mct-nightly 2.2.0.20241222.533__py3-none-any.whl → 2.2.0.20241224.532__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/attach2pytorch.py

@@ -0,0 +1,91 @@
+# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import operator
+
+import torch
+from torch import add, sub, mul, div, divide, flatten, reshape, split, unsqueeze, dropout, sigmoid, tanh, \
+    chunk, unbind, topk, gather, equal, transpose, permute, argmax, squeeze, multiply, subtract, minimum, \
+    maximum
+from torch.nn import Conv2d, Linear, ConvTranspose2d, MaxPool2d, BatchNorm2d
+from torch.nn import Dropout, Flatten, Hardtanh
+from torch.nn import ReLU, ReLU6, PReLU, SiLU, Sigmoid, Tanh, Hardswish, Hardsigmoid, LeakyReLU, GELU
+import torch.nn.functional as F
+from torch.nn.functional import relu, relu6, prelu, silu, hardtanh, hardswish, hardsigmoid, leaky_relu, gelu
+
+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
+from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2fw import \
+    AttachTpModelToFw
+
+
+class AttachTpModelToPytorch(AttachTpModelToFw):
+    def __init__(self):
+        super().__init__()
+
+        self._opset2layer = {
+            OperatorSetNames.OPSET_CONV.value: [Conv2d],
+            OperatorSetNames.OPSET_CONV_TRANSPOSE.value: [ConvTranspose2d],
+            OperatorSetNames.OPSET_FULLY_CONNECTED.value: [Linear],
+            OperatorSetNames.OPSET_CONCATENATE.value: [torch.cat, torch.concat, torch.concatenate],
+            OperatorSetNames.OPSET_STACK.value: [torch.stack],
+            OperatorSetNames.OPSET_UNSTACK.value: [unbind],
+            OperatorSetNames.OPSET_GATHER.value: [gather],
+            OperatorSetNames.OPSET_EXPAND.value: [torch.Tensor.expand],
+            OperatorSetNames.OPSET_BATCH_NORM.value: [BatchNorm2d],
+            OperatorSetNames.OPSET_RELU.value: [torch.relu, ReLU, relu],
+            OperatorSetNames.OPSET_RELU6.value: [ReLU6, relu6],
+            OperatorSetNames.OPSET_LEAKY_RELU.value: [LeakyReLU, leaky_relu],
+            OperatorSetNames.OPSET_HARD_TANH.value: [LayerFilterParams(Hardtanh, min_val=0),
+                                                     LayerFilterParams(hardtanh, min_val=0)],
+            OperatorSetNames.OPSET_ADD.value: [operator.add, add],
+            OperatorSetNames.OPSET_SUB.value: [operator.sub, sub, subtract],
+            OperatorSetNames.OPSET_MUL.value: [operator.mul, mul, multiply],
+            OperatorSetNames.OPSET_DIV.value: [operator.truediv, div, divide],
+            OperatorSetNames.OPSET_MIN.value: [minimum],
+            OperatorSetNames.OPSET_MAX.value: [maximum],
+            OperatorSetNames.OPSET_PRELU.value: [PReLU, prelu],
+            OperatorSetNames.OPSET_SWISH.value: [SiLU, silu],
+            OperatorSetNames.OPSET_SIGMOID.value: [Sigmoid, sigmoid, F.sigmoid],
+            OperatorSetNames.OPSET_TANH.value: [Tanh, tanh, F.tanh],
+            OperatorSetNames.OPSET_GELU.value: [GELU, gelu],
+            OperatorSetNames.OPSET_HARDSIGMOID.value: [Hardsigmoid, hardsigmoid],
+            OperatorSetNames.OPSET_HARDSWISH.value: [Hardswish, hardswish],
+            OperatorSetNames.OPSET_FLATTEN.value: [Flatten, flatten],
+            OperatorSetNames.OPSET_GET_ITEM.value: [operator.getitem],
+            OperatorSetNames.OPSET_RESHAPE.value: [reshape],
+            OperatorSetNames.OPSET_UNSQUEEZE.value: [unsqueeze],
+            OperatorSetNames.OPSET_SQUEEZE.value: [squeeze],
+            OperatorSetNames.OPSET_PERMUTE.value: [permute],
+            OperatorSetNames.OPSET_TRANSPOSE.value: [transpose],
+            OperatorSetNames.OPSET_DROPOUT.value: [Dropout, dropout],
+            OperatorSetNames.OPSET_SPLIT.value: [split],
+            OperatorSetNames.OPSET_CHUNK.value: [chunk],
+            OperatorSetNames.OPSET_MAXPOOL.value: [MaxPool2d],
+            OperatorSetNames.OPSET_SIZE.value: [torch.Tensor.size],
+            OperatorSetNames.OPSET_SHAPE.value: [torch.Tensor.shape],
+            OperatorSetNames.OPSET_EQUAL.value: [equal],
+            OperatorSetNames.OPSET_ARGMAX.value: [argmax],
+            OperatorSetNames.OPSET_TOPK.value: [topk],
+        }
+
+        pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),
+                                       BIAS_ATTR: DefaultDict(default_value=BIAS)}
+        self._opset2attr_mapping = {OperatorSetNames.OPSET_CONV.value: pytorch_linear_attr_mapping,
+                                    OperatorSetNames.OPSET_CONV_TRANSPOSE.value: pytorch_linear_attr_mapping,
+                                    OperatorSetNames.OPSET_FULLY_CONNECTED.value: pytorch_linear_attr_mapping}

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/operations_to_layers.py

@@ -90,7 +90,7 @@ class OperationsToLayers:
                 return o.layers
         if isinstance(op, OperatorSetConcat):  # If its a concat - return all layers from all OperatorsSets that in the OperatorSetConcat
             layers = []
-            for o in op.op_set_list:
+            for o in op.operators_set:
                 layers.extend(self.get_layers_by_op(o))
             return layers
         Logger.warning(f'{op.name} is not in model.')

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/target_platform_capabilities.py

@@ -100,8 +100,10 @@ class TargetPlatformCapabilities(ImmutableClass):
 
         """
         res = []
+        if self.tp_model.fusing_patterns is None:
+            return res
         for p in self.tp_model.fusing_patterns:
-            ops = [self.get_layers_by_opset(x) for x in p.operator_groups_list]
+            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]
 
@@ -207,9 +209,10 @@ class TargetPlatformCapabilities(ImmutableClass):
         Remove OperatorSets names from the list of the unused sets (so a warning
         will not be displayed).
         """
-        for f in self.tp_model.fusing_patterns:
-            for s in f.operator_groups_list:
-                self.remove_opset_from_not_used_list(s.name)
+        if self.tp_model.fusing_patterns is not None:
+            for f in self.tp_model.fusing_patterns:
+                for s in f.operator_groups:
+                    self.remove_opset_from_not_used_list(s.name)
 
     def remove_opset_from_not_used_list(self,
                                         opset_to_remove: str):

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

@@ -153,7 +153,54 @@ 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 = schema.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions(tuple([default_config]))
+
+    # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(mixed_precision_cfg_list),
+                                                                             base_config=base_config)
+
+    # Create an OperatorsSet to represent a set of operations.
+    # Each OperatorsSet has a unique label.
+    # If a quantization configuration options is passed, these options will
+    # be used for operations that will be attached to this set's label.
+    # Otherwise, it will be a configure-less set (used in fusing):
+    operator_set = []
+    fusing_patterns = []
+
+    operator_set.append(schema.OperatorsSet("NoQuantization",
+                           default_configuration_options.clone_and_edit(enable_activation_quantization=False)
+                           .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
+
+    # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
+    add = schema.OperatorsSet("Add")
+    sub = schema.OperatorsSet("Sub")
+    mul = schema.OperatorsSet("Mul")
+    div = schema.OperatorsSet("Div")
+    prelu = schema.OperatorsSet("PReLU")
+    swish = schema.OperatorsSet("Swish")
+    sigmoid = schema.OperatorsSet("Sigmoid")
+    tanh = schema.OperatorsSet("Tanh")
+
+    operator_set.extend([conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, 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([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
+    # ------------------- #
+    fusing_patterns.append(schema.Fusing((conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing((fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing((any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
@@ -163,57 +210,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
+        operator_set=tuple(operator_set),
+        fusing_patterns=tuple(fusing_patterns),
         name=name,
         add_metadata=False,
         is_simd_padding=True)
-
-    # To start defining the model's components (such as operator sets, and fusing patterns),
-    # use 'with' the TargetPlatformModel instance, and create them as below:
-    with generated_tpc:
-        # Create an OperatorsSet to represent a set of operations.
-        # Each OperatorsSet has a unique label.
-        # If a quantization configuration options is passed, these options will
-        # be used for operations that will be attached to this set's label.
-        # Otherwise, it will be a configure-less set (used in fusing):
-
-        # May suit for operations like: Dropout, Reshape, etc.
-        default_qco = tp.get_default_quantization_config_options()
-        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 = schema.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                                    base_config=base_config)
-
-        # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
-        add = schema.OperatorsSet("Add")
-        sub = schema.OperatorsSet("Sub")
-        mul = schema.OperatorsSet("Mul")
-        div = schema.OperatorsSet("Div")
-        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 = 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
-        # ------------------- #
-        schema.Fusing([conv, activations_after_conv_to_fuse])
-        schema.Fusing([fc, activations_after_fc_to_fuse])
-        schema.Fusing([any_binary, any_relu])
-
     return generated_tpc

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

@@ -19,7 +19,8 @@ import model_compression_toolkit.target_platform_capabilities.schema.mct_current
 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, 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 TargetPlatformModel, \
+    Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
@@ -150,7 +151,56 @@ 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 = schema.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions(tuple([default_config]))
+
+    # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(mixed_precision_cfg_list),
+                                                                             base_config=base_config)
+
+    # Create an OperatorsSet to represent a set of operations.
+    # Each OperatorsSet has a unique label.
+    # If a quantization configuration options is passed, these options will
+    # be used for operations that will be attached to this set's label.
+    # Otherwise, it will be a configure-less set (used in fusing):
+    operator_set = []
+    fusing_patterns = []
+
+    # May suit for operations like: Dropout, Reshape, etc.
+    operator_set.append(schema.OperatorsSet("NoQuantization",
+                                            default_configuration_options.clone_and_edit(
+                                                enable_activation_quantization=False)
+                                            .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
+
+    # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
+    add = schema.OperatorsSet("Add")
+    sub = schema.OperatorsSet("Sub")
+    mul = schema.OperatorsSet("Mul")
+    div = schema.OperatorsSet("Div")
+    prelu = schema.OperatorsSet("PReLU")
+    swish = schema.OperatorsSet("Swish")
+    sigmoid = schema.OperatorsSet("Sigmoid")
+    tanh = schema.OperatorsSet("Tanh")
+
+    operator_set.extend([conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, 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([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
+    # ------------------- #
+    fusing_patterns.append(schema.Fusing((conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing((fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing((any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
@@ -160,56 +210,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
+        operator_set=tuple(operator_set),
+        fusing_patterns=tuple(fusing_patterns),
         add_metadata=False,
         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:
-    with generated_tpc:
-        # Create an OperatorsSet to represent a set of operations.
-        # Each OperatorsSet has a unique label.
-        # If a quantization configuration options is passed, these options will
-        # be used for operations that will be attached to this set's label.
-        # Otherwise, it will be a configure-less set (used in fusing):
-
-        # May suit for operations like: Dropout, Reshape, etc.
-        default_qco = tp.get_default_quantization_config_options()
-        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 = schema.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                                    base_config=base_config)
-
-        # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
-        add = schema.OperatorsSet("Add")
-        sub = schema.OperatorsSet("Sub")
-        mul = schema.OperatorsSet("Mul")
-        div = schema.OperatorsSet("Div")
-        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 = 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
-        # ------------------- #
-        schema.Fusing([conv, activations_after_conv_to_fuse])
-        schema.Fusing([fc, activations_after_fc_to_fuse])
-        schema.Fusing([any_binary, any_relu])
-
     return generated_tpc

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

@@ -19,7 +19,8 @@ import model_compression_toolkit.target_platform_capabilities.schema.mct_current
 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 TargetPlatformModel, \
+    Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
@@ -146,7 +147,57 @@ 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 = schema.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions(tuple([default_config]))
+
+    # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(mixed_precision_cfg_list),
+                                                                             base_config=base_config)
+
+    # Create an OperatorsSet to represent a set of operations.
+    # Each OperatorsSet has a unique label.
+    # If a quantization configuration options is passed, these options will
+    # be used for operations that will be attached to this set's label.
+    # Otherwise, it will be a configure-less set (used in fusing):
+    operator_set = []
+    fusing_patterns = []
+
+    # May suit for operations like: Dropout, Reshape, etc.
+    operator_set.append(schema.OperatorsSet("NoQuantization",
+                                            default_configuration_options.clone_and_edit(
+                                                enable_activation_quantization=False)
+                                            .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
+
+    # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
+    add = schema.OperatorsSet("Add")
+    sub = schema.OperatorsSet("Sub")
+    mul = schema.OperatorsSet("Mul")
+    div = schema.OperatorsSet("Div")
+    prelu = schema.OperatorsSet("PReLU")
+    swish = schema.OperatorsSet("Swish")
+    sigmoid = schema.OperatorsSet("Sigmoid")
+    tanh = schema.OperatorsSet("Tanh")
+
+    operator_set.extend([conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, 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([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
+    # ------------------- #
+    fusing_patterns.append(schema.Fusing((conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing((fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing((any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
@@ -156,56 +207,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
+        operator_set=tuple(operator_set),
+        fusing_patterns=tuple(fusing_patterns),
+        name=name,
         add_metadata=False,
-        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:
-    with generated_tpc:
-        # Create an OperatorsSet to represent a set of operations.
-        # Each OperatorsSet has a unique label.
-        # If a quantization configuration options is passed, these options will
-        # be used for operations that will be attached to this set's label.
-        # Otherwise, it will be a configure-less set (used in fusing):
-
-        # May suit for operations like: Dropout, Reshape, etc.
-        default_qco = tp.get_default_quantization_config_options()
-        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 = schema.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                                    base_config=base_config)
-
-        # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
-        add = schema.OperatorsSet("Add")
-        sub = schema.OperatorsSet("Sub")
-        mul = schema.OperatorsSet("Mul")
-        div = schema.OperatorsSet("Div")
-        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 = 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
-        # ------------------- #
-        schema.Fusing([conv, activations_after_conv_to_fuse])
-        schema.Fusing([fc, activations_after_fc_to_fuse])
-        schema.Fusing([any_binary, any_relu])
-
+        is_simd_padding=True)
     return generated_tpc

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

@@ -19,7 +19,8 @@ import model_compression_toolkit.target_platform_capabilities.schema.mct_current
 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 TargetPlatformModel, \
+    Signedness, \
     AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
@@ -155,7 +156,54 @@ 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 = schema.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions(tuple([default_config]))
+
+    # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(mixed_precision_cfg_list),
+                                                                             base_config=base_config)
+
+    # Create an OperatorsSet to represent a set of operations.
+    # Each OperatorsSet has a unique label.
+    # If a quantization configuration options is passed, these options will
+    # be used for operations that will be attached to this set's label.
+    # Otherwise, it will be a configure-less set (used in fusing):
+    operator_set = []
+    fusing_patterns = []
+    # May suit for operations like: Dropout, Reshape, etc.
+    operator_set.append(schema.OperatorsSet("NoQuantization", default_configuration_options.clone_and_edit(
+        enable_activation_quantization=False).clone_and_edit_weight_attribute(enable_weights_quantization=False)))
+
+    # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
+    add = schema.OperatorsSet("Add")
+    sub = schema.OperatorsSet("Sub")
+    mul = schema.OperatorsSet("Mul")
+    div = schema.OperatorsSet("Div")
+    prelu = schema.OperatorsSet("PReLU")
+    swish = schema.OperatorsSet("Swish")
+    sigmoid = schema.OperatorsSet("Sigmoid")
+    tanh = schema.OperatorsSet("Tanh")
+
+    operator_set.extend([conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, 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([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
+    # ------------------- #
+    fusing_patterns.append(schema.Fusing((conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing((fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing((any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
@@ -165,57 +213,10 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=2,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
+        operator_set=tuple(operator_set),
+        fusing_patterns=tuple(fusing_patterns),
         add_metadata=True,
         name=name,
         is_simd_padding=True)
 
-    # To start defining the model's components (such as operator sets, and fusing patterns),
-    # use 'with' the TargetPlatformModel instance, and create them as below:
-    with generated_tpm:
-        # Create an OperatorsSet to represent a set of operations.
-        # Each OperatorsSet has a unique label.
-        # If a quantization configuration options is passed, these options will
-        # be used for operations that will be attached to this set's label.
-        # Otherwise, it will be a configure-less set (used in fusing):
-
-        # May suit for operations like: Dropout, Reshape, etc.
-        default_qco = tp.get_default_quantization_config_options()
-        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 = schema.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                                    base_config=base_config)
-
-        # Define operator sets that use 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 = schema.OperatorsSet("AnyReLU")
-        add = schema.OperatorsSet("Add")
-        sub = schema.OperatorsSet("Sub")
-        mul = schema.OperatorsSet("Mul")
-        div = schema.OperatorsSet("Div")
-        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 = 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
-        # ------------------- #
-        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