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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250331.610
+Version: 2.3.0.20250402.536
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

{mct_nightly-2.3.0.20250331.610.dist-info → mct_nightly-2.3.0.20250402.536.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mct_nightly-2.3.0.20250331.610.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-model_compression_toolkit/__init__.py,sha256=tulTPjSjSee0ySdxccC46EZ_AbQkEIr3RvtUps-6IME,1557
+mct_nightly-2.3.0.20250402.536.dist-info/licenses/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+model_compression_toolkit/__init__.py,sha256=dhPx1u7eKO_zAY9CefOYP31YislX9FLOXxMFWv9PVJo,1557
 model_compression_toolkit/constants.py,sha256=2ltuH-gdaLZoZV4CPUgKjC3S9ojz2z4OTVdenyVEypU,3912
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=L3q7tn3Uht0i_7phnlOWMR2Te2zvzrt2HOz9vYEInts,4529
@@ -34,8 +34,8 @@ model_compression_toolkit/core/common/fusion/__init__.py,sha256=Rf1RcYmelmdZmBV5
 model_compression_toolkit/core/common/fusion/graph_fuser.py,sha256=b41_4rL_Adiza4vpWlmmqgvkpUmWVdfdx0nEIB0p2n8,6195
 model_compression_toolkit/core/common/fusion/layer_fusing.py,sha256=-2fnjyC9q2RPw9st6RxROW-gdtT2mSRz0QZ_Gz1KDz4,5579
 model_compression_toolkit/core/common/graph/__init__.py,sha256=Xr-Lt_qXMdrCnnOaUS_OJP_3iTTGfPCLf8_vSrQgCs0,773
-model_compression_toolkit/core/common/graph/base_graph.py,sha256=VhniLTiMqL7i1Vqg2UBQuFFTvw2cYeJayssUJwabp3E,38112
-model_compression_toolkit/core/common/graph/base_node.py,sha256=kZbmAMh5cPAwYzlY8KYa8w0ipL58yApB09-WXQ8plrE,33763
+model_compression_toolkit/core/common/graph/base_graph.py,sha256=cSwHUqwZEiR1t2DaBfc7_qSJbtX8crpqerN4ol9v3H8,38859
+model_compression_toolkit/core/common/graph/base_node.py,sha256=CJu8_r80MGVnYmlAUGOGKGRsD9xShMyaRNb3VMeRC0s,34523
 model_compression_toolkit/core/common/graph/edge.py,sha256=buoSEUZwilWBK3WeBKpJ-GeDaUA1SDdOHxDpxU_bGpk,3784
 model_compression_toolkit/core/common/graph/functional_node.py,sha256=GH5wStmw8SoAj5IdT_-ItN1Meo_P5NUTt_5bgJC4fak,3935
 model_compression_toolkit/core/common/graph/graph_matchers.py,sha256=CrDoHYq4iPaflgJWmoJ1K4ziLrRogJvFTVWg8P0UcDU,4744
@@ -75,10 +75,10 @@ model_compression_toolkit/core/common/mixed_precision/set_layer_to_bitwidth.py,s
 model_compression_toolkit/core/common/mixed_precision/solution_refinement_procedure.py,sha256=fk7PWiZ6Na5O_Z_dymk_UfDCTqW_X_4EROU7DZknQnc,9444
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization.py,sha256=PKkhc5q8pEPnNLXwo3U56EOCfYnPXIvPs0LlCGZOoKU,4426
-model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=xCYL36K0nK41VSsLcy52uDA7zVfoLxhubmOrtXbqw7s,39140
+model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py,sha256=MP4Q5lThvEIhfa1iBajQQM3nCUNgK-2yseqQQ8Rgiog,40624
 model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_data.py,sha256=QQwtl08DiDxUOQGpYPnek_RlZjWm1Ky7tL2ESHXMK78,4050
 model_compression_toolkit/core/common/mixed_precision/search_methods/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
-model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=rSSN5MhH5BO5b58d8pe2pY9wc5HbfescoUStfg-nWfk,7263
+model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py,sha256=TaK5NqVdmygsHw9_x5JsJ-BPvlbKA9cRyTno1R8gbnU,7269
 model_compression_toolkit/core/common/network_editors/__init__.py,sha256=vZmu55bYqiaOQs3AjfwWDXHmuKZcLHt-wm7uR5fPEqg,1307
 model_compression_toolkit/core/common/network_editors/actions.py,sha256=nid0_j-Cn10xvmztT8yCKW_6uA7JEnom9SW9syx7wc0,19594
 model_compression_toolkit/core/common/network_editors/edit_network.py,sha256=dfgawi-nB0ocAJ0xcGn9E-Zv203oUnQLuMiXpX8vTgA,1748
@@ -435,13 +435,14 @@ model_compression_toolkit/target_platform_capabilities/constants.py,sha256=BFSgD
 model_compression_toolkit/target_platform_capabilities/immutable.py,sha256=YhROBiXEIB3TU-bAFrnL3qbAsb1yuWPBAQ_CLOJbYUU,1827
 model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py,sha256=4ydTWWKv_PEOAFok2JtxFNj8rav-0IlqcXKF6lnhHNE,4157
 model_compression_toolkit/target_platform_capabilities/schema/__init__.py,sha256=pKAdbTCFM_2BrZXUtTIw0ouKotrWwUDF_hP3rPwCM2k,696
-model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py,sha256=PvO8eHxnb3A55gyExT5fZGnOUl3ce7BbbT5SPxCEXNo,541
+model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py,sha256=hf539WJ3nBGn0RnALXrKmAPnbhJ-VmWmLIa207x8b4M,541
 model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py,sha256=vBkXxVJagm9JKB9cdm4Pvi7u_luriXUjvNn0-m8Zr0k,4653
 model_compression_toolkit/target_platform_capabilities/schema/v1.py,sha256=4CGpWENuOyjwaIMaGrFI0Act7jsSeT7m94pjrv91dxE,27516
+model_compression_toolkit/target_platform_capabilities/schema/v2.py,sha256=vUhCocA0EcjdR741Yv48W4Kr5Pq22Miebhm7F9GKb3Y,6086
 model_compression_toolkit/target_platform_capabilities/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=mxc3DBbUi-HDFgSx8Nmnyxr8SIdbx8lmtcRMsQl1BLE,7578
-model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=WPCqs_aFGE28XJf7KKB-SlrYoUNOcD9epgoaqQMCJMw,6320
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py,sha256=AE09QLE_QKwNqUTZbkZP9XLJStG1ECiTWmEGuXZTEsQ,7652
+model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py,sha256=-zbPmzQJal-1vZiQ6vIBBBnlEOB2DTb09koA0Aj4I_I,6396
 model_compression_toolkit/target_platform_capabilities/targetplatform2framework/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
@@ -526,7 +527,7 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=UVN_S9ULHBEldBpShCOt8-soT8YTQ5oE362y96qF_FA,3950
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.3.0.20250331.610.dist-info/METADATA,sha256=BSWkSPN58Xfzc8eImgBxCG3v_wXYt8c7l8oFNOOoyGw,27098
-mct_nightly-2.3.0.20250331.610.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mct_nightly-2.3.0.20250331.610.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.3.0.20250331.610.dist-info/RECORD,,
+mct_nightly-2.3.0.20250402.536.dist-info/METADATA,sha256=v7bHr6SXyb9qkbAmhb3xAHDXzinP-56xYnw-3SMtHVc,27098
+mct_nightly-2.3.0.20250402.536.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mct_nightly-2.3.0.20250402.536.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.3.0.20250402.536.dist-info/RECORD,,

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.20250331.000610"
+__version__ = "2.3.0.20250402.000536"

model_compression_toolkit/core/common/graph/base_graph.py

@@ -696,6 +696,23 @@ class Graph(nx.MultiDiGraph, GraphSearches):
         sorted_conf_activation = self.get_sorted_activation_configurable_nodes()
         return [(n, n.final_activation_quantization_cfg.activation_n_bits) for n in sorted_conf_activation]
 
+    def retrieve_preserved_quantization_node(self, node: BaseNode) -> BaseNode:
+        """
+        For a node with quantization_preserving == True, get the previous non-quantization_preserving node
+        to get activation quantization config from. If quantization_preserving is False return node.
+        Args:
+            node: quantization preserving node.
+
+        Returns:
+            The node that the quantization preserving node should get the activation quantization from.
+
+        """
+        while node.is_quantization_preserving():
+            prev_nodes = self.get_prev_nodes(node)
+            assert len(prev_nodes) == 1, "Activation preserving node should have only 1 input."
+            node = prev_nodes[0]
+        return node
+
     def update_fused_nodes(self, fusion: List[Any]):
         """
         Updates the graphs fusions list with a new list of nodes that have been fused.

model_compression_toolkit/core/common/graph/base_node.py

@@ -131,6 +131,19 @@ class BaseNode:
                    qc.activation_quantization_cfg.enable_activation_quantization
         return self.candidates_quantization_cfg[0].activation_quantization_cfg.enable_activation_quantization
 
+    def is_quantization_preserving(self) -> bool:
+        """
+        Returns: Whether node activation quantization information is preserved from its inputs.
+        """
+        if self.final_activation_quantization_cfg:
+            # if we have a final configuration, then we only care to check if it enables activation quantization.
+            return self.final_activation_quantization_cfg.quantization_preserving
+
+        for qc in self.candidates_quantization_cfg:
+            assert self.candidates_quantization_cfg[0].activation_quantization_cfg.quantization_preserving == \
+                   qc.activation_quantization_cfg.quantization_preserving
+        return self.candidates_quantization_cfg[0].activation_quantization_cfg.quantization_preserving
+
     def is_weights_quantization_enabled(self, attr_name: str) -> bool:
         """
         Checks whether a node's weights attribute quantization is enabled.

model_compression_toolkit/core/common/mixed_precision/resource_utilization_tools/resource_utilization_calculator.py

@@ -335,13 +335,35 @@ class ResourceUtilizationCalculator:
         """
         return self.compute_activation_utilization_by_cut(target_criterion, bitwidth_mode, act_qcs)
 
+    def _extract_qc(self, n: BaseNode, act_qcs: Optional[ActivationQCfgPerNode] = None
+                    ) -> Union[NodeActivationQuantizationConfig, None]:
+        """
+        Extract quantization config the activation configs dictionary is provided. If node is quantization
+        preserving, extract the quantization config from the preceding activation quantized node (i.e.
+        the Quantization the original node preserves).
+
+        Args:
+            n: Node to extract qc for.
+            act_qcs: custom activations quantization configuration. If not provided, the default
+             configuration will be extracted from the node.
+
+        Returns:
+            The relevant quantization config.
+        """
+        if act_qcs:
+            assert not (n.is_quantization_preserving() and act_qcs.get(n.name) is not None), \
+                f"Quantization preserving node {n.name} should not have a qc for this computation."
+            return act_qcs.get(self.graph.retrieve_preserved_quantization_node(n).name)
+        return None
+
     def compute_activation_utilization_by_cut(self,
                                               target_criterion: TargetInclusionCriterion,
                                               bitwidth_mode: BitwidthMode,
                                               act_qcs: Optional[ActivationQCfgPerNode] = None) \
             -> Tuple[float, Dict[Cut, Utilization], Dict[Cut, Dict[BaseNode, Utilization]]]:
         """
-        Compute graph activation cuts utilization.
+        Compute graph activation cuts utilization. If activation quantization configs are provided, then for
+        quantization preserving nodes, get the previous quantized activation node bit-width.
 
         Args:
             target_criterion: criterion to include weights for computation.
@@ -369,7 +391,7 @@ class ResourceUtilizationCalculator:
             if not cut_target_nodes:
                 continue
             for n in cut_target_nodes:
-                qc = act_qcs.get(n.name) if act_qcs else None
+                qc = self._extract_qc(n, act_qcs)
                 util_per_cut_per_node[cut][n.name] = self.compute_node_activation_tensor_utilization(n, target_criterion,
                                                                                                      bitwidth_mode, qc)
             util_per_cut[cut] = sum(util_per_cut_per_node[cut].values())    # type: ignore
@@ -384,7 +406,8 @@ class ResourceUtilizationCalculator:
                                                include_reused=False) \
             -> Tuple[float, Dict[NodeName, Utilization]]:
         """
-        Compute resource utilization for graph's activations tensors.
+        Compute resource utilization for graph's activations tensors. If activation quantization configs are provided, then for
+        quantization preserving nodes, get the previous quantized activation node bit-width.
 
         Args:
             target_criterion: criterion to include weights for computation.
@@ -405,7 +428,7 @@ class ResourceUtilizationCalculator:
 
         util_per_node: Dict[NodeName, Utilization] = {}
         for n in self._topo_sort(nodes):
-            qc = act_qcs.get(n.name) if act_qcs else None
+            qc = self._extract_qc(n, act_qcs)
             util = self.compute_node_activation_tensor_utilization(n, None, bitwidth_mode, qc)
             util_per_node[n.name] = util
 
@@ -659,7 +682,7 @@ class ResourceUtilizationCalculator:
         if target_criterion == TargetInclusionCriterion.QConfigurable:
             nodes = [n for n in nodes if n.has_configurable_activation()]
         elif target_criterion == TargetInclusionCriterion.AnyQuantized:
-            nodes = [n for n in nodes if n.is_activation_quantization_enabled()]
+            nodes = [n for n in nodes if n.is_activation_quantization_enabled() or n.is_quantization_preserving()]
         elif target_criterion == TargetInclusionCriterion.QNonConfigurable:
             nodes = [n for n in nodes if n.is_activation_quantization_enabled() and not n.has_configurable_activation()]
         elif target_criterion != TargetInclusionCriterion.Any:    # pragma: no cover
@@ -668,8 +691,7 @@ class ResourceUtilizationCalculator:
             nodes = [n for n in nodes if not n.reuse]
         return nodes
 
-    @classmethod
-    def _get_activation_nbits(cls,
+    def _get_activation_nbits(self,
                               n: BaseNode,
                               bitwidth_mode: BitwidthMode,
                               act_qc: Optional[NodeActivationQuantizationConfig]) -> int:
@@ -690,21 +712,22 @@ class ResourceUtilizationCalculator:
             assert bitwidth_mode == BitwidthMode.QCustom
             return act_qc.activation_n_bits if act_qc.enable_activation_quantization else FLOAT_BITWIDTH
 
-        if bitwidth_mode == BitwidthMode.Float or not n.is_activation_quantization_enabled():
+        if bitwidth_mode == BitwidthMode.Float or not (n.is_activation_quantization_enabled() or
+                                                       n.is_quantization_preserving()):
             return FLOAT_BITWIDTH
 
         if bitwidth_mode == BitwidthMode.Q8Bit:
             return 8
 
-        if bitwidth_mode in cls._bitwidth_mode_fn:
+        if bitwidth_mode in self._bitwidth_mode_fn:
             candidates_nbits = [c.activation_quantization_cfg.activation_n_bits for c in n.candidates_quantization_cfg]
-            return cls._bitwidth_mode_fn[bitwidth_mode](candidates_nbits)
+            return self._bitwidth_mode_fn[bitwidth_mode](candidates_nbits)
 
         if bitwidth_mode in [BitwidthMode.QCustom, BitwidthMode.QDefaultSP]:
-            qcs = n.get_unique_activation_candidates()
+            qcs = self.graph.retrieve_preserved_quantization_node(n).get_unique_activation_candidates()
             if len(qcs) != 1:
                 raise ValueError(f'Could not retrieve the activation quantization candidate for node {n} '
-                                 f'as it has {len(qcs)}!=1 unique candidates .')
+                                 f'as it has {len(qcs)}!=1 unique candidates.')
             return qcs[0].activation_quantization_cfg.activation_n_bits
 
         raise ValueError(f'Unknown mode {bitwidth_mode}')    # pragma: no cover

model_compression_toolkit/core/common/mixed_precision/search_methods/linear_programming.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 import numpy as np
 from pulp import *
-from typing import Dict, Tuple
+from typing import Dict, Tuple, List
 
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import RUTarget
 

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/v2.py

@@ -0,0 +1,177 @@
+# 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 pprint
+from enum import Enum
+from typing import Dict, Any, Tuple, Optional
+
+from pydantic import BaseModel, root_validator
+
+from mct_quantizers import QuantizationMethod
+from model_compression_toolkit.constants import FLOAT_BITWIDTH
+from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.target_platform_capabilities.schema.v1 import (
+    Signedness,
+    AttributeQuantizationConfig,
+    OpQuantizationConfig,
+    QuantizationConfigOptions,
+    TargetPlatformModelComponent,
+    OperatorsSetBase,
+    OperatorsSet,
+    OperatorSetGroup,
+    Fusing)
+
+
+class OperatorSetNames(str, Enum):
+    CONV = "Conv"
+    DEPTHWISE_CONV = "DepthwiseConv2D"
+    CONV_TRANSPOSE = "ConvTranspose"
+    FULLY_CONNECTED = "FullyConnected"
+    CONCATENATE = "Concatenate"
+    STACK = "Stack"
+    UNSTACK = "Unstack"
+    GATHER = "Gather"
+    EXPAND = "Expend"
+    BATCH_NORM = "BatchNorm"
+    L2NORM = "L2Norm"
+    RELU = "ReLU"
+    RELU6 = "ReLU6"
+    LEAKY_RELU = "LeakyReLU"
+    ELU = "Elu"
+    HARD_TANH = "HardTanh"
+    ADD = "Add"
+    SUB = "Sub"
+    MUL = "Mul"
+    DIV = "Div"
+    MIN = "Min"
+    MAX = "Max"
+    PRELU = "PReLU"
+    ADD_BIAS = "AddBias"
+    SWISH = "Swish"
+    SIGMOID = "Sigmoid"
+    SOFTMAX = "Softmax"
+    LOG_SOFTMAX = "LogSoftmax"
+    TANH = "Tanh"
+    GELU = "Gelu"
+    HARDSIGMOID = "HardSigmoid"
+    HARDSWISH = "HardSwish"
+    FLATTEN = "Flatten"
+    GET_ITEM = "GetItem"
+    RESHAPE = "Reshape"
+    UNSQUEEZE = "Unsqueeze"
+    SQUEEZE = "Squeeze"
+    PERMUTE = "Permute"
+    TRANSPOSE = "Transpose"
+    DROPOUT = "Dropout"
+    SPLIT_CHUNK = "SplitChunk"
+    MAXPOOL = "MaxPool"
+    AVGPOOL = "AvgPool"
+    SIZE = "Size"
+    SHAPE = "Shape"
+    EQUAL = "Equal"
+    ARGMAX = "ArgMax"
+    TOPK = "TopK"
+    FAKE_QUANT = "FakeQuant"
+    COMBINED_NON_MAX_SUPPRESSION = "CombinedNonMaxSuppression"
+    BOX_DECODE = "BoxDecode"
+    ZERO_PADDING2D = "ZeroPadding2D"
+    CAST = "Cast"
+    RESIZE = "Resize"
+    PAD = "Pad"
+    FOLD = "Fold"
+    STRIDED_SLICE = "StridedSlice"
+    SSD_POST_PROCESS = "SSDPostProcess"
+
+    @classmethod
+    def get_values(cls):
+        return [v.value for v in cls]
+
+
+class TargetPlatformCapabilities(BaseModel):
+    """
+    Represents the hardware configuration used for quantized model inference.
+
+    Attributes:
+        default_qco (QuantizationConfigOptions): Default quantization configuration options for the model.
+        operator_set (Optional[Tuple[OperatorsSet, ...]]): Tuple of operator sets within the model.
+        fusing_patterns (Optional[Tuple[Fusing, ...]]): Tuple of fusing patterns for the model.
+        tpc_minor_version (Optional[int]): Minor version of the Target Platform Configuration.
+        tpc_patch_version (Optional[int]): Patch version of the Target Platform Configuration.
+        tpc_platform_type (Optional[str]): Type of the platform for the Target Platform Configuration.
+        add_metadata (bool): Flag to determine if metadata should be added.
+        name (str): Name of the Target Platform Model.
+        is_simd_padding (bool): Indicates if SIMD padding is applied.
+        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]
+    add_metadata: bool = True
+    name: Optional[str] = "default_tpc"
+    is_simd_padding: bool = False
+
+    SCHEMA_VERSION: int = 2
+
+    class Config:
+        frozen = True
+
+    @root_validator(allow_reuse=True)
+    def validate_after_initialization(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Perform validation after the model has been instantiated.
+
+        Args:
+            values (Dict[str, Any]): The instantiated target platform model.
+
+        Returns:
+            Dict[str, Any]: The validated values.
+        """
+        # Validate `default_qco`
+        default_qco = values.get('default_qco')
+        if len(default_qco.quantization_configurations) != 1:
+            Logger.critical("Default QuantizationConfigOptions must contain exactly one option.")  # pragma: no cover
+
+        # Validate `operator_set` uniqueness
+        operator_set = values.get('operator_set')
+        if operator_set is not None:
+            opsets_names = [
+                op.name.value if isinstance(op.name, OperatorSetNames) else op.name
+                for op in operator_set
+            ]
+            if len(set(opsets_names)) != len(opsets_names):
+                Logger.critical("Operator Sets must have unique names.")  # pragma: no cover
+
+        return values
+
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get a dictionary summarizing the TargetPlatformCapabilities properties.
+
+        Returns:
+            Dict[str, Any]: Summary of the TargetPlatformCapabilities properties.
+        """
+        return {
+            "Model name": self.name,
+            "Operators sets": [o.get_info() for o in self.operator_set] if self.operator_set else [],
+            "Fusing patterns": [f.get_info() for f in self.fusing_patterns] if self.fusing_patterns else [],
+        }
+
+    def show(self):
+        """
+        Display the TargetPlatformCapabilities.
+        """
+        pprint.pprint(self.get_info(), sort_dicts=False)

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2keras.py

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

model_compression_toolkit/target_platform_capabilities/targetplatform2framework/attach2pytorch.py

@@ -97,7 +97,8 @@ 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: [],  # no such operator in pytorch
+            OperatorSetNames.BOX_DECODE: []  # no such operator in pytorch
         }
 
         pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),