mct-nightly 2.1.0.20240821.444__py3-none-any.whl → 2.1.0.20240822.448__py3-none-any.whl

{mct_nightly-2.1.0.20240821.444.dist-info → mct_nightly-2.1.0.20240822.448.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.1.0.20240821.444
+Version: 2.1.0.20240822.448
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct_nightly-2.1.0.20240821.444.dist-info → mct_nightly-2.1.0.20240822.448.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=bgVjYSXQXW6v8ZyYSkCY0qnZUwsnF6W5MYVYsczk7LA,1573
+model_compression_toolkit/__init__.py,sha256=VxopIov64itXZS8DVq4AbrhJWECuZqAt-hf9_rqheig,1573
 model_compression_toolkit/constants.py,sha256=i4wYheBkIdQmsQA-axIpcT3YiSO1USNc-jaNiNE8w6E,3920
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
@@ -8,7 +8,7 @@ model_compression_toolkit/core/__init__.py,sha256=tnDtL9KmT0vsOU27SsJ19TKDEbIH-t
 model_compression_toolkit/core/analyzer.py,sha256=X-2ZpkH1xdXnISnw1yJvXnvV-ssoUh-9LkLISSWNqiY,3691
 model_compression_toolkit/core/graph_prep_runner.py,sha256=7-b7Jd5jBVaXOWg5nSqbEyzBtdaGDbCxs8aqMV6GZ6I,11287
 model_compression_toolkit/core/quantization_prep_runner.py,sha256=K9eJ7VbB_rpeyxX4yEnorOmSxFW3DkvofzxS6QI8Hp8,6454
-model_compression_toolkit/core/runner.py,sha256=kiNClmonlaqNI2U72bzGoJUzLxKHLh61iak9-HvsfQM,13880
+model_compression_toolkit/core/runner.py,sha256=ryHhW5Qqu7XHVkngLF0uLX8oa4CxNAIF4PoGBeUjoSk,14346
 model_compression_toolkit/core/common/__init__.py,sha256=Wh127PbXcETZX_d1PQqZ71ETK3J9XO5A-HpadGUbj6o,1447
 model_compression_toolkit/core/common/base_substitutions.py,sha256=xDFSmVVs_iFSZfajytI0cuQaNRNcwHX3uqOoHgVUvxQ,1666
 model_compression_toolkit/core/common/framework_implementation.py,sha256=kSg2f7wS7e2EyvX6y0eKfNTTFvVFVrB8lvldJvcPvN8,20724
@@ -441,7 +441,7 @@ model_compression_toolkit/target_platform_capabilities/target_platform/targetpla
 model_compression_toolkit/target_platform_capabilities/tpc_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 model_compression_toolkit/target_platform_capabilities/tpc_models/get_target_platform_capabilities.py,sha256=CWind2Kd91lzBTRAh1A9sHuNw17xXhMb3gV436RpK8c,3033
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py,sha256=yIWwvfTpiT0wRf7GwPgK9elKbGh46jxCrkcLVEjvesU,6081
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py,sha256=YxQC_JjnnB_ZEVgUVXAXZIrRKvAj9A7nWIVZTL2HDVA,5631
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/latest/__init__.py,sha256=eVIRpx5O0JQI7TSdw5JAWtwrG3MQ8-7hYThQvB9da5c,1528
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/__init__.py,sha256=1mMOREEMoNHu_KTMGDp4crN61opKWX6aFn1DrDLvqcc,717
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v1/tp_model.py,sha256=6mbv-fNVz559j5XCSX5e8aENUJACYuJzQcZBLPh12gU,11057
@@ -464,17 +464,13 @@ model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/tpc_keras.py,sha256=EgDKcY-ba9cBmQmh0-sv45GLm-HP6Cc4Rgf-KxZXTgM,6601
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v2_lut/tpc_pytorch.py,sha256=dFQjzFlLDwoUqKNP1at1fS1N1WJadSSasRyzHl6vaB8,5733
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/__init__.py,sha256=gAeebYCKyIXH9-Qwze7FwvTihudzAHk_Qsg94fQbkjQ,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tp_model.py,sha256=ChprWTT6hLoKBM7iTVhQWQZYAXM_XOMHaK8PC8GEu30,12018
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tpc_keras.py,sha256=gMQ2qNm7T5FukkR_3DwVB1B41CMEW-KnrT-mPDMfCL8,6593
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tpc_pytorch.py,sha256=HRo0W5l4IJesr_np4ZhXoMk_xfdiV53LgamquQIryJA,5800
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tp_model.py,sha256=purcM7kLdh2HyJaxzROAoVSwz1Xlo6GPEe8JQKfMcuM,12911
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tpc_keras.py,sha256=x_-lIQJ_Cv546EmXblZA2xjvcw8Yo5xg_cy43mhqsh0,6803
+model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/tpc_pytorch.py,sha256=5Q54Qgi7_NTByRSJNVCfPUCJZ0lADT98UUZOhyHaV24,5986
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/__init__.py,sha256=C2kwyDE1-rtukkbNSoKRv9q8Nt2GOCaBbl0BdOr3goA,721
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tp_model.py,sha256=YANvT38YiwO9jE3dC04wHDZBGJQ34hGTvKygHwwbI_U,11751
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tpc_keras.py,sha256=XM6qBLIvzsmdFf-AZq5WOlORK2GXC_X-gulReNxHb9E,6601
 model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3_lut/tpc_pytorch.py,sha256=nP05jqvh6uaj30a3W7zEkJfKtqfP0Nz5bobwRqbYrdM,5807
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/__init__.py,sha256=tHTUvsaerSfbe22pU0kIDauPpFD7Pq5EmZytVIDkHz4,717
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tp_model.py,sha256=purcM7kLdh2HyJaxzROAoVSwz1Xlo6GPEe8JQKfMcuM,12911
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tpc_keras.py,sha256=j57CrY5w4Bxpwx35yi3pYJtLyDgq3YOq_crTmSKarUY,6803
-model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v4/tpc_pytorch.py,sha256=DVBWc_97B0s9PHHPYRoT5FFYs8tcGY7LC3GU1TqP88c,5986
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/target_platform_capabilities.py,sha256=is00rNrDmmirYsyMtMkWz0DwOA92-x7hAJwpd6z1n2E,2806
 model_compression_toolkit/target_platform_capabilities/tpc_models/qnnpack_tpc/latest/__init__.py,sha256=CXC-HQolSDu7j8V-Xm-SWGCd74gXB3XnAkEhI_TVbIQ,1516
@@ -531,8 +527,8 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=bOc-hFL3gdoSM1Th_S2N_-9JJSlPGpZCTx_QLJHS6lg,3388
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.1.0.20240821.444.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.1.0.20240821.444.dist-info/METADATA,sha256=CB9zxyzGHxt_fKfaVpEJ0av1kBt6yPEN3gTzefmGHHY,19718
-mct_nightly-2.1.0.20240821.444.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-mct_nightly-2.1.0.20240821.444.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.1.0.20240821.444.dist-info/RECORD,,
+mct_nightly-2.1.0.20240822.448.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.1.0.20240822.448.dist-info/METADATA,sha256=FKbBDaOPXg2CWXPUpwPKk3NdJCjcYm9xCOrPh5HPfWM,19718
+mct_nightly-2.1.0.20240822.448.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+mct_nightly-2.1.0.20240822.448.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.1.0.20240822.448.dist-info/RECORD,,

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.1.0.20240821.000444"
+__version__ = "2.1.0.20240822.000448"

model_compression_toolkit/core/runner.py

@@ -152,6 +152,12 @@ def core_runner(in_model: Any,
                 f'Mixed Precision has overwrite bit-width configuration{core_config.mixed_precision_config.configuration_overwrite}')
             bit_widths_config = core_config.mixed_precision_config.configuration_overwrite
 
+        if (target_resource_utilization.activation_memory < np.inf or
+                target_resource_utilization.total_memory < np.inf):
+            Logger.warning(
+                f"Running mixed precision for activation compression, please note this feature is experimental and is "
+                f"subject to future changes. If you encounter an issue, please open an issue in our GitHub "
+                f"project https://github.com/sony/model_optimization")
     else:
         bit_widths_config = []
 

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py

@@ -42,8 +42,6 @@ def get_tpc_dict_by_fw(fw_name):
                 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,
@@ -53,7 +51,6 @@ def get_tpc_dict_by_fw(fw_name):
                                '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:
         ###############################
@@ -76,8 +73,6 @@ def get_tpc_dict_by_fw(fw_name):
                 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,
@@ -87,7 +82,6 @@ def get_tpc_dict_by_fw(fw_name):
                                '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

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

@@ -167,6 +167,16 @@ def generate_tp_model(default_config: OpQuantizationConfig,
             weights_quantization_method=tp.QuantizationMethod.POWER_OF_TWO))
     const_configuration_options = tp.QuantizationConfigOptions([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 = tp.QuantizationConfigOptions([const_config_input16_output16,
+                                                                        const_config_input16],
+                                                                       base_config=const_config_input16)
+
     # 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):
@@ -186,8 +196,10 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # May suit for operations like: Dropout, Reshape, etc.
         default_qco = tp.get_default_quantization_config_options()
         tp.OperatorsSet("NoQuantization",
-                        default_qco.clone_and_edit(enable_activation_quantization=False)
+                        default_qco.clone_and_edit(enable_activation_quantization=False,
+                                                   supported_input_activation_n_bits=(8, 16))
                         .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+        tp.OperatorsSet("Default16BitInout", const_configuration_options_inout16)
 
         # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
         mixed_precision_configuration_options = tp.QuantizationConfigOptions(mixed_precision_cfg_list,
@@ -200,9 +212,9 @@ def generate_tp_model(default_config: OpQuantizationConfig,
         # Define operations sets without quantization configuration
         # options (useful for creating fusing patterns, for example):
         any_relu = tp.OperatorsSet("AnyReLU")
-        add = tp.OperatorsSet("Add", const_configuration_options)
-        sub = tp.OperatorsSet("Sub", const_configuration_options)
-        mul = tp.OperatorsSet("Mul", const_configuration_options)
+        add = tp.OperatorsSet("Add", const_configuration_options_inout16)
+        sub = tp.OperatorsSet("Sub", const_configuration_options_inout16)
+        mul = tp.OperatorsSet("Mul", const_configuration_options_inout16)
         div = tp.OperatorsSet("Div", const_configuration_options)
         prelu = tp.OperatorsSet("PReLU")
         swish = tp.OperatorsSet("Swish")

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

@@ -26,11 +26,11 @@ if FOUND_SONY_CUSTOM_LAYERS:
 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
+        Conv2DTranspose, Identity, Concatenate
 else:
     from keras.layers import Conv2D, DepthwiseConv2D, Dense, Reshape, ZeroPadding2D, Dropout, \
         MaxPooling2D, Activation, ReLU, Add, Subtract, Multiply, PReLU, Flatten, Cropping2D, LeakyReLU, Permute, \
-        Conv2DTranspose, Identity
+        Conv2DTranspose, Identity, Concatenate
 
 from model_compression_toolkit.target_platform_capabilities.tpc_models.imx500_tpc.v3.tp_model import get_tp_model
 import model_compression_toolkit as mct
@@ -84,6 +84,7 @@ def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
                      tf.compat.v1.gather,
                      tf.nn.top_k,
                      tf.__operators__.getitem,
+                     tf.strided_slice,
                      tf.image.combined_non_max_suppression,
                      tf.compat.v1.shape]
 
@@ -92,6 +93,8 @@ def generate_keras_tpc(name: str, tp_model: tp.TargetPlatformModel):
 
     with keras_tpc:
         tp.OperationsSetToLayers("NoQuantization", no_quant_list)
+        tp.OperationsSetToLayers("Default16BitInout", [tf.stack,
+                                                       tf.concat, Concatenate])
         tp.OperationsSetToLayers("Conv",
                                  [Conv2D,
                                   DepthwiseConv2D,

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

@@ -17,7 +17,7 @@ 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
+    gather, equal, transpose, permute, argmax, squeeze, multiply, subtract
 from torch.nn import Conv2d, Linear, ConvTranspose2d, MaxPool2d
 from torch.nn import Dropout, Flatten, Hardtanh, Identity
 from torch.nn import ReLU, ReLU6, PReLU, SiLU, Sigmoid, Tanh, Hardswish, LeakyReLU
@@ -85,6 +85,8 @@ def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
                                                     topk,
                                                     squeeze,
                                                     MaxPool2d])
+        tp.OperationsSetToLayers("Default16BitInout",
+                                 [torch.stack, torch.cat, torch.concat, torch.concatenate])
 
         tp.OperationsSetToLayers("Conv", [Conv2d, ConvTranspose2d],
                                  attr_mapping=pytorch_linear_attr_mapping)
@@ -101,8 +103,8 @@ def generate_pytorch_tpc(name: str, tp_model: tp.TargetPlatformModel):
                                              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("Sub", [operator.sub, sub, subtract])
+        tp.OperationsSetToLayers("Mul", [operator.mul, mul, multiply])
         tp.OperationsSetToLayers("Div", [operator.truediv, div])
         tp.OperationsSetToLayers("PReLU", [PReLU, prelu])
         tp.OperationsSetToLayers("Swish", [SiLU, silu, Hardswish, hardswish])

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

@@ -1,16 +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.
-# ==============================================================================
-
-__version__ = 'v4'

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

@@ -1,238 +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
-from model_compression_toolkit.constants import FLOAT_BITWIDTH
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR, WEIGHTS_N_BITS
-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 \
-    AttributeQuantizationConfig
-
-tp = mct.target_platform
-
-
-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 = tp.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 = tp.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 = tp.QuantizationConfigOptions([default_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 = tp.QuantizationConfigOptions([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 = tp.QuantizationConfigOptions([const_config_input16_output16,
-                                                                        const_config_input16],
-                                                                       base_config=const_config_input16)
-
-    # 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 = tp.TargetPlatformModel(default_configuration_options, add_metadata=True, 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_tpm:
-        # 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):
-
-        generated_tpm.set_simd_padding(is_simd_padding=True)
-
-        # May suit for operations like: Dropout, Reshape, etc.
-        default_qco = tp.get_default_quantization_config_options()
-        tp.OperatorsSet("NoQuantization",
-                        default_qco.clone_and_edit(enable_activation_quantization=False,
-                                                   supported_input_activation_n_bits=(8, 16))
-                        .clone_and_edit_weight_attribute(enable_weights_quantization=False))
-        tp.OperatorsSet("Default16BitInout", const_configuration_options_inout16)
-
-        # Create Mixed-Precision quantization configuration options from the given list of OpQuantizationConfig objects
-        mixed_precision_configuration_options = tp.QuantizationConfigOptions(mixed_precision_cfg_list,
-                                                                             base_config=base_config)
-
-        # Define operator sets that use mixed_precision_configuration_options:
-        conv = tp.OperatorsSet("Conv", mixed_precision_configuration_options)
-        fc = tp.OperatorsSet("FullyConnected", mixed_precision_configuration_options)
-
-        # Define operations sets without quantization configuration
-        # options (useful for creating fusing patterns, for example):
-        any_relu = tp.OperatorsSet("AnyReLU")
-        add = tp.OperatorsSet("Add", const_configuration_options_inout16)
-        sub = tp.OperatorsSet("Sub", const_configuration_options_inout16)
-        mul = tp.OperatorsSet("Mul", const_configuration_options_inout16)
-        div = tp.OperatorsSet("Div", const_configuration_options)
-        prelu = tp.OperatorsSet("PReLU")
-        swish = tp.OperatorsSet("Swish")
-        sigmoid = tp.OperatorsSet("Sigmoid")
-        tanh = tp.OperatorsSet("Tanh")
-
-        # 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 = tp.OperatorSetConcat(any_relu, swish, prelu, sigmoid, tanh)
-        activations_after_fc_to_fuse = tp.OperatorSetConcat(any_relu, swish, sigmoid)
-        any_binary = tp.OperatorSetConcat(add, sub, mul, div)
-
-        # ------------------- #
-        # Fusions
-        # ------------------- #
-        tp.Fusing([conv, activations_after_conv_to_fuse])
-        tp.Fusing([fc, activations_after_fc_to_fuse])
-        tp.Fusing([any_binary, any_relu])
-
-    return generated_tpm

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

@@ -1,134 +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
-
-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
-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
-
-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
-
-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: tp.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, name=name, version=TPC_VERSION)
-
-    no_quant_list = [Identity,
-                     tf.identity,
-                     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.strided_slice,
-                     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("Default16BitInout", [tf.stack,
-                                                       tf.concat, Concatenate])
-        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, tf.math.truediv])
-        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/v4/tpc_pytorch.py

@@ -1,114 +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, flatten, reshape, split, unsqueeze, dropout, sigmoid, tanh, chunk, unbind, topk, \
-    gather, equal, transpose, permute, argmax, squeeze, multiply, subtract
-from torch.nn import Conv2d, Linear, ConvTranspose2d, MaxPool2d
-from torch.nn import Dropout, Flatten, Hardtanh, Identity
-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.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
-
-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: tp.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,
-                                                name=name,
-                                                version=TPC_VERSION)
-
-    # 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", [Identity,
-                                                    Dropout,
-                                                    Flatten,
-                                                    dropout,
-                                                    flatten,
-                                                    split,
-                                                    operator.getitem,
-                                                    reshape,
-                                                    unsqueeze,
-                                                    chunk,
-                                                    unbind,
-                                                    torch.Tensor.size,
-                                                    permute,
-                                                    transpose,
-                                                    equal,
-                                                    argmax,
-                                                    gather,
-                                                    topk,
-                                                    squeeze,
-                                                    MaxPool2d])
-        tp.OperationsSetToLayers("Default16BitInout",
-                                 [torch.stack, torch.cat, torch.concat, torch.concatenate])
-
-        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, subtract])
-        tp.OperationsSetToLayers("Mul", [operator.mul, mul, multiply])
-        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