mct-nightly 2.2.0.20241211.531__py3-none-any.whl → 2.2.0.20241213.540__py3-none-any.whl

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/operations_to_layers.py

@@ -16,6 +16,8 @@
 from typing import List, Any, Dict
 
 from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.target_platform_capabilities.schema.schema_functions import \
+    get_config_options_by_operators_set, is_opset_in_model
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.current_tpc import  _current_tpc
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.target_platform_capabilities_component import TargetPlatformCapabilitiesComponent
 from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import OperatorsSetBase, OperatorSetConcat
@@ -137,14 +139,14 @@ class OperationsToLayers:
                                                       f'is of type {type(ops2layers)}'
 
             # Assert that opset in the current TargetPlatformCapabilities and has a unique name.
-            is_opset_in_model = _current_tpc.get().tp_model.is_opset_in_model(ops2layers.name)
-            assert is_opset_in_model, f'{ops2layers.name} is not defined in the target platform model that is associated with the target platform capabilities.'
+            opset_in_model = is_opset_in_model(_current_tpc.get().tp_model, ops2layers.name)
+            assert opset_in_model, f'{ops2layers.name} is not defined in the target platform model that is associated with the target platform capabilities.'
             assert not (ops2layers.name in existing_opset_names), f'OperationsSetToLayers names should be unique, but {ops2layers.name} appears to violate it.'
             existing_opset_names.append(ops2layers.name)
 
             # Assert that a layer does not appear in more than a single OperatorsSet in the TargetPlatformModel.
             for layer in ops2layers.layers:
-                qco_by_opset_name = _current_tpc.get().tp_model.get_config_options_by_operators_set(ops2layers.name)
+                qco_by_opset_name = get_config_options_by_operators_set(_current_tpc.get().tp_model, ops2layers.name)
                 if layer in existing_layers:
                     Logger.critical(f'Found layer {layer.__name__} in more than one '
                                     f'OperatorsSet')  # pragma: no cover

model_compression_toolkit/target_platform_capabilities/target_platform/targetplatform2framework/target_platform_capabilities.py

@@ -19,6 +19,8 @@ import pprint
 from typing import List, Any, Dict, Tuple
 
 from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.target_platform_capabilities.schema.schema_functions import \
+    get_config_options_by_operators_set, get_default_op_quantization_config, get_opset_by_name
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.operations_to_layers import \
     OperationsToLayers, OperationsSetToLayers
 from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.target_platform_capabilities_component import TargetPlatformCapabilitiesComponent
@@ -64,7 +66,7 @@ class TargetPlatformCapabilities(ImmutableClass):
         Returns:
             List of layers/LayerFilterParams that are attached to the opset name.
         """
-        opset = self.tp_model.get_opset_by_name(opset_name)
+        opset = get_opset_by_name(self.tp_model, opset_name)
         if opset is None:
             Logger.warning(f'{opset_name} was not found in TargetPlatformCapabilities.')
             return None
@@ -165,7 +167,7 @@ class TargetPlatformCapabilities(ImmutableClass):
         to the TargetPlatformCapabilities.
 
         """
-        return self.tp_model.get_default_op_quantization_config()
+        return get_default_op_quantization_config(self.tp_model)
 
 
     def _get_config_options_mapping(self) -> Tuple[Dict[Any, QuantizationConfigOptions],
@@ -181,7 +183,7 @@ class TargetPlatformCapabilities(ImmutableClass):
         filterlayer2qco = {}
         for op2layers in self.op_sets_to_layers.op_sets_to_layers:
             for l in op2layers.layers:
-                qco = self.tp_model.get_config_options_by_operators_set(op2layers.name)
+                qco = get_config_options_by_operators_set(self.tp_model, op2layers.name)
                 if qco is None:
                     qco = self.tp_model.default_qco
 

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

@@ -164,7 +164,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
         name=name,
-        add_metadata=False)
+        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:
@@ -175,8 +176,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpc.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet("NoQuantization",
@@ -206,9 +205,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -201,9 +201,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -197,9 +197,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -166,7 +166,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
         add_metadata=True,
-        name=name)
+        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:
@@ -177,8 +178,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet("NoQuantization",
@@ -208,9 +207,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -203,9 +203,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -187,7 +187,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
         add_metadata=True,
-        name=name)
+        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:
@@ -198,8 +199,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet("NoQuantization",
@@ -231,9 +230,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -214,9 +214,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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)
+        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

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

@@ -15,7 +15,7 @@
 from typing import List, Tuple
 
 import model_compression_toolkit as mct
-import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
+import model_compression_toolkit.target_platform_capabilities.schema.v1 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, \
     IMX500_TP_MODEL
@@ -235,7 +235,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=4,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,
-        add_metadata=True, name=name)
+        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:
@@ -246,8 +248,6 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # be used for operations that will be attached to this set's label.
         # Otherwise, it will be a configure-less set (used in fusing):
 
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         schema.OperatorsSet(OPSET_NO_QUANTIZATION,
@@ -294,11 +294,11 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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, 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)
+        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

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

@@ -180,11 +180,11 @@ def generate_tp_model(default_config: OpQuantizationConfig,
                                    fixed_zero_point=-128, fixed_scale=1 / 256))
 
         conv2d = schema.OperatorsSet("Conv2d")
-        kernel = schema.OperatorSetConcat(conv2d, fc)
+        kernel = schema.OperatorSetConcat([conv2d, fc])
 
         relu = schema.OperatorsSet("Relu")
         elu = schema.OperatorsSet("Elu")
-        activations_to_fuse = schema.OperatorSetConcat(relu, elu)
+        activations_to_fuse = schema.OperatorSetConcat([relu, elu])
 
         batch_norm = schema.OperatorsSet("BatchNorm")
         bias_add = schema.OperatorsSet("BiasAdd")