mct-nightly 2.4.0.20250925.543__tar.gz → 2.4.2.20250927.534__tar.gz

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.4.0.20250925.543
+Version: 2.4.2.20250927.534
 Summary: A Model Compression Toolkit for neural networks
 Author-email: ssi-dnn-dev@sony.com
 Classifier: Programming Language :: Python :: 3
@@ -23,7 +23,7 @@ Requires-Dist: scipy
 Requires-Dist: protobuf
 Requires-Dist: mct-quantizers==1.6.0
 Requires-Dist: pydantic>=2.0
-Requires-Dist: edge-mdt-cl>=1.0
+Requires-Dist: edge-mdt-cl-dev
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
@@ -69,7 +69,7 @@ Pip install the model compression toolkit package in a Python>=3.9 environment w
 ```
 pip install model-compression-toolkit
 ```
-For installing the nightly version or installing from source, refer to the [installation guide](https://github.com/sony/model_optimization/blob/main/INSTALLATION.md).
+For installing the nightly version or installing from source, refer to the [installation guide](https://github.com/SonySemiconductorSolutions/mct-model-optimization/blob/main/INSTALLATION.md).
 
 **Important note**: In order to use MCT, you’ll need to provide a pre-trained floating point model (PyTorch/Keras) as an input.
 
@@ -139,6 +139,9 @@ Modify your model's quantization configuration for specific layers or apply a cu
 **🖥️ Visualization**. Observe useful information for troubleshooting the quantized model's performance using TensorBoard. [Read more](https://sonysemiconductorsolutions.github.io/mct-model-optimization/guidelines/visualization.html).
 
 **🔑 XQuant (Explainable Quantization)** [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sony/model_optimization/blob/main/tutorials/notebooks/mct_features_notebooks/pytorch/example_pytorch_xquant.ipynb). Get valuable insights regarding the quality and success of the quantization process of your model. The report includes histograms and similarity metrics between the original float model and the quantized model in key points of the model. The report can be visualized using TensorBoard.
+
+**🔑 XQuant Extension Tool.** Calculates the error for each layer by comparing the float model and quantized model, using both models along with the quantization log. The results are presented in reports. It identifies the causes of the detected errors and recommends appropriate improvement measures for each cause. [Read more](docs/guidelines/XQuant_Extension_Tool.html) [Troubleshoot Manual](docs/docs_troubleshoot/index.html)
+
 __________________________________________________________________________________________________________
 ### Enhanced Post-Training Quantization (EPTQ)
 As part of the GPTQ capability, we provide an advanced optimization algorithm called EPTQ.

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/README.md

@@ -34,7 +34,7 @@ Pip install the model compression toolkit package in a Python>=3.9 environment w
 ```
 pip install model-compression-toolkit
 ```
-For installing the nightly version or installing from source, refer to the [installation guide](https://github.com/sony/model_optimization/blob/main/INSTALLATION.md).
+For installing the nightly version or installing from source, refer to the [installation guide](https://github.com/SonySemiconductorSolutions/mct-model-optimization/blob/main/INSTALLATION.md).
 
 **Important note**: In order to use MCT, you’ll need to provide a pre-trained floating point model (PyTorch/Keras) as an input.
 
@@ -104,6 +104,9 @@ Modify your model's quantization configuration for specific layers or apply a cu
 **🖥️ Visualization**. Observe useful information for troubleshooting the quantized model's performance using TensorBoard. [Read more](https://sonysemiconductorsolutions.github.io/mct-model-optimization/guidelines/visualization.html).
 
 **🔑 XQuant (Explainable Quantization)** [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sony/model_optimization/blob/main/tutorials/notebooks/mct_features_notebooks/pytorch/example_pytorch_xquant.ipynb). Get valuable insights regarding the quality and success of the quantization process of your model. The report includes histograms and similarity metrics between the original float model and the quantized model in key points of the model. The report can be visualized using TensorBoard.
+
+**🔑 XQuant Extension Tool.** Calculates the error for each layer by comparing the float model and quantized model, using both models along with the quantization log. The results are presented in reports. It identifies the causes of the detected errors and recommends appropriate improvement measures for each cause. [Read more](docs/guidelines/XQuant_Extension_Tool.html) [Troubleshoot Manual](docs/docs_troubleshoot/index.html)
+
 __________________________________________________________________________________________________________
 ### Enhanced Post-Training Quantization (EPTQ)
 As part of the GPTQ capability, we provide an advanced optimization algorithm called EPTQ.

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.4.0.20250925.543
+Version: 2.4.2.20250927.534
 Summary: A Model Compression Toolkit for neural networks
 Author-email: ssi-dnn-dev@sony.com
 Classifier: Programming Language :: Python :: 3
@@ -23,7 +23,7 @@ Requires-Dist: scipy
 Requires-Dist: protobuf
 Requires-Dist: mct-quantizers==1.6.0
 Requires-Dist: pydantic>=2.0
-Requires-Dist: edge-mdt-cl>=1.0
+Requires-Dist: edge-mdt-cl-dev
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
@@ -69,7 +69,7 @@ Pip install the model compression toolkit package in a Python>=3.9 environment w
 ```
 pip install model-compression-toolkit
 ```
-For installing the nightly version or installing from source, refer to the [installation guide](https://github.com/sony/model_optimization/blob/main/INSTALLATION.md).
+For installing the nightly version or installing from source, refer to the [installation guide](https://github.com/SonySemiconductorSolutions/mct-model-optimization/blob/main/INSTALLATION.md).
 
 **Important note**: In order to use MCT, you’ll need to provide a pre-trained floating point model (PyTorch/Keras) as an input.
 
@@ -139,6 +139,9 @@ Modify your model's quantization configuration for specific layers or apply a cu
 **🖥️ Visualization**. Observe useful information for troubleshooting the quantized model's performance using TensorBoard. [Read more](https://sonysemiconductorsolutions.github.io/mct-model-optimization/guidelines/visualization.html).
 
 **🔑 XQuant (Explainable Quantization)** [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sony/model_optimization/blob/main/tutorials/notebooks/mct_features_notebooks/pytorch/example_pytorch_xquant.ipynb). Get valuable insights regarding the quality and success of the quantization process of your model. The report includes histograms and similarity metrics between the original float model and the quantized model in key points of the model. The report can be visualized using TensorBoard.
+
+**🔑 XQuant Extension Tool.** Calculates the error for each layer by comparing the float model and quantized model, using both models along with the quantization log. The results are presented in reports. It identifies the causes of the detected errors and recommends appropriate improvement measures for each cause. [Read more](docs/guidelines/XQuant_Extension_Tool.html) [Troubleshoot Manual](docs/docs_troubleshoot/index.html)
+
 __________________________________________________________________________________________________________
 ### Enhanced Post-Training Quantization (EPTQ)
 As part of the GPTQ capability, we provide an advanced optimization algorithm called EPTQ.

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/mct_nightly.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ model_compression_toolkit/core/common/framework_info.py
 model_compression_toolkit/core/common/memory_computation.py
 model_compression_toolkit/core/common/model_builder_mode.py
 model_compression_toolkit/core/common/model_collector.py
+model_compression_toolkit/core/common/model_validation.py
 model_compression_toolkit/core/common/node_prior_info.py
 model_compression_toolkit/core/common/similarity_analyzer.py
 model_compression_toolkit/core/common/user_info.py
@@ -117,6 +118,7 @@ model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py
 model_compression_toolkit/core/common/quantization/node_quantization_config.py
 model_compression_toolkit/core/common/quantization/quantization_config.py
 model_compression_toolkit/core/common/quantization/quantization_fn_selection.py
+model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py
 model_compression_toolkit/core/common/quantization/quantize_graph_weights.py
 model_compression_toolkit/core/common/quantization/quantize_node.py
 model_compression_toolkit/core/common/quantization/set_node_quantization_config.py
@@ -166,6 +168,7 @@ model_compression_toolkit/core/keras/custom_layer_validation.py
 model_compression_toolkit/core/keras/data_util.py
 model_compression_toolkit/core/keras/default_framework_info.py
 model_compression_toolkit/core/keras/keras_implementation.py
+model_compression_toolkit/core/keras/keras_model_validation.py
 model_compression_toolkit/core/keras/keras_node_prior_info.py
 model_compression_toolkit/core/keras/resource_utilization_data_facade.py
 model_compression_toolkit/core/keras/tf_tensor_numpy.py
@@ -208,10 +211,9 @@ model_compression_toolkit/core/keras/mixed_precision/configurable_activation_qua
 model_compression_toolkit/core/keras/mixed_precision/configurable_weights_quantizer.py
 model_compression_toolkit/core/keras/pruning/__init__.py
 model_compression_toolkit/core/keras/pruning/pruning_keras_implementation.py
-model_compression_toolkit/core/keras/quantization/__init__.py
-model_compression_toolkit/core/keras/quantization/activation_quantization_fn_factory.py
-model_compression_toolkit/core/keras/quantization/fake_quant_builder.py
-model_compression_toolkit/core/keras/quantization/lut_fake_quant.py
+model_compression_toolkit/core/keras/quantizer/__init__.py
+model_compression_toolkit/core/keras/quantizer/fake_quant_builder.py
+model_compression_toolkit/core/keras/quantizer/lut_fake_quant.py
 model_compression_toolkit/core/keras/reader/__init__.py
 model_compression_toolkit/core/keras/reader/common.py
 model_compression_toolkit/core/keras/reader/connectivity_handler.py
@@ -279,10 +281,9 @@ model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_q
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quantizer.py
 model_compression_toolkit/core/pytorch/pruning/__init__.py
 model_compression_toolkit/core/pytorch/pruning/pruning_pytorch_implementation.py
-model_compression_toolkit/core/pytorch/quantization/__init__.py
-model_compression_toolkit/core/pytorch/quantization/activation_quantization_fn_factory.py
-model_compression_toolkit/core/pytorch/quantization/fake_quant_builder.py
-model_compression_toolkit/core/pytorch/quantization/lut_fake_quant.py
+model_compression_toolkit/core/pytorch/quantizer/__init__.py
+model_compression_toolkit/core/pytorch/quantizer/fake_quant_builder.py
+model_compression_toolkit/core/pytorch/quantizer/lut_fake_quant.py
 model_compression_toolkit/core/pytorch/reader/__init__.py
 model_compression_toolkit/core/pytorch/reader/graph_builders.py
 model_compression_toolkit/core/pytorch/reader/node_holders.py
@@ -438,8 +439,6 @@ model_compression_toolkit/qat/pytorch/quantizer/lsq/uniform_lsq.py
 model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/__init__.py
 model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/symmetric_ste.py
 model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/uniform_ste.py
-model_compression_toolkit/quantization_preparation/__init__.py
-model_compression_toolkit/quantization_preparation/load_fqc.py
 model_compression_toolkit/target_platform_capabilities/__init__.py
 model_compression_toolkit/target_platform_capabilities/constants.py
 model_compression_toolkit/target_platform_capabilities/immutable.py
@@ -515,26 +514,33 @@ model_compression_toolkit/trainable_infrastructure/pytorch/activation_quantizers
 model_compression_toolkit/xquant/__init__.py
 model_compression_toolkit/xquant/common/__init__.py
 model_compression_toolkit/xquant/common/constants.py
-model_compression_toolkit/xquant/common/core_report_generator.py
 model_compression_toolkit/xquant/common/dataset_utils.py
-model_compression_toolkit/xquant/common/framework_report_utils.py
 model_compression_toolkit/xquant/common/model_analyzer.py
 model_compression_toolkit/xquant/common/model_folding_utils.py
-model_compression_toolkit/xquant/common/similarity_calculator.py
 model_compression_toolkit/xquant/common/similarity_functions.py
 model_compression_toolkit/xquant/common/tensorboard_utils.py
 model_compression_toolkit/xquant/common/xquant_config.py
 model_compression_toolkit/xquant/keras/__init__.py
+model_compression_toolkit/xquant/keras/core_report_generator.py
 model_compression_toolkit/xquant/keras/dataset_utils.py
 model_compression_toolkit/xquant/keras/facade_xquant_report.py
+model_compression_toolkit/xquant/keras/framework_report_utils.py
 model_compression_toolkit/xquant/keras/keras_report_utils.py
 model_compression_toolkit/xquant/keras/model_analyzer.py
+model_compression_toolkit/xquant/keras/similarity_calculator.py
 model_compression_toolkit/xquant/keras/similarity_functions.py
 model_compression_toolkit/xquant/keras/tensorboard_utils.py
 model_compression_toolkit/xquant/pytorch/__init__.py
+model_compression_toolkit/xquant/pytorch/core_detect_degrade_layer.py
+model_compression_toolkit/xquant/pytorch/core_judge_troubleshoot.py
+model_compression_toolkit/xquant/pytorch/core_report_generator.py
 model_compression_toolkit/xquant/pytorch/dataset_utils.py
+model_compression_toolkit/xquant/pytorch/detect_degrade_utils.py
 model_compression_toolkit/xquant/pytorch/facade_xquant_report.py
+model_compression_toolkit/xquant/pytorch/framework_report_utils.py
+model_compression_toolkit/xquant/pytorch/judge_troubleshoot_utils.py
 model_compression_toolkit/xquant/pytorch/model_analyzer.py
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py
+model_compression_toolkit/xquant/pytorch/similarity_calculator.py
 model_compression_toolkit/xquant/pytorch/similarity_functions.py
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/mct_nightly.egg-info/requires.txt

@@ -11,4 +11,4 @@ scipy
 protobuf
 mct-quantizers==1.6.0
 pydantic>=2.0
-edge-mdt-cl>=1.0
+edge-mdt-cl-dev

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/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.4.0.20250925.000543"
+__version__ = "2.4.2.20250927.000534"

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/model_compression_toolkit/core/analyzer.py

@@ -32,7 +32,8 @@ def analyzer_model_quantization(representative_data_gen: Callable,
                                 tb_w: TensorboardWriter,
                                 float_graph: Graph,
                                 quantized_graph: Graph,
-                                fw_impl: FrameworkImplementation):
+                                fw_impl: FrameworkImplementation,
+                                fw_info: FrameworkInfo):
     """
     Plot the cosine similarity of different points on the graph between the float and quantized
     graphs. Add them to the passed TensorboardWriter object and close all tensorboard writer open
@@ -44,12 +45,14 @@ def analyzer_model_quantization(representative_data_gen: Callable,
         float_graph: Graph of float model.
         quantized_graph: Graph of quantized model.
         fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+        fw_info: Information needed for quantization about the specific framework.
 
     """
     if tb_w is not None:
         visual = NNVisualizer(float_graph,
                               quantized_graph,
-                              fw_impl=fw_impl)
+                              fw_impl=fw_impl,
+                              fw_info=fw_info)
         if not visual.has_compare_points():
             Logger.error(f'No comparing points were found to plot analyze similarity.')
         else:

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/model_compression_toolkit/core/common/back2framework/base_model_builder.py

@@ -15,6 +15,7 @@
 from abc import ABC, abstractmethod
 from typing import Any, Tuple
 
+from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common.user_info import UserInformation
 
@@ -27,17 +28,20 @@ class BaseModelBuilder(ABC):
     def __init__(self,
                  graph: common.Graph,
                  append2output=None,
+                 fw_info: FrameworkInfo = None,
                  return_float_outputs: bool = False):
         """
 
         Args:
             graph: Graph to build the model from.
             append2output: Nodes of graph to append to model's output.
+            fw_info: Information about the specific framework of the model that is built.
             return_float_outputs: Whether the model returns float tensors or not.
         """
 
         self.graph = graph
         self.append2output = append2output
+        self.fw_info = fw_info
         self.return_float_outputs = return_float_outputs
 
     @abstractmethod

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/model_compression_toolkit/core/common/collectors/base_collector.py

@@ -13,12 +13,11 @@
 # limitations under the License.
 # ==============================================================================
 
-from abc import ABC, abstractmethod
 import numpy as np
 from model_compression_toolkit.logger import Logger
 
 
-class BaseCollector(ABC):
+class BaseCollector(object):
     """
     Base class for statistics collection object.
     """
@@ -27,7 +26,6 @@ class BaseCollector(ABC):
         # When manipulation statistics in a granularity they were not collected by, the data is invalid.
         self.is_legal = True
 
-    @abstractmethod
     def scale(self, scale_factor: np.ndarray):
         """
         Scale all statistics in collector by some factor.
@@ -39,7 +37,6 @@ class BaseCollector(ABC):
         raise NotImplemented(
             f'{self.__class__.__name__} needs to implement scale operation for its state.')  # pragma: no cover
 
-    @abstractmethod
     def shift(self, shift_value: np.ndarray):
         """
         Shift all statistics in collector by some value.

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/model_compression_toolkit/core/common/collectors/mean_collector.py

@@ -87,13 +87,10 @@ class MeanCollector(BaseCollector):
             x: Tensor that goes through the mean collector and needs to be considered in the mean computation.
         """
         self.i += 1  # Update the iteration index
-        if self.axis is None:
-            mu = np.mean(np.reshape(x, [1, -1]), axis=-1)  # mean per channel for a batch
-        else:
-            axis = (len(x.shape) - 1) if self.axis == LAST_AXIS else self.axis
-            n = x.shape[axis]
-            transpose_index = [axis, *[i for i in range(len(x.shape)) if i != axis]]
-            mu = np.mean(np.reshape(np.transpose(x, transpose_index), [n, -1]), axis=-1) # mean per channel for a batch
+        axis = (len(x.shape) - 1) if self.axis == LAST_AXIS else self.axis
+        n = x.shape[axis]
+        transpose_index = [axis, *[i for i in range(len(x.shape)) if i != axis]]
+        mu = np.mean(np.reshape(np.transpose(x, transpose_index), [n, -1]), axis=-1) # mean per channel for a batch
         self.current_sum += mu # sum of all batches
         self.current_mean = self.current_sum / self.i # mean of all batches
 

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/model_compression_toolkit/core/common/collectors/min_max_per_channel_collector.py

@@ -130,13 +130,10 @@ class MinMaxPerChannelCollector(BaseCollector):
             x: Tensor that goes through the collector and needs to be considered in the min/max computation.
         """
 
-        if self.axis is None:
-            x_reshape = np.reshape(x, [1, -1])
-        else:
-            axis = (len(x.shape) - 1) if self.axis == LAST_AXIS else self.axis
-            n = x.shape[axis]
-            transpose_index = [axis, *[i for i in range(len(x.shape)) if i != axis]]
-            x_reshape = np.reshape(np.transpose(x, transpose_index), [n, -1])
+        axis = (len(x.shape) - 1) if self.axis == LAST_AXIS else self.axis
+        n = x.shape[axis]
+        transpose_index = [axis, *[i for i in range(len(x.shape)) if i != axis]]
+        x_reshape = np.reshape(np.transpose(x, transpose_index), [n, -1])
         if self.state is None:
             x_max = np.max(x_reshape, axis=-1)
             x_min = np.min(x_reshape, axis=-1)

{mct_nightly-2.4.0.20250925.543 → mct_nightly-2.4.2.20250927.534}/model_compression_toolkit/core/common/framework_implementation.py

@@ -125,16 +125,18 @@ class FrameworkImplementation(ABC):
                       graph: Graph,
                       mode: ModelBuilderMode,
                       append2output: List[Any],
+                      fw_info: FrameworkInfo,
                       return_float_outputs: bool = False) -> Tuple:
         """
         Build a framework model from a graph.
-        The mode determines how the model should be built. append2output is a list of Nodes
+        The mode determines how the model should be build. append2output is a list of Nodes
         to set as the model outputs.
 
         Args:
             graph: Graph to build the model from it.
             mode: Mode for how to build the model.
             append2output: List of Nodes to set as the model's outputs.
+            fw_info: FrameworkInfo object with information about the specific framework's model
             return_float_outputs (bool): whether to return outputs before or after quantization nodes (default)
 
         Returns:
@@ -168,13 +170,15 @@ class FrameworkImplementation(ABC):
     @abstractmethod
     def shift_negative_correction(self,
                                   graph: Graph,
-                                  core_config: CoreConfig) -> Graph:
+                                  core_config: CoreConfig,
+                                  fw_info: FrameworkInfo) -> Graph:
         """
         Apply shift negative correction (SNC) on a graph.
 
         Args:
             graph: Graph to apply SNC on.
             core_config: Quantization configuration.
+            fw_info: FrameworkInfo object with information about the specific framework's model.
 
         Returns:
             Graph after SNC.
@@ -185,13 +189,15 @@ class FrameworkImplementation(ABC):
     @abstractmethod
     def compute_activation_bias_correction(self,
                                            graph: Graph,
-                                           quant_config: QuantizationConfig) -> Graph:
+                                           quant_config: QuantizationConfig,
+                                           fw_info: FrameworkInfo) -> Graph:
         """
         Compute activation bias correction on a graph.
 
         Args:
             graph: Graph to apply activation bias correction on.
             quant_config: QuantizationConfig of how the model should be quantized.
+            fw_info: FrameworkInfo object with information about the specific framework's model.
 
         Returns:
             Graph after activation bias correction computing.
@@ -201,28 +207,30 @@ class FrameworkImplementation(ABC):
 
     @abstractmethod
     def get_substitutions_channel_equalization(self,
-                                               quant_config: QuantizationConfig) -> List[common.BaseSubstitution]:
+                                               quant_config: QuantizationConfig,
+                                               fw_info: FrameworkInfo) -> List[common.BaseSubstitution]:
         """
         Return a list of the framework substitutions used for channel equalization.
 
         Args:
             quant_config: QuantizationConfig to determine which substitutions to return.
+            fw_info: FrameworkInfo object with information about the specific framework's model.
 
         Returns:
             A list of the framework substitutions used after we collect statistics.
         """
         raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
-                                  f'framework\'s get_substitutions_channel_equalization method.')  # pragma: no cover
+                             f'framework\'s get_substitutions_channel_equalization method.')  # pragma: no cover
 
     @abstractmethod
-    def get_substitutions_prepare_graph(self) -> List[common.BaseSubstitution]:
+    def get_substitutions_prepare_graph(self, fw_info: FrameworkInfo = None) -> List[common.BaseSubstitution]:
         """
 
         Returns: A list of the framework substitutions used to prepare the graph.
 
         """
         raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
-                                  f'framework\'s get_substitutions_prepare_graph method.')  # pragma: no cover
+                             f'framework\'s get_substitutions_prepare_graph method.')  # pragma: no cover
 
     @abstractmethod
     def get_substitutions_pre_statistics_collection(self, quant_config: QuantizationConfig) -> \
@@ -320,12 +328,14 @@ class FrameworkImplementation(ABC):
                              f'method.')  # pragma: no cover
 
     def get_node_prior_info(self, node: BaseNode,
+                            fw_info: FrameworkInfo,
                             graph: Graph) -> NodePriorInfo:
         """
         Get a NodePriorInfo object for a node.
 
         Args:
             node: Node to get its prior info.
+            fw_info: Framework specific information needed to create the prior info of the node.
             graph: Graph to check the next node type.
 
         Returns:
@@ -333,7 +343,7 @@ class FrameworkImplementation(ABC):
         """
 
         raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
-                                  f'framework\'s get_node_prior_info method.')  # pragma: no cover
+                             f'framework\'s get_node_prior_info method.')  # pragma: no cover
 
     def count_node_for_mixed_precision_interest_points(self, node: BaseNode) -> bool:
         """
@@ -384,18 +394,20 @@ class FrameworkImplementation(ABC):
 
     @abstractmethod
     def get_node_mac_operations(self,
-                                node: BaseNode) -> float:
+                                node: BaseNode,
+                                fw_info: FrameworkInfo) -> float:
         """
         Gets the MAC operation count for a given operation.
 
         Args:
             node: A graph node that wraps the operation for which the MAC count is computed.
+            fw_info: FrameworkInfo object with information about the specific framework's model.
 
         Returns: The MAC count of the operation
         """
 
         raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
-                                  f'framework\'s get_node_mac_operations method.')  # pragma: no cover
+                             f'framework\'s get_node_mac_operations method.')  # pragma: no cover
 
     @abstractmethod
     def apply_second_moment_correction(self,

mct_nightly-2.4.2.20250927.534/model_compression_toolkit/core/common/framework_info.py

@@ -0,0 +1,150 @@
+# 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 collections.abc import Callable
+from enum import Enum
+from typing import Dict, Any, List
+
+from mct_quantizers import QuantizationMethod
+from model_compression_toolkit.defaultdict import DefaultDict
+
+
+# Default value to use for ops without kernel.
+# This is a weird default, but it's used all over the place, so for now only extract it to const so that it can be
+# referenced by variable instead of hard-coded.
+DEFAULT_KERNEL_ATTRIBUTES = [None]
+
+
+class ChannelAxis(Enum):
+    """
+
+    Index of output channels axis:
+
+    NHWC - Output channels index is last.
+
+    NCHW - Output channels index is 1.
+
+    """
+    NHWC = -1
+    NCHW = 1
+
+
+class FrameworkInfo:
+
+    def __init__(self,
+                 activation_quantizer_mapping: Dict[QuantizationMethod, Callable],
+                 kernel_channels_mapping: DefaultDict,
+                 activation_min_max_mapping: Dict[str, tuple],
+                 layer_min_max_mapping: Dict[Any, tuple],
+                 kernel_ops_attributes_mapping: DefaultDict,
+                 out_channel_axis_mapping: DefaultDict):
+        """
+        A class to wrap all information about a specific framework the library needs to quantize a model.
+        Specifically, FrameworkInfo holds lists of layers by how they should be quantized, and multiple mappings such as
+        layer to it kernel channels indices, and a layer to its min/max values, etc.
+        The layers lists are divided into three groups:
+        kernel_ops: Layers that have coefficients and need to get quantized (e.g., Conv2D, Dense, etc.)
+        activation_ops: Layers that their outputs should get quantized (e.g., Add, ReLU, etc.)
+        no_quantization_ops:Layers that should not get quantized (e.g., Reshape, Transpose, etc.)
+
+        Args:
+            activation_quantizer_mapping (Dict[QuantizationMethod, Callable]): A dictionary mapping from QuantizationMethod to a quantization function.
+            kernel_channels_mapping (DefaultDict): Dictionary from a layer to a tuple of its kernel in/out channels indices.
+            activation_min_max_mapping (Dict[str, tuple]): Dictionary from an activation function to its min/max output values.
+            layer_min_max_mapping (Dict[Any, tuple]): Dictionary from a layer to its min/max output values.
+            kernel_ops_attributes_mapping (DefaultDict): Dictionary from a framework operator to a list of its weights attirbutes to quantize.
+            out_channel_axis_mapping (DefaultDict): Dictionary of output channels of the model's layers (for computing statistics per-channel).
+
+        Examples:
+            When quantizing a Keras model, if we want to quantize the kernels of Conv2D layers only, we can
+            set, and we know it's kernel out/in channel indices are (3, 2) respectivly:
+
+            >>> import tensorflow as tf
+            >>> kernel_ops = [tf.keras.layers.Conv2D]
+            >>> kernel_channels_mapping = DefaultDict({tf.keras.layers.Conv2D: (3,2)})
+
+            Then, we can create a FrameworkInfo object:
+
+            >>> FrameworkInfo(kernel_channels_mapping, {}, {})
+
+            If an activation layer (tf.keras.layers.Activation) should be quantized and we know it's min/max outputs range in advanced, we can add it to activation_min_max_mapping for saving the statistics collection time. For example:
+
+            >>> activation_min_max_mapping = {'softmax': (0, 1)}
+            >>> FrameworkInfo(kernel_channels_mapping, activation_min_max_mapping, {})
+
+            If a layer's activations should be quantized and we know it's min/max outputs range in advanced, we can add it to layer_min_max_mapping for saving the statistics collection time. For example:
+
+            >>> layer_min_max_mapping = {tf.keras.layers.Softmax: (0, 1)}
+            >>> FrameworkInfo(kernel_channels_mapping, activation_min_max_mapping, layer_min_max_mapping)
+
+        """
+
+        self.activation_quantizer_mapping = activation_quantizer_mapping
+        self.kernel_channels_mapping = kernel_channels_mapping
+        self.activation_min_max_mapping = activation_min_max_mapping
+        self.layer_min_max_mapping = layer_min_max_mapping
+        self.kernel_ops_attributes_mapping = kernel_ops_attributes_mapping
+        self.out_channel_axis_mapping = out_channel_axis_mapping
+
+    def get_kernel_op_attributes(self, node_type: Any) -> List[str]:
+        """
+        Get a list of attributes of a layer's weights to quantize.
+
+        Args:
+            node_type: Layer to get its attributes.
+
+        Returns:
+            A list of attributes the layer has and should be quantized.
+        """
+        attr_list = self.kernel_ops_attributes_mapping.get(node_type)
+        return attr_list
+
+    def is_kernel_op(self, node_type: Any) -> bool:
+        """
+        Check is the node is a kernel operation.
+
+        Args:
+            node_type: Layer to get its attributes.
+
+        Returns:
+            True if node type is a kernel operation, else False.
+        """
+        return node_type in self.kernel_ops_attributes_mapping.keys()
+
+    def layers_has_min_max(self, layer: Any) -> bool:
+        """
+        Check if a layer is in a layer to min/max mapping the FrameworkInfo holds.
+        Args:
+            layer: A layer to check if has a min/max known values.
+
+        Returns:
+            Whether a layer has a min/max known values or not.
+        """
+
+        return layer in self.layer_min_max_mapping
+
+    def activation_has_min_max(self, activation_name: str) -> bool:
+        """
+        Check if an activation layer has a min/max mapping.
+
+        Args:
+            activation_name: String of the activation function to check for its min/max values.
+
+        Returns:
+            Whether an activation layer has a min/max known values or not.
+        """
+
+        return activation_name in self.activation_min_max_mapping