mct-nightly 2.2.0.20250106.546__py3-none-any.whl → 2.2.0.20250107.15510__py3-none-any.whl

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

@@ -1,332 +0,0 @@
-# Copyright 2024 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 List, Tuple
-
-import model_compression_toolkit as mct
-import model_compression_toolkit.target_platform_capabilities.schema.v1 as schema
-from model_compression_toolkit.constants import FLOAT_BITWIDTH
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, WEIGHTS_N_BITS, \
-    IMX500_TP_MODEL
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel, \
-    Signedness, \
-    AttributeQuantizationConfig, OpQuantizationConfig
-
-tp = mct.target_platform
-
-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"
-OPSET_BATCH_NORM = "BatchNorm"
-OPSET_ANY_RELU = "AnyReLU"
-OPSET_ADD = "Add"
-OPSET_SUB = "Sub"
-OPSET_MUL = "Mul"
-OPSET_DIV = "Div"
-OPSET_MIN_MAX = "MinMax"
-OPSET_PRELU = "PReLU"
-OPSET_SWISH = "Swish"
-OPSET_SIGMOID = "Sigmoid"
-OPSET_TANH = "Tanh"
-OPSET_GELU = "Gelu"
-OPSET_HARDSIGMOID = "HardSigmoid"
-OPSET_HARDSWISH = "HardSwish"
-
-
-def get_tp_model() -> TargetPlatformModel:
-    """
-    A method that generates a default target platform model, with base 8-bit quantization configuration and 8, 4, 2
-    bits configuration list for mixed-precision quantization.
-    NOTE: in order to generate a target platform model with different configurations but with the same Operators Sets
-    (for tests, experiments, etc.), use this method implementation as a test-case, i.e., override the
-    'get_op_quantization_configs' method and use its output to call 'generate_tp_model' with your configurations.
-    This version enables metadata by default.
-
-    Returns: A TargetPlatformModel object.
-
-    """
-    base_config, mixed_precision_cfg_list, default_config = get_op_quantization_configs()
-    return generate_tp_model(default_config=default_config,
-                             base_config=base_config,
-                             mixed_precision_cfg_list=mixed_precision_cfg_list,
-                             name='imx500_tp_model')
-
-
-def get_op_quantization_configs() -> \
-        Tuple[OpQuantizationConfig, List[OpQuantizationConfig], OpQuantizationConfig]:
-    """
-    Creates a default configuration object for 8-bit quantization, to be used to set a default TargetPlatformModel.
-    In addition, creates a default configuration objects list (with 8, 4 and 2 bit quantization) to be used as
-    default configuration for mixed-precision quantization.
-
-    Returns: An OpQuantizationConfig config object and a list of OpQuantizationConfig objects.
-
-    """
-
-    # TODO: currently, we don't want to quantize any attribute but the kernel by default,
-    #  to preserve the current behavior of MCT, so quantization is disabled for all other attributes.
-    #  Other quantization parameters are set to what we eventually want to quantize by default
-    #  when we enable multi-attributes quantization - THIS NEED TO BE MODIFIED IN ALL TP MODELS!
-
-    # define a default quantization config for all non-specified weights attributes.
-    default_weight_attr_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
-        weights_n_bits=8,
-        weights_per_channel_threshold=False,
-        enable_weights_quantization=False,
-        # TODO: this will changed to True once implementing multi-attributes quantization
-        lut_values_bitwidth=None)
-
-    # define a quantization config to quantize the kernel (for layers where there is a kernel attribute).
-    kernel_base_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.SYMMETRIC,
-        weights_n_bits=8,
-        weights_per_channel_threshold=True,
-        enable_weights_quantization=True,
-        lut_values_bitwidth=None)
-
-    # define a quantization config to quantize the bias (for layers where there is a bias attribute).
-    bias_config = AttributeQuantizationConfig(
-        weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
-        weights_n_bits=FLOAT_BITWIDTH,
-        weights_per_channel_threshold=False,
-        enable_weights_quantization=False,
-        lut_values_bitwidth=None)
-
-    # Create a quantization config.
-    # A quantization configuration defines how an operator
-    # should be quantized on the modeled hardware:
-
-    # 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 = OpQuantizationConfig(
-        default_weight_attr_config=default_weight_attr_config,
-        attr_weights_configs_mapping={},
-        activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
-        activation_n_bits=8,
-        supported_input_activation_n_bits=8,
-        enable_activation_quantization=True,
-        quantization_preserving=False,
-        fixed_scale=None,
-        fixed_zero_point=None,
-        simd_size=32,
-        signedness=Signedness.AUTO)
-
-    # We define an 8-bit config for linear operations quantization, that include a kernel and bias attributes.
-    linear_eight_bits = OpQuantizationConfig(
-        default_weight_attr_config=default_weight_attr_config,
-        attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
-        activation_quantization_method=tp.QuantizationMethod.POWER_OF_TWO,
-        activation_n_bits=8,
-        supported_input_activation_n_bits=8,
-        enable_activation_quantization=True,
-        quantization_preserving=False,
-        fixed_scale=None,
-        fixed_zero_point=None,
-        simd_size=32,
-        signedness=Signedness.AUTO)
-
-    # To quantize a model using mixed-precision, create
-    # a list with more than one OpQuantizationConfig.
-    # In this example, we quantize some operations' weights
-    # using 2, 4 or 8 bits, and when using 2 or 4 bits, it's possible
-    # to quantize the operations' activations using LUT.
-    four_bits = linear_eight_bits.clone_and_edit(attr_to_edit={KERNEL_ATTR: {WEIGHTS_N_BITS: 4}},
-                                                 simd_size=linear_eight_bits.simd_size * 2)
-    two_bits = linear_eight_bits.clone_and_edit(attr_to_edit={KERNEL_ATTR: {WEIGHTS_N_BITS: 2}},
-                                                simd_size=linear_eight_bits.simd_size * 4)
-
-    mixed_precision_cfg_list = [linear_eight_bits, four_bits, two_bits]
-
-    return linear_eight_bits, mixed_precision_cfg_list, eight_bits_default
-
-
-def generate_tp_model(default_config: OpQuantizationConfig,
-                      base_config: OpQuantizationConfig,
-                      mixed_precision_cfg_list: List[OpQuantizationConfig],
-                      name: str) -> TargetPlatformModel:
-    """
-    Generates TargetPlatformModel with default defined Operators Sets, based on the given base configuration and
-    mixed-precision configurations options list.
-
-    Args
-        default_config: A default OpQuantizationConfig to set as the TP model default configuration.
-        base_config: An OpQuantizationConfig to set as the TargetPlatformModel base configuration for mixed-precision purposes only.
-        mixed_precision_cfg_list: A list of OpQuantizationConfig to be used as the TP model mixed-precision
-            quantization configuration options.
-        name: The name of the TargetPlatformModel.
-
-    Returns: A TargetPlatformModel object.
-
-    """
-    # Create a QuantizationConfigOptions, which defines a set
-    # 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(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(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.
-    # Since the constants are not named attributes of the layer, we use the default_weight_attr_config to
-    # define the desired quantization properties for them.
-    const_config = default_config.clone_and_edit(
-        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(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.
-    const_config_input16 = const_config.clone_and_edit(
-        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(
-        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),
-        default_weight_attr_config=default_config.default_weight_attr_config.clone_and_edit(
-            enable_weights_quantization=True, weights_per_channel_threshold=False,
-            weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO)
-    )
-    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(quantization_configurations=tuple(
-        [const_config_input16_output16_per_tensor,
-         const_config_input16_per_tensor]),
-        base_config=const_config_input16_per_tensor)
-
-    qpreserving_const_config = const_config.clone_and_edit(enable_activation_quantization=False,
-                                                           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(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(quantization_configurations=tuple(
-        mixed_precision_cfg_list + mp_cfg_list_16bit),
-        base_config=base_config)
-
-    # Create an OperatorsSet to represent a set of operations.
-    # Each OperatorsSet has a unique label.
-    # If a quantization configuration options is passed, these options will
-    # be used for operations that will be attached to this set's label.
-    # Otherwise, it will be a configure-less set (used in fusing):
-    operator_set = []
-    fusing_patterns = []
-    # May suit for operations like: Dropout, Reshape, etc.
-    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(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(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(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(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(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(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(operators_set=[any_relu, swish, prelu, sigmoid,
-                                                               tanh, gelu, hardswish, hardsigmoid])
-    activations_after_fc_to_fuse = schema.OperatorSetConcat(operators_set=[any_relu, swish, sigmoid, tanh, gelu,
-                                                             hardswish, hardsigmoid])
-    any_binary = schema.OperatorSetConcat(operators_set=[add, sub, mul, div])
-
-    # ------------------- #
-    # Fusions
-    # ------------------- #
-    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_qco=default_configuration_options,
-        tpc_minor_version=4,
-        tpc_patch_version=0,
-        tpc_platform_type=IMX500_TP_MODEL,
-        operator_set=tuple(operator_set),
-        fusing_patterns=tuple(fusing_patterns),
-        add_metadata=True,
-        name=name,
-        is_simd_padding=True)
-
-    return generated_tpm

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

@@ -1,140 +0,0 @@
-# Copyright 2024 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.
-# ==============================================================================
-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.verify_packages import FOUND_SONY_CUSTOM_LAYERS
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, KERAS_DEPTHWISE_KERNEL, \
-    KERAS_KERNEL, BIAS_ATTR, BIAS
-
-if FOUND_SONY_CUSTOM_LAYERS:
-    from sony_custom_layers.keras.object_detection.ssd_post_process import SSDPostProcess
-
-if version.parse(tf.__version__) >= version.parse("2.13"):
-    from keras.src.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
-        MaxPooling2D, Activation, ReLU, Add, Subtract, Multiply, PReLU, Flatten, Cropping2D, LeakyReLU, Permute, \
-        Conv2DTranspose, Identity, Concatenate, BatchNormalization, Minimum, Maximum
-else:
-    from keras.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
-        MaxPooling2D, Activation, ReLU, Add, Subtract, Multiply, PReLU, Flatten, Cropping2D, LeakyReLU, Permute, \
-        Conv2DTranspose, Identity, Concatenate, BatchNormalization, Minimum, Maximum
-
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tp_model import get_tp_model
-import model_compression_toolkit as mct
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4 import __version__ as TPC_VERSION
-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_SPLIT_OPS
-
-tp = mct.target_platform
-
-
-def get_keras_tpc() -> tp.TargetPlatformCapabilities:
-    """
-    get a Keras TargetPlatformCapabilities object with default operation sets to layers mapping.
-
-    Returns: a Keras TargetPlatformCapabilities object for the given TargetPlatformModel.
-    """
-    imx500_tpc_tp_model = get_tp_model()
-    return generate_keras_tpc(name='imx500_tpc_keras_tpc', tp_model=imx500_tpc_tp_model)
-
-
-def generate_keras_tpc(name: str, tp_model: schema.TargetPlatformModel):
-    """
-    Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
-
-    Args:
-        name: Name of the TargetPlatformCapabilities.
-        tp_model: TargetPlatformModel object.
-
-    Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
-    """
-
-    keras_tpc = tp.TargetPlatformCapabilities(tp_model)
-
-    no_quant_list = [tf.quantization.fake_quant_with_min_max_vars,
-                     tf.math.argmax,
-                     tf.shape,
-                     tf.math.equal,
-                     tf.nn.top_k,
-                     tf.image.combined_non_max_suppression,
-                     tf.compat.v1.shape]
-    quantization_preserving = [Cropping2D,
-                               ZeroPadding2D,
-                               Dropout,
-                               MaxPooling2D,
-                               tf.cast]
-    quantization_preserving_list_16bit_input = [Reshape,
-                                                tf.reshape,
-                                                Permute,
-                                                tf.transpose,
-                                                Flatten]
-
-    if FOUND_SONY_CUSTOM_LAYERS:
-        no_quant_list.append(SSDPostProcess)
-
-    with keras_tpc:
-        tp.OperationsSetToLayers(OPSET_NO_QUANTIZATION, no_quant_list)
-        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,
-                                  DepthwiseConv2D,
-                                  Conv2DTranspose,
-                                  tf.nn.conv2d,
-                                  tf.nn.depthwise_conv2d,
-                                  tf.nn.conv2d_transpose],
-                                 # we provide attributes mapping that maps each layer type in the operations set
-                                 # that has weights attributes with provided quantization config (in the tp model) to
-                                 # its framework-specific attribute name.
-                                 # note that a DefaultDict should be provided if not all the layer types in the
-                                 # operation set are provided separately in the mapping.
-                                 attr_mapping={
-                                     KERNEL_ATTR: DefaultDict({
-                                         DepthwiseConv2D: KERAS_DEPTHWISE_KERNEL,
-                                         tf.nn.depthwise_conv2d: KERAS_DEPTHWISE_KERNEL}, default_value=KERAS_KERNEL),
-                                     BIAS_ATTR: DefaultDict(default_value=BIAS)})
-        tp.OperationsSetToLayers(OPSET_FULLY_CONNECTED, [Dense],
-                                 attr_mapping={KERNEL_ATTR: DefaultDict(default_value=KERAS_KERNEL),
-                                               BIAS_ATTR: DefaultDict(default_value=BIAS)})
-        tp.OperationsSetToLayers(OPSET_BATCH_NORM, [BatchNormalization])
-        tp.OperationsSetToLayers(OPSET_ANY_RELU, [tf.nn.relu,
-                                                  tf.nn.relu6,
-                                                  tf.nn.leaky_relu,
-                                                  ReLU,
-                                                  LeakyReLU,
-                                                  tp.LayerFilterParams(Activation, activation="relu"),
-                                                  tp.LayerFilterParams(Activation, activation="leaky_relu")])
-        tp.OperationsSetToLayers(OPSET_ADD, [tf.add, Add])
-        tp.OperationsSetToLayers(OPSET_SUB, [tf.subtract, Subtract])
-        tp.OperationsSetToLayers(OPSET_MUL, [tf.math.multiply, Multiply])
-        tp.OperationsSetToLayers(OPSET_DIV, [tf.math.divide, tf.math.truediv])
-        tp.OperationsSetToLayers(OPSET_MIN_MAX, [tf.math.minimum, tf.math.maximum, Minimum, Maximum])
-        tp.OperationsSetToLayers(OPSET_PRELU, [PReLU])
-        tp.OperationsSetToLayers(OPSET_SWISH, [tf.nn.swish, tp.LayerFilterParams(Activation, activation="swish")])
-        tp.OperationsSetToLayers(OPSET_SIGMOID, [tf.nn.sigmoid, tp.LayerFilterParams(Activation, activation="sigmoid")])
-        tp.OperationsSetToLayers(OPSET_TANH, [tf.nn.tanh, tp.LayerFilterParams(Activation, activation="tanh")])
-        tp.OperationsSetToLayers(OPSET_GELU, [tf.nn.gelu, tp.LayerFilterParams(Activation, activation="gelu")])
-        tp.OperationsSetToLayers(OPSET_HARDSIGMOID, [tf.keras.activations.hard_sigmoid,
-                                                     tp.LayerFilterParams(Activation, activation="hard_sigmoid")])
-
-    return keras_tpc

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

@@ -1,122 +0,0 @@
-# Copyright 2024 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.
-# ==============================================================================
-
-import operator
-
-import torch
-from torch import add, sub, mul, div, divide, flatten, reshape, split, unsqueeze, dropout, sigmoid, tanh, \
-    chunk, unbind, topk, gather, equal, transpose, permute, argmax, squeeze, multiply, subtract, minimum, \
-    maximum
-from torch.nn import Conv2d, Linear, ConvTranspose2d, MaxPool2d, BatchNorm2d
-from torch.nn import Dropout, Flatten, Hardtanh
-from torch.nn import ReLU, ReLU6, PReLU, SiLU, Sigmoid, Tanh, Hardswish, Hardsigmoid, LeakyReLU, GELU
-import torch.nn.functional as F
-from torch.nn.functional import relu, relu6, prelu, silu, hardtanh, hardswish, hardsigmoid, leaky_relu, gelu
-
-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, BIAS_ATTR, PYTORCH_KERNEL, \
-    BIAS
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tp_model import get_tp_model
-import model_compression_toolkit as mct
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4 import __version__ as TPC_VERSION
-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_HARDSWISH, OPSET_SPLIT_OPS
-
-tp = mct.target_platform
-
-
-def get_pytorch_tpc() -> tp.TargetPlatformCapabilities:
-    """
-    get a Pytorch TargetPlatformCapabilities object with default operation sets to layers mapping.
-
-    Returns: a Pytorch TargetPlatformCapabilities object for the given TargetPlatformModel.
-    """
-    imx500_tpc_tp_model = get_tp_model()
-    return generate_pytorch_tpc(name='imx500_tpc_pytorch_tpc', tp_model=imx500_tpc_tp_model)
-
-
-def generate_pytorch_tpc(name: str, tp_model: schema.TargetPlatformModel):
-    """
-    Generates a TargetPlatformCapabilities object with default operation sets to layers mapping.
-    Args:
-        name: Name of the TargetPlatformModel.
-        tp_model: TargetPlatformModel object.
-    Returns: a TargetPlatformCapabilities object for the given TargetPlatformModel.
-    """
-
-    pytorch_tpc = tp.TargetPlatformCapabilities(tp_model)
-
-    # we provide attributes mapping that maps each layer type in the operations set
-    # that has weights attributes with provided quantization config (in the tp model) to
-    # its framework-specific attribute name.
-    # note that a DefaultDict should be provided if not all the layer types in the
-    # operation set are provided separately in the mapping.
-    pytorch_linear_attr_mapping = {KERNEL_ATTR: DefaultDict(default_value=PYTORCH_KERNEL),
-                                   BIAS_ATTR: DefaultDict(default_value=BIAS)}
-
-    with pytorch_tpc:
-        tp.OperationsSetToLayers(OPSET_NO_QUANTIZATION, [torch.Tensor.size,
-                                                         equal,
-                                                         argmax,
-                                                         topk])
-        tp.OperationsSetToLayers(OPSET_QUANTIZATION_PRESERVING, [Dropout,
-                                                                 dropout,
-                                                                 MaxPool2d])
-        tp.OperationsSetToLayers(OPSET_DIMENSION_MANIPULATION_OPS, [Flatten,
-                                                                    flatten,
-                                                                    operator.getitem,
-                                                                    reshape,
-                                                                    unsqueeze,
-                                                                    squeeze,
-                                                                    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])
-
-        tp.OperationsSetToLayers(OPSET_CONV, [Conv2d, ConvTranspose2d],
-                                 attr_mapping=pytorch_linear_attr_mapping)
-        tp.OperationsSetToLayers(OPSET_FULLY_CONNECTED, [Linear],
-                                 attr_mapping=pytorch_linear_attr_mapping)
-        tp.OperationsSetToLayers(OPSET_BATCH_NORM, [BatchNorm2d])
-        tp.OperationsSetToLayers(OPSET_ANY_RELU, [torch.relu,
-                                                  ReLU,
-                                                  ReLU6,
-                                                  LeakyReLU,
-                                                  relu,
-                                                  relu6,
-                                                  leaky_relu,
-                                                  tp.LayerFilterParams(Hardtanh, min_val=0),
-                                                  tp.LayerFilterParams(hardtanh, min_val=0)])
-
-        tp.OperationsSetToLayers(OPSET_ADD, [operator.add, add])
-        tp.OperationsSetToLayers(OPSET_SUB, [operator.sub, sub, subtract])
-        tp.OperationsSetToLayers(OPSET_MUL, [operator.mul, mul, multiply])
-        tp.OperationsSetToLayers(OPSET_DIV, [operator.truediv, div, divide])
-        tp.OperationsSetToLayers(OPSET_MIN_MAX, [minimum, maximum])
-        tp.OperationsSetToLayers(OPSET_PRELU, [PReLU, prelu])
-        tp.OperationsSetToLayers(OPSET_SWISH, [SiLU, silu])
-        tp.OperationsSetToLayers(OPSET_SIGMOID, [Sigmoid, sigmoid, F.sigmoid])
-        tp.OperationsSetToLayers(OPSET_TANH, [Tanh, tanh, F.tanh])
-        tp.OperationsSetToLayers(OPSET_GELU, [GELU, gelu])
-        tp.OperationsSetToLayers(OPSET_HARDSIGMOID, [Hardsigmoid, hardsigmoid])
-        tp.OperationsSetToLayers(OPSET_HARDSWISH, [Hardswish, hardswish])
-
-    return pytorch_tpc

model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/target_platform_capabilities.py

@@ -1,55 +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.constants import TENSORFLOW, PYTORCH
-from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.constants import LATEST
-
-def get_tpc_dict_by_fw(fw_name):
-    tpc_models_dict = None
-    if fw_name == TENSORFLOW:
-        ###############################
-        # Build Tensorflow TPC models
-        ###############################
-        if FOUND_TF:
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.latest import \
-                get_keras_tpc_latest
-
-            # Keras: TPC versioning
-            tpc_models_dict = {'v1': get_keras_tpc_v1,
-                               LATEST: get_keras_tpc_latest}
-    elif fw_name == PYTORCH:
-        ###############################
-        # Build Pytorch TPC models
-        ###############################
-        if FOUND_TORCH:
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.v1.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.qnnpack_tpc.latest import \
-                get_pytorch_tpc_latest
-
-            # Pytorch: TPC versioning
-            tpc_models_dict = {'v1': get_pytorch_tpc_v1,
-                               LATEST: get_pytorch_tpc_latest}
-    if tpc_models_dict is not None:
-        return tpc_models_dict
-    else:
-        Logger.critical(f'Framework {fw_name} is not supported in imx500 or the relevant packages are not '
-                        f'installed. Please make sure the relevant packages are installed when using MCT for optimizing'
-                        f' a {fw_name} model. For Tensorflow, please install tensorflow. For PyTorch, please install '
-                        f'torch.')  # pragma: no cover