U d@sddlZddlZddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZmZdd lmZmZmZd d lmZmZmZd d lmZdd lmZmZd dlmZm Z d dl!m"Z"m#Z#d dl$m%Z%m&Z&d dl'm(Z(ddl)m*Z*d dl)m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5ddl)m6Z6m7Z7m8Z8m9Z9ddl:m;Z;mZ>ddl?m@Z@d dlAmBZBddlCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMeNeOejPdgZQeeFeRejSjTfePdddZUeeDePddd ZVeeDePdd!d"ZWe eeFeReFeReHeJejXeYfffeFeRejXfePd#d$d%ZZeeFeReFeReHeJejXeYfffeFeRejXfePd&d'd(Z[d)d*Z\eHeeHeeFeReFeReHeJejXeYfffeHeFeReDfePd+d,d-Z]eeFeRejSjTfeFeReDfeeHeFeReDfeIeFeReDfeFeReDfeFeReDffd.d/d0Z^ejSjTeFeEeEfdd1d2d3Z_eeKeRd4d5d6Z`d7d8Zaee ejSjTeFeRejSjTfeed9d:d;ZbeeeNeNeGeNeGeNeHeeFeRejSjTfeFeePfeFeReHeJejXeYffd< d=d>ZceeFeRejSjTfeFeReFeReHeJejXeYfffeHeJejXeYfd?d@dAZdeeeFeRejSjTfeFeReFeReHeJejXeYfffeHeJejXeYfdBdCdDZeeeeFeRejSjTfeFeReFeReJejXeYdfffeJejXeYdfdBdEdFZfeJeeDfe eejSjTeFeRejSjTfeeFeReFeReHeJejXeYfffeHeeFeReDfeHeFeReDfe dG dHdIZgeeejSjTeFeRejSjTfeeFeReFeReHeJejXeYfffeHeeFeReDfeHeFeReDfddJ dKdLZheeDejSjTeFeRejSjTfeeFeReFeReHeJejXeYfffePddMdNdOZieejSjTeFeRejSjTfeeFeRe%feFeReFeReHeJejXeYfffeDeHeePeHedP dQdRZjeeGeNeFeReFeReHeJejXeYfffeFeRefejSjTeFeRejSjTfeddSdTdUZkeeJejXeYfeFeReFeReHeJejXeYfffeFeRe%fddVdWdXZleeFeReFeReHeJejXeYfffeFeRe%fddYdZd[ZmeejSjTeFeRejSjTfePd\d]d^ZneejSjTeFeRejSjTfd_d`daZoeeeFeRejSjTfeFeReDfdbdcddZpeeFeRejSjTfeFeRe%feFeRefeeFeReDfeFeReDfeGeNeGeNeHeFeReDfeKeRePeHede dfdgZqejSjTePeFeRejSjTfeDeFeReDfeHeFeReDfddhdidjZreeFeRefeFeReIeReYffeFeReDfeFeReDfeFeReFeDeDffePeKeRddk dldmZsdreeDePeFeReIeReYffeHeFeReDfeHeFeReDfeHeFeReDfePe"do dpdqZtdS)sN) GraphModule)GraphNode)Argument)propagate_qconfig_) ObserverBase) QConfigAnyis_reuse_input_qconfig)get_flattened_qconfig_dictconvert_dict_to_ordered_dictupdate_qconfig_for_qat)generate_qconfig_mapupdate_qconfig_for_fusionget_standalone_module_configs)QuantizeHandler)Pattern NodePattern)is_equalization_observernode_supports_equalization)ObservedGraphModuleObservedStandaloneGraphModule) MatchResultsorted_patterns_dict) find_matches) _parent_name)get_custom_module_class_keysall_node_args_have_no_tensorsassert_and_get_unique_device(get_non_observable_arg_indexes_and_typesget_new_attr_name_with_prefixNON_QUANTIZABLE_WEIGHT_OPSWEIGHT_INDEX_DICTBIAS_INDEX_DICT)is_activation_post_processconvert)get_qconfig_dtypesget_swapped_custom_module_class"activation_is_statically_quantizedactivation_is_int8_quantized)get_pattern_to_dtype_configs"get_pattern_to_input_type_to_indexget_module_to_qat_module&get_fusion_pattern_to_root_node_getter)get_native_backend_config_dict) get_pattern_to_quantize_handlers)AnyCallableDictListOptionalTupleUnionSet) defaultdict)nodemodulesreturncCs*t|tjjo(|jdko(t|t|jS)N call_module) isinstancetorchfxropr%strtarget)r:r;rDD/tmp/pip-unpacked-wheel-ua33x9lu/torch/ao/quantization/fx/prepare.pyis_activation_post_process_nodefsrF)r:argr<cCs|t|trx|jdkrx|jtkrxt|jD]$\}}||kr(|t|jkr(dSq(|jD]\}}|dkrX||krXdSqXdS)N call_functionTweightF) r>rrArCr# enumerateargskwargsitems)r:rGinode_argZ kwarg_nameZ kwarg_valuerDrDrEnode_arg_is_weightjs rPcCsdt|tr|jdks|jtkr"dSt|jD]$\}}||kr,|t|jkr,dSq,|jdd|kS)NrHFTbias) r>rrArCr$rJrKrLget)r:rGrNrOrDrDrEnode_arg_is_biasvs rS)rGr:node_name_to_target_dtype dtype_configr<c st|ttfr(ttfdd|St|ts6dSt|}t|}| oT| }|rdd}|rdd}j dd} |dkp| |kSdd}|dkpj d |kSnR|rd d} | dkpj d | kSd d} | dkpj d | kSdS) z] Check if the configured qconfig for the argument is supported by the backend or not cst|SN)'is_input_arg_dtype_supported_by_backend)arUr:rTrDrEz9is_input_arg_dtype_supported_by_backend..T is_dynamicFZ input_dtypeNinput_activation_compute_dtypeinput_activation_dtype weight_dtype bias_dtype) r>listtupleallmaprrPrSrRname) rGr:rTrU is_weightis_bias is_activationr\r^Z compute_dtyper_r`rDrYrErWs0          rW)r:rTrUr<cCs&|dd}|dkp$|||jdkS)z[ Check if the configured qconfig for the output is supported by the backend or not output_dtypeNoutput_activation_dtype)rRre)r:rTrUrirDrDrE$is_output_dtype_supported_by_backends rkcCsLt|||}t|jdkrHt|jdtrH|tjkrH|jdjdkrHdSdS)z Check if observer in same graph when the node output is not fp32 and input is 'placeholder' the input is assumed to be quantized, so it is observed in a different place rather than not observed. r placeholderFT)get_arg_target_dtype_as_outputlenrKr>rr?quint8rA)r:r;rTZnode_output_dtyperDrDrEis_observer_in_same_graphs  rp)patternmatched_node_patternrTbackend_config_dictr<c Cs|dks|dkrdS|dk r(t|dks,tt|}||g}t|}|}|d}|D]f} d} |jD]} | ozt| ||| } qf|jD]\} } | ot| ||| } q| ot ||| } | rXdSqXdS)zZ Check is the dtype configuration of a pattern is supported by the backend or not NTrrF) rnAssertionErrorr+rR_default_root_node_getterrKrWrLrMrk) rqrrrTrsZpattern_to_dtype_configsZ dtype_configs root_nodeZ input_nodeZ output_noderU supportedrGkrDrDrE,is_pattern_dtype_config_supported_by_backendsH   ry)r:r;prepare_custom_config_dictparent_qconfigparent_backend_config_dictr<c CsZt|j}t||}t|||\}}} |dkr8d|i}|dkrDi}| dkrP|} ||| fS)z Returns the standalone module qconfig_dict and prepare_config_dict for `node`, assuming that the module pointed to by `node` is a standalone modules. N)rBrCtyper) r:r;rzr{r|standalone_module_nameZstandalone_module_typesm_qconfig_dictsm_prepare_config_dictsm_backend_config_dictrDrDrE%prepare_get_standalone_module_configss   r)rootmodule_to_qat_moduler<cCst||ddddS)NTF)mappingZinplaceZremove_qconfig)r&)rrrDrDrEqat_swap_modulessr)rrscCs>t|tr||jn"t|ttfr:|D]}t||q*dSrV)r>raddrerarbadd_matched_node_name_to_set)rrr maybe_noderDrDrErs  rcCst|ts|d}q|S)N)r>r)Z node_patternrDrDrEru s  ru)r:observermodelr;graphr<c Cs~t|}|r||t|r*|jd}nd}t|}||}t||||||<|||d||fi} W5QRX| S)zp Attaches `observer` to `model`, and creates a node which calls `observer` on the output of `node`. Z_equalization_process_Zactivation_post_process_r=)rtorrer!setattrZinserting_afterZ create_node) r:rrr;rZ model_deviceprefixZget_new_observer_nameZ observer_namenew_obsrDrDrEinsert_observers$     r) r:qconfiginputs_seen_counteroutputs_seen_counterinput_quantized_idxsoutput_quantized_idxsqhandlerr;cache_for_no_tensor_checkr<c CsF|jdkr2||kr tjtjdStjtjdSn|jdkrt|||} | rVdddS|jdkoj|jtjk} | r~tjtjdS|dk r|dk r|rt |\} } } | tj kr| tj krtj ntj}| | | || dStjtjdS|jdkrtjtjdS|jdkr0||kr tjtjdStjtjdSnt d | dS) ay Returns the expected dtype of the input and output of this node after convert. If the value is not None, it represents the dtype of the Tensor. If the value is None, it means the value is not a Tensor. Note: this is for activations only, weight dtypes are not handled here. TODO(future PR, if needed): explicitly spell out the non-Tensor dtypes. rl)r^rj)r= call_methodrHNrH)r^r]r_r`rjZget_attroutputzneed to handle ) rAr?rofloatrrCoperatorgetitemZinput_output_observedr'float16rtZ format_node)r:rrrrrrr;rZargs_have_no_tensors is_getitemZ act_dtyper_Zact_compute_dtyper`rDrDrE$get_target_activation_dtype_for_node-st        r)rGr;rTr<cCsTt|tstt||rB|jd}t|ts4td||jdS||jdSdS)a Get the target output activation dtype for the argumnet in the original graph, skipping inserted observers We are assuming that the observers are inserted correctly, and the dtype for argument in quantized graph will match what is specified by the qconfig rz(Currently we only support observing NoderjN)r>rrtrFrKre)rGr;rTZ observed_argrDrDrErms   rm)rGr:r;rTr<cCstt|tstt||}t||}| o,| }|r@||jdS|rb|jtkrRdS||jdSn||jdSdS)W Get the target argument dtype for the argument `arg`, as input to node `node` r^Nr_r`)r>rrtrPrSrerCr"rGr:r;rTrfrgrhrDrDrE%get_arg_target_dtype_as_input_to_nodes     rcCsVt|tstt||}t||}| o,| }|rNd||jkrN||jdSdSdS)rr]N)r>rrtrPrSrerrDrDrE-get_arg_target_compute_dtype_as_input_to_nodes     r) r:rGrrr;rrTrrzrsr<c # CsHt|ttfrLg} |D](} t|| |||||||| } | | qt|| St|tsZ|St|tsht|} |dk oz|}|dk st|s t ||}t |}|r|j n|j }t |||}t||||}t||||}||kr|tjkr|tkr| p|tjtjtjfko||jdk}nt||||| \}}}|dg}d}t|jD]\}}||krP|}qpqP|dkrd}n6t |||}||krtjntj}||ko|tjk}|j }|rD|}d}|jD]H\}} |jdkr||j}!t|!t|kr|!j|kr|}q q|dkr@t|||||}"|"} n|} | S)zk Given a `node` and an `arg`, inserts an input observer between `node` and `arg` if necessary. NrrFr=) r>rarb,maybe_insert_input_observer_for_arg_or_kwargappendr~rrtis_standalone_modulerPr rI activationrmrrr?rDO_NOT_OBS_DTYPE_LISTroZint8rrKrrRrJusersrMrArCdtyper)#r:rGrrr;rrTrrzrsZnew_arg_to_returnZ inner_argZ new_inner_argnew_argrrfis_reuse_input_qconfig_act_post_process_ctrZarg_as_output_target_dtypeZarg_as_input_target_dtypeZ!arg_as_input_target_compute_dtypeZ needs_obsZ_sm_qconfig_dictrZ_sm_backend_config_dictZsm_input_quantized_idxsZ cur_input_idxZarg_idxZ arg_to_checkZ new_obs_modZexisting_obs_nodeZmaybe_obs_node_Z maybe_obs_modZ new_obs_noderDrDrErs        "           r) r:rrr;rrTrrzrsr<c  Cs|dkr dS|dk stg} |jD](} t|| |||||||| } | | q"i} |jD]*\} }t|||||||||| }|| | <qZt| |_| |_dS)a  If needed, inserts observers to the input args and kwargs of `node`. Note: modifies `node` inplace. For example, if cur_node needs an observer after prev_node, we change from prev_node -> cur_node To prev_node -> obs -> cur_node N)rtrKrrrLrMrb)r:rrr;rrTrrzrsnew_argsrGrZ new_kwargsrxkwargZ new_kwargrDrDrE%maybe_insert_input_observers_for_nodeQsF     r)r:equalization_qconfigrr;rrT is_branchr<c Cs|dkst||sdS|r0td|ddSg}|jD]^}t|trRt||r^||q:t||} | rr|j n|j } | } t || |||} || q:t ||_dS)z If `node` needs to be equalized, find the input/weight observers it needs in `equalization_qconfig`, creates them, and inserts it into `graph`. If `node` does not need an equalization observer, returns None. NzCannot equalize z because it is part of a branch.) rwarningswarnrKr>rrSrrPrIZinput_activationrrb) r:rrr;rrTrrrGrfZact_eq_process_ctrZnew_eq_obs_modZnew_eq_obs_noderDrDrE2maybe_insert_input_equalization_observers_for_nodes4      r) r:rr;rmatchesrTmatched_patternris_qatr<c Cs||jd\} } } }} |dkr$dS| dk s0t|jdksBtd|dk oP|} ||jd}|ttjgk}|ozt| }|o| }|r| j }t | r| | ||}|}t |||||}|SdSdS)z If `node` needs an output observer, creates it, inserts it into `graph` and returns it. If `node` does not need an output observer, returns None. NNNNNNrz3observer insertion for outputs is handled elsewhererj) rRrertrArrr?rr)rr*Zget_activation_ctrr)r:rr;rrrTrrrrvrrqrrrZshould_insert_observerrrrrDrDrE%maybe_insert_output_observer_for_nodes: r)graph_output_noderrT qconfig_maprr;rr<c s|dgks|gkstd|gkr&dStj}ttjtttttttjt fffttt ftj j tttj j ft tdfdd g}|jD]} || ||||||qt||_dS)z If the output needs to be quantized and there are any nodes in the output which are not already observed, inserts observers for those nodes. rz,unrecognized format of output_quantized_idxsN)r target_dtyperTrrr;rr<c st|tr\t|||}||krV||j}|dk s:td|} t|| |||} | S|Snt|tt frg} |D]} | | ||||||qrt|tr| St | Sn@t|t ri} | D] \}}|||||||| |<q| S| SdS)a` Navigate an arbitrary data structure of lists, tuples, dicts. For each container type, recurse on all inputs. Once any Node is found, insert an observer if needed and do not recurse further. For example, given a structure of {'foo1': [[bar1]], 'foo2': {'foo3': [[[bar3]]]}} we recurse down to bar1 and bar3, observe them if necessary, and if we inserted an observer then replace the original node with its observer. Returns the data structure with all nodes needing observation being replaced by their observers. Nz=Quantizing the output node without a qconfig is not supported) r>rrmrRrertrrrarbrdictrM)rrrTrrr;rthis_node_dtyperZ observer_modZ observer_noderesultsZ inner_nodeZ results_dictrxZinner_v&_recursive_maybe_replace_node_with_obsrDrErsd       zZmaybe_insert_observers_before_graph_output.._recursive_maybe_replace_node_with_obs)rtr?rorrr3rBr5r7r~r nnModulerrKrrb) rrrTrrr;rZoutput_target_dtyperZold_argrDrrE*maybe_insert_observers_before_graph_outputs:  > r)r:rrTrr<c Csj|||jd<|||jd<||jd\}}}}}|dk rf|rf|jd} t| trft| |||dS)a Assigns `target_dtype` to `node`. If `node` is a general tensor shape op (see GeneralTensorShapeOpQuantizeHandler in quantization_patterns.py for more details) also call this function recursively on the first argument, to propagate the dtype to the caller. r^rjrNr)rerRis_general_tensor_value_oprKr>rmaybe_propagate_dtype_for_node) r:rrTrrvrrqrrZ prev_noderDrDrErNs   r)rrTrr<c Cs|jD]}t|}|D]p}|||}|D]Z}|j|}t|tsLt|trVt|} n|g} | D]"} t| tjjj r`t | |||q`q*qqdS)a Currently we assume that inputs to the graph are either `torch.float` or `torch.quint8`, which is not always correct. For ops such as `x.masked_fill(mask, value)`, we know that the dtype of `mask` is a `BoolTensor`. Propagate this information throughout the graph. Note: not all dtypes in the graph will be correct after this pass, but a higher percentage of them will be correct. Hopefully in the future we can replace this with a better way to reason about dtypes of tensors. N) nodesr rKr>rbrar?r@r:rr) rrTrr:Znon_observable_arg_dictZarg_typeZnon_observable_indicesindexrGarg_listZcur_argrDrDrE propagate_dtypes_for_known_nodeses"    r)r:rr;r<cCs d}tt|jD](}t|j|tttfr|j|}qd}t| |st| jdkrzdS| jd} |d7}|dkrXt dqXt | j \} } t|| | | q>|jD]8\}}t||st t |j \} } t|| | | qdS) a Ensures that we share an observer for all input arguments as well as the output argument. In detail, given a graph of x0 -> obs0 -> op -> x2 / x1 -> obs1 / where node obs0 points to observer instance observer0, obs1 points to observer1 and obs2 points to observer2, we make nodes obs1 and ob2 point to observer0. Returns: whether the operation succeeded or not NFrrlri'z(Unable to find observer of previous nodeT)rangernrKr>rrarbrFrArtrCrBrJrrrrM)r:rr;Z first_argrNZ first_arg_argZiteration_guardZtrace_back_nodeZ target_to_useZobs_mod_to_useZ input_idxZ input_arg parent_namereoutput_obs_noderrDrDrE'maybe_make_input_output_share_observerssh              r)r:rr;cCsDt|j}|D],\}}t||s(t|||j|qdSrV)rarrMrFrtZreplace_all_uses_withrZ erase_node)r:rr;rMrrrDrDrEremove_output_observers   r)r:rr;rzc CsN||j}|di}t|||}||}t|j\}} t||| |dS)N%float_to_observed_custom_module_class)rCrRr( from_floatrr) r:rr;rzZ custom_moduleZcustom_module_class_mappingZobserved_custom_module_classZobserved_custom_modulerrerDrDrEswap_custom_module_to_observeds r) rr;rrrrzequalization_config_maprrrsobserved_node_namesrr<c + Cstt} t} d}d}t|jdd}|jjD]^}||jd\}}}}}t||||||||| | |j<|jdkrz|d7}|jdkr.|d7}q.t |j| |t |jj}d}d}d}|D]}|jdkr̐n|jd kr`||jd\}}}}}||jd}| |j}|dk}|jd ko&|j t j k}|dks>|s>|oH|jdk }t||| | }|s`|r`t|jdd}|jdkrL|dk stt|| d} t|jdkr0t|jdtr0t|jdjdkr0|jdjD]N}!||!jddk p|!jd kot|t|!j t}"|!|kr|"rd } qt|}||k}#|#rrt|||||| ||| t|||||| | ||k}$|dk o|}%t|}&|$r`t|||||| ||| }'|'dk r`t |j}(|(D] })|)|'krq|)||'qt ||| }*|%r|*s|&r(t!|||s(t"||||dk r`|#r`t$||||nt%||| |||||jdkrv|d7}q|jdkr|d7}|}q|S) a$ Inserts observers, using the following high level algorithm: For each node in the graph: 1. determine the target dtype of this node in the quantized graph, and save it for future steps 2. determine the target dtype or all args and kwargs of this node 3. if any arg or kwarg's target dtype does not match the current node's dtype, insert an observer 4. if the current node needs an output observer, insert it For example: - starting graph: x0 -> linear -> x1 - observed graph after processing x0: x0(fp32) - observed graph after processing linear: x0(fp32) -> x0_obs0(int8) -> linear(int8) -> linear_obs0(int8) - observed graph after processing x1: x0(fp32) -> x0_obs0(int8) -> linear(int8) -> linear_obs0(int8) -> x1 After a node is processed, the naive observer placement is guaranteed to be complete for that node and all of its predecessors. There can be future passes which optimize the graph by deduplicating observers, etc. rFZremove_duplicaterrlrrN)r=rrHrrHr=T)&r9r named_modulesrrrRrerrArrarCrrryrtrrnrKr>rrrBrrurrrr rkeysZreplace_input_withrprrZis_custom_modulerr)+rr;rrrrzrrrrsrrrTrrrr:rvrrqrrZnodes_before_observationZ results_nodeZ last_noderrrrZoutput_not_a_tensorrZskip_inserting_observersZis_supported_by_backendZis_quantized_branchuserZis_user_quantizedZis_input_node_of_the_patternZis_last_node_of_patternrrZmaybe_output_obs_nodeZ orig_usersZ user_nodeZis_observer_in_same_graph_rDrDrEinsert_observers_for_models&B                          r)rrr;rrzrsr<cCs|D]\}\}}} } } | dkr&qn | s0qt|||| |\} } }||j}tjjjj}||| || |d}t | dg}t ||j |}t |j\}}t|||||||j<qdS)z Runs prepare_fx on each standalone module. Note: this does not modify the graph, it just replaces the unobserved modules with their observed versions. N)rspreserved_attributes)rMrrrCr?ZaoZ quantizationZ quantize_fxZ_prepare_standalone_module_fxsetrRrrrr)rrr;rrzrsZ node_namervrrqrrrrrZstandalone_moduleprepareZobserved_standalone_modulerrrerDrDrE$run_prepare_fx_on_standalone_modulessN    r) observedrnode_name_to_scoperzequalization_qconfig_map qconfig_dictrrr<cCs.||_||_||_||_||_||_||_dSrV)Z _qconfig_mapZ_prepare_custom_config_dictZ_node_name_to_scopeZ_equalization_qconfig_mapZ _qconfig_dictZ_is_qatZ_observed_node_names)rrrrzrrrrrDrDrE save_state0s rF) rrrrrzequalization_qconfig_dictrsrr<c! Csz|dkr i}|dkri}i}|dkr*t}t|}t|}t|} | D]t\} } | D]b\} } ttid}| |kstd|d| || }| |kr||  | qZ| g|| <qZqJt |}t |t |t ||}t ||}t |}t||||r"t|}t||t|i}t|jdd}t|||j||}t|||j||}|dg}|dg}d d |D}d d |D}t|d }t|j|||||||}|d g}|dg}t||||||t}t|||||j||||||| }t||||||||t|dg} t||j| }|rv|dk sDtt|jdt s^tdt!"||_#t!"||_$|S)aQ standalone_module means it a submodule that is not inlined in parent module, and will be quantized separately as one unit. How the standalone module is observed is specified by `input_quantized_idxs` and `output_quantized_idxs` in the prepare_custom_config for the standalone module Args: node_name_to_scope: mapping from node name to the scope of the module which contains the node. The scope is a tuple of fully qualified path of the module and the type of the module Returns: model(GraphModule): prepared standalone module attributes: _standalone_module_input_quantized_idxs(List[Int]): a list of indexes for the graph input that is expected to be quantized, same as input_quantized_idxs configuration provided for the standalone module _standalone_module_output_quantized_idxs(List[Int]): a list of indexs for the graph output that is quantized same as input_quantized_idxs configuration provided for the standalone module N)rIrQinputzinput type must be one of z but got: FrrZstandalone_module_classcSsg|] }|dqSrrD.0configrDrDrE szprepare..cSsg|] }|dqSrrDrrDrDrErsrrrrrzVstandalone module only supports returning simple value currently(not tuple, dict etc.))%r/r0rr,rMr#r$rrtrr.r rr rr-rr rrrrrRrrrrrrrr>rKrr?ZtensorZ'_standalone_module_input_quantized_idxsZ(_standalone_module_output_quantized_idxs)!rrrrrzrrsrpatternsZpattern_to_input_type_to_indexrqZinput_type_to_indexZ input_typerZ index_dictsZ index_dictZroot_node_getter_mappingZflattened_qconfig_dictrr;rrZstandalone_module_name_configsZstandalone_module_class_configsZstandalone_module_namesZstandalone_module_classesZcustom_module_classesrrrrZ result_noderrDrDrErCs        r)NNNF)ur?rrZtorch.fxrZtorch.fx.graphrrZ torch.fx.noderquantizerrrrr r Zqconfig_dict_utilsr r r Z qconfig_utilsrrrZquantization_patternsrZ(torch.ao.quantization.quantization_typesrrZ _equalizerrZ graph_modulerrZ pattern_utilsrrZ match_utilsrutilsrrrrr r!r"r#r$Ztorch.ao.quantization.quantizer%r&r'r(r)r*Zbackend_config.utilsr+r,r-r.Zbackend_configr/Zbackend_config_utilsr0typingr1r2r3r4r5r6r7r8 collectionsr9intrboolrrBrrrFrPrSrr~rWrkrpryrrrrurrrmrrrrrrrrrrrrrrrrrDrDrDrEs       (   (      %      ' $      b             8  -   6   f       & ^         /