mct-nightly 1.9.0.20230621.post405__py3-none-any.whl → 1.9.0.20230623.post423__py3-none-any.whl

{mct_nightly-1.9.0.20230621.post405.dist-info → mct_nightly-1.9.0.20230623.post423.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 1.9.0.20230621.post405
+Version: 1.9.0.20230623.post423
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct_nightly-1.9.0.20230621.post405.dist-info → mct_nightly-1.9.0.20230623.post423.dist-info}/RECORD

@@ -251,13 +251,13 @@ model_compression_toolkit/exporter/model_wrapper/keras/__init__.py,sha256=cco4Tm
 model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py,sha256=ihcMbqi_UGYnDZNnTS3XouKF7dmrrBGIZbfFEzW6KXE,3543
 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=iuo76cqmoHpF9eAc3Sqz4W-i6nnY1eeySBOdzh8bY5g,4287
-model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py,sha256=prOosEwrTEUsg4gvnZwgyLtDu2id-eMsZ97pEHHBGwM,8318
+model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py,sha256=2Ex9kTJ4H9dQzV_5KHXCIk_tdgs3DFv8OwNALHS8PK8,8764
 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=gNURwKHO5C3fez_SPZ9lxfp7FamN5A6W6Jp4AaGQJBE,7582
+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_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
@@ -276,7 +276,7 @@ model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=UKnP0iZlLjKVe
 model_compression_toolkit/gptq/keras/quantizer/__init__.py,sha256=-DK1CDXvlsnEbki4lukZLpl6Xrbo91_jcqxXlG5Eg6Q,963
 model_compression_toolkit/gptq/keras/quantizer/base_keras_gptq_quantizer.py,sha256=RWmsUXCw051shsPZ6igkSJBzqp7r4ddW1zYzZd3g0Xs,4751
 model_compression_toolkit/gptq/keras/quantizer/quant_utils.py,sha256=Vt7Qb8i4JsE4sFtcjpfM4FTXTtfV1t6SwfoNH8a_Iaw,5055
-model_compression_toolkit/gptq/keras/quantizer/quantization_builder.py,sha256=fh5CNTs0S47txLn8pWJfnif4CJEb1PsQbYFGBWhOp1Q,4136
+model_compression_toolkit/gptq/keras/quantizer/quantization_builder.py,sha256=lUJ2cT5WCSoEeOD6ZTk0MxqFD5KlBtcgNktIxpMfZpI,4431
 model_compression_toolkit/gptq/keras/quantizer/regularization_factory.py,sha256=iKzHnxl2ZSEp09oatfJVoiDuu6Q_iN36mOxQzDr1cy8,2087
 model_compression_toolkit/gptq/keras/quantizer/soft_rounding/__init__.py,sha256=huHoBUcKNB6BnY6YaUCcFvdyBtBI172ZoUD8ZYeNc6o,696
 model_compression_toolkit/gptq/keras/quantizer/soft_rounding/soft_quantizer_reg.py,sha256=t9-CQZE9AgnQ_Lq4SPd5uemvNcbtUHnU0qTHnx-QxZc,3962
@@ -293,7 +293,7 @@ model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=T4512JClbZI
 model_compression_toolkit/gptq/pytorch/quantizer/__init__.py,sha256=ZHNHo1yzye44m9_ht4UUZfTpK01RiVR3Tr74-vtnOGI,968
 model_compression_toolkit/gptq/pytorch/quantizer/base_pytorch_gptq_quantizer.py,sha256=Zb-P0yRyZHHBlDvUBdRwxDpdduEJyJp6OT9pfKFF5ks,4171
 model_compression_toolkit/gptq/pytorch/quantizer/quant_utils.py,sha256=OocYYRqvl7rZ37QT0hTzfJnWGiNCPskg7cziTlR7TRk,3893
-model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py,sha256=PHbfJf7qdqWMmTGxxdGGoGFsQhhSqTELa6Sv3jeS9sQ,3996
+model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py,sha256=OAYcc34a6ozOIH4Ju4Bb1ggtSQ0MaBA-7sEpBkuui2I,4291
 model_compression_toolkit/gptq/pytorch/quantizer/regularization_factory.py,sha256=9owTzSu_xz29dsjONB-AYXuCZoPo_4nqxTk3yH18a0g,2089
 model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/__init__.py,sha256=lNJ29DYxaLUPDstRDA1PGI5r9Fulq_hvrZMlhst1Z5g,697
 model_compression_toolkit/gptq/pytorch/quantizer/soft_rounding/soft_quantizer_reg.py,sha256=oO7WgsAHMnWoXNm_gTKAAe-Nd79mGL_m677ai-ui424,4132
@@ -418,8 +418,8 @@ model_compression_toolkit/trainable_infrastructure/keras/load_model.py,sha256=Vq
 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.20230621.post405.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-1.9.0.20230621.post405.dist-info/METADATA,sha256=EwUkuJv0yr8rUVK4EJjLWewvKE3-BEGo60uHdOz7MCo,10872
-mct_nightly-1.9.0.20230621.post405.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-mct_nightly-1.9.0.20230621.post405.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-1.9.0.20230621.post405.dist-info/RECORD,,
+mct_nightly-1.9.0.20230623.post423.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-1.9.0.20230623.post423.dist-info/METADATA,sha256=7ao3yBjgYi_woxmPzx1rJKDIhTrncSAmOsZ0Gwj5mO0,10872
+mct_nightly-1.9.0.20230623.post423.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+mct_nightly-1.9.0.20230623.post423.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-1.9.0.20230623.post423.dist-info/RECORD,,

model_compression_toolkit/exporter/model_wrapper/keras/builder/node_to_quantizer.py

@@ -16,6 +16,8 @@ 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.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
+    NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
 
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
@@ -24,54 +26,59 @@ from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers.keras.quantizers import BaseKerasInferableQuantizer
 from mct_quantizers import constants as qi_keras_consts
 
-def get_inferable_quantizer_kwargs(node: BaseNode,
+
+def get_inferable_quantizer_kwargs(node_qc: BaseNodeQuantizationConfig,
                                    quantization_target: QuantizationTarget) -> Dict[str, Any]:
     """
     Get the quantization parameters for an inferable quantizer.
     Args:
-        node: The node for which the quantizer is being created.
+        node_qc: The node quantization configuration of the node for which the quantizer is being created.
+            Needs to match the specific quantization target.
         quantization_target: The target of the quantization (weights or activations).
+
     Returns:
         The quantization parameters as a dictionary.
     """
 
     if quantization_target == QuantizationTarget.Weights:
-        # Get the weights quantization configuration for the node
-        node_w_qc = node.final_weights_quantization_cfg
-        quantization_method = node_w_qc.weights_quantization_method
+        if not isinstance(node_qc, NodeWeightsQuantizationConfig):
+            Logger.error(f"Non-compatible node quantization config was given for quantization target Weights.")  # pragma: no cover
+
+        quantization_method = node_qc.weights_quantization_method
 
         # Return the appropriate quantization parameters based on the quantization method
         if quantization_method in [QuantizationMethod.POWER_OF_TWO,
                                    QuantizationMethod.SYMMETRIC]:
-            return {qi_keras_consts.NUM_BITS: node_w_qc.weights_n_bits,
-                    qi_keras_consts.THRESHOLD: list(node_w_qc.weights_quantization_params[THRESHOLD].flatten()),
-                    qi_keras_consts.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
-                    qi_keras_consts.CHANNEL_AXIS: node_w_qc.weights_channels_axis,
-                    qi_keras_consts.INPUT_RANK: len(node_w_qc.weights_quantization_params[THRESHOLD].shape)}
+            return {qi_keras_consts.NUM_BITS: node_qc.weights_n_bits,
+                    qi_keras_consts.THRESHOLD: list(node_qc.weights_quantization_params[THRESHOLD].flatten()),
+                    qi_keras_consts.PER_CHANNEL: node_qc.weights_per_channel_threshold,
+                    qi_keras_consts.CHANNEL_AXIS: node_qc.weights_channels_axis,
+                    qi_keras_consts.INPUT_RANK: len(node_qc.weights_quantization_params[THRESHOLD].shape)}
 
         elif quantization_method in [QuantizationMethod.UNIFORM]:
-            return {qi_keras_consts.NUM_BITS: node_w_qc.weights_n_bits,
-                    qi_keras_consts.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
-                    qi_keras_consts.MIN_RANGE: list(node_w_qc.weights_quantization_params[RANGE_MIN].flatten()),
-                    qi_keras_consts.MAX_RANGE: list(node_w_qc.weights_quantization_params[RANGE_MAX].flatten()),
-                    qi_keras_consts.CHANNEL_AXIS: node_w_qc.weights_channels_axis,
-                    qi_keras_consts.INPUT_RANK: len(node_w_qc.weights_quantization_params[RANGE_MIN].shape)}
+            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.MIN_RANGE: list(node_qc.weights_quantization_params[RANGE_MIN].flatten()),
+                    qi_keras_consts.MAX_RANGE: list(node_qc.weights_quantization_params[RANGE_MAX].flatten()),
+                    qi_keras_consts.CHANNEL_AXIS: node_qc.weights_channels_axis,
+                    qi_keras_consts.INPUT_RANK: len(node_qc.weights_quantization_params[RANGE_MIN].shape)}
 
         elif quantization_method in [QuantizationMethod.LUT_SYM_QUANTIZER, QuantizationMethod.LUT_POT_QUANTIZER]:
-            return {qi_keras_consts.NUM_BITS: node_w_qc.weights_n_bits,
-                    qi_keras_consts.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
-                    qi_keras_consts.CLUSTER_CENTERS: node_w_qc.weights_quantization_params[CLUSTER_CENTERS],
-                    qi_keras_consts.THRESHOLD: list(node_w_qc.weights_quantization_params[SCALE_PER_CHANNEL].flatten()),
-                    qi_keras_consts.CHANNEL_AXIS: node_w_qc.weights_channels_axis,
+            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: node_qc.weights_quantization_params[CLUSTER_CENTERS],
+                    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?
-                    qi_keras_consts.INPUT_RANK: len(node_w_qc.weights_quantization_params[SCALE_PER_CHANNEL].shape)}
+                    qi_keras_consts.INPUT_RANK: len(node_qc.weights_quantization_params[SCALE_PER_CHANNEL].shape)}
 
         else:
             Logger.critical(f'Not supported quantization method for inferable quantizers.')  # pragma: no cover
 
     elif quantization_target == QuantizationTarget.Activation:
-        # Get the activation quantization configuration for the node
-        node_qc = node.final_activation_quantization_cfg
+        if not isinstance(node_qc, NodeActivationQuantizationConfig):
+            Logger.error(f"Non-compatible node quantization config was given for quantization target Activation.")  # pragma: no cover
+
         quantization_method = node_qc.activation_quantization_method
 
         # Return the appropriate quantization parameters based on the quantization method
@@ -118,7 +125,7 @@ def get_weights_quantizer_for_node(node: BaseNode) -> BaseKerasInferableQuantize
     quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Weights,
                                                       weights_quantization_method,
                                                       BaseKerasInferableQuantizer)
-    kwargs = get_inferable_quantizer_kwargs(node, QuantizationTarget.Weights)
+    kwargs = get_inferable_quantizer_kwargs(node_w_qc, QuantizationTarget.Weights)
 
     return quantier_for_node(**kwargs)
 
@@ -140,6 +147,6 @@ def get_activations_quantizer_for_node(node: BaseNode) -> BaseKerasInferableQuan
     quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
                                                       activation_quantization_method,
                                                       BaseKerasInferableQuantizer)
-    kwargs = get_inferable_quantizer_kwargs(node, QuantizationTarget.Activation)
+    kwargs = get_inferable_quantizer_kwargs(node_act_qc, QuantizationTarget.Activation)
 
     return quantier_for_node(**kwargs)

model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantizer.py

@@ -18,6 +18,8 @@ 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
+from model_compression_toolkit.core.common.quantization.node_quantization_config import BaseNodeQuantizationConfig, \
+    NodeWeightsQuantizationConfig, NodeActivationQuantizationConfig
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from mct_quantizers import QuantizationTarget
@@ -28,41 +30,66 @@ from mct_quantizers.pytorch.quantizers import BasePyTorchInferableQuantizer
 import numpy as np
 
 
-def get_weights_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
-    # Get the weights quantization configuration for the node
-    node_w_qc = node.final_weights_quantization_cfg
-    quantization_method = node_w_qc.weights_quantization_method
+def get_weights_inferable_quantizer_kwargs(node_qc: NodeWeightsQuantizationConfig) -> Dict[str, Any]:
+    """
+    Get the quantization parameters for a weights inferable quantizer.
+    Args:
+        node_qc: The node quantization configuration of the node for which the quantizer is being created.
+            Needs to match the specific quantization target.
+
+    Returns:
+        The quantization parameters as a dictionary.
+    """
+
+    if not isinstance(node_qc, NodeWeightsQuantizationConfig):
+        Logger.error(
+            f"Non-compatible node quantization config was given for quantization target Weights.")  # pragma: no cover
+
+    quantization_method = node_qc.weights_quantization_method
 
     # Return the appropriate quantization parameters based on the quantization method
     if quantization_method in [QuantizationMethod.POWER_OF_TWO,
                                QuantizationMethod.SYMMETRIC]:
-        return {qi_inferable_quantizers_constants.NUM_BITS: node_w_qc.weights_n_bits,
-                qi_inferable_quantizers_constants.THRESHOLD: node_w_qc.weights_quantization_params[THRESHOLD].flatten(),
-                qi_inferable_quantizers_constants.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
-                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_w_qc.weights_channels_axis}
+        return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.weights_n_bits,
+                qi_inferable_quantizers_constants.THRESHOLD: node_qc.weights_quantization_params[THRESHOLD].flatten(),
+                qi_inferable_quantizers_constants.PER_CHANNEL: node_qc.weights_per_channel_threshold,
+                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_qc.weights_channels_axis}
 
     elif quantization_method in [QuantizationMethod.UNIFORM]:
-        return {qi_inferable_quantizers_constants.NUM_BITS: node_w_qc.weights_n_bits,
-                qi_inferable_quantizers_constants.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
-                qi_inferable_quantizers_constants.MIN_RANGE: node_w_qc.weights_quantization_params[RANGE_MIN].flatten(),
-                qi_inferable_quantizers_constants.MAX_RANGE: node_w_qc.weights_quantization_params[RANGE_MAX].flatten(),
-                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_w_qc.weights_channels_axis}
+        return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.weights_n_bits,
+                qi_inferable_quantizers_constants.PER_CHANNEL: node_qc.weights_per_channel_threshold,
+                qi_inferable_quantizers_constants.MIN_RANGE: node_qc.weights_quantization_params[RANGE_MIN].flatten(),
+                qi_inferable_quantizers_constants.MAX_RANGE: node_qc.weights_quantization_params[RANGE_MAX].flatten(),
+                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_qc.weights_channels_axis}
 
     elif quantization_method in [QuantizationMethod.LUT_POT_QUANTIZER, QuantizationMethod.LUT_SYM_QUANTIZER]:
-        return {qi_inferable_quantizers_constants.NUM_BITS: node_w_qc.weights_n_bits,
-                qi_inferable_quantizers_constants.CLUSTER_CENTERS: node_w_qc.weights_quantization_params[CLUSTER_CENTERS].flatten(),
-                qi_inferable_quantizers_constants.THRESHOLD: node_w_qc.weights_quantization_params[SCALE_PER_CHANNEL].flatten(),
-                qi_inferable_quantizers_constants.PER_CHANNEL: node_w_qc.weights_per_channel_threshold,
-                qi_inferable_quantizers_constants.CHANNEL_AXIS: node_w_qc.weights_channels_axis}
+        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.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
 
     else:
         Logger.critical(f'Not supported quantization method for weights inferable quantizers.')  # pragma: no cover
 
 
-def get_activation_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
-    # Get the activation quantization configuration for the node
-    node_qc = node.final_activation_quantization_cfg
+def get_activation_inferable_quantizer_kwargs(node_qc: NodeActivationQuantizationConfig) -> Dict[str, Any]:
+    """
+    Get the quantization parameters for an activation inferable quantizer.
+
+    Args:
+        node_qc: The node quantization configuration of the node for which the quantizer is being created.
+            Needs to match the specific quantization target.
+
+    Returns:
+        The quantization parameters as a dictionary.
+    """
+
+    if not isinstance(node_qc, NodeActivationQuantizationConfig):
+        Logger.error(
+            f"Non-compatible node quantization config was given for quantization target Activation.")  # pragma: no cover
+
     quantization_method = node_qc.activation_quantization_method
 
     # Return the appropriate quantization parameters based on the quantization method
@@ -109,7 +136,7 @@ def get_weights_quantizer_for_node(node: BaseNode) -> BasePyTorchInferableQuanti
     quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Weights,
                                                       weights_quantization_method,
                                                       BasePyTorchInferableQuantizer)
-    kwargs = get_weights_inferable_quantizer_kwargs(node)
+    kwargs = get_weights_inferable_quantizer_kwargs(node_w_qc)
 
     return quantier_for_node(**kwargs)
 
@@ -134,7 +161,7 @@ def get_activations_quantizer_for_node(node: BaseNode) -> BasePyTorchInferableQu
     quantizer_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
                                                        activation_quantization_method,
                                                        BasePyTorchInferableQuantizer)
-    kwargs = get_activation_inferable_quantizer_kwargs(node)
+    kwargs = get_activation_inferable_quantizer_kwargs(node_act_qc)
 
     return quantizer_for_node(**kwargs)
 

model_compression_toolkit/gptq/keras/quantizer/quantization_builder.py

@@ -24,6 +24,8 @@ from model_compression_toolkit.gptq.keras.quantizer.base_keras_gptq_quantizer im
 from mct_quantizers import QuantizationTarget
 from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers.keras.quantizers import BaseKerasInferableQuantizer
+
+from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.trainable_infrastructure.common.get_quantizer_config import \
     get_trainable_quantizer_weights_config
 from model_compression_toolkit.trainable_infrastructure.common.get_quantizers import \
@@ -63,13 +65,17 @@ def quantization_builder(n: common.BaseNode,
 
     activation_quantizers = []
     if n.is_activation_quantization_enabled():
+        if n.final_activation_quantization_cfg is None:
+            Logger.critical(f'Can not set quantizer for a node with no final activation quantization configuration')  #
+            # pragma: no cover
+
         quant_method = n.final_activation_quantization_cfg.activation_quantization_method
 
         quantizer_class = get_inferable_quantizer_class(quant_target=QuantizationTarget.Activation,
                                                         quant_method=quant_method,
                                                         quantizer_base_class=BaseKerasInferableQuantizer)
 
-        kwargs = get_inferable_quantizer_kwargs(n, QuantizationTarget.Activation)
+        kwargs = get_inferable_quantizer_kwargs(n.final_activation_quantization_cfg, QuantizationTarget.Activation)
 
         activation_quantizers.append(quantizer_class(**kwargs))
 

model_compression_toolkit/gptq/pytorch/quantizer/quantization_builder.py

@@ -24,6 +24,8 @@ from model_compression_toolkit.gptq.pytorch.quantizer.base_pytorch_gptq_quantize
 from mct_quantizers import QuantizationTarget
 from mct_quantizers.common.get_quantizers import get_inferable_quantizer_class
 from mct_quantizers.pytorch.quantizers import BasePyTorchInferableQuantizer
+
+from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.trainable_infrastructure.common.get_quantizer_config import \
     get_trainable_quantizer_weights_config
 from model_compression_toolkit.qat.pytorch.quantizer.base_pytorch_qat_quantizer import BasePytorchQATTrainableQuantizer
@@ -60,13 +62,17 @@ def quantization_builder(n: common.BaseNode,
                                                            **gptq_config.gptq_quantizer_params_override)})
     activation_quantizers = []
     if n.is_activation_quantization_enabled():
+        if n.final_activation_quantization_cfg is None:
+            Logger.critical(f'Can not set quantizer for a node with no final activation quantization configuration')  #
+            # pragma: no cover
+
         quant_method = n.final_activation_quantization_cfg.activation_quantization_method
 
         quantizer_class = get_inferable_quantizer_class(quant_target=QuantizationTarget.Activation,
                                                         quant_method=quant_method,
                                                         quantizer_base_class=BasePyTorchInferableQuantizer)
 
-        kwargs = get_activation_inferable_quantizer_kwargs(n)
+        kwargs = get_activation_inferable_quantizer_kwargs(n.final_activation_quantization_cfg)
 
         activation_quantizers.append(quantizer_class(**kwargs))