mct-nightly 2.2.0.20241111.513__py3-none-any.whl → 2.2.0.20241113.521__py3-none-any.whl

{mct_nightly-2.2.0.20241111.513.dist-info → mct_nightly-2.2.0.20241113.521.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.2.0.20241111.513
+Version: 2.2.0.20241113.521
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

{mct_nightly-2.2.0.20241111.513.dist-info → mct_nightly-2.2.0.20241113.521.dist-info}/RECORD

@@ -1,4 +1,4 @@
-model_compression_toolkit/__init__.py,sha256=Fw-5L3IgVjoHACxhUUWu7J7Obhrbfc3uR1xU069wk4g,1573
+model_compression_toolkit/__init__.py,sha256=FqZ6XbAbgDSAhK2i7UqlDeDmXsSUCvu0RyBhUeMPDp0,1573
 model_compression_toolkit/constants.py,sha256=i4wYheBkIdQmsQA-axIpcT3YiSO1USNc-jaNiNE8w6E,3920
 model_compression_toolkit/defaultdict.py,sha256=LSc-sbZYXENMCw3U9F4GiXuv67IKpdn0Qm7Fr11jy-4,2277
 model_compression_toolkit/logger.py,sha256=3DByV41XHRR3kLTJNbpaMmikL8icd9e1N-nkQAY9oDk,4567
@@ -47,7 +47,7 @@ model_compression_toolkit/core/common/graph/memory_graph/max_cut_astar.py,sha256
 model_compression_toolkit/core/common/graph/memory_graph/memory_element.py,sha256=gRmBEFRmyJsNKezQfiwDwQu1cmbGd2wgKCRTH6iw8mw,3961
 model_compression_toolkit/core/common/graph/memory_graph/memory_graph.py,sha256=gw4av_rzn_3oEAPpD3B7PHZDqnxHMjIESevl6ppPnkk,7175
 model_compression_toolkit/core/common/hessian/__init__.py,sha256=E7LK3K_1AwMCQokanNc1JODMwUKNOKmwXQiGQ7GO10I,1033
-model_compression_toolkit/core/common/hessian/hessian_info_service.py,sha256=OH8Xadv0ZSD_yoymgSfaNg8tqr4vxUfAbNLCBMRz6pQ,13233
+model_compression_toolkit/core/common/hessian/hessian_info_service.py,sha256=YynbVHdHH2gPlk1QHXH6GygIkXRZ9qxR14cpgKrHPT0,13238
 model_compression_toolkit/core/common/hessian/hessian_info_utils.py,sha256=1axmN0tjJSo_7hUr2d2KMv4y1pBi19cqWSQpi4BbdsA,1458
 model_compression_toolkit/core/common/hessian/hessian_scores_calculator.py,sha256=Pe4uKerx-MeDQPJ7Slr8fvFUHfv02q33w3gbQK5kBKs,4186
 model_compression_toolkit/core/common/hessian/hessian_scores_request.py,sha256=U2n5fz6fK633HWzIvEuQ7N6dekMqH9-DecOXAgd3v4E,3140
@@ -350,19 +350,19 @@ model_compression_toolkit/exporter/model_wrapper/pytorch/builder/node_to_quantiz
 model_compression_toolkit/gptq/__init__.py,sha256=pEgkJvmf05KSw70iLDTz_6LI_2Oi5L8sTN0JsEUpnpk,1445
 model_compression_toolkit/gptq/runner.py,sha256=La12JTYjWyJW0YW4Al4TP1_Xi4JWBCEKw6FR_JQsxe0,5982
 model_compression_toolkit/gptq/common/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
-model_compression_toolkit/gptq/common/gptq_config.py,sha256=Z6T5B3q4k2Tlr2bBWvC6TAF3d2opyA7ZT_D_mz6D1_0,6297
-model_compression_toolkit/gptq/common/gptq_constants.py,sha256=D1x2n4-NdAx6g_1Wc2hwwh4vX9vmx5VnQWN26H107kg,766
+model_compression_toolkit/gptq/common/gptq_config.py,sha256=QwSEZZlC6OpnpoBQoAFfgXTrdBgewgqlgaCV2hoJEso,6143
+model_compression_toolkit/gptq/common/gptq_constants.py,sha256=8HB0yiX75zZ1IKgQUPWpFCM5sS8HAqslws5XrOhxJQ0,750
 model_compression_toolkit/gptq/common/gptq_framework_implementation.py,sha256=n3mSf4J92kFjekzyGyrJULylI-8Jf5OVWJ5AFoVnEx0,1266
 model_compression_toolkit/gptq/common/gptq_graph.py,sha256=-bL5HhPcKqV8nj4dZPXc5QmQJbFBel6etrioikP0tEo,3039
-model_compression_toolkit/gptq/common/gptq_training.py,sha256=tt4O8PjSChquzl4c6NojvQWZmvCdTxcMLtmEVIGx1ns,13252
+model_compression_toolkit/gptq/common/gptq_training.py,sha256=EnG-17U6kGDgTeMkOJQmRoMs0KUldROss683_Bo5oHQ,13249
 model_compression_toolkit/gptq/common/gradual_activation_quantization.py,sha256=EgpzMs_aDoB0wQiTagqvcxCTfrgNUuCfdXEXmfNiyb0,3780
 model_compression_toolkit/gptq/common/regularization_factory.py,sha256=hyunpXepVeHyoAFJw6zNLK-3ZHBmiut3lmNisJN_L3E,2514
 model_compression_toolkit/gptq/keras/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/gptq/keras/gptq_keras_implementation.py,sha256=axBwnCSjq5xk-xGymOwSOqjp39It-CVtGcCTRTf0E_4,1248
 model_compression_toolkit/gptq/keras/gptq_loss.py,sha256=rbRkF15MYd6nq4G49kcjb_dPTa-XNq9cTkrb93mXawo,6241
-model_compression_toolkit/gptq/keras/gptq_training.py,sha256=TEWqAU8JZnZVZ-dIkINA0x1NmSrYpEkXTdG835JdKnI,20848
+model_compression_toolkit/gptq/keras/gptq_training.py,sha256=yBiAod9hbzh2bp4xhVO5szmtCHm6bLUa7-kjUVVwo40,20845
 model_compression_toolkit/gptq/keras/graph_info.py,sha256=MKIfrRTRH3zCuxCR1g9ZVIFyuSSr0e0sDybqh4LDM7E,4672
-model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=DhEEpW0rK4JRdk5WQlN-_DOUuzlwOBqpiwTBOySjn2g,16820
+model_compression_toolkit/gptq/keras/quantization_facade.py,sha256=e3O835Ol5ML0XuqNsCmoTbnnfs-gEgrSGT1ijUZLX7Q,17102
 model_compression_toolkit/gptq/keras/quantizer/__init__.py,sha256=-DK1CDXvlsnEbki4lukZLpl6Xrbo91_jcqxXlG5Eg6Q,963
 model_compression_toolkit/gptq/keras/quantizer/base_keras_gptq_quantizer.py,sha256=Rbl9urzkmACvVxICSEyJ02qFOBxWK0UQWtysFJzBVZw,4899
 model_compression_toolkit/gptq/keras/quantizer/quant_utils.py,sha256=Vt7Qb8i4JsE4sFtcjpfM4FTXTtfV1t6SwfoNH8a_Iaw,5055
@@ -376,9 +376,9 @@ model_compression_toolkit/gptq/keras/quantizer/ste_rounding/symmetric_ste.py,sha
 model_compression_toolkit/gptq/pytorch/__init__.py,sha256=cco4TmeIDIh32nj9ZZXVkws4dd9F2UDrmjKzTN8G0V0,697
 model_compression_toolkit/gptq/pytorch/gptq_loss.py,sha256=_07Zx_43bnNokwR5S8phIqeu5-_7_5VBT4DT-FCw7Do,3892
 model_compression_toolkit/gptq/pytorch/gptq_pytorch_implementation.py,sha256=tECPTavxn8EEwgLaP2zvxdJH6Vg9jC0YOIMJ7857Sdc,1268
-model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=2KwJFlJj6hFJClsJbC9aaWDAGbZUNDbSx1d-QX4LShc,22132
+model_compression_toolkit/gptq/pytorch/gptq_training.py,sha256=iuZJcoG2w-7qjWGntXWTdU2XUuMPy5IwzZbiolThuI4,22145
 model_compression_toolkit/gptq/pytorch/graph_info.py,sha256=4mVM-VvnBaA64ACVdOe6wTGHdMSa2UTLIUe7nACLcdo,4008
-model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=lY7_lNtS1SqaaJ0gc6C7_HO71bBalsxQY37QQlWpu70,15479
+model_compression_toolkit/gptq/pytorch/quantization_facade.py,sha256=hZFU_ZY-LYcpRZyzzX7NsJievkIYKGdkgBzEoB4rsRQ,16020
 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=fKg-PNOhGBiL-4eySS9Fyw0GkA76Pq8jT_HbJuJ8iZU,4143
 model_compression_toolkit/gptq/pytorch/quantizer/quant_utils.py,sha256=OocYYRqvl7rZ37QT0hTzfJnWGiNCPskg7cziTlR7TRk,3893
@@ -558,8 +558,8 @@ model_compression_toolkit/xquant/pytorch/model_analyzer.py,sha256=b93o800yVB3Z-i
 model_compression_toolkit/xquant/pytorch/pytorch_report_utils.py,sha256=bOc-hFL3gdoSM1Th_S2N_-9JJSlPGpZCTx_QLJHS6lg,3388
 model_compression_toolkit/xquant/pytorch/similarity_functions.py,sha256=CERxq5K8rqaiE-DlwhZBTUd9x69dtYJlkHOPLB54vm8,2354
 model_compression_toolkit/xquant/pytorch/tensorboard_utils.py,sha256=mkoEktLFFHtEKzzFRn_jCnxjhJolK12TZ5AQeDHzUO8,9767
-mct_nightly-2.2.0.20241111.513.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
-mct_nightly-2.2.0.20241111.513.dist-info/METADATA,sha256=McWeuqci7NFAVzdRUjfGJWF-nPncUEACLapRtf-Dx2Y,20830
-mct_nightly-2.2.0.20241111.513.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-mct_nightly-2.2.0.20241111.513.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
-mct_nightly-2.2.0.20241111.513.dist-info/RECORD,,
+mct_nightly-2.2.0.20241113.521.dist-info/LICENSE.md,sha256=aYSSIb-5AFPeITTvXm1UAoe0uYBiMmSS8flvXaaFUks,10174
+mct_nightly-2.2.0.20241113.521.dist-info/METADATA,sha256=vVYCluqgh4ApdcolpQzjr1vaNDLvkAqWpZAYn6kLz3I,20830
+mct_nightly-2.2.0.20241113.521.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+mct_nightly-2.2.0.20241113.521.dist-info/top_level.txt,sha256=gsYA8juk0Z-ZmQRKULkb3JLGdOdz8jW_cMRjisn9ga4,26
+mct_nightly-2.2.0.20241113.521.dist-info/RECORD,,

model_compression_toolkit/__init__.py

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
 
-__version__ = "2.2.0.20241111.000513"
+__version__ = "2.2.0.20241113.000521"

model_compression_toolkit/core/common/hessian/hessian_info_service.py

@@ -204,7 +204,7 @@ class HessianInfoService:
             target_nodes = [n for n in orig_request.target_nodes if n.name in missing]
             request = request.clone(target_nodes=target_nodes)
         self._compute_hessians(request, n_iterations, count_by_cache=True)
-        res, missing = self.cache.fetch_hessian(request)
+        res, missing = self.cache.fetch_hessian(orig_request)
         assert not missing
         return res
 

model_compression_toolkit/gptq/common/gptq_config.py

@@ -16,8 +16,7 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import Callable, Any, Dict, Optional
 
-from model_compression_toolkit.constants import GPTQ_HESSIAN_NUM_SAMPLES, ACT_HESSIAN_DEFAULT_BATCH_SIZE
-from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT
+from model_compression_toolkit.constants import ACT_HESSIAN_DEFAULT_BATCH_SIZE
 
 
 class RoundingType(Enum):
@@ -39,20 +38,26 @@ class GPTQHessianScoresConfig:
     Configuration to use for computing the Hessian-based scores for GPTQ loss metric.
 
     Args:
+        per_sample (bool): Whether to use per sample attention score.
         hessians_num_samples (int|None): Number of samples to use for computing the Hessian-based scores.
           If None, compute Hessian for all images.
         norm_scores (bool): Whether to normalize the returned scores of the weighted loss function (to get values between 0 and 1).
         log_norm (bool): Whether to use log normalization for the GPTQ Hessian-based scores.
         scale_log_norm (bool): Whether to scale the final vector of the Hessian-based scores.
         hessian_batch_size (int): The Hessian computation batch size. used only if using GPTQ with Hessian-based objective.
-        per_sample (bool): Whether to use per sample attention score.
     """
-    hessians_num_samples: Optional[int] = GPTQ_HESSIAN_NUM_SAMPLES
-    norm_scores: bool = True
-    log_norm: bool = True
+    per_sample: bool
+    hessians_num_samples: Optional[int]
+    norm_scores: bool = None
+    log_norm: bool = None
     scale_log_norm: bool = False
     hessian_batch_size: int = ACT_HESSIAN_DEFAULT_BATCH_SIZE
-    per_sample: bool = False
+
+    def __post_init__(self):
+        if self.norm_scores is None:
+            self.norm_scores = not self.per_sample
+        if self.log_norm is None:
+            self.log_norm = not self.per_sample
 
 
 @dataclass
@@ -107,32 +112,30 @@ class GradientPTQConfig:
 
     Args:
         n_epochs: Number of representative dataset epochs to train.
-        optimizer: Optimizer to use.
-        optimizer_rest: Optimizer to use for bias and quantizer parameters.
         loss: The loss to use. See 'multiple_tensors_mse_loss' for the expected interface.
-        log_function: Function to log information about the GPTQ process.
+        optimizer: Optimizer to use.
+        optimizer_rest: Default optimizer to use for bias and quantizer parameters.
         train_bias: Whether to update the bias during the training or not.
-        rounding_type: An enum that defines the rounding type.
-        use_hessian_based_weights: Whether to use Hessian-based weights for weighted average loss.
-        optimizer_quantization_parameter: Optimizer to override the rest optimizer  for quantizer parameters.
-        optimizer_bias: Optimizer to override the rest optimizer for bias.
-        regularization_factor: A floating point number that defines the regularization factor.
         hessian_weights_config: A configuration that include all necessary arguments to run a computation of
             Hessian scores for the GPTQ loss.
         gradual_activation_quantization_config: A configuration for Gradual Activation Quantization.
+        regularization_factor: A floating point number that defines the regularization factor.
+        rounding_type: An enum that defines the rounding type.
+        optimizer_quantization_parameter: Optimizer to override the rest optimizer for quantizer parameters.
+        optimizer_bias: Optimizer to override the rest optimizer for bias.
+        log_function: Function to log information about the GPTQ process.
         gptq_quantizer_params_override: A dictionary of parameters to override in GPTQ quantizer instantiation.
     """
     n_epochs: int
+    loss: Callable
     optimizer: Any
-    optimizer_rest: Any = None
-    loss: Callable = None
-    log_function: Callable = None
-    train_bias: bool = True
+    optimizer_rest: Any
+    train_bias: bool
+    hessian_weights_config: Optional[GPTQHessianScoresConfig]
+    gradual_activation_quantization_config: Optional[GradualActivationQuantizationConfig]
+    regularization_factor: float
     rounding_type: RoundingType = RoundingType.SoftQuantizer
-    use_hessian_based_weights: bool = True
     optimizer_quantization_parameter: Any = None
     optimizer_bias: Any = None
-    regularization_factor: float = REG_DEFAULT
-    hessian_weights_config: GPTQHessianScoresConfig = field(default_factory=GPTQHessianScoresConfig)
-    gradual_activation_quantization_config: Optional[GradualActivationQuantizationConfig] = None
+    log_function: Callable = None
     gptq_quantizer_params_override: Dict[str, Any] = field(default_factory=dict)

model_compression_toolkit/gptq/common/gptq_constants.py

@@ -14,6 +14,7 @@ N_CYCLES = 4
 MIM_TEMP = 0.5
 MAX_TEMP = 1.0
 REG_DEFAULT = 0.01
+REG_DEFAULT_SLA = 10
 MAX_LSB_CHANGE = 1
 
 # Soft rounding arguments values
@@ -27,6 +28,5 @@ MAX_LSB_STR = 'max_lsbs_change_map'
 # GPTQ learning hyperparameters
 LR_DEFAULT = 3e-2
 LR_REST_DEFAULT = 1e-4
-LR_BIAS_DEFAULT = 1e-3
-LR_QUANTIZATION_PARAM_DEFAULT = 1e-3
+LR_BIAS_DEFAULT = 1e-4
 GPTQ_MOMENTUM = 0.9

model_compression_toolkit/gptq/common/gptq_training.py

@@ -75,7 +75,7 @@ class GPTQTrainer(ABC):
                                                                        fw_info=self.fw_info)
 
         self.fxp_model, self.gptq_user_info = self.build_gptq_model()
-        if self.gptq_config.use_hessian_based_weights:
+        if self.gptq_config.hessian_weights_config:
             if not isinstance(hessian_info_service, HessianInfoService):
                 Logger.critical(f"When using Hessian-based approximations for sensitivity evaluation, "
                                 f"an 'HessianInfoService' object must be provided, but received: {hessian_info_service}.")   # pragma: no cover

model_compression_toolkit/gptq/keras/gptq_training.py

@@ -139,7 +139,7 @@ class KerasGPTQTrainer(GPTQTrainer):
 
     def _get_compare_points_loss_weights(self):
         """ Get compare points weights for the distillation loss. """
-        if self.gptq_config.use_hessian_based_weights:
+        if self.gptq_config.hessian_weights_config:
             hess_dataloader = data_gen_to_dataloader(self.representative_data_gen_fn,
                                                      batch_size=self.gptq_config.hessian_weights_config.hessian_batch_size)
             return self.compute_hessian_based_weights(hess_dataloader)

model_compression_toolkit/gptq/keras/quantization_facade.py

@@ -21,7 +21,7 @@ from model_compression_toolkit.core.common.visualization.tensorboard_writer impo
 from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT, LR_DEFAULT, LR_REST_DEFAULT, \
     LR_BIAS_DEFAULT, GPTQ_MOMENTUM
 from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.constants import TENSORFLOW, ACT_HESSIAN_DEFAULT_BATCH_SIZE
+from model_compression_toolkit.constants import TENSORFLOW, ACT_HESSIAN_DEFAULT_BATCH_SIZE, GPTQ_HESSIAN_NUM_SAMPLES
 from model_compression_toolkit.verify_packages import FOUND_TF
 from model_compression_toolkit.core.common.user_info import UserInformation
 from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig, GPTQHessianScoresConfig, \
@@ -117,16 +117,20 @@ if FOUND_TF:
             raise TypeError(f'gradual_activation_quantization argument should be bool or '
                             f'GradualActivationQuantizationConfig, received {type(gradual_activation_quantization)}')
 
-        return GradientPTQConfig(n_epochs,
-                                 optimizer,
+        hessian_weights_config = None
+        if use_hessian_based_weights:
+            hessian_weights_config = GPTQHessianScoresConfig(per_sample=False,
+                                                             hessians_num_samples=GPTQ_HESSIAN_NUM_SAMPLES,
+                                                             hessian_batch_size=hessian_batch_size)
+        return GradientPTQConfig(n_epochs=n_epochs,
+                                 optimizer=optimizer,
                                  optimizer_rest=optimizer_rest,
                                  loss=loss,
                                  log_function=log_function,
                                  train_bias=True,
                                  optimizer_bias=bias_optimizer,
-                                 use_hessian_based_weights=use_hessian_based_weights,
                                  regularization_factor=regularization_factor,
-                                 hessian_weights_config=GPTQHessianScoresConfig(hessian_batch_size=hessian_batch_size),
+                                 hessian_weights_config=hessian_weights_config,
                                  gradual_activation_quantization_config=gradual_quant_config)
 
 

model_compression_toolkit/gptq/pytorch/gptq_training.py

@@ -116,7 +116,7 @@ class PytorchGPTQTrainer(GPTQTrainer):
                                                                   trainable_threshold)
         hessian_cfg = self.gptq_config.hessian_weights_config
 
-        self.use_sample_layer_attention = hessian_cfg.per_sample
+        self.use_sample_layer_attention = hessian_cfg and hessian_cfg.per_sample
         if self.use_sample_layer_attention:
             # normalization is currently not supported, make sure the config reflects it.
             if hessian_cfg.norm_scores or hessian_cfg.log_norm or hessian_cfg.scale_log_norm:
@@ -178,7 +178,7 @@ class PytorchGPTQTrainer(GPTQTrainer):
         dataset = IterableDatasetFromGenerator(data_gen_fn)
         num_nodes = len(self.compare_points)
 
-        if self.gptq_config.use_hessian_based_weights:
+        if self.gptq_config.hessian_weights_config:
             hess_dataloader = DataLoader(dataset, batch_size=self.gptq_config.hessian_weights_config.hessian_batch_size)
             loss_weights = torch.from_numpy(self.compute_hessian_based_weights(hess_dataloader))
         else:

model_compression_toolkit/gptq/pytorch/quantization_facade.py

@@ -15,7 +15,7 @@
 import copy
 from typing import Callable, Union
 
-from model_compression_toolkit.constants import ACT_HESSIAN_DEFAULT_BATCH_SIZE, PYTORCH
+from model_compression_toolkit.constants import ACT_HESSIAN_DEFAULT_BATCH_SIZE, PYTORCH, GPTQ_HESSIAN_NUM_SAMPLES
 from model_compression_toolkit.core import CoreConfig
 from model_compression_toolkit.core.analyzer import analyzer_model_quantization
 from model_compression_toolkit.core.common.mixed_precision.mixed_precision_quantization_config import \
@@ -27,7 +27,7 @@ from model_compression_toolkit.core.runner import core_runner
 from model_compression_toolkit.gptq.common.gptq_config import (
     GradientPTQConfig, GPTQHessianScoresConfig, GradualActivationQuantizationConfig)
 from model_compression_toolkit.gptq.common.gptq_constants import REG_DEFAULT, LR_DEFAULT, LR_REST_DEFAULT, \
-    LR_BIAS_DEFAULT, GPTQ_MOMENTUM
+    LR_BIAS_DEFAULT, GPTQ_MOMENTUM, REG_DEFAULT_SLA
 from model_compression_toolkit.gptq.runner import gptq_runner
 from model_compression_toolkit.logger import Logger
 from model_compression_toolkit.metadata import create_model_metadata
@@ -55,10 +55,10 @@ if FOUND_TORCH:
                                 loss: Callable = None,
                                 log_function: Callable = None,
                                 use_hessian_based_weights: bool = True,
-                                regularization_factor: float = REG_DEFAULT,
+                                regularization_factor: float = None,
                                 hessian_batch_size: int = ACT_HESSIAN_DEFAULT_BATCH_SIZE,
-                                use_hessian_sample_attention: bool = False,
-                                gradual_activation_quantization: Union[bool, GradualActivationQuantizationConfig] = False,
+                                use_hessian_sample_attention: bool = True,
+                                gradual_activation_quantization: Union[bool, GradualActivationQuantizationConfig] = True,
                                 ) -> GradientPTQConfig:
         """
         Create a GradientPTQConfig instance for Pytorch models.
@@ -94,25 +94,26 @@ if FOUND_TORCH:
         """
         optimizer = optimizer or Adam([torch.Tensor([])], lr=LR_DEFAULT)
         optimizer_rest = optimizer_rest or Adam([torch.Tensor([])], lr=LR_REST_DEFAULT)
-
+        # TODO this contradicts the docstring for optimizer_rest
         bias_optimizer = torch.optim.SGD([torch.Tensor([])], lr=LR_BIAS_DEFAULT, momentum=GPTQ_MOMENTUM)
 
+        if regularization_factor is None:
+            regularization_factor = REG_DEFAULT_SLA if use_hessian_sample_attention else REG_DEFAULT
+
+        loss = loss or multiple_tensors_mse_loss
+        hessian_weights_config = None
         if use_hessian_sample_attention:
             if not use_hessian_based_weights:    # pragma: no cover
                 raise ValueError('use_hessian_based_weights must be set to True in order to use Sample Layer Attention.')
 
-            hessian_weights_config = GPTQHessianScoresConfig(
-                hessians_num_samples=None,
-                norm_scores=False,
-                log_norm=False,
-                scale_log_norm=False,
-                hessian_batch_size=hessian_batch_size,
-                per_sample=True,
-            )
+            hessian_weights_config = GPTQHessianScoresConfig(per_sample=True,
+                                                             hessians_num_samples=None,
+                                                             hessian_batch_size=hessian_batch_size)
             loss = loss or sample_layer_attention_loss
-        else:
-            hessian_weights_config = GPTQHessianScoresConfig(hessian_batch_size=hessian_batch_size)
-            loss = loss or multiple_tensors_mse_loss
+        elif use_hessian_based_weights:
+            hessian_weights_config = GPTQHessianScoresConfig(per_sample=False,
+                                                             hessians_num_samples=GPTQ_HESSIAN_NUM_SAMPLES,
+                                                             hessian_batch_size=hessian_batch_size)
 
         if isinstance(gradual_activation_quantization, bool):
             gradual_quant_config = GradualActivationQuantizationConfig() if gradual_activation_quantization else None
@@ -122,12 +123,16 @@ if FOUND_TORCH:
             raise TypeError(f'gradual_activation_quantization argument should be bool or '
                             f'GradualActivationQuantizationConfig, received {type(gradual_activation_quantization)}')
 
-        return GradientPTQConfig(n_epochs, optimizer, optimizer_rest=optimizer_rest, loss=loss,
-                                 log_function=log_function, train_bias=True, optimizer_bias=bias_optimizer,
-                                 use_hessian_based_weights=use_hessian_based_weights,
+        return GradientPTQConfig(n_epochs=n_epochs,
+                                 loss=loss,
+                                 optimizer=optimizer,
+                                 optimizer_rest=optimizer_rest,
+                                 optimizer_bias=bias_optimizer,
+                                 train_bias=True,
                                  regularization_factor=regularization_factor,
                                  hessian_weights_config=hessian_weights_config,
-                                 gradual_activation_quantization_config=gradual_quant_config)
+                                 gradual_activation_quantization_config=gradual_quant_config,
+                                 log_function=log_function)
 
     def pytorch_gradient_post_training_quantization(model: Module,
                                                     representative_data_gen: Callable,