mct-nightly 2.3.0.20250517.552__tar.gz → 2.3.0.20250519.609__tar.gz

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250517.552
+Version: 2.3.0.20250519.609
 Summary: A Model Compression Toolkit for neural networks
 Author-email: ssi-dnn-dev@sony.com
 Classifier: Programming Language :: Python :: 3

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250517.552
+Version: 2.3.0.20250519.609
 Summary: A Model Compression Toolkit for neural networks
 Author-email: ssi-dnn-dev@sony.com
 Classifier: Programming Language :: Python :: 3

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/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.20250517.000552"
+__version__ = "2.3.0.20250519.000609"

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/fusion/fusing_info.py

@@ -36,22 +36,28 @@ class FusingInfo:
     belong to fused operations and validate this info is correct after changes in the graph.
 
     The core structures maintained are:
+    - 'fusing_patterns': The patterns to generate the fused operators from.
+    - 'manual_fused_ops': List of sequence of node names to handle as fused ops (even if they are not part of the fusing patterns).
     - `fusing_data`: A dictionary mapping fused operation IDs to lists of nodes that belong to that operation.
     - `node_to_fused_node_map`: A dictionary mapping each node name to the ID of the fused operation it belongs to.
 
     """
-    fusing_patterns: any = None
+    fusing_patterns: List[list[any]] = None
+    manual_fused_ops: List[List[str]] = None
     fusing_data: Dict[str, Tuple['BaseNode']] = field(default_factory=dict)
     node_to_fused_node_map: Dict[str, str] = field(init=False, default_factory=dict)
     fused_op_id_to_quant_config: Dict[str, OpQuantizationConfig] = field(default_factory=dict)
 
     def __post_init__(self):
         """Validates and initializes mappings after dataclass instantiation."""
+        self.fusing_patterns = self.fusing_patterns or []
         for op_id, op_nodes in self.fusing_data.items():
             assert isinstance(op_id, str) and op_id.startswith(FUSED_OP_ID_PREFIX), f"Found invalid fused op id: {op_id}"
             assert isinstance(op_nodes, tuple) and len(op_nodes) > 1, f"Found invalid fused op nodes: {op_nodes}"
 
         self._init_node_mapping()
+        self._manual_fused_ops = self.manual_fused_ops or []
+        del self.manual_fused_ops
         self._init_quantization_config_map()
 
     def _init_node_mapping(self) -> None:
@@ -63,6 +69,26 @@ class FusingInfo:
             for node in nodes:
                 self.node_to_fused_node_map[node.name] = op_id
 
+    def get_manual_nodes_to_fuse(self) -> List[List[str]]:
+        """
+        Get the list of node names to be fused manually.
+        """
+        return self._manual_fused_ops
+
+
+    def add_manual_nodes_to_fuse(self, node_names: List[str]):
+        """
+        Add a list of node names to be fused manually.
+
+        Args:
+            node_names: List of nodes to be fused.
+
+        """
+        assert isinstance(node_names, list)
+        assert all([isinstance(n, str) for n in node_names])
+        assert node_names not in self._manual_fused_ops, f"{node_names} is already in manual fused ops: {self._manual_fused_ops}"
+        self._manual_fused_ops.append(node_names)
+
     def _init_quantization_config_map(self) -> None:
         """
         Init the mapping between fused operation IDs and their quantization configurations.
@@ -121,12 +147,16 @@ class FusingInfo:
             raise ValueError(f"Fused operation {op_id} does not exist.")
         # Remove nodes from the mapping
         nodes = self.fusing_data[op_id]
+        node_names = [n.name for n in nodes]
+        if node_names in self._manual_fused_ops:
+            self._manual_fused_ops.remove(node_names)
+
         for node in nodes:
             self.node_to_fused_node_map.pop(node.name, None)
         del self.fusing_data[op_id]
         self.fused_op_id_to_quant_config.pop(op_id, None)
 
-    def get_fused_node_name(self, node_name: str) -> Optional[str]:
+    def get_fused_op_id_for_node(self, node_name: str) -> Optional[str]:
         """
         Get the name of the fused node containing the given original node name.
 
@@ -168,6 +198,12 @@ class FusingInfo:
         """
         return self.fusing_data.get(op_id)
 
+    def get_nodes_to_disable_activation_quantization(self) -> List['BaseNode']:
+        """
+        Returns a list of the nodes that their activation quantization is disabled due to fusing.
+        """
+        return [node for nodes in self.get_all_fused_operations().values() for node in nodes[:-1]]
+
     def get_fused_op_quantization_config(self, op_id: str) -> OpQuantizationConfig:
         """
         Retrieve the quantization configuration for a given fused operation ID.
@@ -268,7 +304,7 @@ class FusingInfo:
 
             # Check 4: Ensure the sequence matches a valid fusing pattern
             valid_fusing_patterns = _get_fusing_layer_patterns(self.fusing_patterns)
-            if not is_valid_fusion(valid_fusing_patterns, nodes):
+            if not is_valid_fusion(valid_fusing_patterns, nodes, self._manual_fused_ops):
                 raise ValueError(
                     f"Fused operation {op_id} does not match any valid fusing pattern "
                     f"from {valid_fusing_patterns}."
@@ -311,13 +347,17 @@ class FusingInfo:
             f"  Total fused operations: {len(self.fusing_data)}\n"
             f"  Fusing Data:\n{fusing_data_repr}\n"
             f"  Node-to-Fused Mapping:\n  {mapping_repr}\n"
+            f"  Manual fused ops:\n  {self._manual_fused_ops}\n"
             f")"
         )
 
 
 class FusingInfoGenerator:
-    def __init__(self, fusing_patterns):
-        self._fusing_patterns = fusing_patterns
+    def __init__(self, fusing_patterns: List[list] = None, manual_fused_ops: List[List[str]] = None):
+        self._fusing_patterns = fusing_patterns or []
+        assert isinstance(self._fusing_patterns, list)
+        self._manual_fused_ops = manual_fused_ops or []
+        assert isinstance(self._manual_fused_ops, list)
 
     def generate_fusing_info(self, graph: 'Graph') -> FusingInfo:
         """
@@ -338,7 +378,7 @@ class FusingInfoGenerator:
             - Each node belongs to at most one fused operation.
         """
         if not self._fusing_patterns:
-            return FusingInfo(fusing_patterns=self._fusing_patterns)
+            return FusingInfo(fusing_patterns=self._fusing_patterns, manual_fused_ops=self._manual_fused_ops)
 
         # Extract fusing layer patterns
         fusing_layer_patterns = _get_fusing_layer_patterns(self._fusing_patterns)
@@ -352,31 +392,53 @@ class FusingInfoGenerator:
         fusing_info: Dict[str, Tuple['BaseNode']] = {}
         fused_nodes = []  # nodes that are participating in fusing
 
-        for node in nodes:
-            # Skip if already in fusing
-            if node in fused_nodes:
-                continue
-            # Start fusing search
-            fusing_nodes = []  # nodes that are candidates for participating in fusing
-            patterns = copy.deepcopy(fusing_layer_patterns)
-            next_nodes = [node]
-            for i in range(max_layer_patterns):
-                patterns = get_valid_fusing_patterns_for_node(patterns, next_nodes[0], i)
-                if len(patterns) == 0:  # Give up if no more fusion pattern
-                    break
-                fusing_nodes.append(next_nodes[0])
-                next_nodes = graph.get_next_nodes(fusing_nodes[-1])
-                if len(next_nodes) != 1:  # Give up if node has more than one connection (not supported for fusion)
-                    break
-
-            # New fusion
-            if is_valid_fusion(fusing_layer_patterns, fusing_nodes):
-                fused_op_id = FusingInfo.generate_fused_op_id(fusing_nodes)
-                assert fused_op_id not in fusing_info, f"{fused_op_id} is already in fusing info: {fusing_info}"
-                fusing_info[fused_op_id] = tuple(fusing_nodes)
-                fused_nodes.extend(fusing_nodes)
-
-        return FusingInfo(fusing_data=fusing_info, fusing_patterns=self._fusing_patterns)
+        if len(self._fusing_patterns)>0:
+            for node in nodes:
+                # Skip if already in fusing
+                if node in fused_nodes:
+                    continue
+                # Start fusing search
+                fusing_nodes = []  # nodes that are candidates for participating in fusing
+                patterns = copy.deepcopy(fusing_layer_patterns)
+                next_nodes = [node]
+                for i in range(max_layer_patterns):
+                    patterns = get_valid_fusing_patterns_for_node(patterns, next_nodes[0], i)
+                    if len(patterns) == 0:  # Give up if no more fusion pattern
+                        break
+                    fusing_nodes.append(next_nodes[0])
+                    next_nodes = graph.get_next_nodes(fusing_nodes[-1])
+                    if len(next_nodes) != 1:  # Give up if node has more than one connection (not supported for fusion)
+                        break
+
+                # New fusion
+                if is_valid_fusion(fusing_layer_patterns, fusing_nodes):
+                    fused_op_id = FusingInfo.generate_fused_op_id(fusing_nodes)
+                    assert fused_op_id not in fusing_info, f"{fused_op_id} is already in fusing info: {fusing_info}"
+                    fusing_info[fused_op_id] = tuple(fusing_nodes)
+                    fused_nodes.extend(fusing_nodes)
+
+        for manual_names in self._manual_fused_ops:
+            manual_nodes = [graph.find_node_by_name(n) for n in manual_names]
+            for n in manual_nodes:
+                if len(n) != 1:
+                    raise ValueError(f"Expected exactly one node, but got {len(n)}")
+            manual_nodes = [n[0] for n in manual_nodes]
+
+            # Remove any existing fused ops containing any of the manual nodes
+            fused_ids_to_remove = {
+                op_id for op_id, nodes in fusing_info.items()
+                if any(node in nodes for node in manual_nodes)
+            }
+            for op_id in fused_ids_to_remove:
+                del fusing_info[op_id]
+
+            fused_op_id = FusingInfo.generate_fused_op_id(manual_nodes)
+            assert fused_op_id not in fusing_info, f"{fused_op_id} is already in fusing info: {fusing_info}"
+            fusing_info[fused_op_id] = tuple(manual_nodes)
+
+        return FusingInfo(fusing_data=fusing_info,
+                          fusing_patterns=self._fusing_patterns,
+                          manual_fused_ops=self._manual_fused_ops)
 
 
 def get_valid_fusing_patterns_for_node(fusing_patterns: List[List[Any]],
@@ -404,15 +466,20 @@ def get_valid_fusing_patterns_for_node(fusing_patterns: List[List[Any]],
     return valid_fusing_patterns
 
 
-def is_valid_fusion(fusing_patterns: List[List[Any]], nodes: List['BaseNode']) -> bool:
+def is_valid_fusion(fusing_patterns: List[List[Any]], nodes: List['BaseNode'], manual_fused_names: List[List[str]]=None) -> bool:
     """
     Check if the fusion is valid: exist in fusing_patterns
     Args:
         fusing_patterns: supported fusing patterns
         nodes: nodes which are participating in fusion
+        manual_fused_names: list of nodes names to handle as a valid fusing op.
     Returns:
         whether the fusion in valid
     """
+    node_names = [n.name for n in nodes]
+    if any(manual == node_names for manual in (manual_fused_names or [])):
+        return True
+
     fusion_depth = len(nodes)
     if fusion_depth <= 1:
         return False

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/fusion/graph_fuser.py

@@ -46,12 +46,14 @@ class GraphFuser:
             The updated graph with fused nodes replacing the original node groups.
         """
         graph_copy = copy.deepcopy(graph)
-        expected_fusing_info = FusingInfoGenerator(graph_copy.fusing_info.fusing_patterns).generate_fusing_info(graph_copy)
+        expected_fusing_info = FusingInfoGenerator(graph_copy.fusing_info.fusing_patterns,
+                                                   graph_copy.fusing_info.get_manual_nodes_to_fuse()).generate_fusing_info(graph_copy)
 
-        if expected_fusing_info != graph_copy.fusing_info:
+        existing_fusing_info = graph_copy.fusing_info
+        if expected_fusing_info != existing_fusing_info:
             raise ValueError(
                 f"Mismatch between expected and existing fusing information.\n"
-                f"Expected:\n{expected_fusing_info}\nExisting:\n{graph_copy.fusing_info}"
+                f"Expected:\n{expected_fusing_info}\nExisting:\n{existing_fusing_info}"
             )
 
         fused_operations = list(graph_copy.fusing_info.get_all_fused_operations().items())

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/graph/base_graph.py

@@ -908,7 +908,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         Disable activation quantization for all nodes in fused operations,
         except for the last node in each fused group.
         """
-        nodes_to_disable = [node for nodes in self.fusing_info.get_all_fused_operations().values() for node in nodes[:-1]]
+        nodes_to_disable = self.fusing_info.get_nodes_to_disable_activation_quantization()
         for node in nodes_to_disable:
             for qc in node.candidates_quantization_cfg:
                 qc.activation_quantization_cfg.quant_mode = ActivationQuantizationMode.FLN_QUANT

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py

@@ -51,7 +51,7 @@ class MixedPrecisionRUHelper:
         """
         act_qcs, w_qcs = self.get_quantization_candidates(mp_cfg)
 
-        ru, detailed_ru = self.ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized,
+        ru, detailed_ru = self.ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantizedNonFused,
                                                                           BitwidthMode.QCustom,
                                                                           act_qcs=act_qcs,
                                                                           w_qcs=w_qcs,

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py

@@ -294,8 +294,12 @@ class MixedPrecisionSearchManager:
         """
         act_qcs, w_qcs = self.orig_graph_ru_helper.get_quantization_candidates(config)
         ru = self.orig_graph_ru_helper.ru_calculator.compute_resource_utilization(
-            target_criterion=TargetInclusionCriterion.AnyQuantized, bitwidth_mode=BitwidthMode.QCustom, act_qcs=act_qcs,
-            w_qcs=w_qcs, ru_targets=self.ru_targets, allow_unused_qcs=True)
+            target_criterion=TargetInclusionCriterion.AnyQuantizedNonFused,
+            bitwidth_mode=BitwidthMode.QCustom,
+            act_qcs=act_qcs,
+            w_qcs=w_qcs,
+            ru_targets=self.ru_targets,
+            allow_unused_qcs=True)
         return ru
 
     def _finalize_distance_metric(self, layer_to_metrics_mapping: Dict[BaseNode, List[float]]):

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -67,11 +67,13 @@ class TargetInclusionCriterion(Enum):
     QNonConfigurable: non-configurable targets (single quantization candidate).
     AnyQuantized: any quantized targets (configurable and non-configurable).
     Any: all targets (quantized + float).
+    QuantizedNonFused: any quantized targets that are not inside fused operations.
     """
     QConfigurable = auto()
     QNonConfigurable = auto()
     AnyQuantized = auto()
     Any = auto()
+    AnyQuantizedNonFused = auto()
 
 
 class Utilization(NamedTuple):
@@ -534,8 +536,9 @@ class ResourceUtilizationCalculator:
         assert not isinstance(n, VirtualNode), 'Use original graph to compute BOPS.'
         if target_criterion is None:
             target_criterion = TargetInclusionCriterion.Any
-        if target_criterion not in [TargetInclusionCriterion.AnyQuantized, TargetInclusionCriterion.Any]:
-            raise ValueError('BOPS computation is supported only for Any and AnyQuantized targets.')
+        if target_criterion not in [TargetInclusionCriterion.AnyQuantized, TargetInclusionCriterion.AnyQuantizedNonFused, TargetInclusionCriterion.Any]:
+            raise ValueError(
+                'BOPS computation is supported only for Any, AnyQuantized and AnyQuantizedNonFused targets.')
 
         self._validate_custom_qcs(act_qcs, bitwidth_mode)
         self._validate_custom_qcs(w_qc, bitwidth_mode)
@@ -621,7 +624,7 @@ class ResourceUtilizationCalculator:
         weight_attrs = n.get_node_weights_attributes()
         if target_criterion == TargetInclusionCriterion.QConfigurable:
             weight_attrs = [attr for attr in weight_attrs if n.is_configurable_weight(attr)]
-        elif target_criterion == TargetInclusionCriterion.AnyQuantized:
+        elif target_criterion in [TargetInclusionCriterion.AnyQuantized, TargetInclusionCriterion.AnyQuantizedNonFused]:
             weight_attrs = [attr for attr in weight_attrs if n.is_weights_quantization_enabled(attr)]
         elif target_criterion == TargetInclusionCriterion.QNonConfigurable:
             quantized = [attr for attr in weight_attrs if n.is_weights_quantization_enabled(attr)]
@@ -671,6 +674,10 @@ class ResourceUtilizationCalculator:
             nodes = [n for n in nodes if n.has_configurable_activation()]
         elif target_criterion == TargetInclusionCriterion.AnyQuantized:
             nodes = [n for n in nodes if n.is_activation_quantization_enabled() or n.is_quantization_preserving()]
+        elif target_criterion == TargetInclusionCriterion.AnyQuantizedNonFused:
+            nodes = [n for n in nodes if n.is_activation_quantization_enabled() or n.is_quantization_preserving()]
+            # remove fused nodes (due to SNC, where the non-linear is quantized, even though it should not be quantized)
+            nodes = [n for n in nodes if n not in self.graph.fusing_info.get_nodes_to_disable_activation_quantization()]
         elif target_criterion == TargetInclusionCriterion.QNonConfigurable:
             nodes = [n for n in nodes if n.is_activation_quantization_enabled() and not n.has_configurable_activation()]
         elif target_criterion != TargetInclusionCriterion.Any:    # pragma: no cover

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py

@@ -63,4 +63,4 @@ def compute_resource_utilization_data(in_model: Any,
                                                  running_gptq=False)
 
     ru_calculator = ResourceUtilizationCalculator(transformed_graph, fw_impl, fw_info)
-    return ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized, BitwidthMode.QDefaultSP)
+    return ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantizedNonFused, BitwidthMode.QDefaultSP)

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py

@@ -149,7 +149,7 @@ class BatchNormalizationReconstruction(common.BaseSubstitution):
         # the current info, or this creates a new fusion and the old pattern should be
         # replaced with the new one.
         fi = graph.fusing_info
-        fused_op = fi.get_fused_node_name(source_node.name)
+        fused_op = fi.get_fused_op_id_for_node(source_node.name)
         if fused_op:
             fused_nodes = list(fi.get_fused_nodes(fused_op))
             assert source_node in fused_nodes

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -23,8 +23,6 @@ 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
 from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
-from mct_quantizers import QuantizationMethod
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import AttributeQuantizationConfig
 from model_compression_toolkit.core.common.quantization.set_node_quantization_config import create_node_activation_qc, \
     set_quantization_configs_to_node
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
@@ -33,6 +31,7 @@ from model_compression_toolkit.core.common.quantization.quantization_params_gene
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.error_functions import \
     _mse_error_histogram
 from model_compression_toolkit.core.common.quantization.quantization_params_generation import z_score_filter
+from model_compression_toolkit.target_platform_capabilities import QuantizationMethod, AttributeQuantizationConfig
 
 """
 This substitution aims to solve an issue of activation with negative outputs where
@@ -188,6 +187,65 @@ def remove_node_between_two_nodes(graph: Graph,
     graph.remove_node(node_to_remove)
 
 
+def fuse_padding_with_op2d(graph: 'BaseGraph', pad_node: 'BaseNode', op2d_node: 'BaseNode') -> None:
+    """
+    Add a padding node to the fused operation containing op2d_node.
+    If op2d_node is not already in a fused op, create a new fused group with both nodes.
+
+    Args:
+        graph: The computational graph.
+        pad_node: The padding node to be added.
+        op2d_node: The Conv2D or similar op node following the pad.
+    """
+    fusing_info = graph.fusing_info
+
+    if fusing_info.is_node_in_fused_op(op2d_node):
+        fused_id = fusing_info.get_fused_op_id_for_node(op2d_node.name)
+        fused_nodes = fusing_info.get_fused_nodes(fused_id)
+        fusing_info.remove_fused_operation(fused_id)
+    else:
+        fused_nodes = [op2d_node]
+
+    new_fused_nodes = [pad_node] + list(fused_nodes)
+    fused_op_id = fusing_info.generate_fused_op_id(new_fused_nodes)
+
+    fusing_info.add_fused_operation(fused_op_id, tuple(new_fused_nodes))
+    fusing_info.add_manual_nodes_to_fuse([n.name for n in new_fused_nodes])
+
+def update_fused_op_with_add(graph: 'BaseGraph', non_linear_node: 'BaseNode', add_node: 'BaseNode') -> None:
+    """
+    Update the fused operation to include an Add node that follows a non-linear activation node.
+
+    Args:
+        graph: The computational graph.
+        non_linear_node: The non-linear activation node (e.g., ReLU).
+        add_node: The Add node inserted after the non-linear node.
+    """
+    fusing_info = graph.fusing_info
+    prev_node = graph.get_prev_nodes(non_linear_node)[0]
+
+    # Gather existing fused nodes (if any)
+    fused_candidates = []
+    for node in (prev_node, non_linear_node):
+        if fusing_info.is_node_in_fused_op(node):
+            fused_id = fusing_info.get_fused_op_id_for_node(node.name)
+            fused_candidates.extend(fusing_info.get_fused_nodes(fused_id))
+    fused_candidates.append(add_node)
+
+    # Remove duplicates while preserving order
+    fused_candidates = list(dict.fromkeys(fused_candidates))
+
+    # Remove existing fused ops involving prev_node or non_linear_node
+    for node in (prev_node, non_linear_node):
+        if fusing_info.is_node_in_fused_op(node):
+            fusing_info.remove_fused_operation(fusing_info.get_fused_op_id_for_node(node.name))
+
+    # Register new fused operation
+    fused_op_id = fusing_info.generate_fused_op_id(fused_candidates)
+    fusing_info.add_manual_nodes_to_fuse([n.name for n in fused_candidates])
+    fusing_info.add_fused_operation(fused_op_id, tuple(fused_candidates))
+
+
 def shift_negative_function(graph: Graph,
                             core_config: CoreConfig,
                             non_linear_node: BaseNode,
@@ -232,7 +290,6 @@ def shift_negative_function(graph: Graph,
     Returns:
         Graph after applying the shifting and correction.
     """
-
     min_to_correct, max_value2compare = graph.get_out_stats_collector(non_linear_node).get_min_max_values()
 
     if not non_linear_node.is_all_activation_candidates_equal():
@@ -242,6 +299,7 @@ def shift_negative_function(graph: Graph,
     # all candidates have same activation config, so taking the first candidate for calculations
     non_linear_node_cfg_candidate = non_linear_node.candidates_quantization_cfg[0].activation_quantization_cfg
 
+
     # get the non-linear activation threshold
     activation_threshold = non_linear_node_cfg_candidate.activation_quantization_params.get(THRESHOLD)
 
@@ -350,7 +408,14 @@ def shift_negative_function(graph: Graph,
                                      fqc=graph.fqc,
                                      mixed_precision_enable=core_config.is_mixed_precision_enabled)
 
-    if padding is not None:
+    update_fused_op_with_add(graph=graph,
+                             non_linear_node=non_linear_node,
+                             add_node=add_node)
+
+    # If sum([pad_top, pad_btm, pad_left, pad_right])==0 it means we do not pad in any side, thus
+    # we do not add a padding node as this is meaningless
+    pad_node = None
+    if padding is not None and sum([pad_top, pad_btm, pad_left, pad_right])>0:
         pad_node = create_pad_node(op2d_node.name,
                                    add_node.name,
                                    shift_value,
@@ -394,8 +459,16 @@ def shift_negative_function(graph: Graph,
                     graph.shift_stats_collector(bypass_node, np.array(shift_value))
 
     add_node_qco = add_node.get_qco(graph.fqc).quantization_configurations
+    add_supported_bitwidths = [c.activation_n_bits for c in add_node_qco]
+    if original_non_linear_activation_nbits not in add_supported_bitwidths:
+        raise ValueError(
+            f"Add supported activation bit-widths according to the TPC are: {add_supported_bitwidths}, but non-linear "
+            f"bitwidth is {original_non_linear_activation_nbits}. Consider adapting the TPC so 'Add' will support the "
+            f"same bitwidth as {non_linear_node.type} or disable shift negative correction.")
+
     for op_qc_idx, candidate_qc in enumerate(add_node.candidates_quantization_cfg):
         for attr in add_node.get_node_weights_attributes():
+            # TODO: do we not quantize the weights of this 'add' on purpose?
             candidate_qc.weights_quantization_cfg.get_attr_config(attr).enable_weights_quantization = False
 
         candidate_qc.activation_quantization_cfg = create_node_activation_qc(core_config.quantization_config,
@@ -404,8 +477,15 @@ def shift_negative_function(graph: Graph,
 
         candidate_qc.activation_quantization_cfg.set_activation_quantization_param({THRESHOLD: activation_threshold,
                                                                                     SIGNED: False})
+
         candidate_qc.activation_quantization_cfg.activation_n_bits = original_non_linear_activation_nbits
 
+    # Add the new padding node to a fused op with the op2d.
+    if pad_node:
+        fuse_padding_with_op2d(graph=graph,
+                               pad_node=pad_node,
+                               op2d_node=op2d_node)
+
     if non_linear_node_cfg_candidate.shift_negative_threshold_recalculation:
         activation_param = get_activations_qparams(activation_quant_cfg=non_linear_node_cfg_candidate,
                                                    nodes_prior_info=non_linear_node.prior_info,

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/shift_negative_activation.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+import copy
 import operator
 from typing import Tuple, Any, Callable
 
@@ -149,9 +150,9 @@ def create_pad_node(next_node_name: str,
     op_call_kwargs = {PAD: [pad_left, pad_right, pad_top, pad_btm],
                VALUE: float(value_to_pad)}
 
-    padded_shape = input_shape[0]
-    padded_shape[1] += pad_top + pad_btm
-    padded_shape[2] += pad_left + pad_right
+    padded_shape = copy.deepcopy(input_shape[0])
+    padded_shape[2] += pad_top + pad_btm
+    padded_shape[3] += pad_left + pad_right
     pad_node = common.graph.functional_node.FunctionalNode(pad_node_name,
                                                            {},
                                                            input_shape,
@@ -241,5 +242,4 @@ def pytorch_apply_shift_negative_correction(graph: Graph,
                                            PADDING,
                                            BIAS,
                                            USE_BIAS,
-                                           params_search_quantization_fn=params_search_quantization_fn
-                                           )
+                                           params_search_quantization_fn=params_search_quantization_fn)

{mct_nightly-2.3.0.20250517.552 → mct_nightly-2.3.0.20250519.609}/model_compression_toolkit/core/runner.py

@@ -220,7 +220,7 @@ def _set_final_resource_utilization(graph: Graph,
         ru_calculator = ResourceUtilizationCalculator(graph, fw_impl, fw_info)
         w_qcs = {n.name: n.final_weights_quantization_cfg for n in graph.nodes}
         a_qcs = {n.name: n.final_activation_quantization_cfg for n in graph.nodes}
-        final_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantized,
+        final_ru = ru_calculator.compute_resource_utilization(TargetInclusionCriterion.AnyQuantizedNonFused,
                                                               BitwidthMode.QCustom, act_qcs=a_qcs, w_qcs=w_qcs,
                                                               ru_targets=ru_targets, allow_unused_qcs=True)
         summary = final_ru.get_summary_str(restricted=True)