mct-nightly 2.2.0.20250113.527__py3-none-any.whl → 2.2.0.20250114.84821__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/schema/v1.py

@@ -414,7 +414,7 @@ class QuantizationConfigOptions(BaseModel):
 
 class TargetPlatformModelComponent(BaseModel):
     """
-    Component of TargetPlatformModel (Fusing, OperatorsSet, etc.).
+    Component of TargetPlatformCapabilities (Fusing, OperatorsSet, etc.).
     """
     class Config:
         frozen = True
@@ -433,7 +433,7 @@ class OperatorsSet(OperatorsSetBase):
     Set of operators that are represented by a unique label.
 
     Attributes:
-        name (Union[str, OperatorSetNames]): The set's label (must be unique within a TargetPlatformModel).
+        name (Union[str, OperatorSetNames]): The set's label (must be unique within a TargetPlatformCapabilities).
         qc_options (Optional[QuantizationConfigOptions]): Configuration options to use for this set of operations.
             If None, it represents a fusing set.
         type (Literal["OperatorsSet"]): Fixed type identifier.
@@ -457,7 +457,7 @@ class OperatorsSet(OperatorsSetBase):
         return {"name": self.name}
 
 
-class OperatorSetConcat(OperatorsSetBase):
+class OperatorSetGroup(OperatorsSetBase):
     """
     Concatenate a tuple of operator sets to treat them similarly in different places (like fusing).
 
@@ -469,7 +469,7 @@ class OperatorSetConcat(OperatorsSetBase):
     name: Optional[str] = None  # Will be set in the validator if not given
 
     # Define a private attribute _type
-    type: Literal["OperatorSetConcat"] = "OperatorSetConcat"
+    type: Literal["OperatorSetGroup"] = "OperatorSetGroup"
 
     class Config:
         frozen = True
@@ -518,11 +518,11 @@ class Fusing(TargetPlatformModelComponent):
     hence no quantization is applied between them.
 
     Attributes:
-        operator_groups (Tuple[Union[OperatorsSet, OperatorSetConcat], ...]): A tuple of operator groups,
-                                                                              each being either an OperatorSetConcat or an OperatorsSet.
+        operator_groups (Tuple[Union[OperatorsSet, OperatorSetGroup], ...]): A tuple of operator groups,
+                                                                              each being either an OperatorSetGroup or an OperatorsSet.
         name (Optional[str]): The name for the Fusing instance. If not provided, it is generated from the operator groups' names.
     """
-    operator_groups: Tuple[Annotated[Union[OperatorsSet, OperatorSetConcat], Field(discriminator='type')], ...]
+    operator_groups: Tuple[Annotated[Union[OperatorsSet, OperatorSetGroup], Field(discriminator='type')], ...]
     name: Optional[str] = None  # Will be set in the validator if not given.
 
     class Config:
@@ -591,7 +591,7 @@ class Fusing(TargetPlatformModelComponent):
         for i in range(len(self.operator_groups) - len(other.operator_groups) + 1):
             for j in range(len(other.operator_groups)):
                 if self.operator_groups[i + j] != other.operator_groups[j] and not (
-                        isinstance(self.operator_groups[i + j], OperatorSetConcat) and (
+                        isinstance(self.operator_groups[i + j], OperatorSetGroup) and (
                         other.operator_groups[j] in self.operator_groups[i + j].operators_set)):
                     break
             else:
@@ -621,7 +621,7 @@ class Fusing(TargetPlatformModelComponent):
             for x in self.operator_groups
         ])
 
-class TargetPlatformModel(BaseModel):
+class TargetPlatformCapabilities(BaseModel):
     """
     Represents the hardware configuration used for quantized model inference.
 
@@ -644,7 +644,7 @@ class TargetPlatformModel(BaseModel):
     tpc_patch_version: Optional[int]
     tpc_platform_type: Optional[str]
     add_metadata: bool = True
-    name: Optional[str] = "default_tp_model"
+    name: Optional[str] = "default_tpc"
     is_simd_padding: bool = False
 
     SCHEMA_VERSION: int = 1
@@ -682,10 +682,10 @@ class TargetPlatformModel(BaseModel):
 
     def get_info(self) -> Dict[str, Any]:
         """
-        Get a dictionary summarizing the TargetPlatformModel properties.
+        Get a dictionary summarizing the TargetPlatformCapabilities properties.
 
         Returns:
-            Dict[str, Any]: Summary of the TargetPlatformModel properties.
+            Dict[str, Any]: Summary of the TargetPlatformCapabilities properties.
         """
         return {
             "Model name": self.name,
@@ -695,6 +695,6 @@ class TargetPlatformModel(BaseModel):
 
     def show(self):
         """
-        Display the TargetPlatformModel.
+        Display the TargetPlatformCapabilities.
         """
         pprint.pprint(self.get_info(), sort_dicts=False)

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/__init__.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 # ==============================================================================
 
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.current_tpc import get_current_tpc
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.target_platform_capabilities import TargetPlatformCapabilities
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attribute_filter import \
-    Eq, GreaterEq, NotEq, SmallerEq, Greater, Smaller
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.layer_filter_params import \
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.current_tpc import get_current_tpc
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities import FrameworkQuantizationCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.layer_filter_params import \
     LayerFilterParams
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.operations_to_layers import \
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attribute_filter import \
+    Eq, GreaterEq, NotEq, SmallerEq, Greater, Smaller
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.operations_to_layers import \
     OperationsToLayers, OperationsSetToLayers
 
 

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/attach2fw.py

@@ -1,12 +1,12 @@
 from typing import Dict, Optional
 
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, \
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities, \
     OperatorsSet
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities, \
-    OperationsSetToLayers
 
 from model_compression_toolkit.core.common.quantization.quantization_config import CustomOpsetLayers
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import \
+    FrameworkQuantizationCapabilities, OperationsSetToLayers
 
 
 class AttachTpcToFramework:
@@ -19,25 +19,25 @@ class AttachTpcToFramework:
         # in the operation set are provided in the mapping,  a DefaultDict should be supplied to handle missing entries.
         self._opset2attr_mapping = None  # Mapping of operation sets to their corresponding framework-specific layers
 
-    def attach(self, tpc_model: TargetPlatformModel,
+    def attach(self, tpc_model: TargetPlatformCapabilities,
                custom_opset2layer: Optional[Dict[str, 'CustomOpsetLayers']] = None
-               ) -> TargetPlatformCapabilities:
+               ) -> FrameworkQuantizationCapabilities:
         """
-        Attaching a TargetPlatformModel which includes a platform capabilities description to specific
+        Attaching a TargetPlatformCapabilities which includes a platform capabilities description to specific
         framework's operators.
 
         Args:
-            tpc_model: a TargetPlatformModel object.
+            tpc_model: a TargetPlatformCapabilities object.
             custom_opset2layer: optional set of custom operator sets which allows to add/override the built-in set
                 of framework operator, to define a specific behavior for those operators. This dictionary should map
                 an operator set unique name to a pair of: a list of framework operators and an optional
                 operator's attributes names mapping.
 
-        Returns: a TargetPlatformCapabilities object.
+        Returns: a FrameworkQuantizationCapabilities object.
 
         """
 
-        tpc = TargetPlatformCapabilities(tpc_model)
+        tpc = FrameworkQuantizationCapabilities(tpc_model)
         custom_opset2layer = custom_opset2layer if custom_opset2layer is not None else {}
 
         with tpc:
@@ -59,7 +59,7 @@ class AttachTpcToFramework:
                             attr_mapping = self._opset2attr_mapping.get(opset.name)
                             OperationsSetToLayers(opset.name, layers, attr_mapping=attr_mapping)
                     else:
-                        Logger.critical(f'{opset.name} is defined in TargetPlatformModel, '
+                        Logger.critical(f'{opset.name} is defined in TargetPlatformCapabilities, '
                                         f'but is not defined in the framework set of operators or in the provided '
                                         f'custom operator sets mapping.')
 

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/attach2keras.py

@@ -16,6 +16,9 @@
 import tensorflow as tf
 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:
@@ -34,9 +37,6 @@ from model_compression_toolkit import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS, \
     BIAS_ATTR, KERAS_KERNEL, KERAS_DEPTHWISE_KERNEL
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OperatorSetNames
-from model_compression_toolkit.target_platform_capabilities.target_platform import LayerFilterParams
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2fw import \
-    AttachTpcToFramework
 
 
 class AttachTpcToKeras(AttachTpcToFramework):

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/attach2pytorch.py

@@ -28,9 +28,10 @@ from model_compression_toolkit import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, PYTORCH_KERNEL, BIAS, \
     BIAS_ATTR
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OperatorSetNames
-from model_compression_toolkit.target_platform_capabilities.target_platform import LayerFilterParams, Eq
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2fw import \
+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.target_platform_capabilities.targetplatform2framework.attribute_filter import Eq
 
 
 class AttachTpcToPytorch(AttachTpcToFramework):

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/current_tpc.py

@@ -18,7 +18,7 @@ from model_compression_toolkit.logger import Logger
 def get_current_tpc():
     """
 
-    Returns: The current TargetPlatformCapabilities that is being used and accessed.
+    Returns: The current FrameworkQuantizationCapabilities that is being used and accessed.
 
     """
     return _current_tpc.get()
@@ -26,7 +26,7 @@ def get_current_tpc():
 
 class _CurrentTPC(object):
     """
-    Wrapper of the current TargetPlatformCapabilities object that is being accessed and defined.
+    Wrapper of the current FrameworkQuantizationCapabilities object that is being accessed and defined.
     """
     def __init__(self):
         super(_CurrentTPC, self).__init__()
@@ -35,28 +35,28 @@ class _CurrentTPC(object):
     def get(self):
         """
 
-        Returns: The current TargetPlatformCapabilities that is being defined.
+        Returns: The current FrameworkQuantizationCapabilities that is being defined.
 
         """
         if self.tpc is None:
-            Logger.critical("'TargetPlatformCapabilities' (TPC) instance is not initialized.")
+            Logger.critical("'FrameworkQuantizationCapabilities' (TPC) instance is not initialized.")
         return self.tpc
 
     def reset(self):
         """
 
-        Reset the current TargetPlatformCapabilities so a new TargetPlatformCapabilities can be wrapped and
-        used as the current TargetPlatformCapabilities object.
+        Reset the current FrameworkQuantizationCapabilities so a new FrameworkQuantizationCapabilities can be wrapped and
+        used as the current FrameworkQuantizationCapabilities object.
 
         """
         self.tpc = None
 
     def set(self, target_platform_capabilities):
         """
-        Set and wrap a TargetPlatformCapabilities as the current TargetPlatformCapabilities.
+        Set and wrap a FrameworkQuantizationCapabilities as the current FrameworkQuantizationCapabilities.
 
         Args:
-            target_platform_capabilities: TargetPlatformCapabilities to set as the current TargetPlatformCapabilities
+            target_platform_capabilities: FrameworkQuantizationCapabilities to set as the current FrameworkQuantizationCapabilities
             to access and use.
 
         """

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework/target_platform_capabilities.py → targetplatform2framework/framework_quantization_capabilities.py}

@@ -21,38 +21,38 @@ from typing import List, Any, Dict, Tuple
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.schema.schema_functions import \
     get_config_options_by_operators_set, get_default_op_quantization_config, get_opset_by_name
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.operations_to_layers import \
-    OperationsToLayers, OperationsSetToLayers
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.target_platform_capabilities_component import TargetPlatformCapabilitiesComponent
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.layer_filter_params import LayerFilterParams
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.operations_to_layers import OperationsToLayers, \
+    OperationsSetToLayers
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities_component import \
+    FrameworkQuantizationCapabilitiesComponent
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.layer_filter_params import LayerFilterParams
 from model_compression_toolkit.target_platform_capabilities.immutable import ImmutableClass
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, OperatorsSetBase, \
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities, OperatorsSetBase, \
     OpQuantizationConfig, QuantizationConfigOptions
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.current_tpc import _current_tpc
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.current_tpc import  _current_tpc
 
-
-class TargetPlatformCapabilities(ImmutableClass):
+class FrameworkQuantizationCapabilities(ImmutableClass):
     """
     Attach framework information to a modeled hardware.
     """
     def __init__(self,
-                 tp_model: TargetPlatformModel,
+                 tpc: TargetPlatformCapabilities,
                  name: str = "base"):
         """
 
         Args:
-            tp_model (TargetPlatformModel): Modeled hardware to attach framework information to.
-            name (str): Name of the TargetPlatformCapabilities.
+            tpc (TargetPlatformCapabilities): Modeled hardware to attach framework information to.
+            name (str): Name of the FrameworkQuantizationCapabilities.
         """
 
         super().__init__()
         self.name = name
-        assert isinstance(tp_model, TargetPlatformModel), f'Target platform model that was passed to TargetPlatformCapabilities must be of type TargetPlatformModel, but has type of {type(tp_model)}'
-        self.tp_model = tp_model
+        assert isinstance(tpc, TargetPlatformCapabilities), f'Target platform model that was passed to FrameworkQuantizationCapabilities must be of type TargetPlatformCapabilities, but has type of {type(tpc)}'
+        self.tpc = tpc
         self.op_sets_to_layers = OperationsToLayers() # Init an empty OperationsToLayers
         self.layer2qco, self.filterlayer2qco = {}, {} # Init empty mappings from layers/LayerFilterParams to QC options
         # Track the unused opsets for warning purposes.
-        self.__tp_model_opsets_not_used = [s.name for s in tp_model.operator_set]
+        self.__tpc_opsets_not_used = [s.name for s in tpc.operator_set]
         self.remove_fusing_names_from_not_used_list()
 
     def get_layers_by_opset_name(self, opset_name: str) -> List[Any]:
@@ -66,9 +66,9 @@ class TargetPlatformCapabilities(ImmutableClass):
         Returns:
             List of layers/LayerFilterParams that are attached to the opset name.
         """
-        opset = get_opset_by_name(self.tp_model, opset_name)
+        opset = get_opset_by_name(self.tpc, opset_name)
         if opset is None:
-            Logger.warning(f'{opset_name} was not found in TargetPlatformCapabilities.')
+            Logger.warning(f'{opset_name} was not found in FrameworkQuantizationCapabilities.')
             return None
         return self.get_layers_by_opset(opset)
 
@@ -100,9 +100,9 @@ class TargetPlatformCapabilities(ImmutableClass):
 
         """
         res = []
-        if self.tp_model.fusing_patterns is None:
+        if self.tpc.fusing_patterns is None:
             return res
-        for p in self.tp_model.fusing_patterns:
+        for p in self.tpc.fusing_patterns:
             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]
@@ -111,47 +111,47 @@ class TargetPlatformCapabilities(ImmutableClass):
     def get_info(self) -> Dict[str, Any]:
         """
 
-        Returns: Summarization of information in the TargetPlatformCapabilities.
+        Returns: Summarization of information in the FrameworkQuantizationCapabilities.
 
         """
         return {"Target Platform Capabilities": self.name,
-                "Minor version": self.tp_model.tpc_minor_version,
-                "Patch version": self.tp_model.tpc_patch_version,
-                "Platform type": self.tp_model.tpc_platform_type,
-                "Target Platform Model": self.tp_model.get_info(),
+                "Minor version": self.tpc.tpc_minor_version,
+                "Patch version": self.tpc.tpc_patch_version,
+                "Platform type": self.tpc.tpc_platform_type,
+                "Target Platform Model": self.tpc.get_info(),
                 "Operations to layers": {op2layer.name:[l.__name__ for l in op2layer.layers] for op2layer in self.op_sets_to_layers.op_sets_to_layers}}
 
     def show(self):
         """
 
-        Display the TargetPlatformCapabilities.
+        Display the FrameworkQuantizationCapabilities.
 
         """
         pprint.pprint(self.get_info(), sort_dicts=False, width=110)
 
-    def append_component(self, tpc_component: TargetPlatformCapabilitiesComponent):
+    def append_component(self, tpc_component: FrameworkQuantizationCapabilitiesComponent):
         """
-        Append a Component (like OperationsSetToLayers) to the TargetPlatformCapabilities.
+        Append a Component (like OperationsSetToLayers) to the FrameworkQuantizationCapabilities.
 
         Args:
-            tpc_component: Component to append to TargetPlatformCapabilities.
+            tpc_component: Component to append to FrameworkQuantizationCapabilities.
 
         """
         if isinstance(tpc_component, OperationsSetToLayers):
             self.op_sets_to_layers += tpc_component
         else:
-            Logger.critical(f"Attempt to append an unrecognized 'TargetPlatformCapabilitiesComponent' of type: '{type(tpc_component)}'. Ensure the component is compatible.")  # pragma: no cover
+            Logger.critical(f"Attempt to append an unrecognized 'FrameworkQuantizationCapabilitiesComponent' of type: '{type(tpc_component)}'. Ensure the component is compatible.")  # pragma: no cover
 
     def __enter__(self):
         """
-        Init a TargetPlatformCapabilities object.
+        Init a FrameworkQuantizationCapabilities object.
         """
         _current_tpc.set(self)
         return self
 
     def __exit__(self, exc_type, exc_value, tb):
         """
-        Finalize a TargetPlatformCapabilities object.
+        Finalize a FrameworkQuantizationCapabilities object.
         """
         if exc_value is not None:
             print(exc_value, exc_value.args)
@@ -164,11 +164,11 @@ class TargetPlatformCapabilities(ImmutableClass):
     def get_default_op_qc(self) -> OpQuantizationConfig:
         """
 
-        Returns: The default OpQuantizationConfig of the TargetPlatformModel that is attached
-        to the TargetPlatformCapabilities.
+        Returns: The default OpQuantizationConfig of the TargetPlatformCapabilities that is attached
+        to the FrameworkQuantizationCapabilities.
 
         """
-        return get_default_op_quantization_config(self.tp_model)
+        return get_default_op_quantization_config(self.tpc)
 
 
     def _get_config_options_mapping(self) -> Tuple[Dict[Any, QuantizationConfigOptions],
@@ -184,9 +184,9 @@ class TargetPlatformCapabilities(ImmutableClass):
         filterlayer2qco = {}
         for op2layers in self.op_sets_to_layers.op_sets_to_layers:
             for l in op2layers.layers:
-                qco = get_config_options_by_operators_set(self.tp_model, op2layers.name)
+                qco = get_config_options_by_operators_set(self.tpc, op2layers.name)
                 if qco is None:
-                    qco = self.tp_model.default_qco
+                    qco = self.tpc.default_qco
 
                 # here, we need to take care of mapping a general attribute name into a framework and
                 # layer type specific attribute name.
@@ -208,8 +208,8 @@ class TargetPlatformCapabilities(ImmutableClass):
         Remove OperatorSets names from the list of the unused sets (so a warning
         will not be displayed).
         """
-        if self.tp_model.fusing_patterns is not None:
-            for f in self.tp_model.fusing_patterns:
+        if self.tpc.fusing_patterns is not None:
+            for f in self.tpc.fusing_patterns:
                 for s in f.operator_groups:
                     self.remove_opset_from_not_used_list(s.name)
 
@@ -222,8 +222,8 @@ class TargetPlatformCapabilities(ImmutableClass):
             opset_to_remove: OperatorsSet name to remove.
 
         """
-        if opset_to_remove in self.__tp_model_opsets_not_used:
-            self.__tp_model_opsets_not_used.remove(opset_to_remove)
+        if opset_to_remove in self.__tpc_opsets_not_used:
+            self.__tpc_opsets_not_used.remove(opset_to_remove)
 
     @property
     def is_simd_padding(self) -> bool:
@@ -232,4 +232,4 @@ class TargetPlatformCapabilities(ImmutableClass):
         Returns: Check if the TP model defines that padding due to SIMD constrains occurs.
 
         """
-        return self.tp_model.is_simd_padding
+        return self.tpc.is_simd_padding

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework/target_platform_capabilities_component.py → targetplatform2framework/framework_quantization_capabilities_component.py}

@@ -13,10 +13,10 @@
 # limitations under the License.
 # ==============================================================================
 
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.current_tpc import  _current_tpc
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.current_tpc import  _current_tpc
 
 
-class TargetPlatformCapabilitiesComponent:
+class FrameworkQuantizationCapabilitiesComponent:
     def __init__(self, name: str):
         self.name = name
         _current_tpc.get().append_component(self)

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/layer_filter_params.py

@@ -14,7 +14,6 @@
 # ==============================================================================
 
 from typing import Any
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attribute_filter import AttributeFilter
 
 
 class LayerFilterParams:

model_compression_toolkit/target_platform_capabilities/{target_platform/targetplatform2framework → targetplatform2framework}/operations_to_layers.py

@@ -18,13 +18,13 @@ from typing import List, Any, Dict
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.schema.schema_functions import \
     get_config_options_by_operators_set, is_opset_in_model
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.current_tpc import  _current_tpc
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.target_platform_capabilities_component import TargetPlatformCapabilitiesComponent
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OperatorsSetBase, OperatorSetConcat
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.current_tpc import  _current_tpc
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.framework_quantization_capabilities_component import FrameworkQuantizationCapabilitiesComponent
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OperatorsSetBase, OperatorSetGroup
 from model_compression_toolkit import DefaultDict
 
 
-class OperationsSetToLayers(TargetPlatformCapabilitiesComponent):
+class OperationsSetToLayers(FrameworkQuantizationCapabilitiesComponent):
     """
     Associate an OperatorsSet to a list of framework's layers.
     """
@@ -57,7 +57,7 @@ class OperationsSetToLayers(TargetPlatformCapabilitiesComponent):
 
 class OperationsToLayers:
     """
-    Gather multiple OperationsSetToLayers to represent mapping of framework's layers to TargetPlatformModel OperatorsSet.
+    Gather multiple OperationsSetToLayers to represent mapping of framework's layers to TargetPlatformCapabilities OperatorsSet.
     """
     def __init__(self,
                  op_sets_to_layers: List[OperationsSetToLayers]=None):
@@ -88,7 +88,7 @@ class OperationsToLayers:
         for o in self.op_sets_to_layers:
             if op.name == o.name:
                 return o.layers
-        if isinstance(op, OperatorSetConcat):  # If its a concat - return all layers from all OperatorsSets that in the OperatorSetConcat
+        if isinstance(op, OperatorSetGroup):  # If its a concat - return all layers from all OperatorsSets that in the OperatorSetGroup
             layers = []
             for o in op.operators_set:
                 layers.extend(self.get_layers_by_op(o))
@@ -142,9 +142,9 @@ class OperationsToLayers:
             assert ops2layers.name not in existing_opset_names, f'OperationsSetToLayers names should be unique, but {ops2layers.name} appears to violate it.'
             existing_opset_names.append(ops2layers.name)
 
-            # Assert that a layer does not appear in more than a single OperatorsSet in the TargetPlatformModel.
+            # Assert that a layer does not appear in more than a single OperatorsSet in the TargetPlatformCapabilities.
             for layer in ops2layers.layers:
-                qco_by_opset_name = get_config_options_by_operators_set(_current_tpc.get().tp_model, ops2layers.name)
+                qco_by_opset_name = get_config_options_by_operators_set(_current_tpc.get().tpc, ops2layers.name)
                 if layer in existing_layers:
                     Logger.critical(f'Found layer {layer.__name__} in more than one '
                                     f'OperatorsSet')  # pragma: no cover

model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py

@@ -16,34 +16,34 @@ 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 TargetPlatformModel
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
 import json
 
 
-def load_target_platform_model(tp_model_or_path: Union[TargetPlatformModel, str]) -> TargetPlatformModel:
+def load_target_platform_model(tpc_obj_or_path: Union[TargetPlatformCapabilities, str]) -> TargetPlatformCapabilities:
     """
-        Parses the tp_model input, which can be either a TargetPlatformModel object
+        Parses the tpc input, which can be either a TargetPlatformCapabilities object
         or a string path to a JSON file.
 
         Parameters:
-            tp_model_or_path (Union[TargetPlatformModel, str]): Input target platform model or path to .JSON file.
+            tpc_obj_or_path (Union[TargetPlatformModel, str]): Input target platform model or path to .JSON file.
 
         Returns:
-            TargetPlatformModel: The parsed TargetPlatformModel.
+            TargetPlatformCapabilities: The parsed TargetPlatformCapabilities.
 
         Raises:
             FileNotFoundError: If the JSON file does not exist.
-            ValueError: If the JSON content is invalid or cannot initialize the TargetPlatformModel.
-            TypeError: If the input is neither a TargetPlatformModel nor a valid JSON file path.
+            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(tp_model_or_path, TargetPlatformModel):
-        return tp_model_or_path
+    if isinstance(tpc_obj_or_path, TargetPlatformCapabilities):
+        return tpc_obj_or_path
 
-    if isinstance(tp_model_or_path, str):
-        path = Path(tp_model_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 '{tp_model_or_path}' is not a valid 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.")
@@ -51,35 +51,35 @@ def load_target_platform_model(tp_model_or_path: Union[TargetPlatformModel, str]
             with path.open('r', encoding='utf-8') as file:
                 data = file.read()
         except OSError as e:
-            raise ValueError(f"Error reading the file '{tp_model_or_path}': {e.strerror}.") from e
+            raise ValueError(f"Error reading the file '{tpc_obj_or_path}': {e.strerror}.") from e
 
         try:
-            return TargetPlatformModel.parse_raw(data)
+            return TargetPlatformCapabilities.parse_raw(data)
         except ValueError as e:
-            raise ValueError(f"Invalid JSON for loading TargetPlatformModel in '{tp_model_or_path}': {e}.") from 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 TargetPlatformModel: {e}.") from e
+            raise ValueError(f"Unexpected error while initializing TargetPlatformCapabilities: {e}.") from e
 
     raise TypeError(
-        f"tp_model_or_path must be either a TargetPlatformModel instance or a string path to a JSON file, "
-        f"but received type '{type(tp_model_or_path).__name__}'."
+        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_model(model: TargetPlatformModel, export_path: Union[str, Path]) -> None:
+def export_target_platform_model(model: TargetPlatformCapabilities, export_path: Union[str, Path]) -> None:
     """
-    Exports a TargetPlatformModel instance to a JSON file.
+    Exports a TargetPlatformCapabilities instance to a JSON file.
 
     Parameters:
-        model (TargetPlatformModel): The TargetPlatformModel instance to export.
+        model (TargetPlatformCapabilities): The TargetPlatformCapabilities instance to export.
         export_path (Union[str, Path]): The file path to export the model to.
 
     Raises:
-        ValueError: If the model is not an instance of TargetPlatformModel.
+        ValueError: If the model is not an instance of TargetPlatformCapabilities.
         OSError: If there is an issue writing to the file.
     """
-    if not isinstance(model, TargetPlatformModel):
-        raise ValueError("The provided model is not a valid TargetPlatformModel instance.")
+    if not isinstance(model, TargetPlatformCapabilities):
+        raise ValueError("The provided model is not a valid TargetPlatformCapabilities instance.")
 
     path = Path(export_path)
     try: