TRL documentation
Personalización del entrenamiento
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