mct-nightly 1.7.1.31122022.post351__py3-none-any.whl → 1.8.0.1042023.post423__py3-none-any.whl

model_compression_toolkit/gptq/common/gptq_config.py

@@ -16,61 +16,46 @@ 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
-
-MAX_LSBS_CHANGE_MAP = {8: 2,
-                       4: 1,
-                       2: 1}
-
-N_CYCLES = 4
-MIM_TEMP = 0.5
-MAX_TEMP = 1.0
-GAMMA_TEMPERATURE = 0.1
-GUMBEL_SCALE = 0.5
+from model_compression_toolkit.gptq.common.gptq_constants import QUANT_PARAM_LEARNING_STR, MAX_LSB_STR, REG_DEFAULT
 
 
 class RoundingType(Enum):
     """
     An enum for choosing the GPTQ rounding methods
     0. STRAIGHT-THROUGH ESTIMATOR
-    1. Gumbel Rounding
+    1. SoftQuantizer
     """
     STE = 0
-    GumbelRounding = 1
+    SoftQuantizer = 1
 
 
-class GumbelConfig(object):
+class GPTQHessianWeightsConfig:
     """
-    Configuration to use for quantization with Gumbel Rounding.
+    Configuration to use for computing the Hessian-based weights for GPTQ loss metric.
     """
 
     def __init__(self,
-                 temperature_learning: bool = True,
-                 n_cycles: int = N_CYCLES,
-                 minimal_temp: float = MIM_TEMP,
-                 maximal_temp: float = MAX_TEMP,
-                 gumbel_entropy_regularization: float = GAMMA_TEMPERATURE,
-                 gumbel_scale: float = GUMBEL_SCALE,
-                 gumbel_scale_per_bitwidth: Dict[int, float] = None):
-        """
-        Initialize a GumbelConfig.
-
+                 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:
-            temperature_learning (bool): Whether to update the temperature during the training or not.
-            gumbel_entropy_regularization (float): A floating point number that defines the gumbel entropy regularization factor.
-            n_cycles (int): A floating point number that defines the gumbel entropy regularization factor.
-            minimal_temp (float): A floating point number that defines the gumbel entropy regularization factor.
-            maximal_temp (float): A floating point number that defines the gumbel entropy regularization factor.
-            gumbel_scale (float): A normalization factor for the gumbel tensor values.
-            gumbel_scale_per_bitwidth (dict): An optional mapping between a bit-width and a gumbel scale value for Gumbel Rounding,
+            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.gumbel_entropy_regularization = gumbel_entropy_regularization
-        self.temperature_learning = temperature_learning
-        self.n_cycles = n_cycles
-        self.minimal_temp = minimal_temp
-        self.maximal_temp = maximal_temp
-        self.gumbel_scale = gumbel_scale
-        self.gumbel_scale_per_bitwidth = gumbel_scale_per_bitwidth
+
+        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:
@@ -78,27 +63,19 @@ 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,
-                 sam_optimization: bool = False,
-                 rounding_type: RoundingType = RoundingType.GumbelRounding,
-                 rho: float = 0.01,
-                 lsb_change_per_bit_width: dict = DefaultDict(MAX_LSBS_CHANGE_MAP, lambda: 1),
-                 eps: float = 1e-6,
-                 use_jac_based_weights: bool = True,
-                 num_samples_for_loss: int = 16,
-                 norm_weights: bool = False,
-                 quantizer_config: GumbelConfig = GumbelConfig(),
+                 rounding_type: RoundingType = RoundingType.SoftQuantizer,
+                 use_hessian_based_weights: bool = True,
                  optimizer_quantization_parameter: Any = None,
                  optimizer_bias: Any = None,
-                 log_norm: bool = True,
-                 weights_n_iter: int = 50):
+                 regularization_factor: float = REG_DEFAULT,
+                 hessian_weights_config: GPTQHessianWeightsConfig = GPTQHessianWeightsConfig(),
+                 gptq_quantizer_params_override: Dict[str, Any] = None):
         """
         Initialize a GradientPTQConfig.
 
@@ -111,20 +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.
-            sam_optimization (bool): Whether to use sam optimization.
-            rounding_type (RoundingType): An enum that defines the rounding type (STE or GumbelRoudning).
-            rho (rho): A floating point number that defines the sam optimization lookahead.
-            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).
-            quantizer_config (Any): A class the contins the quantizer specific config.
+            rounding_type (RoundingType): An enum that defines the rounding type.
+            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.
+            optimizer_bias (Any): Optimizer to override the rest optimizer for bias.
+            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
@@ -133,58 +103,35 @@ class GradientPTQConfig:
         self.loss = loss
         self.log_function = log_function
         self.train_bias = train_bias
-        self.quantization_parameters_learning = quantization_parameters_learning
+
         self.rounding_type = rounding_type
-        self.sam_optimization = sam_optimization
-        self.rho = rho
-        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
-        if not isinstance(quantizer_config, GumbelConfig) and self.is_gumbel:
-            common.Logger.error("Please use GumbelConfig as quantizer config when using Gumbel Rounding")
-        self.quantizer_config = quantizer_config
+        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
 
-    @property
-    def is_gumbel(self) -> bool:
-        """
-        This function state if Gumbel Rounding is in use.
-        Returns: boolean
-
-        """
-        return self.rounding_type == RoundingType.GumbelRounding
+        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,
-                 sam_optimization: bool = False,
-                 rounding_type: RoundingType = RoundingType.GumbelRounding,
-                 rho: float = 0.01,
-                 lsb_change_per_bit_width: dict = DefaultDict(MAX_LSBS_CHANGE_MAP, lambda: 1),
-                 eps: float = 1e-6,
-                 use_jac_based_weights: bool = True,
-                 num_samples_for_loss: int = 16,
-                 norm_weights: bool = False,
-                 quantizer_config: GumbelConfig = GumbelConfig(),
+                 rounding_type: RoundingType = RoundingType.SoftQuantizer,
+                 use_hessian_based_weights: bool = True,
                  optimizer_quantization_parameter: Any = None,
                  optimizer_bias: Any = None,
-                 log_norm: bool = True,
-                 weights_n_iter: int = 50):
+                 regularization_factor: float = REG_DEFAULT,
+                 hessian_weights_config: GPTQHessianWeightsConfig = GPTQHessianWeightsConfig(),
+                 gptq_quantizer_params_override: Dict[str, Any] = None):
         """
         Initialize a GradientPTQConfigV2.
 
@@ -197,20 +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.
-            sam_optimization (bool): Whether to use sam optimization.
-            rounding_type (RoundingType): An enum that defines the rounding type (STE or GumbelRoudning).
-            rho (rho): A floating point number that defines the sam optimization lookahead.
-            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).
-            quantizer_config (Any): A class the contins the quantizer specific config.
+            rounding_type (RoundingType): An enum that defines the rounding type.
+            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.
+            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).
 
         """
 
@@ -220,20 +160,13 @@ class GradientPTQConfigV2(GradientPTQConfig):
                          loss=loss,
                          log_function=log_function,
                          train_bias=train_bias,
-                         quantization_parameters_learning=quantization_parameters_learning,
-                         sam_optimization=sam_optimization,
                          rounding_type=rounding_type,
-                         rho=rho,
-                         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,
-                         quantizer_config=quantizer_config,
+                         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)
+                         regularization_factor=regularization_factor,
+                         hessian_weights_config=hessian_weights_config,
+                         gptq_quantizer_params_override=gptq_quantizer_params_override)
         self.n_epochs = n_epochs
 
     @classmethod
@@ -248,8 +181,5 @@ class GradientPTQConfigV2(GradientPTQConfig):
         """
         n_epochs = int(round(config_v1.n_iter) / n_ptq_iter)
         v1_params = config_v1.__dict__
-        v1_params.pop('n_iter')
+        v1_params = {k: v for k, v in v1_params.items() if k != 'n_iter'}
         return cls(n_epochs, **v1_params)
-
-
-

model_compression_toolkit/gptq/common/gptq_constants.py

@@ -1,11 +1,25 @@
+# Parameters names
 AUXVAR = 'auxvar_tensor'
 ITERVAR = 'iteration_variable'
-THRESHOLD_TENSOR = "ptq_threshold_tensor"
 SCALE_TENSOR = "scale_ptq_tensor"
-GPTQ_ITER = "_gptq_iter"
-AUXSHIFT = '_shift'
-TEMP = '_temp'
+AUXSHIFT = 'shift'
 WEIGHTS_QUANTIZATION_PARAMS = 'weights_quantization_params'
-PTQ_MIN_RANGE = "_min_range"
-PTQ_MAX_RANGE = "_max_range"
+PTQ_MIN_RANGE = "min_range"
+PTQ_MAX_RANGE = "max_range"
+PTQ_THRESHOLD = "ptq_threshold"
+SCALE_PTQ = "scale"
 
+# Default quantizer values
+N_CYCLES = 4
+MIM_TEMP = 0.5
+MAX_TEMP = 1.0
+REG_DEFAULT = 0.01
+MAX_LSB_CHANGE = 1
+
+# Soft rounding arguments values
+SOFT_ROUNDING_GAMMA = -0.1
+SOFT_ROUNDING_ZETA = 1.1
+
+# GPTQ config constant
+QUANT_PARAM_LEARNING_STR = 'quantization_parameter_learning'
+MAX_LSB_STR = 'max_lsbs_change_map'

model_compression_toolkit/gptq/common/gptq_graph.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 # ==============================================================================
 from typing import Tuple, List
+
+from model_compression_toolkit import FrameworkInfo
+from model_compression_toolkit.core.common import Logger
 from model_compression_toolkit.core.common.graph.base_graph import Graph
 from model_compression_toolkit.core.common.graph.base_node import BaseNode
 
@@ -42,3 +45,22 @@ def get_compare_points(input_graph: Graph) -> Tuple[List[BaseNode], List[str], L
             compare_points_std.append(n.prior_info.std_output)
             compare_points_mean.append(n.prior_info.mean_output)
     return compare_points, compare_points_name, compare_points_mean, compare_points_std
+
+
+def get_kernel_attribute_name_for_gptq(layer_type: type, fw_info: FrameworkInfo) -> str:
+    """
+    Returns a layer's kernel attribute name for GPTQ training purposes.
+
+    Args:
+        layer_type: A type of model's layer.
+        fw_info: A FrameworkInfo object.
+
+    Returns: The name of the kernel attribute.
+
+    """
+    kernel_attribute = fw_info.get_kernel_op_attributes(layer_type)
+    if len(kernel_attribute) != 1:
+        Logger.error(  # pragma: no cover
+            f"In GPTQ training only the kernel weights attribute should be trained, but number of kernel "
+            f"attributes is {len(kernel_attribute)}.")
+    return kernel_attribute[0]

model_compression_toolkit/gptq/common/gptq_training.py

@@ -20,6 +20,7 @@ from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
 from model_compression_toolkit.core.common import Graph, Logger, BaseNode
 from model_compression_toolkit.core.common.framework_info import FrameworkInfo
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+from model_compression_toolkit.gptq.common.gptq_constants import QUANT_PARAM_LEARNING_STR
 from model_compression_toolkit.gptq.common.gptq_graph import get_compare_points
 from model_compression_toolkit.core.common.model_builder_mode import ModelBuilderMode
 
@@ -69,26 +70,23 @@ class GPTQTrainer(ABC):
     def get_optimizer_with_param(self,
                                  flattened_trainable_weights: List[Any],
                                  flattened_bias_weights: List[Any],
-                                 trainable_quantization_parameters: List[Any],
-                                 temperature_weights: List[Any]) -> List[Any]:
+                                 trainable_quantization_parameters: List[Any]) -> List[Any]:
         """
         Create Optimizers with their trainable parameters
         Args:
             flattened_trainable_weights: list of trainable weights parameters (flattened)
             flattened_bias_weights: list of trainable bias parameters (flattened)
             trainable_quantization_parameters: list of trainable quantization parameters
-            temperature_weights: list of temperature weights variables
         Returns:
             List of Optimizer objects with parameters
         """
 
         w2train = [*flattened_trainable_weights]
-        if self.gptq_config.is_gumbel:
-            if self.gptq_config.quantizer_config.temperature_learning:
-                w2train.extend(temperature_weights)
+
+        quant_params_learning = self.gptq_config.gptq_quantizer_params_override.get(QUANT_PARAM_LEARNING_STR, False)
 
         optimizer_with_param = [(self.gptq_config.optimizer, w2train)]
-        if self.gptq_config.train_bias or self.gptq_config.quantization_parameters_learning:
+        if self.gptq_config.train_bias or quant_params_learning:
             w2train_res = []
             if self.gptq_config.train_bias:
                 if self.gptq_config.optimizer_bias is not None:
@@ -96,35 +94,42 @@ class GPTQTrainer(ABC):
                 else:
                     w2train_res.extend(flattened_bias_weights)
                     if self.gptq_config.optimizer_rest is None:
-                        Logger.error(
+                        Logger.error(  # pragma: no cover
                             "To enable bias micro training an additional optimizer is required, please define the optimizer_rest")
-            if self.gptq_config.quantization_parameters_learning:
+            if quant_params_learning:
                 if self.gptq_config.optimizer_quantization_parameter is not None:  # Ability to override optimizer
                     optimizer_with_param.append((self.gptq_config.optimizer_quantization_parameter,
                                                  trainable_quantization_parameters))
                 else:
                     w2train_res.extend(trainable_quantization_parameters)
                 if self.gptq_config.optimizer_rest is None:
-                    Logger.error(
-                        "To enable bias micro training an additional optimizer is required, please define the optimizer_rest")
-            optimizer_with_param.append((self.gptq_config.optimizer_rest, w2train_res))
+                    Logger.error(  # pragma: no cover
+                        "To enable quantization parameters micro training an additional optimizer is required, please define the optimizer_rest")
+            if len(w2train_res) > 0:
+                # Either bias or quantization parameters are trainable but did not provide a specific optimizer,
+                # so we should use optimizer_rest to train them
+                if self.gptq_config.optimizer_rest is None:
+                    Logger.error(  # pragma: no cover
+                        "To enable bias or quantization parameters micro training an additional optimizer is required, please define the optimizer_rest")
+                optimizer_with_param.append((self.gptq_config.optimizer_rest, w2train_res))
 
         return optimizer_with_param
 
 
-    def compute_jacobian_based_weights(self,
-                                       representative_data_gen: Callable) -> np.ndarray:
+    def compute_hessian_based_weights(self,
+                                      representative_data_gen: Callable) -> np.ndarray:
         """
-        Computes the jacobian-based weights using the framework's model_grad method per batch of images.
+        Computes the Hessian-based weights using the framework's model_grad method per batch of images.
 
         Args:
-            representative_data_gen: Dataset used for inference to compute the jacobian-based weights.
+            representative_data_gen: Dataset used for inference to compute the Hessian-based weights.
 
         Returns: A vector of weights, one for each compare point,
         to be used for the loss metric weighted average computation when running GPTQ training.
         """
-        if self.gptq_config.use_jac_based_weights:
-            images = self._generate_images_batch(representative_data_gen, self.gptq_config.num_samples_for_loss)
+        if self.gptq_config.use_hessian_based_weights:
+            images = self._generate_images_batch(representative_data_gen,
+                                                 self.gptq_config.hessian_weights_config.hessians_num_samples)
 
             model_output_replacement = self._get_model_output_replacement()
 
@@ -142,17 +147,18 @@ class GPTQTrainer(ABC):
                                                              output_list=model_output_replacement,
                                                              all_outputs_indices=[],
                                                              alpha=0,
-                                                             norm_weights=self.gptq_config.norm_weights,
-                                                             n_iter=self.gptq_config.weights_n_iter)
+                                                             norm_weights=self.gptq_config.hessian_weights_config.norm_weights,
+                                                             n_iter=self.gptq_config.hessian_weights_config.hessians_n_iter)
                 points_apprx_jacobians_weights.append(image_ip_gradients)
-            if self.gptq_config.log_norm:
+            if self.gptq_config.hessian_weights_config.log_norm:
                 mean_jacobian_weights = np.mean(points_apprx_jacobians_weights, axis=0)
                 mean_jacobian_weights = np.where(mean_jacobian_weights != 0, mean_jacobian_weights,
                                                  np.partition(mean_jacobian_weights, 1)[1])
                 log_weights = np.log10(mean_jacobian_weights)
 
-                # To add scaling to the normalized weights replace return statement with the following line:
-                # return log_weights - np.min(log_weights) / (np.max(log_weights) - np.min(log_weights))
+                if self.gptq_config.hessian_weights_config.scale_log_norm:
+                    return (log_weights - np.min(log_weights)) / (np.max(log_weights) - np.min(log_weights))
+
                 return log_weights - np.min(log_weights)
             else:
                 return np.mean(points_apprx_jacobians_weights, axis=0)
@@ -204,7 +210,7 @@ class GPTQTrainer(ABC):
             Quantized graph for GPTQ fine-tuning, GPTQ graph user info
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
-                             f'framework\'s GPTQ model builder method.')
+                             f'framework\'s GPTQ model builder method.')  # pragma: no cover
 
     @abstractmethod
     def train(self, representative_data_gen: Callable):
@@ -214,7 +220,7 @@ class GPTQTrainer(ABC):
             representative_data_gen: Dataset to use for inputs of the models.
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
-                             f'framework\'s train method.')
+                             f'framework\'s train method.')  # pragma: no cover
 
     @abstractmethod
     def update_graph(self) -> Graph:
@@ -225,7 +231,7 @@ class GPTQTrainer(ABC):
             Updated graph after GPTQ.
         """
         raise NotImplemented(f'{self.__class__.__name__} have to implement the '
-                             f'framework\'s update_graph method.')
+                             f'framework\'s update_graph method.')  # pragma: no cover
 
     def _get_model_output_replacement(self) -> List[BaseNode]:
         """

model_compression_toolkit/gptq/keras/gptq_loss.py

@@ -86,6 +86,7 @@ def mse_loss_per_tensor(y: tf.Tensor,
     _loss = tf.reduce_mean(tf.pow(tf.abs(y - x), p))
     return _loss / tf.reduce_mean(tf.pow(tf.abs(x), p)) if normalized else _loss
 
+
 def activation_mse(flp_act_list,
                    fxp_act_list,
                    p_vector=None,
@@ -116,7 +117,6 @@ def activation_mse(flp_act_list,
         return tf.reduce_mean(tf.stack(loss_values_list)), tf.reduce_mean(tf.stack(bias_loss_list))
 
 
-
 class GPTQMultipleTensorsLoss:
     def __init__(self, norm_loss: bool = False):
         self.alpha = None