Tutorial Interactivo 2025 · Self-Refinement

Self-Refining Language Models

De la generacion pasiva a la generacion con metacognicion. Iteracion, auto-critica y refinamiento en modelos de lenguaje modernos.

Nota terminologica: Este tutorial usa "Recursive Language Model" como analogia para self-refinement. El termino academico oficial (Zhang et al., 2025) define un paradigma diferente para procesar contextos largos via REPL + recursion programatica sobre el input. Ver diferencias ->

1Terminologia Real del Campo

Tu tutorial usa "RLM" como marca conceptual, pero en papers e industria no hay un termino unico. Estos son los nombres reales que encontraras:

🔁

Self-Refinement

El modelo genera output, luego se evalua a si mismo y produce una version mejorada. Termino del paper Self-Refine (Madaan et al., 2023).

📈

Test-Time Compute Scaling

Usar mas compute en inference, no solo en entrenamiento. Mas "pensamiento" durante la prediccion. Paper clave: Snell et al. (2024).

🧠

Reasoning Model

Modelos entrenados expresamente para razonar paso a paso antes de responder. o1, o3, DeepSeek-R1, Gemini 2.5 Flash Thinking.

🔍

Process-Based Reasoning

Recompensar (o verificar) cada paso del razonamiento, no solo el resultado final. PRM vs ORM.

2Evolucion Historica

La idea de que un LLM revise su propio output no surgio de la noche a la manana. Es el resultado de 4 anos de investigacion incremental:

2022 — Wei et al.

Chain-of-Thought (CoT)

Demostraban que pedirle al modelo "piensa paso a paso" mejora drasticamente el razonamiento. El germen: externalizar el pensamiento como texto.

2022 — Anthropic

Constitutional AI

El modelo genera respuesta, la critica contra un conjunto de "principios constitucionales", y reescribe para alinearse. Primera forma industrializada de auto-correccion.

2022 — Zelikman et al.

STaR (Self-Taught Reasoner)

Iteracion de auto-entrenamiento: el modelo genera razonamientos, filtra los correctos, y se re-entrena con esos datos.

2023 — Madaan et al.

Self-Refine

El paradigma FEEDBACK -> REFINE como loop explicito de prompting. Mismo modelo, prompts diferentes: uno genera, otro critica, otro reescribe.

2023 — Shinn et al.

Reflexion

Agrega memoria episodica: el modelo recuerda errores pasados y los evita en futuras iteraciones. Aplicable a programacion y tareas de agentes.

2023 — Yao et al.

Tree of Thoughts

En lugar de una sola cadena de pensamiento, explora multiples caminos como arbol de busqueda. Busqueda BFS/DFS sobre razonamientos.

2024 — OpenAI

o1 / o3 (Reasoning Models)

Cambio de paradigma: no es "promptear 3 veces", es generar un reasoning trace continuo de 10,000+ tokens donde el modelo se autocorrige implicitamente.

2025 — DeepSeek-AI

DeepSeek-R1

Demuestra que no necesitas datos humanos: entrena con GRPO sobre reglas verificables (ej: ecuacion correcta o no). Costo marginal, rendimiento elite.

3Dos Paradigmas: Explicito vs Implicito

Tu tutorial muestra un loop explicito: generar -> criticar -> reescribir, paso a paso. Pero los modelos comerciales de 2025 usan un enfoque diferente.

Prompt

"Resuelve esta ecuacion"

↓

Paso 1: Generar (t=0.7)

model.generate(prompt) -> draft

↓

Paso 2: Critica (t=0.2)

model.generate("Revisa errores: " + draft) -> critique

↓

Paso 3: Reescribir

model.generate(prompt + critique) -> draft_v2

↓

Output Final

Despues de N iteraciones

Representantes: Self-Refine (2023), Reflexion (2023), el demo de este tutorial.

Ventaja: Facil de entender e implementar con cualquier LLM via prompting.

Limitacion: Cada paso consume context window. La critica puede ser debil si el modelo no fue entrenado para criticar.

Prompt Unico

"Resuelve esta ecuacion. Piensa paso a paso."

↓

Un solo stream largo (10K+ tokens)

Veamos... Primero, factorizo el lado izquierdo.

Hmm, espera. Si factorizo asi, el signo queda invertido.

Actually, that's wrong. Let me recalculate.

La factorizacion correcta es (x-3)(x+2) porque...

Verifico: (x-3)(x+2) = x² - x - 6 ✓

Por tanto, x = 3 o x = -2.

↓

Output

x = 3 o x = -2

Representantes: OpenAI o1/o3, DeepSeek-R1, Gemini 2.5 Flash Thinking, Qwen QwQ.

Ventaja: No hay overhead de contexto entre pasos. La autocorreccion es fluida y natural dentro del pensamiento. Consume mas tokens pero es un solo forward pass logico.

Como se entrena: RL sobre reasoning traces correctos (GRPO para R1, PPO/RL con PRM para o1).

4Como se Entrena en la Vida Real

Tu tutorial menciona RLHF y DPO. En 2025, el panorama es mas rico. Todos los LLMs siguen siendo "predictores de siguiente token" a nivel base. La diferencia esta en el fine-tuning.

👤

RLHF

Humano rankea respuestas, luego PPO entrena una policy. Usado por ChatGPT y Claude originales. Limitacion: costoso, sesgado, no escala perfecto.

⚡

DPO

Direct Preference Optimization. Sin RL explicito, optimiza directamente sobre pares ganador/perdedor. Simple y efectivo para alineacion basica.

🎯

GRPO (novedad 2025)

Group Relative Policy Optimization. Para un mismo prompt, genera un grupo de respuestas, las compara entre si, y recompensa relativamente. Clave de DeepSeek-R1.

🧮

Rule-Based Verification

En matematicas/codigo, no necesitas un reward model humano. Un verificador simbolico (solucion correcta o no) da la recompensa directamente. Gratis y exacto.

ORM vs PRM vs Rule-Based

ORM (Outcome Reward Model)

Evalua solo el RESULTADO final
"La respuesta es correcta?"
Barato de entrenar
No sabe DONDE se equivoco el modelo

PRM (Process Reward Model)

Evalua cada PASO del razonamiento
"Paso 3 contiene un error algebraico"
Mejor para reasoning largo
Mas caro: necesita labels por paso

Regla de oro 2025

Para tareas verificables (matematicas, codigo, puzzle juegos): usa rule-based verification. Es gratuito, exacto y elimina la necesidad de reward models entrenados. Para tareas abiertas (escritura, opinion): necesitas ORM/PRM o jueces humanos.

5Cuando NO Funciona

Tu tutorial asume que la auto-correccion siempre mejora. La literatura dice: depende. Y a veces empeora.

Paper clave: Huang et al. (2024)

"Large Language Models Cannot Self-Correct Reasoning Yet". Demuestran que LLMs sin acceso a ground truth no pueden auto-corregir su razonamiento. La "self-correction" sin verificador externo es, estadisticamente, ruido.

Funciona en tareas verificables

Matematicas

Hay una sola respuesta correcta. Puedes verificar con computo simbolico.

Codigo

El compilador y los unit tests son verificadores perfectos. Paso o no paso.

Puzzles / Juegos

Reglas duras y estado finito. Puedes simular y verificar.

NO funciona (o es debil) en tareas abiertas

Escritura creativa

Que es "mejor" un poema? Sin criterio objetivo, la "correccion" es arbitraria.

Resumenes de texto

ROUGE/BLEU son metricas debiles. El modelo no sabe si su "mejora" realmente lo es.

Opinion / Debatte abierto

Sin verificador, puede "corregir" algo que estaba bien, empeorando el resultado.

Regla practica: auto-correccion = mejora SOLO cuando existe un verificador externo confiable.

6Implementacion Conceptual (Corregida)

Tu tutorial original tenia un pseudocodigo correcto como ilustracion, pero impreciso en detalles. Esta version distingue verificacion por reglas, ORM y PRM:

# Pseudocodigo: Iterative Refinement (Explicit Paradigm)
# NOTA: Para el paradigma implicito (o1/R1), ver seccion Paradigmas.

def iterative_refine(prompt, max_iterations=3):
    context = prompt
    best_score = float("-inf")
    best_draft = ""

    for i in range(max_iterations):
        # 1. Generar con temperatura exploratoria
        draft = model.generate(context, temperature=0.6)

        # 2. Auto-critica (mismo modelo, prompt diferente)
        critique = model.generate(
            f"Review for errors: {draft}",
            temperature=0.2
        )

        # 3. Verificar con la MEJOR fuente disponible
        if task.is_verifiable(draft):
            # Opcion A: Reglas duras (DeepSeek-R1 style)
            # Gratis, exacto, no necesita entrenamiento
            score = rule_verifier.score(draft)
        elif prm_available:
            # Opcion B: Process Reward Model (OpenAI o1 style)
            # Evalua cada paso del razonamiento
            score = process_reward_model.score(draft)
        else:
            # Opcion C: Outcome Reward Model
            # Evalua solo el resultado final
            score = outcome_reward_model.score(draft)

        if score > best_score:
            best_score = score
            best_draft = draft

        # 4. Parada temprana si perfecto y verificable
        if score >= 1.0 and task.is_verifiable():
            break

        # 5. Refinar: prompt = original + feedback
        # NOTA: solo la critica, no todo el draft anterior
        context = f"""{prompt}

Feedback: {critique}
Rewrite addressing the above."""

    return best_draft
    

Correcciones respecto al tutorial original

El reward model NO toma el critique como input. Toma el draft.
Se prioriza verificacion por reglas sobre RM neural cuando es posible.
El contexto de refinamiento incluye solo la critica, no todo el draft anterior (explota la ventana de contexto).
Se distingue PRM vs ORM vs rule-based.

7Modelos Comerciales 2025

Todos estos modelos operan en el paradigma "reasoning" (implicito o explicito):

🧠 GPT-4o (tradicional)

🧠 o1 / o3 (reasoning)

🧠 DeepSeek-R1 (reasoning)

🧠 Gemini 2.5 Flash Thinking

🧠 Qwen QwQ

🧠 Kimi k1.5

Modelo Base (GPT-4o, Claude 3.5)

1 pasada, pensamiento invisible
Rapido, barato en tokens
Entrenado con RLHF/DPO
No autocorrige internamente
Ideal para tareas simples/chat

Reasoning Model (o3, R1, Thinking)

Reasoning trace visible (10K+ tokens)
Lento, caro, pero mas preciso
Entrenado con RL sobre reasoning (GRPO/PPO)
Autocorreccion implicita en el stream
Ideal para matematicas, codigo, ciencia

La diferencia no es el entrenamiento base — ambos son predictores de siguiente token. La diferencia es:

Datos de fine-tuning: reasoning models se entrenan con millones de ejemplos de thinking step-by-step.
RL post-training: usan GRPO, PPO o similares para premiar procesos de razonamiento correctos.
Inference compute: generan muchos mas tokens de "pensamiento" antes de responder.

9Referencias Academicas

Wei et al. (2022) — Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS.
Bai et al. (2022) — Constitutional AI: Harmlessness from AI Feedback. Anthropic.
Zelikman et al. (2022) — STaR: Self-Taught Reasoner. arXiv.
Madaan et al. (2023) — Self-Refine: Iterative Self-Improvement via Feedback. NeurIPS.
Shinn et al. (2023) — Reflexion: Self-Reflective Agents. NeurIPS.
Yao et al. (2023) — Tree of Thoughts: Deliberate Problem Solving with Large Language Models. NeurIPS.
Huang et al. (2024) — Large Language Models Cannot Self-Correct Reasoning Yet. ICLR.
Snell et al. (2024) — Scaling LLM Test-Time Compute Optimally. arXiv.
OpenAI (2024) — o1 System Card & Technical Report.
DeepSeek-AI (2025) — DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv.
Zhang, Kraska & Khattab (2025) — Recursive Language Models: Processing Arbitrarily Long Prompts via Recursive Inference-Time Scaffold. MIT CSAIL. arXiv:2512.24601.

10Resumen

Los Self-Refining Language Models —bajo cualquier nombre— representan un desplazamiento fundamental: de generar en un paso a generar con proceso. Pero el campo tiene matices importantes que tu tutorial original omitia:

Importante: "Recursive Language Model" es un termino academico real (Zhang et al., 2025) pero define un paradigma diferente: REPL externo + recursion programatica sobre slices del input para procesar contextos de 10M+ tokens. Ver seccion de abajo para detalles.

El termino no es estandar. Usa self-refinement, reasoning model, o test-time compute.
Hay dos paradigmas: explicito (prompteo multiple) e implicito (reasoning trace continuo).
No todo es RLHF. GRPO + verificacion por reglas es el metodo estrella de 2025.
Auto-correccion no es magica. Funciona con verificadores externos; sin ellos puede empeorar.
ORM vs PRM vs reglas: no todos los reward models son iguales. Prioriza reglas duras cuando se pueda.
El futuro es implicito. o1, o3, R1, Gemini Flash Thinking operan en un solo stream de thinking.

El futuro no es generar mas rapido. Es generar, razonar, verificar — y generar mejor.