mct-nightly 2.1.0.20240801.515__py3-none-any.whl → 2.1.0.20240803.442__py3-none-any.whl

model_compression_toolkit/core/common/quantization/quantization_params_generation/symmetric_selection.py

@@ -16,7 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES
+from model_compression_toolkit.constants import MIN_THRESHOLD, THRESHOLD, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.error_functions import \
     get_threshold_selection_tensor_error_function, get_threshold_selection_histogram_error_function, _kl_error_histogram
@@ -106,7 +106,8 @@ def symmetric_selection_histogram(bins: np.ndarray,
                                   constrained: bool = True,
                                   n_iter: int = 20,
                                   min_threshold: float = MIN_THRESHOLD,
-                                  quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> dict:
+                                  quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                                  is_signed: bool = None) -> Dict:
     """
     Compute the optimal threshold based on the provided QuantizationErrorMethod to quantize a histogram.
     Different search is applied, depends on the value of the selected QuantizationErrorMethod.
@@ -122,6 +123,7 @@ def symmetric_selection_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small (used only for kl threshold selection).
         quant_error_method: an error function to optimize the parameters' selection accordingly.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimal threshold to quantize the histogram a symmetric manner.
@@ -129,23 +131,27 @@ def symmetric_selection_histogram(bins: np.ndarray,
     tensor_max = np.max(np.abs(bins)[1:][counts > 0])
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
         threshold = get_init_threshold(min_threshold, tensor_max)
+        # Resolve is_signed in case it is None.
+        signed = (bins<0).any() if is_signed is None else is_signed
     elif quant_error_method == qc.QuantizationErrorMethod.KL:
         # search for KL error is separated because the error method signature is different from the other error methods.
-        threshold = kl_qparams_symmetric_selection_histogram_search(_kl_error_histogram,
-                                                                    tensor_max,
-                                                                    bins,
-                                                                    counts,
-                                                                    n_bits,
-                                                                    min_threshold=min_threshold)
+        threshold, signed = kl_qparams_symmetric_selection_histogram_search(_kl_error_histogram,
+                                                                            tensor_max,
+                                                                            bins,
+                                                                            counts,
+                                                                            n_bits,
+                                                                            min_threshold=min_threshold,
+                                                                            is_signed=is_signed)
     else:
         error_function = get_threshold_selection_histogram_error_function(QuantizationMethod.SYMMETRIC, quant_error_method, p)
-        threshold = qparams_symmetric_selection_histogram_search(error_function,
-                                                                 tensor_max,
-                                                                 bins,
-                                                                 counts,
-                                                                 n_bits,
-                                                                 min_threshold=min_threshold)
-    return {THRESHOLD: threshold}
+        threshold, signed = qparams_symmetric_selection_histogram_search(error_function,
+                                                                         tensor_max,
+                                                                         bins,
+                                                                         counts,
+                                                                         n_bits,
+                                                                         min_threshold=min_threshold,
+                                                                         is_signed=is_signed)
+    return {THRESHOLD: threshold, SIGNED: signed}
 
 
 def symmetric_no_clipping_selection_min_max(bins: np.ndarray,
@@ -158,7 +164,8 @@ def symmetric_no_clipping_selection_min_max(bins: np.ndarray,
                                             n_iter: int = 20,
                                             min_threshold: float = MIN_THRESHOLD,
                                             quant_error_method: qc.QuantizationErrorMethod =
-                                            qc.QuantizationErrorMethod.NOCLIPPING) -> dict:
+                                            qc.QuantizationErrorMethod.NOCLIPPING,
+                                            is_signed: bool = None) -> Dict:
     """
     Gets a threshold between min and max numbers.
     If computed threshold is less than min_threshold, min_threshold is returned.
@@ -175,7 +182,8 @@ def symmetric_no_clipping_selection_min_max(bins: np.ndarray,
                                          constrained,
                                          n_iter,
                                          min_threshold=min_threshold,
-                                         quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING)
+                                         quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING,
+                                         is_signed=is_signed)
 
 
 def get_init_threshold(min_threshold: float, tensor_max: np.ndarray, per_channel: bool = False) -> np.ndarray:

model_compression_toolkit/core/common/quantization/quantization_params_generation/uniform_selection.py

@@ -16,7 +16,7 @@ import numpy as np
 from typing import Union, Tuple, Dict
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import MIN_THRESHOLD, RANGE_MIN, RANGE_MAX, NUM_QPARAM_HESSIAN_SAMPLES
+from model_compression_toolkit.constants import MIN_THRESHOLD, RANGE_MIN, RANGE_MAX, NUM_QPARAM_HESSIAN_SAMPLES, SIGNED
 from model_compression_toolkit.core.common.hessian import HessianInfoService
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.qparams_search import \
     qparams_uniform_selection_tensor_search, qparams_uniform_selection_histogram_search
@@ -114,7 +114,8 @@ def uniform_selection_histogram(bins: np.ndarray,
                                 constrained: bool = True,
                                 n_iter: int = 20,
                                 min_threshold: float = MIN_THRESHOLD,
-                                quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE) -> dict:
+                                quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
+                                is_signed: bool = None) -> Dict:
     """
     Compute the optimal quantization range based on the provided QuantizationErrorMethod
     to uniformly quantize the histogram.
@@ -131,6 +132,7 @@ def uniform_selection_histogram(bins: np.ndarray,
         n_iter: Number of iteration ot search for the threshold (not used for this method).
         min_threshold: Minimal threshold to use if threshold is too small (not used for this method).
         quant_error_method: an error function to optimize the range parameters selection accordingly.
+        is_signed: Whether the quantization is signed or not. If None then compute SIGNED value.
 
     Returns:
         Optimal quantization range to quantize the histogram uniformly.
@@ -139,6 +141,7 @@ def uniform_selection_histogram(bins: np.ndarray,
     tensor_max = np.max(bins[1:][counts > 0])
     tensor_min_max = np.array([tensor_min, tensor_max])
 
+    signed = tensor_min < 0 if is_signed is None else is_signed
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
         mm = tensor_min_max
     else:
@@ -150,7 +153,7 @@ def uniform_selection_histogram(bins: np.ndarray,
                                                         n_bits)
 
     return {RANGE_MIN: mm[0],
-            RANGE_MAX: mm[1]}
+            RANGE_MAX: mm[1], SIGNED: signed}
 
 
 def uniform_no_clipping_selection_min_max(bins: np.ndarray,
@@ -163,7 +166,8 @@ def uniform_no_clipping_selection_min_max(bins: np.ndarray,
                                           n_iter: int = 20,
                                           min_threshold: float = MIN_THRESHOLD,
                                           quant_error_method: qc.QuantizationErrorMethod =
-                                          qc.QuantizationErrorMethod.NOCLIPPING) -> dict:
+                                          qc.QuantizationErrorMethod.NOCLIPPING,
+                                          is_signed: bool = None) -> Dict:
     """
     Gets a quantization rage between min and max numbers.
 
@@ -179,5 +183,5 @@ def uniform_no_clipping_selection_min_max(bins: np.ndarray,
                                        constrained,
                                        n_iter,
                                        min_threshold=min_threshold,
-                                       quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING)
-
+                                       quant_error_method=qc.QuantizationErrorMethod.NOCLIPPING,
+                                       is_signed=is_signed)

model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -64,6 +64,7 @@ def set_quantization_configuration_to_graph(graph: Graph,
 
     for n in graph.nodes:
         set_quantization_configs_to_node(node=n,
+                                         graph=graph,
                                          quant_config=quant_config,
                                          fw_info=graph.fw_info,
                                          tpc=graph.tpc,
@@ -72,6 +73,7 @@ def set_quantization_configuration_to_graph(graph: Graph,
 
 
 def set_quantization_configs_to_node(node: BaseNode,
+                                     graph: Graph,
                                      quant_config: QuantizationConfig,
                                      fw_info: FrameworkInfo,
                                      tpc: TargetPlatformCapabilities,
@@ -81,19 +83,22 @@ def set_quantization_configs_to_node(node: BaseNode,
 
     Args:
         node: Node to set its quantization configurations.
+        graph: Model's internal representation graph.
         quant_config: Quantization configuration to generate the node's configurations from.
         fw_info: Information needed for quantization about the specific framework.
         tpc: TargetPlatformCapabilities to get default OpQuantizationConfig.
         mixed_precision_enable: is mixed precision enabled.
     """
     node_qc_options = node.get_qco(tpc)
+    base_config, node_qc_options_list = node.filter_node_qco_by_graph(tpc, graph.get_next_nodes(node), node_qc_options)
 
     # Create QC candidates for weights and activation combined
     weight_channel_axis = fw_info.kernel_channels_mapping.get(node.type)
     node.candidates_quantization_cfg = _create_node_candidates_qc(quant_config,
                                                                   fw_info,
                                                                   weight_channel_axis,
-                                                                  node_qc_options,
+                                                                  node_qc_options_list,
+                                                                  base_config,
                                                                   node,
                                                                   mixed_precision_enable=mixed_precision_enable)
 
@@ -186,7 +191,8 @@ def _create_node_single_candidate_qc(qc: QuantizationConfig,
 def _create_node_candidates_qc(qc: QuantizationConfig,
                                fw_info: FrameworkInfo,
                                weight_channel_axis: Tuple[int, int],
-                               node_qc_options: QuantizationConfigOptions,
+                               node_qc_options_list: List[OpQuantizationConfig],
+                               base_config: OpQuantizationConfig,
                                node: BaseNode,
                                mixed_precision_enable: bool = False) -> List[CandidateNodeQuantizationConfig]:
     """
@@ -196,7 +202,8 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
         qc: Quantization configuration the quantization process should follow.
         fw_info: Framework information (e.g., which layers should have their kernels' quantized).
         weight_channel_axis: (Output, Input) channel index of the node's kernel.
-        node_qc_options: QuantizationConfigOptions for the node with quantization candidates information.
+        node_qc_options_list: List of quantization configs of node.
+        base_config: Base quantization config for node.
         node: A node to set quantization configuration candidates to.
         mixed_precision_enable: is mixed precision enabled
 
@@ -208,7 +215,7 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
     node_attrs_list = node.get_node_weights_attributes()
 
     if mixed_precision_enable:
-        for op_cfg in node_qc_options.quantization_config_list:
+        for op_cfg in node_qc_options_list:
             candidate_qc = copy.deepcopy(qc)
             candidates.append(_create_node_single_candidate_qc(candidate_qc,
                                                                fw_info,
@@ -220,7 +227,7 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
         candidates.append(_create_node_single_candidate_qc(qc,
                                                            fw_info,
                                                            weight_channel_axis,
-                                                           node_qc_options.base_config,
+                                                           base_config,
                                                            node_attrs_list))
 
     return candidates

model_compression_toolkit/core/common/substitutions/shift_negative_activation.py

@@ -349,9 +349,15 @@ def shift_negative_function(graph: Graph,
                                    add_node.output_shape,
                                    pad_top, pad_btm, pad_left, pad_right)
 
+        # Insert a pad node between the add node to the op2d, and create statistics for the pad node
+        insert_node_before_node(graph,
+                                node_to_insert=pad_node,
+                                last_node=op2d_node)
+
         # Set quantization configuration to node, even though we do not quantize it:
         set_quantization_configs_to_node(fw_info=fw_info,
                                          node=pad_node,
+                                         graph=graph,
                                          quant_config=core_config.quantization_config,
                                          tpc=graph.tpc,
                                          mixed_precision_enable=core_config.mixed_precision_enable)
@@ -361,11 +367,6 @@ def shift_negative_function(graph: Graph,
             for attr in pad_node.get_node_weights_attributes():
                 candidate_qc.weights_quantization_cfg.get_attr_config(attr).enable_weights_quantization = False
 
-        # Insert a pad node between the add node to the op2d, and create statistics for the pad node
-        insert_node_before_node(graph,
-                                node_to_insert=pad_node,
-                                last_node=op2d_node)
-
         graph.set_out_stats_collector_to_node(pad_node,
                                               add_node_stats_collector)  # We ignore the padding effect on statistics
 
@@ -373,6 +374,7 @@ def shift_negative_function(graph: Graph,
 
     set_quantization_configs_to_node(fw_info=fw_info,
                                      node=add_node,
+                                     graph=graph,
                                      quant_config=core_config.quantization_config,
                                      tpc=graph.tpc,
                                      mixed_precision_enable=core_config.mixed_precision_enable)

model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 
 import copy
-from typing import List, Dict, Union, Any
+from typing import List, Dict, Union, Any, Tuple
 
 from mct_quantizers import QuantizationMethod
 from model_compression_toolkit.constants import FLOAT_BITWIDTH
@@ -114,11 +114,13 @@ class OpQuantizationConfig:
                  attr_weights_configs_mapping: Dict[str, AttributeQuantizationConfig],
                  activation_quantization_method: QuantizationMethod,
                  activation_n_bits: int,
+                 supported_input_activation_n_bits: Union[int, Tuple[int]],
                  enable_activation_quantization: bool,
                  quantization_preserving: bool,
                  fixed_scale: float,
                  fixed_zero_point: int,
-                 simd_size: int
+                 simd_size: int,
+                 is_signed: bool = None
                  ):
         """
 
@@ -127,10 +129,12 @@ class OpQuantizationConfig:
             attr_weights_configs_mapping (Dict[str, AttributeQuantizationConfig]): A mapping between an op attribute name and its quantization configuration.
             activation_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for activation quantization.
             activation_n_bits (int): Number of bits to quantize the activations.
+            supported_input_activation_n_bits (int or Tuple[int]): Number of bits that operator accepts as input.
             enable_activation_quantization (bool): Whether to quantize the model activations or not.
             quantization_preserving (bool): Whether quantization parameters should be the same for an operator's input and output.
             fixed_scale (float): Scale to use for an operator quantization parameters.
             fixed_zero_point (int): Zero-point to use for an operator quantization parameters.
+            is_signed (bool): Force activation quantization signedness (None means don't force).
             simd_size (int): Per op integer representing the Single Instruction, Multiple Data (SIMD) width of an operator. It indicates the number of data elements that can be fetched and processed simultaneously in a single instruction.
 
         """
@@ -140,10 +144,17 @@ class OpQuantizationConfig:
 
         self.activation_quantization_method = activation_quantization_method
         self.activation_n_bits = activation_n_bits
+        if isinstance(supported_input_activation_n_bits, tuple):
+            self.supported_input_activation_n_bits = supported_input_activation_n_bits
+        elif isinstance(supported_input_activation_n_bits, int):
+            self.supported_input_activation_n_bits = (supported_input_activation_n_bits,)
+        else:
+            Logger.critical(f"Supported_input_activation_n_bits only accepts int or tuple of ints, but got {type(supported_input_activation_n_bits)}")  # pragma: no cover
         self.enable_activation_quantization = enable_activation_quantization
         self.quantization_preserving = quantization_preserving
         self.fixed_scale = fixed_scale
         self.fixed_zero_point = fixed_zero_point
+        self.is_signed = is_signed
         self.simd_size = simd_size
 
     def get_info(self):
@@ -193,9 +204,21 @@ class OpQuantizationConfig:
             self.attr_weights_configs_mapping == other.attr_weights_configs_mapping and \
             self.activation_quantization_method == other.activation_quantization_method and \
             self.activation_n_bits == other.activation_n_bits and \
+            self.supported_input_activation_n_bits == other.supported_input_activation_n_bits and \
             self.enable_activation_quantization == other.enable_activation_quantization and \
+            self.is_signed == other.is_signed and \
             self.simd_size == other.simd_size
 
+    @property
+    def max_input_activation_n_bits(self) -> int:
+        """
+        Get maximum supported input bit-width.
+
+        Returns: Maximum supported input bit-width.
+
+        """
+        return max(self.supported_input_activation_n_bits)
+
 
 class QuantizationConfigOptions:
     """

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py

@@ -29,6 +29,7 @@ if FOUND_TF:
     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
     keras_tpc_models_dict = {'v1': get_keras_tpc_v1,
@@ -38,6 +39,7 @@ if FOUND_TF:
                              '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}
 
 ###############################
@@ -60,6 +62,8 @@ if FOUND_TORCH:
         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
     pytorch_tpc_models_dict = {'v1': get_pytorch_tpc_v1,
@@ -69,6 +73,7 @@ if FOUND_TORCH:
                                '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}
 
 tpc_dict = {TENSORFLOW: keras_tpc_models_dict,

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

@@ -93,6 +93,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         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,
@@ -105,6 +106,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         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,

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

@@ -89,6 +89,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         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,
@@ -101,6 +102,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         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,

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

@@ -89,6 +89,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         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,
@@ -101,6 +102,7 @@ def get_op_quantization_configs() -> Tuple[OpQuantizationConfig, List[OpQuantiza
         default_weight_attr_config=default_weight_attr_config,
         attr_weights_configs_mapping={KERNEL_ATTR: kernel_base_config, BIAS_ATTR: bias_config},
         activation_n_bits=8,
+        supported_input_activation_n_bits=8,
         enable_activation_quantization=True,
         quantization_preserving=False,
         fixed_scale=None,

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

@@ -95,6 +95,7 @@ def get_op_quantization_configs() -> \
         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,
@@ -107,6 +108,7 @@ def get_op_quantization_configs() -> \
         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,

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

@@ -91,6 +91,7 @@ def get_op_quantization_configs() -> \
         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,
@@ -103,6 +104,7 @@ def get_op_quantization_configs() -> \
         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,

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

@@ -95,6 +95,7 @@ def get_op_quantization_configs() -> \
         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,
@@ -107,6 +108,7 @@ def get_op_quantization_configs() -> \
         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,

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

@@ -91,6 +91,7 @@ def get_op_quantization_configs() -> \
         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,
@@ -103,6 +104,7 @@ def get_op_quantization_configs() -> \
         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,

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

@@ -0,0 +1,16 @@
+# 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'