sh0xSSKJrJrJr SSKrSSKJr SSKJs Jr SSK J r J r SSK Jr SSKJrJrJr /SQrS\S \\\\44S jrS\S \\S 44S jrS\S \\S 44S jrS\S \\\\\444SjrS\S \\\R R<\\R R<44SjrS\S \\\\R@\444Sjr!S\S \\\\R R<44Sjr"S\S \\\44Sjr#S\S \\\44Sjr$S \4Sjr%S \4Sjr&S \4Sjr'S\S \4Sjr(S\S \4Sjr)g))AnyCallableUnionN) _reverse2 _reverse3)Pattern) BackendConfigBackendPatternConfig DTypeConfig) get_pattern_to_dtype_configsget_qat_module_classesget_fused_module_classes"get_pattern_to_input_type_to_index-get_root_module_to_quantized_reference_moduleget_fuser_method_mappingget_module_to_qat_module&get_fusion_pattern_to_root_node_getter)get_fusion_pattern_to_extra_inputs_getter!remove_boolean_dispatch_from_namepattern_to_human_readableentry_to_pretty_strbackend_configreturncl0nURR5Hup#URX'M U$N)!_pattern_complex_format_to_configitems dtype_configs)rpattern_to_dtype_configspatternconfigs ~/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/torch/ao/quantization/backend_config/utils.pyr r s=BD)KKQQS,2,@,@ )T ##.cURVs/sHnURcMURPM nn[[U55$s snfr)configs qat_moduletupleset)rr"qat_module_classess r#rr&sS%,,,F    , '( ))  A A cURVs/sHnURcMURPM nn[[U55$s snfr)r& fused_moduler(r))rr"fused_module_classess r#rr/sS%,,,F    , )* ++ r+cl0nURR5Hup#URX'M U$r)rr_input_type_to_index)rpattern_to_input_type_to_indexr!r"s r#rr8s=EG")KKQQS282M2M&/T ))r$c0nURH9nURcMURcM!URXR'M; U$r)r& root_modulereference_quantized_module)rmappingr"s r#rrAsNCEG ((    *11=*0*K*KG&& ' ) Nr$c0nURR5H#up#URcM[U5nXAU'M% U$r)rr fuser_method1_get_fuser_method_in_reversed_nested_tuple_format)rfuser_method_mappingr!r"r7s r#rrNsQKM)KKQQS    *MVTL,8 ) T r$c0nURR5H"up#URcMURX'M$ U$r)rrr')rmodule_to_qat_moduler!r"s r#rr\sKBD)KKQQS    (,2,=,= )T r$c0nURR5H"up#URcMURX'M$ U$)aGet a map from fusion pattern to a function that returns the root node from the fusion pattern, e.g. the most common one is: def get_root_node(node_pattern): while not isinstance(node_pattern[-1], Node): node_pattern = node_pattern[-1] return node_pattern[-1] This can work for all patterns whose root node is the "last node" in the pattern, e.g. (torch.add, MatchAllNode, (torch.ReLU, torch.Conv2d)) )rr_root_node_getter)rroot_node_getter_mappingr!r"s r#rrfsI9;)KKQQS  # # /060H0H $ -T $#r$c0nURR5H"up#URcMURX'M$ U$)aGet a map from fusion pattern to a function that returns extra input nodes from the fusion pattern, in the order required by the root node. This is optional, if not specified, we will not copy over any extra inputs for the root node. Example: # Let's say we have the pattern (torch.add, MatchAllNode, (torch.nn.BatchNorm2d, torch.nn.Conv2d)) # and root node is torch.nn.Conv2d, and the node in MatchAllNode would be an extra # argument to the fused module, we can unpack the pattern and return the node at # MatchAllNode here # we can implement extra_inputs_getter as follows: def extra_inputs_getter(pattern) -> List[Any]: add, extra_input, conv_pattern = pattern return [extra_input] )rr_extra_inputs_getter)rextra_inputs_getter_mappingr!r"s r#rrysI <>)KKQQS  & & 2393N3N ' 0T '&r$c~U[RLagU[RLagU[RLagU[RLagU[R LagU[R LagU[RLagU[RLagS [U5;d US 3S -5eU$) z Some ops have a default string representation such as '.fn at 0x7ff1106bf280>', this function replaces them with the hardcoded function names. z)torch.nn.functional.fractional_max_pool2dz)torch.nn.functional.fractional_max_pool3dztorch.nn.functional.max_pool1dztorch.nn.functional.max_pool2dztorch.nn.functional.max_pool3dz'torch.nn.functional.adaptive_max_pool1dz'torch.nn.functional.adaptive_max_pool2dz'torch.nn.functional.adaptive_max_pool3dboolean_dispatchz2 does not have a human readable representation in zquantization documentation) Ffractional_max_pool2dfractional_max_pool3d max_pool1d max_pool2d max_pool3dadaptive_max_pool1dadaptive_max_pool2dadaptive_max_pool3dstrps r#rrs  A # ##: a%% %: all / all / all / a## #8 a## #8 a## #8 SV + # ?@ & ' + Hr$c[U[5(a[SU55$[U[5(aU$[U5nU$)Nc38# UHn[U5v M g7fr)r).0inner_ps r# ,pattern_to_human_readable..sIqG.w77qs) isinstancer(rMrrNs r#rrsA!UIqIII As   -a 0r$cSnSU;a[US5nUSUS3- nSU;aEUS- nUSH2nUS- nUR5HupEUSUS US3- nM US - nM4 US - nS U;a2US - nUS R5HupEUSUSUS3- nM US- n/SQnUHnXv;aM USUS XS3- nM US- nU$)zc Given a backend_config_dict entry, returns a string with the human readable representation of it. z{ r!z 'pattern': z, rz 'dtype_configs': [ z { z 'z': z }, z ], #num_tensor_args_to_observation_typez+ 'num_tensor_args_to_observation_type': { z z: z }, )r!rrXz '})rr)entrys pattern_str dtype_configkvcustom_handled_fields field_names r#rrsA AE/i0@A  }[M --% %%!/2L NA$**,wqcQCs++- OA 3 X -5 ;;?@FFHDA 4s"QCs# #AI X    .  s:,c%"3!4C 88 HA Hr$r"cURb UR$URc [S5e[UR[5(d UR$[ UR5S:XaURupX!4$[ UR5S:XaURupnX2U44$[SUR5e)a4 Return the pattern specified in the given config in the reversed nested tuple format used internally in the quantization pattern matching code. If the pattern is not a tuple, or the pattern is already specified in the reversed nested tuple format, return the pattern as is. Otherwise: For 2-tuples (a, b), return (b, a). For 3-tuples (a, b, c), return (c, (b, a)). For example: * Given nn.Linear, return nn.Linear * Given (nn.Linear, nn.ReLU), return (nn.ReLU, nn.Linear) * Given (nn.Conv2d, nn.BatchNorm2d, nn.ReLU), return (nn.ReLU, (nn.BatchNorm2d, nn.Conv2d)) For context, the reason why this is needed is the user-facing BackendConfig API accepts the flat 2-or-3-tuple format in forward order. While this simple format handles the vast majority of use cases, it does not handle the more complex ones, and so the internal pattern matching code for quantization uses the following, more general reversed nested tuple format instead: operator = module_type | functional | torch op | native op | MatchAllNode Pattern = (operator, Pattern, Pattern, ...) | operator In the future, we expect to replace the above complex format with the one used by the subgraph rewriter in torch.fx, so we don't have to maintain our own complex pattern matching code. Then we won't need this helper function anymore. z>Either 'pattern' or 'pattern_complex_format' must be specified,Expected a tuple with 2 or 3 elements, got: )_pattern_complex_formatr! ValueErrorrVr(len)r"abcs r#,_get_pattern_in_reversed_nested_tuple_formatrls@%%1--- ~~ L   fnne , ,~~ 6>>av V^^  !NN qq6{GXXr$cURceURb UR$[UR[5(d[ SUR5e[ UR5S:Xa[UR5$[ UR5S:Xa[UR5$[ SUR5e)a Return the fuser method specified in the given config in the reversed nested tuple format used internally in the quantization pattern matching code. If pattern is specified in the reversed nested tuple format, we assume the fuser method is also specified in this format and simply return it as is. Otherwise, we convert the fuser method as follows: * Given f(is_qat, conv, relu), return f'(is_qat, relu, conv) * Given f(is_qat, conv, bn, relu), return f'(is_qat, relu, bn_conv), where bn_conv is a 2-tuple (bn, conv) The first argument of a fuser method is always `is_qat` and is not affected in the conversion. We currently only support functions with 3 or 4 arguments. z%Expected pattern to be a tuple, got: rcrdre) r7rfrVr!r(rgrhrr)r"s r#r8r8s$    ** * %%1""" fnne , ,@&..QQ 6>>a,,-- V^^  !,,--GXXr$)*typingrrrtorchtorch.nnnntorch.nn.functional functionalrD+torch.ao.quantization.fuser_method_mappingsrrtorch.ao.quantization.utilsrrr r r __all__dictlistr r(typerrrMintrModuler Sequentialrrrrrrrrlr8r$r#r~s'' L/LL  $!$ '4 $ $%$*=*U49=M*,],uT3Y?O,*!* '4S> !"* !  $uxx ehhoo!6 67   !   '501 12   !  '4( () $!$ '8 $&'!' '8 '. C : C * #* Z1Y 1Y 1YhY Y Yr$