mct-nightly 2.2.0.20250121.508__py3-none-any.whl → 2.3.0.20250122.511__py3-none-any.whl

{mct_nightly-2.2.0.20250121.508.dist-info → mct_nightly-2.3.0.20250122.511.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mct-nightly
-Version: 2.2.0.20250121.508
+Version: 2.3.0.20250122.511
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

{mct_nightly-2.2.0.20250121.508.dist-info → mct_nightly-2.3.0.20250122.511.dist-info}/RECORD

@@ -1,14 +1,14 @@
-model_compression_toolkit/__init__.py,sha256=dCI9aFLTLdv_Vw1I21_bjRpvMUL4bsNznfoVB0CKrdk,1557
+model_compression_toolkit/__init__.py,sha256=W-VlbEGVB70K-VEhpBiGAs-C2rkPbSEdZ7j7VtmYi2w,1557
 model_compression_toolkit/constants.py,sha256=i_R6uXBfO1ph_X6DNJych2x59SUojfJbn7dNjs_mZnc,3846
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
-model_compression_toolkit/metadata.py,sha256=7EhKNNw1X_kcFHfrCMW4bUl-KhB2tNbdkBSw91bSCGg,3961
+model_compression_toolkit/metadata.py,sha256=x_Bk4VpzILdsFax6--CZ3X18qUTP28sbF_AhoQW8dNc,4003
 model_compression_toolkit/verify_packages.py,sha256=TlS-K1EP-QsghqWUW7SDPkAJiUf7ryw4tvhFDe6rCUk,1405
 model_compression_toolkit/core/__init__.py,sha256=8a0wUNBKwTdJGDk_Ho6WQAXjGuCqQZG1FUxxJlAV8L8,2096
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=CVTjBaci8F6EP3IKDnRMfxkP-Sv8qY8GpkGt6FyII2U,11376
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=OtL6g2rTC5mfdKrkzm47EPPW-voGGVYMYxpy2_sfu1U,6547
-model_compression_toolkit/core/runner.py,sha256=iFpcF1EFbMfEHIkL2XV7NXey3HnQT6kizB7_S0xwVwI,13624
+model_compression_toolkit/core/runner.py,sha256=T3AMorIqKSIQQAdN9XKrqmFBmdXr6H5tVBn5RDgg8as,13876
 model_compression_toolkit/core/common/__init__.py,sha256=Wh127PbXcETZX_d1PQqZ71ETK3J9XO5A-HpadGUbj6o,1447
 model_compression_toolkit/core/common/base_substitutions.py,sha256=xDFSmVVs_iFSZfajytI0cuQaNRNcwHX3uqOoHgVUvxQ,1666
 model_compression_toolkit/core/common/framework_implementation.py,sha256=IkMydCj6voau7dwkYLYA_Ka_EFUKP3GKQdpYN6b1fgc,22163
@@ -41,9 +41,9 @@ model_compression_toolkit/core/common/graph/graph_searches.py,sha256=2oKuW6L8hP-
 model_compression_toolkit/core/common/graph/virtual_activation_weights_node.py,sha256=3el-A7j1oyoo1_9zq3faQp7IeRsFXFCvnrb3zZFXpU0,9803
 model_compression_toolkit/core/common/graph/memory_graph/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/core/common/graph/memory_graph/bipartite_graph.py,sha256=X6FK3C3y8ixFRPjC_wm3ClloCX8_06SOdA1TRi7o_LA,3800
-model_compression_toolkit/core/common/graph/memory_graph/compute_graph_max_cut.py,sha256=S3m34BY9P8NPx1I4d9G94X1Zk93MobX5SOVmqipwCOE,3458
+model_compression_toolkit/core/common/graph/memory_graph/compute_graph_max_cut.py,sha256=sUGp9GnKBI5NL7Y6d9pCyAL6Nv_3Htf2wInUtCtNMpU,3497
 model_compression_toolkit/core/common/graph/memory_graph/cut.py,sha256=7Dfq4TVJIrnencHLJqjhxYKhY7ooUo_ml33WH2IIAgc,2576
-model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py,sha256=-Gt4MTnQiyljQWtqMmYKtFKvtZBpj5cPH-Mf6n5Iimo,17753
+model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py,sha256=E8xKMUxtEF0GjztUk-3CmMtivPPBcADnZTUaSN24o6A,17816
 model_compression_toolkit/core/common/graph/memory_graph/memory_element.py,sha256=ISD2BvJWj5mB91jrFjG8VQb0oOoLBoita_thCZWzCPI,4238
 model_compression_toolkit/core/common/graph/memory_graph/memory_graph.py,sha256=FCzK4HmX4lWI4qGoGv94wpGv7o6_f5wPBfeBPMerZ18,7752
 model_compression_toolkit/core/common/hessian/__init__.py,sha256=E7LK3K_1AwMCQokanNc1JODMwUKNOKmwXQiGQ7GO10I,1033
@@ -70,11 +70,11 @@ model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_fac
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=fe8R1ZdllwL_YQoHgvzTBjoI3GJo4bEVk89I3zEVr14,32463
 model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=gsigifJ-ykWNafF4t7UMEC_-nd6YPERAk1_z0kT-Y88,27172
 model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,sha256=P8QtKgFXtt5b2RoubzI5OGlCfbEfZsAirjyrkFzK26A,2846
-model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=UWgxzhKWFOoESLq0TFVz0M1PhkU9d9n6wccSA3RgUxk,7903
+model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=8oAFJc_KC3z5ClI-zo4KC40kKGscyixUc5oYP4j4cMo,8019
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py,sha256=T5yVr7lay-6QLuTDBZNI1Ufj02EMBWuY_yHjC8eHx5I,3998
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=eaZX_Sng1uBpqjKUKuWMQO8wUfnjoQJqEoGwPFD3gsw,35051
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=tfcbMppa5KP_brfkFWRiOX9LQVHGXJtlgxyAt9oDGuw,8529
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=qdnkkviZZFYqFuRY7o0US_ihH1Iq-X-eG7OwiTVsRBU,34937
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=J7gqUGs4ITo4ufl84A5vACxm670LG6RhQyXkejfpbn8,8834
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=uhC0az5OVSfeYexcasoy0cT8ZOonFKIedk_1U-ZPLhA,17171
 model_compression_toolkit/core/common/network_editors/__init__.py,sha256=vZmu55bYqiaOQs3AjfwWDXHmuKZcLHt-wm7uR5fPEqg,1307
@@ -105,7 +105,7 @@ model_compression_toolkit/core/common/quantization/core_config.py,sha256=yxCzWql
 model_compression_toolkit/core/common/quantization/debug_config.py,sha256=zJP2W9apUPX9RstpPWWK71wr9xJsg7j-s7lGV4_bQdc,1510
 model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py,sha256=IHVX-Gdekru4xLuDTgcsp_JCnRtuVWnbYsDBQuSXTKc,7079
 model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=HctuRvQsT6Dx9A3lLiLEijghPftM-iABcjmDShlPAn4,26527
-model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=eFU2vSdFl20aaBQ5l_0Ox9KHzyA_Fh_D90tanky59Eo,4607
+model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=UkSVW7d1OF_Px9gAjsqqK65aYhIBFWaBO-_IH6_AFfg,4403
 model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,sha256=HfBkSiRTOf9mNF-TNQHTCCs3xSg66F20no0O6vl5v1Y,2154
 model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py,sha256=7eG7dl1TcbdnHwgmvyjarxLs0o6Lw_9VAjXAm4rsiBk,3791
 model_compression_toolkit/core/common/quantization/quantize_graph_weights.py,sha256=N005MSvx8UypVpa7XrxNrB2G732n2wHj3RmLyjTgd3I,2728
@@ -379,11 +379,11 @@ model_compression_toolkit/gptq/pytorch/gptq_loss.py,sha256=_07Zx_43bnNokwR5S8phI
 model_compression_toolkit/gptq/pytorch/gptq_pytorch_implementation.py,sha256=tECPTavxn8EEwgLaP2zvxdJH6Vg9jC0YOIMJ7857Sdc,1268
 model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=WtehnyiYXdUXf8-uNpV0mdsalF7YF7eKnL7tcFrzZoE,19549
 model_compression_toolkit/gptq/pytorch/graph_info.py,sha256=4mVM-VvnBaA64ACVdOe6wTGHdMSa2UTLIUe7nACLcdo,4008
-model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=Dkanqdv7Eo5lWRoa56aomU5VdH9yqA6zd8I4WE37hxk,16874
+model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=ciBrdTZqTNFw-5RleEAM6o5GJq5zNhym2GmAmf6U0_I,17179
 model_compression_toolkit/gptq/pytorch/quantizer/__init__.py,sha256=ZHNHo1yzye44m9_ht4UUZfTpK01RiVR3Tr74-vtnOGI,968
 model_compression_toolkit/gptq/pytorch/quantizer/base_pytorch_gptq_quantizer.py,sha256=fKg-PNOhGBiL-4eySS9Fyw0GkA76Pq8jT_HbJuJ8iZU,4143
 model_compression_toolkit/gptq/pytorch/quantizer/quant_utils.py,sha256=OocYYRqvl7rZ37QT0hTzfJnWGiNCPskg7cziTlR7TRk,3893
-model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py,sha256=5EyAzvlU01vLyXmMwY_8dNyb7GwYktXmnrvUON8n8WI,4696
+model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py,sha256=dMZ4Aavw8r32CRSh53c5z27_Im7ivKMNyAi9ay7mSKg,4474
 model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
 model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/soft_quantizer_reg.py,sha256=f7B95Bx-MX-HKheqAUn1GG8cVHFI2ldFReXrUPwk2tY,3002
 model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/symmetric_soft_quantizer.py,sha256=xzTK2apHSSO6MDygDyhrlGgwoIyCsiQqgqLDIX93aao,12291
@@ -417,7 +417,7 @@ model_compression_toolkit/qat/keras/quantizer/ste_rounding/__init__.py,sha256=cc
 model_compression_toolkit/qat/keras/quantizer/ste_rounding/symmetric_ste.py,sha256=lXeMPI-n24jbZDGrtOs5eQZ14QvmhFd0e7Y1_QRQxw0,8214
 model_compression_toolkit/qat/keras/quantizer/ste_rounding/uniform_ste.py,sha256=ZdZwMwLa1Ws2eo3DiQYYTvPS1JfiswZL1xlQPtRnIgE,7067
 model_compression_toolkit/qat/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/qat/pytorch/quantization_facade.py,sha256=BvKYsLXyWvE3MXN7khYhBQXVLm-r-C17XpJkEwit7KM,14095
+model_compression_toolkit/qat/pytorch/quantization_facade.py,sha256=M4u2V12y_B_EFoT52iky4J3ebYCkT2cPu7TUKTir0fQ,14082
 model_compression_toolkit/qat/pytorch/quantizer/__init__.py,sha256=xYa4C8pr9cG1f3mQQcBXO_u3IdJN-zl7leZxuXDs86w,1003
 model_compression_toolkit/qat/pytorch/quantizer/base_pytorch_qat_weight_quantizer.py,sha256=gjzrnBAZr5c_OrDpSjxpQYa_jKImv7ll52cng07_2oE,1813
 model_compression_toolkit/qat/pytorch/quantizer/quantization_builder.py,sha256=lM10cGUkkTDtRyLLdWj5Rk0cgvcxp0uaCseyvrnk_Vg,5752
@@ -523,8 +523,8 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=UVN_S9ULHBEldBpShCOt8-soT8YTQ5oE362y96qF_FA,3950
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.2.0.20250121.508.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.2.0.20250121.508.dist-info/METADATA,sha256=GZeKtLsm-8OHe6sy9xG4ckvNwecKMsp2y9x2uEsdpWI,26601
-mct_nightly-2.2.0.20250121.508.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mct_nightly-2.2.0.20250121.508.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.2.0.20250121.508.dist-info/RECORD,,
+mct_nightly-2.3.0.20250122.511.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.3.0.20250122.511.dist-info/METADATA,sha256=XzRqjnA-eL0k76UFKe0lPnpFegLxpNE4EaADNqMNaig,26601
+mct_nightly-2.3.0.20250122.511.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mct_nightly-2.3.0.20250122.511.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250122.511.dist-info/RECORD,,

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.2.0.20250121.000508"
+__version__ = "2.3.0.20250122.000511"

model_compression_toolkit/core/common/graph/memory_graph/compute_graph_max_cut.py

@@ -53,9 +53,10 @@ def compute_graph_max_cut(memory_graph: MemoryGraph,
         try:
             schedule, max_cut_size, cuts = max_cut_astar.solve(estimate=estimate, iter_limit=astar_n_iter,
                                                                time_limit=None if it == 0 else 300)
-        except TimeoutError:
+        except TimeoutError:  # pragma: no cover
+            # TODO: add test for this.
             if last_result[0] is None:
-                Logger.critical(f"Max-cut solver stopped on timeout in iteration {it} before finding a solution.")  # pragma: no cover
+                Logger.critical(f"Max-cut solver stopped on timeout in iteration {it} before finding a solution.")
             else:
                 Logger.warning(f"Max-cut solver stopped on timeout in iteration {it}.")
                 return last_result

model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py

@@ -151,7 +151,8 @@ class MaxCutAstar:
         t1 = time()
         while expansion_count < iter_limit and len(open_list) > 0:
             if time_limit is not None and time() - t1 > time_limit:
-                raise TimeoutError
+                # TODO: add test for this.
+                raise TimeoutError  # pragma: no cover
             # Choose next node to expand
             next_cut = self._get_cut_to_expand(open_list, costs, routes, estimate)
 

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -170,7 +170,6 @@ class ResourceUtilizationCalculator:
             w_total, *_ = self.compute_weights_utilization(target_criterion, bitwidth_mode, w_qcs)
 
         if {RUTarget.ACTIVATION, RUTarget.TOTAL}.intersection(ru_targets):
-            Logger.warning("Using an experimental feature max-cut for activation memory utilization estimation.")
             a_total = self.compute_activations_utilization(target_criterion, bitwidth_mode, act_qcs)
 
         ru = ResourceUtilization()

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py

@@ -104,6 +104,12 @@ def requires_mixed_precision(in_model: Any,
 
     Returns: A boolean indicating if mixed precision is needed.
     """
+    # Any target resource utilization other than weights will always require MP calculation.
+    if target_resource_utilization.activation_restricted() or \
+            target_resource_utilization.total_mem_restricted() or \
+            target_resource_utilization.bops_restricted():
+        return True
+
     core_config = _create_core_config_for_ru(core_config)
 
     transformed_graph = graph_preparation_runner(in_model,

model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py

@@ -68,7 +68,7 @@ def greedy_solution_refinement_procedure(mp_solution: List[int],
             node_candidates = current_node.candidates_quantization_cfg
 
             # only weights kernel attribute is quantized with weights mixed precision
-            kernel_attr = search_manager.fw_info.get_kernel_op_attributes(current_node)
+            kernel_attr = search_manager.fw_info.get_kernel_op_attributes(current_node.type)
             kernel_attr = None if kernel_attr is None else kernel_attr[0]
             valid_candidates = _get_valid_candidates_indices(node_candidates, new_solution[node_idx], kernel_attr)
 
@@ -139,8 +139,9 @@ def _get_valid_candidates_indices(node_candidates: List[CandidateNodeQuantizatio
         activation_num_bits = current_candidate.activation_quantization_cfg.activation_n_bits
 
         # Filter candidates that have higher bit-width for both weights and activations (except for the current index).
+        # TODO: activation bits comparison: should be >= if ACTIVATION or TOTAL ru is used. else should be ==.
         return [i for i, c in enumerate(node_candidates) if
-                c.activation_quantization_cfg.activation_n_bits >= activation_num_bits
+                c.activation_quantization_cfg.activation_n_bits == activation_num_bits
                 and c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits >= weights_num_bits
                 and not (c.activation_quantization_cfg.activation_n_bits == activation_num_bits
                          and c.weights_quantization_cfg.get_attr_config(kernel_attr).weights_n_bits == weights_num_bits)]

model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -78,9 +78,6 @@ class QuantizationConfig:
         >>> qc = mct.core.QuantizationConfig(activation_error_method=mct.core.QuantizationErrorMethod.NOCLIPPING, weights_error_method=mct.core.QuantizationErrorMethod.MSE, relu_bound_to_power_of_2=True, weights_bias_correction=True)
 
 
-        The QuantizationConfig instance can then be used in the quantization workflow,
-        such as with Keras in the function: :func:~model_compression_toolkit.ptq.keras_post_training_quantization`.
-
     """
 
     activation_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE

model_compression_toolkit/core/runner.py

@@ -90,9 +90,11 @@ def core_runner(in_model: Any,
 
     # Checking whether to run mixed precision quantization
     if target_resource_utilization is not None and target_resource_utilization.is_any_restricted():
-        if core_config.mixed_precision_config is None:
+        if core_config.mixed_precision_config is None:  # pragma: no cover
             Logger.critical("Provided an initialized target_resource_utilization, that means that mixed precision quantization is "
                             "enabled, but the provided MixedPrecisionQuantizationConfig is None.")
+        if target_resource_utilization.activation_restricted() or target_resource_utilization.total_mem_restricted():
+            Logger.warning("Using an experimental feature max-cut for activation memory utilization estimation.")
         # Determine whether to use mixed precision or single precision based on target_resource_utilization.
         if requires_mixed_precision(in_model,
                                     target_resource_utilization,

model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -77,6 +77,7 @@ if FOUND_TORCH:
             regularization_factor (float): A floating point number that defines the regularization factor.
             hessian_batch_size (int): Batch size for Hessian computation in Hessian-based weights GPTQ.
             use_hessian_sample_attention (bool): whether to use Sample-Layer Attention score for weighted loss.
+            gradual_activation_quantization (bool, GradualActivationQuantizationConfig): If False, GradualActivationQuantization is disabled. If True, GradualActivationQuantization is enabled with the default settings. GradualActivationQuantizationConfig object can be passed to use non-default settings.
 
         returns:
             a GradientPTQConfig object to use when fine-tuning the quantized model using gptq.

model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py

@@ -16,12 +16,9 @@ from typing import List, Dict, Tuple
 
 from model_compression_toolkit.gptq import GradientPTQConfig
 from model_compression_toolkit.core import common
-from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantizer import \
-    get_activation_inferable_quantizer_kwargs
 from model_compression_toolkit.gptq.pytorch.quantizer.base_pytorch_gptq_quantizer import \
     BasePytorchGPTQTrainableQuantizer
 from mct_quantizers import QuantizationTarget
-from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers.pytorch.quantizers import BasePyTorchInferableQuantizer
 
 from model_compression_toolkit.logger import Logger

model_compression_toolkit/metadata.py

@@ -57,6 +57,7 @@ def get_versions_dict(fqc) -> Dict:
         tpc_minor_version: str = f'{fqc.tpc.tpc_minor_version}'
         tpc_patch_version: str = f'{fqc.tpc.tpc_patch_version}'
         tpc_platform_type: str = f'{fqc.tpc.tpc_platform_type}'
+        tpc_name: str = f'{fqc.tpc.name}'
         tpc_schema: str = f'{fqc.tpc.SCHEMA_VERSION}'
 
     return asdict(TPCVersions(mct_version))

model_compression_toolkit/qat/pytorch/quantization_facade.py

@@ -110,7 +110,6 @@ if FOUND_TORCH:
              User information that may be needed to handle the quantized model.
 
          Examples:
-
              Import MCT:
 
              >>> import model_compression_toolkit as mct
@@ -120,21 +119,19 @@ if FOUND_TORCH:
              >>> from torchvision.models import mobilenet_v2
              >>> model = mobilenet_v2(pretrained=True)
 
-            Create a random dataset generator, for required number of calibration iterations (num_calibration_batches):
-            In this example a random dataset of 10 batches each containing 4 images is used.
+             Create a random dataset generator, for required number of calibration iterations (num_calibration_batches). In this example, a random dataset of 10 batches each containing 4 images is used:
 
-            >>> import numpy as np
-            >>> num_calibration_batches = 10
-            >>> def repr_datagen():
-            >>>     for _ in range(num_calibration_batches):
-            >>>         yield [np.random.random((4, 3, 224, 224))]
+             >>> import numpy as np
+             >>> num_calibration_batches = 10
+             >>> def repr_datagen():
+             >>>     for _ in range(num_calibration_batches):
+             >>>         yield [np.random.random((4, 3, 224, 224))]
 
              Create a MCT core config, containing the quantization configuration:
 
              >>> config = mct.core.CoreConfig()
 
-             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a
-             quantized model. Now the model contains quantizer wrappers for fine tunning the weights:
+             Pass the model, the representative dataset generator, the configuration and the target resource utilization to get a quantized model. Now the model contains quantizer wrappers for fine tunning the weights:
 
              >>> quantized_model, quantization_info = mct.qat.pytorch_quantization_aware_training_init_experimental(model, repr_datagen, core_config=config)
 
@@ -149,8 +146,8 @@ if FOUND_TORCH:
         if core_config.is_mixed_precision_enabled:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config to mixed-precision facade is not of type "
-                             "MixedPrecisionQuantizationConfig. Please use pytorch_post_training_quantization API,"
-                             "or pass a valid mixed precision configuration.")
+                                "MixedPrecisionQuantizationConfig. Please use pytorch_post_training_quantization API,"
+                                "or pass a valid mixed precision configuration.")
 
         tb_w = init_tensorboard_writer(DEFAULT_PYTORCH_INFO)
         fw_impl = PytorchImplementation()