mct-nightly 2.2.0.20241230.534__py3-none-any.whl → 2.2.0.20250102.111338__py3-none-any.whl

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

@@ -153,10 +153,10 @@ 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(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=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),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -167,46 +167,46 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                           default_configuration_options.clone_and_edit(enable_activation_quantization=False)
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                           qc_options=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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add")
+    sub = schema.OperatorsSet(name="Sub")
+    mul = schema.OperatorsSet(name="Mul")
+    div = schema.OperatorsSet(name="Div")
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpc = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -151,10 +151,10 @@ 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(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=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),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -166,47 +166,47 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     fusing_patterns = []
 
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                                            qc_options=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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add")
+    sub = schema.OperatorsSet(name="Sub")
+    mul = schema.OperatorsSet(name="Mul")
+    div = schema.OperatorsSet(name="Div")
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpc = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -147,10 +147,10 @@ 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(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=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),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -162,48 +162,48 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     fusing_patterns = []
 
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                                            qc_options=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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add")
+    sub = schema.OperatorsSet(name="Sub")
+    mul = schema.OperatorsSet(name="Mul")
+    div = schema.OperatorsSet(name="Div")
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpc = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -156,10 +156,10 @@ 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(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=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),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -170,46 +170,46 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet("NoQuantization", default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name="NoQuantization", qc_options=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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add")
+    sub = schema.OperatorsSet(name="Sub")
+    mul = schema.OperatorsSet(name="Mul")
+    div = schema.OperatorsSet(name="Div")
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpm = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=2,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -153,10 +153,10 @@ 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(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=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),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -167,47 +167,47 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                                            qc_options=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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add")
+    sub = schema.OperatorsSet(name="Sub")
+    mul = schema.OperatorsSet(name="Mul")
+    div = schema.OperatorsSet(name="Div")
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpm = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=2,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -156,7 +156,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 = schema.QuantizationConfigOptions(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([default_config]))
 
     # Create a QuantizationConfigOptions for quantizing constants in functional ops.
     # Constant configuration is similar to the default eight bit configuration except for PoT
@@ -167,7 +167,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 = schema.QuantizationConfigOptions(tuple([const_config]))
+    const_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([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.
@@ -175,12 +175,12 @@ 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 = schema.QuantizationConfigOptions(tuple([const_config_input16_output16,
+    const_configuration_options_inout16 = schema.QuantizationConfigOptions(quantization_configurations=tuple([const_config_input16_output16,
                                                                             const_config_input16]),
                                                                            base_config=const_config_input16)
 
     # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
-    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(mixed_precision_cfg_list),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -191,49 +191,49 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                                            qc_options=default_configuration_options.clone_and_edit(
                                                 enable_activation_quantization=False,
                                                 supported_input_activation_n_bits=(8, 16))
                                             .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
-    operator_set.append(schema.OperatorsSet("Default16BitInout", const_configuration_options_inout16))
+    operator_set.append(schema.OperatorsSet(name="Default16BitInout", qc_options=const_configuration_options_inout16))
 
     # 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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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", const_configuration_options_inout16)
-    sub = schema.OperatorsSet("Sub", const_configuration_options_inout16)
-    mul = schema.OperatorsSet("Mul", const_configuration_options_inout16)
-    div = schema.OperatorsSet("Div", const_configuration_options)
-    prelu = schema.OperatorsSet("PReLU")
-    swish = schema.OperatorsSet("Swish")
-    sigmoid = schema.OperatorsSet("Sigmoid")
-    tanh = schema.OperatorsSet("Tanh")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add", qc_options=const_configuration_options_inout16)
+    sub = schema.OperatorsSet(name="Sub", qc_options=const_configuration_options_inout16)
+    mul = schema.OperatorsSet(name="Mul", qc_options=const_configuration_options_inout16)
+    div = schema.OperatorsSet(name="Div", qc_options=const_configuration_options)
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpm = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=3,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -153,7 +153,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 = schema.QuantizationConfigOptions(tuple([default_config]))
+    default_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([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,10 +164,10 @@ 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 = schema.QuantizationConfigOptions(tuple([const_config]))
+    const_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([const_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),
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(mixed_precision_cfg_list),
                                                                              base_config=base_config)
 
     # Create an OperatorsSet to represent a set of operations.
@@ -178,47 +178,47 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                                            qc_options=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)
+    conv = schema.OperatorsSet(name="Conv", qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name="FullyConnected", qc_options=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", 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")
+    any_relu = schema.OperatorsSet(name="AnyReLU")
+    add = schema.OperatorsSet(name="Add", qc_options=const_configuration_options)
+    sub = schema.OperatorsSet(name="Sub", qc_options=const_configuration_options)
+    mul = schema.OperatorsSet(name="Mul", qc_options=const_configuration_options)
+    div = schema.OperatorsSet(name="Div", qc_options=const_configuration_options)
+    prelu = schema.OperatorsSet(name="PReLU")
+    swish = schema.OperatorsSet(name="Swish")
+    sigmoid = schema.OperatorsSet(name="Sigmoid")
+    tanh = schema.OperatorsSet(name="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])
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid, tanh])
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid])
+    any_binary = schema.OperatorSetConcat(operators_set=[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)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, activations_after_conv_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(fc, activations_after_fc_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(any_binary, any_relu)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
     # unless specified otherwise (see OperatorsSet, for example):
     generated_tpm = schema.TargetPlatformModel(
-        default_configuration_options,
+        default_qco=default_configuration_options,
         tpc_minor_version=3,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,