mct-nightly 2.2.0.20241201.617__py3-none-any.whl → 2.2.0.20241202.131715__py3-none-any.whl

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

@@ -15,12 +15,11 @@
 from typing import List, Tuple
 
 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
-from model_compression_toolkit.target_platform_capabilities.target_platform import OpQuantizationConfig, \
-    TargetPlatformModel, Signedness
-from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import \
-    QuantizationMethod, AttributeQuantizationConfig
+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, \
+    AttributeQuantizationConfig, OpQuantizationConfig
 
 tp = mct.target_platform
 
@@ -83,7 +82,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
 
     # We define a default config for operation without kernel attribute.
     # This is the default config that should be used for non-linear operations.
-    eight_bits_default = tp.OpQuantizationConfig(
+    eight_bits_default = schema.OpQuantizationConfig(
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={},
         activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
@@ -97,8 +96,8 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         signedness=Signedness.AUTO)
 
     # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
-    linear_eight_bits = tp.OpQuantizationConfig(
-        activation_quantization_method=QuantizationMethod.UNIFORM,
+    linear_eight_bits = schema.OpQuantizationConfig(
+        activation_quantization_method=tp.QuantizationMethod.UNIFORM,
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
         activation_n_bits=8,
@@ -137,12 +136,18 @@ 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 = tp.QuantizationConfigOptions([default_config])
+    default_configuration_options = schema.QuantizationConfigOptions([default_config])
 
     # 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 = tp.TargetPlatformModel(default_configuration_options, name=name)
+    generated_tpc = schema.TargetPlatformModel(
+        default_configuration_options,
+        tpc_minor_version=1,
+        tpc_patch_version=0,
+        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:
@@ -150,52 +155,52 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # 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
-        tp.OperatorsSet("NoQuantization",
-                        tp.get_default_quantization_config_options().clone_and_edit(
-                            quantization_preserving=True))
+        schema.OperatorsSet("NoQuantization",
+                               tp.get_default_quantization_config_options().clone_and_edit(
+                                   quantization_preserving=True))
 
         fc_qco = tp.get_default_quantization_config_options()
-        fc = tp.OperatorsSet("FullyConnected",
-                             fc_qco.clone_and_edit_weight_attribute(weights_per_channel_threshold=False))
-
-        tp.OperatorsSet("L2Normalization",
-                        tp.get_default_quantization_config_options().clone_and_edit(
-                            fixed_zero_point=0, fixed_scale=1 / 128))
-        tp.OperatorsSet("LogSoftmax",
-                        tp.get_default_quantization_config_options().clone_and_edit(
-                            fixed_zero_point=127, fixed_scale=16 / 256))
-        tp.OperatorsSet("Tanh",
-                        tp.get_default_quantization_config_options().clone_and_edit(
-                            fixed_zero_point=0, fixed_scale=1 / 128))
-        tp.OperatorsSet("Softmax",
-                        tp.get_default_quantization_config_options().clone_and_edit(
-                            fixed_zero_point=-128, fixed_scale=1 / 256))
-        tp.OperatorsSet("Logistic",
-                        tp.get_default_quantization_config_options().clone_and_edit(
-                            fixed_zero_point=-128, fixed_scale=1 / 256))
-
-        conv2d = tp.OperatorsSet("Conv2d")
-        kernel = tp.OperatorSetConcat(conv2d, fc)
-
-        relu = tp.OperatorsSet("Relu")
-        elu = tp.OperatorsSet("Elu")
-        activations_to_fuse = tp.OperatorSetConcat(relu, elu)
-
-        batch_norm = tp.OperatorsSet("BatchNorm")
-        bias_add = tp.OperatorsSet("BiasAdd")
-        add = tp.OperatorsSet("Add")
-        squeeze = tp.OperatorsSet("Squeeze",
-                                  qc_options=tp.get_default_quantization_config_options().clone_and_edit(
-                                      quantization_preserving=True))
+        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
-        tp.Fusing([kernel, bias_add])
-        tp.Fusing([kernel, bias_add, activations_to_fuse])
-        tp.Fusing([conv2d, batch_norm, activations_to_fuse])
-        tp.Fusing([conv2d, squeeze, activations_to_fuse])
-        tp.Fusing([batch_norm, activations_to_fuse])
-        tp.Fusing([batch_norm, add, activations_to_fuse])
+        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/tpc_models/tflite_tpc/v1/tpc_keras.py

@@ -15,6 +15,7 @@
 import tensorflow as tf
 from packaging import version
 
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, KERAS_KERNEL, BIAS_ATTR, BIAS
 
@@ -46,7 +47,7 @@ def get_keras_tpc() -> tp.TargetPlatformCapabilities:
     return generate_keras_tpc(name='tflite_keras', tp_model=tflite_tp_model)
 
 
-def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_keras_tpc(name: str, tp_model: schema.TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
 
@@ -57,9 +58,7 @@ def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    keras_tpc = tp.TargetPlatformCapabilities(tp_model,
-                                              name=name,
-                                              version=TPC_VERSION)
+    keras_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     with keras_tpc:
         tp.OperationsSetToLayers("NoQuantization", [AveragePooling2D,

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

@@ -16,6 +16,7 @@ import torch
 from torch.nn import AvgPool2d, MaxPool2d
 from torch.nn.functional import avg_pool2d, max_pool2d, interpolate
 
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
 from model_compression_toolkit.defaultdict import DefaultDict
 from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, PYTORCH_KERNEL, BIAS_ATTR, \
     BIAS
@@ -37,7 +38,7 @@ def get_pytorch_tpc() -> tp.TargetPlatformCapabilities:
     return generate_pytorch_tpc(name='tflite_torch', tp_model=tflite_tp_model)
 
 
-def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
+def generate_pytorch_tpc(name: str, tp_model: schema.TargetPlatformModel):
     """
     Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
     Args:
@@ -46,9 +47,7 @@ def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
     Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
     """
 
-    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model,
-                                                name=name,
-                                                version=TPC_VERSION)
+    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model)
 
     with pytorch_tpc:
         tp.OperationsSetToLayers("NoQuantization", [AvgPool2d,

model_compression_toolkit/target_platform_capabilities/target_platform/fusing.py

@@ -1,85 +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 typing import Any, List, Union
-
-from model_compression_toolkit.target_platform_capabilities.target_platform.operators import OperatorSetConcat, \
-    OperatorsSet
-from model_compression_toolkit.target_platform_capabilities.target_platform.target_platform_model_component import TargetPlatformModelComponent
-
-
-class Fusing(TargetPlatformModelComponent):
-    """
-     Fusing defines a list of operators that should be combined and treated as a single operator,
-     hence no quantization is applied between them.
-    """
-
-    def __init__(self,
-                 operator_groups_list: List[Union[OperatorsSet, OperatorSetConcat]],
-                 name: str = None):
-        """
-        Args:
-            operator_groups_list (List[Union[OperatorsSet, OperatorSetConcat]]): A list of operator groups, each being either an OperatorSetConcat or an OperatorsSet.
-            name (str): The name for the Fusing instance. If not provided, it's generated from the operator groups' names.
-        """
-        assert isinstance(operator_groups_list,
-                          list), f'List of operator groups should be of type list but is {type(operator_groups_list)}'
-        assert len(operator_groups_list) >= 2, f'Fusing can not be created for a single operators group'
-
-        # Generate a name from the operator groups if no name is provided
-        if name is None:
-            name = '_'.join([x.name for x in operator_groups_list])
-
-        super().__init__(name)
-        self.operator_groups_list = operator_groups_list
-
-    def contains(self, other: Any) -> bool:
-        """
-        Determines if the current Fusing instance contains another Fusing instance.
-
-        Args:
-            other: The other Fusing instance to check against.
-
-        Returns:
-            A boolean indicating whether the other instance is contained within this one.
-        """
-        if not isinstance(other, Fusing):
-            return False
-
-        # Check for containment by comparing operator groups
-        for i in range(len(self.operator_groups_list) - len(other.operator_groups_list) + 1):
-            for j in range(len(other.operator_groups_list)):
-                if self.operator_groups_list[i + j] != other.operator_groups_list[j] and not (
-                        isinstance(self.operator_groups_list[i + j], OperatorSetConcat) and (
-                        other.operator_groups_list[j] in self.operator_groups_list[i + j].op_set_list)):
-                    break
-            else:
-                # If all checks pass, the other Fusing instance is contained
-                return True
-        # Other Fusing instance is not contained
-        return False
-
-    def get_info(self):
-        """
-        Retrieves information about the Fusing instance, including its name and the sequence of operator groups.
-
-        Returns:
-            A dictionary with the Fusing instance's name as the key and the sequence of operator groups as the value,
-            or just the sequence of operator groups if no name is set.
-        """
-        if self.name is not None:
-            return {self.name: ' -> '.join([x.name for x in self.operator_groups_list])}
-        return ' -> '.join([x.name for x in self.operator_groups_list])

model_compression_toolkit/target_platform_capabilities/target_platform/operators.py

@@ -1,87 +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 typing import Dict, Any
-
-from model_compression_toolkit.target_platform_capabilities.constants import OPS_SET_LIST
-from model_compression_toolkit.target_platform_capabilities.target_platform.target_platform_model_component import TargetPlatformModelComponent
-from model_compression_toolkit.target_platform_capabilities.target_platform.current_tp_model import _current_tp_model
-from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import QuantizationConfigOptions
-
-
-class OperatorsSetBase(TargetPlatformModelComponent):
-    """
-    Base class to represent a set of operators.
-    """
-    def __init__(self, name: str):
-        """
-
-        Args:
-            name: Name of OperatorsSet.
-        """
-        super().__init__(name=name)
-
-
-class OperatorsSet(OperatorsSetBase):
-    def __init__(self,
-                 name: str,
-                 qc_options: QuantizationConfigOptions = None):
-        """
-        Set of operators that are represented by a unique label.
-
-        Args:
-            name (str): Set's label (must be unique in a TargetPlatformModel).
-            qc_options (QuantizationConfigOptions): Configuration options to use for this set of operations.
-        """
-
-        super().__init__(name)
-        self.qc_options = qc_options
-        is_fusing_set = qc_options is None
-        self.is_default = _current_tp_model.get().default_qco == self.qc_options or is_fusing_set
-
-
-    def get_info(self) -> Dict[str,Any]:
-        """
-
-        Returns: Info about the set as a dictionary.
-
-        """
-        return {"name": self.name,
-                "is_default_qc": self.is_default}
-
-
-class OperatorSetConcat(OperatorsSetBase):
-    """
-    Concatenate a list of operator sets to treat them similarly in different places (like fusing).
-    """
-    def __init__(self, *opsets: OperatorsSet):
-        """
-        Group a list of operation sets.
-
-        Args:
-            *opsets (OperatorsSet): List of operator sets to group.
-        """
-        name = "_".join([a.name for a in opsets])
-        super().__init__(name=name)
-        self.op_set_list = opsets
-        self.qc_options = None  # Concat have no qc options
-
-    def get_info(self) -> Dict[str,Any]:
-        """
-
-        Returns: Info about the sets group as a dictionary.
-
-        """
-        return {"name": self.name,
-                OPS_SET_LIST: [s.name for s in self.op_set_list]}

model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model_component.py

@@ -1,40 +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 typing import Any, Dict
-
-from model_compression_toolkit.target_platform_capabilities.target_platform.current_tp_model import _current_tp_model
-
-
-class TargetPlatformModelComponent:
-    """
-    Component of TargetPlatformModel (Fusing, OperatorsSet, etc.)
-    """
-    def __init__(self, name: str):
-        """
-
-        Args:
-            name: Name of component.
-        """
-        self.name = name
-        _current_tp_model.get().append_component(self)
-
-    def get_info(self) -> Dict[str, Any]:
-        """
-
-        Returns: Get information about the component to display (return an empty dictionary.
-        the actual component should fill it with info).
-
-        """
-        return {}