mct-nightly 2.3.0.20250515.544__tar.gz → 2.3.0.20250516.613__tar.gz

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250515.544
+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.20250515.544 → mct_nightly-2.3.0.20250516.613}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250515.544
+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.20250515.544 → mct_nightly-2.3.0.20250516.613}/mct_nightly.egg-info/requires.txt

@@ -9,6 +9,6 @@ PuLP
 matplotlib<3.10.0
 scipy
 protobuf
-mct-quantizers-nightly
+mct-quantizers==1.6.0
 pydantic>=2.0
 edge-mdt-cl-dev

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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.20250515.000544"
+__version__ = "2.3.0.20250516.000613"

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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"

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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

mct_nightly-2.3.0.20250516.613/model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py

@@ -0,0 +1,124 @@
+# 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.
+# ==============================================================================
+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, 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,)
+
+
+def is_tpc_instance(tpc_obj_or_path: Any) -> bool:
+    """
+    Checks if the given object is an instance of a TargetPlatformCapabilities
+    :param tpc_obj_or_path: Object to check its type
+    :return: True if the given object is an instance of a TargetPlatformCapabilities, False otherwise
+    """
+    return type(tpc_obj_or_path) in all_tpc_types
+
+
+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.
+    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
+    """
+    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:
+    """
+    Retrieves the schema conversion map.
+    :return: A dictionary where:
+        - Keys representing supported source schema versions.
+        - Values are Callable functions that take tpc in one schema version and return it in the next (higher) version
+    """
+    conversion_map = {
+        schema_v1.TargetPlatformCapabilities: _schema_v1_to_v2,
+    }
+    return conversion_map
+
+
+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.
+
+    In case a new schema is added to MCT, need to add a conversion function from the previous version to the new
+    version, e.g. if the current schema version was updated from v4 to v5, need to add _schema_v4_to_v5 function to
+    this file, and add it to the conversion_map.
+
+    :param tpc: TargetPlatformCapabilities of some schema version
+    :return: TargetPlatformCapabilities with the current MCT schema version
+    """
+    conversion_map = get_conversion_map()
+    prev_tpc_type = type(tpc)
+    while not isinstance(tpc, current_schema.TargetPlatformCapabilities):
+        if type(tpc) not in conversion_map:
+            raise KeyError(f"TPC using schema version {tpc.SCHEMA_VERSION} which is not in schemas conversion map. "
+                           f"Make sure the schema version is supported, or add it in case it's a new schema version")
+        tpc = conversion_map[type(tpc)](tpc)
+        if isinstance(tpc, prev_tpc_type):
+            raise RuntimeError(f"TPC of type {prev_tpc_type} failed to update to next schema version")
+        prev_tpc_type = type(tpc)
+    return tpc

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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"
 

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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 = {

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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),

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/model_compression_toolkit/target_platform_capabilities/targetplatform2framework/framework_quantization_capabilities.py

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

{mct_nightly-2.3.0.20250515.544 → mct_nightly-2.3.0.20250516.613}/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:

mct_nightly-2.3.0.20250515.544/model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py

@@ -1,84 +0,0 @@
-# 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 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_tpc_types = tuple([s.TargetPlatformCapabilities for s in ALL_SCHEMA_VERSIONS])
-tpc_or_str_type = all_tpc_types + (str,)
-
-
-def is_tpc_instance(tpc_obj_or_path: Any) -> bool:
-    """
-    Checks if the given object is an instance of a TargetPlatformCapabilities
-    :param tpc_obj_or_path: Object to check its type
-    :return: True if the given object is an instance of a TargetPlatformCapabilities, False otherwise
-    """
-    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
-    """
-    Converts given tpc of schema version 1 to schema version 2
-    :return: TargetPlatformCapabilities instance of 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)
-
-def get_conversion_map() -> dict:
-    """
-    Retrieves the schema conversion map.
-    :return: A dictionary where:
-        - Keys representing supported source schema versions.
-        - Values are Callable functions that take tpc in one schema version and return it in the next (higher) version
-    """
-    conversion_map = {
-        schema_v1.TargetPlatformCapabilities: _schema_v1_to_v2,
-    }
-    return conversion_map
-
-
-def tpc_to_current_schema_version(tpc: Union[all_tpc_types]) -> current_schema.TargetPlatformCapabilities:  # pragma: no cover
-    """
-    Given tpc instance of some schema version, convert it to the current MCT schema version.
-
-    In case a new schema is added to MCT, need to add a conversion function from the previous version to the new
-    version, e.g. if the current schema version was updated from v4 to v5, need to add _schema_v4_to_v5 function to
-    this file, and add it to the conversion_map.
-
-    :param tpc: TargetPlatformCapabilities of some schema version
-    :return: TargetPlatformCapabilities with the current MCT schema version
-    """
-    conversion_map = get_conversion_map()
-    prev_tpc_type = type(tpc)
-    while not isinstance(tpc, current_schema.TargetPlatformCapabilities):
-        if type(tpc) not in conversion_map:
-            raise KeyError(f"TPC using schema version {tpc.SCHEMA_VERSION} which is not in schemas conversion map. "
-                           f"Make sure the schema version is supported, or add it in case it's a new schema version")
-        tpc = conversion_map[type(tpc)](tpc)
-        if isinstance(tpc, prev_tpc_type):
-            raise RuntimeError(f"TPC of type {prev_tpc_type} failed to update to next schema version")
-        prev_tpc_type = type(tpc)
-    return tpc