TRL documentation

RLOO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

RLOO Trainer

model badge

Resumen

TRL admite el RLOO Trainer para entrenar modelos de lenguaje, tal como se describe en el artículo Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs de Arash Ahmadian, Chris Cremer, Matthias Gallé, Marzieh Fadaee, Julia Kreutzer, Ahmet Üstün y Sara Hooker.

El resumen del artículo es el siguiente:

El alineamiento de la IA en la forma de Aprendizaje por Refuerzo con Retroalimentación Humana (RLHF) se trata cada vez más como un ingrediente crucial para los grandes modelos de lenguaje de alto rendimiento. La Optimización de Política Proximal (PPO) ha sido posicionada por la literatura reciente como el método canónico para la parte de RL de RLHF. Sin embargo, implica tanto un alto costo computacional como un ajuste sensible de hiperparámetros. Sostenemos que la mayoría de los principios motivacionales que llevaron al desarrollo de PPO son de menor preocupación práctica en RLHF y abogamos por un método menos costoso computacionalmente que preserve e incluso aumente el rendimiento. Revisamos la formulación del alineamiento a partir de preferencias humanas en el contexto de RL. Manteniendo la simplicidad como principio rector, demostramos que muchos componentes de PPO son innecesarios en un contexto de RLHF y que variantes de optimización mucho más simples de estilo REINFORCE superan tanto a PPO como a los métodos “RL-free” recién propuestos, como DPO y RAFT. Nuestro trabajo sugiere que una adaptación cuidadosa a las características de alineamiento de los LLM permite beneficiarse de la optimización de RL en línea a bajo costo.

Este método de post-entrenamiento fue aportado por Costa Huang y posteriormente refactorizado por Shirin Yamani.

Inicio rápido

Este ejemplo demuestra cómo entrenar un modelo utilizando el método RLOO. Entrenamos un modelo Qwen 0.5B Instruct con los prompts del conjunto de datos DeepMath-103K. Puede ver los datos del conjunto de datos aquí:

A continuación se muestra el script para entrenar el modelo. accuracy_reward requiere math-verify, que puede instalar con pip install trl[math_verify].

# train_rloo.py
from datasets import load_dataset
from trl import RLOOTrainer
from trl.rewards import accuracy_reward

dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=accuracy_reward,
    train_dataset=dataset,
)
trainer.train()

Ejecute el script usando el siguiente comando:

torchrun --nproc_per_node 8 train_rloo.py

Mirando más a fondo el método RLOO

RLOO es un algoritmo de aprendizaje en línea, lo que significa que mejora de forma iterativa utilizando los datos generados por el propio modelo entrenado durante el entrenamiento. La intuición detrás del objetivo de RLOO es maximizar la ventaja de las completaciones generadas, al tiempo que se garantiza que el modelo se mantenga cerca de la política de referencia. Para entender cómo funciona RLOO, se puede desglosar en cuatro pasos principales: generar completaciones, calcular la ventaja, estimar la divergencia de KL y calcular la pérdida.

RLOO

Generar completiones

En cada paso de entrenamiento, muestreamos un lote de prompts y generamos un conjunto de G G completaciones para cada prompt (denotado como oi o_i ).

Cálculo de la recompensa

En RLOO, la recompensa consta de dos componentes: la recompensa proporcionada por el modelo de recompensa (o función de recompensa) y una penalización KL que desalienta que la política se desvíe demasiado de una política de referencia fija

  1. Para cada una de las G G secuencias generadas oi=(oi,1,…,oi,T) o_i = (o_{i,1}, \dots, o_{i,T}) condicionadas en una consulta q q , calculamos una recompensa escalar utilizando un modelo de recompensa R(oi,q) R(o_i, q) .
  2. Simultáneamente, estimamos la divergencia de KL entre la política actual πθ \pi_\theta y la política de referencia fija πref \pi_{\text{ref}} a lo largo de la secuencia. La estimación de KL para la secuencia oi o_i es: DKL ⁣[πθ∥πref]=∑t=1Tlog⁡πθ(oi,t∣q,oi,<t)πref(oi,t∣q,oi,<t). \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta\|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}.

La recompensa final asignada a la secuencia oi o_i es la siguiente: ri=R(oi,q)−β DKL ⁣[πθ∥πref], r_i = R(o_i, q) - \beta \, \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta \|\pi_{\mathrm{ref}}\right],

donde β>0 \beta > 0 controla la intensidad de la penalización KL.

En un entorno puramente en línea (num_iterations = 1, valor predeterminado), los datos se generan mediante la política actual. En este caso, la penalización KL se calcula directamente utilizando la política actual.

En el caso más general (p. ej., múltiples pasos de gradiente por lote), los datos se generan en su lugar mediante una instantánea anterior πold \pi_{\text{old}} . Para mantener la penalización coherente con la distribución de muestreo, la KL se define con respecto a esta política:

DKL ⁣[πold ∥ πref]. \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \,\|\, \pi_{\text{ref}}\right].

Equivalentemente, para una secuencia muestreada o o , la estimación de Monte Carlo es:

DKL ⁣[πold∥πref]=∑t=1Tlog⁡πold(oi,t∣q,oi,<t)πref(oi,t∣q,oi,<t). \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_{\text{old}}(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}.

Cálculo de la ventaja

Una vez que se han calculado las recompensas para cada finalización, calculamos una línea base como la recompensa promedio de todas las demás muestras del mismo lote, excluyendo la muestra actual. Esta línea base se utiliza para reducir la varianza de la estimación del gradiente de la política. La ventaja para cada finalización se obtiene entonces como la diferencia entre su propia recompensa y esta línea base de exclusión de uno.

Formalmente, para un lote de G finalizaciones, la línea base para la finalización es:bi=1G−1∑j≠irj b_i = \frac{1}{G-1} \sum_{j \neq i} r_j

y luego la ventaja para cada finalización se calcula como la diferencia entre su recompensa y la línea base: Ai=ri−bi A_i = r_i - b_i

Cálculo de la pérdida

La pérdida REINFORCE se define simplemente como: LRLOO(θ)=−1G∑i=1GA^i log⁡πθ(oi∣q) \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \hat{A}_i \, \log \pi_\theta(o_i \mid q)

En la práctica, realizar múltiples pasos de gradiente en el mismo lote hace que las acciones sean efectivamente fuera de política en relación con los parámetros actuales. Para corregir esto, introducimos la proporción de muestreo de importancia. Para evitar actualizaciones excesivamente grandes cuando la política cambia entre el muestreo y los pasos de gradiente, recortamos esta proporción: LRLOO(θ)=−1G∑i=1Gmin⁡(πθ(oi∣q)πθold(oi∣q)A^i, clip(πθ(oi∣q)πθold(oi∣q),1−ϵ,1+ϵ)A^i) \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \min \left( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \hat{A}_i, \, \text{clip}\left(\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)}, 1-\epsilon, 1+\epsilon\right) \hat{A}_i \right)

En un entorno totalmente en línea y de un solo paso (predeterminado), πθ(oi∣q)πθold(oi∣q)=1 \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} = 1 y esto se reduce a REINFORCE estándar.

A diferencia de GRPO, RLOO no realiza la propagación inversa de gradientes a través del término KL. Aquí, la KL se utiliza puramente para la formación de recompensas: se calcula bajo no_grad y se incorpora en la recompensa escalar ri r_i , que se convierte en la ventaja desacoplada A^i \hat{A}_i .

En otras palabras, la única ruta por la que el gradiente entra en la política es el término de la razón de importancia πθ(oi∣q)πθold(oi∣q) \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} , y el término KL no se propaga hacia atrás en la política.

En cambio, GRPO añade un término KL explícito y diferenciable a su objetivo, calculado sobre la marcha con la política actual πθ \pi_\theta , de modo que su gradiente fluye a través del término de ratio y de la penalización KL.

Métricas registradas

Durante el entrenamiento y la evaluación, registramos las siguientes métricas:

  • num_tokens: El número total de tokens procesados hasta el momento, incluyendo tanto los prompts como las completions.
  • step_time: Tiempo promedio (en segundos) por paso de entrenamiento (incluida la generación).
  • completions/mean_length: La longitud media de las completaciones generadas.
  • completions/min_length: La longitud mínima de las completaciones generadas.
  • completions/max_length: La longitud máxima de las completaciones generadas.
  • completions/mean_terminated_length: La longitud media de las completaciones generadas que terminan con EOS.
  • completions/min_terminated_length: La longitud mínima de las completaciones generadas que terminan con EOS.
  • completions/max_terminated_length: La longitud máxima de las completaciones generadas que terminan con EOS.
  • completions/clipped_ratio: La proporción de completados truncados (recortados).
  • rewards/{reward_func_name}/mean: La recompensa media de una función de recompensa específica.
  • rewards/{reward_func_name}/std: La desviación estándar de la recompensa de una función de recompensa específica.
  • reward: La recompensa media general tras sumar las recompensas de todas las funciones (ponderadas por reward_weights).
  • reward_std: La desviación estándar de las recompensas sumadas entre funciones (ponderadas por reward_weights), calculada sobre el lote completo.
  • frac_reward_zero_std: La fracción de muestras en el lote de generación con una desviación estándar de recompensa igual a cero, lo que implica que hay poca diversidad para ese prompt (todas las respuestas son correctas o incorrectas).
  • entropy: Entropía media de las predicciones de tokens en las completaciones generadas. (Si mask_truncated_completions=True, se excluyen los tokens de las secuencias enmascaradas.)
  • aux_loss: La pérdida auxiliar de equilibrio de carga de un modelo Mixture-of-Experts, antes de que se escale por router_aux_loss_coef y se sume a la pérdida. Se registra solo cuando el modelo es un modelo MoE y router_aux_loss_coef es distinto de cero.
  • kl: La divergencia KL media entre el modelo y el modelo de referencia, calculada sobre las completaciones generadas. Se registra solo si beta es distinto de cero.
  • clip_ratio/region_mean: La proporción de probabilidades de secuencia donde el objetivo RLOO se recorta para mantenerse dentro de la región de confianza: clip(ri(θ),1−ϵlow,1+ϵhigh) ,ri(θ)=πθ(oi∣q)πθold(oi∣q) \text{clip}\left( r_{i}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right)\,, \quad r_{i}(\theta) = \frac{\pi_\theta(o_{i} \mid q)}{\pi_{\theta_{\text{old}}}(o_{i} \mid q)} . Un valor más alto significa que se recortan más muestras, lo que limita cuánto puede cambiar la política πθ\pi_\theta .
  • clip_ratio/low_mean: La proporción media de probabilidades de secuencia que se recortaron en el límite inferior de la región de confianza: ri,t(θ)<1−ϵlowr_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}.
  • clip_ratio/low_min: El indicador de recorte más pequeño por finalización en el límite inferior de la región de confianza: ri,t(θ)<1−ϵlowr_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}.
  • clip_ratio/high_mean: La proporción media de probabilidades de secuencia que se recortaron en el límite superior de la región de confianza: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.
  • clip_ratio/high_max: El mayor indicador de recorte por finalización en el límite superior de la región de confianza: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.

Personalización

Acelera el entrenamiento con generación impulsada por vLLM

La generación suele ser el principal cuello de botella al entrenar con métodos en línea. Para acelerar la generación, puedes usar vLLM, un motor de inferencia de alto rendimiento y baja latencia para LLMs. Para habilitarlo, primero instala el paquete con

pip install trl[vllm]

Soportamos dos formas de usar vLLM durante el entrenamiento: modo servidor y modo colocalizado.

Opción 1: Modo Colocate

En este modo, vLLM se ejecuta dentro del proceso del entrenador y comparte la memoria de GPU con el modelo de entrenamiento. Esto evita iniciar un servidor separado y puede mejorar la utilización de la GPU, pero puede provocar una contención de memoria en las GPUs de entrenamiento. Este es el modo predeterminado.

from trl import RLOOConfig

training_args = RLOOConfig(
    ...,
    use_vllm=True,  # vllm_mode="colocate" by default
)

Opción 2: Modo servidor

En este modo, vLLM se ejecuta en un proceso separado (y usando GPUs separadas) y se comunica con el entrenador a través de HTTP. Esto es ideal si tienes GPUs dedicadas para inferencia.

  1. Iniciar el servidor de vLLM:

    VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
        --weight-transfer-config '{"backend": "nccl"}' \
        --logprobs-mode processed_logprobs \
        --max-logprobs -1
  2. Habilita el modo de servidor en tu script de entrenamiento:

    from trl import RLOOConfig
    
    training_args = RLOOConfig(
        ...,
        use_vllm=True,
        vllm_mode="server",
    )

Asegúrate de que el servidor utilice GPUs diferentes a las del entrenador, de lo contrario es posible que aparezcan errores de NCCL. Puedes especificar las GPUs a utilizar con la variable de entorno CUDA_VISIBLE_DEVICES.

En función del tamaño del modelo y de los requisitos generales de memoria de GPU para el entrenamiento, es posible que necesites ajustar el parámetro vllm_gpu_memory_utilization en RLOOConfig para evitar la subutilización o errores de memoria insuficiente.

Ponemos a disposición un HF Space para ayudar a estimar la utilización de memoria de GPU recomendada en función de la configuración de tu modelo y los ajustes de tu experimento. Simplemente úsalo de la siguiente manera para obtener la recomendación de vllm_gpu_memory_utilization:

Si el valor recomendado no funciona en su entorno, sugerimos añadir un pequeño margen (p. ej., +0.05 o +0.1) al valor recomendado para garantizar la estabilidad.

Si aún obtienes errores de memoria insuficiente, establece vllm_enable_sleep_mode en True y los parámetros y la caché de vllm se descargarán durante el paso de optimización. Para obtener más información, consulta Reducing Memory Usage with vLLM Sleep Mode.

Por defecto, RLOO utiliza MASTER_ADDR=localhost y MASTER_PORT=12345 para vLLM, pero puedes sobrescribir estos valores configurando las variables de entorno de forma correspondiente.

Para obtener más información, consulte Acelerar el entrenamiento con vLLM.

RLOO a gran escala: entrena un modelo de 70B+ en varios nodos

Al entrenar modelos grandes como Qwen2.5-72B, se necesitan varias optimizaciones clave para hacer que el entrenamiento sea eficiente y escalable en varias GPU y nodos. Estas incluyen:

  • DeepSpeed ZeRO Stage 3: ZeRO aprovecha el paralelismo de datos para distribuir los estados del modelo (pesos, gradientes, estados del optimizador) entre varias GPU y CPU, reduciendo los requisitos de memoria y cómputo en cada dispositivo. Dado que los modelos grandes no caben en una sola GPU, es necesario usar ZeRO Stage 3 para entrenar dichos modelos. Para más detalles, consulte DeepSpeed Integration.
  • torchrun: el lanzador de PyTorch inicia un proceso por GPU en cada nodo y los conecta a través de un punto de encuentro común. Para más detalles, consulte Distributing Training.
  • vLLM: Consulte la sección anterior para saber cómo usar vLLM para acelerar la generación.

A continuación se muestra un ejemplo de script de SLURM para entrenar un modelo de 70B con RLOO en varios nodos. Este script entrena un modelo en 4 nodos y utiliza el 5º nodo para la generación impulsada por vLLM.

#!/bin/bash
#SBATCH --nodes=5
#SBATCH --gres=gpu:8

# Get the list of allocated nodes
NODELIST=($(scontrol show hostnames $SLURM_JOB_NODELIST))

# Assign the first 4 nodes for training and the 5th node for vLLM
TRAIN_NODES="${NODELIST[@]:0:4}"  # Nodes 0, 1, 2, 3 for training
VLLM_NODE="${NODELIST[4]}"  # Node 4 for vLLM

# Run training on the first 4 nodes (Group 1)
srun --nodes=4 --ntasks=4 --nodelist="${NODELIST[@]:0:4}" torchrun \
     --nnodes 4 \
     --nproc_per_node 8 \
     --node_rank $SLURM_PROCID \
     --rdzv_backend c10d \
     --rdzv_endpoint ${NODELIST[0]}:29500 \
     train_rloo.py \
     --server_ip $VLLM_NODE &

# Run vLLM server on the 5th node (Group 2)
srun --nodes=1 --ntasks=1 --nodelist="${NODELIST[4]}" env VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-72B --tensor-parallel-size 8 \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --max-logprobs -1 &

wait
import argparse

from datasets import load_dataset
from trl import RLOOTrainer, RLOOConfig

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--vllm_server_host", type=str, default="", help="The server IP")
    args = parser.parse_args()

    # Example dataset from TLDR
    dataset = load_dataset("trl-lib/tldr", split="train")

    # Dummy reward function: count the number of unique characters in the completions
    def reward_num_unique_chars(completions, **kwargs):
        return [len(set(c)) for c in completions]

    training_args = RLOOConfig(
        output_dir="Qwen2.5-72B-RLOO",
        per_device_train_batch_size=4,
        bf16=True,
        deepspeed="examples/deepspeed_configs/zero3.json",
        use_vllm=True,
        vllm_mode="server",
        vllm_server_host=args.vllm_server_host.replace("ip-", "").replace("-", "."),  # from ip-X-X-X-X to X.X.X.X
    )

    trainer = RLOOTrainer(model="Qwen/Qwen2.5-72B", args=training_args, reward_funcs=reward_num_unique_chars, train_dataset=dataset)
    trainer.train()

if __name__=="__main__":
    main()

Uso de una función de recompensa personalizada

El RLOOTrainer permite el uso de funciones de recompensa personalizadas en lugar de modelos de recompensa densos. Para garantizar la compatibilidad, su función de recompensa debe cumplir con los siguientes requisitos:

Las funciones de recompensa pueden ser funciones Python síncronas o corrutinas asíncronas async def. Cuando se proporcionan varias funciones de recompensa asíncronas, se espera su finalización de forma concurrente (se ejecutan en paralelo mediante asyncio.gather) para que su latencia se solape.

  1. Argumentos de entrada:

    • La función debe aceptar lo siguiente como argumentos de palabra clave:

      • prompts (contiene los prompts),
      • completions (contiene las completaciones generadas),
      • completion_ids (contiene las completas tokenizadas),
      • trainer_state (TrainerState): El estado actual del trainer. Esto se puede usar para implementar funciones de recompensa dinámicas, como el aprendizaje por currículo, donde la recompensa se ajusta en función del progreso del entrenamiento.
      • log_extra: una función log_extra(column: str, values: list) para añadir columnas adicionales a la tabla de completados. Consulte el Ejemplo 6.
      • log_metric: una función log_metric(name: str, value: float) para registrar métricas escalares como gráficos junto a kl, entropy, etc. Consulte el Ejemplo 6.
      • Todos los nombres de columnas (excepto prompt) que el conjunto de datos puede tener. Por ejemplo, si el conjunto de datos contiene una columna llamada ground_truth, la función se llamará con ground_truth como argumento de palabra clave.

      La forma más sencilla de cumplir con este requisito es usar **kwargs en la firma de la función.

    • Dependiendo del formato del conjunto de datos, la entrada variará:

  2. Valor de retorno: La función debe devolver una lista de floats. Cada float representa la recompensa correspondiente a una única finalización.

Ejemplo 1: Recompensar las finalizaciones más largas

A continuación se muestra un ejemplo de una función de recompensa para un formato estándar que recompensa las finalizaciones más largas:

def reward_func(completion_ids, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of token count)."""
    return [float(len(ids)) for ids in completion_ids]

Puedes probarlo de la siguiente manera:

>>> prompts = ["The sky is", "The sun is"]  # not used in the reward function, but the trainer will pass it
>>> completions = [" blue.", " in the sky."]  # not used in the reward function, but the trainer will pass it
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[2.0, 4.0]

Ejemplo 1.1: Recompensar las finalizaciones más largas (basado en el número de caracteres)

Igual que en el ejemplo anterior, pero esta vez la función de recompensa se basa en el número de caracteres en lugar de tokens.

def reward_func(completions, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of character count)."""
    return [float(len(completion)) for completion in completions]

Puedes probarlo de la siguiente manera:

>>> prompts = ["The sky is", "The sun is"]
>>> completions = [" blue.", " in the sky."]
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]  # not used in the reward function, but the trainer will pass it
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[6.0, 12.0]

Ejemplo 2: Recompensar las finalizaciones con un formato específico

A continuación se muestra un ejemplo de una función de recompensa que verifica si la finalización tiene un formato específico. Este ejemplo se inspira en la función format reward utilizada en el artículo DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. Está diseñada para un formato conversacional, donde los prompts y las finalizaciones consisten en mensajes estructurados.

import re

def format_reward_func(completions, **kwargs):
    """Reward function that checks if the completion has a specific format."""
    pattern = r"^<think>.*?</think><answer>.*?</answer>$"
    completion_contents = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, content) for content in completion_contents]
    return [1.0 if match else 0.0 for match in matches]

Puedes probar esta función de la siguiente manera:

>>> prompts = [
...     [{"role": "user", "content": "What is the result of (1 + 2) * 4?"}],
...     [{"role": "user", "content": "What is the result of (3 + 1) * 2?"}],
... ]
>>> completions = [
...     [{"role": "assistant", "content": "<think>The sum of 1 and 2 is 3, which we multiply by 4 to get 12.</think><answer>(1 + 2) * 4 = 12</answer>"}],
...     [{"role": "assistant", "content": "The sum of 3 and 1 is 4, which we multiply by 2 to get 8. So (3 + 1) * 2 = 8."}],
... ]
>>> format_reward_func(prompts=prompts, completions=completions)
[1.0, 0.0]

Ejemplo 3: Recompensar las finalizaciones basándose en una referencia

A continuación se muestra un ejemplo de una función de recompensa que verifica si la finalización es correcta. Este ejemplo se inspira en la función de recompensa de precisión utilizada en el artículo DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. Este ejemplo está diseñado para el formato estándar, donde el conjunto de datos contiene una columna llamada ground_truth.

import re

def reward_func(completions, ground_truth, **kwargs):
    # Regular expression to capture content inside \boxed{}
    matches = [re.search(r"\\boxed\{(.*?)\}", completion) for completion in completions]
    contents = [match.group(1) if match else "" for match in matches]
    # Reward 1 if the content is the same as the ground truth, 0 otherwise
    return [1.0 if c == gt else 0.0 for c, gt in zip(contents, ground_truth)]

Puedes probar esta función de la siguiente manera:

>>> prompts = ["Problem: Solve the equation $2x + 3 = 7$. Solution:", "Problem: Solve the equation $3x - 5 = 10$."]
>>> completions = [r" The solution is \boxed{2}.", r" The solution is \boxed{6}."]
>>> ground_truth = ["2", "5"]
>>> reward_func(prompts=prompts, completions=completions, ground_truth=ground_truth)
[1.0, 0.0]

Ejemplo 4: Funciones de recompensa multitarea

A continuación se muestra un ejemplo de uso de múltiples funciones de recompensa en el RLOOTrainer. En este ejemplo, definimos dos funciones de recompensa específicas para cada tarea: math_reward_func y coding_reward_func. La math_reward_func otorga recompensas a los problemas de matemáticas en función de su corrección, mientras que la coding_reward_func otorga recompensas a los problemas de programación en función de si la solución funciona.

from datasets import Dataset
from trl import RLOOTrainer

# Define a dataset that contains both math and coding problems
dataset = Dataset.from_list(
    [
        {"prompt": "What is 2+2?", "task": "math"},
        {"prompt": "Write a function that returns the sum of two numbers.", "task": "code"},
        {"prompt": "What is 3*4?", "task": "math"},
        {"prompt": "Write a function that returns the product of two numbers.", "task": "code"},
    ]
)

# Math-specific reward function
def math_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "math":
            # Calculate math-specific reward
            correct = check_math_solution(prompt, completion)
            reward = 1.0 if correct else -1.0
            rewards.append(reward)
        else:
            # Return None for non-math tasks
            rewards.append(None)
    return rewards

# Coding-specific reward function
def coding_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "code":
            # Calculate coding-specific reward
            works = test_code_solution(prompt, completion)
            reward = 1.0 if works else -1.0
            rewards.append(reward)
        else:
            # Return None for non-coding tasks
            rewards.append(None)
    return rewards

# Use both task-specific reward functions
trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=[math_reward_func, coding_reward_func],
    train_dataset=dataset,
)

trainer.train()

En este ejemplo, math_reward_func y coding_reward_func están diseñadas para funcionar con un conjunto de datos mixto que contiene tanto problemas de matemáticas como de programación. La columna task del conjunto de datos se utiliza para determinar qué función de recompensa aplicar a cada problema. Si no hay una función de recompensa relevante para una muestra del conjunto de datos, la función de recompensa devolverá None y el RLOOTrainer continuará con las funciones y tareas válidas. Esto permite que el RLOOTrainer maneje múltiples funciones de recompensa con diferentes alcances de aplicación.

Tenga en cuenta que el RLOOTrainer ignorará las recompensas None devueltas por las funciones de recompensa y solo considerará las recompensas devueltas por las funciones relevantes. Esto garantiza que el modelo se entrene en las tareas relevantes e ignore las tareas para las que no existe una función de recompensa relevante.

Ejemplo 5: Funciones de recompensa asíncronas

Las funciones de recompensa personalizadas también pueden definirse como corrutinas async def. Esto resulta útil si la recompensa depende de una E/S lenta (por ejemplo, al llamar a un servicio remoto). Al pasar varias funciones de recompensa asíncronas, RLOOTrainer las ejecuta de forma concurrente para que su latencia se solape.

A continuación se muestra un ejemplo mínimo de una función de recompensa asíncrona que simula una operación limitada por E/S:

import asyncio

async def async_reward_func(prompts, completions, **kwargs):
    # Simulate an I/O-bound call (e.g., HTTP request, database lookup)
    await asyncio.sleep(0.01)
    # Simple toy reward: 1.0 if the completion is non-empty, else 0.0
    return [1.0 if completion else 0.0 for completion in completions]

Ejemplo 6: Registro de columnas y métricas adicionales

A continuación se muestra un ejemplo de una función de recompensa que registra columnas adicionales en la tabla de completados y métricas escalares como gráficos.

import re

def reward_func(completions, ground_truth, log_extra=None, log_metric=None, **kwargs):
    extracted = [re.search(r"\\boxed\{(.*?)\}", c) for c in completions]
    extracted = [m.group(1) if m else None for m in extracted]
    rewards = [1.0 if e == gt else 0.0 for e, gt in zip(extracted, ground_truth)]

    if log_extra:
        log_extra("golden_answer", list(ground_truth))
        log_extra("extracted_answer", [e or "[none]" for e in extracted])

    if log_metric:
        log_metric("accuracy", sum(rewards) / len(rewards))

    return rewards

Pasar la función de recompensa al entrenador

Para usar su función de recompensa personalizada, pásela al RLOOTrainer de la siguiente manera:

from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=reward_func,
    ...,
)

Puedes pasar varias funciones de recompensa como una lista; esta lista puede incluir tanto funciones síncronas como asíncronas:

from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=[reward_func, async_reward_func1, async_reward_func2],
    ...,
)

y la recompensa se calculará como la suma de las recompensas de cada función, o como la suma ponderada si se proporciona reward_weights en la configuración.

Tenga en cuenta que RLOOTrainer admite múltiples funciones de recompensa de diferentes tipos. Consulte la documentación de los parámetros para obtener más detalles.

Entrenamiento de modelos de visión y lenguaje

RLOO admite el entrenamiento de modelos de visión-lenguaje (VLM) en conjuntos de datos multimodales que contienen tanto texto como imágenes.

Modelos compatibles

Probado con:

  • Gemma3 — p. ej., google/gemma-3-4b-it
  • LLaVA-NeXT — p. ej., llava-hf/llava-v1.6-mistral-7b-hf
  • Qwen2-VL — por ejemplo, Qwen/Qwen2-VL-2B-Instruct
  • Qwen2.5-VL — por ejemplo, Qwen/Qwen2.5-VL-3B-Instruct
  • SmolVLM2 — por ejemplo, HuggingFaceTB/SmolVLM2-2.2B-Instruct

No se garantiza la compatibilidad con todos los VLM. Si crees que un modelo debería ser compatible, no dudes en abrir un issue en GitHub o, mejor aún, enviar un pull request con los cambios necesarios.

Inicio rápido

Use rloo_vlm.py para ajustar finamente un VLM. Comando de ejemplo para entrenar en lmms-lab/multimodal-open-r1-8k-verified:

torchrun --nproc_per_node 8 examples/rloo_visual_math/rloo_visual_math.py \
  --deepspeed examples/deepspeed_configs/zero3.json \
  --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
  --output_dir rloo-Qwen2.5-VL-3B-Instruct \
  --learning_rate 1e-5 \
  --dtype bfloat16 \
  --max_completion_length 1024 \
  --use_vllm \
  --vllm_mode colocate \
  --use_peft \
  --lora_target_modules "q_proj", "v_proj" \
  --log_completions

Consejos de configuración

  • Usar LoRA en las capas de proyección de visión-lenguaje
  • Habilitar la cuantización de 4 bits para reducir el uso de memoria
  • Los VLM son intensivos en memoria: comience con tamaños de lote más pequeños
  • La mayoría de los modelos son compatibles con vLLM (modos server y colocate)

Formato de datos

Cada muestra de entrenamiento debe incluir:

  • prompt: Texto formateado mediante la plantilla de chat del procesador
  • image/images: Imagen PIL o lista de Imágenes PIL

El trainer maneja automáticamente la conversión de imagen a tensor a través del procesador de imágenes del modelo.

RLOOTrainer

clase trl.RLOOTrainer

< >

( model: str | PreTrainedModel | PeftModelreward_funcs: str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]] | list[str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]]]args: trl.trainer.rloo_config.RLOOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonereward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Parámetros

  • model (str o PreTrainedModel o PeftModel) — Modelo a entrenar. Puede ser:
    • Una cadena, que es el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co, o una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained, por ejemplo, './my_model_directory/'. El modelo se carga usando <ModelArchitecture>.from_pretrained (donde <ModelArchitecture> se deriva de la configuración del modelo) con los argumentos de palabra clave en args.model_init_kwargs. Si dtype no se especifica en args.model_init_kwargs, el valor predeterminado es float32. Esto difiere de from_pretrained, donde (desde Transformers v5) el dtype se infiere de la configuración del modelo.
    • Un objeto PreTrainedModel. Solo se admiten modelos de lenguaje causales.
    • Un objeto PeftModel. Solo se admiten modelos de lenguaje causales.
  • reward_funcs (RewardFunc | list[RewardFunc]) — Funciones de recompensa que se usarán para calcular las recompensas. Para calcular las recompensas, llamamos a todas las funciones de recompensa con los prompts y las completions y sumamos las recompensas. Puede ser:
    • Una única función de recompensa, como

      • Una cadena: el ID del modelo de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co, o una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained, por ejemplo, './my_model_directory/'. El modelo se carga con from_pretrained usando num_labels=1 y los argumentos de palabra clave en args.model_init_kwargs.

      • Un objeto PreTrainedModel: solo se admiten modelos de clasificación de secuencias.

      • Una función de recompensa personalizada: la función recibe los prompts y las completaciones generadas, además de cualquier columna adicional del conjunto de datos. Debe devolver una lista de recompensas. Las funciones de recompensa personalizadas pueden ser síncronas o asíncronas y también pueden devolver None cuando la recompensa no es aplicable a esas muestras. Esto es útil para el entrenamiento multitarea, donde diferentes funciones de recompensa se aplican a diferentes tipos de muestras. Cuando una función de recompensa devuelve None para una muestra, esa función de recompensa se excluye del cálculo de la recompensa para esa muestra. Para más detalles, consulte Usar una función de recompensa personalizada.

        El estado del trainer también se pasa a la función de recompensa. El estado del trainer es una instancia de TrainerState y se puede acceder a él mediante el argumento trainer_state de la firma de la función de recompensa.

    • Una lista de funciones de recompensa, donde cada elemento puede ser independientemente cualquiera de los tipos anteriores. Se permite mezclar diferentes tipos dentro de la lista (p. ej., un ID de modelo en formato de cadena y una función de recompensa personalizada).

  • args (RLOOConfig, opcional) — Configuración para este entrenador. Si es None, se utiliza una configuración predeterminada.
  • train_dataset (Dataset o IterableDataset) — Conjunto de datos para usar en el entrenamiento. Debe incluir una columna "prompt". Cualquier columna adicional en el conjunto de datos se ignora. El formato de las muestras puede ser:
    • Estándar: Cada muestra contiene texto plano.
    • Conversacional: Cada muestra contiene mensajes estructurados (p. ej., rol y contenido).

    Cuando train_dataset es un IterableDataset (por ejemplo, un dataset de streaming), max_steps debe establecerse en los argumentos de entrenamiento, ya que su longitud no se puede inferir y se requiere el número total de pasos de entrenamiento para acotar el bucle de entrenamiento y configurar el programador de tasa de aprendizaje.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict o dict[str, Dataset | IterableDataset]) — Conjunto de datos para usar en la evaluación. Debe cumplir los mismos requisitos que train_dataset.
  • processing_class (PreTrainedTokenizerBase, ProcessorMixin, opcional) — Clase de procesamiento utilizada para procesar los datos. El lado de relleno debe estar configurado en “left”. Si es None, la clase de procesamiento se carga desde el nombre del modelo con from_pretrained. Debe establecerse un token de relleno, tokenizer.pad_token. Si la clase de procesamiento no ha establecido un token de relleno, se utilizará tokenizer.eos_token como valor predeterminado.
  • reward_processing_classes (PreTrainedTokenizerBase o list[PreTrainedTokenizerBase], opcional) — Clases de procesamiento correspondientes a las funciones de recompensa especificadas en reward_funcs. Puede ser:
    • Una única clase de procesamiento: se utiliza cuando reward_funcs contiene solo una función de recompensa.
    • Una lista de clases de procesamiento: debe coincidir con el orden y la longitud de las funciones de recompensa en reward_funcs. Si se establece en None, o si un elemento de la lista correspondiente a un PreTrainedModel es None, el tokenizador del modelo se carga automáticamente usando from_pretrained. Para los elementos de reward_funcs que son funciones de recompensa personalizadas (no PreTrainedModel), las entradas correspondientes en reward_processing_classes se ignoran.
  • callbacks (lista de TrainerCallback, opcional) — Lista de callbacks para personalizar el bucle de entrenamiento. Se añadirán a la lista de callbacks predeterminados detallada en aquí.

    Si deseas eliminar uno de los callbacks predeterminados, utiliza el método remove_callback.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, por defecto (None, None)) — Una tupla que contiene el optimizador y el programador a utilizar. Por defecto, se utilizará una instancia de AdamW en su modelo y un programador dado por get_linear_schedule_with_warmup controlado por args.
  • quantization_config (BitsAndBytesConfig, opcional) — Configuración de cuantización utilizada al cargar el modelo desde un identificador de modelo. Combínala con peft_config para el entrenamiento QLoRA. Se ignora si el modelo ya está instanciado.
  • peft_config (PeftConfig, opcional) — Configuración de PEFT utilizada para envolver el modelo. Si es None, el modelo no se envuelve.

Trainer para el método Reinforce Leave One Out (RLOO). Este algoritmo fue propuesto inicialmente en el artículo Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs.

Ejemplo:

>>> from trl import RLOOTrainer
>>> from trl.rewards import accuracy_reward
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

>>> trainer = RLOOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     reward_funcs=accuracy_reward,
...     train_dataset=dataset,
... )
>>> trainer.train()

entrenar

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

Parámetros

  • resume_from_checkpoint (str o bool, opcional) — Si es una str, ruta local a un punto de control guardado por una instancia anterior de Trainer. Si es un bool y es igual a True, carga el último punto de control en args.output_dir guardado por una instancia anterior de Trainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí.
  • trial (optuna.Trial o dict[str, Any], opcional) — La ejecución del ensayo o el diccionario de hiperparámetros para la búsqueda de hiperparámetros.
  • ignore_keys_for_eval (list[str], opcional) — Una lista de claves en la salida de tu modelo (si es un diccionario) que deben ignorarse al recopilar predicciones para la evaluación durante el entrenamiento.

Devuelve

~trainer_utils.TrainOutput

Objeto que contiene el número de pasos globales, la pérdida de entrenamiento y las métricas.

Punto de entrada principal del entrenamiento.

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

Guardará el modelo, por lo que podrás recargarlo usando from_pretrained().

Solo se guardará desde el proceso principal.

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Parámetros

  • commit_message (str, opcional, valor predeterminado "End of training") — Mensaje para el commit al hacer push.
  • blocking (bool, opcional, valor predeterminado True) — Si la función debe devolver el control solo cuando el git push haya terminado.
  • token (str, opcional, valor predeterminado None) — Token con permiso de escritura para sobrescribir los argumentos originales de Trainer.
  • revision (str, opcional) — La revisión de git desde la que se realizará el commit. Por defecto, es la cabecera de la rama “main”.
  • private (bool, opcional) — Si se debe hacer el repositorio privado cuando se crea. El valor predeterminado es args.hub_private_repo. No tiene efecto si el repositorio ya existe.
  • kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan a ~Trainer.create_model_card.

Sube self.model y self.processing_class al hub de modelos de 🤗 en el repositorio self.args.hub_model_id.

RLOOConfig

clase trl.RLOOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool | None = Falselabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Falsenum_generations: int | None = 2num_generations_eval: int | None = Nonemax_completion_length: int | None = 512ds3_gather_for_generation: bool = Trueshuffle_dataset: bool | None = Truepad_to_multiple_of: int | str | None = 'auto'generation_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict | str | None = Nonechat_template_kwargs: dict | str | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_structured_outputs_regex: str | None = Nonevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonevllm_tensor_parallel_size: int = 1beta: float = 0.05num_iterations: int = 1epsilon: float = 0.2epsilon_high: float | None = Nonereward_weights: list[float] | None = Nonenormalize_advantages: bool = Falsereward_clip_range: tuple[float, float] | None = Nonemask_truncated_completions: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512log_completions: bool = Falselog_multimodal: bool = Truenum_completions_to_print: int | None = Nonelog_unique_prompts: bool = Falseuse_transformers_continuous_batching: bool = Falsetransformers_continuous_batching_config: dict | str | None = Noneuse_transformers_paged: bool = False )

Parámetros que controlan el modelo y el modelo de referencia

  • model_init_kwargs (str o dict[str, Any], opcional) — Argumentos de palabra clave para from_pretrained, utilizados cuando el argumento model del RLOOTrainer se proporciona como una cadena de caracteres. El valor de revision también se utiliza al cargar las clases de procesamiento.
  • trust_remote_code (bool, opcional, valor predeterminado False) — Si se permite cargar modelos y tokenizadores que incluyen código Python personalizado desde el Hub. Se reenvía a from_pretrained y from_pretrained. También se aplica a la carga de modelos de recompensa y tokenizadores de recompensa.
  • router_aux_loss_coef (float, opcional) — Coeficiente de la pérdida auxiliar de equilibrado de carga para modelos Mixture-of-Experts (MoE), que se añade a la pérdida de entrenamiento con este peso. Si no se establece, se utiliza el valor declarado en la configuración del modelo. Establezca 0.0 para desactivarlo. Falla si se utiliza con un modelo que no es MoE.
  • disable_dropout (bool, opcional, valor predeterminado False) — Si se deshabilita el dropout en el modelo. Esto es útil para el entrenamiento con un modelo de referencia, ya que evita que el modelo genere logprobs diferentes para la misma entrada.

Parámetros que controlan el preprocesamiento de datos

  • remove_unused_columns (bool, opcional, valor predeterminado False) — Indica si se debe conservar únicamente la columna "prompt" en el conjunto de datos. Si utiliza una función de recompensa personalizada que requiere cualquier columna distinta de "prompts" y "completions", debe mantener este valor en False.
  • num_generations (int, opcional, por defecto 2) — Número de generaciones por prompt a muestrear. El tamaño de lote efectivo (num_processes * per_device_batch_size * gradient_accumulation_steps) debe ser divisible exactamente por este valor.
    • gradient_accumulation_steps) debe ser divisible exactamente por este valor.
  • num_generations_eval (int, opcional) — Número de generaciones para muestrear durante la evaluación. Esto permite usar menos generaciones durante la evaluación para ahorrar cómputo. Si es None, usa el valor de num_generations.
  • max_completion_length (int o None, opcional, valor predeterminado 512) — Longitud máxima de la generación completada.
  • ds3_gather_for_generation (bool, opcional, valor predeterminado True) — Esta configuración se aplica a DeepSpeed ZeRO-3. Si está habilitada, los pesos del modelo de política se recogen para la generación, mejorando la velocidad de generación. Sin embargo, deshabilitar esta opción permite entrenar modelos que superan la capacidad de VRAM de una sola GPU, aunque a costa de una generación más lenta. Deshabilitar esta opción no es compatible con la generación de vLLM.
  • shuffle_dataset (bool, opcional, valor predeterminado True) — Si se debe barajar el conjunto de datos de entrenamiento.
  • pad_to_multiple_of (int o str, opcional, valor predeterminado "auto") — Si se establece, los ids de los prompts y los ids de las completions se rellenarán hasta un múltiplo de este valor. "auto" rellena hasta un múltiplo de 128 en Neuron (AWS Trainium), que compila una vez por forma de entrada, y no rellena en otros entornos.

Parámetros que controlan la generación

  • generation_batch_size (int, opcional) — Tamaño de lote a utilizar para la generación. Si es None, el valor predeterminado es el tamaño de lote efectivo de entrenamiento: per_device_train_batch_size * num_processes * steps_per_generation. En otras palabras, se procesa un lote de generación por paso de optimización. Es mutuamente excluyente con steps_per_generation.
  • steps_per_generation (int, opcional) — Número de pasos por generación. Si es None, el valor predeterminado es gradient_accumulation_steps. Es mutuamente excluyente con generation_batch_size.
  • temperature (float, opcional, valor predeterminado 1.0) — Temperatura para el muestreo. A mayor temperatura, más aleatorias son las completaciones.
  • top_p (float, opcional, valor predeterminado 1.0) — Flotante que controla la probabilidad acumulada de los tokens superiores a considerar. Debe estar en (0, 1]. Establecerlo en 1.0 para considerar todos los tokens.
  • top_k (int, opcional, valor predeterminado 0) — Número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k. Si es 0, el filtrado top-k se desactiva y se consideran todos los tokens.
  • min_p (float, opcional) — Probabilidad mínima del token, que se escala por la probabilidad del token más probable. Debe ser un valor entre 0.0 y 1.0. Los valores típicos están en el rango 0.01-0.2.
  • generation_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a GenerationConfig (si se usa transformers) o a SamplingParams (si se usa vLLM) al muestrear las completaciones. Esto se puede usar para personalizar aún más el comportamiento de la generación, como establecer suppress_tokens, num_beams, etc. Si contiene claves que entran en conflicto con los otros parámetros de generación (como min_p, top_p, etc.), los sobrescribirán.
  • chat_template_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a la función apply_chat_template al generar las completaciones.
  • repetition_penalty (float, opcional, valor predeterminado 1.0) — Flotante que penaliza los nuevos tokens en función de si aparecen en el prompt y en el texto generado hasta el momento. Los valores > 1.0 animan al modelo a usar tokens nuevos, mientras que los valores < 1.0 animan al modelo a repetir tokens.
  • cache_implementation (str, opcional) — Implementación del método de caché para una generación más rápida cuando use_vllm está establecido en False.

Parámetros que controlan la aceleración de la generación impulsada por vLLM

  • use_vllm (bool, opcional, valor predeterminado False) — Si se usa vLLM para generar completions. Si se establece en True, el trainer usará vLLM para la generación en lugar del método predeterminado model.generate(). Requiere que vllm esté instalado.
  • vllm_mode (str, opcional, por defecto "colocate") — Modo a usar para la integración de vLLM cuando use_vllm está establecido en True. Debe ser uno de "server" o "colocate".
    • "server": El trainer enviará solicitudes de generación a un servidor vLLM separado. Asegúrate de que un servidor vLLM esté en ejecución (inícialo con vllm serve).
    • "colocate": vLLM se ejecutará en el mismo proceso y compartirá las GPU de entrenamiento. Esto evita la necesidad de un servidor separado, pero puede provocar una contención de recursos con el entrenamiento.
  • vllm_model_impl (str, opcional, valor predeterminado "vllm") — Implementación del modelo a usar para vLLM. Debe ser "transformers" o "vllm". "transformers": usa el backend transformers para la implementación del modelo. "vllm": usa la biblioteca vllm para la implementación del modelo.
  • vllm_enable_sleep_mode (bool, opcional, valor predeterminado False) — Activa el modo de suspensión de vLLM para descargar los pesos y la caché durante el paso del optimizador. Mantiene bajo el uso de memoria de GPU, pero despertar el motor añade latencia de transferencia entre el host y el dispositivo.
  • vllm_structured_outputs_regex (str, opcional) — Expresión regular para las salidas estructuradas de vLLM. Si es None (valor predeterminado), las salidas estructuradas están deshabilitadas.

Parámetros que controlan el servidor de vLLM (solo se usan cuando `vllm_mode` es `"server"`)

  • vllm_server_base_url (str, opcional) — URL base del servidor vLLM (p. ej., "http://localhost:8000"). Si se proporciona, vllm_server_host y vllm_server_port se ignoran.
  • vllm_server_host (str, opcional, valor predeterminado "0.0.0.0") — Host del servidor de vLLM al que conectarse. Se ignora si se proporciona vllm_server_base_url.
  • vllm_server_port (int, opcional, valor predeterminado 8000) — Puerto del servidor vLLM al que conectarse. Se ignora si se proporciona vllm_server_base_url.
  • vllm_server_timeout (float, opcional, valor predeterminado 240.0) — Duración total del tiempo de espera, en segundos, para que el servidor vLLM esté en funcionamiento. Si el servidor no está en funcionamiento después del tiempo de espera, se lanza un ConnectionError.
  • vllm_group_port (int, opcional, valor predeterminado 51216) — Número de puerto para el grupo de actualización de pesos. Se utiliza para comunicarse con el servidor de vLLM. A menos que el puerto esté ocupado, no es necesario cambiarlo.

Parámetros que controlan la ejecución de vLLM colocada (solo se usan cuando `vllm_mode` es `"colocate"`)

  • vllm_gpu_memory_utilization (float, opcional, valor predeterminado 0.3) — Controla la utilización de la memoria de GPU para vLLM. Esta configuración solo se aplica cuando vllm_mode está establecido en "colocate". Si estás usando vllm_mode="server", este parámetro debe pasarse por separado al iniciar el servidor de vLLM mediante la bandera --vllm_gpu_memory_utilization.
  • vllm_max_model_length (int, opcional) — Ventana de contexto para vLLM. Establézcala al menos en la longitud máxima de los prompts del conjunto de datos más max_completion_length; si se omite, se infiere desde la configuración del modelo.
  • vllm_tensor_parallel_size (int, opcional, valor predeterminado 1) — Controla el tamaño de paralelismo de tensores para vLLM. Esta configuración solo se aplica cuando vllm_mode está establecido en "colocate". Si está utilizando vllm_mode="server", este parámetro debe pasarse por separado al iniciar el servidor de vLLM mediante la bandera --vllm_tensor_parallel_size.

Parámetros que controlan el entrenamiento

  • beta (float, opcional, valor predeterminado 0.05) — Coeficiente KL. Si es 0.0, el modelo de referencia no se carga, lo que reduce el uso de memoria y mejora la velocidad de entrenamiento.
  • num_iterations (int, opcional, valor predeterminado 1) — Número de iteraciones por lote (denotado como μ en el algoritmo).
  • epsilon (float, opcional, valor predeterminado 0.2) — Valor para el recorte.
  • epsilon_high (float, opcional) — Valor superior de epsilon para el recorte. Si no se especifica, toma por defecto el mismo valor que el límite inferior especificado en el argumento epsilon. El artículo DAPO recomienda 0.28.
  • reward_weights (list[float], opcional) — Pesos para cada función de recompensa. Debe coincidir con el número de funciones de recompensa. Si es None, todas las recompensas se ponderan por igual con un peso de 1.0.
  • normalize_advantages (bool, opcional, valor predeterminado False) — Si se normalizan las ventajas. La normalización se realiza por lote de generación para tener una media de 0.0 y una desviación estándar de 1.0.
  • reward_clip_range (tuple[float, float], opcional) — Rango de recorte para las recompensas como (mín, máx). Si es None, no se aplica recorte.
  • mask_truncated_completions (bool, opcional, valor predeterminado False) — Cuando está habilitado, las completas truncadas se excluyen del cálculo de la pérdida, evitando que se penalicen incorrectamente y se introduzca ruido durante el entrenamiento. Según el DAPO paper, esta es una buena práctica para la estabilidad del entrenamiento.
  • sync_ref_model (bool, opcional, valor predeterminado False) — Si se sincroniza el modelo de referencia con el modelo activo cada ref_model_sync_steps pasos, utilizando el parámetro ref_model_mixup_alpha. Esta sincronización proviene del artículo TR-DPO.
  • ref_model_mixup_alpha (float, opcional, valor predeterminado 0.6) — parámetro α del artículo TR-DPO, que controla la mezcla entre la política actual y la política de referencia anterior durante las actualizaciones. La política de referencia se actualiza según la ecuación: π_ref = α * π_θ + (1 - α) * π_ref_prev. Para usar este parámetro, debe establecer sync_ref_model=True.
  • ref_model_sync_steps (int, opcional, valor predeterminado 512) — parámetro τ del artículo TR-DPO, que determina la frecuencia con la que la política actual se sincroniza con la política de referencia. Para usar este parámetro, debes establecer sync_ref_model=True.

Parámetros que controlan el registro

  • log_completions (bool, opcional, valor predeterminado False) — Indica si se debe registrar una muestra de pares (prompt, completion) cada logging_steps pasos. Si rich está instalado, imprime la muestra. Si el registro de wandb y/o trackio está habilitado, lo registra en wandb y/o trackio.
  • log_multimodal (bool, opcional, valor predeterminado True) — Si se registran o no los contenidos multimodales (imágenes, vídeos, etc.) junto con las completaciones. Desactive esta opción para reducir el tamaño del registro al usar datos multimodales de alta resolución.
  • num_completions_to_print (int, opcional) — Número de completions que se imprimen con rich. Si es None, se registran todas las completions.
  • log_unique_prompts (bool, opcional, valor predeterminado False) — Si se registran los prompts únicos. Si es True, solo se registran los prompts únicos. Si es False, se registran todos los prompts.

Parámetros que controlan la aceleración de la generación mediante el lotes continuo de transformers

  • use_transformers_continuous_batching (bool, opcional, valor predeterminado False) — Si se debe utilizar el motor de lotes continuos de transformers para generar completados. Requiere transformers>=5.8.0.
  • transformers_continuous_batching_config (dict, opcional) — Argumentos de palabra clave para ContinuousBatchingConfig.

Parámetros obsoletos

  • use_transformers_paged —

    El parámetro use_transformers_paged está obsoleto y se eliminará en la versión v2.0.0. Utilice use_transformers_continuous_batching en su lugar.

Clase de configuración para RLOOTrainer.

Esta clase incluye solo los parámetros específicos para el entrenamiento RLOO. Para obtener la lista completa de argumentos de entrenamiento, consulte la documentación de TrainingArguments. Tenga en cuenta que los valores predeterminados de esta clase pueden diferir de los de TrainingArguments.

Con HfArgumentParser podemos convertir esta clase en argumentos de argparse que se pueden especificar en la línea de comandos.

Estos parámetros tienen valores predeterminados diferentes de TrainingArguments:

  • logging_steps: El valor predeterminado es 10 en lugar de 500.
  • gradient_checkpointing: El valor predeterminado es True en lugar de False.
  • bf16: Por defecto, es True si fp16 no está establecido, en lugar de False.
  • learning_rate: El valor predeterminado es 1e-6 en lugar de 5e-5.

Referencias

  1. Artículo de RLOO
  2. Artículo Volver a los básicos: Revisando la optimización de estilo REINFORCE para el aprendizaje a partir de la retroalimentación humana en LLMs
  3. Artículo - REINFORCE++: Un enfoque simple y eficiente para alinear modelos de lenguaje grandes
  4. Publicación en el blog - Devolver el RL al RLHF
  5. Publicación en el blog - Desentrañando RLHF y sus variantes: avances e insights de ingeniería práctica
  6. Youtube - RLOO: una optimización rentable para aprender de la retroalimentación humana en LLMs

Guía de migración desde la implementación anterior (0.21 y versiones anteriores)

Con la publicación de la versión 0.22.0, hemos rediseñado el RLOOTrainer para alinearlo mejor con otros entrenadores en línea de la biblioteca, como GRPOTrainer. Esta nueva implementación introduce varios cambios en los parámetros de configuración y en la estructura general del entrenador. A continuación se presenta un resumen de los cambios clave para RLOOConfig:

TRL ≤ 0.21.xTRL ≥ 0.22.0
rloo_krenombrado a num_generations
cliprangerenombrado a epsilon
kl_coefrenombrado a beta
exp_namerenombrado a run_name. Use run_name = f"{exp_name}__{seed}__{int(time.time())}" para replicar el comportamiento anterior
normalize_rewardrenombrado a normalize_advantages. Nota: esto siempre normalizaba las ventajas (a pesar del nombre antiguo)
num_ppo_epochsrenombrado a num_iterations (predeterminado: 1)
token_level_kleliminado – KL ahora se calcula solo a nivel de secuencia
dataset_num_proceliminado – no se estaba utilizando
num_mini_batchesrenombrado a steps_per_generation
total_episodesuse max_steps=total_episodes / gradient_accumulation_steps en su lugar
local_rollout_forward_batch_sizeeliminado – ahora se establece automáticamente en per_device_train_batch_size (o per_device_eval_batch_size durante la evaluación)
num_sample_generationseliminado – use logging_steps para controlar la frecuencia de registro de la generación
response_lengthrenombrado a max_completion_length (predeterminado: 512)
stop_tokeneliminado
stop_token_ideliminado – usa processing_class.eos_token_id en su lugar
missing_eos_penaltyeliminado – replicar con una función de recompensa personalizada que compruebe si eos_token_id está en completion_ids

A continuación se presenta un resumen de los cambios clave para RLOOTrainer:

TRL ≤ 0.21.xTRL ≥ 0.22.0
configrenombrado a args
reward_modelrenombrado a reward_funcs, que ahora admite tanto modelos de recompensa como funciones de recompensa personalizadas
policyrenombrado a model
ref_policyeliminado – el modelo de referencia ahora se crea automáticamente a partir de model
data_collatoreliminado
Update on GitHub