En el módulo 6 abrimos el RLHF por dentro y vimos por qué PPO (Proximal Policy Optimization, el algoritmo de RL que optimiza la política sin alejarse demasiado de la referencia) es potente pero caro: en memoria conviven cuatro modelos a la vez — la política que se entrena, la referencia congelada que ancla el KL, el modelo de recompensa que puntúa cada respuesta, y el crítico (critic, la red de valor que estima cuánta recompensa futura vale un estado). Cuatro copias del tamaño del modelo, un bucle de RL delicado de estabilizar, y un pipeline previo entero para entrenar el reward model. Funciona — así se alineó la primera generación de asistentes — pero es un lujo que pocos equipos pueden pagar. Este módulo es la historia de cómo la comunidad fue borrando piezas de esa maquinaria, una por una, hasta llegar al método que hizo económicamente viable entrenar razonamiento a gran escala.

La tesis del módulo

Cada método post-PPO borra una pieza cara del RLHF. DPO borra el bucle de RL y el modelo de recompensa, convirtiendo las preferencias en una pérdida supervisada. GRPO borra el crítico, estimando la ventaja al comparar un grupo de respuestas entre sí. Y esa simplificación no fue cosmética: es exactamente lo que hizo económicamente viable entrenar razonamiento a gran escala.

El punto de partida: qué piezas tiene PPO y cuánto cuestan

Antes de borrar nada, conviene tener claro qué hay sobre la mesa. Un paso de PPO-RLHF necesita, en memoria y en cómputo:

La política — el modelo que se entrena. Inevitable.
La referencia — copia congelada de la política inicial. Sirve para el término KL (Kullback-Leibler, una medida de cuánto se aleja una distribución de otra), que castiga que la política se desvíe demasiado y empiece a decir tonterías para engañar a la recompensa.
El modelo de recompensa — otra red, entrenada aparte sobre pares de preferencia, que asigna un número a cada respuesta.
El crítico — una red de valor que estima, en cada token, cuánta recompensa se espera de aquí en adelante. Sirve para calcular la ventaja (advantage, cuánto mejor o peor salió una acción respecto a lo esperado) y reducir la varianza del gradiente.

La familia post-PPO es, literalmente, la historia de ir tachando esa lista. DPO tacha los puntos 3 y 4 y el bucle de RL entero. GRPO tacha el punto 4. RLAIF no toca la arquitectura, pero abarata la pieza más lenta de todas: el humano que etiqueta.

DPO: la política óptima ya tiene forma cerrada

DPO (Direct Preference Optimization, optimización directa de preferencias) parte de una observación que suena a truco de magia y es álgebra. El problema que PPO resuelve iterando — maximizar la recompensa con una penalización KL contra la referencia — tiene una solución analítica en forma cerrada. Es decir: dado un modelo de recompensa, ya se sabe exactamente cuál es la política óptima, sin necesidad de correr RL para buscarla. Esa política óptima es:

π*(y | x) = (1 / Z(x)) · π_ref(y | x) · exp( r(x,y) / β )

donde π_ref es la referencia, r(x,y) la recompensa, β la fuerza de la penalización KL, y Z(x) una constante de normalización (la función de partición) que solo depende del prompt. El paso genial de DPO es invertir esa ecuación: despejar la recompensa en función de la política, r(x,y) = β · log( π(y|x) / π_ref(y|x) ) + β · log Z(x), y meter ese despeje dentro del modelo de preferencia de Bradley-Terry (el modelo estadístico que dice cuán probable es que un humano prefiera una respuesta sobre otra). Al hacerlo, Z(x) se cancela — aparece en los dos lados de la resta — y queda una pérdida que depende solo de la política y de la referencia, sin ningún modelo de recompensa a la vista.

De ahí el subtítulo del paper original: “tu modelo de lenguaje es, en secreto, un modelo de recompensa”. La recompensa nunca desapareció; quedó implícita en la razón de log-probabilidades entre la política y la referencia.

La pérdida, en palabras. Para cada par de preferencia — un prompt x, una respuesta elegida y_w (winner) y una rechazada y_l (loser) —, DPO empuja a la política a subir la probabilidad de y_w y bajar la de y_l, relativas a lo que la referencia ya les daba. La cuenta interna es una sigmoide sobre la diferencia de dos “recompensas implícitas”: β por el log-ratio de la elegida menos β por el log-ratio de la rechazada. Nada más. Es una pérdida supervisada de clasificación binaria, que se entrena con el mismo bucle que un fine-tuning normal.

Qué gana. Se van el reward model, el crítico y el bucle de RL. Quedan dos modelos en memoria (política y referencia) y un entrenamiento estable, reproducible y barato, sin los hiperparámetros temperamentales de PPO.

Qué límites tiene. DPO necesita datos de pares de preferencia ya construidos — no aprende de una recompensa que se calcula al vuelo. Y es off-policy (fuera de política): entrena sobre respuestas que generó otro modelo, no las que produce la política actual mientras aprende. Eso lo hace más simple, pero también menos capaz de explorar comportamientos nuevos que no estuvieran ya en los datos. Para el cómo práctico — preparar el dataset, elegir β, evitar que la política colapse — el módulo dedicado es DPO en la práctica; aquí nos quedamos en la teoría comparada.

Las variantes de DPO, en una tabla

DPO abrió una familia. Cada variante corrige algo del original a alto nivel:

Variante	Qué corrige de DPO	Idea a alto nivel
IPO (Identity PO)	DPO puede sobreajustarse a las preferencias y saturar	Reemplaza la sigmoide por una pérdida cuadrática con margen, más robusta al ruido de las etiquetas
KTO (Kahneman-Tversky Opt.)	DPO exige pares (elegida vs rechazada)	Aprende de ejemplos sueltos etiquetados solo como “bueno” o “malo”, sin necesidad de emparejar
ORPO (Odds Ratio PO)	DPO todavía necesita la referencia y un SFT previo	Fusiona el SFT y la preferencia en una sola pérdida sin referencia: un modelo, un dataset, una etapa

Ojo: menos piezas no es gratis. ORPO borra la referencia y el SFT previo, pero a cambio es más sensible a los hiperparámetros y converge más lento. La regla se repite en toda la familia: cada modelo que borras te ahorra memoria y te quita una red de seguridad. No hay almuerzo gratis, solo trueques distintos.

RLAIF: borrar al humano de la etiqueta

Las etiquetas de preferencia son el cuello de botella más caro y lento del RLHF: gente puntuando respuestas, una por una. RLAIF (RL from AI Feedback, RL a partir de retroalimentación de IA) reemplaza — o complementa — a ese humano con un LLM juez: otro modelo que compara pares de respuestas y decide cuál es mejor, produciendo las etiquetas de preferencia a escala y a bajo costo.

La versión más estructurada es Constitutional AI (IA constitucional, de Anthropic): en vez de que el juez decida por gusto, se le da una constitución — una lista corta de principios escritos por humanos (“prefiere la respuesta más útil y menos dañina”, etc.) — y el modelo critica y reordena las respuestas según esos principios. El único aporte humano son las diez o veinte reglas; el resto del etiquetado lo hace la IA.

Qué gana. Escala y costo: etiquetar con un LLM es órdenes de magnitud más barato y rápido que con anotadores. Los estudios iniciales reportan que RLAIF rinde a la par de RLHF en varios benchmarks.

Qué arriesga. El juez hereda los sesgos y los puntos ciegos del modelo que lo genera — si el juez tiene una debilidad, la escribe en cada etiqueta y la política la absorbe. Y abre la puerta a un bucle de retroalimentación donde el modelo se entrena sobre su propio criterio, amplificando manías en vez de corregirlas. RLAIF es ortogonal a DPO y GRPO: es una fuente de etiquetas, no un algoritmo de optimización, y se puede combinar con cualquiera de los dos.

GRPO: borrar el crítico comparando un grupo

Llegamos al corazón del módulo. GRPO (Group Relative Policy Optimization, optimización de política relativa al grupo), introducido por DeepSeek en el trabajo de DeepSeekMath y llevado a la fama por DeepSeek-R1, ataca la última pieza cara que DPO no toca: el crítico.

Recordemos para qué servía el crítico en PPO: estimar la ventaja, o sea decidir si una respuesta salió mejor o peor de lo esperado. Para eso hacía falta una red de valor entrenada en paralelo, del tamaño del modelo. La pregunta de GRPO es directa: ¿y si en vez de una red que estima el promedio esperado, calculo el promedio de verdad, ahí mismo?

El mecanismo:

Para un mismo prompt, se muestrea un grupo de N respuestas (típicamente 8, 16, 64) desde la política actual.
Se calcula la recompensa de cada una. En razonamiento esto suele ser una recompensa verificable: ¿la respuesta al problema de matemáticas es correcta? ¿el código pasa los tests? Un número objetivo, sin red neuronal de por medio.
La ventaja de cada respuesta se define como su recompensa normalizada dentro del grupo: se le resta la media del grupo y se divide por la desviación estándar del grupo. Una respuesta mejor que el promedio de sus hermanas obtiene ventaja positiva; una peor, negativa.
Se actualiza la política con esas ventajas, dentro del mismo marco de recorte (clipping) y penalización KL que PPO.

El grupo es la línea base (baseline). El promedio de las respuestas hermanas cumple exactamente el papel que antes cumplía el crítico — decir “esto es lo esperado” — pero calculado, no estimado por una red aparte. Se elimina la red de valor entera: menos memoria, menos cómputo, un modelo menos que estabilizar.

           GRPO — VENTAJA RELATIVA AL GRUPO

              ┌─────────────────┐
   prompt ──► │ política actual │
              └────────┬────────┘
                       │ muestrea N respuestas
        ┌───────┬──────┴──┬────────┬───────┐
        ▼       ▼         ▼        ▼       ▼
     ┌─────┐ ┌─────┐   ┌─────┐  ┌─────┐ ┌─────┐
     │ y_1 │ │ y_2 │   │ y_3 │  │ ... │ │ y_N │
     └──┬──┘ └──┬──┘   └──┬──┘  └──┬──┘ └──┬──┘
        │r_1    │r_2      │r_3     │       │r_N
        ▼       ▼         ▼        ▼       ▼
     ┌────────────────────────────────────────┐
     │   recompensa verificable de cada y_i   │
     └────────────────────┬───────────────────┘
                          │ normaliza dentro del grupo:
                          │ A_i = (r_i - media) / desv
                          ▼
              ┌────────────────────────┐
              │  ventaja por grupo A_i │
              └───────────┬────────────┘
                          │ sube prob de las buenas,
                          │ baja la de las malas
                          ▼
              ┌────────────────────────┐
              │  actualiza la política │
              └────────────────────────┘

Cuidado: GRPO no es magia gratis. El costo se movió, no desapareció. Muestrear N respuestas por prompt multiplica el cómputo de generación por N — con grupos de 64, eso es mucho. Lo que GRPO ahorra es memoria (fuera la red de valor) y complejidad (una pieza menos que entrenar y estabilizar), a cambio de más inferencia. Para modelos grandes ese trueque suele convenir, pero no es “más barato en todo”.

Por qué GRPO destrabó el razonamiento

Aquí está la conexión que da título al curso. Entrenar razonamiento con PPO tropezaba con dos muros: el crítico costaba una copia entera del modelo, y el modelo de recompensa neuronal era hackeable — con suficiente entrenamiento, la política encontraba un exploit y engañaba a la recompensa (reward hacking) en vez de razonar mejor.

GRPO derriba los dos muros a la vez. Sin crítico, cabe entrenar modelos grandes. Y como la ventaja se calcula sobre recompensas verificables (correcto/incorrecto, tests que pasan o no), no hay red neuronal que hackear: la recompensa es una regla, no un modelo. DeepSeek-R1 mostró que con esta receta — GRPO + recompensa verificable, sin trayectorias de razonamiento etiquetadas por humanos — emergen solos comportamientos como la autoverificación y el replanteo. Ese es el tema del módulo 10.

Código: DPO y GRPO con TRL

La librería TRL (Transformer Reinforcement Learning, de Hugging Face) implementa los dos. El patrón es casi idéntico al de un fine-tuning normal: un Trainer, un dataset y una config. La diferencia está en qué come cada uno.

# DPOTrainer: aprende de PARES de preferencia (chosen / rejected).
# No hay reward model ni bucle de RL: es una pérdida supervisada.
from trl import DPOTrainer, DPOConfig

dpo_args = DPOConfig(
    output_dir="./dpo_out",
    beta=0.1,                 # fuerza de la penalización KL vs. referencia
    learning_rate=5e-6,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
)

trainer = DPOTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    args=dpo_args,
    train_dataset=dpo_ds,     # columnas: prompt, chosen, rejected
)
trainer.train()

En GRPO no hay pares: hay una función de recompensa que puntúa cada respuesta generada. TRL admite una o varias reward_funcs; si pasas varias, la recompensa total es su suma (o la suma ponderada si defines reward_weights en la config). La firma de una función de recompensa recibe completions y **kwargs — el **kwargs es obligatorio para que el trainer pueda pasarle columnas extra del dataset.

# GRPOTrainer: muestrea un GRUPO de respuestas por prompt y las puntúa
# con reward_funcs. La ventaja se normaliza dentro del grupo; no hay
# crítico ni pares de preferencia.
from datasets import load_dataset
from trl import GRPOTrainer, GRPOConfig

dataset = load_dataset("trl-lib/tldr", split="train")  # columna: prompt

def recompensa_largo(completions, **kwargs):
    """Recompensa ilustrativa: premia respuestas de largo moderado.
    En razonamiento real, aquí iría una recompensa VERIFICABLE
    (respuesta correcta, tests que pasan), no una heurística de forma."""
    objetivo = 200
    return [-abs(len(c) - objetivo) for c in completions]

args = GRPOConfig(
    output_dir="./grpo_out",
    num_generations=8,        # tamaño del grupo N por prompt
    per_device_train_batch_size=8,
)

trainer = GRPOTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    reward_funcs=recompensa_largo,
    args=args,
    train_dataset=dataset,
)
trainer.train()

Ojo: el bloque anterior es un esbozo ilustrativo — la firma de reward_funcs, los nombres num_generations y GRPOConfig corresponden a la API vigente de TRL (doc de GRPO y funciones de recompensa), pero TRL evoluciona rápido: fija la versión y confirma la firma contra la doc de esa versión antes de correrlo. La recompensa_largo es un juguete; su único propósito es mostrar la forma de la función, no un objetivo real.

La tabla que decide cuál usar

Todo el módulo cabe en esta comparación. La columna que importa es la de “cuándo”:

	¿Reward model?	¿Crítico?	On/off-policy	Costo relativo	Cuándo usarlo
PPO	Sí (neuronal)	Sí	On-policy	Alto (4 modelos)	Recompensa densa y neuronal; máximo control; hay presupuesto
DPO	No	No	Off-policy	Bajo (2 modelos)	Tienes pares de preferencia listos; quieres alinear estable y barato
GRPO	No (recompensa directa)	No	On-policy	Medio (2 modelos, +N generaciones)	Recompensa verificable por respuesta; razonamiento, matemáticas, código

Léela así: si ya tienes un dataset de preferencias humanas y solo quieres alinear tono y utilidad, DPO es la ruta más simple. Si tienes una forma objetiva de puntuar cada respuesta — la respuesta al problema es correcta o no —, GRPO aprovecha esa señal y explora on-policy sin crítico. PPO queda para cuando necesitas una recompensa neuronal densa y el control fino que dan sus cuatro piezas, y puedes pagarlo.

Errores comunes

Creer que DPO “hace RL”. DPO no tiene bucle de RL ni muestrea de la política mientras entrena: es una pérdida supervisada sobre pares fijos. Llamarlo RL confunde qué esperar de él (no explora comportamientos nuevos).
Usar DPO sin datos de preferencia. DPO necesita pares chosen/rejected ya construidos. Si solo tienes una recompensa que calculas al vuelo, DPO no aplica; ahí viven PPO o GRPO.
Pensar que GRPO es “PPO barato en todo”. Ahorra memoria (sin crítico), pero multiplica la generación por N. Con grupos grandes el costo de inferencia sube fuerte; el trueque es memoria por cómputo de muestreo.
Aplicar GRPO con recompensa neuronal a gran escala. El punto fuerte de GRPO en razonamiento es la recompensa verificable, que no se puede hackear. Con un reward model neuronal vuelve a aparecer el reward hacking que R1 buscaba evitar.
Tratar RLAIF como un algoritmo. RLAIF es una fuente de etiquetas (juez LLM / constitución), no un optimizador. Se combina con DPO o GRPO; no los reemplaza.
Elegir el método por moda y no por los datos. La pregunta correcta no es “¿cuál es el más nuevo?” sino “¿qué señal de supervisión tengo?”: pares de preferencia → DPO; recompensa verificable → GRPO; recompensa neuronal densa con presupuesto → PPO.

La frase para llevarse

“PPO tenía cuatro modelos en memoria; la familia post-PPO es la historia de tacharlos uno por uno. DPO borró el reward y el crítico volviendo las preferencias una pérdida supervisada; GRPO borró el crítico dejando que un grupo de respuestas se puntúe entre sí. Esa resta no fue estética: fue lo que puso el razonamiento al alcance del presupuesto.”

Qué viene

Módulo 8: por qué un LLM razona. Ya sabemos con qué algoritmo se entrena el razonamiento; falta la pregunta incómoda de qué es “razonar” para un modelo que, por dentro, solo predice el siguiente token. Vamos a ver qué cambia realmente cuando un modelo produce una cadena de pensamiento, por qué pensar más pasos ayuda, y hasta dónde llega la analogía con el razonamiento humano antes de romperse.

Razonamiento y RL — Módulo 7: más allá de PPO — DPO, GRPO y familia