mct-nightly 2.2.0.20240911.455__tar.gz → 2.2.0.20240913.457__tar.gz

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/PKG-INFO

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

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/mct_nightly.egg-info/PKG-INFO

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

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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.20240913.000457"

mct-nightly-2.2.0.20240913.457/model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py

@@ -0,0 +1,73 @@
+# Copyright 2021 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+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:
+    """
+    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._is_mixed_precision_enabled = True
+
+    @property
+    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._is_mixed_precision_enabled

mct-nightly-2.2.0.20240913.457/model_compression_toolkit/core/common/quantization/core_config.py

@@ -0,0 +1,48 @@
+# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# 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 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.
+            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.
+    """
+
+    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 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)
+

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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

mct-nightly-2.2.0.20240913.457/model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -0,0 +1,92 @@
+# Copyright 2021 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from dataclasses import dataclass, field
+import math
+from enum import Enum
+
+from model_compression_toolkit.constants import MIN_THRESHOLD
+
+
+class QuantizationErrorMethod(Enum):
+    """
+    Method for quantization threshold selection:
+
+    NOCLIPPING - Use min/max values as thresholds.
+
+    MSE - Use mean square error for minimizing quantization noise.
+
+    MAE - Use mean absolute error for minimizing quantization noise.
+
+    KL - Use KL-divergence to make signals distributions to be similar as possible.
+
+    Lp - Use Lp-norm to minimizing quantization noise.
+
+    HMSE - Use Hessian-based mean squared error for minimizing quantization noise. This method is using Hessian scores to factorize more valuable parameters when computing the error induced by quantization.
+
+    """
+
+    NOCLIPPING = 0
+    MSE = 1
+    MAE = 2
+    KL = 4
+    LP = 5
+    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`.
+
+    """
+
+    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.
+DEFAULTCONFIG = QuantizationConfig(QuantizationErrorMethod.MSE, QuantizationErrorMethod.MSE,
+                                   relu_bound_to_power_of_2=False, weights_bias_correction=True,
+                                   weights_second_moment_correction=False, input_scaling=False, softmax_shift=False)

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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.

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/model_compression_toolkit/core/pytorch/reader/graph_builders.py

@@ -80,16 +80,19 @@ def _build_input_alloc_and_call_args(n: Node, input_tensors_in_node_kwargs: Dict
     tensor_input_alloc = []
     op_call_args = list(n.args)
     if inputs_as_list:
-        op_call_args.pop(0)
+        # input tensors are a list in the first argument -> remove from op_call_args and go over
+        # the tensors in that list.
+        _args = op_call_args.pop(0)
     else:
-        for in_node in n.all_input_nodes:
-            # The extra for loop is used to tackle the case of the same input tensor for this node (e.g. torch.add(x, x)).
-            for i, arg in enumerate(n.args):
-                if arg == in_node:
-                    tensor_input_alloc.append(i)
-            for k, arg in input_tensors_in_node_kwargs.items():
-                if arg == in_node:
-                    tensor_input_alloc.append(k)
+        _args = n.args
+    for in_node in n.all_input_nodes:
+        # The extra for loop is used to tackle the case of the same input tensor for this node (e.g. torch.add(x, x)).
+        for i, arg in enumerate(_args):
+            if arg == in_node:
+                tensor_input_alloc.append(i)
+        for k, arg in input_tensors_in_node_kwargs.items():
+            if arg == in_node:
+                tensor_input_alloc.append(k)
 
     return op_call_args, tensor_input_alloc
 
@@ -253,11 +256,8 @@ def nodes_builder(model: GraphModule,
                     node_kwargs[k] = v
 
             # Check if node's first input argument is a list of input fx nodes, such as torch.cat:
-            is_first_input_list_of_nodes = is_instance_first_arg(node, (list, tuple)) and all(
+            inputs_as_list = is_instance_first_arg(node, (list, tuple)) and all(
                 [isinstance(n, Node) for n in node.args[0]])
-            is_placeholder_a_list = is_instance_first_arg(node, Node) and \
-                     node.args[0].op == PLACEHOLDER and node.args[0].meta[TYPE] in (list, tuple)
-            inputs_as_list = is_first_input_list_of_nodes or is_placeholder_a_list
 
             # Build tensor_input_alloc required for the model builder. All input nodes are received as a list in the builder,
             # so tensor_input_alloc is used to allocate each input tensor in the correct place in the node's args & kwargs.
@@ -333,7 +333,12 @@ def edges_builder(model: GraphModule,
                 if input_node in fx_node_2_graph_node:
                     # n_edges_for_input_node is for the case that the input node appears more than
                     # once as the input of the node, for example add(x, x)
-                    n_edges_for_input_node = sum([1 for a in node.args if input_node == a])
+                    if node in fx_node_2_graph_node and isinstance(fx_node_2_graph_node[node], FunctionalNode) and \
+                            fx_node_2_graph_node[node].inputs_as_list:
+                        _args = node.args[0]
+                    else:
+                        _args = node.args
+                    n_edges_for_input_node = sum([1 for a in _args if input_node == a])
                     n_edges_for_input_node = max(n_edges_for_input_node, 1)
 
                     dst_index = node.all_input_nodes.index(input_node)

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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()

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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 "

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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' "

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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 "

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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 "

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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,"

{mct-nightly-2.2.0.20240911.455 → mct-nightly-2.2.0.20240913.457}/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,"

mct-nightly-2.2.0.20240911.455/model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py

@@ -1,87 +0,0 @@
-# Copyright 2021 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-from typing import List, Callable
-
-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
-
-
-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
-
-    def set_mixed_precision_enable(self):
-        """
-        Set a flag in mixed precision config indicating that mixed precision is enabled.
-        """
-
-        self._mixed_precision_enable = True
-
-    @property
-    def mixed_precision_enable(self):
-        """
-        A property that indicates whether mixed precision quantization is enabled.
-
-        Returns: True if mixed precision quantization is enabled
-
-        """
-        return self._mixed_precision_enable

mct-nightly-2.2.0.20240911.455/model_compression_toolkit/core/common/quantization/core_config.py

@@ -1,52 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-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
-
-
-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
-                 ):
-        """
-
-        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
-
-        if mixed_precision_config is None:
-            self.mixed_precision_config = MixedPrecisionQuantizationConfig()
-        else:
-            self.mixed_precision_config = mixed_precision_config
-
-    @property
-    def mixed_precision_enable(self):
-        return self.mixed_precision_config is not None and self.mixed_precision_config.mixed_precision_enable
-