PyPI - mct-nightly - Versions diffs - 2.3.0.20250422.534__tar.gz → 2.3.0.20250423.537__tar.gz - Mend

Files changed (539) hide show

{mct_nightly-2.3.0.20250422.534 → mct_nightly-2.3.0.20250423.537}/model_compression_toolkit/target_platform_capabilities/schema/v2.py RENAMED Viewed

@@ -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.

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250422.534
+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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250422.534
+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

@@ -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.20250422.000534"
+__version__ = "2.3.0.20250423.000537"

@@ -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

@@ -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:

@@ -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

@@ -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,

mct-nightly 2.3.0.20250422.534__tar.gz → 2.3.0.20250423.537__tar.gz

mct-nightly 2.3.0.20250422.534tar.gz → 2.3.0.20250423.537tar.gz