Phase 09 - Lesson 09

Reward Modeling & RLHF

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

Los humanos no pueden escribir una función de recompensa para una "buena respuesta de asistente", pero pueden comparar dos respuestas y elegir la mejor. Ajuste un modelo de recompensa a esas comparaciones y, luego, aplique RL al modelo de lenguaje contra él. Christiano 2017. InstructGPT 2022. La receta que transformó GPT-3 en ChatGPT. En 2026 está siendo reemplazado en su mayoría por DPO — pero el modelo mental permanece.

Tipo: Build Idiomas: Python Prerrequisitos: Phase 5 · 05 (Sentiment), Phase 9 · 08 (PPO) Tiempo: ~45 minutos

El Problema

Entrenó un modelo de lenguaje en el objetivo de predicción del siguiente token. Escribe inglés gramaticalmente correcto. También miente, divaga y se niega a rechazar solicitudes. No puede solucionar esto con más preentrenamiento — el texto de la web es el problema, no la cura.

Quiere una recompensa escalar que diga "la respuesta A es mejor que la respuesta B para la instrucción X". Escribir esa función de recompensa a mano es imposible. La "utilidad" no es una expresión en formato cerrado sobre tokens. Pero los humanos pueden comparar dos respuestas y marcar una preferencia. Eso es barato de recopilar a escala.

RLHF (Christiano et al. 2017; Ouyang et al. 2022) convierte las preferencias en un modelo de recompensa y, luego, optimiza el LM mediante PPO contra esa recompensa. En tres pasos: SFT → RM → PPO. Es la receta que hizo posible ChatGPT, Claude, Gemini y cualquier otro LLM alineado en 2023–2025.

En 2026, el paso de PPO se reemplaza en su mayoría por DPO (Phase 10 · 08) porque es más barato y casi tan bueno para el ajuste de alineación. But la pieza del modelo de recompensa sigue siendo la base de cada muestreador Best-of-N, cada pipeline de RL a partir de recompensas verificables y cada modelo de razonamiento que utiliza un modelo de recompensa de proceso. Comprenda RLHF y comprenderá toda la pila de alineación.

El Concepto

Etapa 1: Ajuste fino supervisado (SFT). Comience con un modelo base preentrenado. Realize un ajuste fino en demostraciones escritas por humanos del comportamiento objetivo (respuestas que siguen instrucciones, respuestas útiles, etc.). Resultado: un modelo π_SFT que está sesgado hacia el buen comportamiento pero que aún tiene un espacio de acción ilimitado.

Etapa 2: Entrenamiento del modelo de recompensa.

• Recopile pares de respuestas (y_+, y_-) para prompts x, etiquetados por humanos como "y_+ es preferible a y_-".

• Entrene un modelo de recompensa R_φ(x, y) para asignar puntuaciones más altas a y_+.

• Pérdida: la logística por pares de Bradley-Terry:

  L(φ) = -E[ log σ(R_φ(x, y_+) - R_φ(x, y_-)) ]

  σ es la sigmoide. La diferencia en la recompensa implica una probabilidad logarítmica de preferencia. BT ha sido el estándar desde 1952 (Bradley-Terry) y es la elección dominante en el RLHF moderno.

• R_φ generalmente se inicializa a partir del modelo SFT con una cabecera escalar en la parte superior. Mismo backbone de transformer; una sola capa lineal genera la recompensa.

Etapa 3: PPO contra el RM con penalización KL.

• Inicialice la política entrenable π_θ a partir de π_SFT. Mantenga una referencia congelada π_ref = π_SFT.

• Recompensa al final de una respuesta y:

  r_total(x, y) = R_φ(x, y) - β · KL(π_θ(·|x) || π_ref(·|x))

  La penalización KL evita que π_θ se desvíe arbitrariamente de π_SFT; es un regularizador, no una región de confianza estricta. β normalmente es de 0.01 a 0.05.

• Ejecute PPO (Lección 08) con esta recompensa. Las ventajas se calculan en la trayectoria a nivel de token, pero el RM solo califica la respuesta completa.

¿Por qué la KL? Sin ella, PPO encontrará fácilmente estrategias de hackeo de recompensa: el RM solo se entrenó en completaciones dentro de la distribución. Una respuesta fuera de la distribución podría obtener una puntuación más alta que cualquier respuesta escrita por un humano. La KL mantiene a π_θ cerca de la variedad donde se entrenó el RM. Es el control más importante en RLHF.

Estado en 2026:

• DPO (Rafailov 2023): el álgebra de forma cerrada colapsa las Etapas 2 y 3 en una sola pérdida supervisada sobre datos de preferencia. Sin RM, sin PPO. Misma calidad en los benchmarks de alineación por una fracción del cómputo. Cubierto en Phase 10 · 08.
• GRPO (DeepSeek 2024–2025): PPO con una línea de base relativa al grupo en vez de un crítico, recompensa de un verificador (código ejecutado / respuesta matemática correcta) en lugar de un RM entrenado por humanos. Dominante para modelos de razonamiento. Cubierto en Phase 9 · 12.
• Modelos de recompensa de proceso (PRM): califican soluciones parciales (cada paso de razonamiento), utilizados tanto en las variantes de RLHF como de GRPO para el razonamiento.
• Constitutional AI / RLAIF: utiliza un LLM alineado para generar preferencias en lugar de humanos. Escala el presupuesto de preferencias.

Implementación

Esta lección utiliza "prompts" y "respuestas" sintéticas diminutas representadas como cadenas de texto. El RM es un calificador lineal sobre una representación de saco de palabras. Sin un LLM real: lo que importa es la estructura de la tubería, no la escala. Consulte code/main.py.

Paso 1: datos de preferencia sintéticos

PROMPTS = ["help me", "answer me", "explain this"]
GOOD_WORDS = {"clear", "specific", "kind", "thorough"}
BAD_WORDS = {"vague", "rude", "wrong", "short"}

def make_pair(rng):
    x = rng.choice(PROMPTS)
    y_good = rng.choice(list(GOOD_WORDS)) + " " + rng.choice(list(GOOD_WORDS))
    y_bad = rng.choice(list(BAD_WORDS)) + " " + rng.choice(list(BAD_WORDS))
    return (x, y_good, y_bad)

En el RLHF real, esto es reemplazado por etiquetadores humanos. La estructura — (prompt, preferred_response, rejected_response) — es idéntica.

Paso 2: modelo de recompensa Bradley-Terry

Puntuación lineal: R(x, y) = w · bag(y). Entrene para minimizar la pérdida logarítmica por pares de BT:

def rm_train_step(w, x, y_pos, y_neg, lr):
    r_pos = dot(w, bag(y_pos))
    r_neg = dot(w, bag(y_neg))
    p = sigmoid(r_pos - r_neg)
    for tok, cnt in bag(y_pos).items():
        w[tok] += lr * (1 - p) * cnt
    for tok, cnt in bag(y_neg).items():
        w[tok] -= lr * (1 - p) * cnt

Después de unos cientos de actualizaciones, w asigna pesos positivos a los tokens de palabras buenas y negativos a las malas.

Paso 3: política tipo PPO sobre el RM

Nuestra política de juguete produce un solo token de un vocabulario. Calificamos el token bajo el RM, calculamos log π_θ(token | prompt), agregamos una penalización KL a la referencia y aplicamos el sustituto de PPO recortado.

def rlhf_step(theta, ref, w, prompt, rng, eps=0.2, beta=0.1, lr=0.05):
    logits_theta = policy_logits(theta, prompt)
    probs = softmax(logits_theta)
    token = sample(probs, rng)
    logits_ref = policy_logits(ref, prompt)
    probs_ref = softmax(logits_ref)
    reward = dot(w, bag([token])) - beta * kl(probs, probs_ref)
    # ppo-style update on theta, treating reward as the return
    ...

Paso 4: monitorear la KL

Realice un seguimiento de la media de KL(π_θ || π_ref) en cada actualización. Si supera ~5-10, la política se ha desviado demasiado de π_SFT — el β bajo está subiendo o está comenzando el hackeo de recompensa. Este es el principal diagnóstico en el RLHF real.

Paso 5: la receta de producción con TRL

Una vez que comprenda la tubería de juguete, aquí está el mismo bucle tal como lo escribe un usuario de biblioteca real. TRL de Hugging Face es la implementación de referencia: RewardTrainer para la Etapa 2 y PPOTrainer (con un KL a la referencia integrado) para la Etapa 3.

# Stage 2: reward model from pairwise preferences
from trl import RewardTrainer, RewardConfig
from transformers import AutoModelForSequenceClassification, AutoTokenizer

tok = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
rm = AutoModelForSequenceClassification.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct", num_labels=1
)

# dataset rows: {"prompt", "chosen", "rejected"} — Bradley-Terry format
trainer = RewardTrainer(
    model=rm,
    tokenizer=tok,
    train_dataset=preference_data,
    args=RewardConfig(output_dir="./rm", num_train_epochs=1, learning_rate=1e-5),
)
trainer.train()

# Stage 3: PPO against the RM with KL penalty to the SFT reference
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead

policy = AutoModelForCausalLMWithValueHead.from_pretrained("./sft-checkpoint")
ref    = AutoModelForCausalLMWithValueHead.from_pretrained("./sft-checkpoint")  # frozen

ppo = PPOTrainer(
    config=PPOConfig(learning_rate=1.41e-5, batch_size=64, init_kl_coef=0.05,
                     target_kl=6.0, adap_kl_ctrl=True),
    model=policy, ref_model=ref, tokenizer=tok,
)

for batch in dataloader:
    responses = ppo.generate(batch["query_ids"], max_new_tokens=128)
    rewards   = rm(torch.cat([batch["query_ids"], responses], dim=-1)).logits[:, 0]
    stats     = ppo.step(batch["query_ids"], responses, rewards)
    # stats includes: mean_kl, clip_frac, value_loss — the three PPO diagnostics

Tres cosas que la biblioteca hace por usted. adap_kl_ctrl=True implementa la programación adaptativa de β: si el KL observado excede target_kl, β se duplica; si cae por debajo de la mitad, β se reduce a la mitad. El modelo de referencia se congela por convención; no debe compartir parámetros accidentalmente con policy. Y la cabecera de valor reside en el mismo backbone que la política (AutoModelForCausalLMWithValueHead acopla una cabecera MLP escalar), razón por la cual TRL reporta policy/kl and value/loss por separado.

Dificultades Comunes

• Sobreoptimización / hackeo de recompensa. El RM es imperfecto; π_θ encuentra completaciones adversarias que obtienen una puntuación alta pero son malas. Síntomas: la recompensa sube indefinidamente mientras que la puntuación de evaluación humana se estanca o disminuye. Solución: detenerse antes, aumentar β, ampliar los datos de entrenamiento del RM.
• Length hacking. Los RM entrenados en respuestas útiles a menudo recompensan implícitamente la longitud del texto. La política aprende a rellenar las respuestas. Remedio: recompensa normalizada por longitud, o RLAIF con un RM sensible a la longitud.
• RM demasiado pequeño. El RM debe ser al menos tan grande como la política. Un RM minúsculo no puede calificar fielmente los resultados de la política.
• Ajuste de KL. β demasiado bajo → desviación y hackeo de recompensa. β demasiado alto → la política apenas cambia. El truque estándar es una β adaptativa que apunta a un KL fijo por paso.
• Ruido en los datos de preferencia. ~30% de las etiquetas humanas son ruidosas o ambiguas. Calibre entrenando el RM en datos filtrados por nivel de acuerdo o use una temperatura en BT.
• Problemas fuera de política. Los datos de PPO están ligeramente fuera de política después de la primera época. Monitoree la fracción de recorte como en la Lección 08.

Casos de Uso

El RLHF en 2026 se estructura en capas:

RLHF fue el método en 2022-2024. En 2026, los pipelines de alineación de producción son DPO primero, y PPO solo para los pasos con un uso intensivo de RM o críticos para la seguridad.

Publicación

Guarde como outputs/skill-rlhf-architect.md:

---
name: rlhf-architect
description: Design an RLHF / DPO / GRPO alignment pipeline for a language model, including RM, KL, and data strategy.
version: 1.0.0
phase: 9
lesson: 9
tags: [rl, rlhf, alignment, llm]
---

Given a base LM, a target behavior (alignment / reasoning / refusal / agent), and a preference or verifier budget, output:

1. Stage. SFT? RM? DPO? GRPO? With justification.
2. Preference or verifier source. Humans, AI feedback, rule-based, unit-test-pass, or reward distillation.
3. KL strategy. Fixed β, adaptive β, or DPO (implicit KL).
4. Diagnostics. Mean KL, reward stability, over-optimization guard (holdout human eval).
5. Safety gate. Red-team set, refusal rate, safety RM separate from helpfulness RM.

Refuse to ship RLHF-PPO without a KL monitor. Refuse to use an RM smaller than the target policy. Refuse length-only rewards. Flag any pipeline that does not hold back a blind human-eval set as lacking over-optimization protection.

Ejercicios

1. Fácil. Entrene el modelo de recompensa Bradley-Terry en code/main.py con 500 pares de preferencias sintéticos. Mida la precisión por pares en 100 pares de exclusión. Debería superar el 90%.
2. Medio. Ejecute el bucle de juguete PPO-RLHF con β ∈ {0.0, 0.1, 1.0}. Para cada uno, grafique la puntuación de RM frente a KL a la referencia a lo largo de las actualizaciones. ¿Qué ejecuciones sufren de hackeo de recompensa?
3. Difícil. Implemente DPO (pérdida de probabilidad de preferencia en formato cerrado) en los mismos datos de preferencia y compárelo con la tubería de RLHF-PPO en cómputo utilizado y puntuación final de RM lograda.

Términos Clave

Lectura Adicional

• Christiano et al. (2017). Deep Reinforcement Learning from Human Preferences — el artículo que inició RLHF.
• Ouyang et al. (2022). InstructGPT — Training language models to follow instructions with human feedback — la receta detrás de ChatGPT.
• Stiennon et al. (2020). Learning to summarize with human feedback — RLHF inicial para la generación de resúmenes.
• Rafailov et al. (2023). Direct Preference Optimization — DPO; el estándar post-RLHF en 2026.
• Bai et al. (2022). Constitutional AI: Harmlessness from AI Feedback — RLAIF y bucle de autocrítica.
• Anthropic RLHF paper (Bai et al. 2022). Training a Helpful and Harmless Assistant — el artículo de HH.
• Hugging Face TRL library — RewardTrainer y PPOTrainer de producción. Lea el código fuente del trainer para detalles sobre el KL adaptativo y la cabecera de valor.
• Hugging Face — Illustrating Reinforcement Learning from Human Feedback por Lambert, Castricato, von Werra, Havrilla — el tutorial canónico de la tubería de tres etapas con diagramas.
• von Werra et al. (2020). TRL: Transformer Reinforcement Learning — la biblioteca; examples/ contiene scripts de RLHF de extremo a extremo para Llama, Mistral y Qwen.
• Sutton & Barto (2018). Ch. 17.4 — Designing Reward Signals — la perspectiva de la hipótesis de recompensa; prerrequisito esencial para pensar sobre el hackeo de recompensa.