Phase 09 - Lesson 06

Policy Gradient — REINFORCE desde Cero

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

Deja de estimar el valor. Parametriza la política directamente, calcula el gradiente del retorno esperado, avanza cuesta arriba. Williams (1992) lo escribió en un solo teorema. Es la razón por la que existen PPO, GRPO y cada bucle de RL en LLM.

Tipo: Build Lenguajes: Python Prerrequisitos: Fase 3 · 03 (Backpropagation), Fase 9 · 03 (Monte Carlo), Fase 9 · 04 (TD Learning) Tiempo: ~75 minutos

El Problema

Q-learning y DQN parametrizan la función de valor. Las acciones se eligen mediante argmax Q. Esto funciona bien para acciones discretas y estados discretos. Sin embargo, no funciona cuando las acciones son continuas (¿cómo calcular argmax sobre un torque de 10 dimensiones?) o cuando se desea una política estocástica (argmax es determinista por construcción).

En su lugar, los gradientes de política parametrizan la política. π_θ(a | s) es una red neuronal que genera una distribución sobre las acciones. Toma muestras de ella para actuar. Calcula el gradiente del retorno esperado con respecto a θ. Avanza cuesta arriba. Sin argmax. Sin recursión de Bellman. Solo ascenso de gradiente en J(θ) = E_{π_θ}[G].

El teorema REINFORCE (Williams 1992) indica que este gradiente es computable: ∇J(θ) = E_π[ G · ∇_θ log π_θ(a | s) ]. Ejecuta un episodio. Calcula el retorno. Multiplica por ∇ log π_θ(a | s) en cada paso. Obtén el promedio. Ascenso de gradiente. Listo.

Cada algoritmo de RL para LLM en 2026 — PPO, DPO, GRPO — es un refinamiento de REINFORCE. Comprenderlo a fondo es el prerrequisito para el resto de esta fase, así como para la Fase 10 · 07 (implementación de RLHF) y la Fase 10 · 08 (DPO).

El Concepto

El teorema del gradiente de política. Para cualquier política π_θ parametrizada por θ:

∇J(θ) = E_{τ ~ π_θ}[ Σ_{t=0}^{T} G_t · ∇_θ log π_θ(a_t | s_t) ]

donde G_t = Σ_{k=t}^{T} γ^{k-t} r_{k+1} es el retorno descontado desde el paso t. La expectativa se calcula sobre trayectorias completas τ muestreadas a partir de π_θ.

La demostración es corta. Diferencia J(θ) = Σ_τ P(τ; θ) G(τ) bajo la expectativa. Usa ∇P(τ; θ) = P(τ; θ) ∇ log P(τ; θ) (el truco de la derivada logarítmica). Factoriza log P(τ; θ) = Σ log π_θ(a_t | s_t) + términos del entorno que no dependen de θ. Los términos del entorno desaparecen. Dos líneas de álgebra resultan en el teorema.

Trucos de reducción de varianza. El REINFORCE clásico (vanilla) tiene una varianza extrema: los retornos son ruidosos, ∇ log π es ruidoso, y su producto es sumamente ruidoso. Dos soluciones estándar:

1. Resta de baseline. Reemplaza G_t por G_t - b(s_t) para cualquier baseline b(s_t) que no dependa de a_t. No es sesgado porque E[b(s_t) · ∇ log π(a_t | s_t)] = 0. Elección común: b(s_t) = V̂(s_t) aprendido por un crítico → actor-critic (Lección 07).
2. Reward-to-go. Reemplaza Σ_t G_t · ∇ log π_θ(a_t | s_t) por Σ_t G_t^{from t} · ∇ log π_θ(a_t | s_t). Solo los retornos futuros importan para una acción determinada; las recompensas pasadas aportan ruido con media cero.

Al combinarlos, se obtiene:

∇J ≈ (1/N) Σ_{i=1}^{N} Σ_{t=0}^{T_i} [ G_t^{(i)} - V̂(s_t^{(i)}) ] · ∇_θ log π_θ(a_t^{(i)} | s_t^{(i)})

lo cual es REINFORCE con baseline, el ancestro directo de A2C (Lección 07) y PPO (Lección 08).

Parametrización de política softmax. Para acciones discretas, la elección estándar es:

π_θ(a | s) = exp(f_θ(s, a)) / Σ_{a'} exp(f_θ(s, a'))

donde f_θ es cualquier red neuronal que genera un puntaje por acción. El gradiente tiene una forma limpia:

∇_θ log π_θ(a | s) = ∇_θ f_θ(s, a) - Σ_{a'} π_θ(a' | s) ∇_θ f_θ(s, a')

es decir, el puntaje de la acción tomada menos su valor esperado bajo la política.

Política gaussiana para acciones continuas. π_θ(a | s) = N(μ_θ(s), σ_θ(s)). ∇ log N(a; μ, σ) tiene una forma cerrada. Eso es todo lo que necesita SAC en la Fase 9 · 07.

Construcción

Paso 1: red de política softmax

def policy_logits(theta, state_features):
    return [dot(theta[a], state_features) for a in range(N_ACTIONS)]

def softmax(logits):
    m = max(logits)
    exps = [exp(l - m) for l in logits]
    Z = sum(exps)
    return [e / Z for e in exps]

Usa una política lineal (un vector de pesos por acción) para un entorno tabular. Para Atari, cámbialo por una CNN y mantén la cabeza softmax.

Paso 2: muestreo y log-probabilidad

def sample_action(probs, rng):
    x = rng.random()
    cum = 0
    for a, p in enumerate(probs):
        cum += p
        if x <= cum:
            return a
    return len(probs) - 1

def log_prob(probs, a):
    return log(probs[a] + 1e-12)

Paso 3: rollout con log-probs capturadas

def rollout(theta, env, rng, gamma):
    trajectory = []
    s = env.reset()
    while not done:
        logits = policy_logits(theta, s)
        probs = softmax(logits)
        a = sample_action(probs, rng)
        s_next, r, done = env.step(s, a)
        trajectory.append((s, a, r, probs))
        s = s_next
    return trajectory

Paso 4: actualización de REINFORCE

def reinforce_step(theta, trajectory, gamma, lr, baseline=0.0):
    returns = compute_returns(trajectory, gamma)
    for (s, a, _, probs), G in zip(trajectory, returns):
        advantage = G - baseline
        grad_log_pi_a = [-p for p in probs]
        grad_log_pi_a[a] += 1.0
        for i in range(N_ACTIONS):
            for j in range(len(s)):
                theta[i][j] += lr * advantage * grad_log_pi_a[i] * s[j]

El gradiente ∇ log π(a|s) = e_a - π(·|s) (el vector one-hot de a menos las probabilidades) es la esencia de los gradientes de política softmax. Grábalo en tu memoria muscular.

Paso 5: baselines

Un promedio móvil de G sobre episodios recientes es suficiente reducción de varianza para hacer funcionar GridWorld de 4×4; toma alrededor de 500 episodios para converger. Mejora el baseline a un V̂(s) aprendido y obtendrás actor-critic.

Errores Comunes

• Gradientes explosivos. Los retornos pueden ser enormes. Normaliza siempre G a ~N(0, 1) a lo largo del lote antes de multiplicar por ∇ log π.
• Colapso de entropía. La política converge a una acción casi determinista demasiado pronto, deja de explorar y se estanca. Solución: añade un bono de entropía β · H(π(·|s)) al objetivo.
• Alta varianza. REINFORCE clásico requiere miles de episodios. Un baseline con crítico (Lección 07) o la región de confianza de TRPO/PPO (Lección 08) es la solución estándar.
• Ineficiencia de muestreo. On-policy significa que descartas cada transición después de una actualización. Las correcciones off-policy mediante muestreo por importancia (importance sampling) recuperan datos, a costa de varianza (la relación de PPO es un peso IS recortado).
• Gradientes no estacionarios. El mismo gradiente de hace 100 episodios utiliza una π antigua. Por esta razón, los métodos on-policy se actualizan cada pocos rollouts.
• Asignación de crédito. Sin reward-to-go, las recompensas pasadas aportan ruido. Usa siempre reward-to-go.

Casos de Uso

En 2026, REINFORCE rara vez se ejecuta directamente, pero su fórmula de gradiente está en todas partes:

Cuando lees loss = -advantage * log_prob en un script de entrenamiento de 2026, eso es REINFORCE con un baseline. Artículos enteros (DPO, GRPO, RLOO) son trucos de reducción de varianza aplicados sobre esta única línea.

Entrega

Guarda como outputs/skill-policy-gradient-trainer.md:

---
name: policy-gradient-trainer
description: Produce a REINFORCE / actor-critic / PPO training config for a given task and diagnose variance issues.
version: 1.0.0
phase: 9
lesson: 6
tags: [rl, policy-gradient, reinforce]
---

Given an environment (discrete / continuous actions, horizon, reward stats), output:

1. Policy head. Softmax (discrete) or Gaussian (continuous) with parameter counts.
2. Baseline. None (vanilla), running mean, learned `V̂(s)`, or A2C critic.
3. Variance controls. Reward-to-go on by default, return normalization, gradient clip value.
4. Entropy bonus. Coefficient β and decay schedule.
5. Batch size. Episodes per update; on-policy data freshness contract.

Refuse REINFORCE-no-baseline on horizons > 500 steps. Refuse continuous-action control with a softmax head. Flag any run with `β = 0` and observed policy entropy < 0.1 as entropy-collapsed.

Ejercicios

1. Fácil. Implementa REINFORCE en GridWorld de 4×4 con una política softmax lineal. Entrena durante 1,000 episodios sin un baseline. Grafica la curva de aprendizaje; mide la varianza (desviación estándar de los retornos).
2. Medio. Añade un baseline de promedio móvil. Entrena de nuevo. Compara la eficiencia de muestreo y la varianza con la ejecución clásica. ¿En cuánto reduce el baseline los pasos para la convergencia?
3. Difícil. Añade un bono de entropía β · H(π). Realiza un barrido (sweep) de β ∈ {0, 0.01, 0.1, 1.0}. Grafica el retorno final y la entropía de la política. ¿Cuál es el punto óptimo (sweet spot) en esta tarea?

Términos Clave

Lectura Adicional

• Williams (1992). Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning — el artículo original de REINFORCE.
• Sutton et al. (2000). Policy Gradient Methods for Reinforcement Learning with Function Approximation — el teorema moderno del gradiente de política con aproximación de funciones.
• Sutton & Barto (2018). Ch. 13 — Policy Gradient Methods — presentación en libro de texto.
• OpenAI Spinning Up — VPG / REINFORCE — exposición pedagógica clara con código PyTorch.
• Peters & Schaal (2008). Reinforcement Learning of Motor Skills with Policy Gradients — reducción de varianza y la perspectiva de gradiente natural que conecta REINFORCE con la familia de región de confianza (TRPO, PPO).