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/tpc_models/qnnpack_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 KERNEL_ATTR, BIAS_ATTR, QNNPACK_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
@@ -138,8 +139,28 @@ 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]))
+
+    # Combine operations/modules into a single module.
+    # Pytorch supports the next fusing patterns:
+    # [Conv, Relu], [Conv, BatchNorm], [Conv, BatchNorm, Relu], [Linear, Relu]
+    # Source: # https://pytorch.org/docs/stable/quantization.html#model-preparation-for-quantization-eager-mode
+    operator_set = []
+    fusing_patterns = []
+
+    conv = schema.OperatorsSet("Conv")
+    batchnorm = schema.OperatorsSet("BatchNorm")
+    relu = schema.OperatorsSet("Relu")
+    linear = schema.OperatorsSet("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)))
     # 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):
@@ -148,27 +169,8 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         tpc_minor_version=1,
         tpc_patch_version=0,
         tpc_platform_type=QNNPACK_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 target platform model instance, and create them as below:
-    with generated_tpc:
-        # Combine operations/modules into a single module.
-        # Pytorch supports the next fusing patterns:
-        # [Conv, Relu], [Conv, BatchNorm], [Conv, BatchNorm, Relu], [Linear, Relu]
-        # Source: # https://pytorch.org/docs/stable/quantization.html#model-preparation-for-quantization-eager-mode
-        conv = schema.OperatorsSet("Conv")
-        batchnorm = schema.OperatorsSet("BatchNorm")
-        relu = schema.OperatorsSet("Relu")
-        linear = schema.OperatorsSet("Linear")
-
-        # ------------------- #
-        # Fusions
-        # ------------------- #
-        schema.Fusing([conv, batchnorm, relu])
-        schema.Fusing([conv, batchnorm])
-        schema.Fusing([conv, relu])
-        schema.Fusing([linear, relu])
-
     return generated_tpc

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

@@ -136,7 +136,61 @@ 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]))
+
+    # In TFLite, the quantized operator specifications constraint operators quantization
+    # differently. For more details:
+    # https://www.tensorflow.org/lite/performance/quantization_spec#int8_quantized_operator_specifications
+    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])
+    # ------------------- #
+    # 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)))
 
     # Create a TargetPlatformModel and set its default quantization config.
     # This default configuration will be used for all operations
@@ -145,62 +199,10 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         default_configuration_options,
         tpc_minor_version=1,
         tpc_patch_version=0,
+        operator_set=tuple(operator_set),
+        fusing_patterns=tuple(fusing_patterns),
         tpc_platform_type=TFLITE_TP_MODEL,
         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:
-        # In TFLite, the quantized operator specifications constraint operators quantization
-        # differently. For more details:
-        # https://www.tensorflow.org/lite/performance/quantization_spec#int8_quantized_operator_specifications
-        schema.OperatorsSet("NoQuantization",
-                               tp.get_default_quantization_config_options().clone_and_edit(
-                                   quantization_preserving=True))
-
-        fc_qco = tp.get_default_quantization_config_options()
-        fc = schema.OperatorsSet("FullyConnected",
-                                    fc_qco.clone_and_edit_weight_attribute(weights_per_channel_threshold=False))
-
-        schema.OperatorsSet("L2Normalization",
-                               tp.get_default_quantization_config_options().clone_and_edit(
-                                   fixed_zero_point=0, fixed_scale=1 / 128))
-        schema.OperatorsSet("LogSoftmax",
-                               tp.get_default_quantization_config_options().clone_and_edit(
-                                   fixed_zero_point=127, fixed_scale=16 / 256))
-        schema.OperatorsSet("Tanh",
-                               tp.get_default_quantization_config_options().clone_and_edit(
-                                   fixed_zero_point=0, fixed_scale=1 / 128))
-        schema.OperatorsSet("Softmax",
-                               tp.get_default_quantization_config_options().clone_and_edit(
-                                   fixed_zero_point=-128, fixed_scale=1 / 256))
-        schema.OperatorsSet("Logistic",
-                               tp.get_default_quantization_config_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=tp.get_default_quantization_config_options().clone_and_edit(
-                                             quantization_preserving=True))
-        # ------------------- #
-        # Fusions
-        # ------------------- #
-        # Source: https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/grappler/optimizers/remapper
-        schema.Fusing([kernel, bias_add])
-        schema.Fusing([kernel, bias_add, activations_to_fuse])
-        schema.Fusing([conv2d, batch_norm, activations_to_fuse])
-        schema.Fusing([conv2d, squeeze, activations_to_fuse])
-        schema.Fusing([batch_norm, activations_to_fuse])
-        schema.Fusing([batch_norm, add, activations_to_fuse])
-
     return generated_tpc

model_compression_toolkit/target_platform_capabilities/target_platform/current_tp_model.py

@@ -1,67 +0,0 @@
-# Copyright 2022 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.
-# ==============================================================================
-
-from model_compression_toolkit.logger import Logger
-
-def get_current_tp_model():
-    """
-
-    Returns: The current TargetPlatformModel that is being used and accessed.
-
-    """
-    return _current_tp_model.get()
-
-
-class CurrentTPModel:
-    """
-    Wrapper of the current TargetPlatformModel object that is being accessed and defined.
-    """
-
-    def __init__(self):
-        super(CurrentTPModel, self).__init__()
-        self.tp_model = None
-
-    def get(self):
-        """
-
-        Returns: The current TargetPlatformModel that is being defined.
-
-        """
-        if self.tp_model is None:
-            Logger.critical('Target platform model is not initialized.')  # pragma: no cover
-        return self.tp_model
-
-    def reset(self):
-        """
-
-        Reset the current TargetPlatformModel so a new TargetPlatformModel can be wrapped and
-        used as the current TargetPlatformModel object.
-
-        """
-        self.tp_model = None
-
-    def set(self, tp_model):
-        """
-        Set and wrap a TargetPlatformModel as the current TargetPlatformModel.
-
-        Args:
-            tp_model: TargetPlatformModel to set as the current TargetPlatformModel to access and use.
-
-        """
-        self.tp_model = tp_model
-
-
-# Use a single instance for the current model.
-_current_tp_model = CurrentTPModel()

model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py

@@ -1,30 +0,0 @@
-# Copyright 2022 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.
-# ==============================================================================
-
-from model_compression_toolkit.target_platform_capabilities.target_platform.current_tp_model import get_current_tp_model
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import QuantizationConfigOptions
-
-
-def get_default_quantization_config_options() -> QuantizationConfigOptions:
-    """
-
-    Returns: The default QuantizationConfigOptions of the model. This is the options
-    to use when a layer's options is queried and it wasn't specified in the TargetPlatformCapabilities.
-    The default QuantizationConfigOptions always contains a single option.
-
-    """
-    return get_current_tp_model().default_qco
-
-