mct-nightly 2.2.0.20250113.134913__py3-none-any.whl → 2.2.0.20250114.134534__py3-none-any.whl

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:

model_compression_toolkit/target_platform_capabilities/tpc_models/get_target_platform_capabilities.py

@@ -15,60 +15,60 @@
 from model_compression_toolkit.constants import TENSORFLOW, PYTORCH
 from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL, IMX500_TP_MODEL, \
     TFLITE_TP_MODEL, QNNPACK_TP_MODEL
-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
 
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tp_model import get_tp_model as get_tp_model_imx500_v1
-from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tp_model import get_tp_model as get_tp_model_tflite_v1
-from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model as get_tp_model_qnnpack_v1
+from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc import get_tpc as get_tpc_imx500_v1
+from model_compression_toolkit.target_platform_capabilities.tpc_models.tflite_tpc.v1.tpc import get_tpc as get_tpc_tflite_v1
+from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc import get_tpc as get_tpc_qnnpack_v1
 
 
 # TODO: These methods need to be replaced once modifying the TPC API.
 
 def get_target_platform_capabilities(fw_name: str,
                                      target_platform_name: str,
-                                     target_platform_version: str = None) -> TargetPlatformModel:
+                                     target_platform_version: str = None) -> TargetPlatformCapabilities:
     """
-    This is a degenerated function that only returns the MCT default TargetPlatformModel object, to comply with the
+    This is a degenerated function that only returns the MCT default TargetPlatformCapabilities object, to comply with the
     existing TPC API.
 
     Args:
-        fw_name: Framework name of the TargetPlatformCapabilities.
+        fw_name: Framework name of the FrameworkQuantizationCapabilities.
         target_platform_name: Target platform model name the model will use for inference.
         target_platform_version: Target platform capabilities version.
 
     Returns:
-        A default TargetPlatformModel object.
+        A default TargetPlatformCapabilities object.
     """
 
     assert fw_name in [TENSORFLOW, PYTORCH], f"Unsupported framework {fw_name}."
 
     if target_platform_name == DEFAULT_TP_MODEL:
-        return get_tp_model_imx500_v1()
+        return get_tpc_imx500_v1()
 
     assert target_platform_version == 'v1' or target_platform_version is None, \
         "The usage of get_target_platform_capabilities API is supported only with the default TPC ('v1')."
 
     if target_platform_name == IMX500_TP_MODEL:
-        return get_tp_model_imx500_v1()
+        return get_tpc_imx500_v1()
     elif target_platform_name == TFLITE_TP_MODEL:
-        return get_tp_model_tflite_v1()
+        return get_tpc_tflite_v1()
     elif target_platform_name == QNNPACK_TP_MODEL:
-        return get_tp_model_qnnpack_v1()
+        return get_tpc_qnnpack_v1()
 
     raise ValueError(f"Unsupported target platform name {target_platform_name}.")
 
 
-def get_tpc_model(name: str, tp_model: TargetPlatformModel):
+def get_tpc_model(name: str, tpc: TargetPlatformCapabilities):
     """
-    This is a utility method that just returns the TargetPlatformModel that it receives, to support existing TPC API.
+    This is a utility method that just returns the TargetPlatformCapabilities that it receives, to support existing TPC API.
 
     Args:
-        name: the name of the TargetPlatformModel (not used in this function).
-        tp_model: a TargetPlatformModel to return.
+        name: the name of the TargetPlatformCapabilities (not used in this function).
+        tpc: a TargetPlatformCapabilities to return.
 
     Returns:
-        The given TargetPlatformModel object.
+        The given TargetPlatformCapabilities object.
 
     """
 
-    return tp_model
+    return tpc

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/latest/__init__.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 # ==============================================================================
 from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tp_model import get_tp_model, generate_tp_model, \
+from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc import get_tpc, generate_tpc, \
     get_op_quantization_configs
 if FOUND_TF:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tp_model import get_tp_model as get_keras_tpc_latest
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc import get_tpc as get_keras_tpc_latest
     from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import \
         get_tpc_model as generate_keras_tpc
 if FOUND_TORCH:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tp_model import get_tp_model as get_pytorch_tpc_latest
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc import get_tpc as get_pytorch_tpc_latest
     from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import \
         get_tpc_model as generate_pytorch_tpc

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/{tp_model.py → tpc.py}

@@ -16,36 +16,35 @@ from typing import List, Tuple
 
 import model_compression_toolkit as mct
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, WEIGHTS_N_BITS, \
     IMX500_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, Signedness, \
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities, Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
-tp = mct.target_platform
 
-
-def get_tp_model() -> TargetPlatformModel:
+def get_tpc() -> TargetPlatformCapabilities:
     """
     A method that generates a default target platform model, with base 8-bit quantization configuration and 8, 4, 2
     bits configuration list for mixed-precision quantization.
     NOTE: in order to generate a target platform model with different configurations but with the same Operators Sets
     (for tests, experiments, etc.), use this method implementation as a test-case, i.e., override the
-    'get_op_quantization_configs' method and use its output to call 'generate_tp_model' with your configurations.
+    'get_op_quantization_configs' method and use its output to call 'generate_tpc' with your configurations.
 
-    Returns: A TargetPlatformModel object.
+    Returns: A TargetPlatformCapabilities object.
 
     """
     base_config, mixed_precision_cfg_list, default_config = get_op_quantization_configs()
-    return generate_tp_model(default_config=default_config,
-                             base_config=base_config,
-                             mixed_precision_cfg_list=mixed_precision_cfg_list,
-                             name='imx500_tp_model')
+    return generate_tpc(default_config=default_config,
+                        base_config=base_config,
+                        mixed_precision_cfg_list=mixed_precision_cfg_list,
+                        name='imx500_tpc')
 
 
 def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantizationConfig], OpQuantizationConfig]:
     """
-    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformModel.
+    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformCapabilities.
     In addition, creates a default configuration objects list (with 8, 4 and 2 bit quantization) to be used as
     default configuration for mixed-precision quantization.
 
@@ -60,7 +59,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # define a default quantization config for all non-specified weights attributes.
     default_weight_attr_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
+        weights_quantization_method=QuantizationMethod.POWER_OF_TWO,
         weights_n_bits=8,
         weights_per_channel_threshold=False,
         enable_weights_quantization=False,
@@ -69,7 +68,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # define a quantization config to quantize the kernel (for layers where there is a kernel attribute).
     kernel_base_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
+        weights_quantization_method=QuantizationMethod.SYMMETRIC,
         weights_n_bits=8,
         weights_per_channel_threshold=True,
         enable_weights_quantization=True,
@@ -77,7 +76,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # define a quantization config to quantize the bias (for layers where there is a bias attribute).
     bias_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
+        weights_quantization_method=QuantizationMethod.POWER_OF_TWO,
         weights_n_bits=FLOAT_BITWIDTH,
         weights_per_channel_threshold=False,
         enable_weights_quantization=False,
@@ -92,7 +91,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     eight_bits_default = schema.OpQuantizationConfig(
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={},
-        activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
+        activation_quantization_method=QuantizationMethod.POWER_OF_TWO,
         activation_n_bits=8,
         supported_input_activation_n_bits=8,
         enable_activation_quantization=True,
@@ -106,7 +105,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     linear_eight_bits = schema.OpQuantizationConfig(
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
-        activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
+        activation_quantization_method=QuantizationMethod.POWER_OF_TWO,
         activation_n_bits=8,
         supported_input_activation_n_bits=8,
         enable_activation_quantization=True,
@@ -131,22 +130,22 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
     return linear_eight_bits, mixed_precision_cfg_list, eight_bits_default
 
 
-def generate_tp_model(default_config: OpQuantizationConfig,
-                      base_config: OpQuantizationConfig,
-                      mixed_precision_cfg_list: List[OpQuantizationConfig],
-                      name: str) -> TargetPlatformModel:
+def generate_tpc(default_config: OpQuantizationConfig,
+                 base_config: OpQuantizationConfig,
+                 mixed_precision_cfg_list: List[OpQuantizationConfig],
+                 name: str) -> TargetPlatformCapabilities:
     """
-    Generates TargetPlatformModel with default defined Operators Sets, based on the given base configuration and
+    Generates TargetPlatformCapabilities with default defined Operators Sets, based on the given base configuration and
     mixed-precision configurations options list.
 
     Args
         default_config: A default OpQuantizationConfig to set as the TP model default configuration.
-        base_config: An OpQuantizationConfig to set as the TargetPlatformModel base configuration for mixed-precision purposes only.
+        base_config: An OpQuantizationConfig to set as the TargetPlatformCapabilities base configuration for mixed-precision purposes only.
         mixed_precision_cfg_list: A list of OpQuantizationConfig to be used as the TP model mixed-precision
             quantization configuration options.
-        name: The name of the TargetPlatformModel.
+        name: The name of the TargetPlatformCapabilities.
 
-    Returns: A TargetPlatformModel object.
+    Returns: A TargetPlatformCapabilities object.
 
     """
     # Create a QuantizationConfigOptions, which defines a set
@@ -218,14 +217,14 @@ def generate_tp_model(default_config: OpQuantizationConfig,
 
     operator_set.extend([conv, conv_transpose, depthwise_conv, fc, relu, relu6, leaky_relu, add, sub, mul, div, prelu, swish,
                          hard_swish, sigmoid, tanh, hard_tanh])
-    any_relu = schema.OperatorSetConcat(operators_set=[relu, relu6, leaky_relu, hard_tanh])
+    any_relu = schema.OperatorSetGroup(operators_set=[relu, relu6, leaky_relu, hard_tanh])
     # Combine multiple operators into a single operator to avoid quantization between
     # them. To do this we define fusing patterns using the OperatorsSets that were created.
-    # To group multiple sets with regard to fusing, an OperatorSetConcat can be created
-    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[relu, relu6, leaky_relu, hard_tanh, swish, hard_swish, prelu, sigmoid, tanh])
-    conv_types = schema.OperatorSetConcat(operators_set=[conv, conv_transpose, depthwise_conv])
-    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[relu, relu6, leaky_relu, hard_tanh, swish, hard_swish, sigmoid])
-    any_binary = schema.OperatorSetConcat(operators_set=[add, sub, mul, div])
+    # To group multiple sets with regard to fusing, an OperatorSetGroup can be created
+    activations_after_conv_to_fuse = schema.OperatorSetGroup(operators_set=[relu, relu6, leaky_relu, hard_tanh, swish, hard_swish, prelu, sigmoid, tanh])
+    conv_types = schema.OperatorSetGroup(operators_set=[conv, conv_transpose, depthwise_conv])
+    activations_after_fc_to_fuse = schema.OperatorSetGroup(operators_set=[relu, relu6, leaky_relu, hard_tanh, swish, hard_swish, sigmoid])
+    any_binary = schema.OperatorSetGroup(operators_set=[add, sub, mul, div])
 
     # ------------------- #
     # Fusions
@@ -234,10 +233,10 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
     fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
-    # Create a TargetPlatformModel and set its default quantization config.
+    # Create a TargetPlatformCapabilities and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
-    generated_tpc = schema.TargetPlatformModel(
+    generated_tpc = schema.TargetPlatformCapabilities(
         default_qco=default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/latest/__init__.py

@@ -13,14 +13,14 @@
 # limitations under the License.
 # ==============================================================================
 from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
-from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model, generate_tp_model, get_op_quantization_configs
+from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc import get_tpc, generate_tpc, get_op_quantization_configs
 if FOUND_TF:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model as \
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc import get_tpc as \
         get_keras_tpc_latest
     from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import \
         get_tpc_model as generate_keras_tpc, get_tpc_model as generate_keras_tpc
 if FOUND_TORCH:
-    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tp_model import get_tp_model as \
+    from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc import get_tpc as \
         get_pytorch_tpc_latest
     from model_compression_toolkit.target_platform_capabilities.tpc_models.get_target_platform_capabilities import \
         get_tpc_model as generate_pytorch_tpc, get_tpc_model as generate_pytorch_tpc