mct-nightly 2.2.0.20240911.455__py3-none-any.whl → 2.2.0.20240912.453__py3-none-any.whl

{mct_nightly-2.2.0.20240911.455.dist-info → mct_nightly-2.2.0.20240912.453.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.2.0.20240911.455
+Version: 2.2.0.20240912.453
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct_nightly-2.2.0.20240911.455.dist-info → mct_nightly-2.2.0.20240912.453.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=td8mVc5zVMOS9tP4ad7FK5FNTuAiS3FlWtKKtdaQKik,1573
+model_compression_toolkit/__init__.py,sha256=MQHqvnJpE47tpv4ydHmi75LJ0XLa-WSNrWwOeRTKlwQ,1573
 model_compression_toolkit/constants.py,sha256=i4wYheBkIdQmsQA-axIpcT3YiSO1USNc-jaNiNE8w6E,3920
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
@@ -8,7 +8,7 @@ model_compression_toolkit/core/__init__.py,sha256=tnDtL9KmT0vsOU27SsJ19TKDEbIH-t
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=7-b7Jd5jBVaXOWg5nSqbEyzBtdaGDbCxs8aqMV6GZ6I,11287
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=K9eJ7VbB_rpeyxX4yEnorOmSxFW3DkvofzxS6QI8Hp8,6454
-model_compression_toolkit/core/runner.py,sha256=ryHhW5Qqu7XHVkngLF0uLX8oa4CxNAIF4PoGBeUjoSk,14346
+model_compression_toolkit/core/runner.py,sha256=Wd0cNVMLOPX5cGY5kwz0J64rm87JKd-onJ2k01S9nLo,14362
 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=kSg2f7wS7e2EyvX6y0eKfNTTFvVFVrB8lvldJvcPvN8,20724
@@ -64,7 +64,7 @@ model_compression_toolkit/core/common/mixed_precision/configurable_quant_id.py,s
 model_compression_toolkit/core/common/mixed_precision/configurable_quantizer_utils.py,sha256=7dKMi5S0zQZ16m8NWn1XIuoXsKuZUg64G4-uK8-j1PQ,5177
 model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha256=H8qYkJsk88OszUJo-Zde7vTmWiypLTg9KbbzIZ-hhvM,2812
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py,sha256=klmaMQDeFc3IxRLf6YX4Dw1opFksbLyN10yFHdKAtLo,4875
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py,sha256=rppRZJdSCQGiZsd93QxoUIhj51eETvQbuI5JiC2TUeA,4963
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py,sha256=r1t025_QHshyoop-PZvL7x6UuXaeplCCU3h4VNBhJHo,4309
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=pk8HRoShDhiUprBC4m1AFQv1SacS4hOrj0MRdbq-5gY,7556
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=TTTux4YiOnQqt-2h7Y38959XaDwNZc0eufLMx_yws5U,37578
 model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=QdxFQ0JxsrcSfk5LlUU_3oZpEK7bYwKelGzEHh0mnJY,27558
@@ -102,11 +102,11 @@ model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py,sha256
 model_compression_toolkit/core/common/quantization/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/quantization/bit_width_config.py,sha256=IXHkpI9bH3AbrpC5T5bNYHcojHzeWQrrCpV-xZj5pks,5021
 model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py,sha256=yU-Cr6S4wOSkDk57iH2NVe-WII0whOhLryejkomCOt4,4940
-model_compression_toolkit/core/common/quantization/core_config.py,sha256=f0uSuY9mX-vLX_1s2DemPARQlAXmLPKJKPtCArz3pZI,2670
-model_compression_toolkit/core/common/quantization/debug_config.py,sha256=8G8SpE_4rb8xBp8d6mMq8R_OnXJ_1oxB2g-Lxk9EJCM,1691
+model_compression_toolkit/core/common/quantization/core_config.py,sha256=yxCzWqldcHoe8GGxrH0tp99bhrc5jDT7SgZftnMUUBE,2374
+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=fwF4VILaX-u3ZaFd81xjbJuhg8Ef-JX_KfMXW0TPV-I,7136
 model_compression_toolkit/core/common/quantization/node_quantization_config.py,sha256=YycYN8_JMzvSR3pTVm5dT5x4zP3yBHn0Z9agnwrvOKI,26395
-model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=7dDs9pq9dM9ADVeIi7wyMpW9ZbAI9GLujgxt7nxvnng,7105
+model_compression_toolkit/core/common/quantization/quantization_config.py,sha256=BTDa1Izpdd4Z4essxTWP42V87f8mdq9vdKdVhE8vibo,3818
 model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,sha256=eyosbVdnCwed7oMQ19tqnh0VoyGZ_UAuD_UnNoXyBpo,2210
 model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py,sha256=MwIOBZ4BlZSTIOG75PDvlI3JmZ6t8YjPc1VP9Adei60,3847
 model_compression_toolkit/core/common/quantization/quantize_graph_weights.py,sha256=N005MSvx8UypVpa7XrxNrB2G732n2wHj3RmLyjTgd3I,2728
@@ -142,7 +142,7 @@ model_compression_toolkit/core/common/substitutions/linear_collapsing_substituti
 model_compression_toolkit/core/common/substitutions/remove_identity.py,sha256=TKU1TIU52UIkVnl0EZvWnDhLV9nIVZ4hqi-w1i4NXMk,2637
 model_compression_toolkit/core/common/substitutions/residual_collapsing.py,sha256=N82mso5j3EJQlKt9EMHjjEJ67FmdGQeCfN8U5grOFXo,4830
 model_compression_toolkit/core/common/substitutions/scale_equalization.py,sha256=p57u25qdW2pimxzGwgMXEBV4S-LzXuTVAlIM7830WfU,10966
-model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=AqQ0cTMz0d1qziQD5uUeYJON0wfXKvRIADuonF8Hobs,29969
+model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=9Wq-nZahcmKkZmoo9Pqgb_v_6Rd0z_8HlVjbEbKvl8M,29977
 model_compression_toolkit/core/common/substitutions/softmax_shift.py,sha256=R-0ZqhYAuZLEFWHvB2UTPm52L6gWHGdRdEnwGxKSeGI,2625
 model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py,sha256=aXzUOJfgKPfQpEGfiIun26fgfCqazBG1mBpzoc4Ezxs,3477
 model_compression_toolkit/core/common/substitutions/weights_activation_split.py,sha256=h85L2VlDOqbLd-N98wA3SdYWiblBgSsPceNuLanJd70,4737
@@ -354,7 +354,7 @@ model_compression_toolkit/gptq/keras/gptq_keras_implementation.py,sha256=axBwnCS
 model_compression_toolkit/gptq/keras/gptq_loss.py,sha256=rbRkF15MYd6nq4G49kcjb_dPTa-XNq9cTkrb93mXawo,6241
 model_compression_toolkit/gptq/keras/gptq_training.py,sha256=NXTNsVrO9DTh0uvc8V7rFaM0fYg2OA18ZrYd-cKZ7Z4,19159
 model_compression_toolkit/gptq/keras/graph_info.py,sha256=MKIfrRTRH3zCuxCR1g9ZVIFyuSSr0e0sDybqh4LDM7E,4672
-model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=t4Jxtu8qyGbIftI5l2sb79Ydd85XM6GyDpkCqiotVF8,15711
+model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=iSHnMEdoIqHYqLCTsdK8uxhKbZuuaDOu_BeQ10Z492U,15715
 model_compression_toolkit/gptq/keras/quantizer/__init__.py,sha256=-DK1CDXvlsnEbki4lukZLpl6Xrbo91_jcqxXlG5Eg6Q,963
 model_compression_toolkit/gptq/keras/quantizer/base_keras_gptq_quantizer.py,sha256=Rbl9urzkmACvVxICSEyJ02qFOBxWK0UQWtysFJzBVZw,4899
 model_compression_toolkit/gptq/keras/quantizer/quant_utils.py,sha256=Vt7Qb8i4JsE4sFtcjpfM4FTXTtfV1t6SwfoNH8a_Iaw,5055
@@ -371,7 +371,7 @@ model_compression_toolkit/gptq/pytorch/gptq_loss.py,sha256=kDuWw-6zh17wZpYWh4Xa9
 model_compression_toolkit/gptq/pytorch/gptq_pytorch_implementation.py,sha256=tECPTavxn8EEwgLaP2zvxdJH6Vg9jC0YOIMJ7857Sdc,1268
 model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=-daninmlPGfKsBNPB2C3gT6rK0G5YeyJsuOLA0JlfBU,16633
 model_compression_toolkit/gptq/pytorch/graph_info.py,sha256=4mVM-VvnBaA64ACVdOe6wTGHdMSa2UTLIUe7nACLcdo,4008
-model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=TMus5LYJnTngLKot7coVax8gsIzPDYVU9m6orFPvWSY,13949
+model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=lw9pOV5SKOw9kqOsfskuUiSH_UGOPRczTMpyzN_WTjY,13953
 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
@@ -391,14 +391,14 @@ model_compression_toolkit/pruning/pytorch/pruning_facade.py,sha256=oStXze__7XCm0
 model_compression_toolkit/ptq/__init__.py,sha256=Z_hkmTh7aLFei1DJKV0oNVUbrv_Q_0CTw-qD85Xf8UM,904
 model_compression_toolkit/ptq/runner.py,sha256=_c1dSjlPPpsx59Vbg1buhG9bZq__OORz1VlPkwjJzoc,2552
 model_compression_toolkit/ptq/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/ptq/keras/quantization_facade.py,sha256=DAAJPd6pKLgiwoJT-_u2dvVOO4Ox6IgJgfiUbnNRBwQ,10968
+model_compression_toolkit/ptq/keras/quantization_facade.py,sha256=7_xoCYzA5TKwJSqMf8GlxlZHOmpAwNdmkfudwJsTIiI,10972
 model_compression_toolkit/ptq/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/ptq/pytorch/quantization_facade.py,sha256=xHVTrm9Fyk_j4j8G1Pb97qacN_gn9cGYpsT1HXdTc1A,9305
+model_compression_toolkit/ptq/pytorch/quantization_facade.py,sha256=ynOZ30heMp1bSTCYS6vn3EmmycDJn4G72IYZlzkRFPA,9309
 model_compression_toolkit/qat/__init__.py,sha256=b2mURFGsvaZz_CdAD_w2I4Cdu8ZDN-2iGHMBHTKT5ws,1128
 model_compression_toolkit/qat/common/__init__.py,sha256=6tLZ4R4pYP6QVztLVQC_jik2nES3l4uhML0qUxZrezk,829
 model_compression_toolkit/qat/common/qat_config.py,sha256=xtfVSoyELGXynHNrw86dB9FU3Inu0zwehc3wLrh7JvY,2918
 model_compression_toolkit/qat/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/qat/keras/quantization_facade.py,sha256=VaZTqK53TOWrXebnJzoHHD99DxOgS4NzHGbmYWaajWA,17274
+model_compression_toolkit/qat/keras/quantization_facade.py,sha256=LNM2HW4cNei3tUhwLdNtsWrox_uSAhaswFxWiMEIrPM,17278
 model_compression_toolkit/qat/keras/quantizer/__init__.py,sha256=zmYyCa25_KLCSUCGUDRslh3RCIjcRMxc_oXa54Aui-4,996
 model_compression_toolkit/qat/keras/quantizer/base_keras_qat_quantizer.py,sha256=hoY3AETaLSRP7YfecZ32tyUUj-X_DHRWkV8nALYeRlY,2202
 model_compression_toolkit/qat/keras/quantizer/quant_utils.py,sha256=cBULOgWUodcBO1lHevZggdTevuDYI6tQceV86U2x6DA,2543
@@ -410,7 +410,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=fPAC49mBlB5ViaQT_xHUTC8EvH84OsBX3WAPusqYcM8,13538
 model_compression_toolkit/qat/keras/quantizer/ste_rounding/uniform_ste.py,sha256=6YS0v1qCq5dRqtLKHc2gHaKJWfql84TxtZ7pypaZock,10810
 model_compression_toolkit/qat/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/qat/pytorch/quantization_facade.py,sha256=1eg0jMgFzRLYIFnG9GJnJ8U3W4IOM-4Z27s9Wq-JeOQ,13452
+model_compression_toolkit/qat/pytorch/quantization_facade.py,sha256=NnFy2E_7SR2m8vfh8Q8VrXOXhe7rMScgXnYBtDpsqVs,13456
 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
@@ -536,8 +536,8 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=bOc-hFL3gdoSM1Th_S2N_-9JJSlPGpZCTx_QLJHS6lg,3388
 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.20240911.455.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.2.0.20240911.455.dist-info/METADATA,sha256=okdby2_mBNXyKyLCkF7xT2Ma8QPEhiP1UzWEJPAFbPY,20813
-mct_nightly-2.2.0.20240911.455.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-mct_nightly-2.2.0.20240911.455.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.2.0.20240911.455.dist-info/RECORD,,
+mct_nightly-2.2.0.20240912.453.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.2.0.20240912.453.dist-info/METADATA,sha256=s63h4FLAEjfw0suj6RB6Td_lWn9sGzpmOA4CYE2GkiA,20813
+mct_nightly-2.2.0.20240912.453.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+mct_nightly-2.2.0.20240912.453.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.2.0.20240912.453.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.20240911.000455"
+__version__ = "2.2.0.20240912.000453"

model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py

@@ -13,75 +13,61 @@
 # limitations under the License.
 # ==============================================================================
 
-from typing import List, Callable
-
+from dataclasses import dataclass, field
+from typing import List, Callable, Optional
 from model_compression_toolkit.constants import MP_DEFAULT_NUM_SAMPLES, ACT_HESSIAN_DEFAULT_BATCH_SIZE
 from model_compression_toolkit.core.common.mixed_precision.distance_weighting import MpDistanceWeighting
 
 
+@dataclass
 class MixedPrecisionQuantizationConfig:
-
-    def __init__(self,
-                 compute_distance_fn: Callable = None,
-                 distance_weighting_method: MpDistanceWeighting = MpDistanceWeighting.AVG,
-                 num_of_images: int = MP_DEFAULT_NUM_SAMPLES,
-                 configuration_overwrite: List[int] = None,
-                 num_interest_points_factor: float = 1.0,
-                 use_hessian_based_scores: bool = False,
-                 norm_scores: bool = True,
-                 refine_mp_solution: bool = True,
-                 metric_normalization_threshold: float = 1e10,
-                 hessian_batch_size: int = ACT_HESSIAN_DEFAULT_BATCH_SIZE):
-        """
-        Class with mixed precision parameters to quantize the input model.
-
-        Args:
-            compute_distance_fn (Callable): Function to compute a distance between two tensors. If None, using pre-defined distance methods based on the layer type for each layer.
-            distance_weighting_method (MpDistanceWeighting): MpDistanceWeighting enum value that provides a function to use when weighting the distances among different layers when computing the sensitivity metric.
-            num_of_images (int): Number of images to use to evaluate the sensitivity of a mixed-precision model comparing to the float model.
-            configuration_overwrite (List[int]): A list of integers that enables overwrite of mixed precision with a predefined one.
-            num_interest_points_factor (float): A multiplication factor between zero and one (represents percentage) to reduce the number of interest points used to calculate the distance metric.
-            use_hessian_based_scores (bool): Whether to use Hessian-based scores for weighted average distance metric computation.
-            norm_scores (bool): Whether to normalize the returned scores for the weighted distance metric (to get values between 0 and 1).
-            refine_mp_solution (bool): Whether to try to improve the final mixed-precision configuration using a greedy algorithm that searches layers to increase their bit-width, or not.
-            metric_normalization_threshold (float): A threshold for checking the mixed precision distance metric values, In case of values larger than this threshold, the metric will be scaled to prevent numerical issues.
-            hessian_batch_size (int): The Hessian computation batch size. used only if using mixed precision with Hessian-based objective.
-
-        """
-
-        self.compute_distance_fn = compute_distance_fn
-        self.distance_weighting_method = distance_weighting_method
-        self.num_of_images = num_of_images
-        self.configuration_overwrite = configuration_overwrite
-        self.refine_mp_solution = refine_mp_solution
-
-        assert 0.0 < num_interest_points_factor <= 1.0, "num_interest_points_factor should represent a percentage of " \
-                                                        "the base set of interest points that are required to be " \
-                                                        "used for mixed-precision metric evaluation, " \
-                                                        "thus, it should be between 0 to 1"
-        self.num_interest_points_factor = num_interest_points_factor
-
-        self.use_hessian_based_scores = use_hessian_based_scores
-        self.norm_scores = norm_scores
-        self.hessian_batch_size = hessian_batch_size
-
-        self.metric_normalization_threshold = metric_normalization_threshold
-
-        self._mixed_precision_enable = False
+    """
+    Class with mixed precision parameters to quantize the input model.
+
+    Args:
+        compute_distance_fn (Callable): Function to compute a distance between two tensors. If None, using pre-defined distance methods based on the layer type for each layer.
+        distance_weighting_method (MpDistanceWeighting): MpDistanceWeighting enum value that provides a function to use when weighting the distances among different layers when computing the sensitivity metric.
+        num_of_images (int): Number of images to use to evaluate the sensitivity of a mixed-precision model comparing to the float model.
+        configuration_overwrite (List[int]): A list of integers that enables overwrite of mixed precision with a predefined one.
+        num_interest_points_factor (float): A multiplication factor between zero and one (represents percentage) to reduce the number of interest points used to calculate the distance metric.
+        use_hessian_based_scores (bool): Whether to use Hessian-based scores for weighted average distance metric computation.
+        norm_scores (bool): Whether to normalize the returned scores for the weighted distance metric (to get values between 0 and 1).
+        refine_mp_solution (bool): Whether to try to improve the final mixed-precision configuration using a greedy algorithm that searches layers to increase their bit-width, or not.
+        metric_normalization_threshold (float): A threshold for checking the mixed precision distance metric values, In case of values larger than this threshold, the metric will be scaled to prevent numerical issues.
+        hessian_batch_size (int): The Hessian computation batch size. used only if using mixed precision with Hessian-based objective.
+    """
+
+    compute_distance_fn: Optional[Callable] = None
+    distance_weighting_method: MpDistanceWeighting = MpDistanceWeighting.AVG
+    num_of_images: int = MP_DEFAULT_NUM_SAMPLES
+    configuration_overwrite: Optional[List[int]] = None
+    num_interest_points_factor: float = field(default=1.0, metadata={"description": "Should be between 0.0 and 1.0"})
+    use_hessian_based_scores: bool = False
+    norm_scores: bool = True
+    refine_mp_solution: bool = True
+    metric_normalization_threshold: float = 1e10
+    hessian_batch_size: int = ACT_HESSIAN_DEFAULT_BATCH_SIZE
+    _is_mixed_precision_enabled: bool = field(init=False, default=False)
+
+    def __post_init__(self):
+        # Validate num_interest_points_factor
+        assert 0.0 < self.num_interest_points_factor <= 1.0, \
+            "num_interest_points_factor should represent a percentage of " \
+            "the base set of interest points that are required to be " \
+            "used for mixed-precision metric evaluation, " \
+            "thus, it should be between 0 to 1"
 
     def set_mixed_precision_enable(self):
         """
         Set a flag in mixed precision config indicating that mixed precision is enabled.
         """
-
-        self._mixed_precision_enable = True
+        self._is_mixed_precision_enabled = True
 
     @property
-    def mixed_precision_enable(self):
+    def is_mixed_precision_enabled(self):
         """
         A property that indicates whether mixed precision quantization is enabled.
 
         Returns: True if mixed precision quantization is enabled
-
         """
-        return self._mixed_precision_enable
+        return self._is_mixed_precision_enabled

model_compression_toolkit/core/common/quantization/core_config.py

@@ -12,41 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from dataclasses import dataclass, field
+from typing import Optional
+
 from model_compression_toolkit.core.common.quantization.bit_width_config import BitWidthConfig
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
 from model_compression_toolkit.core.common.quantization.debug_config import DebugConfig
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig
 
 
+@dataclass
 class CoreConfig:
     """
-    A class to hold the configurations classes of the MCT-core.
-    """
-    def __init__(self,
-                 quantization_config: QuantizationConfig = None,
-                 mixed_precision_config: MixedPrecisionQuantizationConfig = None,
-                 bit_width_config: BitWidthConfig = None,
-                 debug_config: DebugConfig = None
-                 ):
-        """
+    A dataclass to hold the configurations classes of the MCT-core.
 
-        Args:
-            quantization_config (QuantizationConfig): Config for quantization.
-            mixed_precision_config (MixedPrecisionQuantizationConfig): Config for mixed precision quantization.
+    Args:
+        quantization_config (QuantizationConfig): Config for quantization.
+        mixed_precision_config (MixedPrecisionQuantizationConfig): Config for mixed precision quantization.
             If None, a default MixedPrecisionQuantizationConfig is used.
-            bit_width_config (BitWidthConfig): Config for manual bit-width selection.
-            debug_config (DebugConfig): Config for debugging and editing the network quantization process.
-        """
-        self.quantization_config = QuantizationConfig() if quantization_config is None else quantization_config
-        self.bit_width_config = BitWidthConfig() if bit_width_config is None else bit_width_config
-        self.debug_config = DebugConfig() if debug_config is None else debug_config
+        bit_width_config (BitWidthConfig): Config for manual bit-width selection.
+        debug_config (DebugConfig): Config for debugging and editing the network quantization process.
+    """
 
-        if mixed_precision_config is None:
-            self.mixed_precision_config = MixedPrecisionQuantizationConfig()
-        else:
-            self.mixed_precision_config = mixed_precision_config
+    quantization_config: QuantizationConfig = field(default_factory=QuantizationConfig)
+    mixed_precision_config: MixedPrecisionQuantizationConfig = field(default_factory=MixedPrecisionQuantizationConfig)
+    bit_width_config: BitWidthConfig = field(default_factory=BitWidthConfig)
+    debug_config: DebugConfig = field(default_factory=DebugConfig)
 
     @property
-    def mixed_precision_enable(self):
-        return self.mixed_precision_config is not None and self.mixed_precision_config.mixed_precision_enable
+    def is_mixed_precision_enabled(self) -> bool:
+        """
+        A property that indicates whether mixed precision is enabled.
+        """
+        return bool(self.mixed_precision_config and self.mixed_precision_config.is_mixed_precision_enabled)
 

model_compression_toolkit/core/common/quantization/debug_config.py

@@ -13,29 +13,24 @@
 # limitations under the License.
 # ==============================================================================
 
-
+from dataclasses import dataclass, field
 from typing import List
 
 from model_compression_toolkit.core.common.network_editors.edit_network import EditRule
 
 
+@dataclass
 class DebugConfig:
     """
-    A class for MCT core debug information.
-    """
-    def __init__(self,
-                 analyze_similarity: bool = False,
-                 network_editor: List[EditRule] = [],
-                 simulate_scheduler: bool = False):
-        """
+    A dataclass for MCT core debug information.
 
-        Args:
+    Args:
+        analyze_similarity (bool): Whether to plot similarity figures within TensorBoard (when logger is
+         enabled) or not. Can be used to pinpoint problematic layers in the quantization process.
+        network_editor (List[EditRule]): A list of rules and actions to edit the network for quantization.
+        simulate_scheduler (bool): Simulate scheduler behavior to compute operators' order and cuts.
+    """
 
-            analyze_similarity (bool): Whether to plot similarity figures within TensorBoard (when logger is
-             enabled) or not. Can be used to pinpoint problematic layers in the quantization process.
-            network_editor (List[EditRule]): A list of rules and actions to edit the network for quantization.
-            simulate_scheduler (bool): Simulate scheduler behaviour to compute operators order and cuts.
-        """
-        self.analyze_similarity = analyze_similarity
-        self.network_editor = network_editor
-        self.simulate_scheduler = simulate_scheduler
+    analyze_similarity: bool = False
+    network_editor: List[EditRule] = field(default_factory=list)
+    simulate_scheduler: bool = False

model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 
-
+from dataclasses import dataclass, field
 import math
 from enum import Enum
 
@@ -46,86 +46,44 @@ class QuantizationErrorMethod(Enum):
     HMSE = 6
 
 
+@dataclass
 class QuantizationConfig:
+    """
+    A class that encapsulates all the different parameters used by the library to quantize a model.
+
+    Examples:
+        You can create a quantization configuration to apply to a model. For example, to quantize a model's weights and
+        activations using thresholds, with weight threshold selection based on MSE and activation threshold selection
+        using NOCLIPPING (min/max), while enabling relu_bound_to_power_of_2 and weights_bias_correction,
+        you can instantiate a quantization configuration like this:
+
+        >>> import model_compression_toolkit as mct
+        >>> 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`.
+
+    """
 
-    def __init__(self,
-                 activation_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE,
-                 weights_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE,
-                 relu_bound_to_power_of_2: bool = False,
-                 weights_bias_correction: bool = True,
-                 weights_second_moment_correction: bool = False,
-                 input_scaling: bool = False,
-                 softmax_shift: bool = False,
-                 shift_negative_activation_correction: bool = True,
-                 activation_channel_equalization: bool = False,
-                 z_threshold: float = math.inf,
-                 min_threshold: float = MIN_THRESHOLD,
-                 l_p_value: int = 2,
-                 linear_collapsing: bool = True,
-                 residual_collapsing: bool = True,
-                 shift_negative_ratio: float = 0.05,
-                 shift_negative_threshold_recalculation: bool = False,
-                 shift_negative_params_search: bool = False,
-                 concat_threshold_update: bool = False):
-        """
-        Class to wrap all different parameters the library quantize the input model according to.
-
-        Args:
-            activation_error_method (QuantizationErrorMethod): Which method to use from QuantizationErrorMethod for activation quantization threshold selection.
-            weights_error_method (QuantizationErrorMethod): Which method to use from QuantizationErrorMethod for activation quantization threshold selection.
-            relu_bound_to_power_of_2 (bool): Whether to use relu to power of 2 scaling correction or not.
-            weights_bias_correction (bool): Whether to use weights bias correction or not.
-            weights_second_moment_correction (bool): Whether to use weights second_moment correction or not.
-            input_scaling (bool): Whether to use input scaling or not.
-            softmax_shift (bool): Whether to use softmax shift or not.
-            shift_negative_activation_correction (bool): Whether to use shifting negative activation correction or not.
-            activation_channel_equalization (bool): Whether to use activation channel equalization correction or not.
-            z_threshold (float): Value of z score for outliers removal.
-            min_threshold (float): Minimum threshold to use during thresholds selection.
-            l_p_value (int): The p value of L_p norm threshold selection.
-            block_collapsing (bool): Whether to collapse block one to another in the input network
-            shift_negative_ratio (float): Value for the ratio between the minimal negative value of a non-linearity output to its activation threshold, which above it - shifting negative activation should occur if enabled.
-            shift_negative_threshold_recalculation (bool): Whether or not to recompute the threshold after shifting negative activation.
-            shift_negative_params_search (bool): Whether to search for optimal shift and threshold in shift negative activation.
-
-        Examples:
-            One may create a quantization configuration to quantize a model according to.
-            For example, to quantize a model's weights and activation using thresholds, such that
-            weights threshold selection is done using MSE, activation threshold selection is done using NOCLIPPING (min/max),
-            enabling relu_bound_to_power_of_2, weights_bias_correction,
-            one can instantiate a quantization configuration:
-
-            >>> import model_compression_toolkit as mct
-            >>> 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 instanse can then be passed to
-            :func:`~model_compression_toolkit.ptq.keras_post_training_quantization`
-
-        """
-
-        self.activation_error_method = activation_error_method
-        self.weights_error_method = weights_error_method
-        self.relu_bound_to_power_of_2 = relu_bound_to_power_of_2
-        self.weights_bias_correction = weights_bias_correction
-        self.weights_second_moment_correction = weights_second_moment_correction
-        self.activation_channel_equalization = activation_channel_equalization
-        self.input_scaling = input_scaling
-        self.softmax_shift = softmax_shift
-        self.min_threshold = min_threshold
-        self.shift_negative_activation_correction = shift_negative_activation_correction
-        self.z_threshold = z_threshold
-        self.l_p_value = l_p_value
-        self.linear_collapsing = linear_collapsing
-        self.residual_collapsing = residual_collapsing
-        self.shift_negative_ratio = shift_negative_ratio
-        self.shift_negative_threshold_recalculation = shift_negative_threshold_recalculation
-        self.shift_negative_params_search = shift_negative_params_search
-        self.concat_threshold_update = concat_threshold_update
-
-    def __repr__(self):
-        # Used for debugging, thus no cover.
-        return str(self.__dict__)  # pragma: no cover
+    activation_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE
+    weights_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE
+    relu_bound_to_power_of_2: bool = False
+    weights_bias_correction: bool = True
+    weights_second_moment_correction: bool = False
+    input_scaling: bool = False
+    softmax_shift: bool = False
+    shift_negative_activation_correction: bool = True
+    activation_channel_equalization: bool = False
+    z_threshold: float = math.inf
+    min_threshold: float = MIN_THRESHOLD
+    l_p_value: int = 2
+    linear_collapsing: bool = True
+    residual_collapsing: bool = True
+    shift_negative_ratio: float = 0.05
+    shift_negative_threshold_recalculation: bool = False
+    shift_negative_params_search: bool = False
+    concat_threshold_update: bool = False
 
 
 # Default quantization configuration the library use.

model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -360,7 +360,7 @@ def shift_negative_function(graph: Graph,
                                          graph=graph,
                                          quant_config=core_config.quantization_config,
                                          tpc=graph.tpc,
-                                         mixed_precision_enable=core_config.mixed_precision_enable)
+                                         mixed_precision_enable=core_config.is_mixed_precision_enabled)
 
         for candidate_qc in pad_node.candidates_quantization_cfg:
             candidate_qc.activation_quantization_cfg.enable_activation_quantization = False
@@ -377,7 +377,7 @@ def shift_negative_function(graph: Graph,
                                      graph=graph,
                                      quant_config=core_config.quantization_config,
                                      tpc=graph.tpc,
-                                     mixed_precision_enable=core_config.mixed_precision_enable)
+                                     mixed_precision_enable=core_config.is_mixed_precision_enabled)
 
     original_non_linear_activation_nbits = non_linear_node_cfg_candidate.activation_n_bits
     # The non-linear node's output should be float, so we approximate it by using 16bits quantization.

model_compression_toolkit/core/runner.py

@@ -119,7 +119,7 @@ def core_runner(in_model: Any,
                                      tpc,
                                      core_config.bit_width_config,
                                      tb_w,
-                                     mixed_precision_enable=core_config.mixed_precision_enable,
+                                     mixed_precision_enable=core_config.is_mixed_precision_enabled,
                                      running_gptq=running_gptq)
 
     hessian_info_service = HessianInfoService(graph=graph, representative_dataset_gen=representative_data_gen,
@@ -136,7 +136,7 @@ def core_runner(in_model: Any,
     ######################################
     # Finalize bit widths
     ######################################
-    if core_config.mixed_precision_enable:
+    if core_config.is_mixed_precision_enabled:
         if core_config.mixed_precision_config.configuration_overwrite is None:
 
             filter_candidates_for_mixed_precision(graph, target_resource_utilization, fw_info, tpc)
@@ -161,7 +161,7 @@ def core_runner(in_model: Any,
     else:
         bit_widths_config = []
 
-    tg = set_bit_widths(core_config.mixed_precision_enable,
+    tg = set_bit_widths(core_config.is_mixed_precision_enabled,
                         tg,
                         bit_widths_config)
 
@@ -175,7 +175,7 @@ def core_runner(in_model: Any,
                                     fw_info=fw_info,
                                     fw_impl=fw_impl)
 
-    if core_config.mixed_precision_enable:
+    if core_config.is_mixed_precision_enabled:
         # Retrieve lists of tuples (node, node's final weights/activation bitwidth)
         weights_conf_nodes_bitwidth = tg.get_final_weights_config(fw_info)
         activation_conf_nodes_bitwidth = tg.get_final_activation_config()

model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -199,7 +199,7 @@ if FOUND_TF:
         KerasModelValidation(model=in_model,
                              fw_info=DEFAULT_KERAS_INFO).validate()
 
-        if core_config.mixed_precision_enable:
+        if core_config.is_mixed_precision_enabled:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "
                                 "Ensure usage of the correct API for keras_post_training_quantization "

model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -165,7 +165,7 @@ if FOUND_TORCH:
 
         """
 
-        if core_config.mixed_precision_enable:
+        if core_config.is_mixed_precision_enabled:
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "
                                 "Ensure usage of the correct API for 'pytorch_gradient_post_training_quantization' "

model_compression_toolkit/ptq/keras/quantization_facade.py

@@ -124,7 +124,7 @@ if FOUND_TF:
         KerasModelValidation(model=in_model,
                              fw_info=fw_info).validate()
 
-        if core_config.mixed_precision_enable:
+        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 keras_post_training_quantization "

model_compression_toolkit/ptq/pytorch/quantization_facade.py

@@ -96,7 +96,7 @@ if FOUND_TORCH:
 
         fw_info = DEFAULT_PYTORCH_INFO
 
-        if core_config.mixed_precision_enable:
+        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 "

model_compression_toolkit/qat/keras/quantization_facade.py

@@ -176,7 +176,7 @@ if FOUND_TF:
         KerasModelValidation(model=in_model,
                              fw_info=DEFAULT_KERAS_INFO).validate()
 
-        if core_config.mixed_precision_enable:
+        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 keras_post_training_quantization API,"

model_compression_toolkit/qat/pytorch/quantization_facade.py

@@ -145,7 +145,7 @@ if FOUND_TORCH:
             f"If you encounter an issue, please open an issue in our GitHub "
             f"project https://github.com/sony/model_optimization")
 
-        if core_config.mixed_precision_enable:
+        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,"