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

model_compression_toolkit/ptq/pytorch/quantization_facade.py

@@ -19,9 +19,8 @@ from typing import Callable
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.constants import PYTORCH
-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.verify_packages import FOUND_TORCH
-from model_compression_toolkit.target_platform_capabilities.target_platform import TargetPlatformCapabilities
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
@@ -40,7 +39,7 @@ if FOUND_TORCH:
     from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.fully_quantized_model_builder import get_exportable_pytorch_model
     from model_compression_toolkit import get_target_platform_capabilities
     from mct_quantizers.pytorch.metadata import add_metadata
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+    from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2pytorch import \
         AttachTpcToPytorch
 
     DEFAULT_PYTORCH_TPC = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
@@ -49,11 +48,11 @@ if FOUND_TORCH:
                                            representative_data_gen: Callable,
                                            target_resource_utilization: ResourceUtilization = None,
                                            core_config: CoreConfig = CoreConfig(),
-                                           target_platform_capabilities: TargetPlatformModel = DEFAULT_PYTORCH_TPC):
+                                           target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
         """
         Quantize a trained Pytorch module using post-training quantization.
         By default, the module is quantized using a symmetric constraint quantization thresholds
-        (power of two) as defined in the default TargetPlatformCapabilities.
+        (power of two) as defined in the default FrameworkQuantizationCapabilities.
         The module is first optimized using several transformations (e.g. BatchNormalization folding to
         preceding layers). Then, using a given dataset, statistics (e.g. min/max, histogram, etc.) are
         being collected for each layer's output (and input, depends on the quantization configuration).
@@ -112,7 +111,7 @@ if FOUND_TORCH:
 
         # Attach tpc model to framework
         attach2pytorch = AttachTpcToPytorch()
-        target_platform_capabilities = attach2pytorch.attach(target_platform_capabilities,
+        framework_platform_capabilities = attach2pytorch.attach(target_platform_capabilities,
                                                              core_config.quantization_config.custom_tpc_opset_to_layer)
 
         # Ignore hessian info service as it is not used here yet.
@@ -121,7 +120,7 @@ if FOUND_TORCH:
                                                                 core_config=core_config,
                                                                 fw_info=fw_info,
                                                                 fw_impl=fw_impl,
-                                                                tpc=target_platform_capabilities,
+                                                                fqc=framework_platform_capabilities,
                                                                 target_resource_utilization=target_resource_utilization,
                                                                 tb_w=tb_w)
 
@@ -149,9 +148,9 @@ if FOUND_TORCH:
                                         fw_info)
 
         exportable_model, user_info = get_exportable_pytorch_model(graph_with_stats_correction)
-        if target_platform_capabilities.tp_model.add_metadata:
+        if framework_platform_capabilities.tpc.add_metadata:
             exportable_model = add_metadata(exportable_model,
-                                            create_model_metadata(tpc=target_platform_capabilities,
+                                            create_model_metadata(fqc=framework_platform_capabilities,
                                                                   scheduling_info=scheduling_info))
         return exportable_model, user_info
 

model_compression_toolkit/qat/keras/quantization_facade.py

@@ -19,13 +19,14 @@ from functools import partial
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 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
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2keras import \
+    AttachTpcToKeras
 from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
 from mct_quantizers import KerasActivationQuantizationHolder
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import TargetPlatformCapabilities
 from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.ptq.runner import ptq_runner
 
@@ -55,8 +56,6 @@ if FOUND_TF:
     from model_compression_toolkit.qat.keras.quantizer.quantization_builder import quantization_builder, \
     get_activation_quantizer_holder
     from model_compression_toolkit.qat.common.qat_config import QATConfig
-    from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
-        AttachTpcToKeras
 
     DEFAULT_KERAS_TPC = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
 
@@ -93,7 +92,7 @@ if FOUND_TF:
                                                             target_resource_utilization: ResourceUtilization = None,
                                                             core_config: CoreConfig = CoreConfig(),
                                                             qat_config: QATConfig = QATConfig(),
-                                                            target_platform_capabilities: TargetPlatformModel = DEFAULT_KERAS_TPC):
+                                                            target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_KERAS_TPC):
         """
          Prepare a trained Keras model for quantization aware training. First the model quantization is optimized
          with post-training quantization, then the model layers are wrapped with QuantizeWrappers. The model is
@@ -200,7 +199,7 @@ if FOUND_TF:
                                                   core_config=core_config,
                                                   fw_info=DEFAULT_KERAS_INFO,
                                                   fw_impl=fw_impl,
-                                                  tpc=target_platform_capabilities,
+                                                  fqc=target_platform_capabilities,
                                                   target_resource_utilization=target_resource_utilization,
                                                   tb_w=tb_w)
 

model_compression_toolkit/qat/keras/quantizer/lsq/symmetric_lsq.py

@@ -21,7 +21,7 @@ from tensorflow.python.framework.tensor_shape import TensorShape
 
 from model_compression_toolkit.trainable_infrastructure import TrainingMethod
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
 from mct_quantizers import QuantizationTarget, mark_quantizer
 from model_compression_toolkit.qat.common import THRESHOLD_TENSOR

model_compression_toolkit/qat/keras/quantizer/ste_rounding/symmetric_ste.py

@@ -22,7 +22,7 @@ from model_compression_toolkit.trainable_infrastructure.common.constants import
 
 from model_compression_toolkit.trainable_infrastructure import TrainingMethod
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.trainable_infrastructure import KerasTrainableQuantizationWrapper
 from mct_quantizers import QuantizationTarget, mark_quantizer
 from model_compression_toolkit.qat.common import THRESHOLD_TENSOR

model_compression_toolkit/qat/pytorch/quantization_facade.py

@@ -12,13 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-import copy
 from typing import Callable
 from functools import partial
 
 from model_compression_toolkit.constants import PYTORCH
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attach2pytorch import \
     AttachTpcToPytorch
 from model_compression_toolkit.verify_packages import FOUND_TORCH
 
@@ -26,12 +25,9 @@ from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common.visualization.tensorboard_writer import init_tensorboard_writer
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.mixed_precision.resource_utilization_tools.resource_utilization import ResourceUtilization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
-from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework import \
-    TargetPlatformCapabilities
 from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.ptq.runner import ptq_runner
 
@@ -82,7 +78,7 @@ if FOUND_TORCH:
                                                               target_resource_utilization: ResourceUtilization = None,
                                                               core_config: CoreConfig = CoreConfig(),
                                                               qat_config: QATConfig = QATConfig(),
-                                                              target_platform_capabilities: TargetPlatformModel = DEFAULT_PYTORCH_TPC):
+                                                              target_platform_capabilities: TargetPlatformCapabilities = DEFAULT_PYTORCH_TPC):
         """
          Prepare a trained Pytorch model for quantization aware training. First the model quantization is optimized
          with post-training quantization, then the model layers are wrapped with QuantizeWrappers. The model is
@@ -159,7 +155,7 @@ if FOUND_TORCH:
 
         # Attach tpc model to framework
         attach2pytorch = AttachTpcToPytorch()
-        target_platform_capabilities = attach2pytorch.attach(target_platform_capabilities,
+        framework_platform_capabilities = attach2pytorch.attach(target_platform_capabilities,
                                                              core_config.quantization_config.custom_tpc_opset_to_layer)
 
         # Ignore hessian scores service as we do not use it here
@@ -168,7 +164,7 @@ if FOUND_TORCH:
                                                   core_config=core_config,
                                                   fw_info=DEFAULT_PYTORCH_INFO,
                                                   fw_impl=fw_impl,
-                                                  tpc=target_platform_capabilities,
+                                                  fqc=framework_platform_capabilities,
                                                   target_resource_utilization=target_resource_utilization,
                                                   tb_w=tb_w)
 

model_compression_toolkit/qat/pytorch/quantizer/lsq/symmetric_lsq.py

@@ -18,7 +18,7 @@ import numpy as np
 import torch
 import torch.nn as nn
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import PytorchQuantizationWrapper
 from model_compression_toolkit.qat.common import THRESHOLD_TENSOR
 from model_compression_toolkit import constants as C

model_compression_toolkit/qat/pytorch/quantizer/lsq/uniform_lsq.py

@@ -28,7 +28,7 @@ from model_compression_toolkit.trainable_infrastructure.pytorch.quantizer_utils
 from model_compression_toolkit.trainable_infrastructure.common.base_trainable_quantizer import VariableGroup
 from model_compression_toolkit.trainable_infrastructure.common.trainable_quantizer_config import \
     TrainableQuantizerWeightsConfig
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.core.pytorch.utils import to_torch_tensor
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import fix_range_to_include_zero
 from model_compression_toolkit.qat.pytorch.quantizer.base_pytorch_qat_weight_quantizer import BasePytorchQATWeightTrainableQuantizer

model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/symmetric_ste.py

@@ -18,7 +18,7 @@ import numpy as np
 import torch
 import torch.nn as nn
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import PytorchQuantizationWrapper
 from model_compression_toolkit.qat.common import THRESHOLD_TENSOR
 from model_compression_toolkit import constants as C

model_compression_toolkit/qat/pytorch/quantizer/ste_rounding/uniform_ste.py

@@ -20,7 +20,7 @@ from torch import Tensor
 from model_compression_toolkit.constants import RANGE_MAX, RANGE_MIN
 from model_compression_toolkit.trainable_infrastructure.common.constants import FQ_MIN, FQ_MAX
 
-from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from mct_quantizers import QuantizationMethod
 from mct_quantizers import QuantizationTarget, PytorchQuantizationWrapper
 
 from model_compression_toolkit.qat.pytorch.quantizer.base_pytorch_qat_weight_quantizer import BasePytorchQATWeightTrainableQuantizer

model_compression_toolkit/target_platform_capabilities/__init__.py

@@ -12,3 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework.attribute_filter import AttributeFilter
+from model_compression_toolkit.target_platform_capabilities.targetplatform2framework import (
+    FrameworkQuantizationCapabilities, OperationsSetToLayers, Smaller, SmallerEq, NotEq, Eq, GreaterEq, Greater,
+    LayerFilterParams, OperationsToLayers, get_current_tpc)
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities, OperatorsSet, \
+    OperatorSetGroup, Signedness, AttributeQuantizationConfig, OpQuantizationConfig, QuantizationConfigOptions, Fusing
+
+from mct_quantizers import QuantizationMethod

model_compression_toolkit/target_platform_capabilities/constants.py

@@ -21,7 +21,7 @@ LATEST = 'latest'
 
 
 # Supported TP models names:
-DEFAULT_TP_MODEL = 'default'
+DEFAULT_TP_MODEL= 'default'
 IMX500_TP_MODEL = 'imx500'
 TFLITE_TP_MODEL = 'tflite'
 QNNPACK_TP_MODEL = 'qnnpack'

model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py

@@ -7,6 +7,6 @@ OpQuantizationConfig = schema.OpQuantizationConfig
 QuantizationConfigOptions = schema.QuantizationConfigOptions
 OperatorsSetBase = schema.OperatorsSetBase
 OperatorsSet = schema.OperatorsSet
-OperatorSetConcat = schema.OperatorSetConcat
+OperatorSetGroup = schema.OperatorSetGroup
 Fusing = schema.Fusing
-TargetPlatformModel = schema.TargetPlatformModel
+TargetPlatformCapabilities = schema.TargetPlatformCapabilities

model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py

@@ -16,7 +16,7 @@ from logging import Logger
 from typing import Optional
 
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OpQuantizationConfig, \
-    TargetPlatformModel, QuantizationConfigOptions, OperatorsSetBase
+    TargetPlatformCapabilities, QuantizationConfigOptions, OperatorsSetBase
 
 
 def max_input_activation_n_bits(op_quantization_config: OpQuantizationConfig) -> int:
@@ -32,31 +32,31 @@ def max_input_activation_n_bits(op_quantization_config: OpQuantizationConfig) ->
     return max(op_quantization_config.supported_input_activation_n_bits)
 
 
-def get_config_options_by_operators_set(tp_model: TargetPlatformModel,
+def get_config_options_by_operators_set(tpc: TargetPlatformCapabilities,
                                         operators_set_name: str) -> QuantizationConfigOptions:
     """
     Get the QuantizationConfigOptions of an OperatorsSet by its name.
 
     Args:
-        tp_model (TargetPlatformModel): The target platform model containing the operator sets and their configurations.
+        tpc (TargetPlatformCapabilities): The target platform model containing the operator sets and their configurations.
         operators_set_name (str): The name of the OperatorsSet whose quantization configuration options are to be retrieved.
 
     Returns:
         QuantizationConfigOptions: The quantization configuration options associated with the specified OperatorsSet,
         or the default quantization configuration options if the OperatorsSet is not found.
     """
-    for op_set in tp_model.operator_set:
+    for op_set in tpc.operator_set:
         if operators_set_name == op_set.name:
             return op_set.qc_options
-    return tp_model.default_qco
+    return tpc.default_qco
 
 
-def get_default_op_quantization_config(tp_model: TargetPlatformModel) -> OpQuantizationConfig:
+def get_default_op_quantization_config(tpc: TargetPlatformCapabilities) -> OpQuantizationConfig:
     """
-    Get the default OpQuantizationConfig of the TargetPlatformModel.
+    Get the default OpQuantizationConfig of the TargetPlatformCapabilities.
 
     Args:
-        tp_model (TargetPlatformModel): The target platform model containing the default quantization configuration.
+        tpc (TargetPlatformCapabilities): The target platform model containing the default quantization configuration.
 
     Returns:
         OpQuantizationConfig: The default quantization configuration.
@@ -64,32 +64,32 @@ def get_default_op_quantization_config(tp_model: TargetPlatformModel) -> OpQuant
     Raises:
         AssertionError: If the default quantization configuration list contains more than one configuration option.
     """
-    assert len(tp_model.default_qco.quantization_configurations) == 1, \
+    assert len(tpc.default_qco.quantization_configurations) == 1, \
         f"Default quantization configuration options must contain only one option, " \
-        f"but found {len(tp_model.default_qco.quantization_configurations)} configurations." # pragma: no cover
-    return tp_model.default_qco.quantization_configurations[0]
+        f"but found {len(tpc.default_qco.quantization_configurations)} configurations." # pragma: no cover
+    return tpc.default_qco.quantization_configurations[0]
 
 
-def is_opset_in_model(tp_model: TargetPlatformModel, opset_name: str) -> bool:
+def is_opset_in_model(tpc: TargetPlatformCapabilities, opset_name: str) -> bool:
     """
     Check whether an OperatorsSet is defined in the model.
 
     Args:
-        tp_model (TargetPlatformModel): The target platform model containing the list of operator sets.
+        tpc (TargetPlatformCapabilities): The target platform model containing the list of operator sets.
         opset_name (str): The name of the OperatorsSet to check for existence.
 
     Returns:
         bool: True if an OperatorsSet with the given name exists in the target platform model,
               otherwise False.
     """
-    return tp_model.operator_set is not None and opset_name in [x.name for x in tp_model.operator_set]
+    return tpc.operator_set is not None and opset_name in [x.name for x in tpc.operator_set]
 
-def get_opset_by_name(tp_model: TargetPlatformModel, opset_name: str) -> Optional[OperatorsSetBase]:
+def get_opset_by_name(tpc: TargetPlatformCapabilities, opset_name: str) -> Optional[OperatorsSetBase]:
     """
     Get an OperatorsSet object from the model by its name.
 
     Args:
-        tp_model (TargetPlatformModel): The target platform model containing the list of operator sets.
+        tpc (TargetPlatformCapabilities): The target platform model containing the list of operator sets.
         opset_name (str): The name of the OperatorsSet to be retrieved.
 
     Returns:
@@ -99,7 +99,7 @@ def get_opset_by_name(tp_model: TargetPlatformModel, opset_name: str) -> Optiona
     Raises:
         A critical log message if multiple operator sets with the same name are found.
     """
-    opset_list = [x for x in tp_model.operator_set if x.name == opset_name]
+    opset_list = [x for x in tpc.operator_set if x.name == opset_name]
     if len(opset_list) > 1:
-        Logger.critical(f"Found more than one OperatorsSet in TargetPlatformModel with the name {opset_name}.") # pragma: no cover
+        Logger.critical(f"Found more than one OperatorsSet in TargetPlatformCapabilities with the name {opset_name}.") # pragma: no cover
     return opset_list[0] if opset_list else None

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.
 
         """