# Ajuste fino

El fine-tuning consiste en continuar el entrenamiento de un modelo preentrenado grande sobre un conjunto de datos más pequeño específico de una tarea o dominio. Por ejemplo, hacer fine-tuning con un conjunto de datos de ejemplos de programación ayuda al modelo a mejorar en programación. El fine-tuning es idéntico al preentrenamiento, excepto que no se parte de pesos aleatorios. Además, requiere mucho menos cómputo, datos y tiempo.

El tutorial a continuación explica cómo realizar el ajuste fino de un modelo de lenguaje de gran tamaño con [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer).

> [!AgentPrompt]
> Ayuda al usuario a planificar una ejecución de ajuste fino para su tarea. Antes de proponer una configuración, identifica la tarea, el modelo preentrenado y su revisión, los campos del conjunto de datos, los datos de evaluación, la versión de Transformers, el hardware y la memoria disponible. Usa este tutorial para verificar la preparación de datos, la carga del modelo y la configuración de `Trainer` que se aplican a su caso. No asumas que el conjunto de datos o el modelo de ejemplo son adecuados para una tarea diferente.
>
> 1. Solicite los detalles faltantes que podrían cambiar el modelo, el preprocesamiento o la configuración de entrenamiento. Declare cualquier suposición. 2. Mantenga los ejemplos de evaluación separados de los datos de entrenamiento. Seleccione un modelo y un tokenizador para la tarea, prepare las entradas y etiquetas esperadas por el modelo y elija un data collator que coincida con esas entradas. 3. Configure `TrainingArguments` para adaptarse al hardware y a los objetivos del usuario. Configure la evaluación y el guardado de checkpoints cuando el usuario los necesite. Ejecute una prueba pequeña antes de un trabajo de entrenamiento completo y verifique que el modelo reciba las entradas esperadas, que la pérdida sea finita y que la evaluación se complete. 4. No inicie un entrenamiento completo ni cargue artefactos a menos que el usuario lo solicite. Informe la configuración propuesta, la evidencia de cualquier prueba, los compromisos de recursos esperados y cualquier cosa que no haya podido verificar.

Inicia sesión en tu cuenta de Hugging Face con tu token de usuario para subir tu modelo afinado al Hub.

```py
from huggingface_hub import login

login()
```

## Tokenización

Carga un conjunto de datos y [tokeniza](./fast_tokenizers) la columna de texto sobre la que se entrena el modelo (`horoscope` en el conjunto de datos a continuación).

<iframe src="https://huggingface.co/datasets/karthiksagarn/astro_horoscope/embed/viewer/default/train" frameborder="0" width="100%" height="560px"
>

El tokenizador crea las entradas del modelo, `input_ids` y `attention_mask`. El método forward del modelo solo acepta `input_ids` y `attention_mask`, por lo que se debe establecer `remove_columns` para eliminar columnas como `horoscope` después de la tokenización.

- Establezca `truncation=True` y un `max_length` para truncar las secuencias más largas a una longitud máxima especificada.
- Use el método `train_test_split` para crear una división de prueba para evaluar el modelo.

```py
from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorForLanguageModeling

model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
dataset = load_dataset("karthiksagarn/astro_horoscope", split="train")

def tokenize(batch):
    return tokenizer(
        batch["horoscope"],
        truncation=True,
        max_length=512,
    )

dataset = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)
dataset = dataset.train_test_split(test_size=0.1)
```

Un data collator ensambla muestras del conjunto de datos en lotes para que el modelo los procese. [DataCollatorForLanguageModeling](/docs/transformers/v5.23.0/es/main_classes/data_collator#transformers.DataCollatorForLanguageModeling) rellena *dinámicamente* cada lote hasta la secuencia más larga de ese lote, en lugar de rellenar todas las secuencias del conjunto de datos hasta la misma longitud. Esto ahorra cómputo y memoria al evitar el cálculo de tokens de relleno innecesarios.

- Establezca `mlm=False` para evitar enmascarar tokens de forma aleatoria.

```py
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
```

## Carga de un modelo

Cargue un punto de control preentrenado para el ajuste fino (consulte la guía [Carga de modelos](./models) para obtener más detalles sobre la carga de modelos).

- Establezca `dtype="auto"` para cargar los pesos en su dtype guardado. Sin esta configuración, PyTorch carga los pesos en `torch.float32`, lo que duplica el uso de memoria si los pesos originales son `torch.bfloat16`.

```py
from transformers import AutoModelForCausalLM, TrainingArguments, Trainer

model_name = "Qwen/Qwen3-0.6B"
model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto")
```

## Configuración de entrenamiento

[TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) proporciona todas las opciones para personalizar una ejecución de entrenamiento. Aquí solo se cubren los argumentos más comunes. El resto tiene valores predeterminados razonables o solo es relevante para escenarios específicos, como el entrenamiento distribuido. Consulte la documentación de la API de [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) para obtener una lista completa de argumentos.

- `num_train_epochs` y `per_device_train_batch_size` control la duración del entrenamiento y el tamaño del lote. `learning_rate` establece la tasa de aprendizaje inicial para el optimizador.

- Establezca `bf16=True` para un entrenamiento rápido con precisión mixta si su hardware lo admite (GPU Ampere o superior). De lo contrario, use `fp16=True` en hardware más antiguo.
- `gradient_accumulation_steps` simula un tamaño de lote efectivo mayor acumulando gradientes durante varias pasadas hacia adelante antes de actualizar los pesos.
- `gradient_checkpointing` intercambia cómputo por memoria al recalcular las activaciones intermedias durante la pasada inversa en lugar de almacenarlas. Para un compromiso entre memoria y velocidad, consulte [checkpointing parcial](./grad_checkpointing#partial-checkpointing).
- Cuando `gradient_checkpointing=True`, establezca `gradient_checkpointing_kwargs={"offload": True}` para mantener las activaciones guardadas en memoria de host fijada y reducir el uso de memoria de GPU para secuencias largas. Consulte [el descargado de las activaciones guardadas](./grad_checkpointing#offloading-the-saved-activations) para conocer el compromiso.
- Establezca `train_sampling_strategy="group_by_length"` para agrupar en lotes ejemplos de longitudes similares y reducir el relleno. Consulte [agrupar muestras por longitud](./trainer_recipes#group-samples-by-length) para conjuntos de datos multimodales basados en procesadores y longitudes precalculadas.

- `eval_strategy` y `save_strategy` determinan cuándo evaluar un modelo durante el entrenamiento y cuándo guardar un punto de control.
- `load_best_model_at_end` carga el punto de control óptimo al finalizar el entrenamiento. Requiere que `eval_strategy` esté configurado.

- `logging_steps` controla la frecuencia con la que se actualiza y devuelve la pérdida durante el entrenamiento.

```py
training_args = TrainingArguments(
    output_dir="qwen3-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    gradient_checkpointing=True,
    gradient_checkpointing_kwargs={"every_n_layers": 4},
    bf16=True,
    learning_rate=2e-5,
    logging_steps=10,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)
```

## Entrenamiento

Crea una instancia de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) con todos los componentes necesarios y luego llama a [train()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.train) para comenzar.

```py
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    processing_class=tokenizer,
    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

trainer.train()
trainer.push_to_hub()
```

[push_to_hub()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.push_to_hub) sube los pesos afinados, la configuración de generación, el tokenizador y la configuración del modelo al Hub.

## Próximos pasos

- Consulta la guía de [características de Trainer](./trainer_recipes) para ver ejemplos mínimos y funcionales de funciones comunes de Trainer, como funciones de pérdida personalizadas, evaluación eficiente en memoria, creación de puntos de control y más.
- Lea la guía [Métodos de subclase de Trainer](./trainer_customize) para aprender a subclasear los métodos de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) y así admitir nuevas funcionalidades y funcionalidades personalizadas.
- Lee la guía de [Callbacks](./trainer_callbacks) para aprender a conectar eventos de entrenamiento para el registro, la detención temprana y otros comportamientos personalizados.
- Lee la guía de [Data collators](./data_collators) para aprender a personalizar cómo se agrupan las muestras en lotes.
- Ejecuta un script de entrenamiento en una GPU alquilada con [Hugging Face Jobs](https://huggingface.co/docs/hub/jobs-training).
- Explora los [cuadernos](./notebooks) o la sección **Recursos > Recetas de tareas** para ver ejemplos adicionales de entrenamiento en diferentes tareas de texto, audio, visión y multimodales.

