Phase 09 - Lesson 07

Actor-Critic — A2C y A3C

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

REINFORCE es ruidoso. Agregue un crítico que aprenda V̂(s), réstelo del retorno, y obtendrá una ventaja que tiene el mismo valor esperado pero una varianza mucho menor. Eso es actor-critic. A2C lo ejecuta de forma síncrona; A3C lo ejecuta a través de hilos. Ambos son el modelo mental para todo método moderno de deep-RL.

Tipo: Build Lenguajes: Python Prerrequisitos: Fase 9 · 04 (TD Learning), Fase 9 · 06 (REINFORCE) Tiempo: ~75 minutos

El Problema

REINFORCE clásico funciona, pero su varianza es terrible. Los retornos de Monte Carlo G_t pueden oscilar por un factor de más de 10 entre episodios. Multiplicar ese ruido por ∇ log π y promediar produce un estimador de gradiente que requiere miles de episodios para mover la política la misma distancia que se podría mover con muchas menos actualizaciones de DQN.

La varianza proviene del uso de retornos brutos. Si se resta una línea de base (baseline) b(s_t) —cualquier función del estado, incluyendo un valor aprendido—, el valor esperado no cambia y la varianza disminuye. La mejor línea de base tratable es V̂(s_t). Ahora, la cantidad que multiplica a ∇ log π es la ventaja:

A(s, a) = G - V̂(s)

Una acción es buena si produjo un retorno por encima del promedio; mala si fue por debajo. REINFORCE con un crítico aprendido es actor-critic. El crítico le proporciona al actor un maestro de baja varianza. Este es el fundamento de todo método de política profunda después de 2015 (A2C, A3C, PPO, SAC, IMPALA).

El Concepto

Dos redes, una pérdida compartida:

• Actor π_θ(a | s): la política. Muestreada para actuar. Entrenada con gradiente de política.
• Crítico (Critic) V_φ(s): estima el retorno esperado desde el estado. Entrenado para minimizar (V_φ(s) - target)².

La ventaja. Dos formas estándar:

• Vantaje de Monte Carlo (MC): A_t = G_t - V_φ(s_t). No sesgada (unbiased), mayor varianza.
• Ventaja de Diferencia Temporal (TD): A_t = r_{t+1} + γ V_φ(s_{t+1}) - V_φ(s_t). Sesgada (biased, ya que usa V_φ), varianza mucho menor. También llamada residuo de TD (TD residual) δ_t.

Ventaja n-step. Interpola entre las dos:

A_t^{(n)} = r_{t+1} + γ r_{t+2} + … + γ^{n-1} r_{t+n} + γ^n V_φ(s_{t+n}) - V_φ(s_t)

n = 1 es TD puro. n = ∞ es MC. La mayoría de las implementaciones usan n = 5 para Atari, n = 2048 para PPO en MuJoCo.

Estimación de Ventaja Generalizada (GAE - Generalized Advantage Estimation). Schulman et al. (2016) propusieron un promedio ponderado exponencialmente sobre todas las ventajas n-step:

A_t^{GAE} = Σ_{l=0}^{∞} (γλ)^l δ_{t+l}

con λ ∈ [0, 1]. λ = 0 es TD (baja varianza, sesgo alto). λ = 1 es MC (alta varianza, no sesgado). λ = 0.95 es el valor predeterminado de 2026; ajústelo hasta que el dial de sesgo/varianza esté donde lo desee.

A2C: actor-critic de ventaja síncrono (synchronous advantage actor-critic). Reúna T pasos en N entornos paralelos. Calcule las ventajas para cada paso. Actualice el actor y el crítico en el lote (batch) combinado. Repita. El hermano más simple y escalable de A3C.

A3C: actor-critic de ventaja asíncrono (asynchronous advantage actor-critic). Mnih et al. (2016). Genere N hilos de trabajo (worker threads), cada uno ejecutando un entorno. Cada trabajador calcula gradientes localmente en su propio rollout y luego los aplica de forma asíncrona a un servidor de parámetros compartido. No se necesita buffer de repetición (replay buffer); los trabajadores se descorrelacionan al ejecutar trayectorias diferentes. A3C demostró que se podía entrenar en CPUs a escala. En 2026, A2C basado en GPU (entornos paralelos en lotes) domina porque las GPUs requieren lotes grandes.

La pérdida combinada.

L(θ, φ) = -E[ A_t · log π_θ(a_t | s_t) ] + c_v · E[(V_φ(s_t) - G_t)²] - c_e · E[H(π_θ(·|s_t))]

Tres términos: pérdida de gradiente de política, regresión de valor, bonificación de entropía. c_v ~ 0.5, c_e ~ 0.01 son puntos de partida canónicos.

Cómo Construirlo

Paso 1: un crítico

Crítico lineal V_φ(s) = w · features(s) actualizado con MSE:

def critic_update(w, x, target, lr):
    v_hat = dot(w, x)
    err = target - v_hat
    for j in range(len(w)):
        w[j] += lr * err * x[j]
    return v_hat

En un entorno tabular, el crítico converge en unos pocos cientos de episodios. En Atari, reemplace el crítico lineal por un tronco CNN compartido + cabeza de valor (value head).

Paso 2: ventaja n-step

Dado un rollout de longitud T y un V(s_T) final bootstrapped:

def compute_advantages(rewards, values, gamma=0.99, lam=0.95, last_value=0.0):
    advantages = [0.0] * len(rewards)
    gae = 0.0
    for t in reversed(range(len(rewards))):
        next_v = values[t + 1] if t + 1 < len(values) else last_value
        delta = rewards[t] + gamma * next_v - values[t]
        gae = delta + gamma * lam * gae
        advantages[t] = gae
    returns = [a + v for a, v in zip(advantages, values)]
    return advantages, returns

returns es el objetivo del crítico. advantages es lo que multiplica a ∇ log π.

Paso 3: actualización combinada

for step_i, (x, a, _r, probs) in enumerate(traj):
    adv = advantages[step_i]
    target_v = returns[step_i]

    # critic
    critic_update(w, x, target_v, lr_v)

    # actor
    for i in range(N_ACTIONS):
        grad_logpi = (1.0 if i == a else 0.0) - probs[i]
        for j in range(N_FEAT):
            theta[i][j] += lr_a * adv * grad_logpi * x[j]

On-policy, un rollout por actualización, tasas de aprendizaje separadas para actor y crítico.

Paso 4: paralelización (A3C vs A2C)

• A3C: inicie N hilos. Cada uno ejecuta su propio entorno y su propia pasada hacia adelante (forward pass). Periódicamente envían actualizaciones de gradiente a un maestro compartido. Sin bloqueos (locks) en el maestro; las condiciones de carrera están permitidas, simplemente añaden ruido.
• A2C: ejecute N instancias de entornos en un solo proceso, apile las observaciones en un lote de [N, obs_dim], pasada hacia adelante en lote (batched forward pass), pasada hacia atrás en lote (batched backward pass). Mayor utilización de la GPU, determinista, más fácil de analizar. El valor predeterminado en 2026.

Nuestro código de juguete es de un solo hilo para mayor claridad; reescribirlo para A2C en lotes requiere solo tres líneas de numpy.

Errores Comunes

• Sesgo del crítico antes del gradiente del actor. Si el crítico es aleatorio, su línea de base no es informativa y estará entrenando con ruido puro. Caliente (warm up) el crítico durante unos cientos de pasos antes de activar el gradiente de política, o use una tasa de aprendizaje lenta para el actor.
• Normalización de ventajas. Normalice las ventajas a media cero y desviación estándar unitaria por lote. Esto estabiliza enormemente el entrenamiento a un costo casi nulo.
• Tronco compartido (Shared trunk). Utilice un extractor de características compartido para actor y crítico en entradas de imagen, con cabezas separadas. Las características compartidas aprovechan ambas pérdidas.
• Contrato on-policy. A2C reutiliza los datos exactamente para una actualización. Más de eso y su gradiente se volverá sesgado (la corrección por muestreo de importancia es lo que PPO añade).
• Colapso de entropía. Sin c_e > 0, la política se vuelve casi determinista en unos pocos cientos de actualizaciones y deja de explorar.
• Escala de recompensa. Las magnitudes de las ventajas dependen de la escala de recompensa. Normalice las recompensas (por ejemplo, dividiendo por la desviación estándar móvil) para obtener magnitudes de gradiente consistentes en todas las tareas.

Cómo Utilizarlo

A2C/A3C rara vez son la elección final en 2026, pero representan la arquitectura que todo lo posterior refina:

Si ve "ventaja" (advantage) en un artículo de 2026, piense en actor-critic.

Entregarlo (Ship It)

Guarde como outputs/skill-actor-critic-trainer.md:

---
name: actor-critic-trainer
description: Produce an A2C / A3C / GAE configuration for a given environment, with advantage estimation and loss weights specified.
version: 1.0.0
phase: 9
lesson: 7
tags: [rl, actor-critic, gae]
---

Given an environment and compute budget, output:

1. Parallelism. A2C (GPU batched) vs A3C (CPU async) and the number of workers.
2. Rollout length T. Steps per env per update.
3. Advantage estimator. n-step or GAE(λ); specify λ.
4. Loss weights. `c_v` (value), `c_e` (entropy), gradient clip.
5. Learning rates. Actor and critic (separate if using).

Refuse single-worker A2C on environments with horizon > 1000 (too on-policy, too slow). Refuse to ship without advantage normalization. Flag any run with `c_e = 0` and observed entropy < 0.1 as entropy-collapsed.

Ejercicios

1. Fácil. Entrene actor-critic con ventaja MC (G_t - V(s_t)) en un GridWorld de 4×4. Compare la eficiencia de muestras con REINFORCE-con-baseline-de-media-móvil de la Lección 06.
2. Medio. Cambie a la ventaja de residuo de TD (r + γ V(s') - V(s)). Mida la varianza de los lotes de ventaja. ¿Cuánto disminuye?
3. Difícil. Implemente GAE(λ). Realice un barrido con λ ∈ {0, 0.5, 0.9, 0.95, 1.0}. Grafique el retorno final frente a la eficiencia de muestras. ¿Dónde está el punto de equilibrio óptimo entre sesgo y varianza para esta tarea?

Términos Clave

Lectura Adicional

• Mnih et al. (2016). Asynchronous Methods for Deep Reinforcement Learning — A3C, el artículo original de actor-critic asíncrono.
• Schulman et al. (2016). High-Dimensional Continuous Control Using Generalized Advantage Estimation — GAE.
• Sutton & Barto (2018). Ch. 13 — Actor-Critic Methods — fundamentos; empareje esto con el Cap. 9 sobre aproximación de funciones cuando el crítico es una red neuronal.
• Espeholt et al. (2018). IMPALA — actor-critic distribuido escalable con corrección off-policy V-trace.
• OpenAI Baselines / Stable-Baselines3 — implementaciones de producción de A2C/PPO que vale a pena leer.
• Konda & Tsitsiklis (2000). Actor-Critic Algorithms — el resultado de convergencia fundamental para la decomposición actor-critic en dos escalas de tempo.