Double DQN 算法详解与 Python 实现

通过这种分离计算，动作选择的误差不会直接影响到目标值计算，从而减少了过估计的风险。

2.3 Double DQN 的提出

Double DQN（DDQN）受 Double Q-Learning 启发，将其思想扩展到深度强化学习领域。主要区别在于：

1. 使用在线网络（Online Network）来选择动作；
2. 使用目标网络（Target Network）来估计动作的价值。

Double DQN 的目标值公式为：

其中：

是目标网络，用于估计目标 Q 值。

是在线网络，用于选择动作；

这种方法成功地解决了 DQN 的过估计问题，并在多个强化学习任务中表现出了更好的性能和稳定性。

三、Double DQN 的核心思想

Double DQN 通过分离动作选择和目标 Q 值计算来减小过估计问题：

1. 使用在线网络（Online Network）选择动作。
2. 使用目标网络（Target Network）计算目标 Q 值。

这种分离使得目标 Q 值的计算更加可靠，有助于减少估计偏差。

四、算法流程

1.初始化：

初始化两个神经网络：在线网络

和目标网络

。

的参数定期从

同步。

2.执行动作：

当前状态

下，利用

选择动作

：

3.存储经验：

将转移样本

存入经验回放池。

4.经验回放：

从经验回放池中随机采样一个小批量

。

5.目标值计算（关键点）：

使用在线网络选择下一个状态

的最佳动作：

使用目标网络计算目标 Q 值：

6.更新在线网络：

使用均方误差（MSE）作为损失函数，对

进行梯度下降：

7.更新目标网络：

每隔一定步数，将

的参数复制到

。

五、公式推导

减小过估计的作用：

• 通过在线网络选择动作，可以更准确地反映当前策略的动作价值。
• 目标网络仅用来计算 Q 值，减少了目标计算时的估计偏差。

Q 值是由目标网络

计算的。

动作 a 是由在线网络

选择的。

Double DQN 目标： DDQN 通过分离动作选择和目标计算，目标值改为：

Q 学习目标： 传统 DQN 的目标值是：

这里的 max 操作会导致过估计问题。

[Python] Double DQN 算法实现

下面给出 Double DQN 算法的完整 Python 实现代码，它通过 PyTorch 框架实现，并包含了核心的在线网络和目标网络的更新机制：

1. 导入必要库

import numpy as np # 导入 NumPy 库，用于处理数组和数值计算
import torch # 导入 PyTorch 库，用于构建和训练深度学习模型
import torch.nn as nn # 导入 PyTorch 的神经网络模块，用于构建网络结构
import torch.optim as optim # 导入 PyTorch 的优化器模块，用于优化神经网络参数
import random # 导入 Python 的随机模块，用于实现随机采样
from collections import deque # 导入 deque 数据结构，用于存储经验回放池

2. 超参数设置

# Hyperparameters
GAMMA = 0.99 # 折扣因子，控制奖励的时间衰减
LR = 0.001 # 学习率，用于控制优化器的步长
BATCH_SIZE = 64 # 每次训练的批量大小
MEMORY_CAPACITY = 10000 # 经验回放池的最大容量
TARGET_UPDATE = 10 # 目标网络更新的周期（每 10 个回合更新一次）

3. 定义网络

# Define the neural network
class QNetwork(nn.Module):
    # 定义 Q 网络，用于逼近 Q 值函数
    def __init__(self, state_dim, action_dim):
        super(QNetwork, self).__init__()
        # 初始化父类
        self.fc1 = nn.Linear(state_dim, 128) # 第一层全连接层，输入维度为状态维度，输出 128 维
        self.fc2 = nn.Linear(128, 128) # 第二层全连接层，输入和输出均为 128 维
        self.fc3 = nn.Linear(128, action_dim) # 输出层，输出维度为动作维度

    def forward(self, x):
        # 定义前向传播过程
        x = torch.relu(self.fc1(x)) # 第一层激活函数为 ReLU
        x = torch.relu(self.fc2(x)) # 第二层激活函数为 ReLU
        x = self.fc3(x) # 输出层不加激活函数，直接输出 Q 值
        return x

4. 缓存经验区

# Replay buffer
class ReplayBuffer:
    # 定义经验回放池，用于存储和采样经验数据
    def __init__(self, capacity):
        self.buffer = deque(maxlen=capacity) # 使用 deque 实现固定长度的经验池

    def push(self, state, action, reward, next_state, done):
        # 添加新的经验
        self.buffer.append((state, action, reward, next_state, done))

    def sample(self, batch_size):
        # 随机采样一个批量的经验
        batch = random.sample(self.buffer, batch_size)
        states, actions, rewards, next_states, dones = zip(*batch) # 解压为单独的数组
        return (np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(dones))

    def __len__(self):
        # 返回经验池的当前大小
        return len(self.buffer)

5. Double DQN 算法

# Double DQN Agent
class DoubleDQNAgent:
    # 定义 Double DQN 智能体
    def __init__(self, state_dim, action_dim):
        self.state_dim = state_dim # 状态维度
        self.action_dim = action_dim # 动作维度
        # Online and target networks
        self.online_net = QNetwork(state_dim, action_dim) # 在线网络，用于实时决策
        self.target_net = QNetwork(state_dim, action_dim) # 目标网络，用于稳定目标计算
        self.target_net.load_state_dict(self.online_net.state_dict()) # 初始化目标网络参数
        self.target_net.eval() # 设置目标网络为评估模式
        self.optimizer = optim.Adam(self.online_net.parameters(), lr=LR) # 使用 Adam 优化器
        self.memory = ReplayBuffer(MEMORY_CAPACITY) # 创建经验回放池
        self.steps_done = 0 # 记录执行的步数

    def select_action(self, state, epsilon):
        # 动作选择，使用ε-贪婪策略
        if random.random() < epsilon: # 以概率 epsilon 选择随机动作（探索）
            return random.randint(0, self.action_dim - 1)
        else: # 否则选择当前 Q 值最大的动作（利用）
            state = torch.FloatTensor(state).unsqueeze(0) # 转换为张量并增加批量维度
            with torch.no_grad(): # 关闭梯度计算
                q_values = self.online_net(state) # 通过在线网络计算 Q 值
                return q_values.argmax().item() # 返回最大 Q 值对应的动作索引

    def store_transition(self, state, action, reward, next_state, done):
        # 存储经验
        self.memory.push(state, action, reward, next_state, done)

    def update(self):
        # 更新在线网络
        if len(self.memory) < BATCH_SIZE: # 如果经验不足一个批量，则不更新
            return
        # Sample a batch of transitions
        states, actions, rewards, next_states, dones = self.memory.sample(BATCH_SIZE)
        # 从经验池中采样
        states = torch.FloatTensor(states)
        actions = torch.LongTensor(actions).unsqueeze(1) # 转换为张量并调整维度
        rewards = torch.FloatTensor(rewards).unsqueeze(1)
        next_states = torch.FloatTensor(next_states)
        dones = torch.FloatTensor(dones).unsqueeze(1)
        # Compute Q values
        q_values = self.online_net(states).gather(1, actions) # 提取当前 Q 值
        # Compute target Q values using Double DQN
        with torch.no_grad():
            next_actions = self.online_net(next_states).argmax(dim=1, keepdim=True) # 在线网络选择动作
            next_q_values = self.target_net(next_states).gather(1, next_actions) # 目标网络评估动作
            target_q_values = rewards + (1 - dones) * GAMMA * next_q_values # 计算目标 Q 值
        # Compute loss
        loss = nn.MSELoss()(q_values, target_q_values) # 均方误差损失函数
        # Update online network
        self.optimizer.zero_grad() # 清空梯度
        loss.backward() # 反向传播计算梯度
        self.optimizer.step() # 更新在线网络参数

    def update_target_network(self):
        # 定期更新目标网络
        self.target_net.load_state_dict(self.online_net.state_dict())

6. 算法训练

# Environment simulation (example: CartPole-v1)
import gym # 导入 Gym 库，用于创建和交互强化学习环境
env = gym.make('CartPole-v1') # 创建 CartPole 环境
state_dim = env.observation_space.shape[0] # 获取状态空间的维度
action_dim = env.action_space.n # 获取动作空间的维度
agent = DoubleDQNAgent(state_dim, action_dim) # 创建 Double DQN 智能体
# Training Loop
num_episodes = 500 # 总训练回合数
epsilon_start = 1.0 # ε-贪婪策略的初始探索率
epsilon_end = 0.01 # 最终的探索率
epsilon_decay = 500 # 探索率的衰减速度
for episode in range(num_episodes): # 按回合循环训练
    state = env.reset() # 重置环境
    done = False # 标记是否完成
    total_reward = 0 # 累计奖励初始化为 0
    while not done: # 每个时间步内
        # Epsilon-greedy action selection
        epsilon = epsilon_end + (epsilon_start - epsilon_end) * np.exp(-1. * agent.steps_done / epsilon_decay) # 动态调整探索率
        action = agent.select_action(state, epsilon) # 根据ε-贪婪策略选择动作
        # Step in the environment
        next_state, reward, done, _ = env.step(action) # 执行动作并获取下一状态和奖励
        total_reward += reward # 累加奖励
        # Store transition and update
        agent.store_transition(state, action, reward, next_state, done) # 存储经验
        agent.update() # 更新在线网络
        state = next_state # 更新当前状态
        agent.steps_done += 1 # 增加步数计数
    # Update target network periodically
    if episode % TARGET_UPDATE == 0:
        agent.update_target_network() # 定期更新目标网络
    print(f"Episode {episode}, Total Reward: {total_reward}") # 打印当前回合的累计奖励
env.close() # 关闭环境

[Notice] 代码说明

1. ReplayBuffer：经验回放池，用于存储状态、动作、奖励、下一个状态和是否结束标志。
2. QNetwork：定义深度 Q 网络，包含 3 个全连接层。
3. DoubleDQNAgent：
   • 维护在线网络（Online Network）和目标网络（Target Network）。
   • 使用在线网络选择动作，用目标网络计算目标值。
4. 训练流程：
   • 在每个时间步，使用 ( \epsilon )-贪婪策略选择动作。
   • 与环境交互，存储数据到经验回放池。
   • 采样小批量数据进行训练，通过Double DQN 公式计算目标 Q 值。
   • 定期更新目标网络。

# 环境配置
Python 3.11.5
torch 2.1.0
torchvision 0.16.0
gym 0.26.2

由于博文主要为了介绍相关算法的原理和应用的方法，缺乏对于实际效果的关注，算法可能在上述环境中的效果不佳或者无法运行，一是算法不适配上述环境，二是算法未调参和优化，三是没有呈现完整的代码，四是等等。上述代码用于了解和学习算法足够了，但若是想直接将上面代码应用于实际项目中，还需要进行修改。

六、优势与特点

Double DQN 与 DQN 的对比

1.减小过估计偏差：

分离动作选择和目标计算后，Double DQN 有效减少了过高估计的风险。

2.更稳定的训练过程：

由于估计值更准确，训练更加平滑，收敛速度更快。

3.简单易实现：

在 DQN 的基础上，仅需额外引入动作选择的分离逻辑，容易实现。

七、总结

Double DQN 算法的提出，主要是为了解决 DQN 中的'过估计偏差'问题。通过引入双网络，Double DQN 让动作选择和价值评估分离，大大提高了算法的稳定性和准确性。