mct-nightly 2.3.0.20250517.552__py3-none-any.whl → 2.3.0.20250519.609__py3-none-any.whl

{mct_nightly-2.3.0.20250517.552.dist-info → mct_nightly-2.3.0.20250519.609.dist-info}/METADATA

@@ -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.dist-info → mct_nightly-2.3.0.20250519.609.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mct_nightly-2.3.0.20250517.552.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=RueNJeNFQG6WxXCYDucXbXAnF5xB1DP5nCV-ouC3da0,1557
+mct_nightly-2.3.0.20250519.609.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=YPU9BdtahSvlNGtO2EWfbfcVInfNzm5_GyZndC6ZA78,1557
 model_compression_toolkit/constants.py,sha256=KNgiNLpsMgSYyXMNEbHXd4bFNerQc1D6HH3vpbUq_Gs,4086
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
@@ -9,7 +9,7 @@ model_compression_toolkit/core/__init__.py,sha256=8a0wUNBKwTdJGDk_Ho6WQAXjGuCqQZ
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=C6eUTd-fcgxk0LUbt51gFZwmyDDDEB8-9Q4kr9ujYvI,11555
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=DPevqQ8brkdut8K5f5v9g5lbT3r1GSmhLAk3NkL40Fg,6593
-model_compression_toolkit/core/runner.py,sha256=_r6cieb7Ur2BeHQK5XxTZHogjyA0utybvIVbH06CBHY,13056
+model_compression_toolkit/core/runner.py,sha256=EM3B_t_TDUr_ttrQvZFhf6qxO9aIAYOwdl5FU8Y32Ow,13064
 model_compression_toolkit/core/common/__init__.py,sha256=Wh127PbXcETZX_d1PQqZ71ETK3J9XO5A-HpadGUbj6o,1447
 model_compression_toolkit/core/common/base_substitutions.py,sha256=xDFSmVVs_iFSZfajytI0cuQaNRNcwHX3uqOoHgVUvxQ,1666
 model_compression_toolkit/core/common/framework_implementation.py,sha256=JQI_eoZZoNk5Y_jAxLfYt9-wzfs7zGpTldz9UblxmMc,21182
@@ -31,10 +31,10 @@ model_compression_toolkit/core/common/collectors/min_max_per_channel_collector.p
 model_compression_toolkit/core/common/collectors/statistics_collector.py,sha256=psijsQZefwjMDH8SU5E18n65HiGtQilPhKr1hhzZX-I,8268
 model_compression_toolkit/core/common/collectors/weighted_histogram_collector.py,sha256=zp3dE7YTqWmkD5QWdRhsl9zD8W6Lr96G1Wjw1g2D3T0,4894
 model_compression_toolkit/core/common/fusion/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
-model_compression_toolkit/core/common/fusion/fusing_info.py,sha256=S7hBbUJxL52Z8uJ9_upLdFyoSEJvgmVX0OmneqDIj-c,18656
-model_compression_toolkit/core/common/fusion/graph_fuser.py,sha256=F0AaAUBpJ9JjHMB5H2LD9pdwTSWJK-Kqm9dQmGHX1Jo,7368
+model_compression_toolkit/core/common/fusion/fusing_info.py,sha256=uDxF0awrjn3SbcpXBpoQ4OGcKO6Z7HBk8ierZPCGbGo,21970
+model_compression_toolkit/core/common/fusion/graph_fuser.py,sha256=yxxxuwrmQ4wLW-PlTu0MEW59LmNJEh1OWy9Li15YH-8,7520
 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=BSQpKy0BXoGX0G0bySTo72n2isTqvtpkbRYYa8-hPO4,41435
+model_compression_toolkit/core/common/graph/base_graph.py,sha256=YA0c8ucaaZu9eRO-xruLqDT3QFOpxq24ViG6ILS2jqA,41403
 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
@@ -67,16 +67,16 @@ model_compression_toolkit/core/common/mixed_precision/configurable_quantizer_uti
 model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha256=-x8edUyudu1EAEM66AuXPtgayLpzbxoLNubfEbFM5kU,2867
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_candidates_filter.py,sha256=6pLUEEIqRTVIlCYQC4JIvY55KAvuBHEX8uTOQ-1Ac4Q,3859
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_quantization_config.py,sha256=BO4ouM_UVS9Fg0z95gLJSMz1ep6YQC5za_iXI_qW2yQ,5399
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=-hOMBucYn12ePyLd0b1KxniPOIRu4b53SwEzv0bWToI,4943
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=axgAypzsiCOw04ZOtOEjK4riuNsaEU2qU6KkWnEXtMo,4951
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=KhiHGpmN5QbpyJQnTZmXigdXFlSlRNqpOOyKGj1Fwek,6412
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=OzRhlJ2IS9Dwv0rgobee0xTtAeRwlBC6KvVEcx2_oB0,28089
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=MXOK9WPy3fSt5uxsWYMF4szwwqWWgrlzNJdE9VIb-AQ,28145
 model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=4uhUXKgwyMrJqEVK5uJzVr67GI5YzDTHLveV4maB7z0,28079
 model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,sha256=Zn6SgzGLWWKmuYGHd1YtKxZdYnQWRDeXEkKlBiTbHcs,2929
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=MY8df-c_kITEr_7hOctaxhdiq29hSTA0La9Qo0oTJJY,9678
 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=-kNcmQQFVHRPizInaRrCEIuh_q_57CWxC6CIV6azF4g,39640
-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/resource_utilization_tools/resource_utilization_calculator.py,sha256=8f6KDTKD8SzVXDl9jmYJ-p19cQB0Nr_UTdCPuhELTdg,40329
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=ZY5yFIDzbaqIk0UzakDBObfsVevn4fydqAfAm4RCikY,4058
 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=6Z6nQL9UH7B8dbcUR0cuCTEYFOKZAlvOb-SCk_cAZFA,6670
 model_compression_toolkit/core/common/network_editors/__init__.py,sha256=vZmu55bYqiaOQs3AjfwWDXHmuKZcLHt-wm7uR5fPEqg,1307
@@ -138,14 +138,14 @@ model_compression_toolkit/core/common/statistics_correction/statistics_correctio
 model_compression_toolkit/core/common/substitutions/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/substitutions/apply_substitutions.py,sha256=k-bifmakHIYZeZS-4T1QpZ1Et6AwAijMRgAKs7hmMKc,1390
 model_compression_toolkit/core/common/substitutions/batchnorm_folding.py,sha256=wLlTT7sqUffKHwOrMG2VV5SktQkkP54l8taW1Fq0mh0,13392
-model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py,sha256=kz1Xg2OMNXyRbCW3K-wfZpbv6jmLShJjHYUoziOUNv4,8496
+model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py,sha256=ndAKcbnNtDQ0DfL9WOYMYPlxU71t7xo9uxvaFZQsfjI,8501
 model_compression_toolkit/core/common/substitutions/batchnorm_refusing.py,sha256=dWJpVfomF4Ppeeor3VzS23TXHyBm85QI7snyLOYP_ko,9972
 model_compression_toolkit/core/common/substitutions/linear_collapsing.py,sha256=iEtzbWCDXP6EDkTZCtREQ0rpMxhQ2kM9zlcP_0KLq9I,12367
 model_compression_toolkit/core/common/substitutions/linear_collapsing_substitution.py,sha256=uoauhmncQqUBNvD-qCLIXsIbl_IzrbxSKdxiMig-5W4,2406
 model_compression_toolkit/core/common/substitutions/remove_identity.py,sha256=TKU1TIU52UIkVnl0EZvWnDhLV9nIVZ4hqi-w1i4NXMk,2637
 model_compression_toolkit/core/common/substitutions/residual_collapsing.py,sha256=N82mso5j3EJQlKt9EMHjjEJ67FmdGQeCfN8U5grOFXo,4830
 model_compression_toolkit/core/common/substitutions/scale_equalization.py,sha256=p57u25qdW2pimxzGwgMXEBV4S-LzXuTVAlIM7830WfU,10966
-model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=zCkdyZHEkbxkORmd071_XWajkpIhnDq9D6FyeE4TQjc,30057
+model_compression_toolkit/core/common/substitutions/shift_negative_activation.py,sha256=VcwCVWEooYwg6NGcnSP8OaSzgtzSd4k1r-5a68rpqZc,33713
 model_compression_toolkit/core/common/substitutions/softmax_shift.py,sha256=R-0ZqhYAuZLEFWHvB2UTPm52L6gWHGdRdEnwGxKSeGI,2625
 model_compression_toolkit/core/common/substitutions/virtual_activation_weights_composition.py,sha256=w43dRmaG96a8SNECgghxoFCTSoZ-vUb33dXGm2PbomE,4251
 model_compression_toolkit/core/common/substitutions/weights_activation_split.py,sha256=gt07lXRUvYunJKiwv_w20zfXhcplSW4oT2C1dqiNNXc,4719
@@ -258,7 +258,7 @@ model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/reshape
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/residual_collapsing.py,sha256=DcJEIkGvBdIMOelNIwaJUZ5UsAHiGnDJPR20I464vWo,2929
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scale_equalization.py,sha256=XFtU9yuBmoZlX0f0mS6otMPWMk-RcWs94XdvvTNhW8Y,3303
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scaled_dot_product_attention.py,sha256=D1hxN3pZ5-_FLJSS30ZJUo-v8TqUWFcMjhMijFa9aSo,12407
-model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/shift_negative_activation.py,sha256=3WCLvPyx7tVkM0rwYhYq-gntCzW9R_DcImR1ucKlPac,10772
+model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/shift_negative_activation.py,sha256=n90Fu2ZkuWPoqy1_GchrQSk6O-HlaeuBeVfaCR_O8xI,10755
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/softmax_shift.py,sha256=05lV4pIL3hJkZl4JQPV4wk_EFD0eYLG5b8cdzvZk4P8,1588
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/transform_function_call_method.py,sha256=EC9Dvp-_UlpDWnipnf8ds65wh_Y-T8pXAFIwRScWpiY,2044
 model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/virtual_activation_weights_composition.py,sha256=WmEa8Xjji-_tIbthDxlLAGSr69nWk-YKcHNaVqLa7sg,1375
@@ -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.20250517.552.dist-info/METADATA,sha256=kxKFMh-zWtlCfUBFowzu71E5L-8ybwVw0pgy_rCxVYw,25135
-mct_nightly-2.3.0.20250517.552.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-mct_nightly-2.3.0.20250517.552.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250517.552.dist-info/RECORD,,
+mct_nightly-2.3.0.20250519.609.dist-info/METADATA,sha256=7AynprEgb8NPAdgWcUm7I4vNV6rnqahpC68k459nm5Y,25135
+mct_nightly-2.3.0.20250519.609.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+mct_nightly-2.3.0.20250519.609.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250519.609.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.20250517.000552"
+__version__ = "2.3.0.20250519.000609"

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

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())

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

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,

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]]):

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

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)

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

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,

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)

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)