Modelos de razonamiento: las 4 etapas de su entrenamiento

Casi todos los modelos de lenguaje que usás en 2026 ya piensan antes de responder. GPT, Gemini, Qwen y los modelos de Anthropic ofrecen un modo de razonamiento que se puede activar o apagar, y esa deliberación extra es lo que separa a un chatbot que completa texto de un sistema capaz de resolver un problema matemático complejo paso a paso.

Sebastian Raschka, autor de referencia en construir LLM desde cero, publicó en octubre de 2026 el libro y las clases que explican cómo se entrena uno de estos modelos de razonamiento: evaluación, escalado en tiempo de inferencia, aprendizaje por refuerzo y distillation. Este artículo usa ese trabajo como mapa técnico para explicar el proceso completo, con ejemplos propios en Python.

TL;DR

• Construir un razonador combina evaluación, escalado en inferencia, RL verificable y distillation hacia modelos chicos.- El escalado en tiempo de inferencia gasta más cómputo al responder, vía muestreo y voto por mayoría.- RLVR premia solo la respuesta final verificable, el método que usó DeepSeek-R1 sin etiquetar pasos intermedios.- La distillation transfiere el comportamiento de un modelo grande a uno chico con una pérdida KL entre sus salidas.- GRPO calcula la ventaja comparando respuestas entre sí, sin la red de valor separada que usa PPO.

¿Qué son los modelos de razonamiento?

Los modelos de razonamiento son LLM entrenados, además del preentrenamiento estándar, para generar una cadena de pasos intermedios antes de dar la respuesta final, y para revisar o corregir esos pasos cuando detectan un error, en lugar de predecir directamente el siguiente token más probable sin deliberar.

La idea no es nueva: el chain-of-thought ya existía como técnica de prompting. Lo que cambió es que ahora se entrena esa deliberación con reinforcement learning, en vez de pedirla solo con un prompt ingenioso. El modelo aprende, con la práctica, cuándo pensar más y cuándo responder directo.

Por qué importa ahora

La fuente de este artículo lo resume en una frase: casi todos los LLM de generación actual ya son modelos razonadores u ofrecen un modo de razonamiento activable. Lo que empezó como una especialidad para matemáticas y código generalizó a otros dominios: redacción legal, diagnóstico técnico, planificación de tareas largas.

Raschka propone una analogía útil para ubicar estos modelos en el panorama de agentes de IA: el modelo razonador es el motor, y el agent harness (el software que gestiona contexto y da acceso a herramientas) es el vehículo que lo rodea. Un agente puede usar un LLM convencional, pero casi siempre elige un razonador porque resuelve mejor tareas con pasos intermedios, como reservar un viaje completo o depurar un bug real en un repositorio grande.

Por eso entender cómo se entrena uno de estos modelos no es un ejercicio académico. Es la pieza que determina si el agente que programás esta semana sostiene un plan de quince pasos: o se pierde en el tercero.

Cómo se evalúa un modelo de razonamiento

Antes de entrenar nada hay que poder medir si el modelo mejora. La evaluación de un razonador se apoya en benchmarks con respuesta verificable: problemas de matemática tipo GSM8K o AIME, ejercicios de programación con tests automáticos tipo LiveCodeBench, acertijos lógicos con una única solución correcta.

La métrica más simple es pass@1. El modelo responde una sola vez y se compara contra la respuesta correcta. Pass@k es más exigente. El modelo genera k intentos independientes y se considera un acierto si al menos uno es correcto. La diferencia entre ambas métricas revela si el modelo falla por falta de capacidad o por falta de consistencia.

El verificador que decide si una respuesta es correcta es, en el fondo, una función simple. Para matemática alcanza con extraer el número final y compararlo contra la referencia:

import re

def grade_answer(prediction: str, reference: str) -> bool:
    def normalize(text):
        match = re.search(r"-?\d+(?:\.\d+)?", text)
        return match.group(0) if match else text.strip()
    return normalize(prediction) == normalize(reference)

print(grade_answer("La respuesta es 42.", "42"))

Esta función imprime True: extrae el primer número de cada cadena y compara. Es rudimentaria a propósito. El mismo verificador que usás para medir pass@1 es, como vas a ver en la siguiente sección, la pieza que se convierte en señal de recompensa para el entrenamiento con RL.

Un riesgo constante es la contaminación de datos. Si el benchmark de evaluación (o algo muy parecido) estaba en el corpus de preentrenamiento, el modelo puede recordar la respuesta en vez de razonarla. Por eso los benchmarks serios rotan versiones y publican fecha de corte de sus preguntas.
DeepSeek-R1 entrenó razonamiento con RL verificable antes de cualquier ajuste supervisado.

Escalado en tiempo de inferencia

La forma más barata de mejorar un razonador sin reentrenarlo es dejarlo pensar más. En vez de agregar parámetros, el escalado en tiempo de inferencia gasta más cómputo en el momento de responder: cadenas de razonamiento más largas, varios intentos en paralelo, o una búsqueda que explora distintos caminos antes de decidir.

La técnica más simple es el muestreo múltiple con voto por mayoría, conocido como self-consistency desde el paper de Wang et al. de 2022. El modelo genera varias cadenas de razonamiento independientes para la misma pregunta y se queda con la respuesta que más veces se repite.

from collections import Counter

def self_consistency(answers):
    votes = Counter(answers)
    winner, count = votes.most_common(1)[0]
    return winner

samples = ["42", "41", "42", "42", "40"]
print(self_consistency(samples))

El resultado es 42: aparece tres veces sobre cinco muestras, así que gana el voto. Una variante más sofisticada es best-of-n con un verificador o un reward model aparte, que no solo cuenta votos sino que puntúa cada candidato y elige el de mejor puntaje, incluso si es minoría.

Otras formas de escalar en inferencia incluyen la búsqueda en árbol (como Monte Carlo Tree Search aplicado a pasos de razonamiento) y el budget forcing: forzar al modelo a extender o cortar su cadena de pensamiento según un presupuesto de tokens fijo. Ninguna de estas técnicas cambia los pesos del modelo, por eso se las puede aplicar a cualquier razonador ya entrenado, incluso uno cerrado al que solo accedés por API.

flowchart TD
A["Prompt del usuario"] --> B["El modelo genera N cadenas de razonamiento"]
B --> C["Verificador o voto por mayoria"]
C --> D["Respuesta final"]

El límite de este enfoque es económico, no técnico: cada muestra adicional cuesta tokens, y a partir de cierto punto la curva de mejora se aplana. Si la pregunta es demasiado difícil para el modelo base, ningún número de intentos la resuelve. Ahí es donde entra el entrenamiento con RL.

Aprendizaje por refuerzo con recompensas verificables

El escalado en inferencia no mejora al modelo, solo aprovecha mejor lo que ya sabe. Para que un razonador gane capacidad real hay que ajustar sus pesos. Ahí entra el reinforcement learning con recompensas verificables (RLVR), donde el mismo verificador que usaste para evaluar se convierte en la función de recompensa.

La idea central es simple: el modelo (la política) genera una respuesta completa, el verificador la puntúa con 1 si es correcta y 0 si no, y ese puntaje empuja al modelo a aumentar la probabilidad de generar ese tipo de respuesta en el futuro. No se necesitan etiquetas humanas de "este paso intermedio está bien": solo el resultado final verificable.

DeepSeek-R1 mostró en 2025 que esta receta funciona incluso sin una etapa previa de ajuste fino supervisado. La versión llamada R1-Zero se entrenó con RLVR directo sobre un modelo base y el comportamiento de razonamiento emergió solo, aunque con una redacción desordenada que mezclaba idiomas. La versión final, R1, agregó una etapa de ajuste fino antes del RL para que la salida fuera legible para humanos.

El algoritmo clásico para este tipo de entrenamiento es PPO (Proximal Policy Optimization), pero PPO necesita una red de valor separada que estime qué tan buena es cada situación, lo que duplica la memoria de entrenamiento. El paper de DeepSeekMath introdujo GRPO (Group Relative Policy Optimization). En vez de una red de valor, GRPO genera un grupo de respuestas para la misma pregunta y calcula la ventaja de cada una comparándola contra el promedio del grupo.

import numpy as np

def grpo_advantages(rewards):
    rewards = np.array(rewards, dtype=float)
    return (rewards - rewards.mean()) / (rewards.std() + 1e-8)

group_rewards = [1.0, 0.0, 1.0, 1.0, 0.0]
print(np.round(grpo_advantages(group_rewards), 3))

La salida es [ 0.816 -1.225 0.816 0.816 -1.225]. Las tres respuestas correctas del grupo quedan con ventaja positiva y las dos incorrectas con ventaja negativa, normalizadas por la dispersión del propio grupo. Esa ventaja es la señal que se usa para actualizar los pesos del modelo, sin red de valor aparte.

sequenceDiagram
participant P as Modelo (politica)
participant V as Verificador
P->>V: genera respuesta candidata
V-->>P: recompensa (0 o 1)
Note over P,V: el gradiente ajusta los pesos del modelo

⚠️ Ojo: un verificador mal diseñado se puede explotar. Si el checker solo busca un patrón de texto, el modelo aprende a producir ese patrón sin resolver el problema: es el reward hacking, uno de los riesgos más citados del entrenamiento con RLVR.

Distillation: comprimir el razonamiento en un modelo chico

Entrenar con RL es caro: necesita generar miles de respuestas, verificarlas y actualizar pesos en loop. La distillation ofrece un atajo: tomar un modelo grande ya entrenado (el teacher) y transferir su comportamiento a un modelo chico (el student), sin repetir todo el proceso de RL.

Hay dos variantes típicas. La primera es puro ajuste fino supervisado: generás miles de cadenas de razonamiento con el teacher, las filtrás por corrección, y entrenás al student para que las reproduzca como texto normal. Así se construyeron varios de los modelos abiertos destilados de DeepSeek-R1, tomando un Qwen o un Llama chico como base.

La segunda variante es más fina y viene del paper original de Hinton et al. de 2015. En vez de copiar solo el texto final, el student aprende a imitar la distribución completa de probabilidades del teacher sobre cada token, con una pérdida de divergencia KL.

import torch
import torch.nn.functional as F

def distillation_loss(student_logits, teacher_logits, temperature=2.0):
    student_log_probs = F.log_softmax(student_logits / temperature, dim=-1)
    teacher_probs = F.softmax(teacher_logits / temperature, dim=-1)
    return F.kl_div(student_log_probs, teacher_probs, reduction="batchmean") * (temperature ** 2)

student_logits = torch.tensor([[2.0, 1.0, 0.1]])
teacher_logits = torch.tensor([[3.0, 1.0, 0.1]])
print(round(distillation_loss(student_logits, teacher_logits).item(), 4))

El resultado es cercano a 0.1195. Cuanto más se parezcan las dos distribuciones, más chico es este número, y el entrenamiento empuja al student a reducirlo. La temperatura (2.0 en el ejemplo) suaviza ambas distribuciones antes de compararlas, para que el student también aprenda de las probabilidades bajas que el teacher asigna a respuestas casi correctas, no solo de la respuesta ganadora.

La distillation no inventa capacidad nueva, imita la que ya existe en el teacher, así que el student nunca supera a su maestro en el dominio destilado. A cambio, corre con una fracción del costo de inferencia y de entrenamiento, lo que la vuelve atractiva para desplegar un razonador en un celular o en un servidor sin GPU dedicada.

flowchart LR
A["Modelo grande (teacher)"] --> B["Genera cadenas de razonamiento"]
B --> C["Modelo chico (student) imita esas cadenas"]
C --> D["Student conserva gran parte de la capacidad con menos parametros"]

La divergencia KL de Hinton et al. data de 2015 y sigue siendo la base de la distillation moderna.

Cómo empezar a experimentar

Los tres ejemplos de este artículo (el verificador, el voto por mayoría y la pérdida de distillation) corren en cualquier notebook con Python, sin necesitar GPU ni un modelo grande cargado en memoria.

En Linux o macOS, con Python 3.10 o más reciente instalado:

python3 -m venv venv
source venv/bin/activate
pip install torch numpy

En Windows, el único cambio es activar el entorno con venv\Scripts\activate en vez de source venv/bin/activate; el resto de los comandos es igual.

Guardá cualquiera de los fragmentos de código de arriba en un archivo .py y ejecutalo con python nombre_archivo.py. Cada uno imprime exactamente la salida mostrada en su sección.

Para ir más allá de estos fragmentos sueltos y construir un razonador completo, con un Qwen3 pequeño preentrenado como punto de partida, la publicación original de Raschka es la referencia más detallada: cubre desde la evaluación hasta el entrenamiento con RL en PyTorch, paso a paso.

Casos de uso reales

DeepSeek-R1 es el caso más citado de RLVR aplicado a gran escala, con pesos abiertos y un reporte técnico público que detalla su entrenamiento. Los modelos o1 y o3 de OpenAI popularizaron el modo de razonamiento activable en un producto comercial, aunque sin publicar el detalle de su método de entrenamiento.

Qwen3, de Alibaba, permite alternar entre modo rápido y modo razonador según la complejidad de la tarea, una decisión de producto más que una limitación técnica: el mismo modelo sabe cuándo conviene pensar más. Claude, de Anthropic, ofrece algo similar con su razonamiento extendido, visible como pasos intermedios antes de la respuesta final.

Estos casos muestran que los modelos de razonamiento ya se construyen con las piezas descritas arriba: evaluación verificable, escalado en inferencia y RL, con distillation para abaratar el despliegue en modelos chicos que corren en un teléfono o en un servidor sin GPU cara.

Errores comunes y buenas prácticas

El reward hacking es el riesgo más frecuente. Si el verificador tiene un hueco, por ejemplo acepta un formato en vez de validar el contenido, el modelo lo encuentra y lo explota durante el entrenamiento con RL, en vez de aprender a resolver el problema de fondo.

El overthinking es el error simétrico: un razonador mal calibrado gasta miles de tokens deliberando sobre preguntas triviales, lo que infla el costo y la latencia sin mejorar la respuesta. Parte del ajuste fino posterior al RL busca justamente enseñarle al modelo cuándo cortar la cadena de pensamiento.

La contaminación de benchmarks, mencionada arriba, también afecta el entrenamiento. Si el conjunto de RL incluye preguntas que el modelo ya memorizó en preentrenamiento, la mejora medida es ilusoria. Por eso conviene separar siempre los datos de entrenamiento de los de evaluación y rotar las preguntas de test con el tiempo.

Un último gotcha de la distillation: si las cadenas de razonamiento del teacher tienen errores silenciosos, un paso intermedio mal justificado que por casualidad llega a la respuesta correcta, el student aprende a imitar también esos errores. Filtrar las trazas por corrección final no alcanza. Conviene revisar una muestra manual de los pasos intermedios antes de entrenar al student con ellas.

Comparativa: escalado en inferencia, RL y distillation

MétodoCuándo usarloVentajaLimitaciónEscalado en inferencia (self-consistency, best-of-n)El modelo base casi resuelve la tarea, falta exprimir más intentosNo requiere entrenar nada nuevoMás costo por respuesta; no mejora el modelo en síRL con recompensas verificables (RLVR, GRPO)Existe un verificador automático confiable (tests, checker matemático)Mejora permanente y generaliza a preguntas nuevasCaro de entrenar; riesgo de reward hackingDistillation (SFT o KL sobre trazas del teacher)Hace falta un modelo chico, barato de desplegarConserva gran parte de la capacidad a fracción del costoTope en la capacidad del teacher; requiere generar muchas trazasFine-tuning supervisado clásico sin cadena de razonamientoTarea simple, poco presupuesto de entrenamientoRápido y barato de ejecutarNo aprende a deliberar; falla ante problemas nuevos

Profundizando: GRPO, PRM y el costo de la deliberación

GRPO no solo ahorra la red de valor de PPO. También suele incluir un término de penalización KL contra una política de referencia, normalmente el propio modelo antes de empezar el RL, para que la política entrenada no se aleje tanto que empiece a producir texto incoherente solo para maximizar la recompensa.

Otra distinción importante es entre recompensas de resultado (outcome reward models, ORM) y recompensas de proceso (process reward models, PRM). Un ORM solo mira si la respuesta final es correcta, como el verificador de este artículo. Un PRM puntúa cada paso intermedio de la cadena de razonamiento por separado, lo que da una señal más rica, pero exige etiquetar pasos individuales, algo mucho más costoso que etiquetar solo la respuesta final.

El contraste entre R1-Zero y R1 ilustra el trade-off entre pureza y usabilidad. R1-Zero, entrenado con RLVR puro desde el modelo base, desarrolló razonamiento efectivo pero con una redacción que mezclaba idiomas y era difícil de leer. R1 agregó una etapa de ajuste fino antes del RL exactamente para resolver ese problema de legibilidad, sin perder la capacidad ganada con RLVR.

💭 Clave: la capacidad de razonar no vino de agregar parámetros ni datos nuevos de preentrenamiento. Vino de una etapa de post-entrenamiento relativamente chica, pero dirigida con una señal de recompensa verificable.

📖 Resumen en Telegram: Ver resumen

Tu próximo paso: tomá el ejemplo de self-consistency de este artículo, reemplazá la lista de respuestas por las de un problema propio, y probá con cuántas muestras el voto por mayoría empieza a acertar de forma consistente.

Preguntas frecuentes

¿Qué diferencia a un LLM razonador de un LLM normal?

El LLM razonador genera una cadena de pasos intermedios antes de la respuesta final y fue entrenado con una etapa extra, típicamente RL con recompensas verificables, para mejorar esa deliberación. Un LLM normal predice directamente el siguiente token sin ese paso explícito.

¿Los modelos de razonamiento siempre necesitan RL?

No necesariamente. Se puede llegar a un comportamiento similar solo con distillation de las cadenas de otro modelo, pero el techo de capacidad queda atado al teacher. El RL completo (RLVR) es la vía que permite superar a cualquier teacher disponible.

¿Cómo se evalúa si un sistema de razonamiento realmente resuelve el problema?

Con benchmarks de respuesta verificable y métricas como pass@k, que exigen acertar en al menos uno de k intentos independientes, no solo en el primero. Esto distingue capacidad real de un acierto producto del azar.

¿Qué es la distillation aplicada a un motor de razonamiento?

Es entrenar un modelo chico (student) para imitar el comportamiento de uno grande (teacher), ya sea copiando sus cadenas de razonamiento como texto (SFT) o imitando su distribución completa de probabilidades con una pérdida de divergencia KL.

¿Hace falta un modelo razonador grande para empezar a experimentar?

No. Los ejemplos de evaluación y self-consistency de este artículo corren en CPU con cualquier modelo chico o incluso sin modelo, como funciones de verificación puras. Solo el entrenamiento con RL o distillation a gran escala necesita GPU.

Referencias

• Sebastian Raschka, Build Your Own Reasoning Model: A Full Video Course: el artículo y las lecciones que inspiraron esta nota, con el código completo del entrenamiento.- Sebastian Raschka en GitHub: repositorios con el código de sus libros sobre LLM y razonamiento desde cero.- DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning: el paper que documenta el entrenamiento con RLVR de R1-Zero y R1.- DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models: el paper que introdujo GRPO.- Hinton, Vinyals y Dean, Distilling the Knowledge in a Neural Network: el paper original de 2015 sobre distillation con divergencia KL.- Wang et al., Self-Consistency Improves Chain of Thought Reasoning in Language Models: el paper de 2022 que formalizó el voto por mayoría entre cadenas de razonamiento.

📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.