mct-nightly 2.2.0.20241201.617__py3-none-any.whl → 2.2.0.20241202.131715__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tp_model.py

@@ -15,13 +15,12 @@
 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 model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, WEIGHTS_N_BITS, \
-    WEIGHTS_QUANTIZATION_METHOD
-from model_compression_toolkit.target_platform_capabilities.target_platform import OpQuantizationConfig, \
-    TargetPlatformModel, Signedness
-from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import \
-    AttributeQuantizationConfig
+    WEIGHTS_QUANTIZATION_METHOD, IMX500_TP_MODEL
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, Signedness, \
+    AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
 
@@ -86,7 +85,7 @@ def get_op_quantization_configs() -> \
 
     # We define a default config for operation without kernel attribute.
     # This is the default config that should be used for non-linear operations.
-    eight_bits_default = tp.OpQuantizationConfig(
+    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,
@@ -100,7 +99,7 @@ def get_op_quantization_configs() -> \
         signedness=Signedness.AUTO)
 
     # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
-    linear_eight_bits = tp.OpQuantizationConfig(
+    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,
@@ -153,7 +152,7 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     # of possible configurations to consider when quantizing a set of operations (in mixed-precision, for example).
     # If the QuantizationConfigOptions contains only one configuration,
     # this configuration will be used for the operation quantization:
-    default_configuration_options = tp.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions([default_config])
 
     # Create a QuantizationConfigOptions for quantizing constants in functional ops.
     # Constant configuration is similar to the default eight bit configuration except for PoT
@@ -164,12 +163,18 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         default_weight_attr_config=default_config.default_weight_attr_config.clone_and_edit(
             enable_weights_quantization=True, weights_per_channel_threshold=True,
             weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO))
-    const_configuration_options = tp.QuantizationConfigOptions([const_config])
+    const_configuration_options = schema.QuantizationConfigOptions([const_config])
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
-    generated_tpm = tp.TargetPlatformModel(default_configuration_options, add_metadata=True, name=name)
+    generated_tpm = schema.TargetPlatformModel(
+        default_configuration_options,
+        tpc_minor_version=3,
+        tpc_patch_version=0,
+        tpc_platform_type=IMX500_TP_MODEL,
+        add_metadata=True,
+        name=name)
 
     # To start defining the model's components (such as operator sets, and fusing patterns),
     # use 'with' the TargetPlatformModel instance, and create them as below:
@@ -182,42 +187,42 @@ def generate_tp_model(default_config: OpQuantizationConfig,
 
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
-        tp.OperatorsSet("NoQuantization",
-                        default_qco.clone_and_edit(enable_activation_quantization=False)
-                        .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+        schema.OperatorsSet("NoQuantization",
+                               default_qco.clone_and_edit(enable_activation_quantization=False)
+                               .clone_and_edit_weight_attribute(enable_weights_quantization=False))
 
         # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
-        mixed_precision_configuration_options = tp.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                             base_config=base_config)
+        mixed_precision_configuration_options = schema.QuantizationConfigOptions(mixed_precision_cfg_list,
+                                                                                    base_config=base_config)
 
         # Define operator sets that use mixed_precision_configuration_options:
-        conv = tp.OperatorsSet("Conv", mixed_precision_configuration_options)
-        fc = tp.OperatorsSet("FullyConnected", mixed_precision_configuration_options)
+        conv = schema.OperatorsSet("Conv", mixed_precision_configuration_options)
+        fc = schema.OperatorsSet("FullyConnected", mixed_precision_configuration_options)
 
         # Define operations sets without quantization configuration
         # options (useful for creating fusing patterns, for example):
-        any_relu = tp.OperatorsSet("AnyReLU")
-        add = tp.OperatorsSet("Add", const_configuration_options)
-        sub = tp.OperatorsSet("Sub", const_configuration_options)
-        mul = tp.OperatorsSet("Mul", const_configuration_options)
-        div = tp.OperatorsSet("Div", const_configuration_options)
-        prelu = tp.OperatorsSet("PReLU")
-        swish = tp.OperatorsSet("Swish")
-        sigmoid = tp.OperatorsSet("Sigmoid")
-        tanh = tp.OperatorsSet("Tanh")
+        any_relu = schema.OperatorsSet("AnyReLU")
+        add = schema.OperatorsSet("Add", const_configuration_options)
+        sub = schema.OperatorsSet("Sub", const_configuration_options)
+        mul = schema.OperatorsSet("Mul", const_configuration_options)
+        div = schema.OperatorsSet("Div", const_configuration_options)
+        prelu = schema.OperatorsSet("PReLU")
+        swish = schema.OperatorsSet("Swish")
+        sigmoid = schema.OperatorsSet("Sigmoid")
+        tanh = schema.OperatorsSet("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 = tp.OperatorSetConcat(any_relu, swish, prelu, sigmoid, tanh)
-        activations_after_fc_to_fuse = tp.OperatorSetConcat(any_relu, swish, sigmoid)
-        any_binary = tp.OperatorSetConcat(add, sub, mul, div)
+        activations_after_conv_to_fuse = schema.OperatorSetConcat(any_relu, swish, prelu, sigmoid, tanh)
+        activations_after_fc_to_fuse = schema.OperatorSetConcat(any_relu, swish, sigmoid)
+        any_binary = schema.OperatorSetConcat(add, sub, mul, div)
 
         # ------------------- #
         # Fusions
         # ------------------- #
-        tp.Fusing([conv, activations_after_conv_to_fuse])
-        tp.Fusing([fc, activations_after_fc_to_fuse])
-        tp.Fusing([any_binary, any_relu])
+        schema.Fusing([conv, activations_after_conv_to_fuse])
+        schema.Fusing([fc, activations_after_fc_to_fuse])
+        schema.Fusing([any_binary, any_relu])
 
     return generated_tpm

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tpc_keras.py

@@ -15,6 +15,7 @@
 import tensorflow as tf
 from packaging import version
 
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.verify_packages import FOUND_SONY_CUSTOM_LAYERS
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, KERAS_KERNEL, BIAS_ATTR, \
@@ -48,7 +49,7 @@ def get_keras_tpc() -> tp.TargetPlatformCapabilities:
     return generate_keras_tpc(name='imx500_tpc_keras_tpc', tp_model=imx500_tpc_tp_model)
 
 
-def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_keras_tpc(name: str, tp_model: TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
 
@@ -59,7 +60,7 @@ def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    keras_tpc = tp.TargetPlatformCapabilities(tp_model, name=name, version=TPC_VERSION)
+    keras_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     no_quant_list = [Identity,
                      tf.identity,

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tpc_pytorch.py

@@ -23,6 +23,7 @@ from torch.nn import Dropout, Flatten, Hardtanh, Identity
 from torch.nn import ReLU, ReLU6, PReLU, SiLU, Sigmoid, Tanh, Hardswish, LeakyReLU
 from torch.nn.functional import relu, relu6, prelu, silu, hardtanh, hardswish, leaky_relu
 
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, PYTORCH_KERNEL, BIAS_ATTR, \
     BIAS
@@ -42,7 +43,7 @@ def get_pytorch_tpc() -> tp.TargetPlatformCapabilities:
     return generate_pytorch_tpc(name='imx500_tpc_pytorch_tpc', tp_model=imx500_tpc_tp_model)
 
 
-def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_pytorch_tpc(name: str, tp_model: TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
     Args:
@@ -51,9 +52,7 @@ def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model,
-                                                name=name,
-                                                version=TPC_VERSION)
+    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     # we provide attributes mapping that maps each layer type in the operations set
     # that has weights attributes with provided quantization config (in the tp model) to

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tp_model.py

@@ -15,12 +15,12 @@
 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 model_compression_toolkit.constants import FLOAT_BITWIDTH
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, WEIGHTS_N_BITS
-from model_compression_toolkit.target_platform_capabilities.target_platform import OpQuantizationConfig, \
-    TargetPlatformModel, Signedness
-from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import \
-    AttributeQuantizationConfig
+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, \
+    AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
 
@@ -112,7 +112,7 @@ def get_op_quantization_configs() -> \
 
     # We define a default config for operation without kernel attribute.
     # This is the default config that should be used for non-linear operations.
-    eight_bits_default = tp.OpQuantizationConfig(
+    eight_bits_default = OpQuantizationConfig(
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={},
         activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
@@ -126,7 +126,7 @@ def get_op_quantization_configs() -> \
         signedness=Signedness.AUTO)
 
     # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
-    linear_eight_bits = tp.OpQuantizationConfig(
+    linear_eight_bits = 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,
@@ -176,12 +176,13 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     # of possible configurations to consider when quantizing a set of operations (in mixed-precision, for example).
     # If the QuantizationConfigOptions contains only one configuration,
     # this configuration will be used for the operation quantization:
-    default_configuration_options = tp.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions([default_config])
     default_config_input16 = default_config.clone_and_edit(supported_input_activation_n_bits=(8, 16))
-    default_config_options_16bit = tp.QuantizationConfigOptions([default_config_input16,
-                                                                 default_config_input16.clone_and_edit(activation_n_bits=16,
-                                                                                                       signedness=Signedness.SIGNED)],
-                                                                base_config=default_config_input16)
+    default_config_options_16bit = schema.QuantizationConfigOptions([default_config_input16,
+                                                                        default_config_input16.clone_and_edit(
+                                                                            activation_n_bits=16,
+                                                                            signedness=Signedness.SIGNED)],
+                                                                       base_config=default_config_input16)
 
     # Create a QuantizationConfigOptions for quantizing constants in functional ops.
     # Constant configuration is similar to the default eight bit configuration except for PoT
@@ -192,7 +193,7 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         default_weight_attr_config=default_config.default_weight_attr_config.clone_and_edit(
             enable_weights_quantization=True, weights_per_channel_threshold=True,
             weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO))
-    const_configuration_options = tp.QuantizationConfigOptions([const_config])
+    const_configuration_options = schema.QuantizationConfigOptions([const_config])
 
     # 16 bits inputs and outputs. Currently, only defined for consts since they are used in operators that
     # support 16 bit as input and output.
@@ -200,27 +201,28 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         supported_input_activation_n_bits=(8, 16))
     const_config_input16_output16 = const_config_input16.clone_and_edit(
         activation_n_bits=16, signedness=Signedness.SIGNED)
-    const_configuration_options_inout16 = tp.QuantizationConfigOptions([const_config_input16_output16,
-                                                                        const_config_input16],
-                                                                       base_config=const_config_input16)
+    const_configuration_options_inout16 = schema.QuantizationConfigOptions([const_config_input16_output16,
+                                                                               const_config_input16],
+                                                                                                                                     base_config=const_config_input16)
 
     const_config_input16_per_tensor = const_config.clone_and_edit(
         supported_input_activation_n_bits=(8, 16),
         default_weight_attr_config=default_config.default_weight_attr_config.clone_and_edit(
-            enable_weights_quantization=True, weights_per_channel_threshold=True,
+            enable_weights_quantization=True, weights_per_channel_threshold=False,
             weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO)
     )
     const_config_input16_output16_per_tensor = const_config_input16_per_tensor.clone_and_edit(
         activation_n_bits=16, signedness=Signedness.SIGNED)
-    const_configuration_options_inout16_per_tensor = tp.QuantizationConfigOptions([const_config_input16_output16_per_tensor,
-                                                                                   const_config_input16_per_tensor],
-                                                                                  base_config=const_config_input16_per_tensor)
+    const_configuration_options_inout16_per_tensor = schema.QuantizationConfigOptions(
+        [const_config_input16_output16_per_tensor,
+         const_config_input16_per_tensor],
+        base_config=const_config_input16_per_tensor)
 
     qpreserving_const_config = const_config.clone_and_edit(enable_activation_quantization=False,
                                                            quantization_preserving=True,
                                                            default_weight_attr_config=const_config.default_weight_attr_config.clone_and_edit(
                                                                weights_per_channel_threshold=False))
-    qpreserving_const_config_options = tp.QuantizationConfigOptions([qpreserving_const_config])
+    qpreserving_const_config_options = schema.QuantizationConfigOptions([qpreserving_const_config])
 
     mp_cfg_list_16bit = [mp_cfg.clone_and_edit(activation_n_bits=16, signedness=Signedness.SIGNED)
                          for mp_cfg in mixed_precision_cfg_list]
@@ -228,7 +230,12 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
-    generated_tpm = tp.TargetPlatformModel(default_configuration_options, add_metadata=True, name=name)
+    generated_tpm = schema.TargetPlatformModel(
+        default_configuration_options,
+        tpc_minor_version=4,
+        tpc_patch_version=0,
+        tpc_platform_type=IMX500_TP_MODEL,
+        add_metadata=True, name=name)
 
     # To start defining the model's components (such as operator sets, and fusing patterns),
     # use 'with' the TargetPlatformModel instance, and create them as below:
@@ -243,60 +250,61 @@ def generate_tp_model(default_config: OpQuantizationConfig,
 
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
-        tp.OperatorsSet(OPSET_NO_QUANTIZATION,
-                        default_qco.clone_and_edit(enable_activation_quantization=False)
-                        .clone_and_edit_weight_attribute(enable_weights_quantization=False))
-        tp.OperatorsSet(OPSET_QUANTIZATION_PRESERVING,
-                        default_qco.clone_and_edit(enable_activation_quantization=False,
-                                                   quantization_preserving=True)
-                        .clone_and_edit_weight_attribute(enable_weights_quantization=False))
-        tp.OperatorsSet(OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, qpreserving_const_config_options)
-        tp.OperatorsSet(OPSET_DIMENSION_MANIPULATION_OPS,
-                        default_qco.clone_and_edit(enable_activation_quantization=False,
-                                                   quantization_preserving=True,
-                                                   supported_input_activation_n_bits=(8, 16))
-                        .clone_and_edit_weight_attribute(enable_weights_quantization=False))
-        tp.OperatorsSet(OPSET_MERGE_OPS, const_configuration_options_inout16_per_tensor)
+        schema.OperatorsSet(OPSET_NO_QUANTIZATION,
+                               default_qco.clone_and_edit(enable_activation_quantization=False)
+                               .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+        schema.OperatorsSet(OPSET_QUANTIZATION_PRESERVING,
+                               default_qco.clone_and_edit(enable_activation_quantization=False,
+                                                          quantization_preserving=True)
+                               .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+        schema.OperatorsSet(OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, qpreserving_const_config_options)
+        schema.OperatorsSet(OPSET_DIMENSION_MANIPULATION_OPS,
+                               default_qco.clone_and_edit(enable_activation_quantization=False,
+                                                          quantization_preserving=True,
+                                                          supported_input_activation_n_bits=(8, 16))
+                               .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+        schema.OperatorsSet(OPSET_MERGE_OPS, const_configuration_options_inout16_per_tensor)
 
         # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
-        mixed_precision_configuration_options = tp.QuantizationConfigOptions(mixed_precision_cfg_list + mp_cfg_list_16bit,
-                                                                             base_config=base_config)
+        mixed_precision_configuration_options = schema.QuantizationConfigOptions(
+            mixed_precision_cfg_list + mp_cfg_list_16bit,
+            base_config=base_config)
 
         # Define operator sets that use mixed_precision_configuration_options:
-        conv = tp.OperatorsSet(OPSET_CONV, mixed_precision_configuration_options)
-        fc = tp.OperatorsSet(OPSET_FULLY_CONNECTED, mixed_precision_configuration_options)
+        conv = schema.OperatorsSet(OPSET_CONV, mixed_precision_configuration_options)
+        fc = schema.OperatorsSet(OPSET_FULLY_CONNECTED, mixed_precision_configuration_options)
 
-        tp.OperatorsSet(OPSET_BATCH_NORM, default_config_options_16bit)
+        schema.OperatorsSet(OPSET_BATCH_NORM, default_config_options_16bit)
 
         # Note: Operations sets without quantization configuration are useful for creating fusing patterns
-        any_relu = tp.OperatorsSet(OPSET_ANY_RELU, default_config_options_16bit)
-        add = tp.OperatorsSet(OPSET_ADD, const_configuration_options_inout16)
-        sub = tp.OperatorsSet(OPSET_SUB, const_configuration_options_inout16)
-        mul = tp.OperatorsSet(OPSET_MUL, const_configuration_options_inout16)
-        div = tp.OperatorsSet(OPSET_DIV, const_configuration_options)
-        tp.OperatorsSet(OPSET_MIN_MAX, const_configuration_options_inout16)
-        prelu = tp.OperatorsSet(OPSET_PRELU, default_config_options_16bit)
-        swish = tp.OperatorsSet(OPSET_SWISH, default_config_options_16bit)
-        sigmoid = tp.OperatorsSet(OPSET_SIGMOID, default_config_options_16bit)
-        tanh = tp.OperatorsSet(OPSET_TANH, default_config_options_16bit)
-        gelu = tp.OperatorsSet(OPSET_GELU, default_config_options_16bit)
-        hardsigmoid = tp.OperatorsSet(OPSET_HARDSIGMOID, default_config_options_16bit)
-        hardswish = tp.OperatorsSet(OPSET_HARDSWISH, default_config_options_16bit)
+        any_relu = schema.OperatorsSet(OPSET_ANY_RELU, default_config_options_16bit)
+        add = schema.OperatorsSet(OPSET_ADD, const_configuration_options_inout16)
+        sub = schema.OperatorsSet(OPSET_SUB, const_configuration_options_inout16)
+        mul = schema.OperatorsSet(OPSET_MUL, const_configuration_options_inout16)
+        div = schema.OperatorsSet(OPSET_DIV, const_configuration_options)
+        schema.OperatorsSet(OPSET_MIN_MAX, const_configuration_options_inout16)
+        prelu = schema.OperatorsSet(OPSET_PRELU, default_config_options_16bit)
+        swish = schema.OperatorsSet(OPSET_SWISH, default_config_options_16bit)
+        sigmoid = schema.OperatorsSet(OPSET_SIGMOID, default_config_options_16bit)
+        tanh = schema.OperatorsSet(OPSET_TANH, default_config_options_16bit)
+        gelu = schema.OperatorsSet(OPSET_GELU, default_config_options_16bit)
+        hardsigmoid = schema.OperatorsSet(OPSET_HARDSIGMOID, default_config_options_16bit)
+        hardswish = schema.OperatorsSet(OPSET_HARDSWISH, default_config_options_16bit)
 
         # 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 = tp.OperatorSetConcat(any_relu, swish, prelu, sigmoid,
-                                                              tanh, gelu, hardswish, hardsigmoid)
-        activations_after_fc_to_fuse = tp.OperatorSetConcat(any_relu, swish, sigmoid, tanh, gelu,
-                                                            hardswish, hardsigmoid)
-        any_binary = tp.OperatorSetConcat(add, sub, mul, div)
+        activations_after_conv_to_fuse = schema.OperatorSetConcat(any_relu, swish, prelu, sigmoid,
+                                                                     tanh, gelu, hardswish, hardsigmoid)
+        activations_after_fc_to_fuse = schema.OperatorSetConcat(any_relu, swish, sigmoid, tanh, gelu,
+                                                                   hardswish, hardsigmoid)
+        any_binary = schema.OperatorSetConcat(add, sub, mul, div)
 
         # ------------------- #
         # Fusions
         # ------------------- #
-        tp.Fusing([conv, activations_after_conv_to_fuse])
-        tp.Fusing([fc, activations_after_fc_to_fuse])
-        tp.Fusing([any_binary, any_relu])
+        schema.Fusing([conv, activations_after_conv_to_fuse])
+        schema.Fusing([fc, activations_after_fc_to_fuse])
+        schema.Fusing([any_binary, any_relu])
 
     return generated_tpm

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tpc_keras.py

@@ -15,6 +15,7 @@
 import tensorflow as tf
 from packaging import version
 
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.verify_packages import FOUND_SONY_CUSTOM_LAYERS
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, KERAS_DEPTHWISE_KERNEL, \
@@ -53,7 +54,7 @@ def get_keras_tpc() -> tp.TargetPlatformCapabilities:
     return generate_keras_tpc(name='imx500_tpc_keras_tpc', tp_model=imx500_tpc_tp_model)
 
 
-def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_keras_tpc(name: str, tp_model: schema.TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
 
@@ -64,7 +65,7 @@ def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    keras_tpc = tp.TargetPlatformCapabilities(tp_model, name=name, version=TPC_VERSION)
+    keras_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     no_quant_list = [tf.quantization.fake_quant_with_min_max_vars,
                      tf.math.argmax,

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tpc_pytorch.py

@@ -25,6 +25,7 @@ from torch.nn import ReLU, ReLU6, PReLU, SiLU, Sigmoid, Tanh, Hardswish, Hardsig
 import torch.nn.functional as F
 from torch.nn.functional import relu, relu6, prelu, silu, hardtanh, hardswish, hardsigmoid, leaky_relu, gelu
 
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, PYTORCH_KERNEL, \
     BIAS
@@ -50,7 +51,7 @@ def get_pytorch_tpc() -> tp.TargetPlatformCapabilities:
     return generate_pytorch_tpc(name='imx500_tpc_pytorch_tpc', tp_model=imx500_tpc_tp_model)
 
 
-def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_pytorch_tpc(name: str, tp_model: schema.TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
     Args:
@@ -59,9 +60,7 @@ def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model,
-                                                name=name,
-                                                version=TPC_VERSION)
+    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     # we provide attributes mapping that maps each layer type in the operations set
     # that has weights attributes with provided quantization config (in the tp model) to

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tp_model.py

@@ -15,12 +15,11 @@
 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 model_compression_toolkit.constants import FLOAT_BITWIDTH
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR
-from model_compression_toolkit.target_platform_capabilities.target_platform import OpQuantizationConfig, \
-    TargetPlatformModel, Signedness
-from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import \
-    AttributeQuantizationConfig
+from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, QNNPACK_TP_MODEL
+from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, Signedness, \
+    AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
 
@@ -85,7 +84,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a default config for operation without kernel attribute.
     # This is the default config that should be used for non-linear operations.
-    eight_bits_default = tp.OpQuantizationConfig(
+    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,
@@ -99,7 +98,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         signedness=Signedness.AUTO)
 
     # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
-    linear_eight_bits = tp.OpQuantizationConfig(
+    linear_eight_bits = schema.OpQuantizationConfig(
         activation_quantization_method=tp.QuantizationMethod.UNIFORM,
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
@@ -139,12 +138,18 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     # of possible configurations to consider when quantizing a set of operations (in mixed-precision, for example).
     # If the QuantizationConfigOptions contains only one configuration,
     # this configuration will be used for the operation quantization:
-    default_configuration_options = tp.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions([default_config])
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
-    generated_tpc = tp.TargetPlatformModel(default_configuration_options, name=name)
+    generated_tpc = schema.TargetPlatformModel(
+        default_configuration_options,
+        tpc_minor_version=1,
+        tpc_patch_version=0,
+        tpc_platform_type=QNNPACK_TP_MODEL,
+        add_metadata=False,
+        name=name)
 
     # To start defining the model's components (such as operator sets, and fusing patterns),
     # use 'with' the target platform model instance, and create them as below:
@@ -153,17 +158,17 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # Pytorch supports the next fusing patterns:
         # [Conv, Relu], [Conv, BatchNorm], [Conv, BatchNorm, Relu], [Linear, Relu]
         # Source: # https://pytorch.org/docs/stable/quantization.html#model-preparation-for-quantization-eager-mode
-        conv = tp.OperatorsSet("Conv")
-        batchnorm = tp.OperatorsSet("BatchNorm")
-        relu = tp.OperatorsSet("Relu")
-        linear = tp.OperatorsSet("Linear")
+        conv = schema.OperatorsSet("Conv")
+        batchnorm = schema.OperatorsSet("BatchNorm")
+        relu = schema.OperatorsSet("Relu")
+        linear = schema.OperatorsSet("Linear")
 
         # ------------------- #
         # Fusions
         # ------------------- #
-        tp.Fusing([conv, batchnorm, relu])
-        tp.Fusing([conv, batchnorm])
-        tp.Fusing([conv, relu])
-        tp.Fusing([linear, relu])
+        schema.Fusing([conv, batchnorm, relu])
+        schema.Fusing([conv, batchnorm])
+        schema.Fusing([conv, relu])
+        schema.Fusing([linear, relu])
 
     return generated_tpc

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tpc_keras.py

@@ -16,6 +16,7 @@ import tensorflow as tf
 
 from packaging import version
 
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, KERAS_KERNEL, BIAS_ATTR, \
     KERAS_DEPTHWISE_KERNEL, BIAS
@@ -41,7 +42,7 @@ def get_keras_tpc() -> tp.TargetPlatformCapabilities:
     return generate_keras_tpc(name='qnnpack_keras', tp_model=qnnpack_tp_model)
 
 
-def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_keras_tpc(name: str, tp_model: schema.TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
 
@@ -52,9 +53,7 @@ def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    keras_tpc = tp.TargetPlatformCapabilities(tp_model,
-                                              name=name,
-                                              version=TPC_VERSION)
+    keras_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     with keras_tpc:
         tp.OperationsSetToLayers("Conv",

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/v1/tpc_pytorch.py

@@ -16,6 +16,7 @@ import torch
 from torch.nn import Conv2d, Linear, BatchNorm2d, ConvTranspose2d, Hardtanh, ReLU, ReLU6
 from torch.nn.functional import relu, relu6, hardtanh
 
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, PYTORCH_KERNEL, BIAS_ATTR, \
     BIAS
@@ -35,7 +36,7 @@ def get_pytorch_tpc() -> tp.TargetPlatformCapabilities:
     return generate_pytorch_tpc(name='qnnpack_pytorch', tp_model=qnnpack_pytorch)
 
 
-def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_pytorch_tpc(name: str, tp_model: schema.TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
     Args:
@@ -44,9 +45,7 @@ def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model,
-                                                name=name,
-                                                version=TPC_VERSION)
+    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     # we provide attributes mapping that maps each layer type in the operations set
     # that has weights attributes with provided quantization config (in the tp model) to