mct-nightly 1.9.0.20230813.post401__py3-none-any.whl → 1.9.0.20230814.post352__py3-none-any.whl

{mct_nightly-1.9.0.20230813.post401.dist-info → mct_nightly-1.9.0.20230814.post352.dist-info}/METADATA

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

{mct_nightly-1.9.0.20230813.post401.dist-info → mct_nightly-1.9.0.20230814.post352.dist-info}/RECORD

@@ -1,5 +1,5 @@
 model_compression_toolkit/__init__.py,sha256=Jvow82lnEcGy7Wr1diXvcgWoWvIbOryYekqdMYVve4I,3608
-model_compression_toolkit/constants.py,sha256=gLIPvDTywhkIe62utf1_oii8YEwHePiujIXFODCNr28,3825
+model_compression_toolkit/constants.py,sha256=C_kTcbYhWv90JoZVu4kT21b7aHaLEmsA--VDFXbiAJs,3817
 model_compression_toolkit/logger.py,sha256=b9DVktZ-LymFcRxv2aL_sdiE6S2sSrFGWltx6dgEuUY,4863
 model_compression_toolkit/core/__init__.py,sha256=qnBA6aaojI7RpEQZU2vXWiELHfVJf-MnAP-4T0tcFDY,2008
 model_compression_toolkit/core/analyzer.py,sha256=dbsD61pakp_9JXNyAScLdtJvcXny9jr_cMbET0Bd3Sg,2975
@@ -89,8 +89,8 @@ model_compression_toolkit/core/common/quantization/quantize_node.py,sha256=UK_Ys
 model_compression_toolkit/core/common/quantization/set_node_quantization_config.py,sha256=KuYd3fHdTKK8Pg1hLw8zB1CpexyltJOpQMcKMvLJmB8,10683
 model_compression_toolkit/core/common/quantization/quantization_params_generation/__init__.py,sha256=_U4IFPuzGyyAymjDjsPl2NF6UbFggqBaiA1Td3sug3I,1608
 model_compression_toolkit/core/common/quantization/quantization_params_generation/error_functions.py,sha256=rwCedE0zggamSBY50rqh-xqZpIMrn8o96YH_jMCuPrk,16505
-model_compression_toolkit/core/common/quantization/quantization_params_generation/kmeans_params.py,sha256=pJR7oD95LUn9f6A_ni1Yz1bITcV6ePztC93DAeveNJg,2927
-model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=p4Q2m8JiQm4cNaFh7MSVMBaeCh0QtHRX3BZZicngJHk,7286
+model_compression_toolkit/core/common/quantization/quantization_params_generation/kmeans_params.py,sha256=qDfJbvY64KLOG6n18ddEPTFGrKHlaXzZ136TrVpgH9s,2917
+model_compression_toolkit/core/common/quantization/quantization_params_generation/lut_kmeans_params.py,sha256=V__fKVcr6eCJcr7nmAJS24hBW6Wj33d-pKWLa8KwL4A,7289
 model_compression_toolkit/core/common/quantization/quantization_params_generation/outlier_filter.py,sha256=9gnfJV89jpGwAx8ImJ5E9NjCv3lDtbyulP4OtgWb62M,1772
 model_compression_toolkit/core/common/quantization/quantization_params_generation/power_of_two_selection.py,sha256=W4j9IB1Grj_Ku1pLjPxb-HLcYU9LTDuf9_0JilbqU2w,8484
 model_compression_toolkit/core/common/quantization/quantization_params_generation/qparams_activations_computation.py,sha256=noEdvGiyyW7acgQ2OFWLedCODibTGYJifC9qo8YIU5U,4558
@@ -100,9 +100,9 @@ model_compression_toolkit/core/common/quantization/quantization_params_generatio
 model_compression_toolkit/core/common/quantization/quantization_params_generation/symmetric_selection.py,sha256=53OFL3IZxtH-UPakf3h_LZkaZAa3cgc2oqgMUe3Sg8o,9689
 model_compression_toolkit/core/common/quantization/quantization_params_generation/uniform_selection.py,sha256=oiJn1twYpTaq_z5qX4d8_nnk_jouYWHq8z0WAknl5oE,7879
 model_compression_toolkit/core/common/quantization/quantizers/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
-model_compression_toolkit/core/common/quantization/quantizers/kmeans_quantizer.py,sha256=f8GtoebNR04cnCbQP-GW1GsvpfO1acC01yXoQey2OeU,2350
-model_compression_toolkit/core/common/quantization/quantizers/lut_kmeans_quantizer.py,sha256=srG9wH5wWvm5JdDc8gSZuL4QjzE8uCThgSmwTFGUHgE,2774
-model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py,sha256=7R58nhT3kRqz3UgA86ymjcVm-LXwSzu1FhjxYW-qDsI,14210
+model_compression_toolkit/core/common/quantization/quantizers/kmeans_quantizer.py,sha256=ZS3IXGbUTW580vwVF5jgxfPVYVL3tQrpvoSqDxVu7zQ,2325
+model_compression_toolkit/core/common/quantization/quantizers/lut_kmeans_quantizer.py,sha256=P0x_y18LypBxP2tV9OWizheYfILqvaMC8RwHo04sUpQ,2761
+model_compression_toolkit/core/common/quantization/quantizers/quantizers_helpers.py,sha256=5JuPwb9HDHaYQj1YyNWGY7GdjJ105Yr8iEEZhzfuRW4,14190
 model_compression_toolkit/core/common/quantization/quantizers/uniform_quantizers.py,sha256=FVeuK-LeuAsRFcqo5uaNHmb6oTOFs21ltghtqswl6KM,5486
 model_compression_toolkit/core/common/statistics_correction/__init__.py,sha256=sw7LOPN1bM82o3SkMaklyH0jw-TLGK0-fl2Wq73rffI,697
 model_compression_toolkit/core/common/statistics_correction/apply_bias_correction_to_graph.py,sha256=uUMgzZaGYf2rcaCQTIk2N0CaF5DZE5ZsHyAEXtSeCz0,3434
@@ -167,7 +167,7 @@ model_compression_toolkit/core/keras/mixed_precision/configurable_weights_quanti
 model_compression_toolkit/core/keras/quantizer/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/keras/quantizer/base_quantizer.py,sha256=eMRjAUU189-AVwNGMlV0M-ZlL48ZYmILzutheUT00xU,1628
 model_compression_toolkit/core/keras/quantizer/fake_quant_builder.py,sha256=Oi64CD83OopPoQNAarl2MJRbCKujU2W8Wdrs9KOPNWk,6151
-model_compression_toolkit/core/keras/quantizer/lut_fake_quant.py,sha256=I4bWNUCDfBq0tzjbijUS9tiSfSutOuddAihwRRXa_Fo,4507
+model_compression_toolkit/core/keras/quantizer/lut_fake_quant.py,sha256=Up3-sbuAcaJ6kfe7Sz3XN6iiJ9hlxzOMncLCFEXJFjk,4475
 model_compression_toolkit/core/keras/reader/__init__.py,sha256=mjbqLD-KcG3eNeCYpu1GBS7VclGVOQ63x2p6mAAuba4,698
 model_compression_toolkit/core/keras/reader/common.py,sha256=ScJaCiM8FuisN3sLbVsMQiIzkFlzr-gYEeL8M5lkoew,2627
 model_compression_toolkit/core/keras/reader/connectivity_handler.py,sha256=83Abmg-AILnN6NHJexI226ZaHEblLOX3H9sH6vXFQhA,11418
@@ -221,7 +221,7 @@ model_compression_toolkit/core/pytorch/mixed_precision/configurable_activation_q
 model_compression_toolkit/core/pytorch/mixed_precision/configurable_weights_quantizer.py,sha256=VUN9vvWQWAh281C0xgV3w4T2DkSaxFZ-xmBgF50vGdo,5961
 model_compression_toolkit/core/pytorch/quantizer/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/quantizer/fake_quant_builder.py,sha256=rox-f5wbRyxU1UHeHyaoIDXB9r9fCXm1dPN4FVwHqTc,6464
-model_compression_toolkit/core/pytorch/quantizer/lut_fake_quant.py,sha256=GbT3MEzq8_HryDiqUfnDjl57idKTUTOe-9kvcl5LUD8,4452
+model_compression_toolkit/core/pytorch/quantizer/lut_fake_quant.py,sha256=uyeBtNokyDUikk-YkDP_mN_2DX0J5oPm3kSfdSUT2Ck,4420
 model_compression_toolkit/core/pytorch/reader/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/core/pytorch/reader/graph_builders.py,sha256=bZxt288NjFD_VzsguYRfiGSkSekUT6vX5MhGwYywzHY,12113
 model_compression_toolkit/core/pytorch/reader/node_holders.py,sha256=dMvTTs1DER6TJ0FiSEmSdLa27WKpvP2Hz-kILUcnnIA,1789
@@ -250,13 +250,13 @@ model_compression_toolkit/exporter/model_wrapper/keras/__init__.py,sha256=cco4Tm
 model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py,sha256=XMXcszmMSEgeIc1tCNZqWjsyFt9ZmcgfWZQXDqnDMjM,3509
 model_compression_toolkit/exporter/model_wrapper/keras/builder/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/exporter/model_wrapper/keras/builder/fully_quantized_model_builder.py,sha256=P_701NG1OYwyxgbtPSjb-OYseDeiHjye8m9wjpAl6es,4253
-model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py,sha256=N8hjMf_PrSYajtSC0vq4DbpE7Nu41qoX4lDm0drfEOg,8780
+model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py,sha256=VFX8rvlaGTK-k-3g0ayAL_qJJR_6wtS54tn9RzxKev4,8755
 model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizers.py,sha256=n7VTA-a9TrLFpfdYAqrAKj6PGlAyLq8-xdwnMMpX71k,2077
 model_compression_toolkit/exporter/model_wrapper/pytorch/__init__.py,sha256=Rf1RcYmelmdZmBV5qOKvKWF575ofc06JFQSq83Jz99A,696
 model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py,sha256=gvX5ILs5vjQ_F_dq5KaFs0GOQEq9gYXO5a6YZlYY8h4,3449
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/fully_quantized_model_builder.py,sha256=SJ5fetbUMkmB0tkHkmVhMrLksh7eqMQJLFuMD08ZKWM,3921
-model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py,sha256=2ur9W4t_lMhHVXMs1b538470IU5KfQ5mGeD6AUbYd8s,8656
+model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py,sha256=66QXUQI1yvov9QXCW1s8LLN9N7gFwvVrPJDfzHayWZM,8635
 model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizers.py,sha256=hinP-wtyxZyoW860GdJAk6M3iPjmwwPXQTUxd56yhq8,2086
 model_compression_toolkit/gptq/__init__.py,sha256=2xos6AJziEy-eK91XtIJlunf8LhK4OayU7d6CQvXWsw,1276
 model_compression_toolkit/gptq/runner.py,sha256=vWd7cWKgTGc9oPcTtwTQZoI3MArCx19Y61uteLFCxVo,5534
@@ -336,7 +336,7 @@ model_compression_toolkit/target_platform_capabilities/immutable.py,sha256=rSPd3
 model_compression_toolkit/target_platform_capabilities/target_platform/__init__.py,sha256=_LzyDupsTDiJvIsVA-L-M_fRrW8ePcul8mr60L8DW9g,1574
 model_compression_toolkit/target_platform_capabilities/target_platform/current_tp_model.py,sha256=5Bu5MkOYYDGzZgTu-PBQ4xVCnso1mtssc9zz1pZjl7o,2010
 model_compression_toolkit/target_platform_capabilities/target_platform/fusing.py,sha256=NIKUE2AtRv4CFOhpwjVvfG3rLfvd6p7DYBSuK0SKo4s,2353
-model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py,sha256=Nh04rizl8D_qu_DvRacvmDwY9UjI53Jbcfjk1Rq6nD4,8538
+model_compression_toolkit/target_platform_capabilities/target_platform/op_quantization_config.py,sha256=lkiIhVdLML6FY3F_S-v01ZDa9lUUxzNl1rbu0f-6H2w,8540
 model_compression_toolkit/target_platform_capabilities/target_platform/operators.py,sha256=rRmrmPBY4rxCWVpEc6FxeOPUFh8MkfwgQsqD82U9a7w,3108
 model_compression_toolkit/target_platform_capabilities/target_platform/quantization_format.py,sha256=3UIZtGTV0WX3dbfiIMUFWID5W68vtKfiVoPWUbpQFzM,787
 model_compression_toolkit/target_platform_capabilities/target_platform/target_platform_model.py,sha256=dFauUrY7BejPDVX8HcSotoHKcT7S9kk65jgzZdPis2E,9206
@@ -421,8 +421,8 @@ model_compression_toolkit/trainable_infrastructure/keras/load_model.py,sha256=Dw
 model_compression_toolkit/trainable_infrastructure/keras/quantizer_utils.py,sha256=MVwXNymmFRB2NXIBx4e2mdJ1RfoHxRPYRgjb1MQP5kY,1797
 model_compression_toolkit/trainable_infrastructure/pytorch/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
 model_compression_toolkit/trainable_infrastructure/pytorch/base_pytorch_quantizer.py,sha256=SbvRlIdE32PEBsINt1bhSqvrKL_zbM9V-aeSkOn-sw4,3083
-mct_nightly-1.9.0.20230813.post401.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-1.9.0.20230813.post401.dist-info/METADATA,sha256=ZaK4d1ZFCSdjxOycD-Jw3HGMRLpUKFVXketl56x8Smg,10750
-mct_nightly-1.9.0.20230813.post401.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
-mct_nightly-1.9.0.20230813.post401.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-1.9.0.20230813.post401.dist-info/RECORD,,
+mct_nightly-1.9.0.20230814.post352.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-1.9.0.20230814.post352.dist-info/METADATA,sha256=NqhVoJcRgeb3DDNnTzIr4lTEk7fqgP4uMShzIt9b2dg,10750
+mct_nightly-1.9.0.20230814.post352.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+mct_nightly-1.9.0.20230814.post352.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-1.9.0.20230814.post352.dist-info/RECORD,,

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'

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,
             }

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}

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

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

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)
 
 

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
 

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
 

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?
                     }

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
 

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):
         """