Phase 09: Reinforcement Learning

Redes Q profundas (DQN)

Type: Build

Languages: Python

Prerequisites: Phase 3 · 03 (Backpropagation), Phase 9 · 04 (Q-learning, SARSA)

Time: ~75 minutes

El problema

El aprendizaje de Q tabulare necesita un valor Q separado para cada par (estado, acción). Una tabla de ajedrez tiene ~1043 estados. Un marco Atari es 210×160×3 = 100,800 características.

La solución es obvia en retrospectiva: reemplazar la tabla Q por una red neuronal.Q(s, a; θ)Pero la aproximación de funciones ingenuas con el aprendizaje Q diverge bajo la "triada mortal" aproximación de funciones + bootstrapping + aprendizaje fuera de la política. Mnih et al. (2013, 2015) identificaron tres trucos de ingeniería que estabilizan el aprendizaje:

1. Experience replayDescorrelar las transiciones.
2. Target networkcongelará el objetivo de arranque.
3. Reward clippingnormaliza las magnitudes de gradiente.

DQN en Atari fue la primera vez que una única arquitectura con un solo conjunto de hiperparámetros resolvió docenas de problemas de control a partir de píxeles crudos. Todo "deep-RL" construido desde DDQN, Rainbow, Dueling, Distribucional, R2D2, Agent57 está apilado en la parte superior de esta base de tres trucos.

El concepto

!DQN training loop: env, replay buffer, online net, target net, Bellman TD loss

The objective.DQN minimiza la pérdida de TD en un paso en una función Q neuronal:

L(θ) = E_{(s,a,r,s')~D} [ (r + γ max_{a'} Q(s', a'; θ^-) - Q(s, a; θ))² ]

θ= red en línea, actualizado cada paso por descenso de gradiente. θ^-= red objetivo, copiada periódicamente desde θ(cada ~ 10.000 pasos). D= Buffer de reproducción de las transiciones pasadas.

The three tricks, in order of importance:

Experience replay.Un amortiguador de anillos de ~10⁶Cada paso de entrenamiento muestra un minibatch uniformemente al azar. Esto rompe la correlación temporal (los marcos sucesivos son casi idénticos), permite a la red aprender de raras transiciones gratificantes muchas veces y descorrela actualizaciones de gradiente consecutivas.

Target network.Usando la misma red Q(·; θ)En ambos lados de la ecuación Bellman hace que el objetivo se mueva cada actualización "perseguir su propia cola". La solución: mantener una segunda red Q(·; θ^-)con pesos congelados.Cpasos, copia θ → θ^-Esto estabiliza el objetivo de regresión para miles de pasos de gradiente a la vez.θ^- ← τ θ + (1-τ) θ^-(utilizado en DDPG, SAC) son una variante más suave.

Reward clipping.Las magnitudes de la recompensa de Atari varían de 1 a 1000+.{-1, 0, +1}No es correcto cuando la magnitud de la recompensa importa, pero bueno para Atari cuando sólo importa la firma.

Double DQN.Hasselt (2016) corrige el sesgo de maximización: utiliza la red en línea para seleccionar la acción, la red objetivo para * evaluarla.

target = r + γ Q(s', argmax_{a'} Q(s', a'; θ); θ^-)

El reemplazo de entrega es consistentemente mejor.

Other improvements (Rainbow, 2017):repetición priorizada (muestra de transiciones de alto TD-error más), arquitectura de duelo (separado V(s)El sistema de redes de acceso a Internet (C51/QR-DQN), las redes ruidosas (exploración aprendida), los retornos de n pasos, la distribución de Q (C51/QR-DQN), el arranque de múltiples pasos.

Construye el mismo

El código aquí es stdlib-solo numpy-free usamos un MLP de capa oculta única rodada a mano en un pequeño GridWorld continuo, por lo que cada paso de entrenamiento se ejecuta en microsecondas. El algoritmo es idéntico a Atari DQN en escala.

Paso 1: Puente de reproducción

pythonCopyclass ReplayBuffer:
    def __init__(self, capacity):
        self.buf = []
        self.capacity = capacity
    def push(self, s, a, r, s_next, done):
        if len(self.buf) == self.capacity:
            self.buf.pop(0)
        self.buf.append((s, a, r, s_next, done))
    def sample(self, batch, rng):
        return rng.sample(self.buf, batch)

~ 50.000 capacidad para Atari; 5.000 es suficiente para nuestro entorno de juguetes.

Paso 2: una pequeña red Q (MLP manual)

pythonCopyclass QNet:
    def __init__(self, n_in, n_hidden, n_actions, rng):
        self.W1 = [[rng.gauss(0, 0.3) for _ in range(n_in)] for _ in range(n_hidden)]
        self.b1 = [0.0] * n_hidden
        self.W2 = [[rng.gauss(0, 0.3) for _ in range(n_hidden)] for _ in range(n_actions)]
        self.b2 = [0.0] * n_actions
    def forward(self, x):
        h = [max(0.0, sum(w * xi for w, xi in zip(row, x)) + b) for row, b in zip(self.W1, self.b1)]
        q = [sum(w * hi for w, hi in zip(row, h)) + b for row, b in zip(self.W2, self.b2)]
        return q, h

Pasado hacia adelante: lineal → ReLU → lineal. Esa es toda la red.

Paso 3: actualización del DQN

pythonCopydef train_step(online, target, batch, gamma, lr):
    grads = zeros_like(online)
    for s, a, r, s_next, done in batch:
        q, h = online.forward(s)
        if done:
            y = r
        else:
            q_next, _ = target.forward(s_next)
            y = r + gamma * max(q_next)
        td_error = q[a] - y
        accumulate_grads(grads, online, s, h, a, td_error)
    apply_sgd(online, grads, lr / len(batch))

La forma es Q-apprenticio de la lección 04 con dos diferencias: (a) nos retroacomponemos a través de un diferenciable Q(·; θ)En lugar de indexar una tabla, (b) los usos objetivo Q(·; θ^-)¿ Qué ?

Paso 4: el bucle exterior

Para cada episodio, actúa en un acto de codicia.Q(·; θ), empujar las transiciones en el amortiguador, muestran un minibatch, hacen un paso gradiente, sincronizan periódicamenteθ^- ← θEl patrón:

pythonCopyfor episode in range(N):
    s = env.reset()
    while not done:
        a = epsilon_greedy(online, s, epsilon)
        s_next, r, done = env.step(s, a)
        buffer.push(s, a, r, s_next, done)
        if len(buffer) >= batch:
            train_step(online, target, buffer.sample(batch), gamma, lr)
        if steps % sync_every == 0:
            target = copy(online)
        s = s_next

En nuestro pequeño GridWorld con un estado de 16 dimensiones, el agente aprende una política casi óptima en aproximadamente 500 episodios.

Las trampas

• Deadly triad.La aproximación de la función + fuera de la política + arranque puede divergir. DQN mitigó con red objetivo + repetición; no eliminar ninguno.
• Exploration.El sistema de detección de la red Q-net se descompone en el primer 10% del entrenamiento.
• Overestimation. maxEl uso de doble DQN en la producción siempre es de carácter ascendente.
• Reward scale.Clip o normalizar recompensas; la magnitud del gradiente es proporcional a la magnitud de la recompensa.
• Replay buffer coldstart.No entrenes hasta que el amortiguador tenga unos miles de transiciones.
• Target sync frequency.El sistema de control de velocidad de la navegación de Atari utiliza 10.000 pasos env.
• Observation preprocessing.Atari DQN apila 4 cuadros para hacer estado Markov. Cualquier entorno con información de velocidad necesita estado de cuadros o recurrente.

Usalo

En 2026, DQN rara vez es de última generación, pero sigue siendo el algoritmo de referencia fuera de la política:

Las lecciones siguen viajando. Replay y redes de destino aparecen en SAC, TD3, DDPG, SAC-X, el amortiguador de auto-juego de AlphaZero y todos los métodos de RL fuera de línea.

Envío

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

markdownCopy---
name: dqn-trainer
description: Produce a DQN training config (buffer, target sync, ε schedule, reward clipping) for a discrete-action RL task.
version: 1.0.0
phase: 9
lesson: 5
tags: [rl, dqn, deep-rl]
---

Given a discrete-action environment (observation shape, action count, horizon, reward scale), output:

1. Network. Architecture (MLP / CNN / Transformer), feature dim, depth.
2. Replay buffer. Capacity, minibatch size, warmup size.
3. Target network. Sync strategy (hard every C steps or soft τ).
4. Exploration. ε start / end / schedule length.
5. Loss. Huber vs MSE, gradient clip value, reward clipping rule.
6. Double DQN. On by default unless explicit reason to disable.

Refuse to ship a DQN with no target network, no replay buffer, or ε held at 1. Refuse continuous-action tasks (route to SAC / TD3). Flag any reward range > 10× per-step mean as needing clipping or scale normalization.

Los ejercicios

1. Easy.- ¿ Qué ?code/main.py¿Cuántos episodios hasta que la media de ejecución exceda de -10?
2. Medium.Deshabilitar la red de destino (utilizar la red en línea para ambos lados del objetivo de Bellman).
3. Hard.Añadir DQN doble: utilizar la red en línea para seleccionar argmax a', la red de objetivo para evaluar.Q(s_0, best_a)contra verdaderoV*(s_0)Después de 1.000 episodios con vs sin Double DQN en un grido de recompensas GridWorld.

Términos clave

Leer más

• Mnih et al. (2013). Playing Atari with Deep Reinforcement Learning el trabajo del taller de 2013 de NeurIPS que dio inicio a la RL profunda.
• Mnih et al. (2015). Human-level control through deep reinforcement learning el artículo Nature, 49 juegos de DQN.
• Hasselt, Guez, Silver (2016). Deep Reinforcement Learning with Double Q-learning DDQN.
• Wang et al. (2016). Dueling Network Architectures Duelo de DQN.
• Hessel et al. (2018). Rainbow: Combining Improvements in Deep RL el papel de trucos apilados.
• Sutton & Barto (2018). Ch. 9 — On-policy Prediction with Approximation el tratamiento en libros de texto de la "triada mortal" (aproximado de la función + arranque + fuera de la política) que la red objetivo y el buffer de reproducción de DQN están diseñados para domesticar.
• CleanRL DQN implementation DQN de referencia de archivo único utilizado en estudios de ablación; bueno para leer junto con la versión de la lección desde cero.

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.