mct-nightly 2.1.0.20240811.503__tar.gz → 2.1.0.20240813.442__tar.gz

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/PKG-INFO

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

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/mct_nightly.egg-info/PKG-INFO

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

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/mct_nightly.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ model_compression_toolkit/constants.py
 model_compression_toolkit/defaultdict.py
 model_compression_toolkit/logger.py
 model_compression_toolkit/metadata.py
+model_compression_toolkit/verify_packages.py
 model_compression_toolkit/core/__init__.py
 model_compression_toolkit/core/analyzer.py
 model_compression_toolkit/core/graph_prep_runner.py
@@ -107,6 +108,7 @@ model_compression_toolkit/core/common/pruning/mask/__init__.py
 model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py
 model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py
 model_compression_toolkit/core/common/quantization/__init__.py
+model_compression_toolkit/core/common/quantization/bit_width_config.py
 model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py
 model_compression_toolkit/core/common/quantization/core_config.py
 model_compression_toolkit/core/common/quantization/debug_config.py

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/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.1.0.20240811.000503"
+__version__ = "2.1.0.20240813.000442"

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/constants.py

@@ -13,17 +13,10 @@
 # limitations under the License.
 # ==============================================================================
 
-import importlib
 
 # Supported frameworks in MCT:
 TENSORFLOW = 'tensorflow'
 PYTORCH = 'pytorch'
-FOUND_TF = importlib.util.find_spec(TENSORFLOW) is not None
-FOUND_TORCH = importlib.util.find_spec("torch") is not None
-FOUND_TORCHVISION = importlib.util.find_spec("torchvision") is not None
-FOUND_ONNX = importlib.util.find_spec("onnx") is not None
-FOUND_ONNXRUNTIME = importlib.util.find_spec("onnxruntime") is not None
-FOUND_SONY_CUSTOM_LAYERS = importlib.util.find_spec('sony_custom_layers') is not None
 
 # Metadata fields
 MCT_VERSION = 'mct_version'

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/__init__.py

@@ -19,6 +19,7 @@ from model_compression_toolkit.core.common.quantization.debug_config import Debu
 from model_compression_toolkit.core.common.quantization import quantization_config
 from model_compression_toolkit.core.common.mixed_precision import mixed_precision_quantization_config
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig, QuantizationErrorMethod, DEFAULTCONFIG
+from model_compression_toolkit.core.common.quantization.bit_width_config import BitWidthConfig
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/common/graph/functional_node.py

@@ -1,6 +1,6 @@
 from typing import Dict, Any, Tuple, Type, List, Union
 
-from model_compression_toolkit.constants import FOUND_TF
+from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 import numpy as np
 

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py

@@ -67,6 +67,7 @@ def compute_resource_utilization_data(in_model: Any,
                                                      fw_info,
                                                      fw_impl,
                                                      tpc,
+                                                     bit_width_config=core_config.bit_width_config,
                                                      mixed_precision_enable=mixed_precision_enable)
 
     # Compute parameters sum
@@ -227,6 +228,7 @@ def requires_mixed_precision(in_model: Any,
                                                  fw_info,
                                                  fw_impl,
                                                  tpc,
+                                                 bit_width_config=core_config.bit_width_config,
                                                  mixed_precision_enable=False)
     # Compute max weights memory in bytes
     weights_memory_by_layer_bytes, _ = compute_nodes_weights_params(transformed_graph, fw_info)

mct-nightly-2.1.0.20240813.442/model_compression_toolkit/core/common/quantization/bit_width_config.py

@@ -0,0 +1,91 @@
+# Copyright 2024 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, Union, Dict
+
+from model_compression_toolkit.core.common import Graph
+from model_compression_toolkit.core.common.matchers.node_matcher import BaseNodeMatcher
+from model_compression_toolkit.logger import Logger
+
+
+class ManualBitWidthSelection:
+    """
+   Class to encapsulate the manual bit width selection configuration for a specific filter.
+
+   Attributes:
+       filter (BaseNodeMatcher): The filter used to select nodes for bit width manipulation.
+       bit_width (int): The bit width to be applied to the selected nodes.
+   """
+    def __init__(self,
+                 filter: BaseNodeMatcher,
+                 bit_width: int):
+        self.filter = filter
+        self.bit_width = bit_width
+
+
+class BitWidthConfig:
+    """
+    Class to manage manual bit-width configurations.
+
+    Attributes:
+        manual_activation_bit_width_selection_list (List[ManualBitWidthSelection]): A list of ManualBitWidthSelection objects defining manual bit-width configurations.
+    """
+    def __init__(self,
+                 manual_activation_bit_width_selection_list: List[ManualBitWidthSelection] = None):
+        self.manual_activation_bit_width_selection_list = [] if manual_activation_bit_width_selection_list is None else manual_activation_bit_width_selection_list
+
+    def __repr__(self):
+        # Used for debugging, thus no cover.
+        return str(self.__dict__)  # pragma: no cover
+
+    def set_manual_activation_bit_width(self,
+                                        filters: Union[List[BaseNodeMatcher], BaseNodeMatcher],
+                                        bit_widths: Union[List[int], int]):
+        """
+        Add a manual bit-width selection to the configuration.
+
+        Args:
+            filter (Union[List[BaseNodeMatcher], BaseNodeMatcher]): The filters used to select nodes for bit-width manipulation.
+            bit_width (Union[List[int], int]): The bit widths to be applied to the selected nodes.
+            If a single value is given it will be applied to all the filters
+        """
+        filters = [filters] if not isinstance(filters, list) else filters
+        bit_widths = [bit_widths] if not isinstance(bit_widths, list) else bit_widths
+        if len(bit_widths) > 1 and len(bit_widths) != len(filters):
+            Logger.critical(f"Configuration Error: The number of provided bit_width values {len(bit_widths)} "
+                            f"must match the number of filters {len(filters)}, or a single bit_width value "
+                            f"should be provided for all filters.")
+        elif len(bit_widths) == 1 and len(filters) > 1:
+            bit_widths = [bit_widths[0] for f in filters]
+        for bit_width, filter in zip (bit_widths, filters):
+            self.manual_activation_bit_width_selection_list += [ManualBitWidthSelection(filter, bit_width)]
+
+    def get_nodes_to_manipulate_bit_widths(self, graph: Graph) -> Dict:
+        """
+        Retrieve nodes from the graph that need their bit-widths changed according to the manual bit-width selections.
+
+        Args:
+            graph (Graph): The graph containing the nodes to be filtered and manipulated.
+
+        Returns:
+            Dict: A dictionary mapping nodes to their new bit-widths.
+        """
+        nodes_to_change_bit_width = {}
+        for manual_bit_width_selection in self.manual_activation_bit_width_selection_list:
+            filtered_nodes = graph.filter(manual_bit_width_selection.filter)
+            if len(filtered_nodes) == 0:
+                Logger.critical(f"Node Filtering Error: No nodes found in the graph for filter {manual_bit_width_selection.filter.__dict__} "
+                                f"to change their bit width to {manual_bit_width_selection.bit_width}.")
+            nodes_to_change_bit_width.update({n: manual_bit_width_selection.bit_width for n in filtered_nodes})
+        return nodes_to_change_bit_width

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/common/quantization/core_config.py

@@ -12,6 +12,7 @@
 # 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
@@ -22,9 +23,10 @@ class CoreConfig:
     A class to hold the configurations classes of the MCT-core.
     """
     def __init__(self,
-                 quantization_config: QuantizationConfig = QuantizationConfig(),
+                 quantization_config: QuantizationConfig = None,
                  mixed_precision_config: MixedPrecisionQuantizationConfig = None,
-                 debug_config: DebugConfig = DebugConfig()
+                 bit_width_config: BitWidthConfig = None,
+                 debug_config: DebugConfig = None
                  ):
         """
 
@@ -32,10 +34,12 @@ class CoreConfig:
             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 = quantization_config
-        self.debug_config = debug_config
+        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()

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -56,7 +56,7 @@ class QuantizationConfig:
                  weights_second_moment_correction: bool = False,
                  input_scaling: bool = False,
                  softmax_shift: bool = False,
-                 shift_negative_activation_correction: bool = False,
+                 shift_negative_activation_correction: bool = True,
                  activation_channel_equalization: bool = False,
                  z_threshold: float = math.inf,
                  min_threshold: float = MIN_THRESHOLD,

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -15,9 +15,11 @@
 
 
 import copy
-from typing import List, Tuple
+from typing import List, Tuple,  Optional
 
+from mct_quantizers.common.constants import ACTIVATION_N_BITS
 from model_compression_toolkit.core.common import BaseNode
+from model_compression_toolkit.core.common.quantization.bit_width_config import BitWidthConfig
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.graph.base_graph import Graph
@@ -37,19 +39,21 @@ from model_compression_toolkit.target_platform_capabilities.target_platform.op_q
 
 def set_quantization_configuration_to_graph(graph: Graph,
                                             quant_config: QuantizationConfig,
+                                            bit_width_config: BitWidthConfig = None,
                                             mixed_precision_enable: bool = False,
                                             running_gptq: bool = False) -> Graph:
     """
     Add quantization configuration for each graph node.
 
     Args:
-        graph: Graph for which to add quantization info to each node.
-        quant_config: Quantization configuration containing parameters for how the graph should be quantized.
-        mixed_precision_enable: is mixed precision enabled.
-        running_gptq: Whether or not a GPTQ optimization is planned to run after the PTQ process.
+        graph (Graph): Graph for which to add quantization info to each node.
+        quant_config (QuantizationConfig): Quantization configuration containing parameters for how the graph should be quantized.
+        bit_width_config (BitWidthConfig): Configuration for manual bit width selection. Defaults to None.
+        mixed_precision_enable (bool): Whether mixed precision is enabled. Defaults to False.
+        running_gptq (bool): Whether or not a GPTQ optimization is planned to run after the PTQ process. Defaults to False.
 
     Returns:
-        The graph with quantization configurations attached to each node in it.
+        Graph: The graph with quantization configurations attached to each node in it.
     """
 
     if quant_config.weights_error_method == QuantizationErrorMethod.HMSE:
@@ -62,13 +66,16 @@ def set_quantization_configuration_to_graph(graph: Graph,
             Logger.warning("Using the HMSE error method for weights quantization parameters search. "
                            "Note: This method may significantly increase runtime during the parameter search process.")
 
+    nodes_to_manipulate_bit_widths = {} if bit_width_config is None else bit_width_config.get_nodes_to_manipulate_bit_widths(graph)
+
     for n in graph.nodes:
         set_quantization_configs_to_node(node=n,
                                          graph=graph,
                                          quant_config=quant_config,
                                          fw_info=graph.fw_info,
                                          tpc=graph.tpc,
-                                         mixed_precision_enable=mixed_precision_enable)
+                                         mixed_precision_enable=mixed_precision_enable,
+                                         manual_bit_width_override=nodes_to_manipulate_bit_widths.get(n))
     return graph
 
 
@@ -77,21 +84,32 @@ def set_quantization_configs_to_node(node: BaseNode,
                                      quant_config: QuantizationConfig,
                                      fw_info: FrameworkInfo,
                                      tpc: TargetPlatformCapabilities,
-                                     mixed_precision_enable: bool = False):
+                                     mixed_precision_enable: bool = False,
+                                     manual_bit_width_override: Optional[int] = None):
     """
     Create and set quantization configurations to a node (for both weights and activation).
 
     Args:
-        node: Node to set its quantization configurations.
-        graph: Model's internal representation graph.
-        quant_config: Quantization configuration to generate the node's configurations from.
-        fw_info: Information needed for quantization about the specific framework.
-        tpc: TargetPlatformCapabilities to get default OpQuantizationConfig.
-        mixed_precision_enable: is mixed precision enabled.
+        node (BaseNode): Node to set its quantization configurations.
+        graph (Graph): Model's internal representation graph.
+        quant_config (QuantizationConfig): Quantization configuration to generate the node's configurations from.
+        fw_info (FrameworkInfo): Information needed for quantization about the specific framework.
+        tpc (TargetPlatformCapabilities): TargetPlatformCapabilities to get default OpQuantizationConfig.
+        mixed_precision_enable (bool): Whether mixed precision is enabled. Defaults to False.
+        manual_bit_width_override (Optional[int]): Specifies a custom bit-width to override the node's activation bit-width. Defaults to None.
     """
     node_qc_options = node.get_qco(tpc)
     base_config, node_qc_options_list = node.filter_node_qco_by_graph(tpc, graph.get_next_nodes(node), node_qc_options)
 
+    # If a manual_bit_width_override is given, filter node_qc_options_list to retain only the options with activation bits equal to manual_bit_width_override,
+    # and update base_config accordingly.
+    base_config, node_qc_options_list = filter_qc_options_with_manual_bit_width(
+        node=node,
+        node_qc_options_list=node_qc_options_list,
+        base_config=base_config,
+        manual_bit_width_override=manual_bit_width_override,
+        mixed_precision_enable=mixed_precision_enable)
+
     # Create QC candidates for weights and activation combined
     weight_channel_axis = fw_info.kernel_channels_mapping.get(node.type)
     node.candidates_quantization_cfg = _create_node_candidates_qc(quant_config,
@@ -199,16 +217,16 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
     Create a list of candidates of weights and activation quantization configurations for a node.
 
     Args:
-        qc: Quantization configuration the quantization process should follow.
-        fw_info: Framework information (e.g., which layers should have their kernels' quantized).
-        weight_channel_axis: (Output, Input) channel index of the node's kernel.
-        node_qc_options_list: List of quantization configs of node.
-        base_config: Base quantization config for node.
-        node: A node to set quantization configuration candidates to.
-        mixed_precision_enable: is mixed precision enabled
+        qc (QuantizationConfig): Quantization configuration the quantization process should follow.
+        fw_info (FrameworkInfo): Framework information (e.g., which layers should have their kernels quantized).
+        weight_channel_axis (Tuple[int, int]): (Output, Input) channel index of the node's kernel.
+        node_qc_options_list (List[OpQuantizationConfig]): List of quantization configs of node.
+        base_config (OpQuantizationConfig): Base quantization config for node.
+        node (BaseNode): A node to set quantization configuration candidates to.
+        mixed_precision_enable (bool): Whether mixed precision is enabled. Defaults to False.
 
     Returns:
-        List of candidates of weights quantization configurations to set for a node.
+        List[CandidateNodeQuantizationConfig]: List of candidates of weights quantization configurations to set for a node.
     """
 
     candidates = []
@@ -231,3 +249,51 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
                                                            node_attrs_list))
 
     return candidates
+
+
+def filter_qc_options_with_manual_bit_width(
+        node: BaseNode,
+        node_qc_options_list: List[OpQuantizationConfig],
+        base_config: OpQuantizationConfig,
+        manual_bit_width_override: Optional[int],
+        mixed_precision_enable: bool) -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig]]:
+    """
+    Update the quantization configurations for a node, allowing manual bit-width overrides if specified.
+
+    Args:
+        node (BaseNode): A node to set quantization configuration candidates to.
+        node_qc_options_list (List[OpQuantizationConfig]): List of quantization configs for the node.
+        base_config (OpQuantizationConfig): Base quantization config for the node.
+        manual_bit_width_override (Optional[int]): Specifies a custom bit-width to override the node's activation bit-width.
+        mixed_precision_enable (bool): Whether mixed precision is enabled.
+
+    Returns:
+        Tuple[OpQuantizationConfig, List[OpQuantizationConfig]]: The updated base configuration and the filtered list of quantization configs.
+    """
+    if manual_bit_width_override is None:
+        return base_config, node_qc_options_list
+
+    # Filter node_qc_options_list to retain only the options with activation bits equal to manual_bit_width_override.
+    node_qc_options_list = [op_cfg for op_cfg in node_qc_options_list if
+                                manual_bit_width_override == op_cfg.activation_n_bits]
+
+    if len(node_qc_options_list) == 0:
+        Logger.critical(f"Manually selected activation bit-width {manual_bit_width_override} is invalid for node {node}.")
+    else:
+        # Update the base_config to one of the values from the filtered node_qc_options_list.
+        # First, check if a configuration similar to the original base_config but with activation bits equal to manual_bit_width_override exists.
+        # If it does, use it as the base_config. If not, choose a different configuration from node_qc_options_list.
+        Logger.info(f"Setting node {node} bit-width to manually selected bit-width: {manual_bit_width_override} bits.")
+        updated_base_config = base_config.clone_and_edit({ACTIVATION_N_BITS, manual_bit_width_override})
+        if updated_base_config in node_qc_options_list:
+            # If a base_config with the specified manual_bit_width_override exists in the node_qc_options_list,
+            # point the base_config to this option.
+            base_config = node_qc_options_list[node_qc_options_list.index(updated_base_config)]
+        else:
+            # Choose a different configuration from node_qc_options_list. If multiple options exist, issue a warning.
+            base_config = node_qc_options_list[0]
+            if len(node_qc_options_list) > 0 and not mixed_precision_enable:
+                Logger.info(
+                    f"Request received to select {manual_bit_width_override} activation bits. However, the base configuration for layer type {node.type} is missing in the node_qc_options_list."
+                    f" Overriding base_config with an option that uses {manual_bit_width_override} bit activations.")  # pragma: no cover
+    return base_config, node_qc_options_list

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/graph_prep_runner.py

@@ -20,6 +20,7 @@ from model_compression_toolkit.core.common import FrameworkInfo
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.fusion.layer_fusing import fusion
 from model_compression_toolkit.core.common.graph.base_graph import Graph
+from model_compression_toolkit.core.common.quantization.bit_width_config import BitWidthConfig
 from model_compression_toolkit.core.common.quantization.filter_nodes_candidates import filter_nodes_candidates
 from model_compression_toolkit.core.common.quantization.quantization_config import DEFAULTCONFIG
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
@@ -38,6 +39,7 @@ def graph_preparation_runner(in_model: Any,
                              fw_info: FrameworkInfo,
                              fw_impl: FrameworkImplementation,
                              tpc: TargetPlatformCapabilities,
+                             bit_width_config: BitWidthConfig = None,
                              tb_w: TensorboardWriter = None,
                              mixed_precision_enable: bool = False,
                              running_gptq: bool = False) -> Graph:
@@ -50,17 +52,18 @@ def graph_preparation_runner(in_model: Any,
         - Apply all necessary substitutions to finalize the graph for quantization.
 
     Args:
-        in_model: Model to quantize.
-        representative_data_gen: Dataset used for calibration.
-        quantization_config: QuantizationConfig containing parameters of how the model should be quantized.
-        fw_info: Information needed for quantization about the specific framework (e.g., kernel channels indices,
+        in_model (Any): Model to quantize.
+        representative_data_gen (Callable): Dataset used for calibration.
+        quantization_config (QuantizationConfig): QuantizationConfig containing parameters of how the model should be quantized.
+        fw_info (FrameworkInfo): Information needed for quantization about the specific framework (e.g., kernel channels indices,
             groups of layers by how they should be quantized, etc.).
-        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
-        tpc: TargetPlatformCapabilities object that models the inference target platform and
+        fw_impl (FrameworkImplementation): FrameworkImplementation object with a specific framework methods implementation.
+        tpc (TargetPlatformCapabilities): TargetPlatformCapabilities object that models the inference target platform and
             the attached framework operator's information.
-        tb_w: TensorboardWriter object for logging.
-        mixed_precision_enable: is mixed precision enabled.
-        running_gptq: Whether or not a GPTQ optimization is planned to run after the PTQ process.
+        bit_width_config (BitWidthConfig): Config for bit-width selection. Defaults to None.
+        tb_w (TensorboardWriter): TensorboardWriter object for logging.
+        mixed_precision_enable (bool): is mixed precision enabled.
+        running_gptq (bool): Whether or not a GPTQ optimization is planned to run after the PTQ process.
 
     Returns:
         An internal graph representation of the input model.
@@ -78,6 +81,7 @@ def graph_preparation_runner(in_model: Any,
     transformed_graph = get_finalized_graph(graph,
                                             tpc,
                                             quantization_config,
+                                            bit_width_config,
                                             fw_info,
                                             tb_w,
                                             fw_impl,
@@ -90,6 +94,7 @@ def graph_preparation_runner(in_model: Any,
 def get_finalized_graph(initial_graph: Graph,
                         tpc: TargetPlatformCapabilities,
                         quant_config: QuantizationConfig = DEFAULTCONFIG,
+                        bit_width_config: BitWidthConfig = None,
                         fw_info: FrameworkInfo = None,
                         tb_w: TensorboardWriter = None,
                         fw_impl: FrameworkImplementation = None,
@@ -104,6 +109,7 @@ def get_finalized_graph(initial_graph: Graph,
         tpc (TargetPlatformCapabilities): TargetPlatformCapabilities object that describes the desired inference target platform (includes fusing patterns MCT should handle).
         quant_config (QuantizationConfig): QuantizationConfig containing parameters of how the model should be
             quantized.
+        bit_width_config (BitWidthConfig): Config for bit-width selection. Defaults to None.
         fw_info (FrameworkInfo): Information needed for quantization about the specific framework (e.g.,
             kernel channels indices, groups of layers by how they should be quantized, etc.)
         tb_w (TensorboardWriter): TensorboardWriter object to use for logging events such as graphs, histograms, etc.
@@ -147,6 +153,7 @@ def get_finalized_graph(initial_graph: Graph,
     ######################################
     transformed_graph = set_quantization_configuration_to_graph(graph=transformed_graph,
                                                                 quant_config=quant_config,
+                                                                bit_width_config=bit_width_config,
                                                                 mixed_precision_enable=mixed_precision_enable,
                                                                 running_gptq=running_gptq)
 

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/keras/resource_utilization_data_facade.py

@@ -20,7 +20,7 @@ from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW
 from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_data import compute_resource_utilization_data
-from model_compression_toolkit.constants import FOUND_TF
+from model_compression_toolkit.verify_packages import FOUND_TF
 
 if FOUND_TF:
     from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
@@ -89,5 +89,6 @@ else:
     # If tensorflow is not installed,
     # we raise an exception when trying to use this function.
     def keras_resource_utilization_data(*args, **kwargs):
-        Logger.critical("Tensorflow must be installed to use keras_resource_utilization_data. "
-                        "The 'tensorflow' package is missing.")  # pragma: no cover
+        Logger.critical("Tensorflow must be installed with a version of 2.15 or lower to use "
+                        "keras_resource_utilization_data. The 'tensorflow' package is either not installed or is "
+                        "installed with a version higher than 2.15.")  # pragma: no cover

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/pytorch/resource_utilization_data_facade.py

@@ -23,7 +23,7 @@ from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization_data import compute_resource_utilization_data
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import MixedPrecisionQuantizationConfig
-from model_compression_toolkit.constants import FOUND_TORCH
+from model_compression_toolkit.verify_packages import FOUND_TORCH
 
 if FOUND_TORCH:
     from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/core/runner.py

@@ -115,6 +115,7 @@ def core_runner(in_model: Any,
                                      fw_info,
                                      fw_impl,
                                      tpc,
+                                     core_config.bit_width_config,
                                      tb_w,
                                      mixed_precision_enable=core_config.mixed_precision_enable,
                                      running_gptq=running_gptq)

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/data_generation/__init__.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 
-from model_compression_toolkit.constants import FOUND_TORCH, FOUND_TF, FOUND_TORCHVISION
+from model_compression_toolkit.verify_packages import FOUND_TORCHVISION, FOUND_TORCH, FOUND_TF
 from model_compression_toolkit.data_generation.common.data_generation_config import DataGenerationConfig
 from model_compression_toolkit.data_generation.common.enums import ImageGranularity, DataInitType, SchedulerType, BNLayerWeightingType, OutputLossType, BatchNormAlignemntLossType, ImagePipelineType, ImageNormalizationType
 

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/data_generation/keras/keras_data_generation.py

@@ -16,7 +16,7 @@ import time
 from typing import Callable, Tuple, List, Dict, Union
 from tqdm import tqdm
 
-from model_compression_toolkit.constants import FOUND_TF
+from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.data_generation.common.constants import DEFAULT_N_ITER, DEFAULT_DATA_GEN_BS
 from model_compression_toolkit.data_generation.common.data_generation import get_data_generation_classes
 from model_compression_toolkit.data_generation.common.image_pipeline import image_normalization_dict
@@ -349,8 +349,12 @@ if FOUND_TF:
 else:
     def get_keras_data_generation_config(*args, **kwargs):
         Logger.critical(
-            "Tensorflow must be installed to use get_tensorflow_data_generation_config. The 'tensorflow' package is missing.")  # pragma: no cover
+            "Tensorflow must be installed with a version of 2.15 or lower to use "
+            "get_tensorflow_data_generation_config. The 'tensorflow' package is missing or is installed with a "
+            "version higher than 2.15.")  # pragma: no cover
 
 
     def keras_data_generation_experimental(*args, **kwargs):
-        Logger.critical("Tensorflow must be installed to use tensorflow_data_generation_experimental. The 'tensorflow' package is missing.")  # pragma: no cover
+        Logger.critical("Tensorflow must be installed with a version of 2.15 or lower to use "
+                        "tensorflow_data_generation_experimental. The 'tensorflow' package is missing or is installed "
+                        "with a version higher than 2.15.")  # pragma: no cover

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/data_generation/pytorch/pytorch_data_generation.py

@@ -17,7 +17,7 @@ from typing import Callable, Any, Tuple, List, Union
 
 from tqdm import tqdm
 
-from model_compression_toolkit.constants import FOUND_TORCH, FOUND_TORCHVISION
+from model_compression_toolkit.verify_packages import FOUND_TORCHVISION, FOUND_TORCH
 from model_compression_toolkit.core.pytorch.utils import set_model
 from model_compression_toolkit.data_generation.common.constants import DEFAULT_N_ITER, DEFAULT_DATA_GEN_BS
 from model_compression_toolkit.data_generation.common.data_generation import get_data_generation_classes

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/exporter/model_exporter/keras/keras_export_facade.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 from typing import Callable, Dict
 
-from model_compression_toolkit.constants import FOUND_TF
+from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.exporter.model_exporter.fw_agonstic.quantization_format import QuantizationFormat
 from model_compression_toolkit.logger import Logger
 
@@ -101,5 +101,6 @@ if FOUND_TF:
         return exporter.get_custom_objects()
 else:
     def keras_export_model(*args, **kwargs):
-        Logger.critical("Tensorflow must be installed to use keras_export_model. "
-                        "The 'tensorflow' package is missing.")  # pragma: no cover
+        Logger.critical("Tensorflow must be installed with a version of 2.15 or lower to use keras_export_model."
+                        "The 'tensorflow' package is missing or is installed "
+                        "with a version higher than 2.15.")  # pragma: no cover

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/exporter/model_exporter/pytorch/fakely_quant_onnx_pytorch_exporter.py

@@ -18,7 +18,7 @@ from io import BytesIO
 import torch.nn
 
 from mct_quantizers import PytorchActivationQuantizationHolder, PytorchQuantizationWrapper
-from model_compression_toolkit.constants import FOUND_ONNX
+from model_compression_toolkit.verify_packages import FOUND_ONNX
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.pytorch.utils import to_torch_tensor
 from model_compression_toolkit.exporter.model_exporter.pytorch.base_pytorch_exporter import BasePyTorchExporter

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/exporter/model_exporter/pytorch/pytorch_export_facade.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 from typing import Callable
 
-from model_compression_toolkit.constants import FOUND_TORCH
+from model_compression_toolkit.verify_packages import FOUND_TORCH
 from model_compression_toolkit.exporter.model_exporter.fw_agonstic.quantization_format import QuantizationFormat
 from model_compression_toolkit.exporter.model_exporter.pytorch.export_serialization_format import \
     PytorchExportSerializationFormat

{mct-nightly-2.1.0.20240811.503 → mct-nightly-2.1.0.20240813.442}/model_compression_toolkit/exporter/model_wrapper/keras/builder/fully_quantized_model_builder.py

@@ -16,7 +16,7 @@
 from typing import Tuple, Callable
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.constants import FOUND_TF
+from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.logger import Logger
 import model_compression_toolkit.core as C
@@ -101,5 +101,6 @@ if FOUND_TF:
         return exportable_model, user_info
 else:
     def get_exportable_keras_model(*args, **kwargs):  # pragma: no cover
-        Logger.critical("Tensorflow must be installed to use get_exportable_keras_model. "
-                        "The 'tensorflow' package is missing.")  # pragma: no cover
+        Logger.critical("Tensorflow must be installed with a version of 2.15 or lower to use "
+                        "get_exportable_keras_model. The 'tensorflow' package is missing or is installed with a "
+                        "version higher than 2.15.")  # pragma: no cover