TRL documentation
RLOO Trainer
RLOO Trainer
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.

Generar completiones
En cada paso de entrenamiento, muestreamos un lote de prompts y generamos un conjunto de completaciones para cada prompt (denotado como ).
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
- Para cada una de las secuencias generadas condicionadas en una consulta , calculamos una recompensa escalar utilizando un modelo de recompensa .
- Simultáneamente, estimamos la divergencia de KL entre la política actual y la política de referencia fija a lo largo de la secuencia. La estimación de KL para la secuencia es:
La recompensa final asignada a la secuencia es la siguiente:
donde 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 . Para mantener la penalización coherente con la distribución de muestreo, la KL se define con respecto a esta política:
Equivalentemente, para una secuencia muestreada , la estimación de Monte Carlo es:
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:
y luego la ventaja para cada finalización se calcula como la diferencia entre su recompensa y la línea base:
Cálculo de la pérdida
La pérdida REINFORCE se define simplemente como:
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:
En un entorno totalmente en línea y de un solo paso (predeterminado), 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_grady se incorpora en la recompensa escalar , que se convierte en la ventaja desacoplada .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 , 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 , 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 porreward_weights).reward_std: La desviación estándar de las recompensas sumadas entre funciones (ponderadas porreward_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. (Simask_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 porrouter_aux_loss_coefy se sume a la pérdida. Se registra solo cuando el modelo es un modelo MoE yrouter_aux_loss_coefes distinto de cero.kl: La divergencia KL media entre el modelo y el modelo de referencia, calculada sobre las completaciones generadas. Se registra solo sibetaes 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: . Un valor más alto significa que se recortan más muestras, lo que limita cuánto puede cambiar la política .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: .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: .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: .clip_ratio/high_max: El mayor indicador de recorte por finalización en el límite superior de la región de confianza: .
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.
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 -1Habilita 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_utilizationen 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_modeen 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=localhostyMASTER_PORT=12345para 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 &
waitimport 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.
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ónlog_extra(column: str, values: list)para añadir columnas adicionales a la tabla de completados. Consulte el Ejemplo 6.log_metric: una funciónlog_metric(name: str, value: float)para registrar métricas escalares como gráficos junto akl,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 llamadaground_truth, la función se llamará conground_truthcomo argumento de palabra clave.
La forma más sencilla de cumplir con este requisito es usar
**kwargsen la firma de la función.Dependiendo del formato del conjunto de datos, la entrada variará:
- Para el formato estándar,
promptsycompletionsserán listas de cadenas de texto. - Para el formato conversacional,
promptsycompletionsserán listas de diccionarios de mensajes.
- Para el formato estándar,
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 rewardsPasar 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_completionsConsejos 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
serverycolocate)
Formato de datos
Cada muestra de entrenamiento debe incluir:
prompt: Texto formateado mediante la plantilla de chat del procesadorimage/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
< source >( 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 (
stro PreTrainedModel oPeftModel) — 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 enargs.model_init_kwargs. Sidtypeno se especifica enargs.model_init_kwargs, el valor predeterminado esfloat32. 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.
- 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,
- 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 usandonum_labels=1y los argumentos de palabra clave enargs.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
Nonecuando 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 devuelveNonepara 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_statede 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_datasetes un IterableDataset (por ejemplo, un dataset de streaming),max_stepsdebe 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 quetrain_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_tokencomo valor predeterminado. - reward_processing_classes (PreTrainedTokenizerBase o
list[PreTrainedTokenizerBase], opcional) — Clases de procesamiento correspondientes a las funciones de recompensa especificadas enreward_funcs. Puede ser:- Una única clase de procesamiento: se utiliza cuando
reward_funcscontiene 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 enNone, o si un elemento de la lista correspondiente a un PreTrainedModel esNone, el tokenizador del modelo se carga automáticamente usando from_pretrained. Para los elementos dereward_funcsque son funciones de recompensa personalizadas (no PreTrainedModel), las entradas correspondientes enreward_processing_classesse ignoran.
- Una única clase de procesamiento: se utiliza cuando
- 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 deAdamWen su modelo y un programador dado por get_linear_schedule_with_warmup controlado porargs. - quantization_config (BitsAndBytesConfig, opcional) —
Configuración de cuantización utilizada al cargar el modelo desde un identificador de modelo. Combínala con
peft_configpara 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 esNone, 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
< source >( 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 (
strobool, opcional) — Si es unastr, ruta local a un punto de control guardado por una instancia anterior deTrainer. Si es unbooly es igual aTrue, carga el último punto de control en args.output_dir guardado por una instancia anterior deTrainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí. - trial (
optuna.Trialodict[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.
Guardará el modelo, por lo que podrás recargarlo usando from_pretrained().
Solo se guardará desde el proceso principal.
push_to_hub
< source >( 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 predeterminadoTrue) — Si la función debe devolver el control solo cuando elgit pushhaya terminado. - token (
str, opcional, valor predeterminadoNone) — 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 esargs.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
< source >( 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 (
strodict[str, Any], opcional) — Argumentos de palabra clave para from_pretrained, utilizados cuando el argumentomodeldel RLOOTrainer se proporciona como una cadena de caracteres. El valor derevisiontambién se utiliza al cargar las clases de procesamiento. - trust_remote_code (
bool, opcional, valor predeterminadoFalse) — 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. Establezca0.0para desactivarlo. Falla si se utiliza con un modelo que no es MoE. - disable_dropout (
bool, opcional, valor predeterminadoFalse) — 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 predeterminadoFalse) — 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 enFalse. - num_generations (
int, opcional, por defecto2) — 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 esNone, usa el valor denum_generations. - max_completion_length (
intoNone, opcional, valor predeterminado512) — Longitud máxima de la generación completada. - ds3_gather_for_generation (
bool, opcional, valor predeterminadoTrue) — 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 predeterminadoTrue) — Si se debe barajar el conjunto de datos de entrenamiento. - pad_to_multiple_of (
intostr, 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 esNone, 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 consteps_per_generation. - steps_per_generation (
int, opcional) — Número de pasos por generación. Si esNone, el valor predeterminado esgradient_accumulation_steps. Es mutuamente excluyente congeneration_batch_size. - temperature (
float, opcional, valor predeterminado1.0) — Temperatura para el muestreo. A mayor temperatura, más aleatorias son las completaciones. - top_p (
float, opcional, valor predeterminado1.0) — Flotante que controla la probabilidad acumulada de los tokens superiores a considerar. Debe estar en (0, 1]. Establecerlo en1.0para considerar todos los tokens. - top_k (
int, opcional, valor predeterminado0) — Número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k. Si es0, 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 entre0.0y1.0. Los valores típicos están en el rango0.01-0.2. - generation_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a GenerationConfig (si se usa transformers) o aSamplingParams(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 establecersuppress_tokens,num_beams, etc. Si contiene claves que entran en conflicto con los otros parámetros de generación (comomin_p,top_p, etc.), los sobrescribirán. - chat_template_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a la funciónapply_chat_templateal generar las completaciones. - repetition_penalty (
float, opcional, valor predeterminado1.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.0animan al modelo a usar tokens nuevos, mientras que los valores <1.0animan al modelo a repetir tokens. - cache_implementation (
str, opcional) — Implementación del método de caché para una generación más rápida cuandouse_vllmestá establecido enFalse.
Parámetros que controlan la aceleración de la generación impulsada por vLLM
- use_vllm (
bool, opcional, valor predeterminadoFalse) — Si se usa vLLM para generar completions. Si se establece enTrue, el trainer usará vLLM para la generación en lugar del método predeterminado model.generate(). Requiere quevllmesté instalado. - vllm_mode (
str, opcional, por defecto"colocate") — Modo a usar para la integración de vLLM cuandouse_vllmestá establecido enTrue. 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 convllm 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 backendtransformerspara la implementación del modelo."vllm": usa la bibliotecavllmpara la implementación del modelo. - vllm_enable_sleep_mode (
bool, opcional, valor predeterminadoFalse) — 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 esNone(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_hostyvllm_server_portse ignoran. - vllm_server_host (
str, opcional, valor predeterminado"0.0.0.0") — Host del servidor de vLLM al que conectarse. Se ignora si se proporcionavllm_server_base_url. - vllm_server_port (
int, opcional, valor predeterminado8000) — Puerto del servidor vLLM al que conectarse. Se ignora si se proporcionavllm_server_base_url. - vllm_server_timeout (
float, opcional, valor predeterminado240.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 unConnectionError. - vllm_group_port (
int, opcional, valor predeterminado51216) — 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 predeterminado0.3) — Controla la utilización de la memoria de GPU para vLLM. Esta configuración solo se aplica cuandovllm_modeestá establecido en"colocate". Si estás usandovllm_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ásmax_completion_length; si se omite, se infiere desde la configuración del modelo. - vllm_tensor_parallel_size (
int, opcional, valor predeterminado1) — Controla el tamaño de paralelismo de tensores para vLLM. Esta configuración solo se aplica cuandovllm_modeestá establecido en"colocate". Si está utilizandovllm_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 predeterminado0.05) — Coeficiente KL. Si es0.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 predeterminado1) — Número de iteraciones por lote (denotado como μ en el algoritmo). - epsilon (
float, opcional, valor predeterminado0.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 argumentoepsilon. El artículo DAPO recomienda0.28. - reward_weights (
list[float], opcional) — Pesos para cada función de recompensa. Debe coincidir con el número de funciones de recompensa. Si esNone, todas las recompensas se ponderan por igual con un peso de1.0. - normalize_advantages (
bool, opcional, valor predeterminadoFalse) — Si se normalizan las ventajas. La normalización se realiza por lote de generación para tener una media de0.0y una desviación estándar de1.0. - reward_clip_range (
tuple[float, float], opcional) — Rango de recorte para las recompensas como (mín, máx). Si esNone, no se aplica recorte. - mask_truncated_completions (
bool, opcional, valor predeterminadoFalse) — 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 predeterminadoFalse) — Si se sincroniza el modelo de referencia con el modelo activo cadaref_model_sync_stepspasos, utilizando el parámetroref_model_mixup_alpha. Esta sincronización proviene del artículo TR-DPO. - ref_model_mixup_alpha (
float, opcional, valor predeterminado0.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 establecersync_ref_model=True. - ref_model_sync_steps (
int, opcional, valor predeterminado512) — 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 establecersync_ref_model=True.
Parámetros que controlan el registro
- log_completions (
bool, opcional, valor predeterminadoFalse) — Indica si se debe registrar una muestra de pares (prompt, completion) cadalogging_stepspasos. Sirichestá instalado, imprime la muestra. Si el registro dewandby/otrackioestá habilitado, lo registra enwandby/otrackio. - log_multimodal (
bool, opcional, valor predeterminadoTrue) — 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 conrich. Si esNone, se registran todas las completions. - log_unique_prompts (
bool, opcional, valor predeterminadoFalse) — Si se registran los prompts únicos. Si esTrue, solo se registran los prompts únicos. Si esFalse, 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 predeterminadoFalse) — Si se debe utilizar el motor de lotes continuos de transformers para generar completados. Requieretransformers>=5.8.0. - transformers_continuous_batching_config (
dict, opcional) — Argumentos de palabra clave paraContinuousBatchingConfig.
Parámetros obsoletos
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 es10en lugar de500.gradient_checkpointing: El valor predeterminado esTrueen lugar deFalse.bf16: Por defecto, esTruesifp16no está establecido, en lugar deFalse.learning_rate: El valor predeterminado es1e-6en lugar de5e-5.
Referencias
- Artículo de RLOO
- 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
- Artículo - REINFORCE++: Un enfoque simple y eficiente para alinear modelos de lenguaje grandes
- Publicación en el blog - Devolver el RL al RLHF
- Publicación en el blog - Desentrañando RLHF y sus variantes: avances e insights de ingeniería práctica
- 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.x | TRL ≥ 0.22.0 |
|---|---|
rloo_k | renombrado a num_generations |
cliprange | renombrado a epsilon |
kl_coef | renombrado a beta |
exp_name | renombrado a run_name. Use run_name = f"{exp_name}__{seed}__{int(time.time())}" para replicar el comportamiento anterior |
normalize_reward | renombrado a normalize_advantages. Nota: esto siempre normalizaba las ventajas (a pesar del nombre antiguo) |
num_ppo_epochs | renombrado a num_iterations (predeterminado: 1) |
token_level_kl | eliminado – KL ahora se calcula solo a nivel de secuencia |
dataset_num_proc | eliminado – no se estaba utilizando |
num_mini_batches | renombrado a steps_per_generation |
total_episodes | use max_steps=total_episodes / gradient_accumulation_steps en su lugar |
local_rollout_forward_batch_size | eliminado – ahora se establece automáticamente en per_device_train_batch_size (o per_device_eval_batch_size durante la evaluación) |
num_sample_generations | eliminado – use logging_steps para controlar la frecuencia de registro de la generación |
response_length | renombrado a max_completion_length (predeterminado: 512) |
stop_token | eliminado |
stop_token_id | eliminado – usa processing_class.eos_token_id en su lugar |
missing_eos_penalty | eliminado – 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.x | TRL ≥ 0.22.0 |
|---|---|
config | renombrado a args |
reward_model | renombrado a reward_funcs, que ahora admite tanto modelos de recompensa como funciones de recompensa personalizadas |
policy | renombrado a model |
ref_policy | eliminado – el modelo de referencia ahora se crea automáticamente a partir de model |
data_collator | eliminado |