mct-nightly 2.3.0.20250514.602__py3-none-any.whl → 2.3.0.20250516.613__py3-none-any.whl

{mct_nightly-2.3.0.20250514.602.dist-info → mct_nightly-2.3.0.20250516.613.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250514.602
+Version: 2.3.0.20250516.613
 Summary: A Model Compression Toolkit for neural networks
 Author-email: ssi-dnn-dev@sony.com
 Classifier: Programming Language :: Python :: 3
@@ -21,7 +21,7 @@ Requires-Dist: PuLP
 Requires-Dist: matplotlib<3.10.0
 Requires-Dist: scipy
 Requires-Dist: protobuf
-Requires-Dist: mct-quantizers-nightly
+Requires-Dist: mct-quantizers==1.6.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: edge-mdt-cl-dev
 Dynamic: author-email

{mct_nightly-2.3.0.20250514.602.dist-info → mct_nightly-2.3.0.20250516.613.dist-info}/RECORD

@@ -1,6 +1,6 @@
-mct_nightly-2.3.0.20250514.602.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=r8-owZy9MZyc6lGIyuRz2eQeNhwA3DhfnJCgu0VSbhI,1557
-model_compression_toolkit/constants.py,sha256=iJ6vfTjC2oFIZWt8wvHoxEw5YJi3yl0Hd4q30_8q0Zc,3958
+mct_nightly-2.3.0.20250516.613.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=vpUrhwvqdXrPwyv56B5qlxS71UYcqZVGpzP-u2yJA9E,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
 model_compression_toolkit/metadata.py,sha256=x_Bk4VpzILdsFax6--CZ3X18qUTP28sbF_AhoQW8dNc,4003
@@ -31,7 +31,7 @@ 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=W8qZejLwbm-lkvNF3GepNL3ypO10vFRxOxbq-o_rt_I,15479
+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/graph/__init__.py,sha256=Xr-Lt_qXMdrCnnOaUS_OJP_3iTTGfPCLf8_vSrQgCs0,773
 model_compression_toolkit/core/common/graph/base_graph.py,sha256=BSQpKy0BXoGX0G0bySTo72n2isTqvtpkbRYYa8-hPO4,41435
@@ -233,7 +233,7 @@ model_compression_toolkit/core/pytorch/back2framework/factory_model_builder.py,s
 model_compression_toolkit/core/pytorch/back2framework/float_model_builder.py,sha256=tLrlUyYhxVKVjkad1ZAtbRra0HedB3iVfIkZ_dYnQ-4,3419
 model_compression_toolkit/core/pytorch/back2framework/instance_builder.py,sha256=BBHBfTqeWm7L3iDyPBpk0jxvj-rBg1QWI23imkjfIl0,1467
 model_compression_toolkit/core/pytorch/back2framework/mixed_precision_model_builder.py,sha256=HAzzWOnPcIeDxQO1712254RNTBZD-gVSMSVnxqpfuQ0,11907
-model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py,sha256=Z-ZQV-GWdOBGPbksiWBQ8MtFkQ41qgUKU5d5c8aNSjQ,21646
+model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py,sha256=FVewVclo3kx-Oufr_PJE4-MAqkKJseBvd96vz8JtuBg,22163
 model_compression_toolkit/core/pytorch/back2framework/quantized_model_builder.py,sha256=qZNNOlNTTV4ZKPG3q5GDXkIVTPUEr8dvxAS_YiMORmg,3456
 model_compression_toolkit/core/pytorch/back2framework/quantization_wrapper/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/core/pytorch/back2framework/quantization_wrapper/quantized_layer_wrapper.py,sha256=q2JDw10NKng50ee2i9faGzWZ-IydnR2aOMGSn9RoZmc,5773
@@ -349,7 +349,7 @@ model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer
 model_compression_toolkit/exporter/model_wrapper/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py,sha256=vQUGbCi8_pGoN8DwQ0IblSeN6L9t6Cr0reZNuCbBpkM,3469
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py,sha256=gKLKQaVlIx8Rt04aA5EXnG53D1x5N8gaSfUnmip3UK4,6851
+model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py,sha256=AKSpWbTtXHPjW7hY655OXANaK5SgEiF-FZCu5zoioxM,6860
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py,sha256=Pl8a8MSZMzNbm5vngujFjCt_iSMbSmKjlcL1DvN9nTM,9292
 model_compression_toolkit/gptq/__init__.py,sha256=pEgkJvmf05KSw70iLDTz_6LI_2Oi5L8sTN0JsEUpnpk,1445
 model_compression_toolkit/gptq/runner.py,sha256=La12JTYjWyJW0YW4Al4TP1_Xi4JWBCEKw6FR_JQsxe0,5982
@@ -433,20 +433,20 @@ model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/uniform_ste.py,sha2
 model_compression_toolkit/target_platform_capabilities/__init__.py,sha256=8RVOriZg-XNjSt53h_4Yum0oRgOe2gp5H45dfG_lZxE,1415
 model_compression_toolkit/target_platform_capabilities/constants.py,sha256=JRz9DoxLRpkqvu532TFkIvv0595Bfb9NtU4pRp4urDY,1540
 model_compression_toolkit/target_platform_capabilities/immutable.py,sha256=YhROBiXEIB3TU-bAFrnL3qbAsb1yuWPBAQ_CLOJbYUU,1827
-model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py,sha256=nbmlygR-nc3bzwnUDrRamq3a6KFkC4-cCpbUeF7EEmo,4626
+model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py,sha256=hFBq-qKUM9qKZGaMmrxsEmurTV_D1kWIXI1rTERZsbk,5241
 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=PvO8eHxnb3A55gyExT5fZGnOUl3ce7BbbT5SPxCEXNo,541
-model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py,sha256=TtMPbiibV6Hk53nl5Y_ctfpI6mSbd8VVH9fxnv5j9eM,4430
+model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py,sha256=hf539WJ3nBGn0RnALXrKmAPnbhJ-VmWmLIa207x8b4M,541
+model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py,sha256=OpZ9SH2aTAVTCBfj1m3wcAeouk_q_16yWxCwByXK_M8,6294
 model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py,sha256=vBkXxVJagm9JKB9cdm4Pvi7u_luriXUjvNn0-m8Zr0k,4653
 model_compression_toolkit/target_platform_capabilities/schema/v1.py,sha256=oWKNQnnz04kmijmdWtRyXgVXbJ6BG_V_bUBz_MfUM94,27116
-model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=hryYeGK0zJ2ffcRpHihudtYpl8kIl1WTAQOEsyerqlM,10813
+model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=1hrvq4EeLDRe0-wvpHkMLXMYYbETQ_tX-3FAHHsxb18,10880
 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=9r_lDvRYtbGLKjnH1yLuP4vxWn0_4xS4AkdDhvBg7Ko,7154
-model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=NCwuvnByeexLL987h67XhU8vQvCgq63bt0hFSiSSxvE,6400
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=5Uyb5CurpLm4fgOiARKYwy3T-bb0NMmJXIRBgRjMgjo,7301
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=R-kTbJka37u3toun9rRDGGGXYR3Sv4VdirLIn5G1BgQ,6541
 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
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py,sha256=Y-HZKwoakzY6PAYYj9l-h19yLMqBs0qBHo2YIKIsrN8,10375
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities_component.py,sha256=9Hg6AMCzTdDsKKgivRd61UjxGT5SWvKsc3mIUPPsYDQ,1021
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/layer_filter_params.py,sha256=dIu6k1xvGKLtk_47wq1eKYvrS4lYAknAXTeJfFstW0Y,3878
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/operations_to_layers.py,sha256=vZ7I2XDr_YDgU8oQt8gKkcuUOJf28DCzCPunPK2h_Xw,6563
@@ -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.20250514.602.dist-info/METADATA,sha256=G4fXoMcNvxB_V_F7hCVDXAJh5Q2bOmcBRS9FzqtQngM,25136
-mct_nightly-2.3.0.20250514.602.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-mct_nightly-2.3.0.20250514.602.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250514.602.dist-info/RECORD,,
+mct_nightly-2.3.0.20250516.613.dist-info/METADATA,sha256=WTFK8E9-__LO8PW9LL44DHCYKwUvNgKMkGl0ko8dcf0,25135
+mct_nightly-2.3.0.20250516.613.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+mct_nightly-2.3.0.20250516.613.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250516.613.dist-info/RECORD,,

{mct_nightly-2.3.0.20250514.602.dist-info → mct_nightly-2.3.0.20250516.613.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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.20250514.000602"
+__version__ = "2.3.0.20250516.000613"

model_compression_toolkit/constants.py

@@ -138,3 +138,8 @@ SHAPE = 'shape'
 NODE_NAME = 'node_name'
 TOTAL_SIZE = 'total_size'
 NODE_OUTPUT_INDEX = 'node_output_index'
+
+
+# Fusing Patterns constants
+FUSED_LAYER_PATTERN = 'fused_layer_pattern'
+FUSED_OP_QUANT_CONFIG = 'fused_op_quantization_config'

model_compression_toolkit/core/common/fusion/fusing_info.py

@@ -14,6 +14,8 @@
 #  ==============================================================================
 
 from model_compression_toolkit.target_platform_capabilities import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OpQuantizationConfig
+from model_compression_toolkit.constants import FUSED_LAYER_PATTERN, FUSED_OP_QUANT_CONFIG
 from dataclasses import dataclass, field
 
 from typing import Optional, List, Dict, Any, Tuple
@@ -41,6 +43,7 @@ class FusingInfo:
     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)
+    fused_op_id_to_quant_config: Dict[str, OpQuantizationConfig] = field(default_factory=dict)
 
     def __post_init__(self):
         """Validates and initializes mappings after dataclass instantiation."""
@@ -49,6 +52,7 @@ class FusingInfo:
             assert isinstance(op_nodes, tuple) and len(op_nodes) > 1, f"Found invalid fused op nodes: {op_nodes}"
 
         self._init_node_mapping()
+        self._init_quantization_config_map()
 
     def _init_node_mapping(self) -> None:
         """
@@ -59,6 +63,15 @@ class FusingInfo:
             for node in nodes:
                 self.node_to_fused_node_map[node.name] = op_id
 
+    def _init_quantization_config_map(self) -> None:
+        """
+        Init the mapping between fused operation IDs and their quantization configurations.
+        """
+        self.fused_op_id_to_quant_config.clear()
+        if self.fusing_patterns is not None:
+            for op_id, nodes in self.fusing_data.items():
+                self.set_fused_op_quantization_config(op_id, nodes)
+
     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.
@@ -78,6 +91,22 @@ class FusingInfo:
         for node in nodes:
             self.node_to_fused_node_map[node.name] = op_id
 
+        # Update the quantization config mapping for this operation
+        if self.fusing_patterns is not None:
+            self.set_fused_op_quantization_config(op_id, nodes)
+
+    def set_fused_op_quantization_config(self, op_id: str, nodes: Tuple['BaseNode']) -> None:
+        """
+        Set the quantization configuration for a given fused operation ID.
+
+        Args:
+            op_id (str): The identifier for the fused operation.
+            nodes (Tuple[BaseNode]): The tuple of nodes that form the fused operation.
+        """
+        fusing_pattern = next((fp for fp in self.fusing_patterns if is_valid_fusion([fp.get(FUSED_LAYER_PATTERN)], nodes)), None)
+        if fusing_pattern is not None:
+            self.fused_op_id_to_quant_config[op_id] = fusing_pattern.get(FUSED_OP_QUANT_CONFIG)
+
     def remove_fused_operation(self, op_id: str) -> None:
         """
         Remove a fused operation by its ID.
@@ -95,6 +124,7 @@ class FusingInfo:
         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]:
         """
@@ -117,6 +147,15 @@ class FusingInfo:
         """
         return self.node_to_fused_node_map.copy()
 
+    def get_fusing_quantization_config_map(self) -> Dict[str, OpQuantizationConfig]:
+        """
+        Retrieve a copy of the mapping from fused operation IDs to their quantization configurations.
+
+        Returns:
+            A dictionary mapping each fused operation ID to its quantization configuration.
+        """
+        return self.fused_op_id_to_quant_config.copy()
+
     def get_fused_nodes(self, op_id: str) -> Optional[List['BaseNode']]:
         """
         Retrieve the list of nodes for a given fused operation ID.
@@ -129,6 +168,18 @@ class FusingInfo:
         """
         return self.fusing_data.get(op_id)
 
+    def get_fused_op_quantization_config(self, op_id: str) -> OpQuantizationConfig:
+        """
+        Retrieve the quantization configuration for a given fused operation ID.
+
+        Args:
+            op_id (str): The identifier for the fused operation.
+
+        Returns:
+            OpQuantizationConfig: The quantization configuration for the operation, or None if not found.
+        """
+        return self.fused_op_id_to_quant_config.get(op_id)
+
     def is_node_in_fused_op(self, node: 'BaseNode') -> bool:
         """
         Check if a node is part of any fused operation.
@@ -216,10 +267,11 @@ class FusingInfo:
             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):
+            valid_fusing_patterns = _get_fusing_layer_patterns(self.fusing_patterns)
+            if not is_valid_fusion(valid_fusing_patterns, nodes):
                 raise ValueError(
                     f"Fused operation {op_id} does not match any valid fusing pattern "
-                    f"from {self.fusing_patterns}."
+                    f"from {valid_fusing_patterns}."
                 )
 
     def is_nodes_eligible_to_be_fused(self, nodes: List['BaseNode']) -> bool:
@@ -240,7 +292,8 @@ class FusingInfo:
             return False
 
         # Check if the provided nodes match a valid fusion pattern
-        return is_valid_fusion(fusing_patterns=self.fusing_patterns, nodes=nodes)
+        valid_fusing_patterns = _get_fusing_layer_patterns(self.fusing_patterns)
+        return is_valid_fusion(fusing_patterns=valid_fusing_patterns, nodes=nodes)
 
     def __repr__(self) -> str:
         """
@@ -287,8 +340,11 @@ class FusingInfoGenerator:
         if not self._fusing_patterns:
             return FusingInfo(fusing_patterns=self._fusing_patterns)
 
+        # Extract fusing layer patterns
+        fusing_layer_patterns = _get_fusing_layer_patterns(self._fusing_patterns)
+
         # Find max fusion
-        max_layers_fusing = max([len(fusing_pattern) for fusing_pattern in self._fusing_patterns])
+        max_layer_patterns = max([len(fusing_layer_pattern) for fusing_layer_pattern in fusing_layer_patterns])
 
         # Travel along the graph to find layers for fusing
         nodes = graph.get_topo_sorted_nodes()
@@ -302,9 +358,9 @@ class FusingInfoGenerator:
                 continue
             # Start fusing search
             fusing_nodes = []  # nodes that are candidates for participating in fusing
-            patterns = copy.deepcopy(self._fusing_patterns)
+            patterns = copy.deepcopy(fusing_layer_patterns)
             next_nodes = [node]
-            for i in range(max_layers_fusing):
+            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
@@ -314,7 +370,7 @@ class FusingInfoGenerator:
                     break
 
             # New fusion
-            if is_valid_fusion(self._fusing_patterns, fusing_nodes):
+            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)
@@ -371,3 +427,15 @@ def is_valid_fusion(fusing_patterns: List[List[Any]], nodes: List['BaseNode']) -
         if counter == fusion_depth:
             return True
     return False
+
+
+def _get_fusing_layer_patterns(fusing_patterns: List[Dict[Any, OpQuantizationConfig]]) -> List[List[Any]]:
+    """
+    Extracts the fusing layer patterns from the provided fusing patterns.
+    Args:
+        fusing_patterns: List of patterns of layers/LayerFilterParams to fuse and their mapping quantization config.
+
+    Returns:
+        supported fusing layer patterns
+    """
+    return [f.get(FUSED_LAYER_PATTERN) for f in fusing_patterns]

model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py

@@ -233,6 +233,7 @@ class PytorchModel(torch.nn.Module):
         self.return_float_outputs = return_float_outputs
         self.wrapper = wrapper
         self.get_activation_quantizer_holder = get_activation_quantizer_holder_fn
+        self.insert_preserving_quantizers = graph.fqc.insert_preserving_quantizers
         self.reuse_groups = {}
         self._reused_nodes = []
 
@@ -335,12 +336,17 @@ class PytorchModel(torch.nn.Module):
             activation_quantizer_holder = None
             if self.use_activation_holder_during_model_building:
                 if node.is_activation_quantization_enabled():
-                    activation_quantizer_holder = self.get_activation_quantizer_holder(node, holder_type=PytorchActivationQuantizationHolder)
+                    activation_quantizer_holder = self.get_activation_quantizer_holder(node,
+                                                                                       holder_type=PytorchActivationQuantizationHolder)
                 
                 elif node.is_quantization_preserving():
                     prev_node = self.graph.retrieve_preserved_quantization_node(node)
                     if prev_node.is_activation_quantization_enabled():
-                        activation_quantizer_holder = self.get_activation_quantizer_holder(prev_node, holder_type=PytorchPreservingActivationQuantizationHolder)
+                        if self.insert_preserving_quantizers:
+                            holder_kwargs = {'quantization_bypass': True}
+                            activation_quantizer_holder = self.get_activation_quantizer_holder(prev_node,
+                                                                                               holder_type=PytorchPreservingActivationQuantizationHolder,
+                                                                                               **holder_kwargs)
 
             if activation_quantizer_holder is not None:
                 activation_quantizer_holder_name = node.name + '_' + ACTIVATION_HOLDER_QUANTIZER

model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py

@@ -65,26 +65,29 @@ if FOUND_TORCH:
         return module
 
 
-    def get_activation_quantizer_holder(node: BaseNode, holder_type: PytorchActivationQuantizationHolder, fw_impl) -> Callable:
+    def get_activation_quantizer_holder(node: BaseNode, holder_type: PytorchActivationQuantizationHolder,
+                                        fw_impl, **kwargs) -> Callable:
         """
         Retrieve a PytorchActivationQuantizationHolder layer to use for activation quantization of a node.
         If the layer is not supposed to be wrapped with an activation quantizer - return None.
+
         Args:
             node: Node to attach a PytorchActivationQuantizationHolder to its output.
             holder_type: The type of the activation quantization holder to use.
             fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+            **kwargs: Key-arguments to be passed to the quantization holder initialization to set specific arguments
+                based on the holder's type.
+
         Returns:
             A PytorchActivationQuantizationHolder module for the node's activation quantization.
         """
         # Holder by definition uses a single quantizer for the activation quantization
-        # thus we make sure this is the only possible case (unless it's a node we no activation
+        # thus we make sure this is the only possible case (unless it's a node with no activation
         # quantization, which in this case has an empty list).
         _, activation_quantizers = fw_impl.get_inferable_quantizers(node)
         if len(activation_quantizers) == 1:
-            if holder_type == PytorchActivationQuantizationHolder:
-                return holder_type(activation_quantizers[0])
-            elif holder_type == PytorchPreservingActivationQuantizationHolder:
-                return holder_type(activation_quantizers[0], quantization_bypass=True)
+            return holder_type(activation_quantizers[0], **kwargs)
+
         Logger.critical(
             f'PytorchActivationQuantizationHolder supports a single quantizer but {len(activation_quantizers)} quantizers '
             f'were found for node {node}')
@@ -105,9 +108,9 @@ if FOUND_TORCH:
                                                           wrapper=lambda n, m:
                                                           fully_quantized_wrapper(n, m,
                                                                                   fw_impl=fw_impl),
-                                                          get_activation_quantizer_holder_fn=lambda n, holder_type:
+                                                          get_activation_quantizer_holder_fn=lambda n, holder_type, **kwargs:
                                                           get_activation_quantizer_holder(n, holder_type,
-                                                                                          fw_impl=fw_impl)).build_model()
+                                                                                          fw_impl=fw_impl, **kwargs)).build_model()
 
         Logger.info("\nPlease run your accuracy evaluation on the exported quantized model to verify it's accuracy.\n"
                     "Checkout the FAQ and Troubleshooting pages for resolving common issues and improving the quantized model accuracy:\n"

model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py

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

model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py

@@ -12,14 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+import copy
 from typing import Any, Union
 
 import model_compression_toolkit.target_platform_capabilities.schema.v1 as schema_v1
 import model_compression_toolkit.target_platform_capabilities.schema.v2 as schema_v2
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as current_schema
 
-ALL_SCHEMA_VERSIONS = [schema_v1]  # needs to be updated with all active schema versions
-FUTURE_SCHEMA_VERSIONS = [schema_v2]  # once future schema becomes current schema, move to it ALL_SCHEMA_VERSIONS
+ALL_SCHEMA_VERSIONS = [schema_v1, schema_v2]  # needs to be updated with all active schema versions
+FUTURE_SCHEMA_VERSIONS = []  # once future schema becomes current schema, move to it ALL_SCHEMA_VERSIONS
 all_tpc_types = tuple([s.TargetPlatformCapabilities for s in ALL_SCHEMA_VERSIONS])
 tpc_or_str_type = all_tpc_types + (str,)
 
@@ -33,19 +34,57 @@ def is_tpc_instance(tpc_obj_or_path: Any) -> bool:
     return type(tpc_obj_or_path) in all_tpc_types
 
 
-def _schema_v1_to_v2(tpc: schema_v1.TargetPlatformCapabilities) -> schema_v2.TargetPlatformCapabilities:  # pragma: no cover
+def get_schema_by_version(schema_version: str):
+    return {
+        "1": schema_v1,
+        "2": schema_v2
+    }[schema_version]
+
+
+def _schema_v1_to_v2(
+        tpc: schema_v1.TargetPlatformCapabilities) -> schema_v2.TargetPlatformCapabilities:
     """
-    Converts given tpc of schema version 1 to schema version 2
-    :return: TargetPlatformCapabilities instance of of schema version 2
+    Converts given tpc of schema version 1 to schema version 2.
+    Schema v2 updates:
+    1. New TPC field: insert_preserving_quantizers
+        Compatability behavior: Set field to False by default
+    2. New field in Fusing: fuse_op_quantization_config
+        Compatability behavior: set enable_activation_quantization=False in every fuse_op_quantization_config
+    3. New operator set names: EXP, SIN, COS
+        Compatability behavior: Not required
+    :return: TargetPlatformCapabilities instance of schema version 2
     """
-    raise NotImplementedError("Once schema v2 is implemented, add necessary adaptations to _schema_v1_to_v2 function and remove 'pragma: no cover'")
-    return schema_v2.TargetPlatformCapabilities(default_qco=tpc.default_qco,
-                                             operator_set=tpc.operator_set,
-                                             fusing_patterns=tpc.fusing_patterns,
-                                             tpc_minor_version=tpc.tpc_minor_version,
-                                             tpc_patch_version=tpc.tpc_patch_version,
-                                             tpc_platform_type=tpc.tpc_platform_type,
-                                             add_metadata=tpc.add_metadata)
+    v1_default_qco = tpc.default_qco.base_config
+    v2_default_qco = schema_v2.OpQuantizationConfig(
+        default_weight_attr_config=v1_default_qco.default_weight_attr_config,
+        attr_weights_configs_mapping=v1_default_qco.attr_weights_configs_mapping,
+        activation_quantization_method=v1_default_qco.activation_quantization_method,
+        activation_n_bits=v1_default_qco.activation_n_bits,
+        supported_input_activation_n_bits=v1_default_qco.supported_input_activation_n_bits,
+        enable_activation_quantization=False,  # set to False by default because feature not exist in schema v1
+        quantization_preserving=v1_default_qco.quantization_preserving,
+        fixed_scale=v1_default_qco.fixed_scale,
+        fixed_zero_point=v1_default_qco.fixed_zero_point,
+        simd_size=v1_default_qco.simd_size,
+        signedness=v1_default_qco.signedness)
+
+    schema_v2_fusing_patters = []
+    for fussing_pattern in tpc.fusing_patterns:
+        schema_v2_fusing_patters.append(
+            schema_v2.Fusing(operator_groups=fussing_pattern.operator_groups,
+                             fuse_op_quantization_config=copy.deepcopy(v2_default_qco),
+                             name=fussing_pattern.name))
+
+    tpc_schema_v2 = schema_v2.TargetPlatformCapabilities(default_qco=tpc.default_qco,
+                                                         operator_set=tpc.operator_set,
+                                                         fusing_patterns=schema_v2_fusing_patters,
+                                                         tpc_minor_version=tpc.tpc_minor_version,
+                                                         tpc_patch_version=tpc.tpc_patch_version,
+                                                         tpc_platform_type=tpc.tpc_platform_type,
+                                                         add_metadata=tpc.add_metadata,
+                                                         insert_preserving_quantizers=False)  # set to False by default because feature not exist in schema v1
+    return tpc_schema_v2
+
 
 def get_conversion_map() -> dict:
     """
@@ -60,7 +99,8 @@ def get_conversion_map() -> dict:
     return conversion_map
 
 
-def tpc_to_current_schema_version(tpc: Union[all_tpc_types]) -> current_schema.TargetPlatformCapabilities:  # pragma: no cover
+def tpc_to_current_schema_version(
+        tpc: Union[all_tpc_types]) -> current_schema.TargetPlatformCapabilities:
     """
     Given tpc instance of some schema version, convert it to the current MCT schema version.
 

model_compression_toolkit/target_platform_capabilities/schema/v2.py

@@ -91,6 +91,8 @@ class OperatorSetNames(str, Enum):
     STRIDED_SLICE = "StridedSlice"
     SSD_POST_PROCESS = "SSDPostProcess"
     EXP = "Exp"
+    SIN = "Sin"
+    COS = "Cos"
 
     @classmethod
     def get_values(cls):
@@ -218,11 +220,11 @@ class TargetPlatformCapabilities(BaseModel):
         SCHEMA_VERSION (int): Version of the schema for the Target Platform Model.
     """
     default_qco: QuantizationConfigOptions
-    operator_set: Optional[Tuple[OperatorsSet, ...]]
-    fusing_patterns: Optional[Tuple[Fusing, ...]]
-    tpc_minor_version: Optional[int]
-    tpc_patch_version: Optional[int]
-    tpc_platform_type: Optional[str]
+    operator_set: Optional[Tuple[OperatorsSet, ...]] = None
+    fusing_patterns: Optional[Tuple[Fusing, ...]] = None
+    tpc_minor_version: Optional[int] = None
+    tpc_patch_version: Optional[int] = None
+    tpc_platform_type: Optional[str] = None
     add_metadata: bool = True
     name: Optional[str] = "default_tpc"
 

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py

@@ -100,7 +100,10 @@ class AttachTpcToKeras(AttachTpcToFramework):
             OperatorSetNames.LOG_SOFTMAX: [tf.nn.log_softmax],
             OperatorSetNames.ADD_BIAS: [tf.nn.bias_add],
             OperatorSetNames.L2NORM: [tf.math.l2_normalize],
-            OperatorSetNames.SSD_POST_PROCESS: [SSDPostProcess]
+            OperatorSetNames.SSD_POST_PROCESS: [SSDPostProcess],
+            OperatorSetNames.EXP: [tf.math.exp],
+            OperatorSetNames.SIN: [tf.math.sin],
+            OperatorSetNames.COS: [tf.math.cos]
         }
 
         self._opset2attr_mapping = {

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py

@@ -99,6 +99,9 @@ class AttachTpcToPytorch(AttachTpcToFramework):
                                                         Eq('p', 2) | Eq('p', None))],
             OperatorSetNames.SSD_POST_PROCESS: [],  # no such operator in pytorch
             OperatorSetNames.COMBINED_NON_MAX_SUPPRESSION: [MulticlassNMS, MulticlassNMSWithIndices],
+            OperatorSetNames.EXP: [torch.exp],
+            OperatorSetNames.SIN: [torch.sin],
+            OperatorSetNames.COS: [torch.cos],
         }
 
         pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py

@@ -31,6 +31,9 @@ from model_compression_toolkit.target_platform_capabilities.schema.mct_current_s
     OpQuantizationConfig, QuantizationConfigOptions
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.current_tpc import  _current_tpc
 
+from model_compression_toolkit.constants import FUSED_LAYER_PATTERN, FUSED_OP_QUANT_CONFIG
+
+
 class FrameworkQuantizationCapabilities(ImmutableClass):
     """
     Attach framework information to a modeled hardware.
@@ -94,20 +97,26 @@ class FrameworkQuantizationCapabilities(ImmutableClass):
         """
         return self.op_sets_to_layers.get_layers_by_op(op)
 
-    def get_fusing_patterns(self) -> List[List[Any]]:
+    def get_fusing_patterns(self) -> List[Dict[List[Any], OpQuantizationConfig]]:
         """
 
-        Returns: List of patterns of layers/LayerFilterParams to fuse.
+        Returns: List of patterns of layers/LayerFilterParams to fuse and their mapping quantization config.
 
         """
-        res = []
+
+        patterns = []
         if self.tpc.fusing_patterns is None:
-            return res
+            return patterns
+
         for p in self.tpc.fusing_patterns:
+            res = []
             ops = [self.get_layers_by_opset(x) for x in p.operator_groups]
             res.extend(itertools.product(*ops))
-        return [list(x) for x in res]
 
+            fused_op_quant_config = getattr(p, FUSED_OP_QUANT_CONFIG, None)
+            patterns.extend({FUSED_LAYER_PATTERN: list(x), FUSED_OP_QUANT_CONFIG: fused_op_quant_config} for x in res)
+
+        return patterns
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -230,7 +239,17 @@ class FrameworkQuantizationCapabilities(ImmutableClass):
     def is_simd_padding(self) -> bool:
         """
 
-        Returns: Check if the TP model defines that padding due to SIMD constrains occurs.
+        Returns: Check if the TPC defines that padding due to SIMD constrains occurs.
 
         """
         return self.tpc.is_simd_padding
+
+    @property
+    def insert_preserving_quantizers(self) -> bool:
+        """
+
+        Returns: Check if the TPC defines that a quantizer for quantization preserving operators should be added to the
+            constructed model.
+
+        """
+        return self.tpc.insert_preserving_quantizers

model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py

@@ -12,12 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+import json
 from pathlib import Path
 from typing import Union
 
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.target_platform_capabilities.schema.schema_compatability import is_tpc_instance, \
-    tpc_to_current_schema_version, tpc_or_str_type
+    tpc_to_current_schema_version, tpc_or_str_type, get_schema_by_version
+
+
+def _get_json_schema(tpc_json_path: str):
+    """
+    Given a TPC json file path, extract the schema version from it, and return schema object matched to that
+    schema version.
+    """
+    with open(tpc_json_path, 'r', encoding='utf-8') as f:
+        schema_version = str(json.load(f)["SCHEMA_VERSION"])
+    return get_schema_by_version(schema_version)
 
 
 def _get_tpc_from_json(tpc_path: str) -> schema.TargetPlatformCapabilities:
@@ -40,7 +51,11 @@ def _get_tpc_from_json(tpc_path: str) -> schema.TargetPlatformCapabilities:
         raise ValueError(f"Error reading the file '{tpc_path}': {e.strerror}.") from e
 
     try:
-        return schema.TargetPlatformCapabilities.parse_raw(data)
+        # json_schema = _get_json_schema(tpc_path)
+        # tpc = json_schema.TargetPlatformCapabilities.parse_raw(data)
+        # return tpc_to_current_schema_version(tpc)
+        tpc = schema.TargetPlatformCapabilities.parse_raw(data)
+        return tpc_to_current_schema_version(tpc)
     except ValueError as e:
         raise ValueError(f"Invalid JSON for loading TargetPlatformCapabilities in '{tpc_path}': {e}.") from e
     except Exception as e: