mct-nightly 1.9.0.20230812.post349__tar.gz → 1.9.0.20230814.post352__tar.gz

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.9.0.20230812.post349
+Version: 1.9.0.20230814.post352
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.9.0.20230812.post349
+Version: 1.9.0.20230814.post352
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/constants.py

@@ -27,13 +27,13 @@ WEIGHTS_SIGNED = True
 # Minimal threshold to use for quantization ranges:
 MIN_THRESHOLD = (2 ** -16)
 EPS = 1e-8
-MULTIPLIER_N_BITS = 8
+LUT_VALUES_BITWIDTH = 8
 
 # Quantization attributes:
 OUTPUT_SCALE = 'output_scale'
 THRESHOLD = 'threshold'
 SIGNED = 'is_signed'
-CLUSTER_CENTERS = 'cluster_centers'
+LUT_VALUES = 'lut_values'
 SCALE_PER_CHANNEL = 'scale_per_channel'
 RANGE_MIN = 'range_min'
 RANGE_MAX = 'range_max'

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/common/quantization/quantization_params_generation/kmeans_params.py

@@ -17,7 +17,7 @@ import numpy as np
 from sklearn.cluster import KMeans
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import CLUSTER_CENTERS, SCALE_PER_CHANNEL, MIN_THRESHOLD, EPS
+from model_compression_toolkit.constants import LUT_VALUES, SCALE_PER_CHANNEL, MIN_THRESHOLD, EPS
 
 
 def kmeans_tensor(tensor_data: np.ndarray,
@@ -59,6 +59,6 @@ def kmeans_tensor(tensor_data: np.ndarray,
     tensor_for_kmeans = (tensor_data / (scales_per_channel + EPS))
     kmeans.fit(tensor_for_kmeans.reshape(-1, 1))
 
-    return {CLUSTER_CENTERS: kmeans.cluster_centers_,
+    return {LUT_VALUES: kmeans.cluster_centers_,
             SCALE_PER_CHANNEL: scales_per_channel,
             }

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py

@@ -17,8 +17,8 @@ import numpy as np
 from sklearn.cluster import KMeans
 
 import model_compression_toolkit.core.common.quantization.quantization_config as qc
-from model_compression_toolkit.constants import CLUSTER_CENTERS, MIN_THRESHOLD, SCALE_PER_CHANNEL, \
-    MULTIPLIER_N_BITS, THRESHOLD
+from model_compression_toolkit.constants import LUT_VALUES, MIN_THRESHOLD, SCALE_PER_CHANNEL, \
+    LUT_VALUES_BITWIDTH, THRESHOLD
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import \
     max_power_of_two, int_quantization_with_threshold
 from model_compression_toolkit.core.common.quantization.quantization_params_generation.symmetric_selection import \
@@ -41,7 +41,7 @@ def lut_kmeans_tensor(tensor_data: np.ndarray,
     """
     The quantizer first finds the closest max value per channel of tensor_data.
     Now, we divide tensor_data with the threshold vector per channel. In addition, we scale the result to the range
-    [-2^(MULTIPLIER_N_BITS-1), 2^(MULTIPLIER_N_BITS-1)-1].
+    [-2^(LUT_VALUES_BITWIDTH-1), 2^(LUT_VALUES_BITWIDTH-1)-1].
     Next, we take the scaled tensor_data and perform k-means clustering with 2^nbit clusters.
     We return the rounded cluster centers, and threshold per channel. We use these to quantize the data.
     Args:
@@ -59,9 +59,9 @@ def lut_kmeans_tensor(tensor_data: np.ndarray,
         A dictionary containing the cluster assignments according to the k-means algorithm,
         the thresholds per channel and the multiplier num bits.
     """
-    if n_bits >= MULTIPLIER_N_BITS:
+    if n_bits >= LUT_VALUES_BITWIDTH:
         Logger.critical(f'Look-Up-Table bit configuration has {n_bits} bits, but must be less than '
-                        f'{MULTIPLIER_N_BITS}')  # pragma: no cover
+                        f'{LUT_VALUES_BITWIDTH}')  # pragma: no cover
     # TODO: need to set this externally
     if len(np.unique(tensor_data.flatten())) < 2 ** n_bits:
         n_clusters = len(np.unique(tensor_data.flatten()))
@@ -74,10 +74,10 @@ def lut_kmeans_tensor(tensor_data: np.ndarray,
                                                         channel_axis, n_iter, min_threshold,
                                                         qc.QuantizationErrorMethod.NOCLIPPING)[THRESHOLD]
 
-    tensor_for_kmeans = int_quantization_with_threshold(tensor_data, thresholds_per_channel, MULTIPLIER_N_BITS)
+    tensor_for_kmeans = int_quantization_with_threshold(tensor_data, thresholds_per_channel, LUT_VALUES_BITWIDTH)
     kmeans.fit(tensor_for_kmeans.reshape(-1, 1))
 
-    return {CLUSTER_CENTERS: np.round(kmeans.cluster_centers_),
+    return {LUT_VALUES: np.round(kmeans.cluster_centers_),
             SCALE_PER_CHANNEL: thresholds_per_channel}
 
 
@@ -115,9 +115,9 @@ def lut_kmeans_histogram(bins: np.ndarray,
         the threshold for pre-clustering quantization.
     """
 
-    if n_bits >= MULTIPLIER_N_BITS:
+    if n_bits >= LUT_VALUES_BITWIDTH:
         Logger.critical(f'Look-Up-Table bit configuration has {n_bits} bits. It must be less then '
-                        f'{MULTIPLIER_N_BITS}')  # pragma: no cover
+                        f'{LUT_VALUES_BITWIDTH}')  # pragma: no cover
 
     bins_with_values = np.abs(bins)[1:][counts > 0]
     if len(np.unique(bins_with_values.flatten())) < 2 ** n_bits:
@@ -130,8 +130,8 @@ def lut_kmeans_histogram(bins: np.ndarray,
     threshold = max_power_of_two(tensor_max, min_threshold)
 
     signed = np.any(bins[:-1][counts != 0] < 0)  # Whether histogram contains negative values or not.
-    tensor_for_kmeans = int_quantization_with_threshold(data=bins, threshold=threshold, n_bits=MULTIPLIER_N_BITS, signed=signed)
+    tensor_for_kmeans = int_quantization_with_threshold(data=bins, threshold=threshold, n_bits=LUT_VALUES_BITWIDTH, signed=signed)
     kmeans.fit(tensor_for_kmeans.reshape(-1, 1), sample_weight=np.insert(counts, 0, 0))
 
-    return {CLUSTER_CENTERS: np.float32(np.round(kmeans.cluster_centers_)),
+    return {LUT_VALUES: np.float32(np.round(kmeans.cluster_centers_)),
             THRESHOLD: threshold}

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/common/quantization/quantizers/kmeans_quantizer.py

@@ -16,7 +16,7 @@
 from sklearn.cluster import KMeans
 import numpy as np
 
-from model_compression_toolkit.constants import CLUSTER_CENTERS, MIN_THRESHOLD, SCALE_PER_CHANNEL
+from model_compression_toolkit.constants import LUT_VALUES, MIN_THRESHOLD, SCALE_PER_CHANNEL
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import kmeans_assign_clusters
 
 
@@ -42,12 +42,12 @@ def kmeans_quantizer(tensor_data: np.ndarray,
         Quantized data.
     """
     eps = 1e-8
-    cluster_centers = quantization_params[CLUSTER_CENTERS]
+    lut_values = quantization_params[LUT_VALUES]
     scales_per_channel = quantization_params[SCALE_PER_CHANNEL]
     tensor = (tensor_data / (scales_per_channel + eps))
     shape_before_kmeans = tensor.shape
-    cluster_assignments = kmeans_assign_clusters(cluster_centers, tensor.reshape(-1, 1))
-    quant_tensor = cluster_centers[cluster_assignments].reshape(shape_before_kmeans)
+    cluster_assignments = kmeans_assign_clusters(lut_values, tensor.reshape(-1, 1))
+    quant_tensor = lut_values[cluster_assignments].reshape(shape_before_kmeans)
     if per_channel:
         quant_tensor = (quant_tensor * scales_per_channel)
     return quant_tensor

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/common/quantization/quantizers/lut_kmeans_quantizer.py

@@ -15,8 +15,8 @@
 
 import numpy as np
 
-from model_compression_toolkit.constants import CLUSTER_CENTERS, SCALE_PER_CHANNEL, \
-    MULTIPLIER_N_BITS
+from model_compression_toolkit.constants import LUT_VALUES, SCALE_PER_CHANNEL, \
+    LUT_VALUES_BITWIDTH
 from model_compression_toolkit.core.common.quantization.quantizers.quantizers_helpers import kmeans_assign_clusters, \
     get_quantized_tensor, int_quantization_with_threshold
 
@@ -30,8 +30,8 @@ def lut_kmeans_quantizer(tensor_data: np.ndarray,
     """
     Quantize a tensor with given cluster centers and thresholds-per-channel vector.
     1. We divide tensor_data with the scale vector per channel.
-    2. We scale the result to the range [-2^(MULTIPLIER_N_BITS-1), 2^(MULTIPLIER_N_BITS-1)-1].
-    3. We assign cluster centers to every value, multiply by thresholds_per_channel and divide by 2^(MULTIPLIER_N_BITS-1).
+    2. We scale the result to the range [-2^(LUT_VALUES_BITWIDTH-1), 2^(LUT_VALUES_BITWIDTH-1)-1].
+    3. We assign cluster centers to every value, multiply by thresholds_per_channel and divide by 2^(LUT_VALUES_BITWIDTH-1).
     The result is the quantized tensor.
 
 
@@ -46,12 +46,12 @@ def lut_kmeans_quantizer(tensor_data: np.ndarray,
     Returns:
         Quantized data.
     """
-    cluster_centers = quantization_params[CLUSTER_CENTERS]
+    lut_values = quantization_params[LUT_VALUES]
     thresholds_per_channel = quantization_params[SCALE_PER_CHANNEL]
-    tensor = int_quantization_with_threshold(tensor_data, thresholds_per_channel, MULTIPLIER_N_BITS)
+    tensor = int_quantization_with_threshold(tensor_data, thresholds_per_channel, LUT_VALUES_BITWIDTH)
     shape_before_kmeans = tensor.shape
-    cluster_assignments = kmeans_assign_clusters(cluster_centers, tensor.reshape(-1, 1))
-    quant_tensor = get_quantized_tensor(cluster_centers[cluster_assignments].reshape(shape_before_kmeans),
+    cluster_assignments = kmeans_assign_clusters(lut_values, tensor.reshape(-1, 1))
+    quant_tensor = get_quantized_tensor(lut_values[cluster_assignments].reshape(shape_before_kmeans),
                                         thresholds_per_channel,
-                                        MULTIPLIER_N_BITS)
+                                        LUT_VALUES_BITWIDTH)
     return quant_tensor

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py

@@ -151,12 +151,12 @@ def uniform_quantize_tensor(tensor_data: np.ndarray,
     return q
 
 
-def kmeans_assign_clusters(cluster_centers: np.ndarray,
+def kmeans_assign_clusters(lut_values: np.ndarray,
                            query: np.ndarray) -> np.ndarray:
     """
     Assign each data value in query with its closest cluster center point.
     Args:
-        cluster_centers: the cluster centers to assign the query values.
+        lut_values: the cluster centers to assign the query values.
         query: values for which to assign cluster centers.
 
     Returns: A tensor of indexes to the cluster centers that where assigned to each value in
@@ -164,9 +164,9 @@ def kmeans_assign_clusters(cluster_centers: np.ndarray,
 
     """
     d0 = query.shape[0]
-    d1 = cluster_centers.shape[0]
+    d1 = lut_values.shape[0]
     query_ = query.repeat(d1).reshape(d0, d1)
-    cluster_centers_ = cluster_centers.repeat(d0).reshape(d1, d0).transpose(1, 0)
+    cluster_centers_ = lut_values.repeat(d0).reshape(d1, d0).transpose(1, 0)
     return np.argmin(np.abs(query_ - cluster_centers_), axis=1)
 
 

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/keras/quantizer/lut_fake_quant.py

@@ -5,8 +5,8 @@ import tensorflow as tf
 from keras.layers import Layer
 from tensorflow.python.util.object_identity import Reference as TFReference
 
-from model_compression_toolkit.constants import SIGNED, CLUSTER_CENTERS, EPS, \
-    MULTIPLIER_N_BITS, THRESHOLD
+from model_compression_toolkit.constants import SIGNED, LUT_VALUES, EPS, \
+    LUT_VALUES_BITWIDTH, THRESHOLD
 
 
 def activation_lut_kmean_quantizer(activation_n_bits: int,
@@ -29,14 +29,14 @@ def activation_lut_kmean_quantizer(activation_n_bits: int,
 
 class LUTFakeQuant(Layer):
     """
-    A custom Keras layer for quantizing activation tensor with non-uniform quantization (using lookup table clustering).
+    A custom Keras layer for quantizing activation tensor with non-uniform quantization (using lookup table values).
     """
 
     def __init__(self, quantization_params: Dict[str, np.ndarray], **kwargs):
         super(LUTFakeQuant, self).__init__(**kwargs)
         self.quantization_params = quantization_params
         self.activation_is_signed = self.quantization_params.get(SIGNED)
-        self.cluster_centers = self.quantization_params.get(CLUSTER_CENTERS)
+        self.lut_values = self.quantization_params.get(LUT_VALUES)
         self.threshold = self.quantization_params.get(THRESHOLD)
 
     def build(self, input_shape: Tuple[int]):
@@ -59,7 +59,7 @@ class LUTFakeQuant(Layer):
         Returns: KerasTensor after applying a non-uniform fake quantization.
 
         """
-        if self.activation_is_signed is None or self.cluster_centers is None or self.threshold is None:
+        if self.activation_is_signed is None or self.lut_values is None or self.threshold is None:
             return None  # pragma: no cover
 
         _quant_output = self.lut_kmeans_quantizer(input_data)
@@ -79,14 +79,14 @@ class LUTFakeQuant(Layer):
         Returns: Quantized tensor.
         """
 
-        tensor = self.int_quantization_with_threshold(tensor_data, MULTIPLIER_N_BITS)
+        tensor = self.int_quantization_with_threshold(tensor_data, LUT_VALUES_BITWIDTH)
         tensor = tf.expand_dims(tensor, -1)
 
-        expanded_cluster_centers = self.cluster_centers.reshape([*[1 for _ in range(len(tensor.shape)-1)], -1])
-        cluster_assignments = tf.argmin(tf.abs(tensor - expanded_cluster_centers), axis=-1)
-        centers = tf.gather(self.cluster_centers.flatten(), cluster_assignments)
+        expanded_lut_values = self.lut_values.reshape([*[1 for _ in range(len(tensor.shape)-1)], -1])
+        lut_values_assignments = tf.argmin(tf.abs(tensor - expanded_lut_values), axis=-1)
+        centers = tf.gather(self.lut_values.flatten(), lut_values_assignments)
 
-        quant_tensor = (centers / (2 ** (MULTIPLIER_N_BITS - int(self.activation_is_signed)))) * self.threshold
+        quant_tensor = (centers / (2 ** (LUT_VALUES_BITWIDTH - int(self.activation_is_signed)))) * self.threshold
 
         return quant_tensor
 

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/core/pytorch/quantizer/lut_fake_quant.py

@@ -3,7 +3,7 @@ from typing import Dict, Callable
 import torch
 import numpy as np
 
-from model_compression_toolkit.constants import SIGNED, CLUSTER_CENTERS, THRESHOLD, MULTIPLIER_N_BITS, EPS
+from model_compression_toolkit.constants import SIGNED, LUT_VALUES, THRESHOLD, LUT_VALUES_BITWIDTH, EPS
 from model_compression_toolkit.core.pytorch.utils import to_torch_tensor
 
 
@@ -27,7 +27,7 @@ def activation_lut_kmean_quantizer(activation_n_bits: int,
 
 class PytorchLUTFakeQuant(torch.nn.Module):
     """
-    A custom PyTorch layer for quantizing activation tensor with non-uniform quantization (using lookup table clustering).
+    A custom PyTorch layer for quantizing activation tensor with non-uniform quantization (using lookup table values).
     """
 
     def __init__(self,
@@ -43,7 +43,7 @@ class PytorchLUTFakeQuant(torch.nn.Module):
 
         self.quantization_params = quantization_params
         self.activation_is_signed = self.quantization_params.get(SIGNED)
-        self.cluster_centers = to_torch_tensor(self.quantization_params.get(CLUSTER_CENTERS))
+        self.lut_values = to_torch_tensor(self.quantization_params.get(LUT_VALUES))
         self.threshold = self.quantization_params.get(THRESHOLD)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
@@ -56,7 +56,7 @@ class PytorchLUTFakeQuant(torch.nn.Module):
         Returns:
             Quantized torch Tensor.
         """
-        if self.activation_is_signed is None or self.cluster_centers is None or self.threshold is None:
+        if self.activation_is_signed is None or self.lut_values is None or self.threshold is None:
             return None   # pragma: no cover
 
         _quant_output = self.lut_kmeans_quantizer(x)
@@ -76,14 +76,14 @@ class PytorchLUTFakeQuant(torch.nn.Module):
         Returns: Quantized tensor.
         """
 
-        tensor = self.int_quantization_with_threshold(tensor_data, MULTIPLIER_N_BITS)
+        tensor = self.int_quantization_with_threshold(tensor_data, LUT_VALUES_BITWIDTH)
         tensor = tensor.unsqueeze(-1)
 
-        expanded_cluster_centers = self.cluster_centers.reshape([*[1 for _ in range(len(tensor.shape) - 1)], -1])
-        cluster_assignments = torch.argmin(torch.abs(tensor - expanded_cluster_centers), dim=-1)
-        centers = self.cluster_centers.flatten()[cluster_assignments]
+        expanded_lut_values = self.lut_values.reshape([*[1 for _ in range(len(tensor.shape) - 1)], -1])
+        lut_values_assignments = torch.argmin(torch.abs(tensor - expanded_lut_values), dim=-1)
+        centers = self.lut_values.flatten()[lut_values_assignments]
 
-        quant_tensor = (centers / (2 ** (MULTIPLIER_N_BITS - int(self.activation_is_signed)))) * self.threshold
+        quant_tensor = (centers / (2 ** (LUT_VALUES_BITWIDTH - int(self.activation_is_signed)))) * self.threshold
 
         return quant_tensor
 

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py

@@ -15,7 +15,7 @@
 from typing import Dict, Any
 
 from model_compression_toolkit.core.common import BaseNode
-from model_compression_toolkit.constants import THRESHOLD, RANGE_MIN, RANGE_MAX, SIGNED, CLUSTER_CENTERS, SCALE_PER_CHANNEL
+from model_compression_toolkit.constants import THRESHOLD, RANGE_MIN, RANGE_MAX, SIGNED, LUT_VALUES, SCALE_PER_CHANNEL
 from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
     NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
 
@@ -66,7 +66,7 @@ def get_inferable_quantizer_kwargs(node_qc: BaseNodeQuantizationConfig,
         elif quantization_method in [QuantizationMethod.LUT_SYM_QUANTIZER, QuantizationMethod.LUT_POT_QUANTIZER]:
             return {qi_keras_consts.NUM_BITS: node_qc.weights_n_bits,
                     qi_keras_consts.PER_CHANNEL: node_qc.weights_per_channel_threshold,
-                    qi_keras_consts.CLUSTER_CENTERS: list(node_qc.weights_quantization_params[CLUSTER_CENTERS].flatten()),
+                    qi_keras_consts.LUT_VALUES: list(node_qc.weights_quantization_params[LUT_VALUES].flatten()),
                     qi_keras_consts.THRESHOLD: list(node_qc.weights_quantization_params[SCALE_PER_CHANNEL].flatten()),
                     qi_keras_consts.CHANNEL_AXIS: node_qc.weights_channels_axis,
                     # TODO: how to pass multiplier nbits and eps for a specific node?
@@ -98,7 +98,7 @@ def get_inferable_quantizer_kwargs(node_qc: BaseNodeQuantizationConfig,
         elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER]:
             return {qi_keras_consts.NUM_BITS: node_qc.activation_n_bits,
                     qi_keras_consts.SIGNED: node_qc.activation_quantization_params[SIGNED],
-                    qi_keras_consts.CLUSTER_CENTERS: node_qc.activation_quantization_params[CLUSTER_CENTERS],
+                    qi_keras_consts.LUT_VALUES: node_qc.activation_quantization_params[LUT_VALUES],
                     qi_keras_consts.THRESHOLD: [node_qc.activation_quantization_params[THRESHOLD]]
                     # TODO: how to pass multiplier nbits and eps for a specific node?
                     }

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py

@@ -17,7 +17,7 @@ from typing import Dict, Any
 
 from model_compression_toolkit.core.common import BaseNode
 from model_compression_toolkit.constants import THRESHOLD, SIGNED, RANGE_MIN, RANGE_MAX, \
-    SCALE_PER_CHANNEL, CLUSTER_CENTERS
+    SCALE_PER_CHANNEL, LUT_VALUES
 from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
     NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
 from model_compression_toolkit.logger import Logger
@@ -64,11 +64,11 @@ def get_weights_inferable_quantizer_kwargs(node_qc: NodeWeightsQuantizationConfi
 
     elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER, QuantizationMethod.LUT_SYM_QUANTIZER]:
         return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.weights_n_bits,
-                qi_inferable_quantizers_constants.CLUSTER_CENTERS: node_qc.weights_quantization_params[CLUSTER_CENTERS].flatten(),
+                qi_inferable_quantizers_constants.LUT_VALUES: node_qc.weights_quantization_params[LUT_VALUES].flatten(),
                 qi_inferable_quantizers_constants.THRESHOLD: node_qc.weights_quantization_params[SCALE_PER_CHANNEL].flatten(),
                 qi_inferable_quantizers_constants.PER_CHANNEL: node_qc.weights_per_channel_threshold,
                 qi_inferable_quantizers_constants.CHANNEL_AXIS: node_qc.weights_channels_axis}
-                # TODO: Add MULTIPLIER_N_BITS & EPS to node quantization config
+                # TODO: Add LUT_VALUES_BITWIDTH & EPS to node quantization config
 
     else:
         Logger.critical(f'Not supported quantization method for weights inferable quantizers.')  # pragma: no cover
@@ -106,12 +106,12 @@ def get_activation_inferable_quantizer_kwargs(node_qc: NodeActivationQuantizatio
 
     elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER]:
         return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.activation_n_bits,
-                qi_inferable_quantizers_constants.CLUSTER_CENTERS: np.asarray(
-                    [node_qc.activation_quantization_params[CLUSTER_CENTERS]]),
+                qi_inferable_quantizers_constants.LUT_VALUES: np.asarray(
+                    [node_qc.activation_quantization_params[LUT_VALUES]]),
                 qi_inferable_quantizers_constants.THRESHOLD: np.asarray(
                     [node_qc.activation_quantization_params[THRESHOLD]]),
                 qi_inferable_quantizers_constants.SIGNED: node_qc.activation_quantization_params.get(SIGNED)}
-        # TODO: Add MULTIPLIER_N_BITS & EPS to node quantization config
+        # TODO: Add LUT_VALUES_BITWIDTH & EPS to node quantization config
     else:
         Logger.critical(f'Not supported quantization method for inferable quantizers.')  # pragma: no cover
 

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py

@@ -63,7 +63,7 @@ class OpQuantizationConfig:
         self.quantization_preserving = quantization_preserving
         self.fixed_scale = fixed_scale
         self.fixed_zero_point = fixed_zero_point
-        self.weights_multiplier_nbits = weights_multiplier_nbits
+        self.eights_lut_values_bitwidth = weights_multiplier_nbits
 
     def get_info(self):
         """

{mct-nightly-1.9.0.20230812.post349 → mct-nightly-1.9.0.20230814.post352}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 description-file = README.md
-version = 1.9.0.20230812-000349
+version = 1.9.0.20230814-000352
 
 [egg_info]
 tag_build =