U yhP@sddlmZddlmZddlmZmZmZmZm Z m Z ddl m Z ddl mZddlmZmZmZddd d gZd Zd Zd ZdZdZdZdZdZdZeGdd d ZGdd d ZGdddZGdddZ dS)) annotations) dataclass)AnyDictListOptionalTupleType)QConfigMapping) BackendConfig) QuantType_quant_type_from_str_get_quant_type_to_strConvertCustomConfigFuseCustomConfigPrepareCustomConfigStandaloneModuleConfigEntryZstandalone_module_nameZstandalone_module_classZ%float_to_observed_custom_module_classZ)observed_to_quantized_custom_module_classZnon_traceable_module_nameZnon_traceable_module_classZinput_quantized_idxsZoutput_quantized_idxspreserved_attributesc@s.eZdZUded<ded<ded<ded<d S) rOptional[QConfigMapping]qconfig_mappingTuple[Any, ...]example_inputsOptional[PrepareCustomConfig]prepare_custom_configOptional[BackendConfig]backend_configN)__name__ __module__ __qualname____annotations__r r X/var/www/html/venv/lib/python3.8/site-packages/torch/ao/quantization/fx/custom_config.pyrs c@seZdZdZddZddZdddd d dd d d Zdddd d ddddZej fdddddddZ dddddZ dddddZ dddd d!Z dddd"d#Zddd$d%d&Zed'dd(d)d*Zd'd+d,d-Zd.S)/ra Custom configuration for :func:`~torch.ao.quantization.quantize_fx.prepare_fx` and :func:`~torch.ao.quantization.quantize_fx.prepare_qat_fx`. Example usage:: prepare_custom_config = PrepareCustomConfig() .set_standalone_module_name("module1", qconfig_mapping, example_inputs, child_prepare_custom_config, backend_config) .set_standalone_module_class(MyStandaloneModule, qconfig_mapping, example_inputs, child_prepare_custom_config, backend_config) .set_float_to_observed_mapping(FloatCustomModule, ObservedCustomModule) .set_non_traceable_module_names(["module2", "module3"]) .set_non_traceable_module_classes([NonTraceableModule1, NonTraceableModule2]) .set_input_quantized_indexes([0]) .set_output_quantized_indexes([0]) .set_preserved_attributes(["attr1", "attr2"]) cCs4i|_i|_i|_g|_g|_g|_g|_g|_dSN)standalone_module_namesstandalone_module_classesfloat_to_observed_mappingnon_traceable_module_namesnon_traceable_module_classesinput_quantized_indexesoutput_quantized_indexesrselfr r r!__init__<szPrepareCustomConfig.__init__cCs dd|jD}d|dS)NcSs"i|]\}}t|dkr||qSrlen.0kvr r r! Gs z0PrepareCustomConfig.__repr__..zPrepareCustomConfig()__dict__itemsr+Z dict_nonemptyr r r!__repr__FszPrepareCustomConfig.__repr__strrrrr) module_namerrrrreturncCst|||||j|<|S)a| Set the configuration for running a standalone module identified by ``module_name``. If ``qconfig_mapping`` is None, the parent ``qconfig_mapping`` will be used instead. If ``prepare_custom_config`` is None, an empty ``PrepareCustomConfig`` will be used. If ``backend_config`` is None, the parent ``backend_config`` will be used instead. )rr#)r+r<rrrrr r r!set_standalone_module_nameMs z.PrepareCustomConfig.set_standalone_module_namer ) module_classrrrrr=cCst|||||j|<|S)a} Set the configuration for running a standalone module identified by ``module_class``. If ``qconfig_mapping`` is None, the parent ``qconfig_mapping`` will be used instead. If ``prepare_custom_config`` is None, an empty ``PrepareCustomConfig`` will be used. If ``backend_config`` is None, the parent ``backend_config`` will be used instead. )rr$)r+r?rrrrr r r!set_standalone_module_class_s z/PrepareCustomConfig.set_standalone_module_classr ) float_classobserved_class quant_typer=cCs8|tjkrtd||jkr&i|j|<||j||<|S)a5 Set the mapping from a custom float module class to a custom observed module class. The observed module class must have a ``from_float`` class method that converts the float module class to the observed module class. This is currently only supported for static quantization. zQset_float_to_observed_mapping is currently only supported for static quantization)r STATIC ValueErrorr%)r+rArBrCr r r!set_float_to_observed_mappingqs   z1PrepareCustomConfig.set_float_to_observed_mapping List[str]) module_namesr=cCs ||_|S)zZ Set the modules that are not symbolically traceable, identified by name. )r&)r+rHr r r!set_non_traceable_module_namessz2PrepareCustomConfig.set_non_traceable_module_namesz List[Type])module_classesr=cCs ||_|S)z[ Set the modules that are not symbolically traceable, identified by class. )r')r+rJr r r! set_non_traceable_module_classessz4PrepareCustomConfig.set_non_traceable_module_classesz List[int])indexesr=cCs ||_|S)z Set the indexes of the inputs of the graph that should be quantized. Inputs are otherwise assumed to be in fp32 by default instead. )r(r+rLr r r!set_input_quantized_indexessz/PrepareCustomConfig.set_input_quantized_indexescCs ||_|S)z Set the indexes of the outputs of the graph that should be quantized. Outputs are otherwise assumed to be in fp32 by default instead. )r)rMr r r!set_output_quantized_indexessz0PrepareCustomConfig.set_output_quantized_indexes attributesr=cCs ||_|Sz Set the names of the attributes that will persist in the graph module even if they are not used in the model's ``forward`` method. rr+rQr r r!set_preserved_attributessz,PrepareCustomConfig.set_preserved_attributesDict[str, Any])prepare_custom_config_dictr=cCstdddddd}dddddd }ddd dd d }|}|tgD]>\}}}} } ||t} || t} || t} ||| || | qH|tgD]>\}}}} } ||t} || t} || t} ||| || | q|tiD]0\}}t|}|D]\}}||||qq| |t g| |t g| |tg||tg||tg|S) a Create a ``PrepareCustomConfig`` from a dictionary with the following items: "standalone_module_name": a list of (module_name, qconfig_mapping, example_inputs, child_prepare_custom_config, backend_config) tuples "standalone_module_class" a list of (module_class, qconfig_mapping, example_inputs, child_prepare_custom_config, backend_config) tuples "float_to_observed_custom_module_class": a nested dictionary mapping from quantization mode to an inner mapping from float module classes to observed module classes, e.g. {"static": {FloatCustomModule: ObservedCustomModule}} "non_traceable_module_name": a list of modules names that are not symbolically traceable "non_traceable_module_class": a list of module classes that are not symbolically traceable "input_quantized_idxs": a list of indexes of graph inputs that should be quantized "output_quantized_idxs": a list of indexes of graph outputs that should be quantized "preserved_attributes": a list of attributes that persist even if they are not used in ``forward`` This function is primarily for backward compatibility and may be removed in the future. rr;r)objdict_keyr=cSsHt|ts|dkr|St|tr*t|Std|dt|ddS)zn Convert the given object into a QConfigMapping if possible, else throw an exception. Nz7Expected QConfigMapping in prepare_custom_config_dict[" "], got '') isinstancer r from_dictrEtyperXrYr r r!_get_qconfig_mappings   z;PrepareCustomConfig.from_dict.._get_qconfig_mappingrcSsHt|ts|dkr|St|tr*t|Std|dt|ddS)zs Convert the given object into a PrepareCustomConfig if possible, else throw an exception. Nz._get_prepare_custom_configrcSsHt|ts|dkr|St|tr*t|Std|dt|ddS)zm Convert the given object into a BackendConfig if possible, else throw an exception. Nz6Expected BackendConfig in prepare_custom_config_dict["rZr[)r\r rr]rEr^r_r r r!_get_backend_configs   z:PrepareCustomConfig.from_dict.._get_backend_config)getSTANDALONE_MODULE_NAME_DICT_KEYr> STANDALONE_MODULE_CLASS_DICT_KEYr@FLOAT_TO_OBSERVED_DICT_KEYr8r rFrI"NON_TRACEABLE_MODULE_NAME_DICT_KEYrK#NON_TRACEABLE_MODULE_CLASS_DICT_KEYrN INPUT_QUANTIZED_INDEXES_DICT_KEYrO!OUTPUT_QUANTIZED_INDEXES_DICT_KEYrUPRESERVED_ATTRIBUTES_DICT_KEY)clsrWr`rarbconfr< qconfig_dictrZ_prepare_custom_config_dictZbackend_config_dictrrrr?quant_type_namecustom_module_mappingrCrArBr r r!r]sL           zPrepareCustomConfig.from_dictr=cCs:ddddd}i}|jD],\}}t|kr6g|t<|t|||q|jD],\}}t|krng|t<|t|||qV|jD](\}}t|kri|t<||tt|<qt |j dkr|j |t <t |j dkr|j |t <t |jdkr|j|t<t |jdkr|j|t<t |jdkr6|j|t<|S)z Convert this ``PrepareCustomConfig`` to a dictionary with the items described in :func:`~torch.ao.quantization.fx.custom_config.PrepareCustomConfig.from_dict`. rr)keyecSs:|jr|jnd}|jr$|jnd}|||j||jfSr")rto_dictrrr)rrrsrnrWr r r! _make_tuplesz0PrepareCustomConfig.to_dict.._make_tupler)r#r8rdappendr$rer%rfrr/r&rgr'rhr(rir)rjrrk)r+rudr<Zsm_config_entryr?rCr%r r r!rts2     zPrepareCustomConfig.to_dictN)rrr__doc__r,r:r>r@r rDrFrIrKrNrOrU classmethodr]rtr r r r!r)s  Nc@sleZdZdZddZddZejfdddddd d Zd dd d dZ e dddddZ ddddZ dS)ra; Custom configuration for :func:`~torch.ao.quantization.quantize_fx.convert_fx`. Example usage:: convert_custom_config = ConvertCustomConfig() .set_observed_to_quantized_mapping(ObservedCustomModule, QuantizedCustomModule) .set_preserved_attributes(["attr1", "attr2"]) cCsi|_g|_dSr")observed_to_quantized_mappingrr*r r r!r,(szConvertCustomConfig.__init__cCs dd|jD}d|dS)NcSs"i|]\}}t|dkr||qSr-r.r0r r r!r4-s z0ConvertCustomConfig.__repr__..zConvertCustomConfig(r5r6r9r r r!r:,szConvertCustomConfig.__repr__r r )rBquantized_classrCr=cCs&||jkri|j|<||j||<|S)a Set the mapping from a custom observed module class to a custom quantized module class. The quantized module class must have a ``from_observed`` class method that converts the observed module class to the quantized module class. )rz)r+rBr{rCr r r!!set_observed_to_quantized_mapping3s  z5ConvertCustomConfig.set_observed_to_quantized_mappingrGrPcCs ||_|SrRrSrTr r r!rUCsz,ConvertCustomConfig.set_preserved_attributesrV)convert_custom_config_dictr=cCs^|}|tiD]0\}}t|}|D]\}}||||q.q||tg|S)a Create a ``ConvertCustomConfig`` from a dictionary with the following items: "observed_to_quantized_custom_module_class": a nested dictionary mapping from quantization mode to an inner mapping from observed module classes to quantized module classes, e.g.:: { "static": {FloatCustomModule: ObservedCustomModule}, "dynamic": {FloatCustomModule: ObservedCustomModule}, "weight_only": {FloatCustomModule: ObservedCustomModule} } "preserved_attributes": a list of attributes that persist even if they are not used in ``forward`` This function is primarily for backward compatibility and may be removed in the future. )rcOBSERVED_TO_QUANTIZED_DICT_KEYr8r r|rUrk)rlr}rmrorprCrBr{r r r!r]LszConvertCustomConfig.from_dictrqcCsTi}|jD](\}}t|kr&i|t<||tt|<qt|jdkrP|j|t<|S)z Convert this ``ConvertCustomConfig`` to a dictionary with the items described in :func:`~torch.ao.quantization.fx.custom_config.ConvertCustomConfig.from_dict`. r)rzr8r~rr/rrk)r+rwrCrzr r r!rtds zConvertCustomConfig.to_dictN) rrrrxr,r:r rDr|rUryr]rtr r r r!rs   c@sReZdZdZddZddZddddd Zed dd d d Zd dddZ dS)rz Custom configuration for :func:`~torch.ao.quantization.quantize_fx.fuse_fx`. Example usage:: fuse_custom_config = FuseCustomConfig().set_preserved_attributes(["attr1", "attr2"]) cCs g|_dSr"rSr*r r r!r,|szFuseCustomConfig.__init__cCs dd|jD}d|dS)NcSs"i|]\}}t|dkr||qSr-r.r0r r r!r4s z-FuseCustomConfig.__repr__..zFuseCustomConfig(r5r6r9r r r!r:szFuseCustomConfig.__repr__rGrPcCs ||_|SrRrSrTr r r!rUsz)FuseCustomConfig.set_preserved_attributesrV)fuse_custom_config_dictr=cCs|}||tg|S)a/ Create a ``ConvertCustomConfig`` from a dictionary with the following items: "preserved_attributes": a list of attributes that persist even if they are not used in ``forward`` This function is primarily for backward compatibility and may be removed in the future. )rUrcrk)rlrrmr r r!r]s zFuseCustomConfig.from_dictrqcCs i}t|jdkr|j|t<|S)z Convert this ``FuseCustomConfig`` to a dictionary with the items described in :func:`~torch.ao.quantization.fx.custom_config.ConvertCustomConfig.from_dict`. r)r/rrk)r+rwr r r!rts zFuseCustomConfig.to_dictN) rrrrxr,r:rUryr]rtr r r r!rss  N)! __future__r dataclassesrtypingrrrrrr Ztorch.ao.quantizationr Z$torch.ao.quantization.backend_configr Z torch.ao.quantization.quant_typer r r__all__rdrerfr~rgrhrirjrkrrrrr r r r!s2       uV