mct-nightly 2.1.0.20240608.434__py3-none-any.whl → 2.1.0.20240610.442__py3-none-any.whl

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

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-from typing import Dict, Any
+from typing import Dict, Any, Tuple
 
 import numpy as np
 
@@ -34,7 +34,7 @@ def get_weights_qparams(weights_attr_values: np.ndarray,
                         output_channels_axis: int,
                         node=None,
                         hessian_info_service: HessianInfoService = None,
-                        num_hessian_samples: int = NUM_QPARAM_HESSIAN_SAMPLES) -> Dict[Any, Any]:
+                        num_hessian_samples: int = NUM_QPARAM_HESSIAN_SAMPLES) -> Tuple[Dict[Any, Any], int]:
     """
     Compute thresholds to quantize a kernel according to a NodeWeightsQuantizationConfig
     instance.
@@ -50,22 +50,24 @@ def get_weights_qparams(weights_attr_values: np.ndarray,
 
     Returns:
         A dictionary with the quantization threshold of the kernel.
+        Selected quantization channel axis.
     """
     if attr_quant_config.weights_quantization_params_fn is not None:
-        weights_params = attr_quant_config.weights_quantization_params_fn(weights_attr_values,
-                                                                          p=attr_quant_config.l_p_value,
-                                                                          n_bits=attr_quant_config.weights_n_bits,
-                                                                          per_channel=attr_quant_config.weights_per_channel_threshold and output_channels_axis is not None,
-                                                                          channel_axis=output_channels_axis,
-                                                                          min_threshold=weights_quant_config.min_threshold,
-                                                                          quant_error_method=attr_quant_config.weights_error_method,
-                                                                          node=node,
-                                                                          hessian_info_service=hessian_info_service,
-                                                                          num_hessian_samples=num_hessian_samples)
+        weights_params, output_channels_axis = attr_quant_config.weights_quantization_params_fn(
+            weights_attr_values,
+            p=attr_quant_config.l_p_value,
+            n_bits=attr_quant_config.weights_n_bits,
+            per_channel=attr_quant_config.weights_per_channel_threshold,
+            channel_axis=output_channels_axis,
+            min_threshold=weights_quant_config.min_threshold,
+            quant_error_method=attr_quant_config.weights_error_method,
+            node=node,
+            hessian_info_service=hessian_info_service,
+            num_hessian_samples=num_hessian_samples)
     else:
         weights_params = {}
 
-    return weights_params
+    return weights_params, output_channels_axis
 
 
 def _get_kernel_channels_mapping(fw_info:FrameworkInfo,

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

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 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
@@ -25,6 +26,8 @@ from model_compression_toolkit.core.common.quantization.quantization_params_gene
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import \
     get_tensor_max
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from model_compression_toolkit.core.common.similarity_analyzer import compute_mse
+from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import quantize_tensor
 
 
 def symmetric_selection_tensor(tensor_data: np.ndarray,
@@ -37,7 +40,8 @@ def symmetric_selection_tensor(tensor_data: np.ndarray,
                                quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
                                node=None,
                                hessian_info_service: HessianInfoService = None,
-                               num_hessian_samples: int = NUM_QPARAM_HESSIAN_SAMPLES) -> dict:
+                               num_hessian_samples: int = NUM_QPARAM_HESSIAN_SAMPLES,
+                               ) -> Tuple[Dict[str, np.ndarray], int]:
     """
     Compute the optimal threshold based on the provided QuantizationErrorMethod to quantize the tensor.
     Different search is applied, depends on the value of the selected QuantizationErrorMethod.
@@ -47,7 +51,7 @@ def symmetric_selection_tensor(tensor_data: np.ndarray,
         p: p-norm to use for the Lp-norm distance.
         n_bits: Number of bits to quantize the tensor.
         per_channel: Whether the quantization should be per-channel or not.
-        channel_axis: Output channel index.
+        channel_axis: Output channel index. if None, search for best axis.
         n_iter: Number of iterations to search for the optimal 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 parameters' selection accordingly.
@@ -57,12 +61,24 @@ def symmetric_selection_tensor(tensor_data: np.ndarray,
 
     Returns:
         Optimal threshold to quantize the tensor in a symmetric manner.
+        Selected quantization channel axis.
     """
 
-    tensor_max = get_tensor_max(tensor_data, per_channel, channel_axis, n_bits)
-
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
-        threshold = get_init_threshold(min_threshold, tensor_max, per_channel)
+        if channel_axis is None and per_channel:
+            total_error_list = []
+            th_list = []
+            for _axis in range(len(tensor_data.shape)):
+                tensor_max = get_tensor_max(tensor_data, per_channel, _axis, n_bits)
+                threshold = get_init_threshold(min_threshold, tensor_max, per_channel)
+                q_tensor_data = quantize_tensor(tensor_data, threshold, n_bits, True)
+                total_error_list.append(compute_mse(tensor_data, q_tensor_data, norm=True))
+                th_list.append(threshold)
+            channel_axis = np.argmin(total_error_list)
+            threshold = th_list[channel_axis]
+        else:
+            tensor_max = get_tensor_max(tensor_data, per_channel, channel_axis, n_bits)
+            threshold = get_init_threshold(min_threshold, tensor_max, per_channel)
     else:
         signed = True  # weights are always signed
         axis = -1 if per_channel else None
@@ -71,15 +87,14 @@ def symmetric_selection_tensor(tensor_data: np.ndarray,
                                                                        signed=signed, node=node,
                                                                        hessian_info_service=hessian_info_service,
                                                                        num_hessian_samples=num_hessian_samples)
-        threshold = qparams_symmetric_selection_tensor_search(error_function,
-                                                              tensor_data,
-                                                              tensor_max,
-                                                              n_bits,
-                                                              per_channel,
-                                                              channel_axis,
-                                                              min_threshold=min_threshold,
-                                                              signed=signed)
-    return {THRESHOLD: threshold}
+        threshold, channel_axis = qparams_symmetric_selection_tensor_search(error_function,
+                                                                            tensor_data,
+                                                                            n_bits,
+                                                                            per_channel,
+                                                                            channel_axis,
+                                                                            min_threshold=min_threshold,
+                                                                            signed=signed)
+    return {THRESHOLD: threshold}, channel_axis
 
 
 def symmetric_selection_histogram(bins: np.ndarray,

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

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 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
@@ -24,6 +25,9 @@ from model_compression_toolkit.core.common.quantization.quantization_params_gene
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import get_tensor_max, \
     get_tensor_min
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
+from model_compression_toolkit.core.common.similarity_analyzer import compute_mse
+from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import uniform_quantize_tensor
+
 
 def uniform_selection_tensor(tensor_data: np.ndarray,
                              p: int,
@@ -35,7 +39,8 @@ def uniform_selection_tensor(tensor_data: np.ndarray,
                              quant_error_method: qc.QuantizationErrorMethod = qc.QuantizationErrorMethod.MSE,
                              node=None,
                              hessian_info_service: HessianInfoService = None,
-                             num_hessian_samples: int = NUM_QPARAM_HESSIAN_SAMPLES) -> dict:
+                             num_hessian_samples: int = NUM_QPARAM_HESSIAN_SAMPLES,
+                             ) -> Tuple[Dict[str, np.ndarray], int]:
     """
     Compute the optimal quantization range based on the provided QuantizationErrorMethod
     to uniformly quantize the tensor.
@@ -46,7 +51,7 @@ def uniform_selection_tensor(tensor_data: np.ndarray,
         p: p-norm to use for the Lp-norm distance.
         n_bits: Number of bits to quantize the tensor.
         per_channel: Whether the quantization should be per-channel or not.
-        channel_axis: Output channel index.
+        channel_axis: Output channel index. if None, search for best axis.
         n_iter: Number of iterations to search for the optimal 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.
@@ -56,27 +61,48 @@ def uniform_selection_tensor(tensor_data: np.ndarray,
 
     Returns:
         Optimal quantization range to quantize the tensor uniformly.
+        Selected quantization channel axis.
     """
-    tensor_min = get_tensor_min(tensor_data, per_channel, channel_axis)
-    tensor_max = get_tensor_max(tensor_data, per_channel, channel_axis, n_bits, is_uniform_quantization=True)
-
     if quant_error_method == qc.QuantizationErrorMethod.NOCLIPPING:
-        mm = tensor_min, tensor_max
+        if channel_axis is None and per_channel:
+            total_error_list = []
+            th_list = []
+            for _axis in range(len(tensor_data.shape)):
+                tensor_min = get_tensor_min(tensor_data, per_channel, _axis)
+                tensor_max = get_tensor_max(tensor_data, per_channel, _axis, n_bits, is_uniform_quantization=True)
+                q_tensor_data = uniform_quantize_tensor(tensor_data, tensor_min, tensor_max, n_bits)
+                total_error_list.append(compute_mse(tensor_data, q_tensor_data, norm=True))
+                th_list.append((tensor_min, tensor_max))
+            channel_axis = np.argmin(total_error_list)
+            mm = th_list[channel_axis]
+        else:
+            tensor_min = get_tensor_min(tensor_data, per_channel, channel_axis)
+            tensor_max = get_tensor_max(tensor_data, per_channel, channel_axis, n_bits, is_uniform_quantization=True)
+            mm = tensor_min, tensor_max
     else:
         axis = -1 if per_channel else None
         error_function = get_threshold_selection_tensor_error_function(QuantizationMethod.UNIFORM, quant_error_method,
                                                                        p, axis=axis, norm=False, node=node,
                                                                        hessian_info_service=hessian_info_service,
                                                                        num_hessian_samples=num_hessian_samples)
-        mm = qparams_uniform_selection_tensor_search(error_function,
-                                                     tensor_data,
-                                                     tensor_min,
-                                                     tensor_max,
-                                                     n_bits,
-                                                     per_channel,
-                                                     channel_axis)
+        mm, channel_axis = qparams_uniform_selection_tensor_search(error_function,
+                                                                   tensor_data,
+                                                                   n_bits,
+                                                                   per_channel,
+                                                                   channel_axis)
+    # In case the tensor\axis has a single value, then min==max, so need to adjust either min or max to zero.
+    if not isinstance(mm[0], np.ndarray):
+        if mm[0] > 0:
+            mm = (np.float32(0).astype(mm[0].dtype), mm[1])
+        if mm[1] < 0:
+            mm = (mm[0], np.float32(0).astype(mm[1].dtype))
+    else:
+        adj_min_to_zero = np.logical_and(mm[1] == mm[0], mm[0] > 0)
+        adj_max_to_zero = np.logical_and(mm[1] == mm[0], mm[1] < 0)
+        mm[0][adj_min_to_zero] = 0
+        mm[1][adj_max_to_zero] = 0
     return {RANGE_MIN: mm[0],
-            RANGE_MAX: mm[1]}
+            RANGE_MAX: mm[1]}, channel_axis
 
 
 def uniform_selection_histogram(bins: np.ndarray,

model_compression_toolkit/core/keras/reader/node_builder.py

@@ -158,7 +158,8 @@ def build_node(node: KerasNode,
             if is_const(arg) or (
                     keras_layer.symbol in tf_function_symbols and
                     isinstance(arg, (tuple, list))):
-                weights.update({i: to_numpy(arg, is_single_tensor=True)})
+                if inputs_as_list or i in kwarg2index.values():
+                    weights.update({i: to_numpy(arg, is_single_tensor=True)})
         # remove weights and KerasTensors and weights from op_call_args
         if inputs_as_list:
             op_call_args = tuple(op_call_args[1:])
@@ -169,8 +170,7 @@ def build_node(node: KerasNode,
         # read weights from call kwargs
         weight_keys = []
         for k, v in op_call_kwargs.items():
-            if is_const(v) or (keras_layer.function in [tf.add, tf.multiply, tf.subtract, tf.divide, tf.truediv, tf.pow,
-                                                        tf.matmul] and
+            if is_const(v) or (keras_layer.symbol in tf_function_symbols and
                                isinstance(v, (tuple, list))):
                 if k in kwarg2index:
                     weights.update({kwarg2index[k]: to_numpy(v, is_single_tensor=True)})

model_compression_toolkit/core/pytorch/back2framework/pytorch_model_builder.py

@@ -39,20 +39,16 @@ from mct_quantizers import PytorchQuantizationWrapper
 def _build_input_tensors_list(node: BaseNode,
                               graph: Graph,
                               inputs: Tuple[Any],
-                              node_to_output_tensors_dict: Dict[BaseNode, List],
-                              is_op_quantize_wrapper: bool) -> List[List]:
+                              node_to_output_tensors_dict: Dict[BaseNode, List]) -> List[List]:
     """
     Given a node, build a list of input tensors the node gets. The list is built based on the
-    node's incoming edges, previous nodes' output tensors and the node's positional weights.
-    Positional weights aren't used if the node's op is PytorchQuantizationWrapper, since it's
-    positional weights are already in the wrapper.
+    node's incoming edges, previous nodes' output tensors.
 
     Args:
         node: Node to build its input tensors list.
         graph: Graph the node is in.
         inputs: list of input tensors to model.
         node_to_output_tensors_dict: A dictionary from a node to its output tensors.
-        is_op_quantize_wrapper: Whether the func_op is a PytorchQuantizationWrapper or not.
 
     Returns:
         A list of the node's input tensors.
@@ -67,35 +63,30 @@ def _build_input_tensors_list(node: BaseNode,
             _input_tensors = node_to_output_tensors_dict[ie.source_node]
             input_tensors.append(_input_tensors)
         input_tensors = [tensor for tensor_list in input_tensors for tensor in tensor_list]  # flat list of lists
-        input_tensors = node.insert_positional_weights_to_input_list(input_tensors)
-        # convert inputs from positional weights (numpy arrays) to tensors. Must handle each element in the
-        # list separately, because in FX the tensors are FX objects and fail to_torch_tensor
-        input_tensors = [to_torch_tensor(t, numpy_type=t.dtype) if isinstance(t, np.ndarray) else t
-                         for t in input_tensors]
     return input_tensors
 
 
 def _merge_inputs(_node: BaseNode, input_tensors: List, op_call_args: List,
-                  is_op_quantize_wrapper: bool) -> List:
+                  tensor_input_indices: List = None) -> List:
     """
-    Merge input tensors list with op_call_args, according to correct order.
+    Merge input tensors list with positional weights and op_call_args, according to correct order.
 
     Args:
         _node: The node the inputs are for.
         input_tensors: activation input tensors to node.
         op_call_args: framework node call args.
-        is_op_quantize_wrapper: Whether the func_op is a PytorchQuantizationWrapper or not.
+
     Returns:
         Combined list of input_tensors and op_call_args.
     """
     if isinstance(_node, FunctionalNode) and _node.tensor_input_indices:
         _input_list = op_call_args.copy()
-        if is_op_quantize_wrapper:
-            _input_list = input_tensors + _input_list
-        else:
-            assert len(_node.tensor_input_indices) == len(input_tensors), 'Mismatch between input tensors and indices'
-            for i, t in zip(_node.tensor_input_indices, input_tensors):
-                _input_list.insert(i, t)
+        if tensor_input_indices is None:
+            tensor_input_indices = _node.tensor_input_indices
+        assert len(tensor_input_indices) == len(input_tensors), \
+            f'Mismatch between input tensors ({len(tensor_input_indices)}) and indices {len(input_tensors)}'
+        for i, t in zip(tensor_input_indices, input_tensors):
+            _input_list.insert(i, t)
     else:
         _input_list = input_tensors + op_call_args
 
@@ -126,10 +117,22 @@ def _run_operation(n: BaseNode,
     op_call_args = n.op_call_args if isinstance(n, FunctionalNode) else []
     functional_kwargs = n.op_call_kwargs if isinstance(n, FunctionalNode) else {}
 
+    if not (isinstance(n, FunctionalNode) and isinstance(op_func, PytorchQuantizationWrapper)):
+        # Insert positional weights only when not a quantized functional node, because quantized functional nodes
+        # insert the quantized weights in the wrapper.
+        input_tensors = n.insert_positional_weights_to_input_list(input_tensors)
+        # convert inputs from positional weights (numpy arrays) to tensors. Must handle each element in the
+        # list separately, because in FX the tensors are FX objects and fail to_torch_tensor
+        input_tensors = [to_torch_tensor(t, numpy_type=t.dtype) if isinstance(t, np.ndarray) else t
+                         for t in input_tensors]
+        _tensor_input_indices = None
+    else:
+        _tensor_input_indices = [i for i in n.tensor_input_indices if i not in n.weights]
+
     if isinstance(n, FunctionalNode) and n.inputs_as_list:
         out_tensors_of_n_float = op_func(input_tensors, *op_call_args, **functional_kwargs)
     else:
-        merged_inputs = _merge_inputs(n, input_tensors, op_call_args, isinstance(op_func, PytorchQuantizationWrapper))
+        merged_inputs = _merge_inputs(n, input_tensors, op_call_args, tensor_input_indices=_tensor_input_indices)
         out_tensors_of_n_float = op_func(*merged_inputs, **functional_kwargs)
 
     # Add a fake quant node if the node has an activation threshold.
@@ -295,8 +298,7 @@ class PytorchModel(torch.nn.Module):
             input_tensors = _build_input_tensors_list(node,
                                                       self.graph,
                                                       args,
-                                                      node_to_output_tensors_dict,
-                                                      isinstance(op_func, PytorchQuantizationWrapper))
+                                                      node_to_output_tensors_dict)
             use_activation_quantization, activation_quantization_fn = self._get_activation_quantization_fn(node)
 
             # Run node operation and fetch outputs

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/target_platform_capabilities.py

@@ -27,6 +27,8 @@ if FOUND_TF:
     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
 
     # Keras: TPC versioning
     keras_tpc_models_dict = {'v1': get_keras_tpc_v1,
@@ -34,6 +36,8 @@ if FOUND_TF:
                              '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,
                              LATEST: get_keras_tpc_latest}
 
 ###############################
@@ -52,6 +56,10 @@ if FOUND_TORCH:
         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
 
     # Pytorch: TPC versioning
     pytorch_tpc_models_dict = {'v1': get_pytorch_tpc_v1,
@@ -59,6 +67,8 @@ if FOUND_TORCH:
                                '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,
                                LATEST: get_pytorch_tpc_latest}
 
 tpc_dict = {TENSORFLOW: keras_tpc_models_dict,

model_compression_toolkit/target_platform_capabilities/tpc_models/imx500_tpc/v3/__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__ = 'v3'

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

@@ -0,0 +1,222 @@
+# 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
+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,
+        enable_activation_quantization=True,
+        quantization_preserving=False,
+        fixed_scale=None,
+        fixed_zero_point=None,
+        simd_size=32)
+
+    # 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,
+        enable_activation_quantization=True,
+        quantization_preserving=False,
+        fixed_scale=None,
+        fixed_zero_point=None,
+        simd_size=32)
+
+    # 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])
+
+    # 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)
+                        .clone_and_edit_weight_attribute(enable_weights_quantization=False))
+
+        # 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)
+        sub = tp.OperatorsSet("Sub", const_configuration_options)
+        mul = tp.OperatorsSet("Mul", const_configuration_options)
+        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