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

model_compression_toolkit/gptq/keras/gptq_model_builder.py

@@ -1,104 +0,0 @@
-# Copyright 2022 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 typing import List, Tuple
-
-import tensorflow as tf
-from keras.models import Model
-from tensorflow.python.util.object_identity import Reference as TFReference
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapper
-
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common import BaseNode
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
-from model_compression_toolkit.core.common.user_info import UserInformation
-from model_compression_toolkit.core.keras.back2framework.keras_model_builder import KerasModelBuilder, \
-    is_layer_fake_quant, get_node_name_from_layer
-from model_compression_toolkit.core.keras.default_framework_info import DEFAULT_KERAS_INFO
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
-from model_compression_toolkit.gptq.keras.quantizer.config_factory import quantization_config_builder_gptq
-
-
-class GPTQKerasModelBuilder(KerasModelBuilder):
-    """
-    Builder of GPTQ Keras models.
-    """
-
-    def __init__(self,
-                 graph: common.Graph,
-                 gptq_config: GradientPTQConfig,
-                 append2output=None,
-                 fw_info: FrameworkInfo = DEFAULT_KERAS_INFO,
-                 return_float_outputs: bool = True):
-        """
-
-        Args:
-            graph: Graph to build the model from.
-            gptq_config: Configuration for GPTQ optimization.
-            append2output: Nodes to append to model's output.
-            fw_info: Information about the specific framework of the model that is built.
-            return_float_outputs: Whether the model returns float tensors or not.
-        """
-
-        super().__init__(graph,
-                         append2output,
-                         fw_info,
-                         return_float_outputs)
-        self.gptq_config = gptq_config
-
-    def _quantize_node_activations(self,
-                                   node: BaseNode,
-                                   input_tensors: List[TFReference]) -> List[TFReference]:
-        """
-        Quantize node's activation given input tensors.
-
-        Args:
-            node: Node to quantize its outputs.
-            input_tensors: Input tensors of the node.
-
-        Returns:
-            Output of the node.
-
-        """
-
-        return node.final_activation_quantization_cfg.quantize_node_output(input_tensors)
-
-    def build_model(self) -> Tuple[Model, UserInformation]:
-        """
-        Build a Keras GPTQ model and return it.
-        Returns: GPTQ Keras model.
-
-        """
-        model, user_info = super().build_model()
-
-        def _quantize(layer):
-
-            node = self.oh.layer_to_node_dict.get(layer)
-
-            if node is not None:
-                return QuantizeWrapper(layer, quantization_config_builder_gptq(node, self.fw_info, self.gptq_config))
-
-            elif is_layer_fake_quant(layer):
-                return layer
-
-            else:
-                raise Exception(
-                    f"Mismatch between keras model and graph can't find node named: "
-                    f"{get_node_name_from_layer(layer)}")
-
-        # clone each layer in the model and apply _quantize to the layer.
-        model = tf.keras.models.clone_model(model, input_tensors=None, clone_function=_quantize)
-
-        return model, user_info

model_compression_toolkit/gptq/keras/optimizers/sam_optimizer.py

@@ -1,119 +0,0 @@
-# Copyright 2022 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 typing import List, Callable, Tuple
-
-import tensorflow as tf
-from model_compression_toolkit.gptq.keras.quantizer.configs.weight_quantizer_gptq_config import WeightQuantizeConfig
-from tensorflow_model_optimization.python.core.quantization.keras.quantize_wrapper import QuantizeWrapper
-
-
-class SAM:
-    """
-    This class implements Sharpness-Aware Minimization for Efficiently Improving Generalization (https://arxiv.org/abs/2010.01412)
-    """
-
-    def __init__(self, model2quantized,
-                 gradient_step: Callable,
-                 optimizer_with_param: List[Tuple[List, List[tf.Tensor]]],
-                 rho: float = 0.01,
-                 eps: float = 1e-12):
-        """
-        The init function of Sharpness-Aware Minimization  gradient computation class.
-        Args:
-            model2quantized: Input quantized module
-            gradient_step: A function that returns a list of gradients tensors
-            optimizer_with_param: A list of optimizer classes to update with the corresponding parameters.
-            rho: A floating point number that set the region of smoothness
-            eps: A floating point number for numeric stability
-        """
-        assert rho >= 0.0, f"Invalid rho, should be non-negative: {rho}"
-        self.rho = rho
-        self.eps = eps
-        self.gradient_step = gradient_step
-
-        self.trainable_variables = [p for _, p in optimizer_with_param]
-        self.m_var = [len(p) for p in self.trainable_variables]
-        self.n_groups = len(self.trainable_variables)
-        self.model2quantized = model2quantized
-        self.e_ws = [[] for _ in range(len(optimizer_with_param))]
-
-    def _enable_update_step_param(self):
-        """
-        This function enables the parameter update (update iteration index and gumbel random variable)
-        Returns: None
-
-        """
-        for layer in self.model2quantized.layers:
-            if isinstance(layer, QuantizeWrapper) and isinstance(
-                    layer.quantize_config, WeightQuantizeConfig):
-                layer.quantize_config.enable_update()
-
-    def _disable_update_step_param(self):
-        """
-        This function disables the parameter update (update iteration index and gumbel random variable)
-        Returns: None
-
-        """
-        for layer in self.model2quantized.layers:
-            if isinstance(layer, QuantizeWrapper) and isinstance(
-                    layer.quantize_config, WeightQuantizeConfig):
-                layer.quantize_config.disable_update()
-
-    def _update_w_location(self, gradients: List[List[tf.Tensor]]):
-        """
-        This function updates the weights position to the highest point
-        Args:
-            gradients: A list of gradients tensors
-
-        Returns: None
-
-        """
-
-        for g in range(self.n_groups):
-            self.e_ws[g].clear()
-            grad_norm = tf.linalg.global_norm(gradients[g])
-            ew_multiplier = self.rho / (grad_norm + self.eps)
-            for i in range(self.m_var[g]):
-                e_w = tf.math.multiply(gradients[g][i], ew_multiplier)
-                self.trainable_variables[g][i].assign_add(e_w)
-                self.e_ws[g].append(e_w)
-
-    def _restore_w_location(self):
-        """
-        Restore weights to the original position
-        Returns: None
-
-        """
-        for g in range(self.n_groups):
-            for i in range(self.m_var[g]):
-                self.trainable_variables[g][i].assign_add(-self.e_ws[g][i])
-
-    def compute_gradients(self, *arg, **kwargs) -> (tf.Tensor, List[List[tf.Tensor]]):
-        """
-        This function compute the gradients of SAM optimizer
-        Args:
-            *arg: args to pass to the gradient step functions
-            **kwargs: kwargs to pass to the gradient step functions
-
-        Returns: A tensor of the loss value and a list of gradients tensors
-
-        """
-        self._enable_update_step_param()
-        loss, grad = self.gradient_step(*arg, **kwargs)
-        self._update_w_location(grad)
-        self._disable_update_step_param()
-        loss, grad = self.gradient_step(*arg, **kwargs)
-        self._restore_w_location()
-        return loss, grad

model_compression_toolkit/gptq/keras/quantizer/config_factory.py

@@ -1,62 +0,0 @@
-# Copyright 2021 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 tensorflow_model_optimization.python.core.quantization.keras.default_8bit.default_8bit_quantize_configs import \
-    NoOpQuantizeConfig
-from tensorflow_model_optimization.python.core.quantization.keras.default_8bit.default_8bit_quantize_registry import \
-    QuantizeConfig
-
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.framework_info import FrameworkInfo
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfig
-from model_compression_toolkit.gptq.keras.quantizer import WeightQuantizeConfig
-
-
-def quantization_config_builder_gptq(n: common.BaseNode,
-                                     fw_info: FrameworkInfo,
-                                     gptq_config: GradientPTQConfig) -> QuantizeConfig:
-    """
-    Build a QuantizeConfig for a node according to its quantization configuration and
-    a global NoOpQuantizeConfig object.
-
-    Args:
-        n: Node to build its QuantizeConfig.
-        fw_info: Framework information (e.g., mapping from layers to their attributes to quantize).
-        gptq_config: GPTQ Configuration class..
-
-    Returns:
-        A QuantizeConfig object with the appropriate quantizers (according to the node's
-        quantization configuration).
-    """
-
-    if n.is_weights_quantization_enabled() and n.is_activation_quantization_enabled():
-        qc = WeightQuantizeConfig(fw_info.get_kernel_op_attributes(n.type),
-                                  n.final_weights_quantization_cfg,
-                                  gptq_config)
-    elif n.is_activation_quantization_enabled() and not n.is_weights_quantization_enabled():
-        qc = NoOpQuantizeConfig()  # Quantization is Preformed using fake quantization node
-    elif n.is_weights_quantization_enabled() and not n.is_activation_quantization_enabled():
-        qc = WeightQuantizeConfig(fw_info.get_kernel_op_attributes(n.type),
-                                  n.final_weights_quantization_cfg,
-                                  gptq_config)
-
-    elif not n.is_weights_quantization_enabled() and not n.is_activation_quantization_enabled():
-        qc = NoOpQuantizeConfig()
-
-    else:
-        raise Exception('Undefined quantization method')
-
-    return qc

model_compression_toolkit/gptq/keras/quantizer/configs/base_quantizer_gptq_config.py

@@ -1,65 +0,0 @@
-# Copyright 2021 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 tensorflow_model_optimization.python.core.quantization.keras.quantize_config import QuantizeConfig
-from typing import Tuple, List, Any, Dict
-from tensorflow import Tensor
-import six, abc
-
-
-@six.add_metaclass(abc.ABCMeta)
-class BaseQuantizeConfig(QuantizeConfig):
-    """
-    Base QuantizeConfig to define extra API methods needed by the GPTQ post-processing.
-    """
-
-    @abc.abstractmethod
-    def get_quantization_variable(self):
-        """
-        A Functions that get the quantization parameters such as threshold, min, max ,etc.
-
-        Returns: A list of trainable variable
-
-        """
-
-    @abc.abstractmethod
-    def update_layer_quantization_params(self, layer) -> Tuple[Dict[str, Any],
-                                                               Dict[str, Any],
-                                                               Dict[str, Any]]:
-        """
-        A Function to calculate the needed change in attributes in NodeQuantizationConfig after retraining.
-        Usually a function of the config quantizers.
-
-        Args:
-            layer: layer being quantized.
-
-        Returns:
-            3 dictionaries of attributes the quantize_config retraining has changed during GPTQ retraining.
-            Keys must match NodeQuantizationConfig attributes:
-            1. layer weights
-            2. weight quantization config attributes
-            3. activation quantization config attributes
-
-        """
-
-    @abc.abstractmethod
-    def get_trainable_quantizer_parameters(self) -> List[Tensor]:
-        """
-        A function to get a list trainable of trainable parameters for GPTQ retraining from config quantizers
-
-        Returns:
-            A list of trainable Tensors
-
-        """

model_compression_toolkit/gptq/keras/quantizer/configs/weight_quantizer_gptq_config.py

@@ -1,269 +0,0 @@
-# Copyright 2021 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 typing import List, Tuple, Any, Dict
-
-from tensorflow import Tensor
-import tensorflow as tf
-from packaging import version
-
-# As from Tensorflow 2.6, keras is a separate package and some classes should be imported differently.
-
-
-if version.parse(tf.__version__) < version.parse("2.6"):
-    from tensorflow.python.keras.layers import Layer
-else:
-    from keras.engine.base_layer import Layer
-
-from tensorflow.python.training.tracking.data_structures import ListWrapper
-from tensorflow_model_optimization.python.core.quantization.keras.quantizers import Quantizer
-
-from model_compression_toolkit.gptq.keras.quantizer.configs.base_quantizer_gptq_config import BaseQuantizeConfig
-from model_compression_toolkit.core.keras.constants import KERNEL
-
-from model_compression_toolkit.gptq.common.gptq_config import GradientPTQConfigV2, RoundingType
-from model_compression_toolkit.gptq.keras.quantizer.gumbel_rounding.symmetric_gumbel import SymmetricGumbelRounding
-from model_compression_toolkit.gptq.keras.quantizer.gumbel_rounding.uniform_gumbel import UniformGumbelRounding
-from model_compression_toolkit.gptq.keras.quantizer.ste_rounding.symmetric_ste import STEWeightQuantizer
-from model_compression_toolkit.core.common.target_platform.op_quantization_config import QuantizationMethod
-from model_compression_toolkit.core.common.constants import THRESHOLD, RANGE_MAX, RANGE_MIN
-from model_compression_toolkit.core import common
-from model_compression_toolkit.core.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig
-from model_compression_toolkit.gptq.common import gptq_constants
-
-
-class WeightQuantizeConfig(BaseQuantizeConfig):
-    """
-    QuantizeConfig to quantize the weights of a layer using a TrainableQuantizer.
-    """
-
-    def __init__(self, weight_attrs: List[str],
-                 final_weights_quantization_cfg: NodeWeightsQuantizationConfig,
-                 gptq_config: GradientPTQConfigV2):
-        """
-        Initialize a TrainableQuantizer and set as the weights quantizer.
-        Args:
-            weight_attrs: Attributes of the layer's weights to quantize.
-            final_weights_quantization_cfg: quantization config of the current layer.
-            gptq_config: A GPTQ configuration calls.
-        """
-
-        num_bits = final_weights_quantization_cfg.weights_n_bits
-        weight_channel_axis = final_weights_quantization_cfg.weights_channels_axis
-        max_lsbs_change_map = gptq_config.lsb_change_per_bit_width
-        self.weight_attrs = weight_attrs
-        self.final_weights_quantization_cfg = final_weights_quantization_cfg
-        self.gptq_config = gptq_config
-
-        if final_weights_quantization_cfg.weights_quantization_method in [QuantizationMethod.SYMMETRIC,
-                                                                          QuantizationMethod.POWER_OF_TWO]:
-            is_power_of_two = QuantizationMethod.POWER_OF_TWO == final_weights_quantization_cfg.weights_quantization_method
-            threshold_values = final_weights_quantization_cfg.weights_quantization_params.get(THRESHOLD)
-            if gptq_config.rounding_type == RoundingType.STE:
-                self.weight_quantizer = STEWeightQuantizer(num_bits=num_bits,
-                                                           per_axis=len(
-                                                               threshold_values.flatten()) > 1,
-                                                           threshold_values=threshold_values,
-                                                           signed=True,
-                                                           power_of_two=is_power_of_two,
-                                                           quantization_axis=weight_channel_axis,
-                                                           max_lsbs_change_map=max_lsbs_change_map)
-            elif gptq_config.rounding_type == RoundingType.GumbelRounding:
-                self.weight_quantizer = SymmetricGumbelRounding(num_bits=num_bits,
-                                                                per_axis=len(
-                                                                    threshold_values.flatten()) > 1,
-                                                                threshold_values=threshold_values,
-                                                                signed=True,
-                                                                power_of_two=is_power_of_two,
-                                                                quantization_parameter_learning=gptq_config.quantization_parameters_learning,
-                                                                quantization_axis=weight_channel_axis,
-                                                                max_lsbs_change_map=max_lsbs_change_map,
-                                                                max_iteration=gptq_config.n_epochs,
-                                                                gumbel_config=gptq_config.quantizer_config)
-            else:
-                common.Logger.error(
-                    f"For quantization method {final_weights_quantization_cfg.weights_quantization_method}, GPTQ Rounding type {gptq_config.rounding_type} is not supported")
-        elif final_weights_quantization_cfg.weights_quantization_method == QuantizationMethod.UNIFORM:
-            if not gptq_config.rounding_type == RoundingType.GumbelRounding:
-                common.Logger.error(
-                    f"For quantization method {final_weights_quantization_cfg.weights_quantization_method}, GPTQ Rounding type {gptq_config.rounding_type} is not supported")
-            range_max = final_weights_quantization_cfg.weights_quantization_params.get(RANGE_MAX)
-            range_min = final_weights_quantization_cfg.weights_quantization_params.get(RANGE_MIN)
-            self.weight_quantizer = UniformGumbelRounding(num_bits=num_bits,
-                                                          per_axis=len(
-                                                              range_max.flatten()) > 1,
-                                                          min_range=range_min,
-                                                          max_range=range_max,
-                                                          signed=True,
-                                                          quantization_parameter_learning=gptq_config.quantization_parameters_learning,
-                                                          quantization_axis=weight_channel_axis,
-                                                          max_lsbs_change_map=max_lsbs_change_map,
-                                                          max_iteration=gptq_config.n_epochs,
-                                                          gumbel_config=gptq_config.quantizer_config)
-
-    def enable_update(self):
-        """
-        This function enable the parameter update (update iteration index and gumbel random variable)
-        Returns: None
-
-        """
-        if self.gptq_config.is_gumbel:
-            return self.weight_quantizer.enable_update()
-
-    def disable_update(self):
-        """
-
-        This function disable the parameter update (update iteration index and gumbel random variable)
-        Returns: None
-
-        """
-        if self.gptq_config.is_gumbel:
-            return self.weight_quantizer.disable_update()
-
-    def get_weights_and_quantizers(self, layer: Layer) -> List[Tuple[Tensor, Quantizer]]:
-        """
-        Get a list of tuples with weights and the weight quantizer.
-        The layer's attributes are used to get the weights.
-        Args:
-            layer: The layer the WeightQuantizeConfig wraps.
-
-        Returns:
-            List of tuples of the layer's weights and the weight quantizer.
-        """
-        return [(getattr(layer, weight_attr), self.weight_quantizer)
-                for weight_attr in self.weight_attrs]
-
-    def get_activations_and_quantizers(self, layer: Layer) -> list:
-        return []
-
-    def set_quantize_weights(self, layer: Layer, quantize_weights: List[Tensor]):
-        """
-        Set the layer weights with new passed weights.
-        Args:
-            layer: Layer to set its attributes.
-            quantize_weights: Quantized weights to set as new weights.
-
-        """
-        if len(self.weight_attrs) != len(quantize_weights):
-            raise ValueError(
-                '`set_quantize_weights` called on layer {} with {} '
-                'weight parameters, but layer expects {} values.'.format(
-                    layer.name, len(quantize_weights), len(self.weight_attrs)))  # pragma: no cover
-
-        for weight_attr, weight in zip(self.weight_attrs, quantize_weights):
-            current_weight = getattr(layer, weight_attr)
-            if current_weight.shape != weight.shape:
-                raise ValueError('Existing layer weight shape {} is incompatible with'
-                                 'provided weight shape {}'.format(
-                    current_weight.shape, weight.shape))  # pragma: no cover
-
-            setattr(layer, weight_attr, weight)
-
-    def set_quantize_activations(self, layer, quantize_activations: ListWrapper):
-        pass
-
-    def get_output_quantizers(self, layer: Layer) -> list:
-        return []
-
-    @classmethod
-    def from_config(cls, config: dict):
-        """
-        Instantiates a `WeightQuantizeConfig` from its config.
-
-        Args:
-            config: Output of `get_config()`.
-
-        Returns:
-            A `WeightQuantizeConfig` instance.
-        """
-
-        return cls(**config)
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-        Returns: The WeightQuantizeConfig configuration.
-        """
-        return {
-            'weight_attrs': self.weight_attrs,
-            'final_weights_quantization_cfg': self.final_weights_quantization_cfg,
-            'gptq_config': self.gptq_config,
-        }
-
-    def update_layer_quantization_params(self, layer: Layer) -> (Dict[str, tf.Tensor], Dict[str, Dict], Dict):
-        """
-        A Function to calculate the needed change in attributes in NodeQuantizationConfig after retraining.
-        Usually a function of the config quantizers.
-
-        Args:
-            layer: layer being quantized.
-
-        Returns:
-            3 dictionaries describing the change in layer's weights, weights config, activation config
-            that changed during GPTQ retraining.
-            Keys must match NodeQuantizationConfig attributes
-
-        """
-        weights = {}
-        for weight, quantizer, quantizer_vars in layer._weight_vars:
-            weights.update({KERNEL: quantizer(weight, training=False, weights=quantizer_vars)})
-
-        quant_config = {gptq_constants.WEIGHTS_QUANTIZATION_PARAMS: self.weight_quantizer.get_quant_config(layer)}
-
-        return weights, quant_config, {}
-
-    def get_trainable_quantizer_parameters(self) -> List[tf.Tensor]:
-        """
-        A function to get a list trainable of trainable parameters for GPTQ retraining from config quantizers
-
-        Returns:
-            A list of trainable Tensors
-
-        """
-        return self.weight_quantizer.get_trainable_parameters()
-
-    def get_aux_variable(self) -> List[tf.Tensor]:
-        return [self.weight_quantizer.get_aux_variable()]
-
-    def get_quantization_variable(self) -> List[tf.Tensor]:
-        return self.weight_quantizer.get_quantization_variable()
-
-    def get_temperature_variable(self) -> tf.Tensor:
-        if self.gptq_config.is_gumbel:
-            return self.weight_quantizer.get_temperature_variable()
-        else:
-            common.logger.Logger.error("Temperature variable only exist when using Gumbel Rounding Quantizer")
-
-    def get_gumbel_probability(self) -> tf.Tensor:
-        if self.gptq_config.is_gumbel:
-            return self.weight_quantizer.get_gumbel_probability()
-        else:
-            common.logger.Logger.error("Probability variable only exist when using Gumbel Rounding Quantizer")
-
-    def __eq__(self, other: Any) -> bool:
-        """
-        Check whether it equals to another object or not.
-        """
-        if not isinstance(other, WeightQuantizeConfig):
-            return False
-
-        return (self.weight_attrs == other.weight_attrs and
-                self.weight_quantizer == other.weight_quantizer and
-                self.gptq_config == other.gptq_config)
-
-    def __ne__(self, other: Any) -> bool:
-        """
-        Check whether it differs from another object or not.
-        """
-        return not self.__eq__(other)