PythonAI算法
Double DQN 算法详解与 Python 实现
Double DQN 算法通过分离动作选择和目标价值计算来缓解 DQN 中的过估计偏差问题。该算法使用在线网络选择动作，目标网络评估价值，从而提升训练稳定性和收敛性。文中详细阐述了算法背景、核心思想、流程及公式推导，并提供了基于 PyTorch 的 Python 完整实现代码，适用于解决高维状态空间下的强化学习任务。
Double DQN 算法通过分离动作选择和目标价值计算来缓解 DQN 中的过估计偏差问题。该算法使用在线网络选择动作，目标网络评估价值，从而提升训练稳定性和收敛性。文中详细阐述了算法背景、核心思想、流程及公式推导，并提供了基于 PyTorch 的 Python 完整实现代码，适用于解决高维状态空间下的强化学习任务。
强化学习中的深度 Q 网络（DQN）是一种将深度学习与 Q 学习结合的算法，它通过神经网络逼近 Q 函数以解决复杂的高维状态问题。然而，DQN 存在过估计问题（Overestimation Bias），即在更新 Q 值时，由于同时使用同一个网络选择动作和计算目标 Q 值，可能导致 Q 值的估计偏高。
Double DQN（DDQN）引入了'双网络'机制来缓解这个问题，从而提高了算法的稳定性和收敛性。
在强化学习的早期研究中，Q 学习是一种经典算法，它通过构建 Q 值表来描述每个状态 - 动作对的长期累积奖励。然而，当状态和动作空间变得巨大甚至连续时，Q 学习方法难以扩展。为此，深度 Q 网络（Deep Q-Network, DQN）引入了神经网络来逼近 Q 函数，并取得了显著的成果，如成功应用于 Atari 游戏。但 DQN 算法在实际应用中暴露出了一些问题，其中过估计偏差（Overestimation Bias）尤为突出。
在 DQN 算法中，Q 值更新公式如下：
其中：
是目标网络的 Q 值。
是折扣因子；
是当前的即时奖励；
DQN 使用的是'最大值'max 操作来选择动作并估计未来的价值，这种方式可能导致过高估计。其根本原因在于：
这种偏差会导致：
Double Q-Learning 是一种用于减少过估计问题的经典方法。其基本思想是分离动作选择和价值估计。它使用两个独立的 Q 值表：
Double Q-Learning 的目标值公式为：
通过这种分离计算，动作选择的误差不会直接影响到目标值计算，从而减少了过估计的风险。
Double DQN（DDQN）受 Double Q-Learning 启发，将其思想扩展到深度强化学习领域。主要区别在于：
Double DQN 的目标值公式为：
其中：
是目标网络，用于估计目标 Q 值。
是在线网络，用于选择动作；
这种方法成功地解决了 DQN 的过估计问题，并在多个强化学习任务中表现出了更好的性能和稳定性。
Double DQN 通过分离动作选择和目标 Q 值计算来减小过估计问题：
这种分离使得目标 Q 值的计算更加可靠，有助于减少估计偏差。
1.初始化：
初始化两个神经网络：在线网络
和目标网络
。
的参数定期从
同步。
2.执行动作：
当前状态
下，利用
选择动作
：
3.存储经验：
将转移样本
存入经验回放池。
4.经验回放：
从经验回放池中随机采样一个小批量
。
5.目标值计算（关键点）：
使用在线网络选择下一个状态
的最佳动作：
使用目标网络计算目标 Q 值：
6.更新在线网络：
使用均方误差（MSE）作为损失函数，对
进行梯度下降：
7.更新目标网络：
每隔一定步数，将
的参数复制到
。
减小过估计的作用：
Q 值是由目标网络
计算的。
动作 a 是由在线网络
选择的。
Double DQN 目标： DDQN 通过分离动作选择和目标计算，目标值改为：
Q 学习目标： 传统 DQN 的目标值是：
这里的 max 操作会导致过估计问题。
下面给出 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() # 关闭环境
# 环境配置
Python 3.11.5
torch 2.1.0
torchvision 0.16.0
gym 0.26.2
由于博文主要为了介绍相关算法的原理和应用的方法，缺乏对于实际效果的关注，算法可能在上述环境中的效果不佳或者无法运行，一是算法不适配上述环境，二是算法未调参和优化，三是没有呈现完整的代码，四是等等。上述代码用于了解和学习算法足够了，但若是想直接将上面代码应用于实际项目中，还需要进行修改。
Double DQN 与 DQN 的对比
| 特性 | DQN | Double DQN |
|---|---|---|
| 目标值计算 | 动作选择和评估使用同一网络 | 分离动作选择和目标评估 |
| 过估计偏差 | 明显存在 | 显著减小 |
| 训练稳定性 | 容易震荡 | 更加稳定 |
| 算法复杂度 | 较低 | 略微增加（多一次网络前向计算） |
1.减小过估计偏差：
分离动作选择和目标计算后，Double DQN 有效减少了过高估计的风险。
2.更稳定的训练过程：
由于估计值更准确，训练更加平滑，收敛速度更快。
3.简单易实现：
在 DQN 的基础上，仅需额外引入动作选择的分离逻辑，容易实现。
Double DQN 算法的提出，主要是为了解决 DQN 中的'过估计偏差'问题。通过引入双网络，Double DQN 让动作选择和价值评估分离，大大提高了算法的稳定性和准确性。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online