DQN 入门实践：用 PyTorch 从零实现深度 Q 网络

什么是 DQN？#

DQN（Deep Q-Network）是 DeepMind 在 2013 年提出的算法，首次将深度学习与 Q-Learning 结合，在 Atari 游戏上达到人类水平。它用神经网络来近似 Q 值函数 $Q(s, a)$ ，解决了传统 Q-Table 无法处理连续/高维状态空间的问题。

整体架构#

DQN 系统由五个核心模块组成：

1
┌─────────────┐    ┌──────────┐    ┌──────────────┐
2
│ Environment │───▶│  Agent   │───▶│ Q-Network    │
3
│ (Gymnasium) │    │ (ε-greedy)│   │ (3-layer MLP)│
4
└─────────────┘    └──────────┘    └──────────────┘
5
                          │
6
                   ┌──────▼──────┐
7
                   │   Memory    │
8
                   │ (Replay Buf)│
9
                   └─────────────┘

Environment：Gymnasium 标准环境（如 CartPole）
Agent：决策主体，使用 ε-贪婪策略
Q-Network：3 层 MLP 神经网络
Memory：经验回放缓冲区（Deque）

第一步：搭建 Q 网络#

网络输入是状态（如 CartPole 的 4 维向量：位置、速度、角度、角速度），输出是每个动作的 Q 值：

1
import torch.nn as nn
2

3
class DQN(nn.Module):
4
    def __init__(self, input_size, hidden_size, output_size):
5
        super(DQN, self).__init__()
6
        self.fc1 = nn.Linear(input_size, hidden_size)
7
        self.fc2 = nn.Linear(hidden_size, hidden_size)
8
        self.fc3 = nn.Linear(hidden_size, output_size)
9

10
    def forward(self, x):
11
        x = torch.relu(self.fc1(x))
12
        x = torch.relu(self.fc2(x))
13
        return self.fc3(x)  # 输出层不加激活函数

对于 CartPole：

input_size=4（状态维度）
hidden_size=64
output_size=2（左/右两个动作）

第二步：经验回放与 ε-贪婪策略#

经验回放缓冲区#

1
from collections import deque
2
import random
3

4
class ReplayBuffer:
5
    def __init__(self, capacity=10000):
6
        self.buffer = deque(maxlen=capacity)
7

8
    def push(self, state, action, reward, next_state, done):
9
        self.buffer.append((state, action, reward, next_state, done))
10

11
    def sample(self, batch_size=32):
12
        return random.sample(self.buffer, batch_size)
13

14
    def __len__(self):
15
        return len(self.buffer)

为什么需要经验回放？

打破样本的时间相关性
每个经验可被多次使用，提高数据效率

ε-贪婪策略#

1
epsilon = 1.0          # 初始 100% 随机探索
2
epsilon_min = 0.01     # 保持至少 1% 探索
3
epsilon_decay = 0.995  # 每次衰减 0.5%
4

5
def select_action(state):
6
    if random.random() < epsilon:
7
        return random.randrange(n_actions)  # 探索
8
    else:
9
        with torch.no_grad():
10
            return q_network(state).argmax().item()  # 利用

第三步：Q-Learning 更新#

核心公式——Bellman 方程的增量形式：

$Q(s, a) \leftarrow r + \gamma \cdot \max_{a'} Q(s', a')$

在代码中：

1
def train_step(batch):
2
    states, actions, rewards, next_states, dones = batch
3

4
    # 当前 Q 值
5
    current_q = q_network(states).gather(1, actions)
6

7
    # 目标 Q 值（使用 target network 稳定训练）
8
    with torch.no_grad():
9
        next_q = target_network(next_states).max(1)[0]
10
        target_q = rewards + gamma * next_q * (~dones)
11

12
    # MSE Loss
13
    loss = nn.functional.mse_loss(current_q.squeeze(), target_q)
14
    optimizer.zero_grad()
15
    loss.backward()
16
    optimizer.step()

关键超参数：

参数	值	说明
$\gamma$ (gamma)	0.99	折扣因子，值越高越看重长期回报
batch_size	32	每次训练的样本数
lr	0.001	Adam 优化器学习率
target_update	100 steps	Target Network 的同步频率

第四步：完整训练循环#

1
for episode in range(n_episodes):
2
    state, _ = env.reset()
3
    total_reward = 0
4

5
    for step in range(max_steps):
6
        action = select_action(state)
7
        next_state, reward, done, _, _ = env.step(action)
8

9
        memory.push(state, action, reward, next_state, done)
10

11
        if len(memory) >= batch_size:
12
            train_step(memory.sample())
13

14
        state = next_state
15
        total_reward += reward
16

17
        if done:
18
            break
19

20
    epsilon = max(epsilon_min, epsilon * epsilon_decay)

从 CartPole 到更复杂的环境#

这套框架的模块化设计让它很容易扩展到其他任务：

换环境：

1
env = gym.make('LunarLander-v2')    # 登月器
2
env = gym.make('Atari-Pong')        # 雅达利游戏

换网络（图像输入用 CNN）：

1
class CNN_DQN(nn.Module):
2
    def __init__(self):
3
        self.conv1 = nn.Conv2d(4, 32, 8, stride=4)
4
        self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
5
        self.fc = nn.Linear(64 * 7 * 7, 512)

自定义奖励函数：

1
if distance_to_target < 0.1:
2
    reward = 100       # 到达目标
3
else:
4
    reward = -0.01     # 时间惩罚，鼓励快速完成

总结#

DQN 将深度学习引入强化学习的核心创新在于两点：经验回放打破样本相关性，Target Network 稳定训练过程。从 3 层 MLP + CartPole 起步，理解 Q-Learning 和 Bellman 方程的本质后，逐步升级到 CNN + Atari 就是水到渠成的事。