mct-nightly 2.3.0.20250421.604__py3-none-any.whl → 2.3.0.20250423.537__py3-none-any.whl

{mct_nightly-2.3.0.20250421.604.dist-info → mct_nightly-2.3.0.20250423.537.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250421.604
+Version: 2.3.0.20250423.537
 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.20250421.604.dist-info → mct_nightly-2.3.0.20250423.537.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mct_nightly-2.3.0.20250421.604.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=wnmK1gqXxy1bGqYedwsyNhvn4OUAZel25ytzES08fmk,1557
+mct_nightly-2.3.0.20250423.537.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=NXqhvuAEHQlzpdJpTtyy1rDJW2gxmMwEGZvHIBQE_f0,1557
 model_compression_toolkit/constants.py,sha256=iJ6vfTjC2oFIZWt8wvHoxEw5YJi3yl0Hd4q30_8q0Zc,3958
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
@@ -34,7 +34,7 @@ model_compression_toolkit/core/common/fusion/__init__.py,sha256=Rf1RcYmelmdZmBV5
 model_compression_toolkit/core/common/fusion/fusing_info.py,sha256=W8qZejLwbm-lkvNF3GepNL3ypO10vFRxOxbq-o_rt_I,15479
 model_compression_toolkit/core/common/fusion/graph_fuser.py,sha256=F0AaAUBpJ9JjHMB5H2LD9pdwTSWJK-Kqm9dQmGHX1Jo,7368
 model_compression_toolkit/core/common/graph/__init__.py,sha256=Xr-Lt_qXMdrCnnOaUS_OJP_3iTTGfPCLf8_vSrQgCs0,773
-model_compression_toolkit/core/common/graph/base_graph.py,sha256=2aRpL8OP-JWKc2XFdsAQjACthJZmS8zgwIX-wjBRCFQ,41383
+model_compression_toolkit/core/common/graph/base_graph.py,sha256=BSQpKy0BXoGX0G0bySTo72n2isTqvtpkbRYYa8-hPO4,41435
 model_compression_toolkit/core/common/graph/base_node.py,sha256=AbUadAT581zelVcGcK9_--6CAGiht9qwkeWahwT3RzE,33389
 model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-GeDaUA1SDdOHxDpxU_bGpk,3784
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=GH5wStmw8SoAj5IdT_-ItN1Meo_P5NUTt_5bgJC4fak,3935
@@ -75,10 +75,10 @@ model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,s
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=S1ChgxtUjzXJufNWyRbKoNdyNC6fGUjPeComDMx8ZCo,9479
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py,sha256=PKkhc5q8pEPnNLXwo3U56EOCfYnPXIvPs0LlCGZOoKU,4426
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=cjFnpDvxZDE4K2sgt26DhosA2XqhxHDs0eW5Qe7AwAQ,40668
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=D2sNbTPMDsDyUE18NUpVJN27AgdwwhpdOJ8UMLmhdPA,40420
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=QQwtl08DiDxUOQGpYPnek_RlZjWm1Ky7tL2ESHXMK78,4050
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
-model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=32s620FyREMBJYx3AUp6umlRfHxjqhL31PRbVtLdMJ4,6664
+model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=6Z6nQL9UH7B8dbcUR0cuCTEYFOKZAlvOb-SCk_cAZFA,6670
 model_compression_toolkit/core/common/network_editors/__init__.py,sha256=vZmu55bYqiaOQs3AjfwWDXHmuKZcLHt-wm7uR5fPEqg,1307
 model_compression_toolkit/core/common/network_editors/actions.py,sha256=nid0_j-Cn10xvmztT8yCKW_6uA7JEnom9SW9syx7wc0,19594
 model_compression_toolkit/core/common/network_editors/edit_network.py,sha256=dfgawi-nB0ocAJ0xcGn9E-Zv203oUnQLuMiXpX8vTgA,1748
@@ -112,7 +112,7 @@ model_compression_toolkit/core/common/quantization/quantization_fn_selection.py,
 model_compression_toolkit/core/common/quantization/quantization_params_fn_selection.py,sha256=7eG7dl1TcbdnHwgmvyjarxLs0o6Lw_9VAjXAm4rsiBk,3791
 model_compression_toolkit/core/common/quantization/quantize_graph_weights.py,sha256=N005MSvx8UypVpa7XrxNrB2G732n2wHj3RmLyjTgd3I,2728
 model_compression_toolkit/core/common/quantization/quantize_node.py,sha256=cdzGNWfT4MRogIU8ehs0tr3lVjnzAI-jeoS9b4TwVBo,2854
-model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=IeBy1kh3Rdp_LFEd0K2Jc_XANDPYJQDYP9MYrpTE29k,29550
+model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=_hhRb5eeFwbtPddu2xdLi7qK1RsxoR7UHUfjO0ICM3Q,30586
 model_compression_toolkit/core/common/quantization/quantization_params_generation/__init__.py,sha256=eCDGwsWYLU6z7qbEVb4TozMW_nd5VEP_iCJ6PcvyEPw,1486
 model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py,sha256=_m-XkEMJMHf0gYwVIXAoHVjdRa2NXt_gYdwBlw76ZR8,24031
 model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=RL-PklAjGyC-26anSt8fU07a6pB_LBQFQy9o4e9giN0,8739
@@ -439,7 +439,7 @@ model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema
 model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py,sha256=TtMPbiibV6Hk53nl5Y_ctfpI6mSbd8VVH9fxnv5j9eM,4430
 model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py,sha256=vBkXxVJagm9JKB9cdm4Pvi7u_luriXUjvNn0-m8Zr0k,4653
 model_compression_toolkit/target_platform_capabilities/schema/v1.py,sha256=oWKNQnnz04kmijmdWtRyXgVXbJ6BG_V_bUBz_MfUM94,27116
-model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=FiSkRUSuEPnJxvyDuRTwv2gwY4xveSp1hLtWKEFa8zc,6110
+model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=ncKPHVNyq_Yy_F7HOVDHT68EDfRnaB9yVnEP3C89GJk,10627
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/__init__.py,sha256=XjNws3zoiJkeH4ixKqrLA5xBvpv5rq31qX7wYQjNpZM,1447
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2fw.py,sha256=HJ8uc3PFfyxg-WpVXPBg4mGaox8Z9bRqtQNbRfIyAk4,3745
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=Ehwpd_sL6zxmJFpJugOdN9uNxNX05nijvOCilNfHnFs,7162
@@ -528,7 +528,7 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=UVN_S9ULHBEldBpShCOt8-soT8YTQ5oE362y96qF_FA,3950
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.3.0.20250421.604.dist-info/METADATA,sha256=fRMmNKrtVjZdLZAaNnma2VUWCi47C4GsOq2HbD4Dyoc,25413
-mct_nightly-2.3.0.20250421.604.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-mct_nightly-2.3.0.20250421.604.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250421.604.dist-info/RECORD,,
+mct_nightly-2.3.0.20250423.537.dist-info/METADATA,sha256=PeCeasbP-z1tGgn1g1tpCnmFWMlSQ7HtIfby4JXgX68,25413
+mct_nightly-2.3.0.20250423.537.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+mct_nightly-2.3.0.20250423.537.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250423.537.dist-info/RECORD,,

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.3.0.20250421.000604"
+__version__ = "2.3.0.20250423.000537"

model_compression_toolkit/core/common/graph/base_graph.py

@@ -754,7 +754,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         """
         while node.is_quantization_preserving():
             prev_nodes = self.get_prev_nodes(node)
-            assert len(prev_nodes) == 1, "Activation preserving node should have only 1 input."
+            assert len(prev_nodes) == 1, f"Activation preserving node should have only 1 input, but node {node.name} has {len(prev_nodes)} inputs."
             node = prev_nodes[0]
         return node
 

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -51,7 +51,6 @@ class BitwidthMode(Enum):
       single-precision nodes. To compute custom single precision configuration, use QCustom.
     """
     Float = auto()
-    Q8Bit = auto()
     QMaxBit = auto()
     QMinBit = auto()
     QCustom = auto()
@@ -573,7 +572,7 @@ class ResourceUtilizationCalculator:
                 not (a_node.is_activation_quantization_enabled() or n.is_weights_quantization_enabled(kernel_attr))):
             return 0
 
-        act_qc = act_qcs.get(a_node.name) if act_qcs else None
+        act_qc = self._extract_qc(a_node, act_qcs)
         a_nbits = self._get_activation_nbits(a_node, bitwidth_mode, act_qc)
         w_nbits = self._get_weight_nbits(n, kernel_attr, bitwidth_mode, w_qc)
         node_bops = a_nbits * w_nbits * node_mac
@@ -708,23 +707,20 @@ class ResourceUtilizationCalculator:
         Returns:
             Activation bit-width.
         """
+        n = self.graph.retrieve_preserved_quantization_node(n)
         if act_qc:
             assert bitwidth_mode == BitwidthMode.QCustom
             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()):
+        if bitwidth_mode == BitwidthMode.Float or not n.is_activation_quantization_enabled():
             return FLOAT_BITWIDTH
 
-        if bitwidth_mode == BitwidthMode.Q8Bit:
-            return 8
-
         if bitwidth_mode in self._bitwidth_mode_fn:
             candidates_nbits = [c.activation_quantization_cfg.activation_n_bits for c in n.candidates_quantization_cfg]
             return self._bitwidth_mode_fn[bitwidth_mode](candidates_nbits)
 
         if bitwidth_mode in [BitwidthMode.QCustom, BitwidthMode.QDefaultSP]:
-            qcs = self.graph.retrieve_preserved_quantization_node(n).get_unique_activation_candidates()
+            qcs = n.get_unique_activation_candidates()
             if len(qcs) != 1:
                 raise ValueError(f'Could not retrieve the activation quantization candidate for node {n} '
                                  f'as it has {len(qcs)}!=1 unique candidates.')
@@ -760,9 +756,6 @@ class ResourceUtilizationCalculator:
         if bitwidth_mode == BitwidthMode.Float or not n.is_weights_quantization_enabled(w_attr):
             return FLOAT_BITWIDTH
 
-        if bitwidth_mode == BitwidthMode.Q8Bit:
-            return 8
-
         node_qcs = n.get_unique_weights_candidates(w_attr)
         w_qcs = [qc.weights_quantization_cfg.get_attr_config(w_attr) for qc in node_qcs]
         if bitwidth_mode in cls._bitwidth_mode_fn:

model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py

@@ -16,7 +16,7 @@ from collections import defaultdict
 
 import numpy as np
 from pulp import *
-from typing import Dict, Tuple, Any
+from typing import Dict, Tuple, Any, List
 
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import RUTarget
 

model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -67,7 +67,7 @@ def set_quantization_configuration_to_graph(graph: Graph,
     nodes_to_manipulate_activation_bit_widths = {} if bit_width_config is None else bit_width_config.get_nodes_to_manipulate_activation_bit_widths(graph)
     nodes_to_manipulate_weights_bit_widths = {} if bit_width_config is None else bit_width_config.get_nodes_to_manipulate_weights_bit_widths(graph)
 
-    for n in graph.nodes:
+    for n in graph.get_topo_sorted_nodes():
         manual_bit_width_override = {ACTIVATION: nodes_to_manipulate_activation_bit_widths.get(n),
                                      WEIGHTS: nodes_to_manipulate_weights_bit_widths.get(n)}
         set_quantization_configs_to_node(node=n,
@@ -199,6 +199,16 @@ def set_quantization_configs_to_node(node: BaseNode,
         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
+        elif candidate_qc.activation_quantization_cfg.quant_mode == ActivationQuantizationMode.PRESERVE_QUANT:
+            prev_nodes = graph.get_prev_nodes(node)
+            if len(prev_nodes) != 1:
+                # Preserving the quantization of more than 1 previous node is ambiguous, so disable it.
+                Logger.info(f"Disabling Quantization-Preserving for node {node.name} because it has more than 1 input activations.")
+                candidate_qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
+            elif not prev_nodes[0].is_quantization_preserving() or not prev_nodes[0].is_activation_quantization_enabled():
+                # Preserving the quantization of an unquantized node isn't possible, so disable it.
+                Logger.info(f"Disabling Quantization-Preserving for node {node.name} because previous node activation quantization is disabled.")
+                candidate_qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.NO_QUANT
 
 
 def create_node_activation_qc(qc: QuantizationConfig,

model_compression_toolkit/target_platform_capabilities/schema/v2.py

@@ -14,9 +14,9 @@
 # ==============================================================================
 import pprint
 from enum import Enum
-from typing import Dict, Any, Tuple, Optional
+from typing import Dict, Any, Union, Tuple, Optional, Annotated
 
-from pydantic import BaseModel, root_validator, model_validator, ConfigDict
+from pydantic import BaseModel, Field, root_validator, model_validator, ConfigDict
 
 from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
@@ -29,8 +29,7 @@ from model_compression_toolkit.target_platform_capabilities.schema.v1 import (
     TargetPlatformModelComponent,
     OperatorsSetBase,
     OperatorsSet,
-    OperatorSetGroup,
-    Fusing)
+    OperatorSetGroup)
 
 
 class OperatorSetNames(str, Enum):
@@ -98,6 +97,109 @@ class OperatorSetNames(str, Enum):
         return [v.value for v in cls]
 
 
+class Fusing(TargetPlatformModelComponent):
+    """
+    Fusing defines a tuple of operators that should be combined and treated as a single operator,
+    hence no quantization is applied between them.
+
+    Attributes:
+        operator_groups (Tuple[Union[OperatorsSet, OperatorSetGroup], ...]): A tuple of operator groups,
+                                                                              each being either an OperatorSetGroup or an OperatorsSet.
+        fuse_op_quantization_config (Optional[OpQuantizationConfig]): The quantization configuration for the fused operator.
+        name (Optional[str]): The name for the Fusing instance. If not provided, it is generated from the operator groups' names.
+    """
+    operator_groups: Tuple[Annotated[Union[OperatorsSet, OperatorSetGroup], Field(discriminator='type')], ...]
+    fuse_op_quantization_config: Optional[OpQuantizationConfig] = None
+    name: Optional[str] = None  # Will be set in the validator if not given.
+
+    model_config = ConfigDict(frozen=True)
+
+    @model_validator(mode="before")
+    def validate_and_set_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate the operator_groups and set the name by concatenating operator group names.
+
+        Args:
+            values (Dict[str, Any]): Input data.
+
+        Returns:
+            Dict[str, Any]: Modified input data with 'name' set.
+        """
+        operator_groups = values.get('operator_groups')
+
+        # When loading from JSON, lists are returned. If the value is a list, convert it to a tuple.
+        if isinstance(operator_groups, list):
+            values['operator_groups'] = tuple(operator_groups)
+
+        if values.get('name') is None:
+            # Generate the concatenated name from the operator groups
+            concatenated_name = "_".join([
+                op.name.value if isinstance(op.name, OperatorSetNames) else op.name
+                for op in values['operator_groups']
+            ])
+            values['name'] = concatenated_name
+
+        return values
+
+    @model_validator(mode="after")
+    def validate_after_initialization(cls, model: 'Fusing') -> Any:
+        """
+        Perform validation after the model has been instantiated.
+        Ensures that there are at least two operator groups.
+        """
+        if len(model.operator_groups) < 2:
+            Logger.critical("Fusing cannot be created for a single operator.")  # pragma: no cover
+        
+        return model
+
+    def contains(self, other: Any) -> bool:
+        """
+        Determines if the current Fusing instance contains another Fusing instance.
+
+        Args:
+            other (Any): The other Fusing instance to check against.
+
+        Returns:
+            bool: True if the other Fusing instance is contained within this one, False otherwise.
+        """
+        if not isinstance(other, Fusing):
+            return False
+
+        # Check for containment by comparing operator groups
+        for i in range(len(self.operator_groups) - len(other.operator_groups) + 1):
+            for j in range(len(other.operator_groups)):
+                if self.operator_groups[i + j] != other.operator_groups[j] and not (
+                        isinstance(self.operator_groups[i + j], OperatorSetGroup) and (
+                        other.operator_groups[j] in self.operator_groups[i + j].operators_set)):
+                    break
+            else:
+                # If all checks pass, the other Fusing instance is contained
+                return True
+        # Other Fusing instance is not contained
+        return False
+
+    def get_info(self) -> Union[Dict[str, str], str]:
+        """
+        Retrieves information about the Fusing instance, including its name and the sequence of operator groups.
+
+        Returns:
+            Union[Dict[str, str], str]: A dictionary with the Fusing instance's name as the key
+                                        and the sequence of operator groups as the value,
+                                        or just the sequence of operator groups if no name is set.
+        """
+        if self.name is not None:
+            return {
+                self.name: ' -> '.join([
+                    x.name.value if isinstance(x.name, OperatorSetNames) else x.name
+                    for x in self.operator_groups
+                ])
+            }
+        return ' -> '.join([
+            x.name.value if isinstance(x.name, OperatorSetNames) else x.name
+            for x in self.operator_groups
+        ])
+
+
 class TargetPlatformCapabilities(BaseModel):
     """
     Represents the hardware configuration used for quantized model inference.