Phase 09: Reinforcement Learning

Gradiente de política REINFORCE desde cero

Type: Build

Languages: Python

Prerequisites: Phase 3 · 03 (Backpropagation), Phase 9 · 03 (Monte Carlo), Phase 9 · 04 (TD Learning)

Time: ~75 minutes

El problema

El aprendizaje Q y DQN paramétrean la función de valor.argmax QSe rompe cuando las acciones son continuas (que sonargmax¿O cuando se quiere una política estocástica (argmaxes determinista por construcción).

Los gradientes de política paramétrean la política en su lugar. π_θ(a | s)Es una red neuronal que produce una distribución sobre acciones.θ- Un paso hacia arriba.argmaxNo hay recursión de Bellman, sólo ascenso de gradiente enJ(θ) = E_{π_θ}[G]¿ Qué ?

El teorema de la REINFORCE (Williams 1992) dice que este gradiente es computable: ∇J(θ) = E_π[ G · ∇_θ log π_θ(a | s) ]Ejecutar un episodio, calcular el rendimiento, multiplicar por∇ log π_θ(a | s)En promedio, en escala, terminado.

Cada algoritmo LLM-RL en 2026 PPO, DPO, GRPO es un refinamiento de REINFORCE.

El concepto

!Policy gradient: softmax policy, log-π gradient, return-weighted update

The policy gradient theorem.Para cualquier políticaπ_θparametrizado por θ¿Qué es esto ?

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

dondeG_t = Σ_{k=t}^{T} γ^{k-t} r_{k+1}es el retorno descuento de paso tLa expectativa está sobre las trayectorias completas .τmuestras de π_θ¿ Qué ?

The proof is short.DiferenciarJ(θ) = Σ_τ P(τ; θ) G(τ)El uso de la información∇P(τ; θ) = P(τ; θ) ∇ log P(τ; θ)(el truco de la derivación de registro).log P(τ; θ) = Σ log π_θ(a_t | s_t) + environment terms that do not depend on θLos términos de entorno desaparecen. Dos líneas de álgebra te dan el teorema.

Variance reduction tricks.Vanilla ReINFORCE tiene una varianza asesina los retornos son ruidosos, ∇ log πes ruidoso, su producto es muy ruidoso. Dos soluciones estándar:

1. Baseline subtraction.ReemplazarG_tconG_t - b(s_t)para cualquier línea de base b(s_t)que no depende de a_tNo es imparcial porqueE[b(s_t) · ∇ log π(a_t | s_t)] = 0. Escoge típico: b(s_t) = V̂(s_t)Aprendió un crítico → actor-crítico (Lesión 07).
2. Reward-to-go.ReemplazarΣ_t G_t · ∇ log π_θ(a_t | s_t)conΣ_t G_t^{from t} · ∇ log π_θ(a_t | s_t). Sólo los retornos futuros son importantes para una acción dada Las recompensas pasadas contribuyen con ruido cero-medio.

Combinado, obtienes:

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

que es REINFORCE con un valor de referencia el antepasado directo de A2C (lección 07) y PPO (lección 08).

Softmax policy parameterization.Para las acciones discretas, la opción estándar:

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

dondef_θes cualquier red neuronal que emite 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 en el marco de la póliza.

Gaussian policy for continuous actions. π_θ(a | s) = N(μ_θ(s), σ_θ(s))- ¿ Qué ?∇ log N(a; μ, σ)El proyecto de investigación de la Comisión de Agricultura y Desarrollo de la Agricultura, la Agricultura y la Agricultura tiene un formulario cerrado.

Construye el mismo

Paso 1: red de políticas softmax

pythonCopydef 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]

Utilice una política lineal (un vector de peso por acción) para un entorno tabular. Para Atari, intercambiar en una CNN y mantener la cabeza de softmax.

Paso 2: muestreo y probabilidad de registro

pythonCopydef 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: despliegue con log-probes capturados

pythonCopydef 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 la REINFORCE

pythonCopydef 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)(en el caso de a- probabilidades) es el corazón de los gradientes de política de softmax.

Paso 5: líneas de base

Un medio corriente de GEn los últimos episodios, la reducción de varianza es suficiente para que un GridWorld 4×4 funcione; se necesitan ~ 500 episodios para converger.V̂(s)y tienes crítico de actores.

Las trampas

• Exploding gradients.Las devoluciones pueden ser enormes.G¿ Qué ?~N(0, 1)en el lote antes de multiplicarse por ∇ log π¿ Qué ?
• Entropy collapse.La política converge a una acción casi determinista demasiado pronto, deja de explorar, se queda atascada.β · H(π(·|s))al objetivo.
• High variance.Vanilla REINFORCE necesita miles de episodios. Una línea de base crítica (lección 07) o la región de confianza de TRPO/PPO (lección 08) es la solución estándar.
• Sample inefficiency.En política significa que se descarta cada transición después de una actualización. Las correcciones fuera de política a través de muestreo de importancia traen datos, a costa de la variación (la proporción de la OPP es un peso de IS recortado).
• Non-stationary gradients.El mismo gradiente de hace 100 episodios usa el antiguo .πLos métodos en política se actualizan cada pocos lanzamientos por esta razón.
• Credit assignment.Sin recompensas, las recompensas pasadas contribuyen al ruido.

Usalo

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

Cuando usted leeloss = -advantage * log_probEn un guión de formación de 2026, es decir, REINFORCE con una línea de base.

Envío

Salvo comooutputs/skill-policy-gradient-trainer.md¿Qué es esto ?

markdownCopy---
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.

Los ejercicios

1. Easy.Implemente REINFORCE en 4×4 GridWorld con una política de softmax lineal. Entrenar durante 1.000 episodios sin una línea de base. Trazar la curva de aprendizaje; medir la variación (std de rendimientos).
2. Medium.Añadir una línea de base de la media de ejecución. Entrenar de nuevo. Comparar la eficiencia de la muestra y la variación con la carrera de vainilla. ¿En qué medida la línea de base reduce los pasos a la convergencia?
3. Hard.Añadir una bonificación de entropía β · H(π)- Específico .β ∈ {0, 0.01, 0.1, 1.0}¿Dónde está el punto de interés de esta tarea?

Términos clave

Leer más

• Williams (1992). Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning el papel original de REINFORCE.
• Sutton et al. (2000). Policy Gradient Methods for Reinforcement Learning with Function Approximation el teorema moderno de la política-gradiente con aproximación de funciones.
• Sutton & Barto (2018). Ch. 13 — Policy Gradient Methods Presentación de libros 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 la varianza y la visión natural-gradiente que conecta REINFORCE a la familia de la región de confianza (TRPO, PPO).

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.