Update config name

Author: matthewdouglas

src/transformers/quantizers/quantizer_bnb_4bit.py

@@ -151,11 +151,11 @@ def check_quantized_param(
             # but it would wrongly use uninitialized weight there.
             return True
         elif (
-            self.quantization_config.bnb_4bit_target_parameters is not None
+            self.quantization_config.target_parameters is not None
         ):  # Check if the parameter name is in the list of target parameters for quantization
             return any(
                 target_param
-                for target_param in self.quantization_config.bnb_4bit_target_parameters
+                for target_param in self.quantization_config.target_parameters
                 if param_name.endswith("." + target_param) or param_name == target_param
             )
 
@@ -242,7 +242,7 @@ def create_quantized_param(
                     device=target_device,
                     **param_kwargs,
                 )
-            elif self.quantization_config.bnb_4bit_target_parameters:
+            elif self.quantization_config.target_parameters:
                 # Normal nn.Parameter, i.e. outside of a Linear4bit layer.
                 import bitsandbytes.nn.parametrize
 
@@ -357,15 +357,15 @@ def _process_model_before_weight_loading(
         )
         # TODO: consider bringing replace_with_bnb_linear() code from ..integrations/bitsandbyter.py to here
 
-        if self.quantization_config.bnb_4bit_target_parameters:
+        if self.quantization_config.target_parameters:
             # TODO: consider when param is in a module specified by modules_to_not_convert
             matched_params = [
                 param_name
                 for param_name, _ in model.named_parameters()
                 if any(
                     filter(
                         lambda target_param: param_name.endswith("." + target_param) or param_name == target_param,
-                        self.quantization_config.bnb_4bit_target_parameters,
+                        self.quantization_config.target_parameters,
                     )
                 )
             ]
@@ -419,7 +419,7 @@ def is_trainable(self) -> bool:
     def _dequantize(self, model):
         from ..integrations import dequantize_and_replace
 
-        # TODO: support bnb_4bit_target_parameters
+        # TODO: support target_parameters
 
         model = dequantize_and_replace(
             model, self.modules_to_not_convert, quantization_config=self.quantization_config

src/transformers/utils/quantization_config.py

@@ -450,12 +450,13 @@ class BitsAndBytesConfig(QuantizationConfigMixin):
             quantized again.
         bnb_4bit_quant_storage (`torch.dtype` or str, *optional*, defaults to `torch.uint8`):
             This sets the storage type to pack the quanitzed 4-bit params.
-        bnb_4bit_target_parameters (`list[str]`, *optional*):
-            A list of extra parameters that should be quantized in 4-bit. This is useful for models that have
+        target_parameters (`list[str]`, *optional*):
+            A list of extra parameters that should be quantized. This is useful for models that have
             additional parameters that are not Linear layers. Parameters that exactly match or end with the names
             provided here will be quantized in addition to the Linear weights. As an example, for
             [Llama4](https://huggingface.co/collections/meta-llama/llama-4-67f0c30d9fe03840bc9d0164),
-            you can pass: `bnb_4bit_target_parameters=['feed_forward.experts.gate_up_proj', 'feed_forward.experts.down_proj]`
+            you can pass: `target_parameters=['feed_forward.experts.gate_up_proj', 'feed_forward.experts.down_proj]`.
+            This feature is experimental and only supported for 4bit quantization.
         kwargs (`dict[str, Any]`, *optional*):
             Additional parameters from which to initialize the configuration object.
     """
@@ -472,7 +473,7 @@ def __init__(
         bnb_4bit_quant_type="fp4",
         bnb_4bit_use_double_quant=False,
         bnb_4bit_quant_storage=None,
-        bnb_4bit_target_parameters=None,
+        target_parameters=None,
         **kwargs,
     ):
         self.quant_method = QuantizationMethod.BITS_AND_BYTES
@@ -488,7 +489,7 @@ def __init__(
         self.llm_int8_has_fp16_weight = llm_int8_has_fp16_weight
         self.bnb_4bit_quant_type = bnb_4bit_quant_type
         self.bnb_4bit_use_double_quant = bnb_4bit_use_double_quant
-        self.bnb_4bit_target_parameters = bnb_4bit_target_parameters
+        self.target_parameters = target_parameters
 
         if bnb_4bit_compute_dtype is None:
             self.bnb_4bit_compute_dtype = torch.float32
@@ -581,10 +582,14 @@ def post_init(self):
                 "4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version"
             )
 
-        if self.bnb_4bit_target_parameters is not None and bnb_version < version.parse("0.48.0"):
-            raise ValueError(
-                "bnb_4bit_target_parameters requires bitsandbytes>=0.48.0 - please upgrade your bitsandbytes version"
-            )
+        if self.target_parameters:
+            if not self.load_in_4bit:
+                raise ValueError("target_parameters is only supported for 4bit quantization.")
+
+            if bnb_version < version.parse("0.48.0"):
+                raise ValueError(
+                    "target_parameters requires bitsandbytes>=0.48.0 - please upgrade your bitsandbytes version"
+                )
 
     def is_quantizable(self):
         r"""