Índice de artículos

Cada artículo de abajo enlaza a su página de Hugging Face. También puedes leer cualquiera de ellos desde la terminal con la CLI hf, por ejemplo hf papers read 2402.03300 — especialmente útil para agentes de codificación.

Optimización de Política Relativa de Grupo

Artículos relacionados con GRPOTrainer.

DeepSeekMath: Llevando al límite el razonamiento matemático en modelos de lenguaje abiertos

📜 Artículo: https://huggingface.co/papers/2402.03300

Introduce Group Relative Policy Optimization (GRPO) y muestra mejoras significativas en razonamiento matemático gracias al preentrenamiento centrado en matemáticas y a la optimización estilo PPO relativa a grupos. Se utiliza en TRL a través de GRPOTrainer.

from trl import GRPOConfig, GRPOTrainer

# The paper doesn't specify its hyperparameters, so here we provide hyperparameters from "DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning" instead.
training_args = GRPOConfig(
    loss_type="grpo",
    beta=0.001,  # "the KL coefficient to 0.001"
    epsilon=10.0, # "the GRPO clip ratio ϵ to 10"
    num_generations=16,  # "For each question, we sample 16 outputs..."
    max_completion_length=32_768,  # "...with a maximum length of 32,768"
    steps_per_generation=16,  # "To accelerate training, each rollout generates 8,192 outputs, which are randomly split into 16 minibatches"
    # "resulting in a training batch size of 512". One way to achieve this setting with 1 device is per_device_train_batch_size=4, gradient_accumulation_steps=128
    per_device_train_batch_size=4,
    gradient_accumulation_steps=128,  
)
trainer = GRPOTrainer(
    ...,
    args=training_args,
)

DeepSeek-R1: Incentivizar la capacidad de razonamiento en LLM mediante aprendizaje por refuerzo

📜 Artículo: https://huggingface.co/papers/2501.12948

DeepSeek-R1 logra un rendimiento de razonamiento comparable al de OpenAI-o1 mediante un pipeline de múltiples etapas que transiciona desde el aprendizaje por refuerzo (RL) puro hasta un modelo refinado y alineado con humanos. A diferencia de su predecesor, DeepSeek-R1-Zero, que utilizaba RL puro en un modelo base, R1 sigue una evolución estructurada de cuatro etapas:

1. Inicio en frío: el modelo base se ajusta finamente en un pequeño conjunto de datos de alta calidad y largos de razonamiento paso a paso (Chain-of-Thought, CoT) para proporcionar un punto de partida estable.
2. RL orientado al razonamiento: se aplica RL a gran escala para mejorar el rendimiento en matemáticas, programación y lógica, utilizando recompensas basadas en reglas y una recompensa de consistencia del idioma para reducir la mezcla de idiomas.
3. Muestreo de rechazo y SFT: el punto de control de RL genera 600k muestras de razonamiento mediante muestreo de rechazo, que se combinan con 200k muestras no de razonamiento (generales) para crear un nuevo conjunto de datos para una segunda ronda de Supervised Fine-Tuning.
4. RL para todos los escenarios: una etapa final de RL alinea el modelo con las preferencias humanas (utilidad e inofensividad) en todos los dominios, manteniendo al mismo tiempo la capacidad de razonamiento.

Destilación: Potenciando modelos pequeños

Una contribución clave del artículo es demostrar que los patrones de razonamiento pueden destilarse desde un modelo grande (DeepSeek-R1) hacia modelos densos más pequeños (p. ej., las series Qwen y Llama). Se encontró que la destilación es más efectiva para los modelos pequeños que entrenarlos con RL puro desde cero.

Puedes usar GRPOTrainer para replicar las etapas de razonamiento intensivo de este pipeline.

from trl import GRPOConfig, GRPOTrainer

# Example configuration for a reasoning-oriented GRPO stage
# Based on the Open-R1 recipe for Qwen-7B
training_args = GRPOConfig(
    learning_rate=4.0e-5,
    max_completion_length=32768, # Support for long Chain-of-Thought
    num_generations=16,          # Sample 16 outputs per prompt for group relative advantage
    beta=0.001,                  # KL coefficient
    use_vllm=True,               # Use vLLM backend for accelerated rollout generation
)

trainer = GRPOTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    reward_funcs=[accuracy_reward, format_reward], # R1-Zero used rule-based rewards
)

trainer.train()

Optimización de la política de secuencia de grupo

📜 Artículo: https://huggingface.co/papers/2507.18071

GSPO es una variante de GRPO que calcula los pesos de muestreo de importancia a nivel de secuencia en lugar de por token. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl import GRPOConfig

training_args = GRPOConfig(
    importance_sampling_level="sequence",
    loss_type="grpo",
    beta=0.0,  # GSPO set KL regularization to zero: https://github.com/volcengine/verl/pull/2775#issuecomment-3131807306
    epsilon=3e-4,  # GSPO paper (v2), section 5.1
    epsilon_high=4e-4,  # GSPO paper (v2), section 5.1
    gradient_accumulation_steps=1,
    steps_per_generation=4,  # partition rollout batch into 4 mini-batches. GSPO paper (v2), section 5.1. Must be 4 times gradient_accumulation_steps
)

Tenga en cuenta que este método solo tiene un efecto cuando el entrenamiento se desvía ligeramente de la política; por ejemplo, cuando steps_per_generation > gradient_accumulation_steps o num_iterations > 1. De lo contrario, es efectivamente equivalente a no realizar ninguna modificación.

TRL incluyó una implementación experimental de GSPO-token hasta la v1.13; ya no forma parte de la biblioteca y sigue disponible en el historial de git. Difería del objetivo a nivel de secuencia anterior solo cuando la ventaja varía con $t$, lo cual TRL no genera actualmente.

Ratio de política: GRPO vs. GSPO

En GSPO, la proporción de la política se define a nivel de secuencia. En otras palabras, es la proporción entre la probabilidad de que la política actual genere una secuencia y la probabilidad de que la política anterior genere esa misma secuencia.

La verosimilitud de la secuencia se define como: $$\pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),$$

donde $\pi_\theta$ es la política $\pi$ con parámetros $\theta$, $o_i$ es la $i$-ésima secuencia de salida $o$ y $o_{i,t}$ es el $t$-ésimo token de esta secuencia, $q$ es la consulta de entrada. La razón de verosimilitud de la secuencia $s_i (\theta)$ se define como: $$s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}$$

El exponente $\frac{1}{|o_i|}$ representa una normalización por longitud de secuencia, minimizando la influencia de la longitud de la secuencia en la verosimilitud de la secuencia. En otras palabras, calcula la media geométrica de las probabilidades de los tokens, lo que garantiza una comparación equitativa entre secuencias de longitudes variables.

Mientras que GSPO define la proporción de la política a nivel de secuencia, GRPO opera a nivel de token. Específicamente, GRPO calcula una proporción de importancia para cada token de la secuencia: $$w_{i,t}(\theta) = \frac{\pi_\theta (o_{i,t} | q, o_{i,< t})}{\pi_{\theta_{\text{old}}} (o_{i,t} | q, o_{i,< t})}$$

Esta proporción a nivel de token se combina luego con una ventaja compartida $\hat{A}_i$, y el objetivo de GRPO recorta y optimiza cada token de forma independiente a lo largo de la secuencia.

Optimización de la política de la media geométrica

📜 Artículo: https://huggingface.co/papers/2507.20673

La optimización de políticas por media geométrica (GMPO) es una variante de GRPO que maximiza la media geométrica de las relaciones de importancia a nivel de token, en lugar de la media aritmética. La media geométrica es mucho menos sensible a las relaciones atípicas, por lo que la actualización de la política es más estable y tolera un rango de recorte mucho más amplio. El recorte se aplica por token, en espacio logarítmico, y es unilateral según el signo de la ventaja (la región de confianza estándar de PPO); crucialmente, se aplica antes de calcular la media geométrica. Esto es lo que distingue a GMPO de GSPO (importance_sampling_level="sequence"), que recorta la relación a nivel de secuencia después de promediar.

El objetivo de GMPO reemplaza la media aritmética por token de GRPO con la media geométrica de las proporciones de tokens (recortadas): $$\mathcal{J}_{\text{GMPO}}(\theta) = \mathbb{E}_{q, \{o_i\}} \left[ \frac{1}{G} \sum_{i=1}^{G} \left( \prod_{t=1}^{|o_i|} \min\left[ w_{i,t}(\theta)^{\operatorname{sgn}(\hat{A}_i)},\ \operatorname{clip}\left(w_{i,t}(\theta)^{\operatorname{sgn}(\hat{A}_i)}, \epsilon_1, \epsilon_2\right) \right]^{\operatorname{sgn}(\hat{A}_i)} \right)^{\frac{1}{|o_i|}} \hat{A}_i \right]$$

donde $w_{i,t}(\theta)$ es la proporción de importancia por token. En la práctica, el producto y el recorte se calculan en el espacio logarítmico para mayor estabilidad numérica, y el rango de recorte $(\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4})$ es notablemente más amplio que el de GRPO/DAPO para fomentar la exploración.

TRL ofrece una implementación experimental, consulte Experimental - GMPO:

from trl.experimental.gmpo import GMPOConfig, GMPOTrainer

training_args = GMPOConfig(
    epsilon=0.4,  # log-space clip range -> ratios clipped to (exp(-0.4), exp(0.4)); paper, Sec. 4
    beta=0.0,
)

DAPO: Un sistema de aprendizaje por refuerzo de LLM de código abierto a gran escala

📜 Artículo: https://huggingface.co/papers/2503.14476

El algoritmo DAPO incluye 5 componentes clave:

• Filtrado de longitud excesiva
• Clip-Higher
• Castigo suave por exceso de longitud
• Pérdida a nivel de token
• Muestreo dinámico (⚠️ No compatible con TRL)

Para reproducir la configuración del artículo, use esta configuración:

from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(
    # Overlong Filtering
    mask_truncated_completions=True,
    # Token-level Loss
    loss_type="dapo",
    # Clip-Higher
    epsilon_high=0.28, # DAPO paper: section 4.1
    epsilon=0.2, # DAPO paper: section 4.1
    # Other parameters used
    per_device_train_batch_size=512, # mini-batch size for training in the paper, DAPO paper: section 4.1
    num_generations=16, # number of sample responses in the paper, DAPO paper: section 4.1
    max_completion_length=20480, #  maximum number of tokens for generation in the paper, DAPO paper: section 4.1
    beta=0.0, # section 2.3, DAPO paper

)
# Soft Overlong Punishment
sop_reward = get_soft_overlong_punishment(max_completion_len=20480, soft_punish_cache=4096) # DAPO paper: section 4.1
trainer = GRPOTrainer(
    ...,
    args=training_args,
    reward_funcs=[..., sop_reward],
)

Desmitificando el razonamiento de cadena de pensamiento larga en LLM

📜 Artículo: https://huggingface.co/papers/2502.03373

Este estudio analiza el RL de cadenas de pensamiento largas e introduce dos recompensas complementarias basadas en reglas:

• Una recompensa de longitud escalada por coseno (get_cosine_scaled_reward(), Apéndice C.1) que escala la recompensa de corrección según la longitud de la finalización: una finalización correcta recibe una recompensa mayor cuando es más corta, mientras que una finalización incorrecta se penaliza menos cuando es más larga (preservando la exploración).
• Un penalización de repetición de n-gramas (get_repetition_penalty_reward(), Apéndice C.2) que desalienta las finalizaciones degeneradas y repetitivas que surgen como estrategia de manipulación de la recompensa bajo el ajuste de longitud.

Estos dos están diseñados para usarse juntos:

from trl import GRPOTrainer
from trl.rewards import get_cosine_scaled_reward, get_repetition_penalty_reward

# max_len should match the generation budget (in tokens)
cosine_scaled_reward = get_cosine_scaled_reward(max_len=4096)
# Penalize repeated 3-grams, down to -1.0 for fully repetitive completions
repetition_penalty = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
trainer = GRPOTrainer(
    ...,
    reward_funcs=[cosine_scaled_reward, repetition_penalty],
)

INTELLECT-2: Un modelo de razonamiento entrenado mediante aprendizaje por refuerzo descentralizado a nivel global

📜 Artículo: https://huggingface.co/papers/2505.07291

INTELLECT-2 es la primera ejecución de entrenamiento con aprendizaje por refuerzo distribuida a nivel global de un modelo de lenguaje de 32 mil millones de parámetros, utilizando RL totalmente asíncrono a través de un enjambre dinámico y heterogéneo de contribuidores de cómputo sin permisos. Los autores proponen modificaciones a la receta de entrenamiento estándar de GRPO, incluido el recorte de GRPO de doble lado para aumentar la estabilidad del entrenamiento. Para reproducir la configuración del artículo, use esta configuración:

from trl import GRPOConfig

training_args = GRPOConfig(
    delta=4,  # δ in section 4.1 of the paper
    epsilon=0.2,  # ε in section 4.1 of the paper
    beta=0.001,  # KL divergence coefficient in section 4.1 of the paper
    num_generations=16,  # responses per prompt in section 4.1 of the paper
    learning_rate=3e-7,  # section 4.1 of the paper
)

Skywork-OR1: Modelos de razonamiento abierto

📜 Artículo: https://huggingface.co/papers/2505.22312

Skywork-OR1 es una familia de modelos de razonamiento abiertos entrenados con GRPO. El artículo introduce control adaptativo de entropía: se añade un término de regularización de entropía −α·H(π_θ) al objetivo de GRPO, y el coeficiente α se ajusta automáticamente en cada paso del optimizador. Cuando la entropía media por token del modelo cae a o por debajo de un objetivo, α se incrementa para fomentar más exploración; de lo contrario, se decrementa. El bono solo se aplica mientras la entropía esté a o por debajo del objetivo. Para replicar este control adaptativo de entropía, utiliza la siguiente configuración:

from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(
    use_adaptive_entropy=True,   # enable adaptive entropy control (Section 3.3 of the paper)
    entropy_coef=0.01,           # initial entropy regularization coefficient
    entropy_target=5.0,          # target mean per-token entropy (nats); tune for your model
    entropy_coef_delta=0.005,    # step size for coefficient updates per optimizer step
)
trainer = GRPOTrainer(
    ...,
    args=training_args,
)

Más allá de la regla 80/20: los tokens minoritarios de alta entropía impulsan el aprendizaje por refuerzo efectivo para el razonamiento de LLM

📜 Artículo: https://huggingface.co/papers/2506.01939

Una minoría de tokens con alta entropía actúan como “bifurcaciones” de razonamiento en la ruta CoT, impulsando la exploración y las ganancias de rendimiento para RLVR, mientras que la mayoría de los tokens de baja entropía contribuyen poco o incluso obstaculizan el aprendizaje. RLVR ajusta principalmente los tokens de alta entropía, preservando en gran medida los patrones generales de entropía del modelo base. Así, aplicando la regla 80/20, entrenar solo con el 20% de los tokens de mayor entropía es comparable o supera a las actualizaciones de gradiente completo para los modelos Qwen3.

Los resultados principales del artículo utilizan DAPO vanilla (⚠️ Dynamic Sampling no está soportado en TRL). Para replicar los resultados principales, utiliza la siguiente configuración:

from trl import GRPOConfig, GRPOTrainer
from trl.rewards import get_soft_overlong_punishment

training_args = GRPOConfig(
    # --- vanilla DAPO parameters (80/20 rule: section 5.2) --- #
    # Overlong Filtering
    mask_truncated_completions=True,
    # Token-level Loss
    loss_type="dapo",
    # Clip-Higher
    epsilon_high=0.28, # DAPO paper: section 4.1
    epsilon=0.2, # DAPO paper: section 4.1
    # Other parameters used
    per_device_train_batch_size=512, # mini-batch size for training in the paper, DAPO paper: section 4.1
    num_generations=16, # number of sample responses in the paper, DAPO paper: section 4.1
    max_completion_length=20480, #  maximum number of tokens for generation in the paper, DAPO paper: section 4.1
    beta=0.0, # section 2.3, DAPO paper
    # --- Gradients on the highest entropy tokens --- #
    top_entropy_quantile=0.2
)
# Soft Overlong Punishment
sop_reward = get_soft_overlong_punishment(max_completion_len=20480, soft_punish_cache=4096) # DAPO paper: section 4.1
trainer = GRPOTrainer(
    ...,
    args=training_args,
    reward_funcs=[..., sop_reward],
)

Dr. GRPO: Comprensión del entrenamiento similar a R1-Zero: una perspectiva crítica

📜 Artículo: https://huggingface.co/papers/2503.20783

Un estudio sobre el entrenamiento de R1-Zero identifica los efectos del preentrenamiento en el rendimiento de RL y propone Dr. GRPO para mejorar la eficiencia de tokens, logrando una precisión superior en AIME 2024. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="dr_grpo",
    per_device_train_batch_size=1, # train_batch_size_per_device in the Training section of the repository
    num_generations=8, #  num_samples in the Training section of the repository
    max_completion_length=3000, # generate_max_length in the Training section of the repository
    beta=0.0, # β in the Training section of the repository
)

Parte I: ¿Trucos o trampas? Un análisis en profundidad del RL para el razonamiento de LLM (Lite PPO)

📜 Artículo: https://huggingface.co/papers/2508.08221

Los autores de este paper encuentran que la combinación de:

1. escalar las recompensas por la desviación estándar calculada sobre el lote completo y
2. agregando la pérdida sobre el número total de tokens

puede desbloquear la capacidad de aprendizaje de políticas sin crítico utilizando la pérdida PPO estándar. Sus resultados demuestran que esta combinación simple mejora de forma consistente el rendimiento, superando a estrategias como GRPO y DAPO.

TRL permite utilizar estos conocimientos para entrenar un modelo GRPO mediante:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...
    scale_rewards="batch",
    loss_type="dapo",
    # Other parameters used
    beta=0.0,  # = init_kl_coef in the paper
    top_p=0.99,
    top_k=100,
    temperature=0.99,
    num_generations=8, # = num_return_sequences in the paper
    num_iterations=1,  # = ppo_epochs in the paper
    per_device_train_batch_size=4,
    gradient_accumulation_steps=32,
    steps_per_generation=8,  # (rollout_batch_size*num_return_sequences) / (per_device_train_batch_size*gradient_accumulation_steps)
)

Tenga en cuenta que al usar la acumulación de gradientes, la pérdida se agrega sobre el número total de tokens del lote, pero no sobre el lote acumulado. Para más detalles, consulte GRPO Trainer - Loss types.

Muestreo de importancia truncado

📰 Blog: https://fengyao.notion.site/off-policy-rl

📜 Artículo: https://huggingface.co/papers/1606.02647

Los métodos de aprendizaje de políticas en línea suelen utilizar un marco de inferencia optimizado para la generación de rollout (p. ej., vLLM) que es independiente del backend de entrenamiento. Esto introduce una discrepancia entre el rollout y el entrenamiento, ejemplificada en el siguiente objetivo de PPO: $$\small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }$$

A pesar de que $\textcolor{red}{\pi_{\text{inference}}}$ y $\textcolor{blue}{\pi_{\text{training}}}$ comparten los mismos parámetros del modelo $\theta$, pueden generar probabilidades de tokens significativamente diferentes. Este comportamiento inesperado rompe implícitamente el supuesto de on-policy y convierte silenciosamente el entrenamiento en off-policy.

El muestreo de importancia truncado (TIS) aborda este problema adaptando la actualización del modelo mediante una corrección de muestreo de importancia. El cálculo del gradiente del objetivo PPO mencionado anteriormente se convierte en $$\small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \underbrace{\text{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}{\textcolor{red}{\pi_{\text{inference}}}(a, \theta_{\mathrm{old}})}, C_{\min}, C_{\max}\bigr)}_{\text{truncated importance ratio}} \cdot \nabla_\theta \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }$$

donde $C_{\min}$ y $C_{\max}$ son hiperparámetros. TIS se implementa en GRPO y se habilita al seleccionar una variante de vllm_importance_sampling_mode que incluye el término truncate, como "sequence_truncate" o "token_truncate".

from trl import GRPOConfig

training_args = GRPOConfig(
    ...
    use_vllm=True,
    vllm_importance_sampling_correction=True, # default True
    vllm_importance_sampling_mode="sequence_truncate", # or "token_truncate"
    vllm_importance_sampling_clip_max=2.0, # hyper-parameter C_max
)

Muestreo de importancia enmascarado

📰 Blog: https://ringtech.notion.site/icepop

📜 Artículo: https://huggingface.co/papers/2510.18855

📰 Blog: https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda

El Muestreo de Importancia con Enmascarado (MIS) aborda el mismo problema que el Muestreo de Importancia Truncado pero reemplaza el recorte con enmascarado. MIS adopta una postura más decisiva al descartar las actualizaciones cuya discrepancia se encuentra fuera del rango $[C_{\min}, C_{\max}]$.

$$\small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \underbrace{\mathbf{1}\left[ C_{\min} \le \frac{\pi_{\text{training}}(a, \theta_{\mathrm{old}})} {\pi_{\text{inference}}(a, \theta_{\mathrm{old}})} \le C_{\max} \right] \cdot \frac{\pi_{\text{training}}(a, \theta_{\mathrm{old}})} {\pi_{\text{inference}}(a, \theta_{\mathrm{old}})}}_{\text{masked importance ratio}} \cdot \nabla_\theta \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }$$

MIS se implementa para GRPO y se habilita al seleccionar una variante de vllm_importance_sampling_mode que incluya el término "mask", como "sequence_mask" o "token_mask".

from trl import GRPOConfig

training_args = GRPOConfig(
    ...
    use_vllm=True,
    vllm_importance_sampling_correction=True, # default True
    vllm_importance_sampling_mode="sequence_mask", # or "token_mask"
    vllm_importance_sampling_clip_max=2.0, # hyper-parameter C_max
    vllm_importance_sampling_clip_min=0.5, # hyper-parameter C_min
)

En el AsyncGRPOTrainer, las probabilidades logarítmicas antiguas son las del muestreador, por lo que la proporción se toma directamente entre la política entrenada y el muestreador, y los tokens fuera de $[C_{\min}, C_{\max}]$ se descartan de la pérdida. Está activado de forma predeterminada:

from trl import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    vllm_importance_sampling_clip_min=0.5,  # hyper-parameter C_min
    vllm_importance_sampling_clip_max=5.0,  # hyper-parameter C_max
)

Muestreo de importancia a nivel de secuencia

📰 Blog: https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda

La forma teóricamente fundamentada de corregir el cambio de distribución entre el entrenamiento y la inferencia es el muestreo de importancia, tal como se introdujo en los dos artículos anteriores Truncated Importance Sampling y Masked Importance Sampling. Sin embargo, la elección de la formulación es crucial para mantener el gradiente sin sesgo y garantizar un entrenamiento estable.

Este trabajo demuestra que el muestreo de importancia a nivel de secuencia es el enfoque adecuado para abordar la discrepancia entre el entrenamiento y la inferencia. Aunque el muestreo de importancia a nivel de token logra una varianza menor que una proporción a nivel de secuencia, introduce sesgo y, por lo tanto, se considera inadecuado para los modelos autoregresivos. El estimador de gradiente a nivel de token es $$\mathbb{E}_{x\sim\mathcal{D},\, y\sim \pi^{\text{inference}}_\theta(\cdot|x)} \Bigg[ R(x,y)\,\cdot\, \sum_{t=0}^{|y|-1} \frac{\pi^{\text{training}}_\theta(y_t\,|\,x, y_{<t})} {\pi^{\text{inference}}_\theta(y_t\,|\,x, y_{<t})} \,\nabla_\theta \log \pi^{\text{training}}_\theta(y_t\,|\,x, y_{<t}) \Bigg]$$ El estimador de gradiente de política correcto y sin sesgo aplica una única proporción de importancia sobre toda la secuencia generada (trayectoria) $y$, El estimador de IS a nivel de secuencia es: $$\mathbb{E}_{x\sim\mathcal{D},\, y\sim \pi^{\text{inference}}_\theta(\cdot|x)} \Bigg[ \frac{\pi^{\text{training}}_\theta(y|x)} {\pi^{\text{inference}}_\theta(y|x)} \, R(x,y)\, \nabla_\theta \log \pi^{\text{training}}_\theta(y|x) \Bigg]$$

TRL expone el nivel de granularidad del Importance Sampling a través del parámetro de configuración vllm_importance_sampling_mode, donde los modos "sequence_*" implementan una proporción de importance sampling a nivel de secuencia y "token_*" una proporción por token.

El arte de escalar el aprendizaje por refuerzo

📜 Artículo: https://huggingface.co/papers/2510.13786

Un estudio sistemático que define un marco para analizar y predecir el escalado del aprendizaje por refuerzo en modelos de lenguaje grandes, identifica las decisiones de diseño clave que afectan la eficiencia de cómputo y propone una receta de mejores prácticas llamada ScaleRL.

Puede reproducir parcialmente la receta de ScaleRL utilizando GRPOTrainer con las siguientes configuraciones:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="cispo",
    epsilon_high=5.0,
    num_generations=16,
    scale_rewards="batch",
    cast_lm_head_to_fp32=True
)

It Takes Two: Tu GRPO es secretamente DPO

📜 Artículo: https://huggingface.co/papers/2510.00977

Demuestra que la eficacia de GRPO proviene de un objetivo contrastivo implícito y no de una estimación precisa de la ventaja mediante tamaños de grupo grandes. Esto establece una conexión formal entre GRPO y DPO, donde el tamaño del grupo solo afecta a los estimadores de Monte Carlo del objetivo contrastivo. Los autores introducen 2-GRPO —que utiliza solo dos rollouts—, que iguala el rendimiento de 16-GRPO con un costo de entrenamiento significativamente menor. Se utiliza en TRL a través de GRPOTrainer con num_generations=2. Para reproducir la configuración del artículo, use esta configuración:

from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(
    num_generations=2,  # minimal two-rollout case (2-GRPO) from the paper
    loss_type="grpo",
)
trainer = GRPOTrainer(
    ...,
    args=training_args,
)

Optimización de Política Adaptativa Suave

📜 Artículo: https://huggingface.co/papers/2511.20347

Soft Adaptive Policy Optimization (SAPO) sustituye el recorte duro por una compuerta suave controlada por temperatura que atenúa de forma adaptativa las actualizaciones fuera de política, al tiempo que preserva las señales de aprendizaje útiles. En comparación con GSPO y GRPO, SAPO es coherente a nivel de secuencia y adaptativo a nivel de token. Al igual que GSPO, SAPO mantiene la coherencia a nivel de secuencia, pero su compuerta suave forma una región de confianza continua que evita la banda de recorte duro y frágil utilizada en GSPO.

Para reproducir la configuración del artículo, use esta configuración:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="sapo",
    sapo_temperature_pos=1.0,  # default value
    sapo_temperature_neg=1.05,  # default value
    scale_rewards="group",
    ...
)

DeepSeek-V3.2: Impulsando la frontera de los grandes modelos de lenguaje abiertos

📜 Artículo: https://huggingface.co/papers/2512.02556

El informe técnico de DeepSeek-V3.2 introduce varias técnicas para mejorar el rendimiento de GRPO. En TRL implementamos:

• La estimación no sesgada de KL, que corrige el estimador K3 (utilizado en la implementación original de GRPO) para obtener una estimación no sesgada de KL mediante la razón de muestreo por importancia entre la política actual $\pi_\theta$ y la política de comportamiento $\pi_{\text{old}}$. $$\mathrm{D}_{\mathrm{KL}}\!\left(\pi_\theta(o_{i,t}) \,\|\, \pi_{\text{ref}}(o_{i,t})\right) = \textcolor{red}{\frac{\pi_\theta(o_{i,t}\mid q, o_{i,<t})}{\pi_{\text{old}}(o_{i,t}\mid q, o_{i,<t})}} \left( \frac{\pi_{\text{ref}}(o_{i,t}\mid q, o_{i,<t})}{\pi_\theta(o_{i,t}\mid q, o_{i,<t})} - \log \frac{\pi_{\text{ref}}(o_{i,t}\mid q, o_{i,<t})}{\pi_\theta(o_{i,t}\mid q, o_{i,<t})} - 1 \right).$$

Esta función está habilitada de forma predeterminada (use_bias_correction_kl=True en GRPOConfig), por lo que solo necesitas establecer beta > 0:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    beta=0.001,  # the paper doesn't specify the value used, so we use the value from "DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning"
)

• El Off-Policy Masking, que estabiliza el entrenamiento ignorando las secuencias en las que la política tiene un rendimiento deficiente (ventaja negativa) y se ha desviado significativamente de la política anterior (alta divergencia de KL).

La máscara binaria off-policy $\textcolor{red}{M_{i,t}}$ se define como: $$\textcolor{red}{M_{i,t}} = \begin{cases} 0 & \text{if } \hat{A}_{i,t} < 0 \quad \text{and} \quad \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \log \frac{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} > \textcolor{blue}{\delta} \\ 1 & \text{otherwise} \end{cases}$$

Esta máscara se aplica a la pérdida de GRPO de la siguiente manera: $$\mathcal{L}_{\text{GRPO}}(\theta) = -\frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \left[ \min \left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})} \hat{A}_{i,t}, \, \text{clip}\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})}, 1 - \epsilon, 1 + \epsilon \right) \hat{A}_{i,t} \right) \textcolor{red}{M_{i,t}} - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right]$$

Para habilitar esta función, usa el off_policy_mask_threshold (correspondiente a $\textcolor{blue}{\delta}$) en el GRPOConfig:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    off_policy_mask_threshold=0.5,
)

Aunque el artículo no especifica un $\textcolor{blue}{\delta}$ valor utilizado, un buen punto de partida podría ser $\textcolor{blue}{\delta} = 0.5$. Si el entrenamiento parece demasiado conservador o se enmascaran demasiadas secuencias, puedes aumentar el valor. Para referencia, $\textcolor{blue}{\delta} = 1.0$ corresponde a una divergencia de log-ratio promedio de 1 nat por token, es decir, en las secuencias donde se supera este umbral, la política anterior tenía una probabilidad promedio $e^1 \approx 2.7$ veces mayor de generar estos tokens que la política actual.

• La Keep Sampling Mask estrategia, que mantiene el muestreo top-k/top-p sin sesgo. El muestreador extrae cada token de un soporte truncado $\textcolor{red}{\mathcal{S}_{i,t}}$, los tokens restantes tras la truncación, por lo que la log-probabilidad de la política se renormaliza sobre ese mismo soporte: $$\log \pi_\theta(o_{i,t} \mid q, o_{i,<t}) = z_{o_{i,t}} - \log \sum_{v \in \textcolor{red}{\mathcal{S}_{i,t}}} e^{z_v}.$$

Sin él, la proporción de importancia está sesgada hacia abajo y el gradiente sigue empujando la masa de probabilidad hacia tokens que el muestreador nunca extrae, lo que colapsa el entrenamiento. Esto se admite en el AsyncGRPOTrainer: con top_p < 1.0, top_k > 0 o min_p > 0.0, el trabajador de rollout registra el soporte de cada token desde vLLM (>= 0.28, iniciado con --return-sampling-mask --enable-scale-out) y el entrenador lo renormaliza sobre él:

from trl import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    top_p=0.95,
    top_k=512,
)

También se admite en el GRPOTrainer con vLLM en modo colocate (>= 0.28): con top_k > 0 y la corrección de muestreo por importancia habilitada (el valor predeterminado), vLLM devuelve el soporte de cada token y el entrenador lo renormaliza:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    use_vllm=True,
    top_p=0.95,
    top_k=512,
)

GDPO: Optimización de políticas con normalización desacoplada de recompensas por grupo para la optimización RL de múltiples recompensas

📜 Artículo: https://huggingface.co/papers/2601.05242

GDPO es un método de optimización de aprendizaje por refuerzo diseñado para el entrenamiento con múltiples recompensas. Si bien los enfoques existentes aplican comúnmente la Optimización Relativa de Políticas por Grupos (GRPO) en configuraciones de múltiples recompensas, los autores demuestran que esto provoca el colapso de las ventajas de recompensa, lo que reduce la resolución de la señal de entrenamiento y causa una convergencia inestable o fallida. GDPO resuelve este problema desacoplando la normalización de recompensas entre las recompensas individuales, preservando sus diferencias relativas y permitiendo una optimización de preferencias más fiel. Para habilitar GDPO para el entrenamiento de RL con múltiples recompensas, simplemente establezca:

Para un grupo de $N$ recompensas y $G$ muestras por grupo, GDPO normaliza cada recompensa de forma independiente: $$A_n^{(i,j)} = \frac{r_n^{(i,j)} - \text{mean}\{r_n^{(i,1)}, \ldots, r_n^{(i,G)}\}}{\text{std}\{r_n^{(i,1)}, \ldots, r_n^{(i,G)}\} + \epsilon}$$

La ventaja de grupo normalizada se agrega luego entre las recompensas: $$A^{(i,j)} = \sum_{n=1}^{N} w_n A_n^{(i,j)}$$

La normalización final por lote produce: $$\hat{A}^{(i,j)} = \frac{A^{(i,j)} - \text{mean}_{i',j'}\{A^{(i',j')}\}}{\text{std}_{i',j'}\{A^{(i',j')}\} + \epsilon}$$

Aquí, $\text{mean}_{i',j'}\{A^{(i',j')}\}$ y $\text{std}_{i',j'}\{A^{(i',j')}\}$ denotan estadísticas sobre todos los grupos del lote.

from trl import GRPOConfig


training_args = GRPOConfig(
    ...,
    multi_objective_aggregation="normalize_then_sum",
)

Tenga en cuenta que este método solo tiene un efecto cuando el entrenamiento involucra más de una función de recompensa.

Los autores proporcionan un ejemplo de entrenamiento fácil de usar y sin slurm que permite a la comunidad validar rápidamente la eficacia de GDPO frente a GRPO, ver Experiment-”Aha” moment.

Optimización de políticas de secuencias sin sesgo de longitud: revelando y controlando la variación de la longitud de la respuesta en RLVR

📜 Artículo: https://huggingface.co/papers/2602.05261

La optimización de políticas de secuencias sin sesgo de longitud (LUSPO) modifica GSPO escalando la pérdida de cada secuencia por su longitud. Esto corrige el sesgo de gradiente de GSPO que penaliza las respuestas más largas. Para reproducir la configuración del artículo, use esta configuración:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="luspo",
    importance_sampling_level="sequence",
    epsilon=2e-3, # section 5.1 of the paper
    epsilon_high=2.5e-3, # section 5.1 of the paper
)

VESPO: Optimización de políticas suaves a nivel de secuencia variacional para un entrenamiento estable de LLMs fuera de política

📜 Artículo: https://huggingface.co/papers/2602.10693

VESPO aborda la inestabilidad del entrenamiento en RL off-policy causada por la obsolescencia de la política, las actualizaciones asíncronas y las discrepancias entre entrenamiento e inferencia. En lugar de depender del recorte heurístico a nivel de token (GRPO) o de la normalización por longitud de secuencia (GSPO), VESPO deriva un núcleo de remodelado fundamentado a partir de un marco variacional. En la práctica, esto produce una función de ponderación Gamma suave y asimétrica que suprime elegantemente los pesos de importancia extremos a nivel de secuencia sin introducir sesgo de longitud. $$\mathcal{L}_{\text{VESPO}}(\theta) = - \mathbb{E}_{\tau \sim \mu} \left[ \underbrace{W(\tau)^{k} \cdot \exp\left(\lambda (1 - W(\tau))\right)}_{\phi(W) \text{ detached }} \cdot \mathcal{A}(\tau) \cdot \log \pi_\theta(\tau) \right]$$

con $W(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)}$ la razón de importancia a nivel de secuencia, y $\phi(W)$ se desconecta del grafo de cómputo para servir como coeficiente de escalado del gradiente.

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="vespo",
    use_vllm=True,  # or False if not using any token-level `vllm_importance_sampling_correction` methods
    vllm_importance_sampling_mode="token_truncate",  # default correction mode for VESPO, `token_mask` also supported
    vespo_k_pos=2.0,  # power exponent (c1 in paper Section 3.4) for positive advantages
    vespo_lambda_pos=3.0,  # decay factor (c2 in paper Section 3.4) for positive advantages
    vespo_k_neg=3.0,  # power exponent (c1 in paper Section 3.4) for negative advantages
    vespo_lambda_neg=2.0,  # decay factor (c2 in paper Section 3.4) for negative advantages
)

El centrado de puntuaciones estabiliza el aprendizaje por refuerzo fuera de política

📜 Artículo: https://huggingface.co/papers/2609.20807

Bajo un desajuste entre entrenamiento e inferencia, la puntuación $\nabla_\theta \log \pi_\theta$ se promedia a cero bajo el muestreador $\mu$, por lo que cada actualización desplaza la política hacia el muestreador, en una cantidad que crece con la ventaja. El centrado de la puntuación resta esa expectativa en cada posición, de modo que una ventaja constante ya no mueve la política: $$\nabla_\theta \mathcal{L} = - \mathbb{E}_{o \sim \mu} \left[ \hat{A} \left( f(r_t) \nabla_\theta \log \pi_\theta(o_t) - \mathbb{E}_{v \sim \mu} \left[ f(r_v) \nabla_\theta \log \pi_\theta(v) \right] \right) \right], \quad r_v = \frac{\pi_\theta(v)}{\mu(v)},$$

con $f$ el peso de importancia de Muestreo de Importancia Enmascarado: $f(r) = r$ dentro de $[C_{\min}, C_{\max}]$ y $0$ fuera. La esperanza interna se toma sobre los tokens más probables del muestreador en cada posición, cuyos log-probabilidades informa; sobre el resto del vocabulario, el muestreador se toma como la política entrenada reescalada a la masa restante.

Es el objetivo predeterminado del AsyncGRPOTrainer, cuyo trabajador de rollout solicita las log-probabilidades superiores de cada token generado desde vLLM:

from trl import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    score_centering=True,  # default; `False` trains with the clipped objective instead
    vllm_importance_sampling_clip_min=0.5,  # hyper-parameter C_min
    vllm_importance_sampling_clip_max=5.0,  # hyper-parameter C_max
    num_sampler_logprobs=8,  # tokens per position the expectation is taken over
)

Regresión de Ventaja Óptima

Artículos relacionados con experimental.a2po.A2POTrainer.

Acelerar el RL para el razonamiento de LLM con regresión de ventaja óptima

📜 Artículo: https://huggingface.co/papers/2505.20686

A*-PO (Optimal Advantage Regression) es un método de RL de dos etapas para el razonamiento de LLM que evita tanto un crítico en línea como despliegues de grupo con múltiples muestras. La etapa 1 estima el valor óptimo V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)] de forma offline a partir de muestras de la política de referencia; la etapa 2 realiza actualizaciones on-policy con una sola generación por prompt utilizando una pérdida de regresión de error cuadrático (β·log(π(y|x)/π_ref(y|x)) − (r(x, y) − V*(x)))². Esto produce un entrenamiento más rápido y una memoria pico menor que PPO/GRPO/REBEL. El método asume una recompensa binaria verificable y no puede superar el Pass@K de la política de referencia. Consulte A2PO. El código oficial se encuentra en ZhaolinGao/A-PO.

from trl.experimental.a2po import A2POConfig, A2POTrainer

# Hyperparameters from the paper (Qwen2.5, GSM8K/MATH)
training_args = A2POConfig(
    beta1=0.5,  # KL temperature for offline V* estimation
    beta2=1e-3,  # KL temperature for the on-policy regression target
    num_value_samples=8,  # N samples per prompt from the reference policy
)
trainer = A2POTrainer(
    model=...,
    reward_funcs=...,  # should return a binary reward in {0, 1}
    args=training_args,
    train_dataset=...,
)
trainer.train()

Optimización de Preferencias Directas

Artículos relacionados con DPOTrainer

Optimización de Preferencias Directas: Tu modelo de lenguaje es secretamente un modelo de recompensa

📜 Artículo: https://huggingface.co/papers/2305.18290

La optimización de preferencias directas (DPO) ajusta los modelos de lenguaje de manera más eficiente y con un mejor rendimiento en comparación con el aprendizaje por refuerzo a partir de retroalimentación humana (RLHF), optimizando directamente el entrenamiento de la política en función de las preferencias humanas. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid", # losses in Appendix B of the paper
    per_device_train_batch_size=64, #  batch size in Appendix B of the paper
    learning_rate=1e-6, # learning rate in Appendix B of the paper
    beta=0.1, # β in Appendix B of the paper
)

SLiC-HF: Calibración de verosimilitud de secuencias con retroalimentación humana

📜 Artículo: https://huggingface.co/papers/2305.10425

Se ha demostrado que la calibración de verosimilitud de secuencias (SLiC) es una alternativa eficaz y más simple al aprendizaje por refuerzo a partir de retroalimentación humana (RLHF) para aprender de las preferencias humanas en modelos de lenguaje. Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="hinge", # Section 2 of the paper
    per_device_train_batch_size=512, #  batch size in Section 3.2 of the paper
    learning_rate=1e-4, # learning rate in Section 3.2 of the paper
)

Estos parámetros solo aparecen en la versión publicada

El muestreo de rechazo estadístico mejora la optimización de preferencias

📜 Artículo: https://huggingface.co/papers/2309.06657

Propone RSO, seleccionar pares de preferencias más fuertes mediante muestreo de rechazo estadístico para mejorar la optimización de preferencias offline; complementa DPO/SLiC. También introducen una nueva pérdida definida como: $$\mathcal{L}_{\text{hinge-norm}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ \max\left(0,\; 1 - \left[\gamma \log \frac{\pi_\theta(y_w \mid x)}{\pi_\text{ref}(y_w \mid x)} - \gamma \log \frac{\pi_\theta(y_l \mid x)}{\pi_\text{ref}(y_l \mid x)}\right]\right) \right]$$

Para entrenar con datos filtrados por RSO y la pérdida hinge-norm, puede usar el siguiente código:

from trl import DPOConfig, DPOTrainer

dataset = ...

def rso_accept(example):  # replace with your actual filter/score logic
    return example["rso_keep"]

train_dataset = train_dataset.filter(rso_accept)

training_args = DPOConfig(
    loss_type="hinge",
    beta=0.05,  # correspond to γ in the paper
)

trainer = DPOTrainer(
    ...,
    args=training_args,
    train_dataset=train_dataset,
)
trainer.train()

Más allá de la KL inversa: generalización de la Optimización de Preferencias Directas con restricciones de divergencia diversas

📜 Artículo: https://huggingface.co/papers/2309.16240

Propone f-DPO, que extiende DPO reemplazando el regularizador reverse-KL habitual por una f-divergencia general, lo que permite equilibrar el comportamiento de búsqueda de modos frente a la cobertura de masa (p. ej. KL directa, JS, divergencias α). El único cambio es reemplazar el margen de la relación logarítmica de DPO por una puntuación f′: $$\mathcal{L}_{f\text{-DPO}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ -\log \sigma\left( \beta \textcolor{red}{f'}\textcolor{red}{\Big(}\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)}\textcolor{red}{\Big)} - \beta \textcolor{red}{f'}\textcolor{red}{\Big(}\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\textcolor{red}{\Big)} \right) \right]$$

donde $f'$ es la derivada de la función convexa que define la divergencia de f elegida.

Para reproducir:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid",
    beta=0.1,
    f_divergence_type="js_divergence",  # or "reverse_kl" (default), "forward_kl", "js_divergence", "alpha_divergence"
    f_alpha_divergence_coef=0.5,  # only used if f_divergence_type="alpha_divergence"
)

Un paradigma teórico general para comprender el aprendizaje a partir de preferencias humanas

📜 Artículo: https://huggingface.co/papers/2310.12036

Aprender de preferencias humanas se puede escribir como un único objetivo regularizado por KL sobre probabilidades de preferencia por pares, $$\max_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),$$

lo que revela que RLHF y DPO son casos especiales que corresponden a la elección de logits de $\Psi$. El artículo demuestra que esta transformación de logits amplifica las preferencias casi deterministas y debilita efectivamente la regularización KL, lo que explica el sobreajuste. Usando la transformación de identidad (IPO) se evita esta patología optimizando las preferencias directamente, sin asumir un modelo de recompensa de Bradley–Terry. Para reproducir la configuración del artículo, usa esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="ipo",  # Section 5.1 of the paper
    per_device_train_batch_size=90,  #  mini-batch size in Section C.1 of the paper
    learning_rate=1e-2,  # learning rate in Section C.1 of the paper
)

Estos parámetros solo aparecen en la versión publicada

Hacia una optimización eficiente y exacta del alineamiento de modelos de lenguaje

📜 Artículo: https://huggingface.co/papers/2402.00856

El artículo demuestra que los métodos de preferencia directa, como DPO, optimizan la dirección incorrecta de KL, lo que lleva a una captura borrosa de las preferencias, y propone EXO como una forma eficiente de optimizar exactamente el objetivo de alineación con las preferencias humanas aprovechando el ajuste de probabilidad de KL inverso en lugar de aproximaciones de KL directa. Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="exo_pair", # Section 3.2 of the paper
    # From Section B of the paper
    per_device_train_batch_size=64,
    learning_rate=1e-6,
    beta=0.1,
)

Alineamiento contrastivo de ruido de modelos de lenguaje con recompensas explícitas

📜 Artículo: https://huggingface.co/papers/2402.05369

El artículo redefine el alineamiento de modelos de lenguaje como un problema de clasificación contrastiva de ruido, proponiendo InfoNCA para aprender una política a partir de recompensas (o preferencias) explícitas al ajustar una distribución objetivo sobre las respuestas inducida por la recompensa, y demostrando que DPO es un caso binario especial. A continuación, introduce NCA, que añade un término de verosimilitud absoluta para evitar el colapso de la verosimilitud observado en objetivos puramente relativos (contrastivos).

Con preferencias por pares, tratar las elegidas/rechazadas$K=2$, define las puntuaciones$r=\beta(\log\pi_\theta-\log\pi_{\text{ref}})$, y aplicar la pérdida de preferencia NCA$-\log\sigma(r_w)-\tfrac12\log\sigma(-r_w)-\tfrac12\log\sigma(-r_l)$.

Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="nca_pair",
    # From Section C of the paper
    per_device_train_batch_size=32,
    learning_rate=5e-6,
    beta=0.01,
)

DPO robusto demostrable: alineación de modelos de lenguaje con retroalimentación ruidosa

📜 Artículo: https://huggingface.co/papers/2403.00409

DPO se rompe con preferencias humanas ruidosas porque las inversiones de etiquetas sesgan el objetivo. Robust DPO corrige esto desviando analíticamente la pérdida de DPO bajo un modelo de ruido simple, con garantías demostrables. $$\mathcal{L}_{\text{robust}}(\pi_\theta) = \frac{(1-\varepsilon)\mathcal{L}_{\text{DPO}}(y_w, y_l) - \varepsilon\mathcal{L}_{\text{DPO}}(y_l, y_w)} {1-2\varepsilon}$$

Donde $\mathcal{L}_{\text{DPO}}$ es la pérdida DPO definida en Direct Preference Optimization: Your Language Model is Secretly a Reward Model y $\varepsilon$ es la probabilidad de una inversión de etiqueta.

Esta única corrección convierte los datos de preferencia ruidosos en un estimador no sesgado del objetivo DPO limpio.

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="robust",
    per_device_train_batch_size=16,  # batch size in Section B of the paper
    learning_rate=1e-3,  # learning rate in Section B of the paper
    beta=0.1,  # β in Section B of the paper,
    max_length=512,  # max length in Section B of the paper
    label_smoothing=0.1  # label smoothing {@html "$\varepsilon$"} in Section 6 of the paper
)

Optimización de clasificadores binarios para la alineación de modelos de lenguaje de gran escala

📜 Artículo: https://huggingface.co/papers/2404.04656

El análisis teórico y un nuevo algoritmo, Binary Classifier Optimization, explican y mejoran la alineación de los grandes modelos de lenguaje mediante señales de retroalimentación binaria. Para reproducir la configuración del artículo, utiliza esta configuración:

BCO reformula la alineación de modelos de lenguaje como clonación conductual desde una distribución óptima ponderada por recompensa, lo que genera objetivos supervisados simples que evitan el RL manteniendo un fundamento teórico. Admite tanto datos de recompensa no emparejados como datos de preferencia por pares, con una formulación invariante al desplazamiento de recompensa que se reduce a una pérdida de estilo DPO en el contexto de preferencias.

Para la configuración de preferencias por pares, la pérdida BCO se define como: $$\mathcal{L}_{\text{bco\_pair}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ -\log \sigma\Big( \beta[(\log\pi_\theta-\log\pi_{\text{ref}})(y_w) - (\log\pi_\theta-\log\pi_{\text{ref}})(y_l)] \Big) \right]$$

Para reproducir el artículo en esta configuración, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="bco_pair",
    # From Section C of the paper
    per_device_train_batch_size=128,
    learning_rate=5e-7,
    beta=0.01,
)

Aprende tu modelo de referencia para una alineación realmente buena

📜 Artículo: https://huggingface.co/papers/2404.09656

Trust Region DPO (TR-DPO) actualiza la política de referencia durante el entrenamiento, demostrando su eficacia frente a DPO en los conjuntos de datos Anthropic HH y TLDR, superando a DPO en hasta un 19% medido mediante evaluación automática con GPT-4, mejorando la coherencia, la corrección, el nivel de detalle, la utilidad y la inofensividad. Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    sync_ref_model=True,  # enable TR-DPO (Section 3 of the paper)
    ref_model_mixup_alpha=0.6,  # α soft update weight (Table 1 of the paper)
    ref_model_sync_steps=512,  # τ update frequency in steps (Table 1 of the paper)
    beta=0.05,  # β temperature (Table 1 of the paper)
    learning_rate=1e-6,  # learning rate (Table 2 of the paper)
    num_train_epochs=1,  # Table 2 of the paper
    max_length=1024,  # max tokens length (Table 2 of the paper)
    max_grad_norm=2,  # max gradient norm (Table 2 of the paper)
    warmup_steps=100,  # warm-up steps (Table 2 of the paper)
)

Optimización de preferencias de razonamiento iterativo

📜 Artículo: https://huggingface.co/papers/2404.19733

RPO iterativo mejora el razonamiento generando repetidamente candidatos de cadena de pensamiento, construyendo pares de preferencia a partir de respuestas correctas e incorrectas y entrenando con un objetivo DPO + NLL. El término NLL adicional es clave para aprender a generar realmente trazas ganadoras.

TRL puede expresar el objetivo DPO + NLL combinando "sigmoid" (DPO) con "sft" (NLL):

from trl import DPOConfig, DPOTrainer

training_args = DPOConfig(
    loss_type=["sigmoid", "sft"],
    loss_weights=[1.0, 1.0],  # alpha in the paper, recommended value is 1.0
)
trainer = DPOTrainer(
    ...,
    args=training_args,
)

Tenga en cuenta que el artículo utiliza un bucle iterativo: cada iteración regenera candidatos de CoT con el modelo actual y luego entrena de nuevo con pares de preferencias nuevos. TRL no automatiza ese bucle por usted.

Optimización de preferencias mediante autojuego para la alineación de modelos de lenguaje

📜 Artículo: https://huggingface.co/papers/2405.00675

Un método de autojuego llamado SPPO para la alineación de modelos de lenguaje logra un rendimiento líder del estado del arte al aproximar la política de equilibrio de Nash en un entorno de juego de suma constante, superando a otros enfoques con datos limitados. Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sppo_hard",
    # From Section 5 of the paper
    beta=0.001,  # β = η^−1
    per_device_train_batch_size=64,
    learning_rate=5e-7,
)

Mitigar de forma demostrable la sobreoptimización en RLHF: tu pérdida de SFT es implícitamente un regularizador adversarial

📜 Artículo: https://huggingface.co/papers/2405.16436

La Optimización de Preferencias Regularizada (RPO) mitiga la sobreoptimización en RLHF fusionando la pérdida de DPO con la pérdida de SFT, lo que previene de forma demostrable que la política elija acciones con recompensas proxy falsamente altas. Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type=["sigmoid", "sft"],  # RPO loss = DPO + SFT (Section 5 of the paper)
    loss_weights=[1.0, 0.005],  # η=0.005 SFT weight in Appendix E.1 of the paper
    beta=0.01,  # β in Appendix E.1 of the paper
    learning_rate=5e-7,  # learning rate in Appendix E.1 of the paper
    num_train_epochs=1,  # Appendix E.1 of the paper
)

Alineación de preferencias distribucionales de LLMs mediante transporte óptimo

📜 Artículo: https://huggingface.co/papers/2406.05882

El alineamiento mediante transporte óptimo (AOT) alinea los modelos de lenguaje de gran escala de forma distribucional penalizando las violaciones de la dominancia estocástica entre las distribuciones de muestras positivas y negativas, logrando un rendimiento líder en los benchmarks de alineamiento. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="aot",
    beta=0.01,  # from the caption of Figure 2
)

o, para la versión no emparejada:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="aot_unpaired",
    beta=0.01,  # from the caption of Figure 2
)

No hay ningún hiperparámetro adicional en el artículo.

Descubrir algoritmos de optimización de preferencias con y para modelos de lenguaje de gran escala

📜 Artículo: https://huggingface.co/papers/2406.08414

Un método impulsado por un LLM descubre de forma automática algoritmos de optimización de preferencias con alto rendimiento, lo que da lugar a un nuevo algoritmo llamado DiscoPOP que combina pérdidas logísticas y exponenciales. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="discopop",
    per_device_train_batch_size=64,  # batch size in Section B.1 of the paper
    learning_rate=5e-7,  # learning rate in Section B.1 of the paper
    beta=0.05,  # β in Section B.1 of the paper,
    discopop_tau=0.05  # τ in Section E of the paper
)

WPO: Mejora de RLHF con optimización de preferencias ponderadas

📜 Artículo: https://huggingface.co/papers/2406.11827

WPO repondera los pares de preferencia según sus probabilidades de política para reducir la brecha fuera de política en el entrenamiento de estilo DPO. La pérdida es: $$\mathcal{L}_{\text{WPO}} = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ \textcolor{red}{w(x, y_w) w(x, y_l)} \log p(y_w \succ y_l \mid x) \right]$$

donde el peso $w(x, y)$ se define como: $$w(x, y) = \exp\left(\frac{1}{|y|}\sum_{t=1}^{|y|} \log \frac{\pi_\theta(y_t \mid x, y_{<t})}{\sum_{v \in \mathcal{V}} \pi_\theta(v \mid x, y_{<t})^2}\right)$$

Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid",  # DPO loss used in the paper
    beta=0.01,  # Section 4 of the paper
    use_weighting=True,
)

Optimización de preferencias ancladas y revisiones contrastivas: abordando la especificación insuficiente en la alineación

📜 Artículo: https://huggingface.co/papers/2408.06266

CLAIR y APO mejoran el alineamiento de los LLM mediante pares de preferencia más contrastivos y objetivos de alineamiento controlados, mejorando el rendimiento del modelo hasta acercarse al de GPT4-turbo. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="apo_zero",  # Section 4 of the paper
    per_device_train_batch_size=64,  # batch size in Section B.1 of the paper
    learning_rate=2e-7,  # learning rate in Section 5.2 of the paper
    beta=0.1,  # β in Section 5.2 of the paper,
)

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="apo_down",  # Section 4 of the paper
    per_device_train_batch_size=64,  # batch size in Section B.1 of the paper
    learning_rate=2e-7,  # learning rate in Section 5.2 of the paper
    beta=0.1,  # β in Section 5.2 of the paper,
)

Estos parámetros solo aparecen en la versión publicada

Desensibilización de la longitud en la optimización de preferencias directas

📜 Artículo: https://huggingface.co/papers/2409.06411

Muestra que el DPO estándar es inherentemente sensible a la longitud, lo que a menudo impulsa a los modelos hacia generaciones excesivamente largas o verbosas. El paper propone LD-DPO, que modifica la agregación de log-prob de la secuencia dividiendo la respuesta más larga en un prefijo compartido (hasta la longitud de la respuesta más corta) y una cola excesiva, y luego atenuando la cola con un factor $\alpha \in [0,1]$: $$\log \pi_\theta(y_{\text{long}}|x) = \log \pi_\theta(y_{1:l_p}|x) + \alpha \cdot \log \pi_\theta(y_{l_p+1:l}|x, y_{1:l_p}), \quad l_p=\min(|y_w|,|y_l|).$$

Configuración $\alpha=1$ recupera el DPO estándar; un valor menor de $\alpha$ reduce la verbosidad mientras preserva la calidad de las preferencias. El valor óptimo de $\alpha$ depende de la familia de modelos y de si se está entrenando un modelo base o un modelo instruct, pero el paper sugiere $\alpha=0.5$ como un punto de partida predeterminado sólido.

from trl import DPOConfig

training_args = DPOConfig(
    ld_alpha=0.5,
)

Mejora de la capacidad de razonamiento de los grandes modelos de lenguaje multimodales mediante optimización de preferencias mixtas

📜 Artículo: https://huggingface.co/papers/2411.10442

Introduce la Optimización de Preferencias Mixtas (MPO) para mejorar el razonamiento multimodal en MLLMs, abordando el cambio de distribución y la debilidad del Chain-of-Thought (CoT) después del pre-entrenamiento estándar y el SFT. El artículo contribuye con (1) MMPR, un pipeline automatizado para datos de preferencia multimodal de alta calidad, y (2) MPO, un objetivo de preferencia combinado (pareado + estilo BCO + SFT) que mejora el CoT. InternVL2-8B-MPO alcanza 67.0 en MathVista (+8.7 sobre InternVL2-8B), comparable al InternVL2-76B, que es 10 veces más grande. Se utiliza en TRL mediante DPOConfig con pérdida compuesta. Para reproducir la configuración del artículo, use esta configuración:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type=["sigmoid", "bco_pair", "sft"],  # ℒ = w_p·ℒ_p + w_q·ℒ_q + w_g·ℒ_g (Section 3.2 of the paper)
    loss_weights=[0.8, 0.2, 1.0],  # w_p, w_q, w_g loss weights (Section 7 of the paper)
    learning_rate=5e-6,  # learning rate (Section 7 of the paper)
)

TÜLU 3: Impulsando los límites del post-entrenamiento de modelos de lenguaje abiertos

📜 Artículo: https://huggingface.co/papers/2411.15124

La pérdida sigmoid normalizada por longitud aborda el sesgo de longitud en DPO dividiendo las puntuaciones de log-ratio elegidas y rechazadas por sus respectivas longitudes de finalización antes de calcular la pérdida de Bradley-Terry. Esta normalización por token se introdujo en SimPO (Apéndice I «DPO w/ LN» ablation) como una recompensa de log-probabilidad promedio para un escenario sin referencia, y luego se adoptó para el DPO estándar basado en un modelo de referencia en recetas de post-entrenamiento como Tülu 3 (Sección 4.3). La pérdida es: $$\mathcal{L}_{\text{sigmoid\_norm}} = -\log\sigma\!\left(\beta \left({\color{red}\frac{1}{|y_w|}}\log\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - {\color{red}\frac{1}{|y_l|}}\log\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\right)\right),$$ que se puede configurar con:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid_norm",
)

Alineamiento sin sesgo para modelos de lenguaje grandes con preferencias ruidosas

📜 Artículo: https://huggingface.co/papers/2607.03248

Este artículo modela el ruido de preferencia como etiquetas invertidas con probabilidad $\varepsilon$ e invierte esta transición, de modo que la política entrenada con preferencias ruidosas tenga el mismo óptimo que con preferencias limpias. TRL implementa la forma normalizada de la pérdida resultante de Unbiased DPO (UDPO), llamada α-UDPO en el artículo: $$\mathcal{L}_{\text{UDPO}} = -\alpha \log \frac{e^{z} + a}{e^{z} + 1}, \quad z = \beta \left( \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)} \right), \quad a = \frac{\varepsilon}{1 - \varepsilon}, \quad \alpha = \frac{1 + \sqrt{a}}{1 - \sqrt{a}},$$

que es la pérdida DPO para $a = 0$. La constante $\alpha$ mantiene la magnitud máxima del gradiente en 1, al igual que en DPO. A diferencia de Robust DPO, el papel demuestra que el óptimo permanece sin sesgo cuando la probabilidad real de inversión es menor que la supuesta $\varepsilon$ (Corolario 4.7), por lo que $\varepsilon$ no tiene que estimarse con exactitud. En TRL, $\varepsilon$ se establece con label_smoothing. Para usar $a = 0.8$, el valor que el papel recomienda a los profesionales:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="udpo",
    label_smoothing=4 / 9,  # flip probability ε, for a = ε / (1 - ε) = 0.8 as recommended in Appendix B.1 of the paper
    beta=0.1,  # 0.1 for HH and UltraFeedback, 0.5 for TL;DR (Appendix B.1 of the paper)
    learning_rate=5e-6,  # 5e-6 for Llama-3.2-3B and Qwen3-1.7B, 1e-6 for 8B models (Appendix B.1 of the paper)
    num_train_epochs=3,  # Appendix B.1 of the paper
    per_device_train_batch_size=16,  # total batch size of 128 on 8 GPUs (Appendix B.1 of the paper)
    max_grad_norm=10.0,  # Appendix B.1 of the paper
    warmup_ratio=0.1,  # Appendix B.1 of the paper
)

Optimización de Kahneman–Tversky

Artículos relacionados con KTOTrainer

KTO: Alineación de modelos como optimización prospectiva

📜 Artículo: https://huggingface.co/papers/2402.01306

KTO deriva un objetivo de alineación a partir de la teoría de la prospectiva y aprende directamente de la retroalimentación humana binaria (me gusta/no me gusta), igualando o superando a los métodos de estilo DPO, al tiempo que maneja bien las señales desequilibradas o ruidosas. Para reproducir la configuración del artículo, puede utilizar la configuración predeterminada de KTOTrainer:

from trl import KTOConfig, KTOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)

trainer = KTOTrainer(
    model=model,
    processing_class=tokenizer,
    args=KTOConfig(),
    train_dataset=...,
)
trainer.train()

Ajuste fino supervisado

Artículos relacionados con SFTTrainer

TailSFT: El ajuste fino filtrado mejora el rendimiento del posentrenamiento

📜 Artículo: https://huggingface.co/papers/2608.25756

TailSFT preserva la cobertura de respuestas para el aprendizaje por refuerzo posterior al filtrar las secuencias cuya pérdida normalizada por longitud ha mejorado más en relación con la política inicial. El ejemplo tail_sft_gsm8k implementa el filtrado distribuido de lotes de selección del artículo mediante la subclase de SFTTrainer. Registra la pérdida de la política inicial de cada secuencia antes del entrenamiento y filtra los ejemplos de forma independiente en cada lote de selección.

python examples/tail_sft_gsm8k/tail_sft.py

EMA sin retardo: esquemas de promediación de iteraciones corregidos por sesgo

📜 Artículo: https://huggingface.co/papers/2508.00180

El promedio móvil exponencial corregido por sesgo (BEMA) mejora la estabilidad y la eficiencia del ajuste fino de modelos de lenguaje al reducir la estocasticidad y eliminar el sesgo. Para usar BEMA con SFT tal como se describe en el artículo, puedes utilizar BEMACallback:

from trl import BEMACallback, SFTTrainer

trainer = SFTTrainer(
    ...
    callbacks=[BEMACallback()],
)

Sobre la generalización del SFT: una perspectiva de aprendizaje por refuerzo con rectificación de recompensa

📜 Artículo: https://huggingface.co/papers/2508.05629

El ajuste fino dinámico (DFT) mejora la generalización de los modelos de lenguaje de gran escala (LLM) mediante el reescalado dinámico de gradientes, superando al ajuste fino supervisado estándar (SFT) y mostrando resultados competitivos en el aprendizaje por refuerzo sin conexión. $$\mathcal{L}_{\text{DFT}}(\theta) = \mathbb{E}_{(x,y) \sim \mathcal{D}} \left[ - \sum_{t=1}^{|y|} \textcolor{red}{\text{sg}\big(\pi_\theta(y_t \mid y_{<t}, x)\big)} \; \log \pi_\theta(y_t \mid y_{<t}, x) \right]$$

donde $\text{sg}(\cdot)$ es el operador stop-gradient. Para usar DFT con SFT tal como se describe en el artículo, puedes usar el argumento loss_type="dft" :

from trl import SFTConfig

training_args = SFTConfig(
    loss_type="dft",
    ...
)

Para coincidir de cerca con la configuración del artículo, puede utilizar la siguiente configuración (ver Sec. 4.1). Los autores también mencionan que los hiperparámetros no son muy sensibles (Sec. 4.3):

SFTConfig(
    loss_type="dft",
    learning_rate=5e-5,
    max_length=2048,
    # Target batch size 256; achieved via per-device batch 8 * grad accumulation 32
    per_device_train_batch_size=8,
    gradient_accumulation_steps=32,
)

Menos truncamientos mejoran el modelado de lenguaje

📜 Artículo: https://huggingface.co/papers/2404.10830

El artículo demuestra que el preprocesamiento estándar de concatenar y luego dividir (packing_strategy="wrapped") utilizado para el entrenamiento de LLM provoca que muchos documentos se trunquen de forma arbitraria, lo cual perjudica el aprendizaje. Propone empaquetar fragmentos de documentos en ventanas de contexto utilizando un algoritmo de empaquetado de cajas Best-Fit Decreasing, reduciendo drásticamente el truncamiento mientras mantiene una alta utilización de tokens y mejora el rendimiento del modelo. TRL implementa esto como la estrategia de empaquetado "bfd_split" en SFTConfig. Para más detalles sobre el empaquetado, consulte la documentación de SFT.

from trl import SFTConfig

training_args = SFTConfig(
    packing=True,
    packing_strategy="bfd_split",
    max_length=4096,
)

Explorando los límites del aprendizaje por transferencia con un transformador unificado de texto a texto

📜 Artículo: https://huggingface.co/papers/1910.10683

El artículo de T5 propone un marco unificado de texto a texto para el aprendizaje por transferencia e introduce sequence packing (sección 3.5.2): agrupar múltiples secuencias cortas en bloques de longitud fija para reducir el relleno y mejorar la eficiencia del entrenamiento. El empaquetado se admite en TRL a través de SFTConfig con SFTTrainer. Para habilitar el empaquetado con TRL, use esta configuración:

from trl import SFTConfig

training_args = SFTConfig(
    packing=True,  # enable sequence packing (Section 3.5.2 of the paper)
    max_length=512,  # packed sequence length (Section 3.5.2 of the paper)
)

Reparametrización de modelos de difusión uniformes: el desruidador Leave-One-Out

📜 Artículo: https://huggingface.co/papers/2605.22765

En los modelos de difusión discreta uniforme, la entropía cruzada de reemplazo habitual no aprende el desruidor simple$\mathbb{E}[X_0 \mid X_t]$ sino la posterior leave-one-out (LOO), que predice cada token sin utilizar su propio valor corrupto. El paper deriva conversiones exactas entre el desruidor, la posterior LOO y el score, por lo que una red puede entrenarse como cualquiera de estas parametrizaciones con la misma entropía cruzada. Dadas las logits$f_\theta$ cuyo softmax parametriza la posterior LOO, el desruidor utilizado en la pérdida es $$d_\theta(x_t, t)^\ell = \mathrm{softmax}\!\left( f_\theta(x_t, t)^\ell + \log\!\left(1 + \frac{K\,\alpha_t}{1 - \alpha_t}\, x_t^\ell\right) \right),$$

es decir, una corrección aditiva en el logit del token observado, donde$K$ es el tamaño del vocabulario y$\alpha_t$ la probabilidad de que el proceso de difusión hacia adelante conserve el token limpio. El informe indica que la parametrización LOO mejora de forma consistente la generación. El ejemplo de SFT con difusión por bloques examples/sft_diffusion_gemma/sft_diffusion_gemma.py expone ambas parametrizaciones mediante --model_prediction_type (mean para el desruidador simple, que coincide con el punto de control publicado, o mean_loo para la posterior LOO):

torchrun --nproc_per_node 8 examples/sft_diffusion_gemma/sft_diffusion_gemma.py \
    --deepspeed examples/deepspeed_configs/zero3.json \
    --use_peft \
    --activation_checkpointing \
    --model_prediction_type mean_loo \
    --output_dir diffusiongemma-26B-A4B-it-gsm8k-lora

Reducción del recálculo de activaciones en modelos Transformer de gran escala

📜 Artículo: https://huggingface.co/papers/2205.05198

El checkpointing completo de activaciones recalcula cada operación en una región con checkpoint durante la propagación hacia atrás, incluida la atención, aunque solo unas pocas operaciones (entre ellas la atención) representan la mayor parte del costo de recálculo en relación con la memoria que costaría conservarlas. El recálculo selectivo de activaciones del artículo realiza checkpoint solo de esas operaciones costosas en lugar de toda la región. TRL implementa esto como checkpointing selectivo de activaciones (SAC) para SFTTrainer, guardando la salida de la atención durante la propagación hacia adelante para que la propagación hacia atrás no tenga que recalcularla:

from trl import SFTConfig

training_args = SFTConfig(
    activation_checkpointing=True,
    activation_checkpointing_kwargs={"selective": True},
)

Ajuste fino eficiente en parámetros (PEFT)

Para obtener detalles generales sobre el uso de PEFT con TRL, consulte la guía de Integración de PEFT.

LoRA: Adaptación de bajo rango de modelos de lenguaje grandes

📜 Artículo: https://huggingface.co/papers/2106.09685

La Adaptación de Bajo Rango (LoRA) reduce el número de parámetros entrenables y el uso de memoria de GPU en modelos preentrenados a gran escala, manteniendo o mejorando el rendimiento en tareas posteriores. TRL integra LoRA a través de la biblioteca PEFT y se puede habilitar fácilmente en cualquier entrenador de TRL pasando un LoraConfig al argumento peft_config. A continuación se muestra un ejemplo de uso de LoRA con SFTTrainer:

from trl import SFTTrainer
from peft import LoraConfig

trainer = SFTTrainer(
    ...,
    peft_config=LoraConfig(),
)

DoRA: Adaptación de bajo rango con descomposición de pesos

📜 Artículo: https://huggingface.co/papers/2402.09353

La Adaptación de Bajo Rango con Descomposición de Pesos (DoRA) puede mejorar el rendimiento de LoRA, especialmente en rangos bajos. DoRA descompone los pesos preentrenados en dos componentes: magnitud y dirección. La dirección se maneja con LoRA normal, y la magnitud son parámetros aprendibles. TRL integra DoRA a través de la biblioteca PEFT y se puede habilitar fácilmente estableciendo use_dora=True en LoraConfig.

from peft import LoraConfig

config = LoraConfig(use_dora=True, ...)

Reinforce Leave-One-Out

Artículos relacionados con RLOOTrainer

Volver a lo básico: Revisando la optimización de estilo REINFORCE para el aprendizaje a partir de retroalimentación humana en LLM

📜 Artículo: https://huggingface.co/papers/2402.14740

RLOO es una variante de REINFORCE que reduce la varianza mediante el uso de líneas base de tipo leave-one-out. Calcula las recompensas comparando cada muestra con la media de todas las demás muestras del lote, lo que proporciona gradientes más estables que REINFORCE estándar. Para reproducir la configuración del artículo, use esta configuración:

from trl import RLOOConfig

training_args = RLOOConfig(
    per_device_train_batch_size=512,  # section C Training Detail of the paper
    steps_per_generation=2,  # section C Training Detail of the paper
    beta=0.03,  # section C Training Detail of the paper
    num_generations=2,  # experiments of paper different num_generations={2,4}
    learning_rate=1e-6,  # section C Training Detail of the paper
)

REINFORCE++: un enfoque simple y eficiente para alinear modelos de lenguaje de gran escala

📜 Artículo: https://huggingface.co/papers/2501.03262

REINFORCE++ es una variante mejorada del algoritmo clásico REINFORCE que incorpora técnicas clave de optimización de PPO, eliminando la necesidad de una red crítica. Logra simplicidad, mayor estabilidad en el entrenamiento y una reducción de la sobrecarga computacional mediante la normalización global de la ventaja en todo el lote. Para aproximar la configuración del artículo con el RLOOTrainer, use esta configuración:

from trl import RLOOConfig

training_args = RLOOConfig(
    normalize_advantages=True,  # global advantage normalization, core of REINFORCE++
)

Optimización de preferencias de razón de probabilidades

Artículos relacionados con experimental.orpo.ORPOTrainer

ORPO: Optimización de preferencias monolítica sin modelo de referencia

📜 Artículo: https://huggingface.co/papers/2403.07691

La introducción de un algoritmo monolítico de optimización de preferencias basado en la razón de probabilidades (ORPO) que no requiere un modelo de referencia mejora la alineación de preferencias durante el ajuste fino supervisado, superando a modelos más grandes en evaluaciones clave. Para reproducir la configuración del artículo, utiliza esta configuración:

from trl.experimental.orpo import ORPOConfig

training_args = ORPOConfig(
    beta=0.1,  # λ odds ratio loss weight (Table 7 of the paper, Mistral-ORPO-β)
    learning_rate=5e-6,  # learning rate (Appendix C of the paper)
    lr_scheduler_type="inverse_sqrt",  # scheduler (Appendix C of the paper)
    num_train_epochs=5,  # Appendix C of the paper
    warmup_steps=200,  # warm-up steps (Appendix C of the paper)
    per_device_train_batch_size=8,  # batch size (Appendix C of the paper)
)

Optimización de Preferencias Contrastivas

Artículos relacionados con experimental.cpo.CPOTrainer

Optimización de Preferencias Contrastivas: Llevando al límite el rendimiento de los LLM en la traducción automática

📜 Artículo: https://huggingface.co/papers/2401.08417

Introduce la Optimización de Preferencias Contrastivas (CPO), un método basado en preferencias para la traducción automática que entrena a los modelos para evitar traducciones adecuadas pero imperfectas, en lugar de imitar las referencias como en SFT. El paper analiza las limitaciones de SFT en MT (incluidos los problemas de calidad de las referencias) y muestra que aplicar CPO a ALMA con solo 22K oraciones paralelas produce ALMA-R, que iguala o supera a los ganadores de la competición WMT y a GPT-4 en WMT’21–WMT’23. Se utiliza en TRL a través de experimental.cpo.CPOTrainer. Para reproducir la configuración del paper, use esta configuración:

from trl.experimental.cpo import CPOConfig

training_args = CPOConfig(
    loss_type="sigmoid",  # preference learning loss (Section 3 of the paper)
    cpo_alpha=1.0,  # NLL regularizer weight (Section 3 of the paper)
    beta=0.1,  # β temperature (Section 4.2 of the paper)
    learning_rate=1e-4,  # learning rate (official code)
    lr_scheduler_type="inverse_sqrt",  # scheduler (official code)
    num_train_epochs=1,  # Section 4.2 of the paper
    warmup_ratio=0.01,  # warm-up ratio (Section 4.2 of the paper)
    max_length=512,  # max sequence length (Section 4.2 of the paper)
)

SimPO: Optimización de preferencias simple con una recompensa sin referencia

📜 Artículo: https://huggingface.co/papers/2405.14734

SimPO es un enfoque de optimización de preferencias más simple pero más efectivo que utiliza la probabilidad logarítmica media de una secuencia como recompensa implícita, eliminando la necesidad de un modelo de referencia. Introduce un margen de recompensa objetivo en el objetivo de Bradley-Terry para fomentar un margen mayor entre las respuestas ganadoras y perdedoras. Para reproducir la configuración del artículo, use esta configuración:

from trl.experimental.cpo import CPOConfig

training_args = CPOConfig(
    loss_type="simpo",  # SimPO loss (Section 3 of the paper)
    cpo_alpha=0.0,  # no BC regularizer for SimPO
    beta=2.5,  # β in Appendix B of the paper
    simpo_gamma=1.375,  # γ target reward margin, from γ/β=0.55 in Appendix B of the paper
    learning_rate=1e-6,  # learning rate in Appendix B of the paper
    num_train_epochs=1,  # Appendix B of the paper
)

AlphaPO — La forma de la recompensa importa para la alineación de LLM

📜 Artículo: https://huggingface.co/papers/2501.03884

AlphaPO es un nuevo método de Direct Alignment Algorithms (DAAs) que aprovecha un parámetro alfa para ayudar a cambiar la forma de la función de recompensa más allá de la recompensa log estándar. AlphaPO ayuda a mantener un control detallado sobre el desplazamiento de la verosimilitud y la sobreoptimización. Para reproducir la configuración del artículo, use esta configuración:

from trl.experimental.cpo import CPOConfig

# Mistral-Instruct from Table 3 of the paper
training_args = CPOConfig(
    loss_type="alphapo",
    alpha=0.25,
    beta=2.5,
    simpo_gamma=0.1,
    learning_rate=7e-7,
    ...
)

Triple Preference Optimization

Triple Preference Optimization: Lograr un mejor alineamiento mediante una optimización de un solo paso

📜 Artículo: https://huggingface.co/papers/2405.16681

Introduce la Optimización de Preferencias Triples (TPO), un método de aprendizaje por preferencias que alinea un LLM con tres respuestas por prompt: una finalización de referencia (reference), una finalización preferida (chosen) y una finalización no preferida (rejected), en un solo paso de optimización. TPO combina un objetivo contrastivo en el par (chosen, rejected) con un término de NLL supervisado en la respuesta de referencia, eliminando la necesidad de una etapa de SFT separada y del modelo de referencia utilizado en DPO. TRL incluyó una implementación como TPOTrainer hasta la v1.16; ya no forma parte de la biblioteca y sigue disponible en el historial de git.

Aprendizaje de Nash a partir de retroalimentación humana

Aprendizaje de Nash a partir de retroalimentación humana

📜 Artículo: https://huggingface.co/papers/2312.00886

Introduce Nash-MD, una alternativa al RLHF estándar que aprende un modelo de preferencias condicionado a dos entradas y encuentra una política en el equilibrio de Nash. En lugar de optimizar frente a un modelo de recompensa, Nash-MD genera políticas que de forma consistente producen respuestas preferidas sobre las de cualquier política competidora. El algoritmo se basa en principios de descenso por espejo. TRL incluyó una implementación como NashMDTrainer hasta la v1.13; ya no forma parte de la biblioteca y sigue disponible en el historial de git.

Modelado de recompensas

Artículos relacionados con RewardTrainer

¿Ayudar o seguir la manada? Los conjuntos de modelos de recompensa mitigan, pero no eliminan, el hackeo de recompensas

📜 Artículo: https://huggingface.co/papers/2312.09244

Este artículo propuso una función de pérdida auxiliar diseñada para aprender directamente un modelo de recompensa centrado. Esta pérdida auxiliar minimiza la suma de los cuadrados de las recompensas, lo que anima al modelo a producir de forma natural salidas con media cero y, por lo tanto, resuelve el problema de la indeterminación. $$\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \textcolor{red}{- \eta \cdot (r_\theta(x, y^+) + r_\theta(x, y^-))^2} \right].$$

Para usar esta pérdida auxiliar con RewardTrainer, puede utilizar el argumento center_rewards_coefficient en RewardConfig de la siguiente manera:

from trl import RewardConfig

training_args = RewardConfig(
    center_rewards_coefficient=0.01,  # η in the paper
    ...
)

Llama 2: Modelos de fundación abiertos y modelos de chat ajustados

📜 Artículo: https://huggingface.co/papers/2307.09288

En este artículo, los autores proponen aprovechar que sus calificaciones de preferencia se descomponen en una escala de cuatro puntos (p. ej., significativamente mejor) para proporcionar un feedback más informativo al modelo de recompensa. Esto se logra añadiendo un margen a la función de pérdida, lo que anima al modelo de recompensa a asignar mayores diferencias en las puntuaciones para pares con calificaciones de preferencia más altas. $$\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-,\textcolor{red}{m}) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-) \textcolor{red}{- m}) \right].$$

Puede añadir un margen a la pérdida añadiendo una columna margin al conjunto de datos. El siguiente ejemplo muestra cómo configurar la configuración “Margin Small” del artículo.

def add_margin(example):
    preference_to_margin = {
        "significantly better": 1.0,
        "better": 2.0/3.0,
        "slightly better": 1.0/3.0,
        "negligibly better / unsure": 0.0,
    }
    return {"margin": preference_to_margin[example["preference_label"]]}

dataset = dataset.map(add_margin)

Optimización directa de preferencias en línea

Artículos relacionados con experimental.online_dpo.OnlineDPOTrainer

Alineación directa de modelos de lenguaje a partir de comentarios de IA en línea

📜 Artículo: https://huggingface.co/papers/2402.04792

Online DPO mejora los métodos de alineación directa a partir de preferencias al proporcionar retroalimentación en tiempo real desde un modelo, superando tanto a los métodos DPO como a los de PPO.

Para usar Online DPO, puedes utilizar el experimental.online_dpo.OnlineDPOTrainer.

Optimización de preferencias exploratoria: aprovechamiento de la aproximación implícita de Q* para un RLHF eficiente en muestras

📜 Artículo: https://huggingface.co/papers/2405.21046

XPO amplifica el objetivo de DPO con un bonus de exploración novedoso y fundamentado, lo que permite al algoritmo explorar fuera del soporte del modelo inicial y de los datos de retroalimentación humana. Se trata de un cambio de una línea en DPO en línea que es demostrablemente eficiente en muestras y converge a una política de modelo de lenguaje casi óptima. TRL lanzó una implementación como XPOTrainer hasta la v1.13; ya no forma parte de la biblioteca y sigue disponible en el historial de git.

Destilación

Artículos relacionados con el entrenamiento de un modelo estudiante con la ayuda de un modelo maestro.

Destilación de modelos de lenguaje en política: aprender de los errores auto-generados

📜 Artículo: https://huggingface.co/papers/2306.13649

Introduce el Generalized Knowledge Distillation (GKD), que aborda el desajuste de distribución en el KD para modelos auto-regresivos entrenando al estudiante con sus propias salidas generadas y retroalimentación del maestro, en lugar de un conjunto fijo de secuencias. GKD admite funciones de pérdida flexibles (p. ej., más allá de KL cuando el estudiante no puede igualar al maestro) y se integra con el ajuste fino de RL (RLHF). El informe de resultados en resumen, traducción, razonamiento aritmético y ajuste de instrucciones. Se utiliza en TRL a través de experimental.gkd.GKDTrainer, que expone la mezcla on/off-policy del artículo (lmbda). DistillationTrainer implementa el mismo objetivo de JSD generalizado para el caso siempre on-policy. Para reproducir la configuración del artículo, use esta configuración:

from trl.experimental.gkd import GKDConfig

# XSum summarization task (Table A.1 of the paper)
training_args = GKDConfig(
    lmbda=0.5,  # λ student data fraction (Section 3 of the paper)
    beta=0.5,  # β Generalized JSD interpolation, 0=KL, 1=reverse KL (Section 3 of the paper)
    temperature=1.0,  # student training temperature (Appendix A of the paper)
    max_steps=40000,  # training steps (Table A.1 of the paper)
    learning_rate=3e-4,  # learning rate (Table A.1 of the paper)
    per_device_train_batch_size=32,  # batch size (Table A.1 of the paper)
    warmup_steps=2000,  # warm-up steps (Table A.1 of the paper)
    max_new_tokens=64,  # max output tokens (Table A.1 of the paper)
)

MOPD: Destilación en política con múltiples maestros para la integración de capacidades en el entrenamiento posterior de LLM

📜 Artículo: https://huggingface.co/papers/2606.30406

Estructura el post-entrenamiento en tres etapas: SFT general, entrenamiento RL independiente por dominio de un experto por dominio (p. ej., RL de respuesta verificable para matemáticas, RL de agente en sandbox para ingeniería de software) y una etapa final de MOPD que fusiona los expertos de dominio congelados en un único estudiante unificado. En esa etapa final, el estudiante genera una trayectoria por prompt, cada trayectoria se envía a su correspondiente maestro de dominio (nunca se promedia ni se ensambles entre maestros) y el estudiante se actualiza minimizando la KL inversa por token frente a la distribución de ese único maestro a lo largo de la trayectoria. Se utiliza en TRL a través de experimental.async_distillation.AsyncDistillationTrainer, que implementa esta tercera etapa de fusión: pasar más de una entrada en teacher_server_urls habilita MOPD, con la columna teacher_id de cada fila seleccionando qué maestro (ya entrenado) la puntúa. Usa beta=1.0 para coincidir con el objetivo de KL inversa del paper.

Sobre el sesgo de posición en la destilación de política

📜 Artículo: https://huggingface.co/papers/2606.22600

Introduce Importance-Weighted On-Policy Distillation (IW-OPD), que aborda el sesgo de posición en OPD mediante la reponderación de las actualizaciones de destilación de tokens muestreados según la discrepancia acumulada del prefijo entre el maestro y el estudiante. Los tokens iniciales conservan pesos mayores, mientras que los tokens posteriores a un alto desplazamiento se ponderan a la baja. Se utiliza en TRL a través de experimental.iw_opd.IWOPDTrainer con distillation_objective="iw_opd".

El artículo optimiza IW-OPD con una configuración de gradiente de política recortado (verl) y despliegues de vLLM. IWOPDTrainer expone las siguientes configuraciones de destilación y despliegue correspondientes; las configuraciones de optimización de política del artículo, como el rango de recorte 0.2, la constante de doble recorte 3.0, las épocas internas de PPO, el coeficiente de entropía, la penalización de recompensa KL, la KL auxiliar y la corrección de importancia del despliegue, no son parámetros de IWOPDConfig.

from trl.experimental.iw_opd import IWOPDConfig

# Table 6 and Algorithm 1 of the paper, mapped to IWOPDConfig where available.
training_args = IWOPDConfig(
    distillation_objective="iw_opd",
    iw_opd_gamma=0.5,  # γ amplification, Algorithm 1 and Appendix C.3
    lmbda=1.0,  # fully on-policy rollouts
    learning_rate=1e-5,  # Table 6
    per_device_train_batch_size=1,  # Table 6 uses PPO micro-batch size 1 per GPU
    gradient_accumulation_steps=32,  # with 32 GPUs, this gives the paper's 1024-prompt batch
    num_generations=1,  # Table 6 rollout samples per prompt
    temperature=1.0,  # Table 6 training decoding temperature
    top_p=1.0,  # Table 6 training decoding top-p
    max_prompt_length=2048,  # Table 6
    max_completion_length=16384,  # Table 6
    warmup_ratio=0.0,  # Table 6
    use_vllm=True,  # Table 6 uses vLLM rollouts
    vllm_sync_frequency=1,  # refresh rollout policy after each update
    save_steps=10,  # Table 6 checkpoint frequency
    eval_steps=10,  # Table 6 validation frequency
)

Destilación en la política

📰 Blog: https://thinkingmachines.ai/blog/on-policy-distillation/

On-Policy Distillation implica que un modelo estudiante genere rollouts para cada lote de datos de entrenamiento. A continuación, obtenemos las distribuciones de probabilidad para cada token de los rollouts tanto del modelo estudiante como del modelo maestro. El modelo estudiante se optimiza entonces para minimizar la divergencia de Kullback-Leibler (KL) negativa entre sus propias distribuciones de tokens y las del modelo maestro.

Se ha demostrado que On-Policy Distillation supera a SFT y GRPO, y puede utilizarse para restaurar las capacidades de generalización perdidas durante SFT.

Además, la destilación on-policy es más eficiente en términos de cómputo y tiene menos tendencia a sobreajustarse cuando se entrena con datos limitados.

Para entrenar un modelo con destilación on-policy usando TRL, puedes usar la siguiente configuración, con DistillationTrainer y DistillationConfig:

from trl import DistillationConfig

training_args = DistillationConfig(
    beta=1.0,  # to ensure reverse-kl as the loss function
    teacher_model_name_or_path="teacher-model",  # specify the teacher model
)

Alternativamente, puede usar experimental.gkd.GKDTrainer y experimental.gkd.GKDConfig:

from trl.experimental.gkd import GKDConfig

training_args = GKDConfig(
    lmbda=1.0,  # student produces rollouts for all batches
    beta=1.0,  # to ensure reverse-kl as the loss function
    teacher_model_name_or_path="teacher-model",  # specify the teacher model
)

También puedes usar experimental.gold.GOLDTrainer para la destilación on-policy; consulta Unlocking On-Policy Distillation for Any Model Family.

Desbloqueando la destilación en política para cualquier familia de modelos

🌐 Proyecto: https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation

Introduce General Online Logit Distillation (GOLD), que extiende la destilación on-policy a pares estudiante/profesor con tokenizadores y familias de modelos diferentes. GOLD alinea los fragmentos de texto entre tokenizadores y puede aplicar Universal Logit Distillation (ULD) para que no se descarten los tokens de finalización. Se utiliza en TRL a través de experimental.gold.GOLDTrainer.

from trl.experimental.gold import GOLDConfig

training_args = GOLDConfig(
    lmbda=1.0,  # student produces rollouts for all batches
    beta=1.0,  # to ensure reverse-kl as the loss function
    use_uld_loss=True,  # Universal Logit Distillation for cross-tokenizer pairs
)

X-Token: Destilación de conocimiento entre tokenizadores guiada por proyección

📜 Artículo: https://huggingface.co/papers/2605.21699

X-Token extiende el marco de destilación GOLD a pares estudiante-docente que no comparten un tokenizador. Es un método off-policy (lmbda=0): el conjunto de datos proporciona el texto de la finalización, tanto el estudiante como el docente ejecutan pases hacia adelante sobre ese texto, y la pérdida de KD entre tokenizadores se calcula entre sus logits. No se necesitan despliegues del estudiante on-policy. Una matriz de proyección dispersa precalculada W ∈ ℝ^{V_s × V_t} asigna cada token del estudiante a los tokens del docente a los que más plausiblemente corresponde, proyectando la distribución del estudiante al espacio de vocabulario del docente para que ambos puedan compararse directamente. Se utiliza en TRL mediante experimental.gold.GOLDTrainer con xtoken_loss_type="p_kl" o "h_kl".

Se proporcionan dos formulaciones de pérdida:

Como en la implementación de referencia, H-KL recorta las log-probabilidades del vocabulario completo al conjunto común y P-KL promedia las log-probabilidades del maestro sobre cada tramo sin renormalizar, por lo que el término KD puede ser negativo. CE y KD utilizan recuentos separados de tokens y tramos alineados sobre cada ventana de acumulación. El equilibrio dinámico CE/KD y la selección top-k de P-KL se calculan por microbatch.

Esta implementación utiliza una matriz de proyección congelada. El artículo también aprende conjuntamente la matriz para P-KL; esa variante no está implementada aquí.

Primero, construya la matriz de proyección con los scripts de preparación en examples/xtoken/. El paso 1 vuelve a tokenizar el vocabulario del estudiante con el tokenizador del maestro; la opción opcional --runtime-top-k ordena y recorta la matriz de una sola vez (equivalente a ejecutar sort_and_cut_projection_matrix.py después):

python examples/xtoken/build_projection_matrix.py \
    --student-model meta-llama/Llama-3.2-1B-Instruct \
    --teacher-model Qwen/Qwen3-4B \
    --runtime-top-k 4 \
    --output-dir cross_tokenizer_data

Luego, entrena con el script de ejemplo (off-policy, no se necesita vLLM):

python examples/xtoken/xtoken.py \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen3-4B \
    --dataset_name trl-lib/chatbot_arena_completions \
    --xtoken_loss_type p_kl \
    --xtoken_projection_matrix_path cross_tokenizer_data/projection_map_Llama-3.2_to_Qwen3_multitoken_top_32_double_special_top4.pt \
    --lmbda 0.0

o pasar la ruta a experimental.gold.GOLDConfig directamente:

from trl.experimental.gold import GOLDConfig

config = GOLDConfig(
    lmbda=0.0,  # "off-policy knowledge distillation"
    xtoken_temperature=1.0,  # "temperature τ=1.0"
    xtoken_dynamic_scaling=True,  # Eq. (7): stop-gradient CE/KD balance
    xtoken_loss_type="p_kl",
    xtoken_projection_matrix_path="cross_tokenizer_data/projection_map_Llama-3.2_to_Qwen3_multitoken_top_32_double_special_top4.pt",
    teacher_tokenizer_name_or_path="Qwen/Qwen3-4B",
)

Destilación de conocimiento de modelos de lenguaje grandes

📜 Artículo: https://huggingface.co/papers/2306.08543

MiniLLM es el primer método de destilación de conocimiento on-policy, que minimiza la KLD inversa a nivel de secuencia entre el modelo maestro y el modelo estudiante y se optimiza mediante aprendizaje por refuerzo.

Es una versión generalizada de On-Policy Distillation de Think Machine Lab, con la opción de añadir señales de destilación de un solo paso a nivel de distribución (como GKD cuando beta=1) y señales de KLD inversa para contexto largo.

TRL incluyó una implementación como MiniLLMTrainer hasta la v1.14; ya no forma parte de la biblioteca y sigue disponible en el historial de git.

Aprendizaje por refuerzo mediante autodestilación

📜 Artículo: https://huggingface.co/papers/2601.20802

La Optimización de Políticas mediante Auto-Distilación (SDPO) mejora el aprendizaje por refuerzo con recompensas verificables al convertir la retroalimentación textual rica (p. ej., errores de tiempo de ejecución, evaluaciones de un juez) en una señal de aprendizaje densa, sin necesidad de un maestro externo ni de un modelo de recompensa explícito. SDPO trata al modelo actual, condicionado por la retroalimentación, como un auto-maestro y destila sus predicciones del siguiente token informadas por la retroalimentación de vuelta en la política. Cabe destacar que SDPO también supera a las líneas base en entornos estándar de RLVR que solo devuelven retroalimentación escalar, al utilizar las ejecuciones exitosas como retroalimentación implícita para los intentos fallidos.

from trl.experimental.sdpo import SDPOConfig, SDPOTrainer

training_args = SDPOConfig(
    distillation_alpha=0.5,                # Jensen-Shannon divergence (recommended)
    distillation_mode="topk_logits",       # Explicitly select top-K logit distillation
    distillation_topk=100,                 # Required for top-K logit distillation
    distillation_is_clip=2.0,              # Importance sampling clipping
    distillation_weight=1.0,               # Convex weight: (1-w)*policy + w*distillation; 1.0 = pure distillation
    use_successful_as_teacher=True,        # Use successful rollouts as teacher
    teacher_model_kind="ema",              # Supported: "base", "live", "ema"
    teacher_update_rate=0.05,              # EMA update rate
    include_environment_feedback=True,     # required to use the dataset's privileged_context (defaults to False)
)

trainer = SDPOTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    reward_funcs=...,
    args=training_args,
    train_dataset=...,
)
trainer.train()

Columnas de datos esperadas:

• prompt
• privileged_context para retroalimentación opcional del entorno

Para más detalles, consulte la documentación del SDPO Trainer.

La auto-distilación permite el aprendizaje continuo

📜 Artículo: https://huggingface.co/papers/2601.19897

El ajuste fino con autodistilación (SDFT) realiza autodistilación en la política generando completados durante el entrenamiento y, a continuación, destilando una vista explícita del maestro condicionada sobre esos mismos completados de vuelta en el estudiante. El maestro se selecciona mediante teacher_model_kind: "base" (el estudiante inicial), "live" (el estudiante actual) o "ema" (un maestro con promedio exponencial). El prompt del maestro se compone internamente a partir del prompt del estudiante más el privileged_context del conjunto de datos.

from datasets import Dataset

from trl.experimental.sdft import SDFTConfig, SDFTTrainer

dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": "Solve 2+2."}]],
        "privileged_context": ["Example answer: 4."],
    }
)

training_args = SDFTConfig(
    distillation_alpha=0.5,
    distillation_mode="topk_logits",
    distillation_topk=5,
    max_completion_length=64,
)

trainer = SDFTTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

Columnas de datos esperadas:

• prompt
• privileged_context que contiene únicamente la información adicional exclusiva del maestro

Para más detalles, consulte la documentación del SDFT Trainer.

La autodistilación simple y vergonzosamente simple mejora la generación de código

📜 Artículo: https://huggingface.co/papers/2604.01193

Simple Self-Distillation (SSD) mejora la generación de código muestreando finalizaciones del modelo con una configuración de temperatura y truncamiento en tiempo de entrenamiento, y luego realizando un ajuste fino sobre esas muestras crudas y no verificadas con la pérdida de entropía cruzada estándar. No se necesita un modelo de recompensa, un verificador, un modelo maestro ni aprendizaje por refuerzo. SSD remodela las distribuciones de tokens de una forma dependiente del contexto: suprime las colas de distractores en las posiciones de “bloqueo” (donde la sintaxis deja poca ambigüedad) mientras preserva la diversidad en las posiciones de “bifurcación” (donde existen múltiples continuaciones válidas).

TRL incluyó una implementación como SSDTrainer hasta la v1.15; ya no forma parte de la biblioteca y sigue disponible en el historial de git.

Una solución para Softmax y Entropía cruzada

📜 Artículo: https://huggingface.co/papers/2610.31642

Identifica el colapso del softmax en predicciones de alta confianza y la cancelación cuando los logits del estudiante y del profesor casi coinciden. Las cabezas de log-probabilidad por bloques y de destilación de TRL utilizan una normalización que excluye el objetivo y diferencias de probabilidad en espacio logarítmico para preservar gradientes pequeños. Las correcciones numéricas se aplican automáticamente, incluidas las de KL directa, KL inversa y JSD generalizada en DistillationTrainer.

El apéndice B.4 de Entropy-preserving reinforcement learning identificó previamente el fallo de gradiente de política de alta confianza y propuso recalcular selectivamente los gradientes en FP64. Los kernels de TRL preservan estos gradientes utilizando fórmulas estables en FP32.

El problema de conversión de salida de FSDP2 discutido en el Apéndice B.1 se resuelve con Accelerate #4403. Las versiones anteriores de Accelerate necesitan una política de precisión mixta con output_dtype=None para conservar las salidas de los kernels en FP32.

El siguiente ejemplo mapea los hiperparámetros reportados en la Sección 7 al objetivo de KL hacia adelante de TRL, que comparte el gradiente del estudiante de la entropía cruzada de objetivos suaves. Ilustra la destilación de modelos de lenguaje en lugar de reproducir el experimento de aritmética modular del artículo. El artículo inicializa el estudiante con los pesos del maestro; esto debe manejarse al construir los modelos, de forma independiente de la configuración. Otros valores predeterminados del entrenador permanecen sin cambios.

from trl import DistillationConfig

training_args = DistillationConfig(
    beta=0.0,  # Forward KL has the same student gradient as soft-target cross-entropy.
    temperature=4.0,  # "distillation temperature T=4"
    learning_rate=2e-3,  # "eta=2 x 10^-3"
    lr_scheduler_type="constant",
    optim="adamw_torch",  # AdamW with zero weight decay has the same updates as Adam.
    weight_decay=0.0,  # "lambda=0"
    adam_epsilon=1e-8,  # "epsilon=10^-8"
    max_steps=2000,  # "2,000 steps of Adam"
)

Entrenamiento distribuido

ZeRO: Optimizaciones de memoria para el entrenamiento de modelos con billones de parámetros

📜 Artículo: https://huggingface.co/papers/1910.02054

ZeRO (Zero Redundancy Optimizer) elimina las redundancias de memoria en el entrenamiento paralelo de datos y de modelo al particionar los estados del optimizador, los gradientes y los parámetros entre dispositivos, manteniendo un volumen de comunicación bajo y una granularidad computacional alta. Esto permite el entrenamiento eficiente de modelos grandes que, de otro modo, no cabrían en la memoria de la GPU.

TRL admite ZeRO a través de la integración de DeepSpeed. Para usarlo, proporcione un archivo de configuración de DeepSpeed con la configuración deseada,

{
  "zero_optimization": {"stage": 3},
  "bf16": {"enabled": "auto"},
  "train_batch_size": "auto",
  "train_micro_batch_size_per_gpu": "auto"
}

Establezca deepspeed="zero3.json" en la configuración de entrenamiento y ejecute el script de entrenamiento con torchrun.

torchrun --nproc_per_node 2 train.py