Transformers documentation

Ajuste fino

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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.

Agent prompt

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. Solicita los detalles faltantes que podrían alterar el modelo, el preprocesamiento o la configuración de entrenamiento. Indica 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 se corresponda con esas entradas.
  3. Configura TrainingArguments para adaptarse al hardware y a los objetivos del usuario. Configura la evaluación y el guardado de puntos de control cuando el usuario los necesite. Ejecuta una prueba pequeña antes de un trabajo de entrenamiento completo y verifica que el modelo reciba las entradas esperadas, que la pérdida sea finita y que la evaluación se complete.
  4. No inicie una ejecución completa de entrenamiento 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 elemento 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.

from huggingface_hub import login

login()

Tokenización

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

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.
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 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.
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 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.
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 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 para obtener una lista completa de argumentos.

duración del entrenamiento
optimizaciones de entrenamiento
evaluación y puntos de control
logging
  • 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.
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 con todos los componentes necesarios y luego llama a train() para comenzar.

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() 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 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 para aprender a subclasear los métodos de Trainer y así admitir nuevas funcionalidades y funcionalidades personalizadas.
  • Lee la guía de 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 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.
  • Explora los cuadernos o la sección Recursos > Recetas de tareas para ver ejemplos adicionales de entrenamiento en diferentes tareas de texto, audio, visión y multimodales.
Update on GitHub