# Ajustar un modelo

Los pesos cuantizados no se pueden actualizar directamente mediante gradientes, por lo que se ajusta un modelo cuantizado entrenando un adaptador pequeño sobre los pesos cuantizados congelados. Entrenar un adaptador [LoRA](https://huggingface.co/docs/peft/main/en/conceptual_guides/lora) en un modelo de 4 bits se conoce como QLoRA, y permite ajustar un modelo que no cabría en memoria en bf16.

[Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer) comprueba el modelo antes del entrenamiento para asegurarse de que:

- El método de cuantización admite el entrenamiento. Consulte la columna Fine-tune en [Choose a method](./selecting).
- El modelo tiene un adaptador entrenable adjunto. Los métodos que admiten entrenamiento consciente de la cuantización son la excepción y se abordan [a continuación](#quantization-aware-training).
- El modelo no está compilado con `torch.compile`.

## Entrenar un adaptador

Instala [PEFT](https://huggingface.co/docs/peft/index).

```bash
pip install -U peft
```

Cargue el modelo con un método que admita entrenamiento, adjunte un adaptador LoRA con [add_adapter()](/docs/transformers/main/es/main_classes/peft#transformers.integrations.PeftAdapterMixin.add_adapter) y pase el modelo a [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer). El ejemplo de abajo usa [bitsandbytes](./bitsandbytes) de 4 bits y asume que `train_dataset` es un conjunto de datos tokenizado.

```py
import torch
from peft import LoraConfig
from transformers import AutoModelForCausalLM, BitsAndBytesConfig, Trainer, TrainingArguments

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    quantization_config=quantization_config,
    device_map="auto",
)

lora_config = LoraConfig(r=16, lora_alpha=32, target_modules="all-linear", task_type="CAUSAL_LM")
model.add_adapter(lora_config)

trainer = Trainer(
    model=model,
    args=TrainingArguments(output_dir="qwen3-qlora", bf16=True),
    train_dataset=train_dataset,
)
trainer.train()
```

Solo se entrenan los pesos del adaptador. Los pesos base cuantizados permanecen congelados.

## Guardar el adaptador

[save_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained) guarda solo los pesos del adaptador, que ocupan unos pocos megabytes. Esto funciona con todos los métodos, incluidos aquellos que no pueden guardar sus pesos cuantizados.

```py
model.save_pretrained("qwen3-qlora-adapter")
```

Para usar el adaptador, cargue el modelo base con la misma configuración de cuantización y cargue el adaptador encima de él. Consulte [Carga de un adaptador](../peft#loading-an-adapter) para más detalles.

## Entrenamiento consciente de la cuantización

[BitNet](./bitnet) y [compressed-tensors](./compressed_tensors) pueden entrenar el modelo completo sin un adaptador, siempre que los pesos se mantengan en una forma entrenable.

- BitNet necesita `linear_class="autobitlinear"` y `quantization_mode="online"` en [BitNetQuantConfig](/docs/transformers/main/es/main_classes/quantization#transformers.BitNetQuantConfig).
- compressed-tensors necesita un checkpoint que no esté comprimido, o `dequantize=True` en [CompressedTensorsConfig](/docs/transformers/main/es/main_classes/quantization#transformers.CompressedTensorsConfig). Los checkpoints que usan los kernels de FP8 no pueden entrenar.

Consulte [Conceptos de cuantización](./concept_guide) para ver cómo el entrenamiento consciente de la cuantización difiere de la cuantización posterior al entrenamiento.