深度解析2015 DeepMind DQN：从原理到实现深度强化学习的突破

1次阅读

没有评论

共计 4038 个字符，预计需要花费 11 分钟才能阅读完成。

强化学习中的 Q 学习算法通过维护一个 Q 表格来存储状态 - 动作对应的价值，但在处理像 Atari 游戏这样的高维状态空间时（如 210×160 像素的屏幕画面），传统方法面临两个致命问题：

维度灾难 ：对于连续或高维状态空间，Q 表格的存储需求呈指数级增长。以 Atari 的原始像素输入为例，可能的状态组合高达 256^(210×160×3) 种，根本无法存储。
特征提取困难：像素数据本身包含大量噪声和冗余信息，传统方法难以自动提取对决策有用的高层特征。

2013 年，DeepMind 团队首次提出用深度神经网络替代 Q 表格的想法，但直接结合面临两个主要挑战：

数据样本间强相关性导致训练不稳定
目标 Q 值随网络更新不断变化（类似于追逐移动的目标）

传统强化学习按时间顺序处理样本，存在两个问题：

连续样本高度相关，导致梯度更新方向有偏
当前经验立即丢弃，数据利用率低

DQN 的解决方案是引入 经验回放缓冲区：

将智能体的经历（state, action, reward, next_state）存储在固定大小的循环缓冲区中
训练时随机采样一批历史经验用于更新网络

这样做的好处是：

打破样本相关性，使训练更稳定
可重复利用历史经验，提升数据效率
类似监督学习的 batch 训练方式

Q 学习的目标值计算公式为：

target = r + γ * max(Q(s',a'))

如果使用同一个网络估算当前 Q 值和目标 Q 值，相当于在追逐一个不断变化的目标，容易导致训练震荡。

DQN 的解决方案是：

维护两个结构相同但参数独立的网络
主网络（online network）：负责选择动作和实时更新
目标网络（target network）：专门用于计算目标 Q 值
每隔 C 步将主网络参数复制到目标网络

这种延迟更新机制使目标值在一段时间内保持稳定，大幅提高了训练稳定性。

import torch
import torch.nn as nn
import torch.optim as optim
import random
from collections import deque

class DQN(nn.Module):
    """3 层卷积 + 2 层全连接的 Q 网络"""
    def __init__(self, input_shape, n_actions):
        super(DQN, self).__init__()
        self.conv = nn.Sequential(nn.Conv2d(input_shape[0], 32, kernel_size=8, stride=4),
            nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, stride=1),
            nn.ReLU())
        conv_out_size = self._get_conv_out(input_shape)
        self.fc = nn.Sequential(nn.Linear(conv_out_size, 512),
            nn.ReLU(),
            nn.Linear(512, n_actions)
        )

    def _get_conv_out(self, shape):
        """计算卷积层输出尺寸"""
        o = self.conv(torch.zeros(1, *shape))
        return int(torch.prod(torch.tensor(o.size())))

    def forward(self, x):
        conv_out = self.conv(x).view(x.size()[0], -1)
        return self.fc(conv_out)

class DQNAgent:
    def __init__(self, state_dim, action_dim, lr=1e-4, gamma=0.99):
        self.gamma = gamma
        self.replay_buffer = deque(maxlen=100000)
        self.batch_size = 32

        # 双网络结构
        self.policy_net = DQN(state_dim, action_dim)
        self.target_net = DQN(state_dim, action_dim)
        self.target_net.load_state_dict(self.policy_net.state_dict())
        self.target_net.eval()  # 目标网络不计算梯度

        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=lr)
        self.loss_fn = nn.MSELoss()
        self.update_target_every = 1000  # 目标网络更新频率

    def store_transition(self, state, action, reward, next_state, done):
        """存储经验到回放缓冲区"""
        self.replay_buffer.append((state, action, reward, next_state, done))

    def sample_batch(self):
        """随机采样一批经验"""
        batch = random.sample(self.replay_buffer, self.batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        return (torch.stack(states),
            torch.tensor(actions),
            torch.tensor(rewards),
            torch.stack(next_states),
            torch.tensor(dones, dtype=torch.float32)
        )

    def update_model(self, step_count):
        """更新主网络参数"""
        if len(self.replay_buffer) < self.batch_size:
            return

        states, actions, rewards, next_states, dones = self.sample_batch()

        # 计算当前 Q 值
        current_q = self.policy_net(states).gather(1, actions.unsqueeze(1))

        # 计算目标 Q 值（使用目标网络）with torch.no_grad():
            next_q = self.target_net(next_states).max(1)[0]
            target_q = rewards + (1 - dones) * self.gamma * next_q

        # 计算损失并更新
        loss = self.loss_fn(current_q.squeeze(), target_q)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

        # 定期更新目标网络
        if step_count % self.update_target_every == 0:
            self.target_net.load_state_dict(self.policy_net.state_dict())

在经典的 Atari 2600 游戏测试中，DQN 展现出显著优势：