TRL documentation

Personalización del entrenamiento

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Personalización del entrenamiento

TRL está diseñado con la modularidad en mente para que los usuarios puedan personalizar de manera eficiente el bucle de entrenamiento según sus necesidades. A continuación se muestran ejemplos de cómo aplicar y probar diferentes técnicas.

Aunque estos ejemplos utilizan DPOTrainer, estos métodos de personalización se aplican a la mayoría (si no es que a todos) los entrenadores de TRL.

Usa diferentes optimizadores y programadores

Por defecto, DPOTrainer crea un optimizador torch.optim.AdamW. Puede crear y definir un optimizador diferente y pasarlo a DPOTrainer de la siguiente manera:

from datasets import load_dataset
from torch import optim
from transformers import AutoModelForCausalLM
from trl import DPOTrainer

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
optimizer = optim.SGD(model.parameters(), lr=1e-6)

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
    optimizers=(optimizer, None),
)
trainer.train()

Agregar un programador de tasa de aprendizaje

También puede agregar programadores de tasa de aprendizaje pasando tanto el optimizador como el programador:

from torch import optim

optimizer = optim.AdamW(model.parameters(), lr=1e-6)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

trainer = DPOTrainer(..., optimizers=(optimizer, lr_scheduler))

Modelos de referencia de 8 bits

Dado que trl admite todos los argumentos de palabras clave al cargar un modelo desde transformers mediante from_pretrained, también puedes aprovechar load_in_8bit de transformers para un ajuste fino más eficiente en memoria.

Obtenga más información sobre la carga de modelos de 8 bits en transformers Carga en 8 bits o 4 bits.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)
ref_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct", quantization_config=quantization_config)

trainer = DPOTrainer(..., ref_model=ref_model)

Agregar callbacks personalizados

Puedes personalizar el bucle de entrenamiento añadiendo callbacks para registrar, monitorear o detener el entrenamiento de forma anticipada. Los callbacks te permiten ejecutar código personalizado en puntos específicos durante el entrenamiento.

from transformers import TrainerCallback


class CustomLoggingCallback(TrainerCallback):
    def on_log(self, args, state, control, logs=None, **kwargs):
        if logs is not None:
            print(f"Step {state.global_step}: {logs}")


trainer = DPOTrainer(..., callbacks=[CustomLoggingCallback()])

Agregar métricas de evaluación personalizadas

Puede definir métricas de evaluación personalizadas para monitorear durante el entrenamiento. Esto resulta útil para supervisar el rendimiento del modelo en tareas específicas.

def compute_metrics(eval_preds):
    logits, labels = eval_preds
    # Add your metric computation here
    return {"custom_metric": 0.0}


training_args = DPOConfig(..., eval_strategy="steps", eval_steps=100)

trainer = DPOTrainer(..., eval_dataset=eval_dataset, compute_metrics=compute_metrics)

Usar entrenamiento con precisión mixta

El entrenamiento con precisión mixta puede acelerar significativamente el entrenamiento y reducir el uso de memoria. Puedes activarlo estableciendo bf16=True o fp16=True en la configuración de entrenamiento.

# Use bfloat16 precision (recommended for modern GPUs)
training_args = DPOConfig(..., bf16=True)

Nota: Use bf16=True para GPUs Ampere (A100, RTX 30xx) o más nuevas, y fp16=True para GPUs más antiguas.

Usar acumulación de gradientes

Al entrenar con memoria de GPU limitada, la acumulación de gradientes permite simular tamaños de lote más grandes acumulando gradientes durante varios pasos antes de actualizar los pesos.

# Simulate a batch size of 32 with per_device_train_batch_size=4 and gradient_accumulation_steps=8
training_args = DPOConfig(
    ...,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
)

Cambiar el objetivo de entrenamiento

Subclasear un trainer es la forma más sencilla de personalizar el entrenamiento. La pérdida se define en el método compute_loss, por lo que, para entrenar con un objetivo diferente, se debe subclasear el trainer y sobrescribirlo. La preparación de datos, la generación, el registro y el checkpointing se heredan, por lo que la subclase solo contiene lo que realmente cambia.

import torch

from trl import DPOTrainer
from trl.trainer.utils import selective_log_softmax


class MyDPOTrainer(DPOTrainer):
    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        # In this example: the hinge loss from https://huggingface.co/papers/2309.06657
        input_ids, attention_mask = inputs["input_ids"], inputs["attention_mask"]
        shift_labels, shift_completion_mask = input_ids[:, 1:], inputs["completion_mask"][:, 1:]
        logits = model(input_ids=input_ids, attention_mask=attention_mask).logits
        with torch.no_grad():
            ref_logits = self.ref_model(input_ids=input_ids, attention_mask=attention_mask).logits

        # Sum the log-probs over the completion tokens, for the policy and for the reference model
        logps = (selective_log_softmax(logits[:, :-1], shift_labels) * shift_completion_mask).sum(dim=1)
        ref_logps = (selective_log_softmax(ref_logits[:, :-1], shift_labels) * shift_completion_mask).sum(dim=1)

        chosen_logps, rejected_logps = logps.chunk(2, dim=0)  # batch is [chosen, rejected]
        ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0)
        delta = (chosen_logps - ref_chosen_logps) - (rejected_logps - ref_rejected_logps)
        return torch.relu(1 - self.beta * delta).mean()

Agregar parámetros a la configuración

Subclasea la configuración para declarar los parámetros que necesita tu función de pérdida:

from dataclasses import dataclass, field

from trl import DPOConfig


@dataclass
class MyDPOConfig(DPOConfig):
    my_coef: float = field(default=0.1, metadata={"help": "Coefficient of the custom term."})

Cambiar el formato del lote

Cuando la pérdida necesita entradas que el collator predeterminado no produce, pase su propio collator y sobrescriba _prepare_dataset para dejar el conjunto de datos sin cambios cuando ya esté en el formato esperado:

class MyDPOTrainer(DPOTrainer):
    def _prepare_dataset(self, dataset, *args, **kwargs):
        return dataset


trainer = MyDPOTrainer(..., data_collator=my_collator)

Ejemplo completo

El ejemplo de SFT con difusión por bloques examples/sft_diffusion_gemma/sft_diffusion_gemma.py combina los tres: DiffusionGemmaSFTConfig extiende SFTConfig con los parámetros de lienzo y corrupción, y DiffusionGemmaSFTTrainer extiende SFTTrainer y reemplaza la entropía cruzada autoregresiva con un objetivo de desruido de difusión por bloques. Ninguno requiere un cambio en la biblioteca.

Antidoom, una herramienta de código abierto de Liquid AI, extiende DPOTrainer con Final Token Preference Optimization (Antislop), una pérdida de preferencia sobre una única posición de token que reduce los bucles de repetición en los modelos de razonamiento.

Update on GitHub