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/v4/tp_model.py

@@ -29,6 +29,7 @@ OPSET_NO_QUANTIZATION = "NoQuantization"
 OPSET_QUANTIZATION_PRESERVING = "QuantizationPreserving"
 OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS = "DimensionManipulationOpsWithWeights"
 OPSET_DIMENSION_MANIPULATION_OPS = "DimensionManipulationOps"
+OPSET_SPLIT_OPS = "SplitOps"
 OPSET_MERGE_OPS = "MergeOps"
 OPSET_CONV = "Conv"
 OPSET_FULLY_CONNECTED = "FullyConnected"
@@ -178,14 +179,24 @@ 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]))
     default_config_input16 = default_config.clone_and_edit(supported_input_activation_n_bits=(8, 16))
-    default_config_options_16bit = schema.QuantizationConfigOptions(tuple([default_config_input16,
+    default_config_options_16bit = schema.QuantizationConfigOptions(quantization_configurations=tuple([default_config_input16,
                                                                      default_config_input16.clone_and_edit(
                                                                          activation_n_bits=16,
                                                                          signedness=Signedness.SIGNED)]),
                                                                     base_config=default_config_input16)
 
+    qpreseving_config = default_config.clone_and_edit(enable_activation_quantization=False,
+                                                      quantization_preserving=True,
+                                                      supported_input_activation_n_bits=(8, 16))
+
+    qpreseving_config_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([qpreseving_config,
+                                                                        qpreseving_config.clone_and_edit(
+                                                                            activation_n_bits=16,
+                                                                            signedness=Signedness.SIGNED)]),
+                                                                 base_config=qpreseving_config)
+
     # Create a QuantizationConfigOptions for quantizing constants in functional ops.
     # Constant configuration is similar to the default eight bit configuration except for PoT
     # quantization method for the constant.
@@ -195,7 +206,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.
@@ -203,9 +214,10 @@ 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_config_input16]),
-                                                                           base_config=const_config_input16)
+    const_configuration_options_inout16 = schema.QuantizationConfigOptions(
+        quantization_configurations=tuple([const_config_input16_output16,
+                                           const_config_input16]),
+        base_config=const_config_input16)
 
     const_config_input16_per_tensor = const_config.clone_and_edit(
         supported_input_activation_n_bits=(8, 16),
@@ -215,7 +227,7 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     )
     const_config_input16_output16_per_tensor = const_config_input16_per_tensor.clone_and_edit(
         activation_n_bits=16, signedness=Signedness.SIGNED)
-    const_configuration_options_inout16_per_tensor = schema.QuantizationConfigOptions(tuple(
+    const_configuration_options_inout16_per_tensor = schema.QuantizationConfigOptions(quantization_configurations=tuple(
         [const_config_input16_output16_per_tensor,
          const_config_input16_per_tensor]),
         base_config=const_config_input16_per_tensor)
@@ -224,13 +236,13 @@ def generate_tp_model(default_config: OpQuantizationConfig,
                                                            quantization_preserving=True,
                                                            default_weight_attr_config=const_config.default_weight_attr_config.clone_and_edit(
                                                                weights_per_channel_threshold=False))
-    qpreserving_const_config_options = schema.QuantizationConfigOptions(tuple([qpreserving_const_config]))
+    qpreserving_const_config_options = schema.QuantizationConfigOptions(quantization_configurations=tuple([qpreserving_const_config]))
 
     mp_cfg_list_16bit = [mp_cfg.clone_and_edit(activation_n_bits=16, signedness=Signedness.SIGNED)
                          for mp_cfg in mixed_precision_cfg_list]
 
     # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
-    mixed_precision_configuration_options = schema.QuantizationConfigOptions(tuple(
+    mixed_precision_configuration_options = schema.QuantizationConfigOptions(quantization_configurations=tuple(
         mixed_precision_cfg_list + mp_cfg_list_16bit),
         base_config=base_config)
 
@@ -242,69 +254,72 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
     # May suit for operations like: Dropout, Reshape, etc.
-    operator_set.append(schema.OperatorsSet(OPSET_NO_QUANTIZATION,
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name=OPSET_NO_QUANTIZATION,
+                                            qc_options=default_configuration_options.clone_and_edit(
                                                 enable_activation_quantization=False)
                                             .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
-    operator_set.append(schema.OperatorsSet(OPSET_QUANTIZATION_PRESERVING,
-                                            default_configuration_options.clone_and_edit(
+    operator_set.append(schema.OperatorsSet(name=OPSET_QUANTIZATION_PRESERVING,
+                                            qc_options=default_configuration_options.clone_and_edit(
                                                 enable_activation_quantization=False,
                                                 quantization_preserving=True)
                                             .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
     operator_set.append(
-        schema.OperatorsSet(OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, qpreserving_const_config_options))
-    operator_set.append(schema.OperatorsSet(OPSET_DIMENSION_MANIPULATION_OPS,
-                                            default_configuration_options.clone_and_edit(
+        schema.OperatorsSet(name=OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS,
+                            qc_options=qpreserving_const_config_options))
+    operator_set.append(schema.OperatorsSet(name=OPSET_DIMENSION_MANIPULATION_OPS,
+                                            qc_options=default_configuration_options.clone_and_edit(
                                                 enable_activation_quantization=False,
                                                 quantization_preserving=True,
                                                 supported_input_activation_n_bits=(8, 16))
                                             .clone_and_edit_weight_attribute(enable_weights_quantization=False)))
-    operator_set.append(schema.OperatorsSet(OPSET_MERGE_OPS, const_configuration_options_inout16_per_tensor))
+
+    operator_set.append(schema.OperatorsSet(name=OPSET_SPLIT_OPS, qc_options=qpreseving_config_options))
+    operator_set.append(schema.OperatorsSet(name=OPSET_MERGE_OPS, qc_options=const_configuration_options_inout16_per_tensor))
 
     # Define operator sets that use mixed_precision_configuration_options:
-    conv = schema.OperatorsSet(OPSET_CONV, mixed_precision_configuration_options)
-    fc = schema.OperatorsSet(OPSET_FULLY_CONNECTED, mixed_precision_configuration_options)
+    conv = schema.OperatorsSet(name=OPSET_CONV, qc_options=mixed_precision_configuration_options)
+    fc = schema.OperatorsSet(name=OPSET_FULLY_CONNECTED, qc_options=mixed_precision_configuration_options)
 
-    operator_set.append(schema.OperatorsSet(OPSET_BATCH_NORM, default_config_options_16bit))
+    operator_set.append(schema.OperatorsSet(name=OPSET_BATCH_NORM, qc_options=default_config_options_16bit))
 
     # Note: Operations sets without quantization configuration are useful for creating fusing patterns
-    any_relu = schema.OperatorsSet(OPSET_ANY_RELU, default_config_options_16bit)
-    add = schema.OperatorsSet(OPSET_ADD, const_configuration_options_inout16)
-    sub = schema.OperatorsSet(OPSET_SUB, const_configuration_options_inout16)
-    mul = schema.OperatorsSet(OPSET_MUL, const_configuration_options_inout16)
-    div = schema.OperatorsSet(OPSET_DIV, const_configuration_options)
-    min_max = schema.OperatorsSet(OPSET_MIN_MAX, const_configuration_options_inout16)
-    prelu = schema.OperatorsSet(OPSET_PRELU, default_config_options_16bit)
-    swish = schema.OperatorsSet(OPSET_SWISH, default_config_options_16bit)
-    sigmoid = schema.OperatorsSet(OPSET_SIGMOID, default_config_options_16bit)
-    tanh = schema.OperatorsSet(OPSET_TANH, default_config_options_16bit)
-    gelu = schema.OperatorsSet(OPSET_GELU, default_config_options_16bit)
-    hardsigmoid = schema.OperatorsSet(OPSET_HARDSIGMOID, default_config_options_16bit)
-    hardswish = schema.OperatorsSet(OPSET_HARDSWISH, default_config_options_16bit)
+    any_relu = schema.OperatorsSet(name=OPSET_ANY_RELU, qc_options=default_config_options_16bit)
+    add = schema.OperatorsSet(name=OPSET_ADD, qc_options=const_configuration_options_inout16)
+    sub = schema.OperatorsSet(name=OPSET_SUB, qc_options=const_configuration_options_inout16)
+    mul = schema.OperatorsSet(name=OPSET_MUL, qc_options=const_configuration_options_inout16)
+    div = schema.OperatorsSet(name=OPSET_DIV, qc_options=const_configuration_options)
+    min_max = schema.OperatorsSet(name=OPSET_MIN_MAX, qc_options=const_configuration_options_inout16)
+    prelu = schema.OperatorsSet(name=OPSET_PRELU, qc_options=default_config_options_16bit)
+    swish = schema.OperatorsSet(name=OPSET_SWISH, qc_options=default_config_options_16bit)
+    sigmoid = schema.OperatorsSet(name=OPSET_SIGMOID, qc_options=default_config_options_16bit)
+    tanh = schema.OperatorsSet(name=OPSET_TANH, qc_options=default_config_options_16bit)
+    gelu = schema.OperatorsSet(name=OPSET_GELU, qc_options=default_config_options_16bit)
+    hardsigmoid = schema.OperatorsSet(name=OPSET_HARDSIGMOID, qc_options=default_config_options_16bit)
+    hardswish = schema.OperatorsSet(name=OPSET_HARDSWISH, qc_options=default_config_options_16bit)
 
     operator_set.extend(
         [conv, fc, any_relu, add, sub, mul, div, prelu, swish, sigmoid, tanh, min_max, gelu, hardsigmoid, hardswish])
     # 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,
+    activations_after_conv_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, prelu, sigmoid,
                                                                tanh, gelu, hardswish, hardsigmoid])
-    activations_after_fc_to_fuse = schema.OperatorSetConcat([any_relu, swish, sigmoid, tanh, gelu,
+    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid, tanh, gelu,
                                                              hardswish, hardsigmoid])
-    any_binary = schema.OperatorSetConcat([add, sub, mul, div])
+    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=4,
         tpc_patch_version=0,
         tpc_platform_type=IMX500_TP_MODEL,

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

@@ -39,7 +39,8 @@ from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tp
 from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tp_model import OPSET_NO_QUANTIZATION, \
     OPSET_QUANTIZATION_PRESERVING, OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, OPSET_DIMENSION_MANIPULATION_OPS, \
     OPSET_MERGE_OPS, OPSET_CONV, OPSET_FULLY_CONNECTED, OPSET_ANY_RELU, OPSET_ADD, OPSET_SUB, OPSET_MUL, OPSET_DIV, \
-    OPSET_PRELU, OPSET_SWISH, OPSET_SIGMOID, OPSET_TANH, OPSET_GELU, OPSET_BATCH_NORM, OPSET_MIN_MAX, OPSET_HARDSIGMOID
+    OPSET_PRELU, OPSET_SWISH, OPSET_SIGMOID, OPSET_TANH, OPSET_GELU, OPSET_BATCH_NORM, OPSET_MIN_MAX, OPSET_HARDSIGMOID, \
+    OPSET_SPLIT_OPS
 
 tp = mct.target_platform
 
@@ -78,11 +79,7 @@ def generate_keras_tpc(name: str, tp_model: schema.TargetPlatformModel):
                                ZeroPadding2D,
                                Dropout,
                                MaxPooling2D,
-                               tf.split,
-                               tf.cast,
-                               tf.unstack,
-                               tf.__operators__.getitem,
-                               tf.strided_slice]
+                               tf.cast]
     quantization_preserving_list_16bit_input = [Reshape,
                                                 tf.reshape,
                                                 Permute,
@@ -97,6 +94,7 @@ def generate_keras_tpc(name: str, tp_model: schema.TargetPlatformModel):
         tp.OperationsSetToLayers(OPSET_QUANTIZATION_PRESERVING, quantization_preserving)
         tp.OperationsSetToLayers(OPSET_DIMENSION_MANIPULATION_OPS, quantization_preserving_list_16bit_input)
         tp.OperationsSetToLayers(OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, [tf.gather, tf.compat.v1.gather])
+        tp.OperationsSetToLayers(OPSET_SPLIT_OPS,[tf.unstack, tf.split, tf.strided_slice, tf.__operators__.getitem])
         tp.OperationsSetToLayers(OPSET_MERGE_OPS, [tf.stack, tf.concat, Concatenate])
         tp.OperationsSetToLayers(OPSET_CONV,
                                  [Conv2D,

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

@@ -36,7 +36,7 @@ from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tp
     OPSET_QUANTIZATION_PRESERVING, OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, OPSET_DIMENSION_MANIPULATION_OPS, \
     OPSET_MERGE_OPS, OPSET_CONV, OPSET_FULLY_CONNECTED, OPSET_ANY_RELU, OPSET_ADD, OPSET_SUB, OPSET_MUL, OPSET_DIV, \
     OPSET_PRELU, OPSET_SWISH, OPSET_SIGMOID, OPSET_TANH, OPSET_GELU, OPSET_BATCH_NORM, OPSET_MIN_MAX, OPSET_HARDSIGMOID, \
-    OPSET_HARDSWISH
+    OPSET_HARDSWISH, OPSET_SPLIT_OPS
 
 tp = mct.target_platform
 
@@ -77,9 +77,6 @@ def generate_pytorch_tpc(name: str, tp_model: schema.TargetPlatformModel):
                                                          topk])
         tp.OperationsSetToLayers(OPSET_QUANTIZATION_PRESERVING, [Dropout,
                                                                  dropout,
-                                                                 split,
-                                                                 chunk,
-                                                                 unbind,
                                                                  MaxPool2d])
         tp.OperationsSetToLayers(OPSET_DIMENSION_MANIPULATION_OPS, [Flatten,
                                                                     flatten,
@@ -90,6 +87,7 @@ def generate_pytorch_tpc(name: str, tp_model: schema.TargetPlatformModel):
                                                                     permute,
                                                                     transpose])
         tp.OperationsSetToLayers(OPSET_DIMENSION_MANIPULATION_OPS_WITH_WEIGHTS, [gather, torch.Tensor.expand])
+        tp.OperationsSetToLayers(OPSET_SPLIT_OPS,[split, chunk, unbind])
         tp.OperationsSetToLayers(OPSET_MERGE_OPS,
                                  [torch.stack, torch.cat, torch.concat, torch.concatenate])
 

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

@@ -139,7 +139,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]))
 
     # Combine operations/modules into a single module.
     # Pytorch supports the next fusing patterns:
@@ -148,24 +148,24 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    conv = schema.OperatorsSet("Conv")
-    batchnorm = schema.OperatorsSet("BatchNorm")
-    relu = schema.OperatorsSet("Relu")
-    linear = schema.OperatorsSet("Linear")
+    conv = schema.OperatorsSet(name="Conv")
+    batchnorm = schema.OperatorsSet(name="BatchNorm")
+    relu = schema.OperatorsSet(name="Relu")
+    linear = schema.OperatorsSet(name="Linear")
 
     operator_set.extend([conv, batchnorm, relu, linear])
     # ------------------- #
     # Fusions
     # ------------------- #
-    fusing_patterns.append(schema.Fusing((conv, batchnorm, relu)))
-    fusing_patterns.append(schema.Fusing((conv, batchnorm)))
-    fusing_patterns.append(schema.Fusing((conv, relu)))
-    fusing_patterns.append(schema.Fusing((linear, relu)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, batchnorm, relu)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, batchnorm)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv, relu)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(linear, 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=QNNPACK_TP_MODEL,

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

@@ -18,7 +18,8 @@ import model_compression_toolkit as mct
 import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
 from model_compression_toolkit.target_platform_capabilities.constants import BIAS_ATTR, KERNEL_ATTR, TFLITE_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
@@ -136,7 +137,8 @@ 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]))
 
     # In TFLite, the quantized operator specifications constraint operators quantization
     # differently. For more details:
@@ -144,59 +146,60 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    operator_set.append(schema.OperatorsSet("NoQuantization",
-                           default_configuration_options.clone_and_edit(
-                               quantization_preserving=True)))
-
-    fc = schema.OperatorsSet("FullyConnected",
-                                default_configuration_options.clone_and_edit_weight_attribute(weights_per_channel_threshold=False))
-
-    operator_set.append(schema.OperatorsSet("L2Normalization",
-                           default_configuration_options.clone_and_edit(
-                               fixed_zero_point=0, fixed_scale=1 / 128)))
-    operator_set.append(schema.OperatorsSet("LogSoftmax",
-                           default_configuration_options.clone_and_edit(
-                               fixed_zero_point=127, fixed_scale=16 / 256)))
-    operator_set.append(schema.OperatorsSet("Tanh",
-                           default_configuration_options.clone_and_edit(
-                               fixed_zero_point=0, fixed_scale=1 / 128)))
-    operator_set.append(schema.OperatorsSet("Softmax",
-                           default_configuration_options.clone_and_edit(
-                               fixed_zero_point=-128, fixed_scale=1 / 256)))
-    operator_set.append(schema.OperatorsSet("Logistic",
-                           default_configuration_options.clone_and_edit(
-                               fixed_zero_point=-128, fixed_scale=1 / 256)))
-
-    conv2d = schema.OperatorsSet("Conv2d")
-    kernel = schema.OperatorSetConcat([conv2d, fc])
-
-    relu = schema.OperatorsSet("Relu")
-    elu = schema.OperatorsSet("Elu")
-    activations_to_fuse = schema.OperatorSetConcat([relu, elu])
-
-    batch_norm = schema.OperatorsSet("BatchNorm")
-    bias_add = schema.OperatorsSet("BiasAdd")
-    add = schema.OperatorsSet("Add")
-    squeeze = schema.OperatorsSet("Squeeze",
-                                     qc_options=default_configuration_options.clone_and_edit(
-                                         quantization_preserving=True))
-    operator_set.extend([fc, conv2d, kernel, relu, elu, batch_norm, bias_add, add, squeeze])
+    operator_set.append(schema.OperatorsSet(name="NoQuantization",
+                                            qc_options=default_configuration_options.clone_and_edit(
+                                                quantization_preserving=True)))
+
+    fc = schema.OperatorsSet(name="FullyConnected",
+                             qc_options=default_configuration_options.clone_and_edit_weight_attribute(
+                                 weights_per_channel_threshold=False))
+
+    operator_set.append(schema.OperatorsSet(name="L2Normalization",
+                                            qc_options=default_configuration_options.clone_and_edit(
+                                                fixed_zero_point=0, fixed_scale=1 / 128)))
+    operator_set.append(schema.OperatorsSet(name="LogSoftmax",
+                                            qc_options=default_configuration_options.clone_and_edit(
+                                                fixed_zero_point=127, fixed_scale=16 / 256)))
+    operator_set.append(schema.OperatorsSet(name="Tanh",
+                                            qc_options=default_configuration_options.clone_and_edit(
+                                                fixed_zero_point=0, fixed_scale=1 / 128)))
+    operator_set.append(schema.OperatorsSet(name="Softmax",
+                                            qc_options=default_configuration_options.clone_and_edit(
+                                                fixed_zero_point=-128, fixed_scale=1 / 256)))
+    operator_set.append(schema.OperatorsSet(name="Logistic",
+                                            qc_options=default_configuration_options.clone_and_edit(
+                                                fixed_zero_point=-128, fixed_scale=1 / 256)))
+
+    conv2d = schema.OperatorsSet(name="Conv2d")
+    kernel = schema.OperatorSetConcat(operators_set=[conv2d, fc])
+
+    relu = schema.OperatorsSet(name="Relu")
+    elu = schema.OperatorsSet(name="Elu")
+    activations_to_fuse = schema.OperatorSetConcat(operators_set=[relu, elu])
+
+    batch_norm = schema.OperatorsSet(name="BatchNorm")
+    bias_add = schema.OperatorsSet(name="BiasAdd")
+    add = schema.OperatorsSet(name="Add")
+    squeeze = schema.OperatorsSet(name="Squeeze",
+                                  qc_options=default_configuration_options.clone_and_edit(
+                                      quantization_preserving=True))
+    operator_set.extend([fc, conv2d, relu, elu, batch_norm, bias_add, add, squeeze])
     # ------------------- #
     # Fusions
     # ------------------- #
     # Source: https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/grappler/optimizers/remapper
-    fusing_patterns.append(schema.Fusing((kernel, bias_add)))
-    fusing_patterns.append(schema.Fusing((kernel, bias_add, activations_to_fuse)))
-    fusing_patterns.append(schema.Fusing((conv2d, batch_norm, activations_to_fuse)))
-    fusing_patterns.append(schema.Fusing((conv2d, squeeze, activations_to_fuse)))
-    fusing_patterns.append(schema.Fusing((batch_norm, activations_to_fuse)))
-    fusing_patterns.append(schema.Fusing((batch_norm, add, activations_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(kernel, bias_add)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(kernel, bias_add, activations_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv2d, batch_norm, activations_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(conv2d, squeeze, activations_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(batch_norm, activations_to_fuse)))
+    fusing_patterns.append(schema.Fusing(operator_groups=(batch_norm, add, activations_to_fuse)))
 
     # 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,
         operator_set=tuple(operator_set),