mct-nightly 2.3.0.20250402.536__py3-none-any.whl → 2.3.0.20250404.535__py3-none-any.whl

{mct_nightly-2.3.0.20250402.536.dist-info → mct_nightly-2.3.0.20250404.535.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
-mct_nightly-2.3.0.20250402.536.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=dhPx1u7eKO_zAY9CefOYP31YislX9FLOXxMFWv9PVJo,1557
+mct_nightly-2.3.0.20250404.535.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=Xy_GrGTjrv9Us1_tnSwgsiJDh-wjxsYto2Xpa5zo45M,1557
 model_compression_toolkit/constants.py,sha256=2ltuH-gdaLZoZV4CPUgKjC3S9ojz2z4OTVdenyVEypU,3912
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
@@ -7,9 +7,9 @@ model_compression_toolkit/metadata.py,sha256=x_Bk4VpzILdsFax6--CZ3X18qUTP28sbF_A
 model_compression_toolkit/verify_packages.py,sha256=TlS-K1EP-QsghqWUW7SDPkAJiUf7ryw4tvhFDe6rCUk,1405
 model_compression_toolkit/core/__init__.py,sha256=8a0wUNBKwTdJGDk_Ho6WQAXjGuCqQZG1FUxxJlAV8L8,2096
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
-model_compression_toolkit/core/graph_prep_runner.py,sha256=CVTjBaci8F6EP3IKDnRMfxkP-Sv8qY8GpkGt6FyII2U,11376
+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=WjZMVXc-OGBTnkiH0PRjNdJEM5pKQRPvLHXor5tjwjk,13096
+model_compression_toolkit/core/runner.py,sha256=_r6cieb7Ur2BeHQK5XxTZHogjyA0utybvIVbH06CBHY,13056
 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=s3yiqnbWkwfnAB1sSal_KAuqVg27rLhAJ2O8LHUbSHE,22494
@@ -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/graph_fuser.py,sha256=b41_4rL_Adiza4vpWlmmqgvkpUmWVdfdx0nEIB0p2n8,6195
-model_compression_toolkit/core/common/fusion/layer_fusing.py,sha256=-2fnjyC9q2RPw9st6RxROW-gdtT2mSRz0QZ_Gz1KDz4,5579
+model_compression_toolkit/core/common/fusion/fusing_info.py,sha256=LfzVS9B6r2KCwf8rcCUdepEQhWkt287SoXfwoudpfFo,15496
+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=cSwHUqwZEiR1t2DaBfc7_qSJbtX8crpqerN4ol9v3H8,38859
+model_compression_toolkit/core/common/graph/base_graph.py,sha256=hedhjVula5rPv0vN0CLBDtPYM8SH3cM6FAL62aFfF7U,41767
 model_compression_toolkit/core/common/graph/base_node.py,sha256=CJu8_r80MGVnYmlAUGOGKGRsD9xShMyaRNb3VMeRC0s,34523
 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
@@ -68,7 +68,7 @@ model_compression_toolkit/core/common/mixed_precision/distance_weighting.py,sha2
 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=r1t025_QHshyoop-PZvL7x6UuXaeplCCU3h4VNBhJHo,4309
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_ru_helper.py,sha256=2Pp4hiYvGW2I9YhloDxQNT0sZRg3TDp9CXObloF8IFU,4971
-model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=LddWtLileazCOvVSz-7j-GA4yskcGD3UHQGo7XUzSTE,5661
+model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py,sha256=GGrp7QngrWvWtPN8cQnL4IEbNwcVRc-hAUqfnxjjMmk,5998
 model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_manager.py,sha256=NBzzhkVI407S9cIiw7t7nsP3MrkOdSnweKQdPBXb8to,38180
 model_compression_toolkit/core/common/mixed_precision/sensitivity_evaluation.py,sha256=gsigifJ-ykWNafF4t7UMEC_-nd6YPERAk1_z0kT-Y88,27172
 model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,sha256=P8QtKgFXtt5b2RoubzI5OGlCfbEfZsAirjyrkFzK26A,2846
@@ -102,7 +102,7 @@ model_compression_toolkit/core/common/pruning/mask/per_channel_mask.py,sha256=77
 model_compression_toolkit/core/common/pruning/mask/per_simd_group_mask.py,sha256=_LcDAxLeC5I0KdMHS8jib5XxIKO2ZLavXYuSMIPIQBo,5868
 model_compression_toolkit/core/common/quantization/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/quantization/bit_width_config.py,sha256=0HA3CIZW-ZrA55ra-yJXRvAYnoR8i1SjpbnMDKcWYNQ,12819
-model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py,sha256=u7uueixA5wi3eYPrZKtLVxogkmgcgFL1w2pzMfd_ToU,4950
+model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py,sha256=lyWPvnoX8BmulhLKR20r5gT2_Yan7P40d8EcgDhErPk,4905
 model_compression_toolkit/core/common/quantization/core_config.py,sha256=yxCzWqldcHoe8GGxrH0tp99bhrc5jDT7SgZftnMUUBE,2374
 model_compression_toolkit/core/common/quantization/debug_config.py,sha256=zJP2W9apUPX9RstpPWWK71wr9xJsg7j-s7lGV4_bQdc,1510
 model_compression_toolkit/core/common/quantization/filter_nodes_candidates.py,sha256=IHVX-Gdekru4xLuDTgcsp_JCnRtuVWnbYsDBQuSXTKc,7079
@@ -138,7 +138,7 @@ 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=10fITLy6in5eLfDe415eTdJnTkdTDialfUhBffFYYw0,7634
+model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py,sha256=1389z4NbTKIHYGr-FB-fV1YP1Gcfta0tOu60DwfNVlI,8452
 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
@@ -435,14 +435,14 @@ model_compression_toolkit/target_platform_capabilities/constants.py,sha256=BFSgD
 model_compression_toolkit/target_platform_capabilities/immutable.py,sha256=YhROBiXEIB3TU-bAFrnL3qbAsb1yuWPBAQ_CLOJbYUU,1827
 model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py,sha256=4ydTWWKv_PEOAFok2JtxFNj8rav-0IlqcXKF6lnhHNE,4157
 model_compression_toolkit/target_platform_capabilities/schema/__init__.py,sha256=pKAdbTCFM_2BrZXUtTIw0ouKotrWwUDF_hP3rPwCM2k,696
-model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py,sha256=hf539WJ3nBGn0RnALXrKmAPnbhJ-VmWmLIa207x8b4M,541
+model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py,sha256=PvO8eHxnb3A55gyExT5fZGnOUl3ce7BbbT5SPxCEXNo,541
 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=4CGpWENuOyjwaIMaGrFI0Act7jsSeT7m94pjrv91dxE,27516
-model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=vUhCocA0EcjdR741Yv48W4Kr5Pq22Miebhm7F9GKb3Y,6086
+model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=yg0ZrsaqaS69lmDvxRrz636CRARzx_eZbokTMVHNEXc,4555
 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=AE09QLE_QKwNqUTZbkZP9XLJStG1ECiTWmEGuXZTEsQ,7652
-model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=-zbPmzQJal-1vZiQ6vIBBBnlEOB2DTb09koA0Aj4I_I,6396
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=mxc3DBbUi-HDFgSx8Nmnyxr8SIdbx8lmtcRMsQl1BLE,7578
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=8spnpqxVUv8WF9-PTukOLvJAFiNi01wNowUVIDqSj5I,6321
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attribute_filter.py,sha256=jfhszvuD2Fyy6W2KjlLzXBQKFzTqGAaDZeFVr4-ONQw,8776
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/current_tpc.py,sha256=_kFG0USYa6yzvLsi82_Vusv_KR8Hi7J1u680pPXECuo,2192
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py,sha256=UKzckLYLdBcFAptyKnVMwpPpfRkmF0SK1Kl0g0eGjQA,9710
@@ -527,7 +527,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.20250402.536.dist-info/METADATA,sha256=v7bHr6SXyb9qkbAmhb3xAHDXzinP-56xYnw-3SMtHVc,27098
-mct_nightly-2.3.0.20250402.536.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mct_nightly-2.3.0.20250402.536.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250402.536.dist-info/RECORD,,
+mct_nightly-2.3.0.20250404.535.dist-info/METADATA,sha256=cb-U_2NM6U6KUmtNnw8cDsM_XjdMPgJrdJkZxDQEn9I,27098
+mct_nightly-2.3.0.20250404.535.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mct_nightly-2.3.0.20250404.535.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250404.535.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.20250402.000536"
+__version__ = "2.3.0.20250404.000535"

model_compression_toolkit/core/common/fusion/fusing_info.py

@@ -0,0 +1,374 @@
+#  Copyright 2025 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#  ==============================================================================
+
+from model_compression_toolkit.target_platform_capabilities import LayerFilterParams
+from dataclasses import dataclass, field
+
+from typing import Optional, List, Dict, Any, Tuple
+import copy
+
+# The prefix of each fused operator (the suffix is a combination of the
+# nodes names that combine the fused operator).
+FUSED_OP_ID_PREFIX = "FusedNode_"
+
+
+@dataclass
+class FusingInfo:
+    """
+    This class manages information about fused operations in a graph.
+
+    The key responsibility of this class is maintaining a mapping between original nodes
+    and their corresponding fused operation IDs. This mapping helps track which nodes
+    belong to fused operations and validate this info is correct after changes in the graph.
+
+    The core structures maintained are:
+    - `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_data: Dict[str, Tuple['BaseNode']] = field(default_factory=dict)
+    node_to_fused_node_map: Dict[str, str] = field(init=False, default_factory=dict)
+
+    def __post_init__(self):
+        """Validates and initializes mappings after dataclass instantiation."""
+        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()
+
+    def _init_node_mapping(self) -> None:
+        """
+        Init the node-to-fused-node mapping based on the initial fusing data.
+        """
+        self.node_to_fused_node_map.clear()
+        for op_id, nodes in self.fusing_data.items():
+            for node in nodes:
+                self.node_to_fused_node_map[node.name] = op_id
+
+    def add_fused_operation(self, op_id: str, nodes: Tuple['BaseNode']) -> None:
+        """
+        Add a new fused operation with the given ID and set of nodes.
+
+        Args:
+            op_id (str): The identifier for the fused operation.
+            nodes (Tuple[BaseNode]): The tuple of nodes that form the fused operation.
+
+        Raises:
+            ValueError: If the operation ID already exists.
+        """
+        if op_id in self.fusing_data:
+            raise ValueError(f"Fused operation {op_id} already exists.")
+        assert isinstance(nodes, tuple), f"Expected nodes to be a tuple but its type is {type(nodes)}"
+        self.fusing_data[op_id] = nodes
+        # Update the mapping for these nodes
+        for node in nodes:
+            self.node_to_fused_node_map[node.name] = op_id
+
+    def remove_fused_operation(self, op_id: str) -> None:
+        """
+        Remove a fused operation by its ID.
+
+        Args:
+            op_id (str): The identifier for the fused operation to remove.
+
+        Raises:
+            ValueError: If the operation ID does not exist.
+        """
+        if op_id not in self.fusing_data:
+            raise ValueError(f"Fused operation {op_id} does not exist.")
+        # Remove nodes from the mapping
+        nodes = self.fusing_data[op_id]
+        for node in nodes:
+            self.node_to_fused_node_map.pop(node.name, None)
+        del self.fusing_data[op_id]
+
+    def get_fused_node_name(self, node_name: str) -> Optional[str]:
+        """
+        Get the name of the fused node containing the given original node name.
+
+        Args:
+            node_name: The name of a node from the original graph.
+
+        Returns:
+            The name of the fused node containing this node, or None if not fused.
+        """
+        return self.node_to_fused_node_map.get(node_name)
+
+    def get_node_to_fused_node_map(self) -> Dict[str, str]:
+        """
+        Retrieve a copy of the mapping from original node names to fused node names.
+
+        Returns:
+            A dictionary mapping each original node name to its fused node name.
+        """
+        return self.node_to_fused_node_map.copy()
+
+    def get_fused_nodes(self, op_id: str) -> Optional[List['BaseNode']]:
+        """
+        Retrieve the list of nodes for a given fused operation ID.
+
+        Args:
+            op_id (str): The identifier for the fused operation.
+
+        Returns:
+            Optional[List[BaseNode]]: The list of nodes for the operation, or None if not found.
+        """
+        return self.fusing_data.get(op_id)
+
+    def is_node_in_fused_op(self, node: 'BaseNode') -> bool:
+        """
+        Check if a node is part of any fused operation.
+
+        Args:
+            node (BaseNode): The node to check.
+
+        Returns:
+            bool: True if the node is in any fused operation, False otherwise.
+        """
+        return any(node in nodes for nodes in self.fusing_data.values())
+
+    def get_all_fused_operations(self) -> Dict[str, Tuple['BaseNode']]:
+        """
+        Retrieve fused information.
+
+        Returns:
+            Dict[str, List[BaseNode]]: The fusing data.
+        """
+        return self.fusing_data
+
+
+    @staticmethod
+    def generate_fused_op_id(nodes: List['BaseNode']) -> str:
+        """
+        Generates an identifier for a fused operation by concatenating
+        the names of the given nodes with a prefix.
+
+        Args:
+            nodes (List[BaseNode]): A list of nodes to be fused.
+
+        Returns:
+            str: An identifier string for the fused operation.
+        """
+        id = FUSED_OP_ID_PREFIX + '_'.join([node.name for node in nodes])
+        return id
+
+    def validate(self, graph) -> None:
+        """
+        Validate that the fusing information is consistent with the given graph and generation logic.
+
+        This method performs the following checks:
+        1. All nodes in the fusing data exist in the graph.
+        2. Each fused sequence forms a valid linear chain in the graph:
+           - Each node (except the last) has exactly one successor, which is the next node in the sequence.
+        3. No node is part of more than one fused operation.
+        4. Each fused sequence matches a valid fusing pattern from the original set.
+
+        Args:
+            graph: The computational graph to validate against. It is expected to have:
+                   - `get_topo_sorted_nodes()`: Returns a list of nodes in topological order.
+                   - `get_next_nodes(node)`: Returns a list of direct successor nodes.
+
+        Raises:
+            ValueError: If any validation check fails.
+        """
+        graph_nodes = set(graph.get_topo_sorted_nodes())  # Retrieve all nodes from the graph
+        all_fused_nodes = set()  # Track all nodes used in fusions to ensure no overlap
+
+        for op_id, nodes in self.fusing_data.items():
+            # Check 1: Ensure all fused nodes exist in the graph
+            for node in nodes:
+                if node not in graph_nodes:
+                    raise ValueError(f"Fused operation {op_id} contains node {node.name} not present in the graph.")
+
+            # Check 2: Validate the fusion sequence forms a valid linear chain
+            for i in range(len(nodes) - 1):  # Up to the second-to-last node
+                current_node = nodes[i]
+                next_node = nodes[i + 1]
+                successors = graph.get_next_nodes(current_node)
+                if len(successors) != 1 or successors[0] != next_node:
+                    raise ValueError(
+                        f"Fused operation {op_id} is not a valid linear chain: "
+                        f"node {current_node.name} does not connect directly to {next_node.name} "
+                        f"with exactly one successor (found successors: {[n.name for n in successors]})."
+                    )
+
+            # Check 3: Ensure no node is reused across fusions
+            node_set = set(nodes)
+            overlap = node_set & all_fused_nodes
+            if overlap:
+                raise ValueError(
+                    f"Fused operation {op_id} contains nodes already used in another fusion: "
+                    f"{[node.name for node in overlap]}."
+                )
+            all_fused_nodes.update(node_set)
+
+            # Check 4: Ensure the sequence matches a valid fusing pattern
+            if not is_valid_fusion(self.fusing_patterns, nodes):
+                raise ValueError(
+                    f"Fused operation {op_id} does not match any valid fusing pattern "
+                    f"from {self.fusing_patterns}."
+                )
+
+    def is_nodes_eligible_to_be_fused(self, nodes: List['BaseNode']) -> bool:
+        """
+        Check whether the given nodes are eligible to be fused based on predefined fusing patterns.
+
+        This method retrieves the fusing patterns from `self.fqc` and verifies whether the
+        given sequence of nodes matches any of the valid patterns.
+
+        Args:
+            nodes (List[BaseNode]): The list of nodes to check for fusion eligibility.
+
+        Returns:
+            bool: True if the nodes can be fused according to fusing patterns, otherwise False.
+        """
+        # If no fusing patterns are defined, fusion is not possible
+        if not self.fusing_patterns:
+            return False
+
+        # Check if the provided nodes match a valid fusion pattern
+        return is_valid_fusion(fusing_patterns=self.fusing_patterns, nodes=nodes)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the fusing information.
+        """
+        fusing_data_repr = "\n".join(
+            f"  {op_id}: [{', '.join(node.name for node in nodes)}]"
+            for op_id, nodes in self.fusing_data.items()
+        )
+        mapping_repr = ", ".join(
+            f"{node} -> {op_id}" for node, op_id in self.node_to_fused_node_map.items()
+        )
+        return (
+            f"FusingInfo(\n"
+            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")"
+        )
+
+
+class FusingInfoGenerator:
+    def __init__(self, fusing_patterns):
+        self._fusing_patterns = fusing_patterns
+
+    def generate_fusing_info(self, graph) -> FusingInfo:
+        """
+        Generate fusing information based on the graph and fusing patterns.
+
+        Args:
+            graph: The input graph to analyze, expected to have methods like
+                   get_topo_sorted_nodes() and get_next_nodes(node).
+
+        Returns:
+            A dictionary where keys are unique fusion identifiers (e.g., 'fused_op_0')
+            and values are lists of BaseNode objects representing nodes in that fusion.
+
+        Notes:
+            - Assumes get_valid_fusing_patterns_for_node and is_valid_fusion functions are defined elsewhere.
+            - Nodes are processed in topological order to respect operation sequence.
+            - Fusions are linear sequences (each node has exactly one successor).
+            - Each node belongs to at most one fused operation.
+        """
+        if not self._fusing_patterns:
+            return FusingInfo(fusing_patterns=self._fusing_patterns)
+
+        # Find max fusion
+        max_layers_fusing = 0 if len(self._fusing_patterns) == 0 else max([len(fusing_pattern) for fusing_pattern in self._fusing_patterns])
+
+        # Travel along the graph to find layers for fusing
+        nodes = graph.get_topo_sorted_nodes()
+
+        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(self._fusing_patterns)
+            next_nodes = [node]
+            for i in range(max_layers_fusing):
+                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(self._fusing_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)
+
+
+def get_valid_fusing_patterns_for_node(fusing_patterns: List[List[Any]],
+                                       node: 'BaseNode',
+                                       idx: int = 0) -> List[List[Any]]:
+    """
+    Returns only the fusing patterns where a specific layer (at index idx) matches the given node — either by type or filter params.
+
+    Args:
+        fusing_patterns: supported fusings
+        node: node to decide if it can be a part of fusion
+        idx: index of layer in the fusion
+
+    Returns:
+        fusing_patterns after filtering non-relevant fusions
+    """
+    valid_fusing_patterns = []
+    for i, fusing_pattern in enumerate(fusing_patterns):
+        if idx < len(fusing_pattern):
+            if ((type(fusing_pattern[idx]) == LayerFilterParams and node.is_match_filter_params(
+                    fusing_pattern[idx])) or node.is_match_type(fusing_pattern[idx])):
+                valid_fusing_patterns.append(fusing_pattern)
+
+    # Return only valid patterns for this node
+    return valid_fusing_patterns
+
+
+def is_valid_fusion(fusing_patterns: List[List[Any]], nodes: List['BaseNode']) -> bool:
+    """
+    Check if the fusion is valid: exist in fusing_patterns
+    Args:
+        fusing_patterns: supported fusing patterns
+        nodes: nodes which are participating in fusion
+    Returns:
+        whether the fusion in valid
+    """
+    fusion_depth = len(nodes)
+    if fusion_depth <= 1:
+        return False
+    for fusing_pattern in fusing_patterns:
+        if fusion_depth != len(fusing_pattern):
+            continue
+        counter = 0
+        for i, layer in enumerate(fusing_pattern):
+            if (type(layer) == LayerFilterParams and nodes[i].is_match_filter_params(layer)) or \
+                    nodes[i].is_match_type(layer):
+                counter += 1
+        if counter == fusion_depth:
+            return True
+    return False

model_compression_toolkit/core/common/fusion/graph_fuser.py

@@ -1,4 +1,4 @@
-#  Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#  Copyright 2025 Sony Semiconductor Israel, Inc. All rights reserved.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -13,10 +13,13 @@
 #  limitations under the License.
 #  ==============================================================================
 
-from typing import Dict, List
+import copy
+from typing import List, Tuple
 
-from model_compression_toolkit.core.common import Graph, BaseNode
-from model_compression_toolkit.core.common.graph.base_graph import OutTensor
+from model_compression_toolkit.core.common.fusion.fusing_info import FusingInfoGenerator
+from model_compression_toolkit.core.common.graph.base_graph import Graph, BaseNode, OutTensor
+from model_compression_toolkit.core.common.quantization.candidate_node_quantization_config import CandidateNodeQuantizationConfig
+from itertools import product
 
 
 class FusedLayerType:
@@ -27,35 +30,41 @@ class FusedLayerType:
     def __init__(self):
         self.__name__ = 'FusedLayer'
 
-
 class GraphFuser:
-
-    def create_fused_graph(self, graph: Graph) -> Dict[str, str]:
+    def apply_node_fusion(self, graph: Graph) -> Graph:
         """
-        GraphFuser is responsible for fusing nodes in a networkx graph.
-        The fusion process involves:
-            1. Creating new fused nodes to represent these groups.
-            2. Updating the graph structure to replace the original nodes with fused nodes.
-            3. Maintaining mapping of original node names to their fused node names.
+        Applies node fusion to the graph according the fusing_info it has.
+
+        The fusion process includes:
+            1. Generating new fused nodes to replace groups of original nodes.
+            2. Updating the graph structure to replace those nodes with the fused representations.
 
         Args:
-            graph: Graph to fuse its nodes.
+            graph: The graph and its fusing metadata.
 
         Returns:
-            Mapping of original node names to their fused node names
+            The updated graph with fused nodes replacing the original node groups.
         """
-        fused_nodes_mapping = {}
-        # Iterate through each group of nodes to be fused
-        for fused_nodes_list in graph.fused_nodes:
-            new_fused_node = self._create_fused_node(fused_nodes_list)
-            self._replace_nodes_with_fused_node(graph, fused_nodes_list, new_fused_node)
-            # Update the mapping to keep track of which original nodes are now part of which fused nodes
-            for node in fused_nodes_list:
-                fused_nodes_mapping[node.name] = new_fused_node.name
-        return fused_nodes_mapping
+        graph_copy = copy.deepcopy(graph)
+        expected_fusing_info = FusingInfoGenerator(graph_copy.fusing_info.fusing_patterns).generate_fusing_info(graph_copy)
+
+        if expected_fusing_info != graph_copy.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}"
+            )
+
+        fused_operations = list(graph_copy.fusing_info.get_all_fused_operations().items())
+        for fused_node_id, original_nodes in fused_operations:
+            fused_node = self._create_fused_node(fused_node_id, original_nodes)
+            graph_copy.fusing_info.remove_fused_operation(fused_node_id)
+            self._replace_nodes_with_fused_node(graph_copy, original_nodes, fused_node)
+
+        return graph_copy
+
 
     @staticmethod
-    def _create_fused_node(nodes: List[BaseNode]) -> BaseNode:
+    def _create_fused_node(fused_node_id: str, nodes: Tuple[BaseNode]) -> BaseNode:
         """
         Create a new node that represents the fusion of the given nodes.
 
@@ -67,22 +76,28 @@ class GraphFuser:
         """
         # Create a new node with a name that reflects its components
         # Use the input shape of the first node and output shape of the last node
-        fused_node = BaseNode(name='FusedNode_' + '_'.join([node.name for node in nodes]),
+        # TODO: consider replacing the fused node with a sub-model to allow inference on it, etc.
+        fused_node = BaseNode(name=fused_node_id,
                               framework_attr={},
                               input_shape=nodes[0].input_shape,
                               output_shape=nodes[-1].output_shape,
                               weights={},
                               layer_class=FusedLayerType)
 
-        # Preserve the final activation quantization configuration
-        # This is important for maintaining the correct behavior of the fused node
+        activation_cfgs = [c.activation_quantization_cfg for c in nodes[-1].candidates_quantization_cfg]
+        fused_node.candidates_quantization_cfg = [
+            CandidateNodeQuantizationConfig(weights_quantization_cfg=None, activation_quantization_cfg=a) for a in
+            activation_cfgs]
+
+        # Keep the final configurations if they were set already.
+        fused_node.final_weights_quantization_cfg = nodes[0].final_weights_quantization_cfg
         fused_node.final_activation_quantization_cfg = nodes[-1].final_activation_quantization_cfg
 
         return fused_node
 
     @staticmethod
     def _replace_nodes_with_fused_node(graph: Graph,
-                                       nodes_to_fuse: List[BaseNode],
+                                       nodes_to_fuse: Tuple[BaseNode],
                                        fused_node: BaseNode):
         """
         Replace the specified nodes in the graph with a new fused node.
@@ -118,6 +133,11 @@ class GraphFuser:
             for next_node in subsequent_nodes:
                 assert next_node in nodes_to_fuse  # Ensure we're not removing edges outside the fusion
                 graph.remove_edge(current_node, next_node)
+                # next_node can have more incoming edges from other nodes that are not
+                # in the fusion and we should remove them to:
+                in_edges = graph.incoming_edges(next_node)
+                for ie in in_edges:
+                    graph.remove_edge(ie.source_node, next_node)
 
         # Handle the case where fused nodes are part of the graph's outputs
         graph_output_tensors = graph.get_outputs()
@@ -136,3 +156,5 @@ class GraphFuser:
 
         # Finally, add the new fused node to the graph
         graph.add_node(fused_node)
+
+

model_compression_toolkit/core/common/graph/base_graph.py

@@ -15,7 +15,8 @@
 from collections import namedtuple
 
 from copy import copy, deepcopy
-from typing import List, Tuple, Any
+from functools import wraps
+from typing import List, Tuple, Any, Callable
 
 import networkx as nx
 import numpy as np
@@ -23,6 +24,7 @@ import numpy as np
 from networkx.algorithms.dag import topological_sort
 
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
+from model_compression_toolkit.core.common.fusion.fusing_info import FusingInfo
 from model_compression_toolkit.core.common.graph.edge import EDGE_SINK_INDEX, EDGE_SOURCE_INDEX
 from model_compression_toolkit.core.common.graph.edge import Edge, convert_to_edge
 from model_compression_toolkit.core.common.graph.graph_searches import GraphSearches
@@ -36,6 +38,27 @@ from model_compression_toolkit.target_platform_capabilities.targetplatform2frame
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
     FrameworkQuantizationCapabilities
 
+
+def validate_graph_after_change(method: Callable) -> Callable:
+    """
+    Decorator for graph-mutating methods. After the decorated method executes,
+    this decorator calls `self.validate()` to ensure the graph remains in a valid state.
+
+    Args:
+        method: The graph-modifying method to wrap.
+
+    Returns:
+        A wrapped method that validates the graph after execution.
+    """
+    @wraps(method)
+    def wrapper(self, *args, **kwargs):
+        result = method(self, *args, **kwargs)
+        if not self.skip_validation_check:
+            self.validate()  # calls Graph.validate(). Ensure graph consistency after changes.
+        return result
+    return wrapper
+
+
 OutTensor = namedtuple('OutTensor', 'node node_out_index')
 
 
@@ -63,6 +86,11 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         """
 
         super().__init__(**attr)
+
+        # This must be set first to ensure it's available when validation runs during graph creation.
+        self._skip_validation_check = False
+        self._fusing_info = FusingInfo()
+
         self.name = name
         self.input_nodes = input_nodes
         self.output_nodes = output_nodes
@@ -75,7 +103,25 @@ class Graph(nx.MultiDiGraph, GraphSearches):
                           **e.get_attributes())
         self.user_info = UserInformation()
         self.fw_info = fw_info
-        self.fused_nodes = []
+
+    @property
+    def skip_validation_check(self) -> bool:
+        return self._skip_validation_check
+
+    @skip_validation_check.setter
+    def skip_validation_check(self, value: bool):
+        if not isinstance(value, bool):
+            raise ValueError("skip_validation_check must be a boolean.")
+        self._skip_validation_check = value
+
+    @property
+    def fusing_info(self) -> FusingInfo:
+        return self._fusing_info
+
+    @fusing_info.setter
+    @validate_graph_after_change
+    def fusing_info(self, fusing_info: FusingInfo):
+        self._fusing_info = fusing_info
 
     def set_fw_info(self,
                     fw_info: FrameworkInfo):
@@ -139,6 +185,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         return self.output_nodes
 
+    @validate_graph_after_change
     def set_inputs(self,
                    input_nodes: List[BaseNode]):
         """
@@ -149,6 +196,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         self.input_nodes = input_nodes
 
+    @validate_graph_after_change
     def set_outputs(self,
                     output_nodes: List[OutTensor]):
         """
@@ -321,6 +369,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             sort_attr = None
         return [edges_list.source_node for edges_list in self.incoming_edges(node_obj, sort_by_attr=sort_attr)]
 
+    @validate_graph_after_change
     def reconnect_out_edges(self,
                             current_node: BaseNode,
                             new_node: BaseNode):
@@ -337,6 +386,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             self.add_edge(new_node, oe.sink_node, **oe.get_attributes())
             self.remove_edge(current_node, oe.sink_node)
 
+    @validate_graph_after_change
     def reconnect_in_edges(self,
                            current_node: BaseNode,
                            new_node: BaseNode):
@@ -353,6 +403,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             self.add_edge(ie.source_node, new_node, **ie.get_attributes())
             self.remove_edge(ie.source_node, current_node)
 
+    @validate_graph_after_change
     def add_node_with_in_edges(self, new_node: BaseNode, input_nodes: List[BaseNode],
                                input_nodes_output_index: List[int] = []):
         """
@@ -378,6 +429,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         for sink_index, (in_node, source_index) in enumerate(zip(input_nodes, input_nodes_output_index)):
             self.add_edge(in_node, new_node, source_index=source_index, sink_index=sink_index)
 
+    @validate_graph_after_change
     def replace_output_node(self,
                             current_node: BaseNode,
                             new_node: BaseNode):
@@ -400,6 +452,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
                 new_graph_outputs[graph_ot_index] = OutTensor(new_node, ot.node_out_index)
         self.set_outputs(new_graph_outputs)
 
+    @validate_graph_after_change
     def replace_input_node(self,
                            current_node: BaseNode,
                            new_node: BaseNode):
@@ -424,6 +477,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             new_graph_inputs.append(new_node)
         self.set_inputs(new_graph_inputs)
 
+    @validate_graph_after_change
     def remove_node(self,
                     node_to_remove: BaseNode,
                     new_graph_inputs: List[BaseNode] = None,
@@ -713,16 +767,6 @@ class Graph(nx.MultiDiGraph, GraphSearches):
             node = prev_nodes[0]
         return node
 
-    def update_fused_nodes(self, fusion: List[Any]):
-        """
-        Updates the graphs fusions list with a new list of nodes that have been fused.
-
-        Args:
-            fusion: A list of nodes that have been fused.
-
-        """
-        self.fused_nodes.append(fusion)
-
     def has_any_configurable_activation(self) -> bool:
         """
         Checks whether any node in the graph has a configurable activation quantization.
@@ -742,6 +786,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         return any([n.has_any_configurable_weight() for n in self.nodes])
 
+    @validate_graph_after_change
     def replace_node(self, node_to_replace: BaseNode, new_node: BaseNode):
         """
         Replaces a node in the graph with a new node.
@@ -867,4 +912,36 @@ class Graph(nx.MultiDiGraph, GraphSearches):
 
         return intermediate_nodes, next_node
 
+    def disable_fused_nodes_activation_quantization(self):
+        """
+        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]]
+        for node in nodes_to_disable:
+            for qc in node.candidates_quantization_cfg:
+                qc.activation_quantization_cfg.enable_activation_quantization = False
+
+    def validate(self):
+        """
+        Validate that the current state of the graph is consistent with
+        the fusing information (e.g., no missing or incorrect fused node mapping).
 
+        Returns:
+            The result of the FusingInfo validation logic (typically None or raises error).
+        """
+        return self.fusing_info.validate(self)
+
+    @validate_graph_after_change
+    def add_edge(self, *args, **kwargs):
+        """
+        Wrap networkx functions (that modifies the graph) with our validate decorator.
+        """
+        return super().add_edge(*args, **kwargs)
+
+    @validate_graph_after_change
+    def remove_edge(self, *args, **kwargs):
+        """
+        Wrap networkx functions (that modifies the graph) with our validate decorator.
+        """
+        return super().remove_edge(*args, **kwargs)

model_compression_toolkit/core/common/mixed_precision/mixed_precision_search_facade.py

@@ -65,6 +65,7 @@ def search_bit_width(graph: Graph,
         bit-width index on the node).
 
     """
+
     assert target_resource_utilization.is_any_restricted()
 
     # If we only run weights compression with MP than no need to consider activation quantization when computing the
@@ -88,6 +89,11 @@ def search_bit_width(graph: Graph,
     if search_method != BitWidthSearchMethod.INTEGER_PROGRAMMING:
         raise NotImplementedError()
 
+    # Validation is skipped during the mixed-precision search configuration because fusing information is not
+    # relevant for the virtual graph. Therefore, validation checks are disabled before the search begins and
+    # re-enabled once it completes.
+    graph.skip_validation_check = True
+
     # Search manager and LP are highly coupled, so LP search method was moved inside search manager.
     search_manager = MixedPrecisionSearchManager(graph,
                                                  fw_info,
@@ -96,6 +102,8 @@ def search_bit_width(graph: Graph,
                                                  target_resource_utilization)
     result_bit_cfg = search_manager.search()
 
+    graph.skip_validation_check = False
+
     if mp_config.refine_mp_solution:
         result_bit_cfg = greedy_solution_refinement_procedure(result_bit_cfg, search_manager, target_resource_utilization)
 

model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py

@@ -71,11 +71,13 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
 
         if weights_quantization_cfg is not None:
             self.weights_quantization_cfg = weights_quantization_cfg
-        else:
-            if any(v is None for v in (qc, op_cfg, node_attrs_list)):  # pragma: no cover
-                Logger.critical("Missing required arguments to initialize a node weights quantization configuration. "
-                                "Ensure QuantizationConfig, OpQuantizationConfig, weights quantization function, "
-                                "parameters function, and weights attribute quantization config are provided.")
-            self.weights_quantization_cfg = NodeWeightsQuantizationConfig(qc=qc, op_cfg=op_cfg,
+        elif all(v is not None for v in (qc, op_cfg, node_attrs_list)):
+            self.weights_quantization_cfg = NodeWeightsQuantizationConfig(qc=qc,
+                                                                          op_cfg=op_cfg,
                                                                           weights_channels_axis=weights_channels_axis,
                                                                           node_attrs_list=node_attrs_list)
+        else:
+            self.weights_quantization_cfg = None
+            Logger.debug("Setting weights quantization config as None during CandidateNodeQuantizationConfig creation."
+                         "Notice, this should happen only for FLN nodes.")
+

model_compression_toolkit/core/common/substitutions/batchnorm_reconstruction.py

@@ -19,11 +19,11 @@ from typing import Callable
 
 import numpy as np
 
+from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common.quantization.node_quantization_config import WeightsAttrQuantizationConfig
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
 from mct_quantizers import QuantizationMethod
@@ -143,6 +143,21 @@ class BatchNormalizationReconstruction(common.BaseSubstitution):
                                                                     AttributeQuantizationConfig(
                                                                         enable_weights_quantization=False)))
 
+        # Check if the source node was part of a fusion. If so, there are two cases:
+        # either this is no longer a fusion, and the fusion info should be updated by removing
+        # 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)
+        if fused_op:
+            fused_nodes = list(fi.get_fused_nodes(fused_op))
+            assert source_node in fused_nodes
+            fused_nodes.insert(fused_nodes.index(source_node)+1, bn_node)
+            fi.remove_fused_operation(fused_op)
+            if fi.is_nodes_eligible_to_be_fused(fused_nodes):
+                op_id = fi.generate_fused_op_id(fused_nodes)
+                fi.add_fused_operation(op_id, tuple(fused_nodes))
+
         graph.reconnect_out_edges(current_node=source_node, new_node=bn_node)
         graph.replace_output_node(current_node=source_node, new_node=bn_node)
         graph.add_node_with_in_edges(bn_node, [source_node])

model_compression_toolkit/core/graph_prep_runner.py

@@ -18,7 +18,7 @@ from typing import Callable, Any
 
 from model_compression_toolkit.core.common import FrameworkInfo
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
-from model_compression_toolkit.core.common.fusion.layer_fusing import fusion
+from model_compression_toolkit.core.common.fusion.fusing_info import FusingInfoGenerator
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.quantization.bit_width_config import BitWidthConfig
 from model_compression_toolkit.core.common.quantization.filter_nodes_candidates import filter_nodes_candidates
@@ -136,6 +136,7 @@ def get_finalized_graph(initial_graph: Graph,
         node.prior_info = fw_impl.get_node_prior_info(node=node,
                                                       fw_info=fw_info,
                                                       graph=graph)
+
     ##################################################
     # Graph substitution (pre statistics collection)
     ##################################################
@@ -161,7 +162,9 @@ def get_finalized_graph(initial_graph: Graph,
     ######################################
     # Layer fusing
     ######################################
-    transformed_graph = fusion(transformed_graph, fqc)
+    fusing_info = FusingInfoGenerator(fqc.get_fusing_patterns()).generate_fusing_info(transformed_graph)
+    transformed_graph.fusing_info = fusing_info
+    transformed_graph.disable_fused_nodes_activation_quantization()
 
     ######################################
     # Channel equalization

model_compression_toolkit/core/runner.py

@@ -184,15 +184,14 @@ def core_runner(in_model: Any,
 
     scheduler_info = None
     if core_config.debug_config.simulate_scheduler:
-        graph_to_fuse = copy.deepcopy(tg)
-        fused_nodes_mapping = GraphFuser().create_fused_graph(graph_to_fuse)
-        memory_graph = MemoryGraph(graph_to_fuse)
+        fused_graph = GraphFuser().apply_node_fusion(tg)
+        memory_graph = MemoryGraph(fused_graph)
         schedule, max_cut, cuts = compute_graph_max_cut(memory_graph)
         scheduler_info = SchedulerInfo(
             operators_scheduling=schedule,
             max_cut=float(max_cut),
             cuts=cuts,
-            fused_nodes_mapping=fused_nodes_mapping
+            fused_nodes_mapping=tg.fusing_info.get_node_to_fused_node_map()
         )
 
     return tg, bit_widths_config, hessian_info_service, scheduler_info

model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py

@@ -1,4 +1,4 @@
-import model_compression_toolkit.target_platform_capabilities.schema.v2 as schema
+import model_compression_toolkit.target_platform_capabilities.schema.v1 as schema
 
 OperatorSetNames = schema.OperatorSetNames
 Signedness = schema.Signedness

model_compression_toolkit/target_platform_capabilities/schema/v2.py

@@ -30,72 +30,8 @@ from model_compression_toolkit.target_platform_capabilities.schema.v1 import (
     OperatorsSetBase,
     OperatorsSet,
     OperatorSetGroup,
-    Fusing)
-
-
-class OperatorSetNames(str, Enum):
-    CONV = "Conv"
-    DEPTHWISE_CONV = "DepthwiseConv2D"
-    CONV_TRANSPOSE = "ConvTranspose"
-    FULLY_CONNECTED = "FullyConnected"
-    CONCATENATE = "Concatenate"
-    STACK = "Stack"
-    UNSTACK = "Unstack"
-    GATHER = "Gather"
-    EXPAND = "Expend"
-    BATCH_NORM = "BatchNorm"
-    L2NORM = "L2Norm"
-    RELU = "ReLU"
-    RELU6 = "ReLU6"
-    LEAKY_RELU = "LeakyReLU"
-    ELU = "Elu"
-    HARD_TANH = "HardTanh"
-    ADD = "Add"
-    SUB = "Sub"
-    MUL = "Mul"
-    DIV = "Div"
-    MIN = "Min"
-    MAX = "Max"
-    PRELU = "PReLU"
-    ADD_BIAS = "AddBias"
-    SWISH = "Swish"
-    SIGMOID = "Sigmoid"
-    SOFTMAX = "Softmax"
-    LOG_SOFTMAX = "LogSoftmax"
-    TANH = "Tanh"
-    GELU = "Gelu"
-    HARDSIGMOID = "HardSigmoid"
-    HARDSWISH = "HardSwish"
-    FLATTEN = "Flatten"
-    GET_ITEM = "GetItem"
-    RESHAPE = "Reshape"
-    UNSQUEEZE = "Unsqueeze"
-    SQUEEZE = "Squeeze"
-    PERMUTE = "Permute"
-    TRANSPOSE = "Transpose"
-    DROPOUT = "Dropout"
-    SPLIT_CHUNK = "SplitChunk"
-    MAXPOOL = "MaxPool"
-    AVGPOOL = "AvgPool"
-    SIZE = "Size"
-    SHAPE = "Shape"
-    EQUAL = "Equal"
-    ARGMAX = "ArgMax"
-    TOPK = "TopK"
-    FAKE_QUANT = "FakeQuant"
-    COMBINED_NON_MAX_SUPPRESSION = "CombinedNonMaxSuppression"
-    BOX_DECODE = "BoxDecode"
-    ZERO_PADDING2D = "ZeroPadding2D"
-    CAST = "Cast"
-    RESIZE = "Resize"
-    PAD = "Pad"
-    FOLD = "Fold"
-    STRIDED_SLICE = "StridedSlice"
-    SSD_POST_PROCESS = "SSDPostProcess"
-
-    @classmethod
-    def get_values(cls):
-        return [v.value for v in cls]
+    Fusing,
+    OperatorSetNames)
 
 
 class TargetPlatformCapabilities(BaseModel):

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py

@@ -93,7 +93,6 @@ class AttachTpcToKeras(AttachTpcToFramework):
             OperatorSetNames.TOPK: [tf.nn.top_k],
             OperatorSetNames.FAKE_QUANT: [tf.quantization.fake_quant_with_min_max_vars],
             OperatorSetNames.COMBINED_NON_MAX_SUPPRESSION: [tf.image.combined_non_max_suppression],
-            OperatorSetNames.BOX_DECODE: [],  # no such operator in keras
             OperatorSetNames.ZERO_PADDING2D: [ZeroPadding2D],
             OperatorSetNames.CAST: [tf.cast],
             OperatorSetNames.STRIDED_SLICE: [tf.strided_slice],

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py

@@ -98,7 +98,6 @@ class AttachTpcToPytorch(AttachTpcToFramework):
                                                         Eq('p', 2) | Eq('p', None))],
             OperatorSetNames.SSD_POST_PROCESS: [],  # no such operator in pytorch
             OperatorSetNames.COMBINED_NON_MAX_SUPPRESSION: [],  # no such operator in pytorch
-            OperatorSetNames.BOX_DECODE: []  # no such operator in pytorch
         }
 
         pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),

model_compression_toolkit/core/common/fusion/layer_fusing.py

@@ -1,131 +0,0 @@
-# Copyright 2022 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-import copy
-from typing import Any, List
-from model_compression_toolkit.core.common.graph.base_graph import Graph
-from model_compression_toolkit.core.common.graph.base_node import BaseNode
-from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import \
-    FrameworkQuantizationCapabilities
-from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.layer_filter_params import LayerFilterParams
-
-
-def filter_fusing_patterns(fusing_patterns: List[List[Any]], node: BaseNode, idx: int = 0) -> List[List[Any]]:
-    """
-    Update relevant fusing patterns object if layer number 'idx' inside the fusion matches the node
-    Args:
-        fusing_patterns: supported fusings
-        node: node to decide if it can be a part of fusion
-        idx: index of layer in the fusion
-    Returns:
-        fusing_patterns after filtering non-relevant fusions
-    """
-    valid_fusing_patterns = []
-    for i, fusing_pattern in enumerate(fusing_patterns):
-        if idx < len(fusing_pattern):
-            if (type(fusing_pattern[idx]) == LayerFilterParams and node.is_match_filter_params(fusing_pattern[idx])) or \
-                    node.is_match_type(fusing_pattern[idx]):
-                valid_fusing_patterns.append(fusing_pattern)
-
-    # Return only valid patterns for this node
-    return valid_fusing_patterns
-
-
-def is_valid_fusion(fusing_patterns: List[List[Any]], nodes: List[BaseNode]) -> bool:
-    """
-    Check if the fusion is valid: exist in fusing_patterns
-    Args:
-        fusing_patterns: supported fusing patterns
-        nodes: nodes which are participating in fusion
-    Returns:
-        whether the fusion in valid
-    """
-    fusion_depth = len(nodes)
-    if fusion_depth <= 1:
-        return False
-    for fusing_pattern in fusing_patterns:
-        if fusion_depth != len(fusing_pattern):
-            continue
-        counter = 0
-        for i, layer in enumerate(fusing_pattern):
-            if (type(layer) == LayerFilterParams and nodes[i].is_match_filter_params(layer)) or \
-                    nodes[i].is_match_type(layer):
-                counter += 1
-        if counter == fusion_depth:
-            return True
-    return False
-
-
-def disable_nodes_activation_quantization(nodes: List[BaseNode]):
-    """
-    Disable activation for non-quantization needed due to fusion
-    Args:
-        nodes: nodes to update their activation quantization
-    """
-    for node in nodes:
-        for qc in node.candidates_quantization_cfg:
-            qc.activation_quantization_cfg.enable_activation_quantization = False
-
-
-def fusion(graph: Graph, fqc: FrameworkQuantizationCapabilities) -> Graph:
-    """
-    Fusing defines a list of operators that should be combined and treated as a single operator,
-    hence no quantization is applied between them when they appear in the graph.
-    This function search and disable quantization for such patterns.
-    Args:
-        graph: Graph we apply the fusion on.
-        fqc: FrameworkQuantizationCapabilities object that describes the desired inference target platform (includes fusing patterns MCT should handle).
-    Returns:
-        Graph after applying fusion activation marking.
-    """
-    fusing_patterns = fqc.get_fusing_patterns()
-    if len(fusing_patterns) == 0:
-        return graph
-
-    # Find max fusion
-    max_layers_fusing = 0 if len(fusing_patterns) == 0 else max([len(fusing_pattern) for fusing_pattern in fusing_patterns])
-
-
-    # -------------------------------- #
-    # Fusion algorithm
-    # -------------------------------- #
-    fused_graph = copy.deepcopy(graph)
-
-    # Travel along the graph to find layers for fusing
-    nodes = fused_graph.get_topo_sorted_nodes()
-    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_patterns)
-        next_nodes = [node]
-        for i in range(max_layers_fusing):
-            patterns = filter_fusing_patterns(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 = fused_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: mark all nodes in the fusion except last one
-        if is_valid_fusion(fusing_patterns, fusing_nodes):
-            fused_nodes.extend(fusing_nodes)
-            disable_nodes_activation_quantization(fusing_nodes[:-1])
-            fused_graph.update_fused_nodes(fusing_nodes)
-
-    return fused_graph