mct-nightly 2.3.0.20250407.1120__tar.gz → 2.3.0.20250409.529__tar.gz

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/PKG-INFO

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

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/mct_nightly.egg-info/PKG-INFO

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

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/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.3.0.20250407.001120"
+__version__ = "2.3.0.20250409.000529"

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/fusion/fusing_info.py

@@ -150,7 +150,6 @@ class FusingInfo:
         """
         return self.fusing_data
 
-
     @staticmethod
     def generate_fused_op_id(nodes: List['BaseNode']) -> str:
         """
@@ -166,7 +165,7 @@ class FusingInfo:
         id = FUSED_OP_ID_PREFIX + '_'.join([node.name for node in nodes])
         return id
 
-    def validate(self, graph) -> None:
+    def validate(self, graph: 'Graph') -> None:
         """
         Validate that the fusing information is consistent with the given graph and generation logic.
 
@@ -267,7 +266,7 @@ class FusingInfoGenerator:
     def __init__(self, fusing_patterns):
         self._fusing_patterns = fusing_patterns
 
-    def generate_fusing_info(self, graph) -> FusingInfo:
+    def generate_fusing_info(self, graph: 'Graph') -> FusingInfo:
         """
         Generate fusing information based on the graph and fusing patterns.
 
@@ -289,7 +288,7 @@ class FusingInfoGenerator:
             return FusingInfo(fusing_patterns=self._fusing_patterns)
 
         # Find max fusion
-        max_layers_fusing = 0 if len(self._fusing_patterns) == 0 else max([len(fusing_pattern) for fusing_pattern in self._fusing_patterns])
+        max_layers_fusing = max([len(fusing_pattern) for fusing_pattern in self._fusing_patterns])
 
         # Travel along the graph to find layers for fusing
         nodes = graph.get_topo_sorted_nodes()
@@ -331,7 +330,7 @@ def get_valid_fusing_patterns_for_node(fusing_patterns: List[List[Any]],
     Returns only the fusing patterns where a specific layer (at index idx) matches the given node — either by type or filter params.
 
     Args:
-        fusing_patterns: supported fusings
+        fusing_patterns: supported fusing patterns
         node: node to decide if it can be a part of fusion
         idx: index of layer in the fusion
 

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/graph/base_graph.py

@@ -33,6 +33,7 @@ from model_compression_toolkit.core.common.collectors.statistics_collector impor
 from model_compression_toolkit.core.common.collectors.statistics_collector import scale_statistics, shift_statistics
 from model_compression_toolkit.core.common.pruning.pruning_section import PruningSection
 from model_compression_toolkit.core.common.user_info import UserInformation
+from model_compression_toolkit.core.common.quantization.node_quantization_config import ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
@@ -920,7 +921,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         nodes_to_disable = [node for nodes in self.fusing_info.get_all_fused_operations().values() for node in nodes[:-1]]
         for node in nodes_to_disable:
             for qc in node.candidates_quantization_cfg:
-                qc.activation_quantization_cfg.enable_activation_quantization = False
+                qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.FLN_QUANT
 
     def validate(self):
         """

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/graph/base_node.py

@@ -20,7 +20,8 @@ import numpy as np
 
 from model_compression_toolkit.constants import WEIGHTS_NBITS_ATTRIBUTE, CORRECTED_BIAS_ATTRIBUTE, \
     ACTIVATION_N_BITS_ATTRIBUTE, FP32_BYTES_PER_PARAMETER
-from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import QuantizationConfigOptions, \
     OpQuantizationConfig
@@ -116,33 +117,28 @@ class BaseNode:
         """
         return any(isinstance(key, int) for key in self.weights.keys())
 
+    def _is_single_quant_mode(self, q_mode: ActivationQuantizationMode) -> bool:
+        """ Check whether all candidates have the same unique quantization mode, and if it is 'q_mode'. """
+
+        if self.final_activation_quantization_cfg:
+            # if we have a final configuration, then we only care to check if it enables activation quantization.
+            return self.final_activation_quantization_cfg.quant_mode == q_mode
+
+        q_modes = {qc.activation_quantization_cfg.quant_mode for qc in self.candidates_quantization_cfg}
+        assert len(q_modes) == 1
+        return q_modes.pop() == q_mode
+
     def is_activation_quantization_enabled(self) -> bool:
         """
-
         Returns: Whether node activation quantization is enabled or not.
-
         """
-        if self.final_activation_quantization_cfg:
-            # if we have a final configuration, then we only care to check if it enables activation quantization
-            return self.final_activation_quantization_cfg.enable_activation_quantization
-
-        for qc in self.candidates_quantization_cfg:
-            assert self.candidates_quantization_cfg[0].activation_quantization_cfg.enable_activation_quantization == \
-                   qc.activation_quantization_cfg.enable_activation_quantization
-        return self.candidates_quantization_cfg[0].activation_quantization_cfg.enable_activation_quantization
+        return self._is_single_quant_mode(ActivationQuantizationMode.QUANT)
 
     def is_quantization_preserving(self) -> bool:
         """
         Returns: Whether node activation quantization information is preserved from its inputs.
         """
-        if self.final_activation_quantization_cfg:
-            # if we have a final configuration, then we only care to check if it enables activation quantization.
-            return self.final_activation_quantization_cfg.quantization_preserving
-
-        for qc in self.candidates_quantization_cfg:
-            assert self.candidates_quantization_cfg[0].activation_quantization_cfg.quantization_preserving == \
-                   qc.activation_quantization_cfg.quantization_preserving
-        return self.candidates_quantization_cfg[0].activation_quantization_cfg.quantization_preserving
+        return self._is_single_quant_mode(ActivationQuantizationMode.PRESERVE_QUANT)
 
     def is_weights_quantization_enabled(self, attr_name: str) -> bool:
         """

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -31,7 +31,7 @@ from model_compression_toolkit.core.common.graph.virtual_activation_weights_node
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
     RUTarget, ResourceUtilization
 from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig, \
-    NodeActivationQuantizationConfig, BaseNodeQuantizationConfig
+    NodeActivationQuantizationConfig, BaseNodeQuantizationConfig, ActivationQuantizationMode
 from model_compression_toolkit.core.common.substitutions.virtual_activation_weights_composition import \
     get_input_activation_if_composable
 
@@ -710,7 +710,7 @@ class ResourceUtilizationCalculator:
         """
         if act_qc:
             assert bitwidth_mode == BitwidthMode.QCustom
-            return act_qc.activation_n_bits if act_qc.enable_activation_quantization else FLOAT_BITWIDTH
+            return act_qc.activation_n_bits if act_qc.quant_mode == ActivationQuantizationMode.QUANT else FLOAT_BITWIDTH
 
         if bitwidth_mode == BitwidthMode.Float or not (n.is_activation_quantization_enabled() or
                                                        n.is_quantization_preserving()):

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py

@@ -20,6 +20,7 @@ from typing import Callable, Any, List, Tuple
 from model_compression_toolkit.constants import AXIS
 from model_compression_toolkit.core import FrameworkInfo, MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common import Graph, BaseNode
+from model_compression_toolkit.core.common.quantization.node_quantization_config import ActivationQuantizationMode
 from model_compression_toolkit.core.common.graph.functional_node import FunctionalNode
 from model_compression_toolkit.core.common.similarity_analyzer import compute_kl_divergence
 from model_compression_toolkit.core.common.model_builder_mode import ModelBuilderMode
@@ -207,7 +208,7 @@ class SensitivityEvaluation:
         if self.disable_activation_for_metric:
             for n in evaluation_graph.get_topo_sorted_nodes():
                 for c in n.candidates_quantization_cfg:
-                    c.activation_quantization_cfg.enable_activation_quantization = False
+                    c.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
 
         model_mp, _, conf_node2layers = self.fw_impl.model_builder(evaluation_graph,
                                                                    mode=ModelBuilderMode.MIXEDPRECISION,

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -15,7 +15,7 @@
 
 
 from typing import Callable, Any, List, Tuple, Union, Dict, TYPE_CHECKING
-
+from enum import Enum, auto
 import numpy as np
 
 from model_compression_toolkit.core.common.quantization.quantization_fn_selection import get_weights_quantization_fn
@@ -40,6 +40,14 @@ if TYPE_CHECKING:
 ##########################################
 
 
+class ActivationQuantizationMode(Enum):
+    """ An enum defining the output activation quantization mode of  a node. """
+    QUANT = auto()
+    FLN_QUANT = auto()
+    PRESERVE_QUANT = auto()
+    NO_QUANT = auto()
+
+
 class BaseNodeQuantizationConfig(object):
     """
     Base class for node quantization configuration
@@ -100,8 +108,14 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         self.activation_n_bits = op_cfg.activation_n_bits
         self.relu_bound_to_power_of_2 = qc.relu_bound_to_power_of_2
         self.activation_bias_correction_term = None
-        self.enable_activation_quantization = op_cfg.enable_activation_quantization
-        self.quantization_preserving = op_cfg.quantization_preserving
+        if op_cfg.enable_activation_quantization and op_cfg.quantization_preserving:
+            raise ValueError("An OpQuantizationConfig can't have both enable_activation_quantization and quantization_preserving enabled.")
+        if op_cfg.enable_activation_quantization:
+            self.quant_mode = ActivationQuantizationMode.QUANT
+        elif op_cfg.quantization_preserving:
+            self.quant_mode = ActivationQuantizationMode.PRESERVE_QUANT
+        else:
+            self.quant_mode = ActivationQuantizationMode.NO_QUANT
         self.signedness = op_cfg.signedness
         self.activation_channel_equalization = qc.activation_channel_equalization
         self.input_scaling = qc.input_scaling
@@ -113,6 +127,17 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
         self.shift_negative_threshold_recalculation = qc.shift_negative_threshold_recalculation
         self.concat_threshold_update = qc.concat_threshold_update
 
+    @property
+    def enable_activation_quantization(self):
+        return self.quant_mode == ActivationQuantizationMode.QUANT
+
+    @property
+    def quantization_preserving(self):
+        return self.quant_mode == ActivationQuantizationMode.PRESERVE_QUANT
+
+    def fln_quantization(self):
+        return self.quant_mode == ActivationQuantizationMode.FLN_QUANT
+
     def quantize_node_output(self,
                              tensors: Any) -> Any:
         """
@@ -181,7 +206,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
             activation_params: Dictionary that contains weight quantization params.
 
         """
-        assert self.enable_activation_quantization
+        assert self.quant_mode == ActivationQuantizationMode.QUANT
         for param_name, param_value in activation_params.items():
             self.activation_quantization_params[param_name] = param_value
 
@@ -203,7 +228,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
                self.activation_error_method == other.activation_error_method and \
                self.activation_quantization_method == other.activation_quantization_method and \
                self.activation_n_bits == other.activation_n_bits and \
-               self.enable_activation_quantization == other.enable_activation_quantization and \
+               self.quant_mode == other.quant_mode and \
                self.activation_channel_equalization == other.activation_channel_equalization and \
                self.input_scaling == other.input_scaling and \
                self.min_threshold == other.min_threshold and \
@@ -219,7 +244,7 @@ class NodeActivationQuantizationConfig(BaseNodeQuantizationConfig):
                      self.activation_error_method,
                      self.activation_quantization_method,
                      self.activation_n_bits,
-                     self.enable_activation_quantization,
+                     self.quant_mode,
                      self.activation_channel_equalization,
                      self.input_scaling,
                      self.min_threshold,
@@ -412,17 +437,12 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                 # If no specific positional attribute config is found, fall back to the default weight attribute config.
                 if len(attrs_included_in_name) == 0:
                     attr_cfg = op_cfg.default_weight_attr_config
-                    # Register this attribute under the positional attributes config mapping.
-                    self.pos_attributes_config_mapping[attr] = WeightsAttrQuantizationConfig(qc=qc,
-                                                                                             weights_attr_cfg=attr_cfg,
-                                                                                             weights_channels_axis=
-                                                                                             weights_channels_axis)
                 else:
                     # If a specific config was found using POS_ATTR, use it.
                     attr_cfg = list(attrs_included_in_name.values())[0]
 
-                    # Register this attribute under the regular attributes config mapping.
-                    self.attributes_config_mapping[attr] = WeightsAttrQuantizationConfig(qc=qc,
+                # Register this attribute under the positional attributes config mapping.
+                self.pos_attributes_config_mapping[attr] = WeightsAttrQuantizationConfig(qc=qc,
                                                                                          weights_attr_cfg=attr_cfg,
                                                                                          weights_channels_axis=
                                                                                          weights_channels_axis)

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -25,7 +25,8 @@ from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import \
     CandidateNodeQuantizationConfig
-from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeActivationQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeActivationQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig, \
     QuantizationErrorMethod
 from model_compression_toolkit.core.common.quantization.quantization_params_fn_selection import \
@@ -191,8 +192,9 @@ def set_quantization_configs_to_node(node: BaseNode,
     node.sort_node_candidates(fw_info)
 
     for candidate_qc in node.candidates_quantization_cfg:
-        candidate_qc.activation_quantization_cfg.enable_activation_quantization = \
-            candidate_qc.activation_quantization_cfg.enable_activation_quantization and node.get_has_activation()
+        if candidate_qc.activation_quantization_cfg.quant_mode == ActivationQuantizationMode.QUANT and \
+                not node.get_has_activation():
+            candidate_qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
 
 
 def create_node_activation_qc(qc: QuantizationConfig,

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/statistics_correction/compute_activation_bias_correction_of_graph.py

@@ -45,8 +45,7 @@ def get_previous_node_with_activation_quantization(linear_node: BaseNode,
     activation_quantization_config = prev_node.final_activation_quantization_cfg
 
     # Search for node with activation quantization
-    if (activation_quantization_config.enable_activation_quantization and
-            not activation_quantization_config.quantization_preserving):
+    if activation_quantization_config.enable_activation_quantization:
         return prev_node
     else:
         return get_previous_node_with_activation_quantization(prev_node, graph)

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py

@@ -22,7 +22,8 @@ import numpy as np
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
 from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
@@ -127,7 +128,7 @@ class BatchNormalizationReconstruction(common.BaseSubstitution):
         bn_node.candidates_quantization_cfg = copy.deepcopy(source_node.candidates_quantization_cfg)
 
         for qc in bn_node.candidates_quantization_cfg:
-            qc.activation_quantization_cfg.enable_activation_quantization = False
+            qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
             for attr in bn_node.get_node_weights_attributes():
                 if qc.weights_quantization_cfg.has_attribute_config(attr):
                     # we only create a BN layer to collect statistics, so we don't need to quantize anything,

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -17,7 +17,8 @@ import numpy as np
 from typing import List, Tuple, Any, Callable
 
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
-from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
+from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig, \
+    ActivationQuantizationMode
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common import FrameworkInfo, Graph, BaseNode
 from model_compression_toolkit.constants import THRESHOLD, SIGNED, SHIFT_NEGATIVE_NON_LINEAR_NUM_BITS
@@ -363,7 +364,7 @@ def shift_negative_function(graph: Graph,
                                          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
+            candidate_qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
             for attr in pad_node.get_node_weights_attributes():
                 candidate_qc.weights_quantization_cfg.get_attr_config(attr).enable_weights_quantization = False
 

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/keras/mixed_precision/configurable_activation_quantizer.py

@@ -64,8 +64,7 @@ class ConfigurableActivationQuantizer(BaseKerasInferableQuantizer):
         verify_candidates_descending_order(self.node_q_cfg, kernel_attr)
 
         for qc in node_q_cfg:
-            if qc.activation_quantization_cfg.enable_activation_quantization != \
-                    node_q_cfg[0].activation_quantization_cfg.enable_activation_quantization:
+            if qc.activation_quantization_cfg.quant_mode != node_q_cfg[0].activation_quantization_cfg.quant_mode:
                 Logger.critical("Unsupported configuration: Mixing candidates with differing activation quantization states (enabled/disabled).")  # pragma: no cover
 
         self.activation_quantizers = init_activation_quantizers(self.node_q_cfg)

{mct_nightly-2.3.0.20250407.1120 → mct_nightly-2.3.0.20250409.529}/model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_quantizer.py

@@ -63,8 +63,7 @@ class ConfigurableActivationQuantizer(BasePyTorchInferableQuantizer):
         verify_candidates_descending_order(self.node_q_cfg, kernel_attr)
 
         for qc in self.node_q_cfg:
-            if qc.activation_quantization_cfg.enable_activation_quantization != \
-                   self.node_q_cfg[0].activation_quantization_cfg.enable_activation_quantization:
+            if qc.activation_quantization_cfg.quant_mode != self.node_q_cfg[0].activation_quantization_cfg.quant_mode:
                 Logger.critical("Unsupported configuration: Mixing candidates with differing activation quantization states (enabled/disabled).")  # pragma: no cover
 
         # Setting layer's activation