mct-nightly 2.3.0.20250409.529__tar.gz → 2.3.0.20250411.529__tar.gz

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250409.529
+Version: 2.3.0.20250411.529
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
@@ -22,6 +22,7 @@ Requires-Dist: scipy
 Requires-Dist: protobuf
 Requires-Dist: mct-quantizers-nightly
 Requires-Dist: pydantic<2.0
+Requires-Dist: sony-custom-layers-dev==0.4.0.dev6
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250409.529
+Version: 2.3.0.20250411.529
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
@@ -22,6 +22,7 @@ Requires-Dist: scipy
 Requires-Dist: protobuf
 Requires-Dist: mct-quantizers-nightly
 Requires-Dist: pydantic<2.0
+Requires-Dist: sony-custom-layers-dev==0.4.0.dev6
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/mct_nightly.egg-info/SOURCES.txt

@@ -444,6 +444,7 @@ model_compression_toolkit/target_platform_capabilities/immutable.py
 model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py
 model_compression_toolkit/target_platform_capabilities/schema/__init__.py
 model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py
+model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py
 model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py
 model_compression_toolkit/target_platform_capabilities/schema/v1.py
 model_compression_toolkit/target_platform_capabilities/schema/v2.py

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/mct_nightly.egg-info/requires.txt

@@ -11,3 +11,4 @@ scipy
 protobuf
 mct-quantizers-nightly
 pydantic<2.0
+sony-custom-layers-dev==0.4.0.dev6

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/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.20250409.000529"
+__version__ = "2.3.0.20250411.000529"

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/common/framework_implementation.py

@@ -93,6 +93,17 @@ class FrameworkImplementation(ABC):
         raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
                              f'framework\'s to_tensor method.')  # pragma: no cover
 
+    @abstractmethod
+    def is_tuple_of_tensors(self, obj: Any) -> bool:
+        """
+        Check if a given object if a tuple of tensors
+        :param obj: Object to check its type
+        :return: True if obj is a tuple of tensors, False otherwise
+        """
+        raise NotImplementedError(f'{self.__class__.__name__} has to implement the '
+                             f'framework\'s is_tuple_of_tensors method.')  # pragma: no cover
+
+
     @abstractmethod
     def model_reader(self,
                      model: Any,

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py

@@ -72,8 +72,7 @@ class HessianScoresCalculator(ABC):
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement compute method.')  # pragma: no cover
 
-    @staticmethod
-    def unfold_tensors_list(tensors_to_unfold: Any) -> List[Any]:
+    def unfold_tensors_list(self, tensors_to_unfold: Any) -> List[Any]:
         """
         Unfold (flatten) a nested tensors list.
         Given a mixed list of single tensors and nested tensor lists,
@@ -85,6 +84,9 @@ class HessianScoresCalculator(ABC):
         """
         unfold_tensors = []
         for tensor in tensors_to_unfold:
+            if self.fw_impl.is_tuple_of_tensors(tensor):
+                tensor = list(tensor)  # converts named tuple to list
+
             if isinstance(tensor, List):
                 unfold_tensors += tensor
             else:

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/common/quantization/debug_config.py

@@ -29,8 +29,10 @@ class DebugConfig:
          enabled) or not. Can be used to pinpoint problematic layers in the quantization process.
         network_editor (List[EditRule]): A list of rules and actions to edit the network for quantization.
         simulate_scheduler (bool): Simulate scheduler behavior to compute operators' order and cuts.
+        bypass (bool): A flag to enable MCT bypass, which skips MCT runner and returns the input model unchanged.
     """
 
     analyze_similarity: bool = False
     network_editor: List[EditRule] = field(default_factory=list)
     simulate_scheduler: bool = False
+    bypass: bool = False

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/keras/keras_implementation.py

@@ -159,6 +159,19 @@ class KerasImplementation(FrameworkImplementation):
         """
         return to_tf_tensor(tensor)
 
+    def is_tuple_of_tensors(self, obj: Any) -> bool:
+        """
+        Check if a given object if a tuple of tensors
+        :param obj: Object to check its type
+        :return: True if obj is a tuple of tensors, False otherwise
+        """
+        if not isinstance(obj, tuple):
+            return False
+        for item in obj:
+            if not isinstance(item, tf.Tensor):
+                return False
+        return True
+
     def model_builder(self,
                       graph: Graph,
                       mode: ModelBuilderMode,
@@ -454,7 +467,7 @@ class KerasImplementation(FrameworkImplementation):
             return True
 
         return any([node.is_match_type(_type) for _type in [Conv2D, DepthwiseConv2D, Conv2DTranspose, Dense,
-                                                            Concatenate, tf.concat, Add, tf.add]])
+                                                            Concatenate, tf.concat, Add, tf.add, tf.stack]])
 
     def get_mp_node_distance_fn(self, n: BaseNode,
                                 compute_distance_fn: Callable = None,

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/pytorch/graph_substitutions/substitutions/scaled_dot_product_attention.py

@@ -198,7 +198,6 @@ class ScaledDotProductDecomposition(BaseSubstitution):
         :param attention_node: the node to replace
         :return: A graph after the substitution
         """
-        print("In scale_dot_product_attention substitution@@@@@@@@")
         input_nodes = self._get_attention_input_nodes(graph, attention_node)
         q_node, k_node, v_node = input_nodes["q"], input_nodes["k"], input_nodes["v"]
         transpose_k_node = self._get_transpose_k_node(attention_node.name, k_node)

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -15,12 +15,12 @@
 import operator
 from copy import deepcopy
 from functools import partial
-from typing import List, Any, Tuple, Callable, Type, Dict, Generator
+from typing import List, Any, Tuple, Callable, Generator
 
 import numpy as np
 import torch
 from mct_quantizers import PytorchQuantizationWrapper, PytorchActivationQuantizationHolder
-from torch import sigmoid, softmax, add, cat, argmax, concat, concatenate
+from torch import sigmoid, softmax, add, cat, argmax, concat, concatenate, stack
 from torch.nn import Conv2d, ConvTranspose2d, Linear
 from torch.nn import Module, Sigmoid, Softmax
 
@@ -144,6 +144,19 @@ class PytorchImplementation(FrameworkImplementation):
         """
         return to_torch_tensor(tensor)
 
+    def is_tuple_of_tensors(self, obj: Any) -> bool:
+        """
+        Check if a given object if a tuple of tensors
+        :param obj: Object to check its type
+        :return: True if obj is a tuple of tensors, False otherwise
+        """
+        if not isinstance(obj, tuple):
+            return False
+        for item in obj:
+            if not isinstance(item, torch.Tensor):
+                return False
+        return True
+
     def model_reader(self,
                      module: Module,
                      representative_data_gen: Callable) -> Graph:
@@ -449,7 +462,7 @@ class PytorchImplementation(FrameworkImplementation):
 
         return any(node.is_match_type(_type) for _type in [Conv2d, Linear, ConvTranspose2d, Sigmoid, sigmoid, Softmax,
                                                            softmax, operator.add, add, cat, concat, concatenate,
-                                                           operator.concat])
+                                                           operator.concat, stack])
 
     def get_mp_node_distance_fn(self, n: BaseNode,
                                 compute_distance_fn: Callable = None,

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/pytorch/reader/reader.py

@@ -13,19 +13,40 @@
 # limitations under the License.
 # ==============================================================================
 
-
-import logging
-from typing import Callable, Dict
-
-import numpy as np
 import torch
-from torch.fx import symbolic_trace
+import logging
+from typing import Callable, Dict, Union, Any
 from torch.fx.passes.shape_prop import ShapeProp
+from torch.fx import Tracer, GraphModule, symbolic_trace
 
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.pytorch.reader.graph_builders import edges_builder, nodes_builder
 from model_compression_toolkit.core.pytorch.utils import set_model
+from sony_custom_layers.pytorch import CustomLayer
+
+
+def _trace_model(root: Union[torch.nn.Module, Callable[..., Any]]) -> GraphModule:
+    """
+    Given an ``nn.Module`` or function instance ``root``, this function will return a ``GraphModule``
+    constructed by recording operations seen while tracing through ``root``.
+    This function replaces torch.fx.symbolic_trace in order to handle custom layers tracing - treating them as graph
+    leafs.
+    :param root: Module or function to be traced and converted into a Graph representation.
+    :return: GraphModule: a Module created from the recorded operations from ``root``.
+    """
+
+    class MCTTracer(Tracer):
+        def is_leaf_module(self, m: torch.nn.Module, module_qualified_name: str) -> bool:
+            if isinstance(m, CustomLayer):
+                return True
+            return super().is_leaf_module(m, module_qualified_name)
+
+    tracer = MCTTracer()
+    graph = tracer.trace(root)
+    # handling the possibility that the model (root) might be a torch.nn.Module or a function
+    model_name = (root.__class__.__name__ if isinstance(root, torch.nn.Module) else root.__name__)
+    return GraphModule(tracer.root, graph, model_name)
 
 
 def generate_module_dict(model: torch.nn.Module) -> Dict:
@@ -87,7 +108,7 @@ def fx_graph_module_generation(pytorch_model: torch.nn.Module,
     set_model(pytorch_model)
 
     try:
-        symbolic_traced = symbolic_trace(pytorch_model)
+        symbolic_traced = _trace_model(pytorch_model)
     except torch.fx.proxy.TraceError as e:
         Logger.critical(f'Error parsing model with torch.fx\n'
                         f'fx error: {e}')

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/core/pytorch/utils.py

@@ -15,7 +15,7 @@
 import torch
 from torch import Tensor
 import numpy as np
-from typing import Union, Sequence, Optional, List, Tuple
+from typing import Union, Optional, List, Tuple, Any
 
 from model_compression_toolkit.core.pytorch.constants import MAX_FLOAT16, MIN_FLOAT16
 from model_compression_toolkit.core.pytorch.pytorch_device_config import get_working_device
@@ -112,4 +112,4 @@ def clip_inf_values_float16(tensor: Tensor) -> Tensor:
     # Replace inf values with max float16 value
     tensor[inf_mask] = MAX_FLOAT16 * torch.sign(tensor[inf_mask])
 
-    return tensor
+    return tensor

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 import copy
 
-from typing import Callable, Tuple, Union
+from typing import Callable, Tuple, Union, Optional
 from packaging import version
 
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
@@ -158,7 +158,7 @@ if FOUND_TF:
                                                   target_resource_utilization: ResourceUtilization = None,
                                                   core_config: CoreConfig = CoreConfig(),
                                                   target_platform_capabilities: Union[TargetPlatformCapabilities, str]
-                                                  = DEFAULT_KERAS_TPC) -> Tuple[Model, UserInformation]:
+                                                  = DEFAULT_KERAS_TPC) -> Tuple[Model, Optional[UserInformation]]:
         """
         Quantize a trained Keras model using post-training quantization. The model is quantized using a
         symmetric constraint quantization thresholds (power of two).
@@ -230,6 +230,10 @@ if FOUND_TF:
             >>> quantized_model, quantization_info = mct.gptq.keras_gradient_post_training_quantization(model, repr_datagen, gptq_config, target_resource_utilization=ru, core_config=config)
 
         """
+
+        if core_config.debug_config.bypass:
+            return in_model, None
+
         KerasModelValidation(model=in_model,
                              fw_info=DEFAULT_KERAS_INFO).validate()
 

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 import copy
-from typing import Callable, Union
+from typing import Callable, Union, Optional, Tuple
 
 from model_compression_toolkit.constants import ACT_HESSIAN_DEFAULT_BATCH_SIZE, PYTORCH, GPTQ_HESSIAN_NUM_SAMPLES
 from model_compression_toolkit.core import CoreConfig
@@ -22,6 +22,7 @@ from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quant
     MixedPrecisionQuantizationConfig
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import \
     ResourceUtilization
+from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.gptq.common.gptq_config import (
@@ -147,7 +148,8 @@ if FOUND_TORCH:
                                                     core_config: CoreConfig = CoreConfig(),
                                                     gptq_config: GradientPTQConfig = None,
                                                     gptq_representative_data_gen: Callable = None,
-                                                    target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC):
+                                                    target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC
+                                                    ) -> Tuple[Module, Optional[UserInformation]]:
         """
         Quantize a trained Pytorch module using post-training quantization.
         By default, the module is quantized using a symmetric constraint quantization thresholds
@@ -206,6 +208,9 @@ if FOUND_TORCH:
 
         """
 
+        if core_config.debug_config.bypass:
+            return model, None
+
         if core_config.is_mixed_precision_enabled:    # pragma: no cover
             if not isinstance(core_config.mixed_precision_config, MixedPrecisionQuantizationConfig):
                 Logger.critical("Given quantization config for mixed-precision is not of type 'MixedPrecisionQuantizationConfig'. "

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/ptq/keras/quantization_facade.py

@@ -14,11 +14,12 @@
 # ==============================================================================
 import copy
 
-from typing import Callable
+from typing import Callable, Tuple, Optional
 
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.analyzer import analyzer_model_quantization
 from model_compression_toolkit.core.common.quantization.quantize_graph_weights import quantize_graph_weights
+from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import TENSORFLOW
@@ -52,7 +53,8 @@ if FOUND_TF:
                                          representative_data_gen: Callable,
                                          target_resource_utilization: ResourceUtilization = None,
                                          core_config: CoreConfig = CoreConfig(),
-                                         target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
+                                         target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC
+                                         ) -> Tuple[Model, Optional[UserInformation]]:
         """
          Quantize a trained Keras model using post-training quantization. The model is quantized using a
          symmetric constraint quantization thresholds (power of two).
@@ -123,6 +125,9 @@ if FOUND_TF:
 
          """
 
+        if core_config.debug_config.bypass:
+            return in_model, None
+
         fw_info = DEFAULT_KERAS_INFO
 
         KerasModelValidation(model=in_model,

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/ptq/pytorch/quantization_facade.py

@@ -14,8 +14,9 @@
 # ==============================================================================
 import copy
 
-from typing import Callable, Union
+from typing import Callable, Union, Tuple, Optional
 
+from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import PYTORCH
@@ -49,7 +50,8 @@ if FOUND_TORCH:
                                            representative_data_gen: Callable,
                                            target_resource_utilization: ResourceUtilization = None,
                                            core_config: CoreConfig = CoreConfig(),
-                                           target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC):
+                                           target_platform_capabilities: Union[TargetPlatformCapabilities, str] = DEFAULT_PYTORCH_TPC
+                                           ) -> Tuple[Module, Optional[UserInformation]]:
         """
         Quantize a trained Pytorch module using post-training quantization.
         By default, the module is quantized using a symmetric constraint quantization thresholds
@@ -97,6 +99,9 @@ if FOUND_TORCH:
 
         """
 
+        if core_config.debug_config.bypass:
+            return in_module, None
+
         fw_info = DEFAULT_PYTORCH_INFO
 
         if core_config.is_mixed_precision_enabled:

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

@@ -0,0 +1,84 @@
+# 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

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/target_platform_capabilities/schema/v2.py

@@ -110,4 +110,5 @@ class TargetPlatformCapabilities(BaseModel):
         """
         Display the TargetPlatformCapabilities.
         """
-        pprint.pprint(self.get_info(), sort_dicts=False)
+        pprint.pprint(self.get_info(), sort_dicts=False)
+

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py

@@ -19,10 +19,8 @@ from packaging import version
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import LayerFilterParams
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2fw import \
     AttachTpcToFramework
-from model_compression_toolkit.verify_packages import FOUND_SONY_CUSTOM_LAYERS
 
-if FOUND_SONY_CUSTOM_LAYERS:
-    from sony_custom_layers.keras.object_detection.ssd_post_process import SSDPostProcess
+from sony_custom_layers.keras.object_detection.ssd_post_process import SSDPostProcess
 
 if version.parse(tf.__version__) >= version.parse("2.13"):
     from keras.src.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
@@ -102,15 +100,9 @@ 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]
         }
 
-        if FOUND_SONY_CUSTOM_LAYERS:
-            self._opset2layer[OperatorSetNames.SSD_POST_PROCESS] = [SSDPostProcess]
-        else:
-            # If Custom layers is not installed then we don't want the user to fail, but just ignore custom layers
-            # in the initialized framework TPC
-            self._opset2layer[OperatorSetNames.SSD_POST_PROCESS] = []
-
         self._opset2attr_mapping = {
             OperatorSetNames.CONV: {
                 KERNEL_ATTR: DefaultDict(default_value=KERAS_KERNEL),

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py

@@ -32,6 +32,7 @@ from model_compression_toolkit.target_platform_capabilities.targetplatform2frame
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2fw import \
     AttachTpcToFramework
 from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attribute_filter import Eq
+from sony_custom_layers.pytorch import MulticlassNMS, MulticlassNMSWithIndices
 
 
 class AttachTpcToPytorch(AttachTpcToFramework):
@@ -97,7 +98,7 @@ class AttachTpcToPytorch(AttachTpcToFramework):
             OperatorSetNames.L2NORM: [LayerFilterParams(torch.nn.functional.normalize,
                                                         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.COMBINED_NON_MAX_SUPPRESSION: [MulticlassNMS, MulticlassNMSWithIndices],
         }
 
         pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py

@@ -15,12 +15,39 @@
 from pathlib import Path
 from typing import Union
 
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
-import json
+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
 
 
-def load_target_platform_capabilities(tpc_obj_or_path: Union[TargetPlatformCapabilities, str]) -> TargetPlatformCapabilities:
+def _get_tpc_from_json(tpc_path: str) -> schema.TargetPlatformCapabilities:
+    """
+    Given a TPC json file path, parse it and returns a TargetPlatformCapabilities instance
+    :param tpc_path: json file path
+    :return: Parsed TargetPlatformCapabilities instance
+    """
+    path = Path(tpc_path)
+
+    if not path.exists() or not path.is_file():
+        raise FileNotFoundError(f"The path '{tpc_path}' is not a valid file.")
+    # Verify that the file has a .json extension
+    if path.suffix.lower() != '.json':
+        raise ValueError(f"The file '{path}' does not have a '.json' extension.")
+    try:
+        with path.open('r', encoding='utf-8') as file:
+            data = file.read()
+    except OSError as e:
+        raise ValueError(f"Error reading the file '{tpc_path}': {e.strerror}.") from e
+
+    try:
+        return schema.TargetPlatformCapabilities.parse_raw(data)
+    except ValueError as e:
+        raise ValueError(f"Invalid JSON for loading TargetPlatformCapabilities in '{tpc_path}': {e}.") from e
+    except Exception as e:
+        raise ValueError(f"Unexpected error while initializing TargetPlatformCapabilities: {e}.") from e
+
+
+def load_target_platform_capabilities(tpc_obj_or_path: Union[tpc_or_str_type]) -> schema.TargetPlatformCapabilities:
     """
         Parses the tpc input, which can be either a TargetPlatformCapabilities object
         or a string path to a JSON file.
@@ -36,37 +63,22 @@ def load_target_platform_capabilities(tpc_obj_or_path: Union[TargetPlatformCapab
             ValueError: If the JSON content is invalid or cannot initialize the TargetPlatformCapabilities.
             TypeError: If the input is neither a TargetPlatformCapabilities nor a valid JSON file path.
         """
-    if isinstance(tpc_obj_or_path, TargetPlatformCapabilities):
-        return tpc_obj_or_path
-
-    if isinstance(tpc_obj_or_path, str):
-        path = Path(tpc_obj_or_path)
-
-        if not path.exists() or not path.is_file():
-            raise FileNotFoundError(f"The path '{tpc_obj_or_path}' is not a valid file.")
-        # Verify that the file has a .json extension
-        if path.suffix.lower() != '.json':
-            raise ValueError(f"The file '{path}' does not have a '.json' extension.")
-        try:
-            with path.open('r', encoding='utf-8') as file:
-                data = file.read()
-        except OSError as e:
-            raise ValueError(f"Error reading the file '{tpc_obj_or_path}': {e.strerror}.") from e
-
-        try:
-            return TargetPlatformCapabilities.parse_raw(data)
-        except ValueError as e:
-            raise ValueError(f"Invalid JSON for loading TargetPlatformCapabilities in '{tpc_obj_or_path}': {e}.") from e
-        except Exception as e:
-            raise ValueError(f"Unexpected error while initializing TargetPlatformCapabilities: {e}.") from e
-
-    raise TypeError(
-        f"tpc_obj_or_path must be either a TargetPlatformCapabilities instance or a string path to a JSON file, "
-        f"but received type '{type(tpc_obj_or_path).__name__}'."
-    )
-
-
-def export_target_platform_capabilities(model: TargetPlatformCapabilities, export_path: Union[str, Path]) -> None:
+    if is_tpc_instance(tpc_obj_or_path):
+        tpc = tpc_obj_or_path
+    elif isinstance(tpc_obj_or_path, str):
+        tpc = _get_tpc_from_json(tpc_obj_or_path)
+    else:
+        raise TypeError(
+            f"tpc_obj_or_path must be either a TargetPlatformCapabilities instance or a string path to a JSON file, "
+            f"but received type '{type(tpc_obj_or_path).__name__}'."
+        )
+
+    if isinstance(tpc, schema.TargetPlatformCapabilities):  # if tpc is of current schema version
+        return tpc
+    return tpc_to_current_schema_version(tpc)
+
+
+def export_target_platform_capabilities(model: schema.TargetPlatformCapabilities, export_path: Union[str, Path]) -> None:
     """
     Exports a TargetPlatformCapabilities instance to a JSON file.
 
@@ -78,7 +90,7 @@ def export_target_platform_capabilities(model: TargetPlatformCapabilities, expor
         ValueError: If the model is not an instance of TargetPlatformCapabilities.
         OSError: If there is an issue writing to the file.
     """
-    if not isinstance(model, TargetPlatformCapabilities):
+    if not is_tpc_instance(model):
         raise ValueError("The provided model is not a valid TargetPlatformCapabilities instance.")
 
     path = Path(export_path)

{mct_nightly-2.3.0.20250409.529 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/verify_packages.py

@@ -30,4 +30,3 @@ FOUND_TORCH = importlib.util.find_spec("torch") is not None
 FOUND_TORCHVISION = importlib.util.find_spec("torchvision") is not None
 FOUND_ONNX = importlib.util.find_spec("onnx") is not None
 FOUND_ONNXRUNTIME = importlib.util.find_spec("onnxruntime") is not None
-FOUND_SONY_CUSTOM_LAYERS = importlib.util.find_spec('sony_custom_layers') is not None