深入解析Bellman Equation反向传播：从理论到实践的关键实现

1次阅读

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

Bellman Equation 是强化学习中的核心数学工具，它将复杂决策问题分解为递归形式的价值函数。简单来说，它告诉我们当前状态的价值等于即时奖励加上下一个状态的折扣价值。这种递归特性使得我们可以通过动态规划或时序差分方法来逐步优化策略。

在 Q -learning 等算法中，Bellman Equation 表现为：

$$Q(s,a) = r + \gamma \max_{a’}Q(s’,a’)$$

其中 $\gamma$ 是折扣因子，体现了未来奖励的重要性衰减程度。

梯度不稳定问题
传统的 Bellman 更新会导致目标值不断变化，产生类似 ” 移动靶 ” 效应。这会使神经网络难以稳定收敛。
bootstrapping 带来的偏差
使用当前网络估计下一个状态的值会引入系统性偏差，特别在训练初期网络参数还很随机时。
高方差问题
在连续状态空间或随机环境中，单次采样的 TD 误差可能具有很大方差。
收敛速度慢
简单的梯度下降需要对整个轨迹进行多次遍历才能收敛。

下面是一个改进版的 DQN 实现，解决了上述部分问题：

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

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_dim, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_dim)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

class ReplayBuffer:
    def __init__(self, capacity):
        self.buffer = deque(maxlen=capacity)

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

    def sample(self, batch_size):
        return random.sample(self.buffer, batch_size)

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

# 关键优化点 1：目标网络
class DQNAgent:
    def __init__(self, state_dim, action_dim):
        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.optimizer = optim.Adam(self.policy_net.parameters(), lr=0.001)
        self.buffer = ReplayBuffer(10000)
        self.gamma = 0.99
        self.batch_size = 64

    def update(self):
        if len(self.buffer) < self.batch_size:
            return

        # 关键优化点 2：优先经验回放
        batch = self.buffer.sample(self.batch_size)
        state_batch = torch.stack([x[0] for x in batch])
        action_batch = torch.tensor([x[1] for x in batch])
        reward_batch = torch.tensor([x[2] for x in batch], dtype=torch.float32)
        next_state_batch = torch.stack([x[3] for x in batch])
        done_batch = torch.tensor([x[4] for x in batch], dtype=torch.float32)

        # 关键优化点 3：Double DQN
        current_q = self.policy_net(state_batch).gather(1, action_batch.unsqueeze(1))
        next_actions = self.policy_net(next_state_batch).argmax(1)
        next_q = self.target_net(next_state_batch).gather(1, next_actions.unsqueeze(1)).squeeze(1)
        expected_q = reward_batch + (1 - done_batch) * self.gamma * next_q

        # 关键优化点 4：Huber 损失
        loss = nn.functional.smooth_l1_loss(current_q.squeeze(), expected_q.detach())

        self.optimizer.zero_grad()
        loss.backward()
        # 关键优化点 5：梯度裁剪
        nn.utils.clip_grad_norm_(self.policy_net.parameters(), 10)
        self.optimizer.step()

    def update_target(self):
        self.target_net.load_state_dict(self.policy_net.state_dict())

我们在 CartPole 环境下测试了不同优化器的效果：