mct-nightly 1.11.0.20240131.post412__tar.gz → 1.11.0.20240201.post434__tar.gz

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.11.0.20240131.post412
+Version: 1.11.0.20240201.post434
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.11.0.20240131.post412
+Version: 1.11.0.20240201.post434
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/constants.py

@@ -114,6 +114,7 @@ WEIGHTS_QUANTIZATION_FN = 'weights_quantization_fn'
 ACTIVATION_QUANT_PARAMS_FN = 'activation_quantization_params_fn'
 WEIGHTS_QUANT_PARAMS_FN = 'weights_quantization_params_fn'
 WEIGHTS_CHANNELS_AXIS = 'weights_channels_axis'
+WEIGHTS_CFG = 'weights_cfg'
 
 # Memory graph constants
 DUMMY_NODE = 'dummy_node'

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/core/common/graph/base_graph.py

@@ -104,7 +104,7 @@ class Graph(nx.MultiDiGraph, GraphSearches):
                 if not is_node_in_tpc:
                     Logger.error(f'MCT does not support optimizing Keras custom layers, but found layer of type {n.type}. '
                                  f'Please add the custom layer to TPC or file a feature request or an issue if you believe this is an issue.')
-                if any([qc.enable_weights_quantization for qc in n.get_qco(tpc).quantization_config_list]):
+                if any([qc.default_weight_attr_config.enable_weights_quantization for qc in n.get_qco(tpc).quantization_config_list]):
                     Logger.error(f'MCT does not support optimizing Keras custom layers with weights quantization. Layer: {n.type}')
 
         self.tpc = tpc

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/core/common/quantization/candidate_node_quantization_config.py

@@ -14,9 +14,10 @@
 # ==============================================================================
 from model_compression_toolkit.constants import ACTIVATION_QUANTIZATION_CFG, WEIGHTS_QUANTIZATION_CFG, QC, \
     OP_CFG, ACTIVATION_QUANTIZATION_FN, WEIGHTS_QUANTIZATION_FN, ACTIVATION_QUANT_PARAMS_FN, WEIGHTS_QUANT_PARAMS_FN, \
-    WEIGHTS_CHANNELS_AXIS
+    WEIGHTS_CHANNELS_AXIS, WEIGHTS_CFG
 from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
     NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
+from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR
 
 
 ##########################################
@@ -47,4 +48,5 @@ class CandidateNodeQuantizationConfig(BaseNodeQuantizationConfig):
                                                                           kwargs.get(OP_CFG),
                                                                           kwargs.get(WEIGHTS_QUANTIZATION_FN),
                                                                           kwargs.get(WEIGHTS_QUANT_PARAMS_FN),
-                                                                          kwargs.get(WEIGHTS_CHANNELS_AXIS))
+                                                                          kwargs.get(WEIGHTS_CHANNELS_AXIS),
+                                                                          kwargs.get(WEIGHTS_CFG))

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/core/common/quantization/node_quantization_config.py

@@ -24,7 +24,8 @@ from model_compression_toolkit.core.common.quantization.quantization_params_fn_s
 
 from model_compression_toolkit.core.common.quantization.quantization_config import QuantizationConfig, \
     QuantizationErrorMethod
-from model_compression_toolkit.target_platform_capabilities.target_platform import OpQuantizationConfig
+from model_compression_toolkit.target_platform_capabilities.target_platform import OpQuantizationConfig, \
+    AttributeQuantizationConfig
 
 
 ##########################################
@@ -236,7 +237,8 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
                  op_cfg: OpQuantizationConfig,
                  weights_quantization_fn: Callable,
                  weights_quantization_params_fn: Callable,
-                 weights_channels_axis: int):
+                 weights_channels_axis: int,
+                 weights_cfg: AttributeQuantizationConfig):
         """
 
         Args:
@@ -245,19 +247,22 @@ class NodeWeightsQuantizationConfig(BaseNodeQuantizationConfig):
             weights_quantization_fn: Function to use when quantizing the node's weights.
             weights_quantization_params_fn:  Function to use when computing the threshold for quantizing a node's weights.
             weights_channels_axis: Axis to quantize a node's kernel when quantizing per-channel.
+            weights_cfg: Weights attribute quantization config.
         """
 
+        # TODO: after refactoring to enable attributes quantization, all weights quantization arguments
+        #  should be taken per attribute, and not from the weights config
         self.weights_quantization_fn = weights_quantization_fn
         self.weights_quantization_params_fn = weights_quantization_params_fn
         self.weights_channels_axis = weights_channels_axis
         self.weights_quantization_params = {}
-        self.weights_quantization_method = op_cfg.weights_quantization_method
+        self.weights_quantization_method = weights_cfg.weights_quantization_method
         self.weights_error_method = qc.weights_error_method
-        self.weights_n_bits = op_cfg.weights_n_bits
+        self.weights_n_bits = weights_cfg.weights_n_bits
         self.weights_bias_correction = qc.weights_bias_correction
         self.weights_second_moment_correction = qc.weights_second_moment_correction
-        self.weights_per_channel_threshold = op_cfg.weights_per_channel_threshold
-        self.enable_weights_quantization = op_cfg.enable_weights_quantization
+        self.weights_per_channel_threshold = weights_cfg.weights_per_channel_threshold
+        self.enable_weights_quantization = weights_cfg.enable_weights_quantization
         self.min_threshold = qc.min_threshold
         self.l_p_value = qc.l_p_value
         self.simd_size = op_cfg.simd_size

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/core/common/quantization/quantization_config.py

@@ -50,7 +50,6 @@ class QuantizationConfig:
                  weights_error_method: QuantizationErrorMethod = QuantizationErrorMethod.MSE,
                  relu_bound_to_power_of_2: bool = False,
                  weights_bias_correction: bool = True,
-                 weights_per_channel_threshold: bool = True,
                  weights_second_moment_correction: bool = False,
                  input_scaling: bool = False,
                  softmax_shift: bool = False,
@@ -73,7 +72,6 @@ class QuantizationConfig:
             relu_bound_to_power_of_2 (bool): Whether to use relu to power of 2 scaling correction or not.
             weights_bias_correction (bool): Whether to use weights bias correction or not.
             weights_second_moment_correction (bool): Whether to use weights second_moment correction or not.
-            weights_per_channel_threshold (bool): Whether to quantize the weights per-channel or not (per-tensor).
             input_scaling (bool): Whether to use input scaling or not.
             softmax_shift (bool): Whether to use softmax shift or not.
             shift_negative_activation_correction (bool): Whether to use shifting negative activation correction or not.
@@ -90,11 +88,11 @@ class QuantizationConfig:
             One may create a quantization configuration to quantize a model according to.
             For example, to quantize a model's weights and activation using thresholds, such that
             weights threshold selection is done using MSE, activation threshold selection is done using NOCLIPPING (min/max),
-            enabling relu_bound_to_power_of_2, weights_bias_correction, and quantizing the weights per-channel,
+            enabling relu_bound_to_power_of_2, weights_bias_correction,
             one can instantiate a quantization configuration:
 
             >>> import model_compression_toolkit as mct
-            >>> qc = mct.core.QuantizationConfig(activation_error_method=mct.core.QuantizationErrorMethod.NOCLIPPING,weights_error_method=mct.core.QuantizationErrorMethod.MSE,relu_bound_to_power_of_2=True,weights_bias_correction=True,weights_per_channel_threshold=True)
+            >>> qc = mct.core.QuantizationConfig(activation_error_method=mct.core.QuantizationErrorMethod.NOCLIPPING, weights_error_method=mct.core.QuantizationErrorMethod.MSE, relu_bound_to_power_of_2=True, weights_bias_correction=True)
 
 
             The QuantizationConfig instanse can then be passed to
@@ -107,7 +105,6 @@ class QuantizationConfig:
         self.relu_bound_to_power_of_2 = relu_bound_to_power_of_2
         self.weights_bias_correction = weights_bias_correction
         self.weights_second_moment_correction = weights_second_moment_correction
-        self.weights_per_channel_threshold = weights_per_channel_threshold
         self.activation_channel_equalization = activation_channel_equalization
         self.input_scaling = input_scaling
         self.softmax_shift = softmax_shift
@@ -126,11 +123,6 @@ class QuantizationConfig:
 
 
 # Default quantization configuration the library use.
-DEFAULTCONFIG = QuantizationConfig(QuantizationErrorMethod.MSE,
-                                   QuantizationErrorMethod.MSE,
-                                   relu_bound_to_power_of_2=False,
-                                   weights_bias_correction=True,
-                                   weights_second_moment_correction=False,
-                                   weights_per_channel_threshold=True,
-                                   input_scaling=False,
-                                   softmax_shift=False)
+DEFAULTCONFIG = QuantizationConfig(QuantizationErrorMethod.MSE, QuantizationErrorMethod.MSE,
+                                   relu_bound_to_power_of_2=False, weights_bias_correction=True,
+                                   weights_second_moment_correction=False, input_scaling=False, softmax_shift=False)

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/core/common/quantization/set_node_quantization_config.py

@@ -81,6 +81,7 @@ def set_quantization_configs_to_node(node: BaseNode,
                                                                   fw_info,
                                                                   weight_channel_axis,
                                                                   node_qc_options,
+                                                                  node.type,
                                                                   mixed_precision_enable=mixed_precision_enable)
 
     for candidate_qc in node.candidates_quantization_cfg:
@@ -118,10 +119,11 @@ def create_node_activation_qc(qc: QuantizationConfig,
                                             activation_quantization_params_fn)
 
 
-def create_node_qc_candidate(qc: QuantizationConfig,
-                             fw_info: FrameworkInfo,
-                             weight_channel_axis: int,
-                             op_cfg: OpQuantizationConfig) -> CandidateNodeQuantizationConfig:
+def _create_node_single_candidate_qc(qc: QuantizationConfig,
+                                     fw_info: FrameworkInfo,
+                                     weight_channel_axis: int,
+                                     op_cfg: OpQuantizationConfig,
+                                     kernel_attr: str) -> CandidateNodeQuantizationConfig:
     """
     Create quantization configuration candidate from a QuantizationConfig object.
     Creates both weights and activation quantization configurations
@@ -133,18 +135,26 @@ def create_node_qc_candidate(qc: QuantizationConfig,
             weights/activations should be quantized)
         weight_channel_axis: Output channel index of the node's kernel.
         op_cfg: OpQuantizationConfig of the node with quantizers types to use when creating node quantization configuration.
+        kernel_attr: The name of the kernel attribute of the node,
+        TODO: kernel_attr should be removed once enabling attributes quantization (because this function would create
+            candidate for all attributes not specifically for the kernel
 
     Returns: a CandidateNodeQuantizationConfig object with both weights and activation quantization config objects.
 
     """
 
-    # get attributes for weights quantization
-    weights_quantization_fn = get_weights_quantization_fn(op_cfg.weights_quantization_method)
+    # get attributes for weights quantization.
+    # if the node doesn't have a specified kernel config we use the default attribute config for quantization.
+    # TODO: This should be the behavior for all attributes that are not specified in the attribute config mapping,
+    #  which currently disables the quantization of the weights attribute.
+    weights_cfg = op_cfg.attr_weights_configs_mapping.get(kernel_attr, op_cfg.default_weight_attr_config)
+
+    weights_quantization_fn = get_weights_quantization_fn(weights_cfg.weights_quantization_method)
 
     if weights_quantization_fn is None:
-        Logger.critical('Unknown quantization method for weights')  # pragma: no cover
+        Logger.critical(f'Unknown quantization method for weights for quantizing attribute: {kernel_attr}')  # pragma: no cover
 
-    weights_quantization_params_fn = get_weights_quantization_params_fn(op_cfg.weights_quantization_method)
+    weights_quantization_params_fn = get_weights_quantization_params_fn(weights_cfg.weights_quantization_method)
 
     # get attributes for activation quantization
     activation_quantization_fn = fw_info.activation_quantizer_mapping.get(op_cfg.activation_quantization_method)
@@ -159,13 +169,15 @@ def create_node_qc_candidate(qc: QuantizationConfig,
                                            activation_quantization_params_fn=activation_quantization_params_fn,
                                            weights_quantization_fn=weights_quantization_fn,
                                            weights_quantization_params_fn=weights_quantization_params_fn,
-                                           weight_channel_axis=weight_channel_axis)
+                                           weight_channel_axis=weight_channel_axis,
+                                           weights_cfg=weights_cfg)
 
 
 def _create_node_candidates_qc(qc: QuantizationConfig,
                                fw_info: FrameworkInfo,
                                weight_channel_axis: int,
                                node_qc_options: QuantizationConfigOptions,
+                               node_type: type,
                                mixed_precision_enable: bool = False) -> List[CandidateNodeQuantizationConfig]:
     """
     Create a list of candidates of weights and activation quantization configurations for a node.
@@ -175,6 +187,7 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
         fw_info: Framework information (e.g., which layers should have their kernels' quantized).
         weight_channel_axis: Output channel index of the node's kernel.
         node_qc_options: QuantizationConfigOptions for the node with quantization candidates information.
+        node_type: The type of the layer that the node represents.
         mixed_precision_enable: is mixed precision enabled
 
     Returns:
@@ -182,21 +195,31 @@ def _create_node_candidates_qc(qc: QuantizationConfig,
     """
 
     candidates = []
+
+    # TODO: Currently, we are using fw_info to get the kernel attribute, but this would changed once we enable multi
+    #  attribute quantization via AttributeQuantizationConfig class (needs to be implemented)
+
+    kernel_attr = fw_info.get_kernel_op_attributes(node_type)
+    assert len(kernel_attr) == 1
+    kernel_attr = kernel_attr[0]
+
     if mixed_precision_enable:
         for op_cfg in node_qc_options.quantization_config_list:
             candidate_nbits_qc = copy.deepcopy(qc)
-            candidates.append(create_node_qc_candidate(candidate_nbits_qc,
-                                                       fw_info,
-                                                       weight_channel_axis,
-                                                       op_cfg))
+            candidates.append(_create_node_single_candidate_qc(candidate_nbits_qc,
+                                                               fw_info,
+                                                               weight_channel_axis,
+                                                               op_cfg,
+                                                               kernel_attr))
         # sorting the candidates by weights number of bits first and then by activation number of bits
         # (in reversed order)
         candidates.sort(key=lambda c: (c.weights_quantization_cfg.weights_n_bits,
                                        c.activation_quantization_cfg.activation_n_bits), reverse=True)
     else:
-        candidates.append(create_node_qc_candidate(qc,
-                                                   fw_info,
-                                                   weight_channel_axis,
-                                                   node_qc_options.base_config))
+        candidates.append(_create_node_single_candidate_qc(qc,
+                                                           fw_info,
+                                                           weight_channel_axis,
+                                                           node_qc_options.base_config,
+                                                           kernel_attr))
 
     return candidates

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/exporter/model_exporter/keras/fakely_quant_tflite_exporter.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ==============================================================================
 import os
+from pathlib import Path
 import tempfile
 from typing import Callable
 
@@ -56,14 +57,20 @@ class FakelyQuantTFLiteExporter(FakelyQuantKerasExporter):
 
         """
         # Use Keras exporter to quantize model's weights before converting it to TFLite.
-        # Since exporter saves the model, we use a tmp path for saving, and then we delete it automatically.
-        with tempfile.NamedTemporaryFile(suffix=DEFAULT_KERAS_EXPORT_EXTENTION) as tmp_file:
-            FakelyQuantKerasExporter(self.model,
-                                     self.is_layer_exportable_fn,
-                                     tmp_file.name,
-                                     verbose=False).export()
+        # Since exporter saves the model, we use a tmp path for saving, and then we delete it.
+        handle, tmp_file = tempfile.mkstemp(DEFAULT_KERAS_EXPORT_EXTENTION)
+        # Close handle right away, the file is going to be reopenned by Keras exporter
+        os.close(handle)
+        try:
+            custom_objects = FakelyQuantKerasExporter(self.model,
+                                                      self.is_layer_exportable_fn,
+                                                      tmp_file,
+                                                      verbose=False).export()
 
-            model = keras_load_quantized_model(tmp_file.name)
+            model = keras_load_quantized_model(tmp_file)
+        # Ensures artifact is removed even in case of error
+        finally:
+            Path(tmp_file).unlink(missing_ok=True)
 
         self.exported_model = tf.lite.TFLiteConverter.from_keras_model(model).convert()
         Logger.info(f'Exporting FQ tflite model to: {self.save_model_path}')

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/exporter/model_exporter/pytorch/fakely_quant_onnx_pytorch_exporter.py

@@ -26,8 +26,11 @@ from mct_quantizers import pytorch_quantizers
 # ONNX opset version 16 is supported from PyTorch 1.12
 if version.parse(torch.__version__) < version.parse("1.12"):
     OPSET_VERSION = 15
-else:
+elif version.parse("1.12.0") <= version.parse(torch.__version__) < version.parse("1.13.0"):
     OPSET_VERSION = 16
+else:
+    # ONNX opset version 17 is supported from PyTorch 1.13
+    OPSET_VERSION = 17
 
 
 class FakelyQuantONNXPyTorchExporter(BasePyTorchExporter):

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/target_platform_capabilities/constants.py

@@ -24,4 +24,21 @@ LATEST = 'latest'
 DEFAULT_TP_MODEL = 'default'
 IMX500_TP_MODEL = 'imx500'
 TFLITE_TP_MODEL = 'tflite'
-QNNPACK_TP_MODEL = 'qnnpack'
+QNNPACK_TP_MODEL = 'qnnpack'
+
+# TP Attributes
+KERNEL_ATTR = "kernel_attr"
+BIAS_ATTR = "bias_attr"
+
+# TODO: this is duplicated from the core frameworks constants files, because the original consts can't be used here
+#  duo to circular dependency. It might be best to extract the constants from the core file and put them here (in a
+#  separate changeset, because it affects the entire code)
+KERAS_KERNEL = "kernel"
+KERAS_DEPTHWISE_KERNEL = "depthwise_kernel"
+BIAS = "bias"
+PYTORCH_KERNEL = "weight"
+
+# Configuration attributes names
+
+WEIGHTS_N_BITS = 'weights_n_bits'
+WEIGHTS_QUANTIZATION_METHOD = 'weights_quantization_method'

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py

@@ -21,7 +21,7 @@ from model_compression_toolkit.target_platform_capabilities.target_platform.targ
     get_default_quantization_config_options, TargetPlatformModel
 
 from model_compression_toolkit.target_platform_capabilities.target_platform.op_quantization_config import OpQuantizationConfig, \
-    QuantizationConfigOptions
+    QuantizationConfigOptions, AttributeQuantizationConfig
 from model_compression_toolkit.target_platform_capabilities.target_platform.operators import OperatorsSet, OperatorSetConcat
 
 from mct_quantizers import QuantizationMethod

{mct-nightly-1.11.0.20240131.post412 → mct-nightly-1.11.0.20240201.post434}/model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py

@@ -14,58 +14,135 @@
 # ==============================================================================
 
 import copy
-from typing import List
+from typing import List, Dict, Union, Any
 
 from mct_quantizers import QuantizationMethod
+from model_compression_toolkit.logger import Logger
 
 
-class OpQuantizationConfig:
+def clone_and_edit_object_params(obj: Any, **kwargs: Dict) -> Any:
     """
-    OpQuantizationConfig is a class to configure the quantization parameters of an operator.
+    Clones the given object and edit some of its parameters.
+
+    Args:
+        obj: An object to clone.
+        **kwargs: Keyword arguments to edit in the cloned object.
+
+    Returns:
+        Edited copy of the given object.
     """
 
+    obj_copy = copy.deepcopy(obj)
+    for k, v in kwargs.items():
+        assert hasattr(obj_copy,
+                       k), f'Edit parameter is possible only for existing parameters in the given object, ' \
+                           f'but {k} is not a parameter of {obj_copy}.'
+        setattr(obj_copy, k, v)
+    return obj_copy
+
+
+class AttributeQuantizationConfig:
+    """
+    Hold the quantization configuration of a weight attribute of a layer.
+    """
     def __init__(self,
-                 activation_quantization_method: QuantizationMethod,
                  weights_quantization_method: QuantizationMethod,
-                 activation_n_bits: int,
                  weights_n_bits: int,
                  weights_per_channel_threshold: bool,
                  enable_weights_quantization: bool,
+                 lut_values_bitwidth: Union[int, None],  # If None - set 8 in hptq, o.w use it
+                 ):
+        """
+        Initializes an attribute quantization config.
+
+        Args:
+            weights_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for weights quantization.
+            weights_n_bits (int): Number of bits to quantize the coefficients.
+            weights_per_channel_threshold (bool): Whether to quantize the weights per-channel or not (per-tensor).
+            enable_weights_quantization (bool): Whether to quantize the model weights or not.
+            lut_values_bitwidth (int): Number of bits to use when quantizing in look-up-table.
+
+        """
+
+        self.weights_quantization_method = weights_quantization_method
+        self.weights_n_bits = weights_n_bits
+        self.weights_per_channel_threshold = weights_per_channel_threshold
+        self.enable_weights_quantization = enable_weights_quantization
+        self.lut_values_bitwidth = lut_values_bitwidth
+
+    def clone_and_edit(self, **kwargs):
+        """
+        Clone the quantization config and edit some of its attributes.
+
+        Args:
+            **kwargs: Keyword arguments to edit the configuration to clone.
+
+        Returns:
+            Edited quantization configuration.
+        """
+
+        return clone_and_edit_object_params(self, **kwargs)
+
+    def __eq__(self, other):
+        """
+        Is this configuration equal to another object.
+
+        Args:
+            other: Object to compare.
+
+        Returns:
+
+            Whether this configuration is equal to another object or not.
+        """
+        if not isinstance(other, AttributeQuantizationConfig):
+            return False
+        return self.weights_quantization_method == other.weights_quantization_method and \
+            self.weights_n_bits == other.weights_n_bits and \
+            self.weights_per_channel_threshold == other.weights_per_channel_threshold and \
+            self.enable_weights_quantization == other.enable_weights_quantization and \
+            self.lut_values_bitwidth == other.lut_values_bitwidth
+
+
+class OpQuantizationConfig:
+    """
+    OpQuantizationConfig is a class to configure the quantization parameters of an operator.
+    """
+
+    def __init__(self,
+                 default_weight_attr_config: AttributeQuantizationConfig,
+                 attr_weights_configs_mapping: Dict[str, AttributeQuantizationConfig],
+                 activation_quantization_method: QuantizationMethod,
+                 activation_n_bits: int,
                  enable_activation_quantization: bool,
                  quantization_preserving: bool,
                  fixed_scale: float,
                  fixed_zero_point: int,
-                 weights_multiplier_nbits: int,  # If None - set 8 in hptq, o.w use it
-                 simd_size: int):
+                 simd_size: int
+                 ):
         """
 
         Args:
+            default_weight_attr_config (AttributeQuantizationConfig): A default attribute quantization configuration for the operation.
+            attr_weights_configs_mapping (dict): A mapping between an op attribute name and its quantization configuration.
             activation_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for activation quantization.
-            weights_quantization_method (QuantizationMethod): Which method to use from QuantizationMethod for weights quantization.
             activation_n_bits (int): Number of bits to quantize the activations.
-            weights_n_bits (int): Number of bits to quantize the coefficients.
-            weights_per_channel_threshold (bool): Whether to quantize the weights per-channel or not (per-tensor).
-            enable_weights_quantization (bool): Whether to quantize the model weights or not.
             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.
-            weights_multiplier_nbits (int): Number of bits to use when quantizing in look-up-table.
-            simd_size (int): An 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.
+            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.
 
         """
 
+        self.default_weight_attr_config = default_weight_attr_config
+        self.attr_weights_configs_mapping = attr_weights_configs_mapping
+
         self.activation_quantization_method = activation_quantization_method
-        self.weights_quantization_method = weights_quantization_method
         self.activation_n_bits = activation_n_bits
-        self.weights_n_bits = weights_n_bits
-        self.weights_per_channel_threshold = weights_per_channel_threshold
-        self.enable_weights_quantization = enable_weights_quantization
         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.eights_lut_values_bitwidth = weights_multiplier_nbits
         self.simd_size = simd_size
 
     def get_info(self):
@@ -76,22 +153,28 @@ class OpQuantizationConfig:
         """
         return self.__dict__
 
-    def clone_and_edit(self, **kwargs):
+    def clone_and_edit(self, attr_to_edit: Dict[str, Dict[str, Any]] = {}, **kwargs):
         """
         Clone the quantization config and edit some of its attributes.
         Args:
+            attr_to_edit: A mapping between attributes names to edit and their parameters that
+            should be edited to a new value.
             **kwargs: Keyword arguments to edit the configuration to clone.
 
         Returns:
             Edited quantization configuration.
         """
 
-        qc = copy.deepcopy(self)
-        for k, v in kwargs.items():
-            assert hasattr(qc,
-                           k), f'Edit attributes is possible only for existing attributes in configuration, ' \
-                               f'but {k} is not an attribute of {qc}'
-            setattr(qc, k, v)
+        qc = clone_and_edit_object_params(self, **kwargs)
+
+        # optionally: editing specific parameters in the config of specified attributes
+        edited_attrs = copy.deepcopy(qc.attr_weights_configs_mapping)
+        for attr_name, attr_cfg in qc.attr_weights_configs_mapping.items():
+            if attr_name in attr_to_edit:
+                edited_attrs[attr_name] = attr_cfg.clone_and_edit(**attr_to_edit[attr_name])
+
+        qc.attr_weights_configs_mapping = edited_attrs
+
         return qc
 
     def __eq__(self, other):
@@ -105,14 +188,12 @@ class OpQuantizationConfig:
         """
         if not isinstance(other, OpQuantizationConfig):
             return False
-        return self.activation_quantization_method == other.activation_quantization_method and \
-               self.weights_quantization_method == other.weights_quantization_method and \
-               self.activation_n_bits == other.activation_n_bits and \
-               self.weights_n_bits == other.weights_n_bits and \
-               self.weights_per_channel_threshold == other.weights_per_channel_threshold and \
-               self.enable_weights_quantization == other.enable_weights_quantization and \
-               self.enable_activation_quantization == other.enable_activation_quantization and \
-               self.simd_size==other.simd_size
+        return self.default_weight_attr_config == other.default_weight_attr_config and \
+            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.enable_activation_quantization == other.enable_activation_quantization and \
+            self.simd_size == other.simd_size
 
 
 class QuantizationConfigOptions(object):
@@ -177,6 +258,67 @@ class QuantizationConfigOptions(object):
             self.__edit_quantization_configuration(qc, kwargs)
         return qc_options
 
+    def clone_and_edit_weight_attribute(self, attrs: List[str] = None, **kwargs):
+        """
+        Clones the quantization configurations and edits some of their attributes' parameters.
+
+        Args:
+            attrs: attributes names to clone their configurations. If None is provided, updating the configurations
+                of all attributes in the operation attributes config mapping.
+            **kwargs: Keyword arguments to edit in the attributes configuration.
+
+        Returns:
+            QuantizationConfigOptions with edited attributes configurations.
+
+        """
+
+        qc_options = copy.deepcopy(self)
+
+        for qc in qc_options.quantization_config_list:
+            if attrs is None:
+                attrs_to_update = list(qc.attr_weights_configs_mapping.keys())
+            else:
+                if not isinstance(attrs, List):
+                    Logger.error(f"Expecting a list of attribute but got {type(attrs)}.")
+                attrs_to_update = attrs
+
+            for attr in attrs_to_update:
+                if qc.attr_weights_configs_mapping.get(attr) is None:
+                    Logger.error(f'Edit attributes is possible only for existing attributes '
+                                 f'in the configuration weights config mapping, but {attr} is not an attribute of {qc}.')
+                self.__edit_quantization_configuration(qc.attr_weights_configs_mapping[attr], kwargs)
+        return qc_options
+
+    def clone_and_map_weights_attr_keys(self, layer_attrs_mapping: Union[Dict[str, str], None]):
+        """
+       Clones the quantization configuration options and edits the keys in each configuration attributes config mapping,
+       based on the given attributes names mapping.
+
+        Args:
+            layer_attrs_mapping: A mapping between attributes names.
+
+        Returns:
+            QuantizationConfigOptions with edited attributes names.
+
+        """
+        qc_options = copy.deepcopy(self)
+
+        for qc in qc_options.quantization_config_list:
+            if layer_attrs_mapping is None:
+                qc.attr_weights_configs_mapping = {}
+            else:
+                new_attr_mapping = {}
+                for attr in list(qc.attr_weights_configs_mapping.keys()):
+                    new_key = layer_attrs_mapping.get(attr)
+                    if new_key is None:
+                        Logger.error(f"Attribute {attr} does not exist in the given attribute mapping.")
+
+                    new_attr_mapping[new_key] = qc.attr_weights_configs_mapping.pop(attr)
+
+                qc.attr_weights_configs_mapping.update(new_attr_mapping)
+
+        return qc_options
+
     def __edit_quantization_configuration(self, qc, kwargs):
         for k, v in kwargs.items():
             assert hasattr(qc,