mct-nightly 1.8.0.8032023.post421__py3-none-any.whl → 1.8.0.8052023.post414__py3-none-any.whl

model_compression_toolkit/exporter/model_wrapper/keras/validate_layer.py

@@ -14,61 +14,69 @@
 # ==============================================================================
 from typing import Any
 
-from keras.engine.input_layer import InputLayer
-
-from model_compression_toolkit.core.common import Logger
-from model_compression_toolkit.quantizers_infrastructure import KerasQuantizationWrapper
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import BaseInferableQuantizer
 
+from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.constants import FOUND_TF
 
+from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.base_inferable_quantizer import BaseInferableQuantizer
 
-def is_keras_layer_exportable(layer: Any) -> bool:
-    """
-    Check whether a Keras layer is a valid exportable layer or not.
 
-    Args:
-        layer: Keras layer to check if considered to be valid for exporting.
+if FOUND_TF:
+    from keras.engine.input_layer import InputLayer
+    from model_compression_toolkit.quantizers_infrastructure import KerasQuantizationWrapper
 
-    Returns:
+    def is_keras_layer_exportable(layer: Any) -> bool:
+        """
         Check whether a Keras layer is a valid exportable layer or not.
-    """
-    # Keras Input layers are not wrapped
-    if isinstance(layer, InputLayer):
-        return True
 
-    valid_layer = isinstance(layer, KerasQuantizationWrapper)
-    if not valid_layer:
-        Logger.error(
-            f'Exportable layer must be wrapped using KerasQuantizationWrapper, but layer {layer.name} is of type '
-            f'{type(layer)}') # pragma: no cover
+        Args:
+            layer: Keras layer to check if considered to be valid for exporting.
 
-    valid_weights_quantizers = isinstance(layer.weights_quantizers, dict)
-    if not valid_weights_quantizers:
-        Logger.error(
-            f'KerasQuantizationWrapper must have a weights_quantizers but has a '
-            f'{type(layer.weights_quantizers)} object') # pragma: no cover
+        Returns:
+            Check whether a Keras layer is a valid exportable layer or not.
+        """
+        # Keras Input layers are not wrapped
+        if isinstance(layer, InputLayer):
+            return True
 
-    for _, weights_quantizer in layer.weights_quantizers.items():
-        if not isinstance(weights_quantizer, BaseInferableQuantizer):
+        valid_layer = isinstance(layer, KerasQuantizationWrapper)
+        if not valid_layer:
             Logger.error(
-                f'weights_quantizer must be a BaseInferableQuantizer object but has a '
-                f'{type(weights_quantizer)} object')  # pragma: no cover
+                f'Exportable layer must be wrapped using KerasQuantizationWrapper, but layer {layer.name} is of type '
+                f'{type(layer)}') # pragma: no cover
 
-    valid_activation_quantizers = isinstance(layer.activation_quantizers, list)
-    if not valid_activation_quantizers:
-        Logger.error(
-            f'KerasQuantizationWrapper must have a activation_quantizers list but has a '
-            f'{type(layer.activation_quantizers)} object') # pragma: no cover
+        valid_weights_quantizers = isinstance(layer.weights_quantizers, dict)
+        if not valid_weights_quantizers:
+            Logger.error(
+                f'KerasQuantizationWrapper must have a weights_quantizers but has a '
+                f'{type(layer.weights_quantizers)} object') # pragma: no cover
+
+        for _, weights_quantizer in layer.weights_quantizers.items():
+            if not isinstance(weights_quantizer, BaseInferableQuantizer):
+                Logger.error(
+                    f'weights_quantizer must be a BaseInferableQuantizer object but has a '
+                    f'{type(weights_quantizer)} object')  # pragma: no cover
 
-    for activation_quantizers in layer.activation_quantizers:
-        if not isinstance(activation_quantizers, BaseInferableQuantizer):
+        valid_activation_quantizers = isinstance(layer.activation_quantizers, list)
+        if not valid_activation_quantizers:
             Logger.error(
-                f'activation_quantizers must be a BaseInferableQuantizer object but has a '
-                f'{type(activation_quantizers)} object')  # pragma: no cover
+                f'KerasQuantizationWrapper must have a activation_quantizers list but has a '
+                f'{type(layer.activation_quantizers)} object') # pragma: no cover
 
-    quantizers = layer.activation_quantizers + list(layer.weights_quantizers.values())
-    is_valid_quantizers = all([isinstance(x, BaseInferableQuantizer) for x in quantizers])
-    if not is_valid_quantizers:
-        Logger.error(f'Found a quantizer that is not of type BaseInferableQuantizer') # pragma: no cover
+        for activation_quantizers in layer.activation_quantizers:
+            if not isinstance(activation_quantizers, BaseInferableQuantizer):
+                Logger.error(
+                    f'activation_quantizers must be a BaseInferableQuantizer object but has a '
+                    f'{type(activation_quantizers)} object')  # pragma: no cover
 
-    return True
+        quantizers = layer.activation_quantizers + list(layer.weights_quantizers.values())
+        is_valid_quantizers = all([isinstance(x, BaseInferableQuantizer) for x in quantizers])
+        if not is_valid_quantizers:
+            Logger.error(f'Found a quantizer that is not of type BaseInferableQuantizer') # pragma: no cover
+
+        return True
+else:
+    def is_keras_layer_exportable(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing tensorflow and tensorflow_model_optimization is mandatory '
+                     'when using is_keras_layer_exportable. '
+                     'Could not find Tensorflow package.')

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

@@ -13,42 +13,50 @@
 # limitations under the License.
 # ==============================================================================
 
-import torch
 
 from model_compression_toolkit import quantizers_infrastructure as qi
 from model_compression_toolkit.core import common
 from model_compression_toolkit.core.common import Graph
-from model_compression_toolkit.core.pytorch.back2framework.pytorch_model_builder import PyTorchModelBuilder
-from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantizers import \
-    get_quantization_quantizers
-
-
-def fully_quantized_wrapper(node: common.BaseNode, module: torch.nn.Module) -> qi.PytorchQuantizationWrapper:
-    """
-    A function which takes a computational graph node and a pytorch module and
-    perform the quantization wrapping
-
-    Args:
-        node: A node of mct graph.
-        module: A Pytorch module
-
-    Returns: Wrapped layer
-
-    """
-    weight_quantizers, activation_quantizers = get_quantization_quantizers(node)
-    wrapped_layer = qi.PytorchQuantizationWrapper(module, weight_quantizers, activation_quantizers)
-    return wrapped_layer
-
-
-def get_exportable_pytorch_model(graph: Graph):
-    """
-    Convert graph to fully quantized PyTorch model.
-
-    Args:
-        graph: Graph to convert to a PyTorch model.
-
-    Returns:
-        Fully quantized PyTorch model.
-    """
-    return PyTorchModelBuilder(graph=graph,
-                               wrapper=fully_quantized_wrapper).build_model()
+from model_compression_toolkit.constants import FOUND_TORCH
+from model_compression_toolkit.logger import Logger
+
+if FOUND_TORCH:
+    import torch
+    from model_compression_toolkit.core.pytorch.back2framework.pytorch_model_builder import PyTorchModelBuilder
+    from model_compression_toolkit.exporter.model_wrapper.pytorch.builder.node_to_quantizers import \
+        get_quantization_quantizers
+
+    def fully_quantized_wrapper(node: common.BaseNode, module: torch.nn.Module) -> qi.PytorchQuantizationWrapper:
+        """
+        A function which takes a computational graph node and a pytorch module and
+        perform the quantization wrapping
+
+        Args:
+            node: A node of mct graph.
+            module: A Pytorch module
+
+        Returns: Wrapped layer
+
+        """
+        weight_quantizers, activation_quantizers = get_quantization_quantizers(node)
+        wrapped_layer = qi.PytorchQuantizationWrapper(module, weight_quantizers, activation_quantizers)
+        return wrapped_layer
+
+
+    def get_exportable_pytorch_model(graph: Graph):
+        """
+        Convert graph to fully quantized PyTorch model.
+
+        Args:
+            graph: Graph to convert to a PyTorch model.
+
+        Returns:
+            Fully quantized PyTorch model.
+        """
+        return PyTorchModelBuilder(graph=graph,
+                                   wrapper=fully_quantized_wrapper).build_model()
+else:
+    def get_exportable_pytorch_model(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing torch is mandatory '
+                     'when using get_exportable_pytorch_model. '
+                     'Could not find PyTorch package.')

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

@@ -15,9 +15,11 @@
 
 from typing import Dict, Any
 
-from model_compression_toolkit.core.common import BaseNode, Logger
-from model_compression_toolkit.core.common.constants import THRESHOLD, SIGNED, RANGE_MIN, RANGE_MAX
-from model_compression_toolkit.core.common.target_platform import QuantizationMethod
+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.logger import Logger
+from model_compression_toolkit.target_platform_capabilities.target_platform import QuantizationMethod
 from model_compression_toolkit.quantizers_infrastructure import QuantizationTarget
 from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.common.get_quantizers import \
     get_inferable_quantizer_class
@@ -45,6 +47,15 @@ def get_weights_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
                 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}
+
+    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}
+                # 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
 
@@ -65,6 +76,15 @@ def get_activation_inferable_quantizer_kwargs(node: BaseNode) -> Dict[str, Any]:
         return {qi_inferable_quantizers_constants.NUM_BITS: node_qc.activation_n_bits,
                 qi_inferable_quantizers_constants.MIN_RANGE: np.asarray([node_qc.activation_quantization_params[RANGE_MIN]]),
                 qi_inferable_quantizers_constants.MAX_RANGE: np.asarray([node_qc.activation_quantization_params[RANGE_MAX]])}
+
+    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.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
     else:
         Logger.critical(f'Not supported quantization method for inferable quantizers.')  # pragma: no cover
 
@@ -111,10 +131,10 @@ def get_activations_quantizer_for_node(node: BaseNode) -> BasePyTorchInferableQu
     node_act_qc = node.final_activation_quantization_cfg
     activation_quantization_method = node_act_qc.activation_quantization_method
 
-    quantier_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
-                                                      activation_quantization_method,
-                                                      BasePyTorchInferableQuantizer)
+    quantizer_for_node = get_inferable_quantizer_class(QuantizationTarget.Activation,
+                                                       activation_quantization_method,
+                                                       BasePyTorchInferableQuantizer)
     kwargs = get_activation_inferable_quantizer_kwargs(node)
 
-    return quantier_for_node(**kwargs)
+    return quantizer_for_node(**kwargs)
 

model_compression_toolkit/exporter/model_wrapper/pytorch/validate_layer.py

@@ -14,24 +14,31 @@
 # ==============================================================================
 from typing import Any
 
-from model_compression_toolkit.quantizers_infrastructure import PytorchQuantizationWrapper
-from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
-    BasePyTorchInferableQuantizer
+from model_compression_toolkit.logger import Logger
+from model_compression_toolkit.constants import FOUND_TORCH
 
+if FOUND_TORCH:
+    from model_compression_toolkit.quantizers_infrastructure import PytorchQuantizationWrapper
+    from model_compression_toolkit.quantizers_infrastructure.inferable_infrastructure.pytorch.quantizers import \
+        BasePyTorchInferableQuantizer
+    def is_pytorch_layer_exportable(layer: Any) -> bool:
+        """
+        Check whether a torch Module is a valid exportable module or not.
 
-def is_pytorch_layer_exportable(layer: Any) -> bool:
-    """
-    Check whether a torch Module is a valid exportable module or not.
+        Args:
+            layer: PyTorch module to check if considered to be valid for exporting.
 
-    Args:
-        layer: PyTorch module to check if considered to be valid for exporting.
-
-    Returns:
-        Check whether a PyTorch layer is a valid exportable layer or not.
-    """
-    if isinstance(layer, PytorchQuantizationWrapper):
-        quantizers = list(layer.weights_quantizers.values())
-        quantizers.extend(layer.activation_quantizers)
-        if all([isinstance(q, BasePyTorchInferableQuantizer) for q in quantizers]):
-            return True
-    return False
+        Returns:
+            Check whether a PyTorch layer is a valid exportable layer or not.
+        """
+        if isinstance(layer, PytorchQuantizationWrapper):
+            quantizers = list(layer.weights_quantizers.values())
+            quantizers.extend(layer.activation_quantizers)
+            if all([isinstance(q, BasePyTorchInferableQuantizer) for q in quantizers]):
+                return True
+        return False
+else:
+    def is_pytorch_layer_exportable(*args, **kwargs):  # pragma: no cover
+        Logger.error('Installing torch is mandatory '
+                     'when using is_pytorch_layer_exportable. '
+                     'Could not find PyTorch package.')

model_compression_toolkit/gptq/__init__.py

@@ -12,3 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+
+from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, RoundingType, GradientPTQConfigV2
+from model_compression_toolkit.gptq.keras.quantization_facade import keras_gradient_post_training_quantization_experimental
+from model_compression_toolkit.gptq.keras.quantization_facade import get_keras_gptq_config
+from model_compression_toolkit.gptq.pytorch.quantization_facade import pytorch_gradient_post_training_quantization_experimental
+from model_compression_toolkit.gptq.pytorch.quantization_facade import get_pytorch_gptq_config

model_compression_toolkit/gptq/common/gptq_config.py

@@ -16,9 +16,7 @@ from enum import Enum
 from typing import Callable, Any, Dict
 from model_compression_toolkit.core.common.defaultdict import DefaultDict
 from model_compression_toolkit.core import common
-from model_compression_toolkit.gptq.common.gptq_constants import N_BATCHES_STR, QUANT_PARAM_LEARNING_STR, N_EPOCHS_STR, \
-    MAX_LSB_STR
-from model_compression_toolkit.gptq.common.gptq_quantizer_config import GPTQQuantizerConfig, SoftQuantizerConfig
+from model_compression_toolkit.gptq.common.gptq_constants import QUANT_PARAM_LEARNING_STR, MAX_LSB_STR, REG_DEFAULT
 
 
 class RoundingType(Enum):
@@ -31,30 +29,53 @@ class RoundingType(Enum):
     SoftQuantizer = 1
 
 
+class GPTQHessianWeightsConfig:
+    """
+    Configuration to use for computing the Hessian-based weights for GPTQ loss metric.
+    """
+
+    def __init__(self,
+                 hessians_num_samples: int = 16,
+                 norm_weights: bool = True,
+                 log_norm: bool = True,
+                 scale_log_norm: bool = False,
+                 hessians_n_iter: int = 50):
+
+        """
+        Initialize a GPTQHessianWeightsConfig.
+        Args:
+            hessians_num_samples (int): Number of samples to use for computing the Hessian-based weights.
+            norm_weights (bool): Whether to normalize the returned weights (to get values between 0 and 1).
+            log_norm (bool): Whether to use log normalization to the GPTQ Hessian-based weights.
+            scale_log_norm (bool): Whether to scale the final vector of the Hessian weights.
+            hessians_n_iter (int): Number of random iterations to run Hessian approximation for GPTQ weights.
+        """
+
+        self.hessians_num_samples = hessians_num_samples
+        self.norm_weights = norm_weights
+        self.log_norm = log_norm
+        self.scale_log_norm = scale_log_norm
+        self.hessians_n_iter = hessians_n_iter
+
+
 class GradientPTQConfig:
     """
     Configuration to use for quantization with GradientPTQ (experimental).
     """
 
-    def __init__(self,
-                 n_iter: int,
+    def __init__(self, n_iter: int,
                  optimizer: Any,
                  optimizer_rest: Any = None,
                  loss: Callable = None,
                  log_function: Callable = None,
                  train_bias: bool = True,
-                 quantization_parameters_learning: bool = False,
                  rounding_type: RoundingType = RoundingType.SoftQuantizer,
-                 lsb_change_per_bit_width: dict = DefaultDict({}, lambda: 1),
-                 eps: float = 1e-6,
-                 use_jac_based_weights: bool = True,
-                 num_samples_for_loss: int = 16,
-                 norm_weights: bool = False,
+                 use_hessian_based_weights: bool = True,
                  optimizer_quantization_parameter: Any = None,
                  optimizer_bias: Any = None,
-                 log_norm: bool = True,
-                 weights_n_iter: int = 50,
-                 quantizer_config: GPTQQuantizerConfig = SoftQuantizerConfig()):
+                 regularization_factor: float = REG_DEFAULT,
+                 hessian_weights_config: GPTQHessianWeightsConfig = GPTQHessianWeightsConfig(),
+                 gptq_quantizer_params_override: Dict[str, Any] = None):
         """
         Initialize a GradientPTQConfig.
 
@@ -67,18 +88,13 @@ class GradientPTQConfig:
              accordingly. see example in multiple_tensors_mse_loss
             log_function (Callable): Function to log information about the GPTQ process.
             train_bias (bool): Whether to update the bias during the training or not.
-            quantization_parameters_learning (bool): Whether to update the quantization param during the training or not.
             rounding_type (RoundingType): An enum that defines the rounding type.
-            lsb_change_per_bit_width (dict): Whether to update the bias during the training or not.
-            eps (float): A floating point value for numeric stability.
-            use_jac_based_weights (bool): Whether to use jacobian-based weights for weighted average loss.
-            num_samples_for_loss (int): Number of samples to use for computing the jacobian-based weights.
-            norm_weights (bool): Whether to normalize the returned weights (to get values between 0 and 1).
+            use_hessian_based_weights (bool): Whether to use Hessian-based weights for weighted average loss.
             optimizer_quantization_parameter (Any): Optimizer to override the rest optimizer  for quantizer parameters.
             optimizer_bias (Any): Optimizer to override the rest optimizer for bias.
-            log_norm (bool): Whether to use log normalization to the GPTQ Jacobian-based weights.
-            weights_n_iter (int): Number of random iterations to run Jacobian approximation for GPTQ weights.
-            quantizer_config (GPTQQuantizerConfig): A class that contains the quantizer specific config.
+            regularization_factor (float): A floating point number that defines the regularization factor.
+            hessian_weights_config (GPTQHessianWeightsConfig): A configuration that include all necessary arguments to run a computation of Hessian weights for the GPTQ loss.
+            gptq_quantizer_params_override (dict): A dictionary of parameters to override in GPTQ quantizer instantiation. Defaults to None (no parameters).
 
         """
         self.n_iter = n_iter
@@ -88,68 +104,34 @@ class GradientPTQConfig:
         self.log_function = log_function
         self.train_bias = train_bias
 
-        if quantization_parameters_learning and rounding_type == RoundingType.STE:
-            common.Logger.error("Quantization parameters learning is not supported with STE rounding.")
-
-        self.quantization_parameters_learning = quantization_parameters_learning
         self.rounding_type = rounding_type
-        self.lsb_change_per_bit_width = lsb_change_per_bit_width
-        self.eps = eps
-        self.use_jac_based_weights = use_jac_based_weights
-        self.num_samples_for_loss = num_samples_for_loss
-        self.norm_weights = norm_weights
+        self.use_hessian_based_weights = use_hessian_based_weights
         self.optimizer_quantization_parameter = optimizer_quantization_parameter
         self.optimizer_bias = optimizer_bias
-        self.log_norm = log_norm
-        self.weights_n_iter = weights_n_iter
+        self.regularization_factor = regularization_factor
+        self.hessian_weights_config = hessian_weights_config
 
-        if self._verify_quantizer_config(quantizer_config, rounding_type):
-            self.quantizer_config = quantizer_config
-        else:
-            common.Logger.error(f"Quantizer config of type {type(quantizer_config)} "
-                                f"is not suitable for rounding type {rounding_type}")
-
-    def _verify_quantizer_config(self, quantizer_config, rounding_type) -> bool:
-        """
-        Verifies that the given quantizer config matches the given rounding type.
-
-        Args:
-            quantizer_config: A quantizer config.
-            rounding_type: A RoundingType.
-
-        Returns: True if the quantizer config matches the rounding type, False otherwise.
-
-        """
-        if rounding_type == RoundingType.SoftQuantizer:
-            return type(quantizer_config) == SoftQuantizerConfig
-
-        # Here, we compare type() and not isinstance to exclude instance equality because of inheritance
-        return type(quantizer_config) == GPTQQuantizerConfig
+        self.gptq_quantizer_params_override = {} if gptq_quantizer_params_override is None \
+            else gptq_quantizer_params_override
 
 
 class GradientPTQConfigV2(GradientPTQConfig):
     """
     Configuration to use for quantization with GradientPTQV2 (experimental).
     """
-    def __init__(self,
-                 n_epochs: int,
+    def __init__(self, n_epochs: int,
                  optimizer: Any,
                  optimizer_rest: Any = None,
                  loss: Callable = None,
                  log_function: Callable = None,
                  train_bias: bool = True,
-                 quantization_parameters_learning: bool = False,
                  rounding_type: RoundingType = RoundingType.SoftQuantizer,
-                 lsb_change_per_bit_width: dict = DefaultDict({}, lambda: 1),
-                 eps: float = 1e-6,
-                 use_jac_based_weights: bool = True,
-                 num_samples_for_loss: int = 16,
-                 norm_weights: bool = False,
+                 use_hessian_based_weights: bool = True,
                  optimizer_quantization_parameter: Any = None,
                  optimizer_bias: Any = None,
-                 log_norm: bool = True,
-                 weights_n_iter: int = 50,
-                 quantizer_config: GPTQQuantizerConfig = SoftQuantizerConfig()):
+                 regularization_factor: float = REG_DEFAULT,
+                 hessian_weights_config: GPTQHessianWeightsConfig = GPTQHessianWeightsConfig(),
+                 gptq_quantizer_params_override: Dict[str, Any] = None):
         """
         Initialize a GradientPTQConfigV2.
 
@@ -162,18 +144,13 @@ class GradientPTQConfigV2(GradientPTQConfig):
              accordingly. see example in multiple_tensors_mse_loss
             log_function (Callable): Function to log information about the GPTQ process.
             train_bias (bool): Whether to update the bias during the training or not.
-            quantization_parameters_learning (bool): Whether to update the quantization param during the training or not.
             rounding_type (RoundingType): An enum that defines the rounding type.
-            lsb_change_per_bit_width (dict): Whether to update the bias during the training or not.
-            eps (float): A floating point value for numeric stability.
-            use_jac_based_weights (bool): Whether to use jacobian-based weights for weighted average loss.
-            num_samples_for_loss (int): Number of samples to use for computing the jacobian-based weights.
-            norm_weights (bool): Whether to normalize the returned weights (to get values between 0 and 1).
+            use_hessian_based_weights (bool): Whether to use Hessian-based weights for weighted average loss.
             optimizer_quantization_parameter (Any): Optimizer to override the rest optimizer  for quantizer parameters.
             optimizer_bias (Any): Optimizer to override the rest optimizerfor bias.
-            log_norm (bool): Whether to use log normalization to the GPTQ Jacobian-based weights.
-            weights_n_iter (int): Number of random iterations to run Jacobian approximation for GPTQ weights.
-            quantizer_config (Any): A class that contains the quantizer specific config.
+            regularization_factor (float): A floating point number that defines the regularization factor.
+            hessian_weights_config (GPTQHessianWeightsConfig): A configuration that include all necessary arguments to run a computation of Hessian weights for the GPTQ loss.
+            gptq_quantizer_params_override (dict): A dictionary of parameters to override in GPTQ quantizer instantiation. Defaults to None (no parameters).
 
         """
 
@@ -183,18 +160,13 @@ class GradientPTQConfigV2(GradientPTQConfig):
                          loss=loss,
                          log_function=log_function,
                          train_bias=train_bias,
-                         quantization_parameters_learning=quantization_parameters_learning,
                          rounding_type=rounding_type,
-                         lsb_change_per_bit_width=lsb_change_per_bit_width,
-                         eps=eps,
-                         use_jac_based_weights=use_jac_based_weights,
-                         num_samples_for_loss=num_samples_for_loss,
-                         norm_weights=norm_weights,
+                         use_hessian_based_weights=use_hessian_based_weights,
                          optimizer_quantization_parameter=optimizer_quantization_parameter,
                          optimizer_bias=optimizer_bias,
-                         log_norm=log_norm,
-                         weights_n_iter=weights_n_iter,
-                         quantizer_config=quantizer_config)
+                         regularization_factor=regularization_factor,
+                         hessian_weights_config=hessian_weights_config,
+                         gptq_quantizer_params_override=gptq_quantizer_params_override)
         self.n_epochs = n_epochs
 
     @classmethod
@@ -211,22 +183,3 @@ class GradientPTQConfigV2(GradientPTQConfig):
         v1_params = config_v1.__dict__
         v1_params = {k: v for k, v in v1_params.items() if k != 'n_iter'}
         return cls(n_epochs, **v1_params)
-
-    def get_extended_quantizer_parametes(self) -> Dict[str, Any]:
-        """
-        Return a dictionary with a mapping to necessary additional parameters for initializing the GPTQ quantizer.
-
-        Returns: A dictionary with parameters for initializing a quantizer.
-
-        """
-
-        if self.rounding_type == RoundingType.SoftQuantizer:
-            return {N_BATCHES_STR: self.quantizer_config.n_batches,
-                    QUANT_PARAM_LEARNING_STR: self.quantization_parameters_learning,
-                    N_EPOCHS_STR: self.n_epochs}
-        elif self.rounding_type == RoundingType.STE:
-            return {MAX_LSB_STR: self.lsb_change_per_bit_width}
-
-        return {}
-
-

model_compression_toolkit/gptq/common/gptq_constants.py

@@ -2,7 +2,6 @@
 AUXVAR = 'auxvar_tensor'
 ITERVAR = 'iteration_variable'
 SCALE_TENSOR = "scale_ptq_tensor"
-GPTQ_ITER = "gptq_iter"
 AUXSHIFT = 'shift'
 WEIGHTS_QUANTIZATION_PARAMS = 'weights_quantization_params'
 PTQ_MIN_RANGE = "min_range"
@@ -11,22 +10,16 @@ PTQ_THRESHOLD = "ptq_threshold"
 SCALE_PTQ = "scale"
 
 # Default quantizer values
-N_EPOCHS = 10000
 N_CYCLES = 4
 MIM_TEMP = 0.5
 MAX_TEMP = 1.0
 REG_DEFAULT = 0.01
-MAX_ITERATIONS_DEFAULT = 10000
 MAX_LSB_CHANGE = 1
 
 # Soft rounding arguments values
 SOFT_ROUNDING_GAMMA = -0.1
 SOFT_ROUNDING_ZETA = 1.1
-SOFT_ROUNDING_BETA = 2 / 3
 
 # GPTQ config constant
-REGULARIZATION_VALUES = "regularization_values"
-N_BATCHES_STR = 'n_batches'
 QUANT_PARAM_LEARNING_STR = 'quantization_parameter_learning'
-N_EPOCHS_STR = 'n_epochs'
 MAX_LSB_STR = 'max_lsbs_change_map'

model_compression_toolkit/gptq/common/gptq_framework_implementation.py

@@ -0,0 +1,32 @@
+# Copyright 2023 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from abc import abstractmethod
+
+from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+
+
+class GPTQFrameworkImplemantation(FrameworkImplementation):
+    """
+    Class to implement framework related methods that are used in GPTQ
+    """
+
+    @abstractmethod
+    def get_gptq_trainer_obj(self):
+        """
+        Returns: GPTQTrainer object
+        """
+        raise NotImplemented(f'{self.__class__.__name__} have to implement the '
+                             f'framework\'s get_gptq_trainer method.')  # pragma: no cover