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

transformers/quantizers/quantizer_torchao.py

@@ -13,14 +13,12 @@
 # limitations under the License.
 import importlib
 import re
-import types
-from collections import defaultdict
 from typing import TYPE_CHECKING
 
 from packaging import version
 
 from .base import HfQuantizer
-from .quantizers_utils import get_module_from_name
+from .quantizers_utils import get_module_from_name, should_convert_module
 
 
 if TYPE_CHECKING:
@@ -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,26 +89,24 @@ 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)
 
-        if isinstance(self.quantization_config.quant_type, str):
-            is_int_4 = "int4" in self.quantization_config.quant_type
-        else:
-            config_name = self.quantization_config.quant_type.__class__.__name__
-            is_int_4 = fuzzy_match_size(config_name) == "4"
-
-        # TODO: better way to get the serialized key names? Hard to read from torchao codebase
-        if is_int_4:
-            self.weight_ao_keys = ["qdata", "scale", "zero_point"]
+        self.quantized_param_size = None
+        quant_type = self.quantization_config.quant_type
+        if isinstance(quant_type, str):
+            map_to_param_size = {
+                "int4_weight_only": 0.5,
+                "int8_weight_only": 1,
+                "int8_dynamic_activation_int8_weight": 1,
+            }
+            if quant_type in map_to_param_size:
+                self.quantized_param_size = map_to_param_size[quant_type]
         else:
-            self.weight_ao_keys = ["qdata", "scale"]
-        # Instead of serializing the simple torch.Tensor like usual, torchao adds a `:_data` suffix so we need this
-        self.full_ao_keys = self.weight_ao_keys + ["_data"]
+            size_digit = fuzzy_match_size(quant_type.__class__.__name__)
+            self.quantized_param_size = 0.5 if size_digit == "4" else 1
 
     def validate_environment(self, *args, **kwargs):
         if not is_torchao_available():
@@ -148,84 +134,39 @@ class TorchAoHfQuantizer(HfQuantizer):
 
     def update_dtype(self, dtype):
         if self.quantization_config.quant_type == "int4_weight_only":
-            if dtype is not None and dtype != torch.bfloat16:
+            if dtype != torch.bfloat16:
                 logger.warning_once(
-                    f"Setting dtype to {dtype} for int4_weight_only quantization, but only bfloat16 is supported right now. Please set the dtype to bfloat16."
-                )
-            if dtype is None:
-                logger.warning_once(
-                    "Setting dtype to torch.bfloat16 for int4_weight_only quantization since only bfloat16 is supported right now. Please set dtype=torch.bfloat16 to remove this warning."
+                    f"Setting dtype to {dtype} for int4_weight_only quantization, but only bfloat16 is supported right now. Overwriting torch_dtype to bfloat16."
                 )
                 dtype = torch.bfloat16
-        if self.quantization_config.quant_type == "int8_dynamic_activation_int8_weight":
-            if dtype is None:
-                logger.info(
-                    "Setting dtype to torch.float32 for int8_dynamic_activation_int8_weight quantization as no dtype was specified in from_pretrained"
-                )
-                # we need to set the dtype, otherwise we have dtype mismatch when performing the quantized linear op
-                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}"
-                )
-        else:
-            return None, {}
-
-    def adjust_target_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
-        from accelerate.utils import CustomDtype
-
-        # Import AOBaseConfig directly since we know we have the right version
-        if self.quantization_config._get_ao_version() > version.Version("0.9.0"):
-            from torchao.core.config import AOBaseConfig
-
-            quant_type = self.quantization_config.quant_type
-            if isinstance(quant_type, AOBaseConfig):
-                # Extract size digit using fuzzy match on the class name
-                config_name = quant_type.__class__.__name__
-                size_digit = fuzzy_match_size(config_name)
-
-                # Map the extracted digit to appropriate dtype
-                if size_digit == "4":
-                    return CustomDtype.INT4
-                else:
-                    # Default to int8
-                    return torch.int8
-
-            # Original mapping for non-AOBaseConfig types
-            map_to_target_dtype = {
-                "int4_weight_only": CustomDtype.INT4,
-                "int8_weight_only": torch.int8,
-                "int8_dynamic_activation_int8_weight": torch.int8,
-                "autoquant": None,
-            }
-            return map_to_target_dtype[self.quantization_config.quant_type]
+        if TORCHAO_VERSION >= version.parse("0.15.0"):
+            return flatten_tensor_state_dict(model.state_dict())
         else:
-            raise ValueError(
-                "You are using `device_map='auto'` on a torchao quantized model. To automatically compute"
-                " the appropriate device map, you should upgrade your `accelerate` library with "
-                "`pip install --upgrade accelerate`"
+            raise RuntimeError(
+                f"In order to use safetensors with torchao, please use torchao version >= 0.15.0. Current version: {TORCHAO_VERSION}"
             )
 
+    def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+        "Return the element size (in bytes) for `param_name`."
+        if self.param_needs_quantization(model, param_name) and self.quantized_param_size is not None:
+            return self.quantized_param_size
+
+        return super().param_element_size(model, param_name, param)
+
     def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
         # need more space for the quantization parameters (e.g. scale). Tested with int4 wo and group size = 128
         max_memory = {key: val * 0.9 for key, val in max_memory.items()}
         return max_memory
 
-    def _process_model_before_weight_loading(
-        self, model: "PreTrainedModel", keep_in_fp32_modules: list[str] | None = None, **kwargs
-    ):
+    def _process_model_before_weight_loading(self, model: "PreTrainedModel", checkpoint_files=None, **kwargs):
         self.modules_to_not_convert = self.get_modules_to_not_convert(
-            model, self.quantization_config.modules_to_not_convert, keep_in_fp32_modules
+            model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
         )
         if self.quantization_config.include_input_output_embeddings:
             input_emb = model.get_input_embeddings()
@@ -235,22 +176,17 @@ class TorchAoHfQuantizer(HfQuantizer):
             self.modules_to_not_convert = [
                 x for x in self.modules_to_not_convert if x not in input_emb_names + output_emb_names
             ]
-        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)]
+        if checkpoint_files is not None:
+            # Torchao needs access to all metadata later
+            self.set_metadata(checkpoint_files)
 
     def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
-        if self.pre_quantized:
-            return False
         if self.quantization_config.quant_type == "autoquant":
             return False
 
         # 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):
+        if not should_convert_module(param_name, 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,164 +212,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
-        the model should be initialized on the meta device so you can freely manipulate the skeleton
-        of the model in order to replace modules in-place. Make sure to override the abstract method `_process_model_before_weight_loading`.
-
-        Args:
-            model (`~transformers.PreTrainedModel`):
-                The model to quantize
-            kwargs (`dict`, *optional*):
-                The keyword arguments that are passed along `_process_model_before_weight_loading`.
-        """
-        super().preprocess_model(model, config, dtype, checkpoint_files, **kwargs)
-        # Torchao needs access to all metadata later
-        self.set_metadata(checkpoint_files)
-
     def _process_model_after_weight_loading(self, model, **kwargs):
         """No process required for torchao quantized model"""
         if self.quantization_config.quant_type == "autoquant":
@@ -450,71 +228,15 @@ 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):
-        """
-        This factor is used in caching_allocator_warmup to determine how many bytes to pre-allocate for accelerator warmup.
-        - A factor of 2 means we pre-allocate the full memory footprint of the model.
-        - A factor of 4 means we pre-allocate half of that, and so on
-
-        However, when using TorchAO, calculating memory usage with param.numel() * param.element_size() doesn't give the correct size for quantized weights (like int4 or int8)
-        That's because TorchAO internally represents quantized tensors using subtensors and metadata, and the reported element_size() still corresponds to the dtype
-        not the actual bit-width of the quantized data.
-
-        To correct for this:
-        - Use a division factor of 8 for int4 weights
-        - Use a division factor of 4 for int8 weights
-        """
-        if self.quantization_config._get_ao_version() > version.Version("0.9.0"):
-            from torchao.core.config import AOBaseConfig
-
-            quant_type = self.quantization_config.quant_type
-            # For autoquant case, it will be treated in the string implementation below in map_to_target_dtype
-            if isinstance(quant_type, AOBaseConfig):
-                # Extract size digit using fuzzy match on the class name
-                config_name = quant_type.__class__.__name__
-                size_digit = fuzzy_match_size(config_name)
-
-                if size_digit == "4":
-                    return 8
-                else:
-                    return 4
-
-        # Original mapping for non-AOBaseConfig types
-        map_to_target_dtype = {
-            "int4_weight_only": 8,
-            "int8_weight_only": 4,
-            "int8_dynamic_activation_int8_weight": 4,
-            "autoquant": 4,
-        }
-
-        return map_to_target_dtype[self.quantization_config.quant_type]
-
     @property
     def is_trainable(self) -> bool:
         supported_quant_types_for_training = [
@@ -548,15 +270,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,49 +46,28 @@ class VptqHfQuantizer(HfQuantizer):
         if not is_vptq_available():
             raise ImportError("Using `vptq` quantization requires VPTQ>=0.0.4: `pip install -U vptq`")
 
-    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`.")
-        return dtype
+        if not torch.cuda.is_available():
+            raise RuntimeError("GPU is required to run VTPQ quantized model.")
 
     def _process_model_before_weight_loading(
         self,
         model: "PreTrainedModel",
-        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
+            model, self.quantization_config.modules_to_not_convert, model._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