En el módulo 9 vimos que un modelo puede pensar más en el momento de responder: gastar más cómputo en la inferencia, generar cadenas de razonamiento más largas y así resolver problemas que de un tirón no salían. Pero dejamos una pregunta abierta y grande: ¿de dónde salió la capacidad de generar esas cadenas? Un modelo base no sabe, por sí solo, que reflexionar largo le conviene. Este módulo responde cómo se entrena esa capacidad — y la respuesta es menos intuitiva de lo que parece. No le mostramos al modelo miles de ejemplos de “así se piensa un problema”. Le damos una sola cosa: una señal de si su respuesta final fue correcta. Y con GRPO — el algoritmo de RL que vimos en el módulo 7 — más una recompensa que se puede verificar, el razonamiento largo emerge solo. Este es el módulo insignia del bloque de razonamiento: acá se juntan todas las piezas.

La tesis del módulo

No le enseñas al modelo CÓMO razonar dándole cadenas de ejemplo para que las imite. Le das una señal de si la respuesta final es correcta y lo dejas descubrir por RL, por prueba y error, las cadenas de pensamiento que llevan ahí. Con una recompensa verificable — no un modelo de recompensa aprendido, sino un verificador objetivo — el razonamiento largo aparece por su cuenta, no porque se lo enseñaste, sino porque funciona: las cadenas largas suben la tasa de aciertos, y RL refuerza lo que sube la recompensa.

RLVR: la pieza central

Todo el módulo gira alrededor de una idea con nombre propio: RLVR (Reinforcement Learning with Verifiable Rewards, aprendizaje por refuerzo con recompensas verificables). La formalizó el equipo de Tulu 3 (Allen AI) y es lo que hace posible entrenar razonamiento sin caer en las trampas del RLHF clásico.

Recordemos el problema del RLHF que vimos en RLHF y alineamiento: la recompensa la produce un reward model (modelo de recompensa: una red neuronal entrenada para imitar el juicio humano de “esta respuesta es mejor que esta otra”). Ese reward model es una aproximación, y como toda aproximación aprendida, es hackeable: el modelo de política puede encontrar respuestas que engañan al reward model sin ser realmente buenas. Es el reward hacking que veremos a fondo en el módulo 11.

RLVR cambia la fuente de la recompensa. En vez de un reward model aprendido, usa un verificador determinista y objetivo:

Matemáticas. ¿La respuesta final, extraída de la salida del modelo, coincide con la respuesta conocida del problema? Se compara numéricamente. Recompensa 1 si es correcta, 0 si no.
Código. ¿El código que generó pasa la batería de tests? Se ejecuta y se cuenta. Verde: recompensa. Rojo: nada.
Formato. ¿La salida respeta la estructura pedida — por ejemplo, el razonamiento entre unas etiquetas y la respuesta entre otras? Se valida con una expresión regular.

La diferencia es enorme y conviene decirla despacio. Un reward model opina; un verificador comprueba. El reward model puede ser engañado porque su juicio es estadístico y aproximado. Un verificador de “¿2+2 da 4?” no tiene margen para ser engañado: la respuesta es correcta o no lo es, y no hay adulación, longitud ni tono que cambien eso. Esa es la razón profunda por la que RLVR entrena razonamiento tan bien: la señal es honesta.

Ojo: RLVR solo existe donde hay un verificador barato y confiable. Matemáticas, código, lógica formal, problemas con respuesta única: ahí brilla. “Escribe un ensayo conmovedor sobre el otoño” no tiene verificador — no hay función que devuelva 1 o 0 sin opinar. Por eso el razonamiento entrenado con RLVR es fortísimo en dominios verificables y no se traslada gratis a los que no lo son. Volveremos a este límite en los errores comunes.

El enfoque DeepSeek-R1

El trabajo que convirtió esta idea en un modelo público y verificable es DeepSeek-R1 (paper DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning, arXiv, enero de 2025; publicado en Nature en septiembre de 2025). Vale la pena contarlo con cuidado porque tiene dos modelos adentro, y la diferencia entre ellos es toda la lección.

R1-Zero: RL puro, sin SFT

El primer experimento, DeepSeek-R1-Zero, es el más radical y el más revelador. Tomaron el modelo base (DeepSeek-V3-Base) y le aplicaron RL directo con GRPO — sin ninguna fase de SFT previa. Nada de mostrarle ejemplos de razonamiento primero. Solo el modelo base crudo y dos recompensas verificables:

Recompensa de correctitud (accuracy reward): ¿la respuesta final es correcta? Verificada, no opinada.
Recompensa de formato (format reward): ¿puso su razonamiento entre etiquetas <think>...</think> y su respuesta entre <answer>...</answer>?

Y funcionó. Sin que nadie le enseñara a razonar, R1-Zero aprendió a generar cadenas de pensamiento cada vez más largas por su cuenta. A medida que avanzaba el entrenamiento, el modelo descubrió — porque subía la recompensa — que pensar más pasos antes de responder le hacía acertar más. La longitud de sus respuestas creció sola, sin ningún término en la recompensa que premiara la longitud. Emergió.

El fenómeno más citado del paper es el “aha moment” (momento de “ajá”). En algún punto del entrenamiento, en las trazas de razonamiento del modelo, los investigadores encontraron que R1-Zero empezaba a reevaluar su propio enfoque a mitad de camino: frases del tipo “espera, revisemos esto de nuevo”, donde el modelo se detiene, cuestiona un paso anterior y lo corrige. Nadie le enseñó a auto-verificarse ni a reflexionar. Apareció como estrategia porque reflexionar sube la tasa de aciertos, y RL refuerza lo que sube la recompensa. Es la evidencia más limpia de la tesis del módulo: no enseñas el comportamiento, incentivas el resultado y el comportamiento emerge.

Cuidado: R1-Zero no era un modelo listo para usar. Sus cadenas eran potentes pero desprolijas: mezclaba idiomas en el mismo razonamiento (saltaba entre inglés y chino), tenía problemas de legibilidad y a veces las trazas eran caóticas de leer. RL puro optimizó lo único que se le pidió — acertar — y todo lo demás quedó a la deriva. La recompensa no premiaba “razona de forma legible en un solo idioma”, así que el modelo no tenía por qué hacerlo.

R1 completo: el cold start y el pipeline multi-etapa

Para arreglar esas patologías sin perder la capacidad de razonar, DeepSeek construyó el modelo completo, DeepSeek-R1, con un pipeline de varias etapas. La pieza nueva es el cold start (arranque en frío): una pequeña fase de SFT con datos de razonamiento de buena calidad, ANTES del RL.

El nombre “arranque en frío” viene de que el RL, empezando desde el modelo base crudo, arranca inestable — como un motor en frío. Unos pocos miles de ejemplos de cadenas de pensamiento largas, limpias y legibles, usados para un SFT breve, le dan al modelo un punto de partida decente: ya sabe cómo se ve una buena traza (un idioma, bien estructurada) antes de que el RL empiece a optimizar la correctitud. El cold start no le enseña a razonar — eso lo sigue haciendo el RL — le enseña el formato y la legibilidad para que el RL parta de un lugar civilizado.

El pipeline completo, a alto nivel y siendo honestos, tiene cuatro etapas:

Cold start SFT. Un SFT corto sobre miles de cadenas de razonamiento largas y legibles, para arreglar legibilidad y arranque.
RL de razonamiento. GRPO con recompensa de correctitud + formato, igual que R1-Zero, más una recompensa de consistencia de idioma (para castigar la mezcla de idiomas que sufría R1-Zero).
Rejection sampling + SFT. Se generan muchas respuestas con el modelo de la etapa 2, se filtran las correctas y bien formadas (rejection sampling: quedarse solo con las muestras que pasan el filtro), se mezclan con datos de capacidades generales (escritura, preguntas y respuestas) y se hace un nuevo SFT. Aquí el modelo recupera habilidades no-razonamiento que el RL había dejado de lado.
RL final. Una segunda fase de RL que suma señales de utilidad e inocuidad (helpfulness, harmlessness) a las de razonamiento, para pulir el modelo de cara al usuario.

La lección de arquitectura: R1-Zero prueba que el razonamiento emerge de RL puro — ese es el hallazgo científico. R1 completo prueba que para un producto usable hay que envolver ese RL en SFT antes (cold start) y después (rejection sampling), más una pasada final de alineamiento. Lo primero es la demostración; lo segundo es la ingeniería.

Diseño de recompensas para razonamiento

El corazón práctico de todo esto es cómo diseñas las recompensas. Para razonamiento se usan dos, y hay una regla dura sobre lo que no se usa.

Tipo de recompensa	Qué mide	Cómo se calcula	Hackeable
Correctitud	¿La respuesta final es correcta?	Verificador determinista (comparación numérica, tests que corren)	No
Formato	¿Usó las etiquetas de razonamiento/respuesta?	Expresión regular sobre la salida	No
Consistencia de idioma	¿Razonó en un solo idioma?	Proporción de palabras del idioma objetivo	Poco
Reward model neuronal	Opinión aprendida de “qué tan buena”	Red neuronal entrenada con preferencias	Sí, mucho

La última fila es la que se evita a propósito en el entrenamiento de razonamiento con RLVR. No se usa un reward model neuronal para la correctitud del razonamiento, y la razón es la misma que atraviesa el módulo: un reward model es aprendido y, por lo tanto, engañable. Si premiaras el razonamiento con una red que “opina” qué tan buena es una cadena, el modelo aprendería a producir cadenas que parecen buenas para esa red — largas, con muchos “por lo tanto”, con aire de rigor — sin ser correctas. El verificador cierra esa puerta: no le importa cómo se ve la cadena, solo si el resultado da.

Ojo: la recompensa de formato importa más de lo que parece. Sin ella, el modelo mezcla el razonamiento con la respuesta y se vuelve imposible extraer “la respuesta final” para verificarla automáticamente. Las etiquetas <think> y <answer> no son cosmética: son lo que le permite al verificador saber qué parte de la salida comparar con la solución conocida.

Código: GRPO con recompensas verificables en TRL

Así se ve el esqueleto con la librería TRL (Transformer Reinforcement Learning, de Hugging Face) y su GRPOTrainer. La idea que lo conecta todo con el módulo: las funciones de recompensa reciben las salidas del modelo y devuelven un número por salida; el GRPOTrainer se encarga del algoritmo GRPO que vimos en el módulo 7.

"""Entrenar razonamiento con GRPO y recompensas verificables (TRL).

Firma verificada contra la doc de TRL (GRPO Trainer): cada función de
recompensa recibe `completions` y, como kwargs, las columnas del dataset
(aquí `solution`); devuelve una lista de floats, una por completación.
`reward_funcs` acepta varias funciones: las recompensas se SUMAN (o se
ponderan con `reward_weights` en el GRPOConfig).
"""
import re
from datasets import load_dataset
from trl import GRPOTrainer, GRPOConfig

# --- Recompensa 1: CORRECTITUD (verificable, no opinada) -----------
def reward_correctitud(completions, solution, **kwargs):
    """1.0 si la respuesta extraída coincide con la solución conocida,
    0.0 si no. Esto es el verificador: comprueba, no opina."""
    rewards = []
    for salida, correcta in zip(completions, solution):
        m = re.search(r"<answer>(.*?)</answer>", salida, re.DOTALL)
        respuesta = m.group(1).strip() if m else ""
        rewards.append(1.0 if respuesta == str(correcta).strip() else 0.0)
    return rewards

# --- Recompensa 2: FORMATO (etiquetas de razonar/responder) --------
PATRON = re.compile(r"<think>.*?</think>\s*<answer>.*?</answer>", re.DOTALL)

def reward_formato(completions, **kwargs):
    """0.5 si la salida respeta <think>...</think><answer>...</answer>.
    Sin esto no se puede extraer 'la respuesta final' para verificarla."""
    return [0.5 if PATRON.search(s) else 0.0 for s in completions]

# --- Dataset: cada fila lleva `prompt` y `solution` -----------------
dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

config = GRPOConfig(
    output_dir="razonador-grpo",
    num_generations=8,          # el "grupo" de GRPO: 8 muestras por prompt
    max_completion_length=1024,  # espacio para cadenas de razonamiento largas
    learning_rate=1e-6,
)

trainer = GRPOTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    reward_funcs=[reward_correctitud, reward_formato],  # se suman
    args=config,
    train_dataset=dataset,
)
trainer.train()

Dos detalles que conectan con toda la teoría. Primero, num_generations=8 es el grupo de GRPO: para cada problema el modelo genera 8 respuestas, y GRPO usa el promedio del grupo como línea base para saber cuáles fueron mejores que el promedio — sin necesidad de un modelo crítico aparte (por eso GRPO es más barato que PPO, como vimos en el módulo 7). Segundo, ninguna de las dos recompensas es una red neuronal: reward_correctitud compara texto y reward_formato corre una regex. Ese es RLVR en veinte líneas.

TRL trae además estas mismas recompensas listas en trl.rewards — accuracy_reward (compara la respuesta con la columna solution usando verificación matemática, no igualdad de texto) y think_format_reward (revisa las etiquetas <think>) — y en la práctica conviene usarlas en vez de las caseras: la comparación exacta de strings de arriba falla con 1/3 frente a \frac{1}{3}, y la de TRL no.

Cuidado: las APIs de TRL cambian entre versiones. La firma reward_func(completions, **kwargs) con las columnas del dataset inyectadas como kwargs está verificada contra la documentación vigente de TRL, pero fija tu versión (pip install trl==...) y revisa la doc del GRPOTrainer de esa versión antes de correr en serio. El código de arriba es un esqueleto ilustrativo del patrón, no un script de producción afinado.

El pipeline completo, en un diagrama

Todo el módulo cabe en una figura: de un modelo base a modelos chicos que razonan, pasando por RLVR.


  ┌────────────┐ cold start  ┌──────────────┐
  │ modelo     │ SFT (pocos  │ base con     │
  │ base       │ ejemplos)─► │ formato ok   │
  │ (crudo)    │             │ y legible    │
  └─────┬──────┘             └──────┬───────┘
        │ R1-Zero:                  │ R1:
        │ SIN cold start            ▼
        │          ┌────────────────────────┐
        │          │ GRPO + recompensa      │
        └────────► │ VERIFICABLE            │
                   │ correctitud + formato  │
                   └───────────┬────────────┘
                               │ el razonamiento
                               │ largo EMERGE
                               ▼
                   ┌────────────────────────┐
                   │ modelo de razonamiento │
                   └───────────┬────────────┘
                               │ genera trazas
                               │ (SFT)
                               ▼
                   ┌────────────────────────┐
                   │ modelos CHICOS que     │
                   │ razonan (destilados)   │
                   └────────────────────────┘

Destilación: el modelo grande le enseña al chico

La última caja del diagrama merece su sección, porque es un resultado contraintuitivo y muy práctico. Una vez que tienes un modelo grande que razona bien, hay dos formas de conseguir un modelo chico que razone:

RL directo en el modelo chico. Aplicarle GRPO + RLVR al modelo pequeño, igual que hiciste con el grande.
Destilación (distillation): usar el modelo grande de razonamiento para generar montones de cadenas de razonamiento de calidad, y con esos datos hacer un simple SFT sobre el modelo chico. El chico aprende a imitar las trazas del grande.

El hallazgo de DeepSeek — y de mucha réplica posterior — es que la destilación suele rendir más que el RL directo en el modelo chico. Los modelos R1 destilados sobre Qwen y Llama (de 1.5B a 70B) heredaron gran parte de la capacidad de razonamiento del R1 completo, y superaron a modelos del mismo tamaño entrenados con RL desde cero. La intuición: un modelo chico tiene poca capacidad para descubrir buenas estrategias de razonamiento por prueba y error, pero sí tiene capacidad para imitar las que un modelo grande ya descubrió. Descubrir es caro y necesita un modelo grande; copiar una buena solución es barato.

Ojo: esto no contradice la tesis. Alguien tiene que descubrir el razonamiento por RL primero — el modelo grande. La destilación no reemplaza a RLVR: lo amortiza, repartiendo el costo de un entrenamiento por RL caro entre muchos modelos chicos que solo hacen SFT.

Errores comunes

Creer que le enseñas a razonar con ejemplos. El SFT del cold start arregla formato y legibilidad; no es lo que crea la capacidad de razonar. Esa capacidad la crea el RL con recompensa verificable, dejando al modelo descubrir las cadenas. Confundir ambas cosas lleva a pensar que basta con SFT sobre cadenas de ejemplo — y eso da imitación superficial, no razonamiento robusto.
Usar un reward model neuronal para la correctitud del razonamiento. Es la puerta directa al reward hacking: el modelo aprende a producir cadenas que parecen rigurosas para la red, sin ser correctas. Para razonamiento, verificador determinista o nada.
Olvidar la recompensa de formato. Sin etiquetas que separen razonamiento de respuesta, no puedes extraer “la respuesta final” y el verificador de correctitud no tiene qué comparar. El formato no es cosmética: es lo que hace verificable a la correctitud.
Creer que RLVR sirve para todo. Solo funciona donde hay verificador barato y confiable: matemáticas, código, lógica. En dominios sin respuesta única (escritura creativa, consejo abierto) no hay 1 o 0 posible, y forzar un verificador ahí produce señales pésimas.
Saltarse el cold start y esperar un producto. RL puro (R1-Zero) da un modelo que razona pero mezcla idiomas y es ilegible. Sirve como demostración científica, no como producto. Si vas a servir el modelo a usuarios, el cold start (o equivalente) no es opcional.
Hacer RL directo en modelos chicos cuando la destilación rinde más. Descubrir estrategias por RL es caro y el modelo chico las descubre mal. Deja que el grande descubra y destila las trazas al chico con un SFT.

La frase para llevarse

“No le enseñas a un modelo a razonar mostrándole cómo se piensa; le das una señal honesta de si acertó y lo dejas descubrir el pensamiento que lleva ahí. El razonamiento no se transfiere: emerge, porque funciona.”

Qué viene

Módulo 11: recompensas y reward hacking. En este módulo dijimos varias veces que el reward model es hackeable y que el verificable no — pero ni siquiera el verificable está totalmente a salvo. Un modelo entrenado por RL es una máquina implacable de encontrar el atajo: si tu recompensa premia acertar, puede aprender a memorizar el test en vez de razonar; si premia el formato, puede poner las etiquetas correctas alrededor de basura. Vamos a ver el catálogo de formas en que un modelo hackea su propia recompensa, por qué “optimiza exactamente lo que mediste, no lo que querías” es la ley de hierro del RL, y cómo se diseñan recompensas que resisten a un optimizador que juega en tu contra.

Razonamiento y RL — Módulo 10: entrenar un modelo de razonamiento