transformers 5.0.0rc0__py3-none-any.whl → 5.0.0rc1__py3-none-any.whl

transformers/quantizers/quantizer_quanto.py

@@ -40,23 +40,10 @@ class QuantoHfQuantizer(HfQuantizer):
     Quantizer for the quanto library
     """
 
-    required_packages = ["quanto", "accelerate"]
-    requires_parameters_quantization = True
     requires_calibration = False
 
     def __init__(self, quantization_config: QuantoConfig, **kwargs):
         super().__init__(quantization_config, **kwargs)
-        self.post_init()
-
-    def post_init(self):
-        r"""
-        Safety checker
-        """
-        if self.quantization_config.activations is not None and not self.pre_quantized:
-            raise ValueError(
-                "We don't support quantizing the activations with transformers library."
-                "Use quanto library for more complex use cases such as activations quantization, calibration and quantization aware training."
-            )
 
     def validate_environment(self, *args, **kwargs):
         if not is_optimum_quanto_available():
@@ -67,42 +54,22 @@ class QuantoHfQuantizer(HfQuantizer):
             raise ImportError(
                 "Loading an optimum-quanto quantized model requires accelerate library (`pip install accelerate`)"
             )
-
-    def update_device_map(self, device_map):
-        if device_map is None:
-            device_map = {"": "cpu"}
-            logger.info(
-                "The device_map was not initialized. "
-                "Setting device_map to {'':'cpu'}. "
-                "If you want to use the model for inference, please set device_map ='auto'"
+        device_map = kwargs.get("device_map")
+        if isinstance(device_map, dict):
+            if len(device_map) > 1 and "cpu" in device_map.values() or "disk" in device_map.values():
+                raise ValueError(
+                    "You are attempting to load an model with a device_map that contains a CPU or disk device."
+                    "This is not supported with quanto when the model is quantized on the fly. "
+                    "Please remove the CPU or disk device from the device_map."
+                )
+        if self.quantization_config.activations is not None:
+            raise ValueError(
+                "We don't support quantizing the activations with transformers library."
+                "Use quanto library for more complex use cases such as activations quantization, calibration and quantization aware training."
             )
-        return device_map
-
-    def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
-        if dtype is None:
-            logger.info("You did not specify `dtype` in `from_pretrained`. Setting it to `torch.float32`.")
-            dtype = torch.float32
-        return dtype
-
-    def update_missing_keys(self, model, missing_keys: list[str], prefix: str) -> list[str]:
-        if is_optimum_quanto_available():
-            from optimum.quanto import QModuleMixin
-
-        not_missing_keys = []
-        for name, module in model.named_modules():
-            if isinstance(module, QModuleMixin):
-                for missing in missing_keys:
-                    if (
-                        (name in missing or name in f"{prefix}.{missing}")
-                        and not missing.endswith(".weight")
-                        and not missing.endswith(".bias")
-                    ):
-                        not_missing_keys.append(missing)
-        return [k for k in missing_keys if k not in not_missing_keys]
 
     def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
-        if is_optimum_quanto_available():
-            from optimum.quanto import QModuleMixin
+        from optimum.quanto import QModuleMixin
 
         module, tensor_name = get_module_from_name(model, param_name)
         # We only quantize the weights and the bias is not quantized.
@@ -116,21 +83,6 @@ class QuantoHfQuantizer(HfQuantizer):
         max_memory = {key: val * 0.90 for key, val in max_memory.items()}
         return max_memory
 
-    def create_quantized_param(
-        self,
-        model: "PreTrainedModel",
-        param_value: "torch.Tensor",
-        param_name: str,
-        target_device: "torch.device",
-        **kwargs,
-    ):
-        from ..modeling_utils import _load_parameter_into_model
-
-        _load_parameter_into_model(model, param_name, param_value.to(target_device))
-        module, _ = get_module_from_name(model, param_name)
-        module.freeze()
-        module.weight.requires_grad = False
-
     def adjust_target_dtype(self, target_dtype: "torch.dtype") -> "torch.dtype":
         from accelerate.utils import CustomDtype
 
@@ -152,14 +104,18 @@ class QuantoHfQuantizer(HfQuantizer):
             model, self.quantization_config.modules_to_not_convert, keep_in_fp32_modules
         )
 
-        model, _ = replace_with_quanto_layers(
+        model = replace_with_quanto_layers(
             model, modules_to_not_convert=self.modules_to_not_convert, quantization_config=self.quantization_config
         )
-        model.config.quantization_config = self.quantization_config
 
     @property
     def is_trainable(self) -> bool:
         return True
 
-    def is_serializable(self, safe_serialization=None):
+    def is_serializable(self):
         return False
+
+    def get_quantize_ops(self):
+        from ..integrations.quanto import QuantoQuantize
+
+        return QuantoQuantize(self)

transformers/quantizers/quantizer_quark.py

@@ -45,12 +45,6 @@ class QuarkHfQuantizer(HfQuantizer):
     """
 
     requires_calibration = True  # On-the-fly quantization with quark is not supported for now.
-    required_packages = ["quark"]
-
-    # Checkpoints are expected to be already quantized when loading a quark model. However, as some keys from
-    # the checkpoint might mismatch the model parameters keys, we use the `create_quantized_param` method
-    # to load the checkpoints, remapping the keys.
-    requires_parameters_quantization = True
 
     def __init__(self, quantization_config, **kwargs):
         super().__init__(quantization_config, **kwargs)
@@ -78,19 +72,44 @@ class QuarkHfQuantizer(HfQuantizer):
     def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
         return True
 
-    def create_quantized_param(self, model, param, param_name, param_device, **kwargs):
-        from ..modeling_utils import _load_parameter_into_model
-
-        postfix = param_name.split(".")[-1]
-
-        if postfix in CHECKPOINT_KEYS:
-            param_name = param_name.replace(postfix, CHECKPOINT_KEYS[postfix])
-
-        _load_parameter_into_model(model, param_name, param.to(param_device))
-
-    def is_serializable(self, safe_serialization=None):
+    def is_serializable(self):
         return False
 
     @property
     def is_trainable(self):
         return False
+
+    def get_weight_conversions(self):
+        from ..core_model_loading import WeightConverter
+        from ..integrations.quark import QuarkDeserialize
+        # In Quark, quantization is managed through a QParamsLinear module, which holds
+        # separate quantizers for the weights, inputs, and biases (e.g. weight_quantizer
+        # input_quantizer, bias_quantizer, etc.).
+        #
+        # When you call `module.state_dict()`, Quark automatically renames the quantizer
+        # parameters — for example, `input_quantizer.scale` becomes `input_scale` — and
+        # saves them directly at the parent module level.
+        #
+        # This means we cannot simply rename keys like `weight_scale` back to
+        # `weight_quantizer.scale` when loading the state_dict.
+        # Otherwise, the `missing_keys` list would still expect keys such as
+        # `weight_scale`, `bias_scale`, etc.
+        #
+        # To fix this, we keep the expected state_dict keys (like `weight_scale`,
+        # `bias_scale`, etc.) unchanged, and during the conversion step, we explicitly
+        # assign their values into the corresponding quantizer attributes
+        # (`weight_quantizer.scale`, `input_quantizer.scale`, and so on).
+
+        # You can notice here that in target_patterns we use the same key as the source_patterns,
+        # this is because we just want to collect the tensors, and we will rename them later in the convert function.
+        # We cannot rename directly or else the missing_keys list will not be able to find the tensors.
+        converters = []
+        for key in CHECKPOINT_KEYS.keys():
+            converters.append(
+                WeightConverter(
+                    source_patterns=[key],
+                    target_patterns=key,
+                    operations=[QuarkDeserialize(self)],
+                )
+            )
+        return converters

transformers/quantizers/quantizer_spqr.py

@@ -39,7 +39,6 @@ class SpQRHfQuantizer(HfQuantizer):
 
     def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
         super().__init__(quantization_config, **kwargs)
-        self.quantization_config = quantization_config
 
     def validate_environment(self, *args, **kwargs):
         if not torch.cuda.is_available():
@@ -71,17 +70,15 @@ class SpQRHfQuantizer(HfQuantizer):
         self.modules_to_not_convert = self.get_modules_to_not_convert(
             model, self.quantization_config.modules_to_not_convert, keep_in_fp32_modules
         )
-
         replace_with_spqr_linear(
             model,
             quantization_config=self.quantization_config,
             modules_to_not_convert=self.modules_to_not_convert,
         )
-        model.config.quantization_config = self.quantization_config
 
     @property
     def is_trainable(self):
         return False
 
-    def is_serializable(self, safe_serialization=None):
+    def is_serializable(self):
         return True

transformers/quantizers/quantizer_torchao.py

@@ -13,8 +13,6 @@
 # limitations under the License.
 import importlib
 import re
-import types
-from collections import defaultdict
 from typing import TYPE_CHECKING
 
 from packaging import version
@@ -37,17 +35,12 @@ if is_torch_available():
 
 if is_torch_available():
     import torch
-    import torch.nn as nn
 
 if is_torchao_available():
-    import torchao
-
-    if version.parse(importlib.metadata.version("torchao")) >= version.parse("0.14.0"):
+    if version.parse(importlib.metadata.version("torchao")) >= version.parse("0.15.0"):
         from torchao.prototype.safetensors.safetensors_support import (
             flatten_tensor_state_dict,
-            unflatten_tensor_state_dict,
         )
-        from torchao.prototype.safetensors.safetensors_utils import is_metadata_torchao
 
 
 logger = logging.get_logger(__name__)
@@ -88,11 +81,6 @@ def _linear_extra_repr(self):
 
 
 if is_torchao_available():
-    SUPPORTED_SAFE_SERIALIZATION_CONFIGS = [
-        torchao.quantization.Float8WeightOnlyConfig,
-        torchao.quantization.Float8DynamicActivationFloat8WeightConfig,
-    ]
-
     TORCHAO_VERSION = version.parse(importlib.metadata.version("torchao"))
 
 
@@ -101,9 +89,7 @@ class TorchAoHfQuantizer(HfQuantizer):
     Quantizer for torchao: https://github.com/pytorch/ao/
     """
 
-    requires_parameters_quantization = True
     requires_calibration = False
-    required_packages = ["torchao"]
 
     def __init__(self, quantization_config, **kwargs):
         super().__init__(quantization_config, **kwargs)
@@ -166,20 +152,16 @@ class TorchAoHfQuantizer(HfQuantizer):
                 dtype = torch.float32
         return dtype
 
-    def get_state_dict_and_metadata(self, model, safe_serialization: bool | None = False):
+    def get_state_dict_and_metadata(self, model):
         """
-        If the model is safe serializable, we flatten the state dict of tensor subclasses so that it is compatible with
-        the safetensors format.
+        We flatten the state dict of tensor subclasses so that it is compatible with the safetensors format.
         """
-        if type(self.quantization_config.quant_type) in SUPPORTED_SAFE_SERIALIZATION_CONFIGS and safe_serialization:
-            if TORCHAO_VERSION >= version.parse("0.14.0"):
-                return flatten_tensor_state_dict(model.state_dict())
-            else:
-                raise RuntimeError(
-                    f"In order to use safetensors with torchao, please use torchao version >= 0.14.0. Current version: {TORCHAO_VERSION}"
-                )
+        if TORCHAO_VERSION >= version.parse("0.15.0"):
+            return flatten_tensor_state_dict(model.state_dict()), {}
         else:
-            return None, {}
+            raise RuntimeError(
+                f"In order to use safetensors with torchao, please use torchao version >= 0.15.0. Current version: {TORCHAO_VERSION}"
+            )
 
     def adjust_target_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
         from accelerate.utils import CustomDtype
@@ -237,9 +219,6 @@ class TorchAoHfQuantizer(HfQuantizer):
             ]
         return
 
-    def update_unexpected_keys(self, model, unexpected_keys: list[str]) -> list[str]:
-        return [k for k in unexpected_keys if not any(k.endswith(x) for x in self.full_ao_keys)]
-
     def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
         if self.pre_quantized:
             return False
@@ -249,8 +228,6 @@ class TorchAoHfQuantizer(HfQuantizer):
         # check if the param_name is not in self.modules_to_not_convert
         if any(key + "." in param_name or key == param_name for key in self.modules_to_not_convert):
             return False
-        elif any(param_name.endswith(f":{x}") for x in self.full_ao_keys):
-            return True
 
         # we only quantize the weight of nn.Linear and nn.Embedding
         module, tensor_name = get_module_from_name(model, param_name)
@@ -276,148 +253,6 @@ class TorchAoHfQuantizer(HfQuantizer):
 
         return isinstance(module, tuple(_QUANTIZABLE)) and tensor_name == "weight"
 
-    def create_quantized_param(
-        self,
-        model: "PreTrainedModel",
-        param_value: "torch.Tensor",
-        param_name: str,
-        target_device: "torch.device",
-        **kwargs,
-    ):
-        """
-        Each nn.Linear layer that needs to be quantized is processed here.
-        First, we set the value the weight tensor, then we move it to the target device. Finally, we quantize the module.
-        """
-        from torchao.quantization import quantize_
-
-        full_name = param_name
-        # Those are the pre quantized weights
-        if ":" in param_name:
-            param_name = param_name.rsplit(":", 1)[0]
-        module, tensor_name = get_module_from_name(model, param_name)
-
-        if self.pre_quantized:
-            # If it's a bias, no need to do anything special (except removing the ":_data" part of the key, but was
-            # already done) - if it's unsafe-serialized (i.e. not safetensors), not need for anything either
-            is_unsafe_serialization = ":" not in full_name
-            if tensor_name == "bias" or is_unsafe_serialization:
-                module._parameters[tensor_name] = torch.nn.Parameter(
-                    param_value.to(target_device), requires_grad=param_value.requires_grad
-                )
-                return
-            # Sanity check for the new serialization format
-            elif not (TORCHAO_VERSION >= version.parse("0.14.0") and is_metadata_torchao(self.metadata)):
-                raise ValueError("To use `safetensors` serialization, you should have `torchao>=0.14.0` installed")
-
-            # Save the states for later quantization when they are all gathered
-            if not hasattr(self, "ao_params"):
-                self.ao_params = defaultdict(dict)
-            self.ao_params[param_name].update({full_name: param_value})
-
-            # We are ready for quantization in this case (we retrieved all the needed keys)
-            if len(self.ao_params[param_name]) == len(self.weight_ao_keys):
-                new_param = unflatten_tensor_state_dict(self.ao_params[param_name], self.metadata)[param_name]
-                # Set it
-                module._parameters[tensor_name] = torch.nn.Parameter(
-                    new_param.to(target_device), requires_grad=new_param.requires_grad
-                )
-
-                # Free memory
-                del self.ao_params[param_name]
-
-            # Add repr to the module
-            if isinstance(module, nn.Linear):
-                module.extra_repr = types.MethodType(_linear_extra_repr, module)
-        else:
-            module._parameters[tensor_name] = torch.nn.Parameter(
-                param_value, requires_grad=param_value.requires_grad
-            ).to(target_device)
-            # if we are quantizing tied parameters, to avoid tying the quantized weights
-            # the correct order to do it is
-            # 1. load the weight to model
-            # 2. run tie_weights to populate the weights
-            # 3. quantize
-            input_embed = model.get_input_embeddings()
-            if self.quantization_config.untie_embedding_weights and id(module) == id(input_embed):
-                model.tie_weights()
-                setattr(model.config.get_text_config(decoder=True), "tie_word_embeddings", False)
-
-            # handle FqnToConfig, introduced in torchao 0.15.0+
-            if self.quantization_config._get_ao_version() >= version.Version("0.15.0"):
-                from torchao.quantization import FqnToConfig
-
-                config = self.quantization_config.get_apply_tensor_subclass()
-                if isinstance(config, FqnToConfig):
-                    module_fqn, top_level_param_name = param_name.rsplit(".", 1)
-                    c = None
-                    if param_name in config.fqn_to_config:
-                        assert not module_fqn.startswith("re:"), (
-                            "param fqn should not start with`re:`, which is used for specifying regex"
-                        )
-                        c = config.module_fqn_to_config[param_name]
-                    elif module_fqn in config.fqn_to_config:
-                        assert not module_fqn.startswith("re:"), (
-                            "module fqn should not start with`re:`, which is used for specifying regex"
-                        )
-                        c = config.module_fqn_to_config[module_fqn]
-                    # regex match module and param
-                    else:
-                        for maybe_module_fqn_pattern in config.fqn_to_config:
-                            # if key doesn't start with re, it is an exact fqn key, so we don't regex match
-                            if not maybe_module_fqn_pattern.startswith("re:"):
-                                continue
-                            # see if param matches first
-                            elif re.fullmatch(maybe_module_fqn_pattern[3:], param_name):
-                                c = config.module_fqn_to_config[maybe_module_fqn_pattern]
-                                break
-                            elif re.fullmatch(maybe_module_fqn_pattern[3:], module_fqn):
-                                # we'll apply the config for first fully matched pattern
-                                c = config.module_fqn_to_config[maybe_module_fqn_pattern]
-                                break
-                        else:
-                            c = config.module_fqn_to_config.get("_default", None)
-
-                    if c is not None:
-                        if top_level_param_name == "weight":
-                            # we can apply the module config directly
-                            quantize_(module, c, (lambda x, fqn: True))
-                        else:
-                            # need to apply to custom param name
-                            custom_param_fqn_config = FqnToConfig({top_level_param_name: c})
-                            quantize_(module, custom_param_fqn_config, filter_fn=None)
-                    return
-
-            # handle ModuleFqnToConfig, introduced in torchao 0.12.0+
-            # TODO deprecate this when we deprecate ModuleFqnToConfig
-            elif self.quantization_config._get_ao_version() >= version.Version("0.12.0"):
-                from torchao.quantization import ModuleFqnToConfig
-
-                config = self.quantization_config.get_apply_tensor_subclass()
-                if isinstance(config, ModuleFqnToConfig):
-                    module_fqn, _ = param_name.rsplit(".", 1)
-                    c = None
-                    if module_fqn in config.module_fqn_to_config:
-                        assert not module_fqn.startswith("re:"), (
-                            "module fqn should not start with`re:`, which is used for specifying regex"
-                        )
-                        c = config.module_fqn_to_config[module_fqn]
-                    else:
-                        for maybe_module_fqn_pattern in config.module_fqn_to_config:
-                            if not maybe_module_fqn_pattern.startswith("re:"):
-                                continue
-                            elif re.fullmatch(maybe_module_fqn_pattern[3:], module_fqn):
-                                # we'll apply the config for first fully matched pattern
-                                c = config.module_fqn_to_config[maybe_module_fqn_pattern]
-                                break
-                        else:
-                            c = config.module_fqn_to_config.get("_default", None)
-                    if c is not None:
-                        # filter_fn: not filtering out any modules
-                        quantize_(module, c, filter_fn=lambda x, fqn: True)
-                    return
-
-            quantize_(module, self.quantization_config.get_apply_tensor_subclass())
-
     def preprocess_model(self, model: "PreTrainedModel", config, dtype=None, checkpoint_files=None, **kwargs):
         """
         Setting model attributes and/or converting model before weights loading. At this point
@@ -450,30 +285,13 @@ class TorchAoHfQuantizer(HfQuantizer):
             return model
         return
 
-    def is_serializable(self, safe_serialization=None) -> bool:
-        if safe_serialization:
-            _is_torchao_serializable = type(
-                self.quantization_config.quant_type
-            ) in SUPPORTED_SAFE_SERIALIZATION_CONFIGS and TORCHAO_VERSION >= version.parse("0.14.0")
-            if not _is_torchao_serializable:
-                logger.warning(
-                    f"torchao quantized model only supports safe serialization for {SUPPORTED_SAFE_SERIALIZATION_CONFIGS}, \
-                    and torchao version >= 0.14.0, please set `safe_serialization` to False for \
-                    {type(self.quantization_config.quant_type)} and {TORCHAO_VERSION}."
-                )
-            return _is_torchao_serializable
-
-        _is_torchao_serializable = version.parse(importlib.metadata.version("huggingface_hub")) >= version.parse(
-            "0.25.0"
-        )
-        if not _is_torchao_serializable:
-            logger.warning("torchao quantized model is only serializable after huggingface_hub >= 0.25.0 ")
-        if self.offload and self.quantization_config.modules_to_not_convert is None:
+    def is_serializable(self) -> bool:
+        _is_torchao_serializable = TORCHAO_VERSION >= version.parse("0.15.0")
+        if not TORCHAO_VERSION >= version.parse("0.15.0"):
             logger.warning(
-                "The model contains offloaded modules and these modules are not quantized. We don't recommend saving the model as we won't be able to reload them."
-                "If you want to specify modules to not quantize, please specify modules_to_not_convert in the quantization_config."
+                "torchao quantized model only supports serialization for torchao version >= 0.15.0, please upgrade "
+                "your version to save the quantized model"
             )
-            return False
         return _is_torchao_serializable
 
     def get_accelerator_warm_up_factor(self):
@@ -548,15 +366,18 @@ class TorchAoHfQuantizer(HfQuantizer):
         if self.pre_quantized:
             return [
                 WeightConverter(
-                    source_patterns=["weight:qdata", "weight:scale", "weight:zero_point"],
-                    target_patterns="weight",
-                    operations=[TorchAoDeserialize(self)],
-                ),
-                WeightConverter(
-                    source_patterns=["weight:_data"],
+                    # TODO: incr flexibility by generalizing the source patterns to match the format of "_weight_"
+                    # note that the matching logic is greedy, so for ex, if _weight_scale is before _weight_scale_and_zero in this list, it will match _weight_scale always (this is incorrect)
+                    # thus, the order of source_patterns is intentional
+                    source_patterns=[
+                        "_weight_qdata",
+                        "_weight_scale_and_zero",
+                        "_weight_scale",
+                        "_weight_zero_point",
+                        "_weight_act_pre_scale",
+                    ],
                     target_patterns="weight",
                     operations=[TorchAoDeserialize(self)],
                 ),
-                # used for unsafe serialization
             ]
         return []

transformers/quantizers/quantizer_vptq.py

@@ -35,11 +35,9 @@ class VptqHfQuantizer(HfQuantizer):
     """
 
     requires_calibration = True
-    required_packages = ["vptq"]
 
     def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
         super().__init__(quantization_config, **kwargs)
-        self.quantization_config = quantization_config
 
     def validate_environment(self, *args, **kwargs):
         if not is_accelerate_available():
@@ -48,21 +46,15 @@ class VptqHfQuantizer(HfQuantizer):
         if not is_vptq_available():
             raise ImportError("Using `vptq` quantization requires VPTQ>=0.0.4: `pip install -U vptq`")
 
+        if not torch.cuda.is_available():
+            raise RuntimeError("GPU is required to run VTPQ quantized model.")
+
     def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
         if dtype is None:
-            if torch.cuda.is_available():
-                dtype = torch.float16
-                logger.info(
-                    "CUDA available. Assuming VPTQ inference on GPU and loading the model in `torch.float16`. To overwrite it, set `dtype` manually."
-                )
-            else:
-                import vptq
-
-                device_availability = getattr(vptq, "device_availability", lambda device: False)
-                if device_availability("cpu") is True:
-                    raise RuntimeError("No GPU found. Please wait for the next release of VPTQ to use CPU inference")
-                dtype = torch.float32
-                logger.info("No GPU found. Assuming VPTQ inference on CPU and loading the model in `torch.float32`.")
+            dtype = torch.float16
+            logger.info(
+                "Assuming VPTQ inference on GPU and loading the model in `torch.float16`. To overwrite it, set `dtype` manually."
+            )
         return dtype
 
     def _process_model_before_weight_loading(
@@ -71,26 +63,20 @@ class VptqHfQuantizer(HfQuantizer):
         keep_in_fp32_modules: list[str] | None = None,
         **kwargs,
     ):
-        """
-        we don't have param like modules_to_not_convert to indicate which layers should not be quantized
-        because `quantization_config` include the layers that should be quantized
-        """
         from ..integrations import replace_with_vptq_linear
 
         self.modules_to_not_convert = self.get_modules_to_not_convert(
             model, self.quantization_config.modules_to_not_convert, keep_in_fp32_modules
         )
-
         replace_with_vptq_linear(
             model,
             quantization_config=self.quantization_config,
             modules_to_not_convert=self.modules_to_not_convert,
         )
-        model.config.quantization_config = self.quantization_config
 
     @property
     def is_trainable(self) -> bool:
         return False
 
-    def is_serializable(self, safe_serialization=None):
+    def is_serializable(self):
         return True

transformers/quantizers/quantizers_utils.py

@@ -11,6 +11,7 @@
 # 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.
+import re
 from typing import Any
 
 
@@ -19,3 +20,22 @@ def get_module_from_name(module, tensor_name: str) -> tuple[Any, str]:
         module_name, tensor_name = tensor_name.rsplit(".", 1)
         module = module.get_submodule(module_name)
     return module, tensor_name
+
+
+def should_convert_module(full_name, patterns: list[str] | None = None):
+    if patterns is None:
+        return True
+
+    # We should avoid converting in the following situations:
+    # 1. The pattern appears as a prefix followed by a dot in `full_name`
+    #    (e.g., "model.decoder.layer.11." matches "model.decoder.layer.11.attn.weight").
+    # 2. The pattern matches `full_name` exactly or via regex
+    #    (e.g., "lm_head" matches "lm_head"; "model.decoder.layer.*" matches "model.decoder.layer.11.attn.weight").
+    # 3. `full_name` ends with the pattern
+    #    (e.g., "fc1" matches "model.decoder.layers.23.fc1").
+
+    should_not_convert = any(
+        re.match(f"{key}\\.", full_name) or re.match(f"{key}", full_name) or full_name.endswith(key)
+        for key in patterns
+    )
+    return not should_not_convert