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

@@ -18,8 +18,7 @@ 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
@@ -137,8 +136,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(
-        quantization_configurations=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:
@@ -146,44 +144,60 @@ def generate_tp_model(default_config: OpQuantizationConfig,
     operator_set = []
     fusing_patterns = []
 
-    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",
+    quant_preserving = default_configuration_options.clone_and_edit(quantization_preserving=True)
+
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.UNSTACK, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.TRANSPOSE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.GATHER, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.RESHAPE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MAXPOOL, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.AVGPOOL, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.STRIDED_SLICE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.CONCATENATE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MUL, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MIN, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.MAX, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.ZERO_PADDING2D, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.RESIZE, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.PAD, qc_options=quant_preserving))
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.FOLD, qc_options=quant_preserving))
+
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.L2NORM,
                                             qc_options=default_configuration_options.clone_and_edit(
                                                 fixed_zero_point=0, fixed_scale=1 / 128)))
-    operator_set.append(schema.OperatorsSet(name="LogSoftmax",
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.LOG_SOFTMAX,
                                             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",
+    operator_set.append(schema.OperatorsSet(name=schema.OperatorSetNames.SOFTMAX,
                                             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])
+    sigmoid = schema.OperatorsSet(name=schema.OperatorSetNames.SIGMOID,
+                                  qc_options=default_configuration_options.clone_and_edit_weight_attribute(
+                                      weights_per_channel_threshold=False))
+    tanh = schema.OperatorsSet(name=schema.OperatorSetNames.TANH,
+                               qc_options=default_configuration_options.clone_and_edit(
+                                   fixed_zero_point=-128, fixed_scale=1 / 256))
+    fc = schema.OperatorsSet(name=schema.OperatorSetNames.FULLY_CONNECTED,
+                             qc_options=default_configuration_options.clone_and_edit_weight_attribute(
+                                 weights_per_channel_threshold=False))
+    squeeze = schema.OperatorsSet(name=schema.OperatorSetNames.SQUEEZE,
+                                  qc_options=default_configuration_options.clone_and_edit(
+                                      quantization_preserving=True))
+
+    conv2d = schema.OperatorsSet(name=schema.OperatorSetNames.CONV)
+    relu = schema.OperatorsSet(name=schema.OperatorSetNames.RELU)
+    relu6 = schema.OperatorsSet(name=schema.OperatorSetNames.RELU6)
+    elu = schema.OperatorsSet(name=schema.OperatorSetNames.ELU)
+    batch_norm = schema.OperatorsSet(name=schema.OperatorSetNames.BATCH_NORM)
+    add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD)
+    bias_add = schema.OperatorsSet(name=schema.OperatorSetNames.ADD_BIAS)
 
-    relu = schema.OperatorsSet(name="Relu")
-    elu = schema.OperatorsSet(name="Elu")
+    kernel = schema.OperatorSetConcat(operators_set=[conv2d, fc])
     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])
+    operator_set.extend([fc, conv2d, relu, relu6, tanh, sigmoid, batch_norm, add, bias_add, elu, squeeze])
+
     # ------------------- #
     # Fusions
     # ------------------- #

model_compression_toolkit/xquant/keras/keras_report_utils.py

@@ -13,11 +13,11 @@
 #  limitations under the License.
 #  ==============================================================================
 
-
+from model_compression_toolkit import get_target_platform_capabilities
+from model_compression_toolkit.constants import TENSORFLOW
 from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
 from model_compression_toolkit.core.keras.keras_implementation import KerasImplementation
 from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
-from model_compression_toolkit.ptq.keras.quantization_facade import DEFAULT_KERAS_TPC
 from model_compression_toolkit.xquant.common.model_folding_utils import ModelFoldingUtils
 from model_compression_toolkit.xquant.common.similarity_calculator import SimilarityCalculator
 from model_compression_toolkit.xquant.keras.dataset_utils import KerasDatasetUtils
@@ -26,6 +26,9 @@ from model_compression_toolkit.xquant.keras.model_analyzer import KerasModelAnal
 from model_compression_toolkit.xquant.keras.similarity_functions import KerasSimilarityFunctions
 from model_compression_toolkit.xquant.keras.tensorboard_utils import KerasTensorboardUtils
 from mct_quantizers.keras.metadata import get_metadata
+from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
+from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2keras import \
+    AttachTpcToKeras
 
 
 class KerasReportUtils(FrameworkReportUtils):
@@ -40,10 +43,15 @@ class KerasReportUtils(FrameworkReportUtils):
         fw_info = DEFAULT_KERAS_INFO
         fw_impl = KerasImplementation()
 
+        # Set the default Target Platform Capabilities (TPC) for Keras.
+        default_tpc = get_target_platform_capabilities(TENSORFLOW, DEFAULT_TP_MODEL)
+        attach2pytorch = AttachTpcToKeras()
+        target_platform_capabilities = attach2pytorch.attach(default_tpc)
+
         dataset_utils = KerasDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=DEFAULT_KERAS_TPC)
+                                          fw_default_tpc=target_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py

@@ -12,9 +12,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #  ==============================================================================
+from model_compression_toolkit import get_target_platform_capabilities
+from model_compression_toolkit.constants import PYTORCH
 from model_compression_toolkit.core.pytorch.utils import get_working_device
+from model_compression_toolkit.target_platform_capabilities.constants import DEFAULT_TP_MODEL
+from model_compression_toolkit.target_platform_capabilities.target_platform.targetplatform2framework.attach2pytorch import \
+    AttachTpcToPytorch
 
-from model_compression_toolkit.ptq.pytorch.quantization_facade import DEFAULT_PYTORCH_TPC
 from model_compression_toolkit.xquant.common.framework_report_utils import FrameworkReportUtils
 from model_compression_toolkit.core.pytorch.default_framework_info import DEFAULT_PYTORCH_INFO
 from model_compression_toolkit.core.pytorch.pytorch_implementation import PytorchImplementation
@@ -37,11 +41,15 @@ class PytorchReportUtils(FrameworkReportUtils):
         """
         fw_info = DEFAULT_PYTORCH_INFO
         fw_impl = PytorchImplementation()
+        # Set the default Target Platform Capabilities (TPC) for PyTorch.
+        default_tpc = get_target_platform_capabilities(PYTORCH, DEFAULT_TP_MODEL)
+        attach2pytorch = AttachTpcToPytorch()
+        target_platform_capabilities = attach2pytorch.attach(default_tpc)
 
         dataset_utils = PytorchDatasetUtils()
         model_folding = ModelFoldingUtils(fw_info=fw_info,
                                           fw_impl=fw_impl,
-                                          fw_default_tpc=DEFAULT_PYTORCH_TPC)
+                                          fw_default_tpc=target_platform_capabilities)
 
         similarity_calculator = SimilarityCalculator(dataset_utils=dataset_utils,
                                                      model_folding=model_folding,

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py

@@ -1,98 +0,0 @@
-# Copyright 2023 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
-
-from model_compression_toolkit.constants import TENSORFLOW, PYTORCH
-from model_compression_toolkit.verify_packages import FOUND_TORCH, FOUND_TF
-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.imx500_tpc.latest import \
-                get_keras_tpc_latest
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_lut.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_pot.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v1_pot
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v2
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2_lut.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v2_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v3
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3_lut.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v3_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tpc_keras import \
-                get_keras_tpc as get_keras_tpc_v4
-
-            # Keras: TPC versioning
-            tpc_models_dict = {'v1': get_keras_tpc_v1,
-                               'v1_lut': get_keras_tpc_v1_lut,
-                               'v1_pot': get_keras_tpc_v1_pot,
-                               'v2': get_keras_tpc_v2,
-                               'v2_lut': get_keras_tpc_v2_lut,
-                               'v3': get_keras_tpc_v3,
-                               'v3_lut': get_keras_tpc_v3_lut,
-                               'v4': get_keras_tpc_v4,
-                               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.imx500_tpc.latest import \
-                get_pytorch_tpc_latest
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_pot.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1_pot
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1_lut.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v1_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v2
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v2_lut.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v2_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v3
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3_lut.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v3_lut
-            from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v4.tpc_pytorch import \
-                get_pytorch_tpc as get_pytorch_tpc_v4
-
-            # Pytorch: TPC versioning
-            tpc_models_dict = {'v1': get_pytorch_tpc_v1,
-                               'v1_lut': get_pytorch_tpc_v1_lut,
-                               'v1_pot': get_pytorch_tpc_v1_pot,
-                               'v2': get_pytorch_tpc_v2,
-                               'v2_lut': get_pytorch_tpc_v2_lut,
-                               'v3': get_pytorch_tpc_v3,
-                               'v3_lut': get_pytorch_tpc_v3_lut,
-                               'v4': get_pytorch_tpc_v4,
-                               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

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

@@ -1,129 +0,0 @@
-# Copyright 2023 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
-
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
-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
-else:
-    from keras.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
-        MaxPooling2D, Activation, ReLU, Add, Subtract, Multiply, PReLU, Flatten, Cropping2D, LeakyReLU, Permute, \
-        Conv2DTranspose
-
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1.tp_model import get_tp_model
-import model_compression_toolkit as mct
-from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v1 import __version__ as TPC_VERSION
-
-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: 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 = [Reshape,
-                     tf.reshape,
-                     Permute,
-                     tf.transpose,
-                     Flatten,
-                     Cropping2D,
-                     ZeroPadding2D,
-                     Dropout,
-                     MaxPooling2D,
-                     tf.split,
-                     tf.quantization.fake_quant_with_min_max_vars,
-                     tf.math.argmax,
-                     tf.shape,
-                     tf.math.equal,
-                     tf.gather,
-                     tf.cast,
-                     tf.unstack,
-                     tf.compat.v1.gather,
-                     tf.nn.top_k,
-                     tf.__operators__.getitem,
-                     tf.image.combined_non_max_suppression,
-                     tf.compat.v1.shape]
-
-    if FOUND_SONY_CUSTOM_LAYERS:
-        no_quant_list.append(SSDPostProcess)
-
-    with keras_tpc:
-        tp.OperationsSetToLayers("NoQuantization", no_quant_list)
-        tp.OperationsSetToLayers("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("FullyConnected", [Dense],
-                                 attr_mapping={KERNEL_ATTR: DefaultDict(default_value=KERAS_KERNEL),
-                                               BIAS_ATTR: DefaultDict(default_value=BIAS)})
-        tp.OperationsSetToLayers("AnyReLU", [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("Add", [tf.add, Add])
-        tp.OperationsSetToLayers("Sub", [tf.subtract, Subtract])
-        tp.OperationsSetToLayers("Mul", [tf.math.multiply, Multiply])
-        tp.OperationsSetToLayers("Div", [tf.math.divide])
-        tp.OperationsSetToLayers("PReLU", [PReLU])
-        tp.OperationsSetToLayers("Swish", [tf.nn.swish, tp.LayerFilterParams(Activation, activation="swish")])
-        tp.OperationsSetToLayers("Sigmoid", [tf.nn.sigmoid, tp.LayerFilterParams(Activation, activation="sigmoid")])
-        tp.OperationsSetToLayers("Tanh", [tf.nn.tanh, tp.LayerFilterParams(Activation, activation="tanh")])
-
-    return keras_tpc

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

@@ -1,108 +0,0 @@
-# Copyright 2023 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, flatten, reshape, split, unsqueeze, dropout, sigmoid, tanh, chunk, unbind, topk, \
-    gather, equal, transpose, permute, argmax, squeeze
-from torch.nn import Conv2d, Linear, BatchNorm2d, ConvTranspose2d
-from torch.nn import Dropout, Flatten, Hardtanh
-from torch.nn import ReLU, ReLU6, PReLU, SiLU, Sigmoid, Tanh, Hardswish, LeakyReLU
-from torch.nn.functional import relu, relu6, prelu, silu, hardtanh, hardswish, leaky_relu
-
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformModel
-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.v1.tp_model import get_tp_model
-import model_compression_toolkit as mct
-
-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: 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("NoQuantization", [Dropout,
-                                                    Flatten,
-                                                    dropout,
-                                                    flatten,
-                                                    split,
-                                                    operator.getitem,
-                                                    reshape,
-                                                    unsqueeze,
-                                                    BatchNorm2d,
-                                                    chunk,
-                                                    unbind,
-                                                    torch.Tensor.size,
-                                                    permute,
-                                                    transpose,
-                                                    equal,
-                                                    argmax,
-                                                    gather,
-                                                    topk,
-                                                    squeeze])
-
-        tp.OperationsSetToLayers("Conv", [Conv2d, ConvTranspose2d],
-                                 attr_mapping=pytorch_linear_attr_mapping)
-        tp.OperationsSetToLayers("FullyConnected", [Linear],
-                                 attr_mapping=pytorch_linear_attr_mapping)
-        tp.OperationsSetToLayers("AnyReLU", [torch.relu,
-                                             ReLU,
-                                             ReLU6,
-                                             LeakyReLU,
-                                             relu,
-                                             relu6,
-                                             leaky_relu,
-                                             tp.LayerFilterParams(Hardtanh, min_val=0),
-                                             tp.LayerFilterParams(hardtanh, min_val=0)])
-
-        tp.OperationsSetToLayers("Add", [operator.add, add])
-        tp.OperationsSetToLayers("Sub", [operator.sub, sub])
-        tp.OperationsSetToLayers("Mul", [operator.mul, mul])
-        tp.OperationsSetToLayers("Div", [operator.truediv, div])
-        tp.OperationsSetToLayers("PReLU", [PReLU, prelu])
-        tp.OperationsSetToLayers("Swish", [SiLU, silu, Hardswish, hardswish])
-        tp.OperationsSetToLayers("Sigmoid", [Sigmoid, sigmoid])
-        tp.OperationsSetToLayers("Tanh", [Tanh, tanh])
-
-    return pytorch_tpc

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

@@ -1,16 +0,0 @@
-# Copyright 2023 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.
-# ==============================================================================
-
-__version__ = 'v1_lut'