深度确定性策略梯度算法 (DDPG) 详解与实现

深度确定性策略梯度（Deep Deterministic Policy Gradient，简称 DDPG）是一种基于深度强化学习的算法，专门用于解决连续动作空间的问题，例如机器人控制中的连续运动。它结合了确定性策略和深度神经网络，属于 Actor-Critic 框架，同时利用了 DQN 和 PG（Policy Gradient）的优点。

DDPG 架构示意图

算法特点

适用于连续动作空间: DDPG 直接输出连续值动作，无需对动作进行离散化。
利用确定性策略: 与随机策略不同，DDPG 输出的是每个状态下一个确定的最优动作。
结合目标网络: 使用延迟更新的目标网络，稳定了训练过程，避免了过大的参数波动。
经验回放机制: 通过经验回放缓解数据相关性，提升样本利用率。
高效学习: 使用 Critic 网络评估动作的质量，使得策略优化过程更加高效。

核心改进点

从 DQN 继承的目标网络: 避免 Q 值的估计震荡问题，提高算法的训练稳定性。
从 PG 继承的策略梯度优化: 通过 Actor 网络直接优化策略，适应连续动作问题。
经验回放（Replay Buffer）: 将交互环境中的经验（状态、动作、奖励、下一状态）存储起来，训练时从中随机采样，减少数据相关性和样本浪费。
双网络架构: Actor 网络负责生成动作；Critic 网络评估动作的质量。

算法公式推导

1. Q 值函数更新

DDPG 使用 Bellman 方程更新 Critic 网络的目标 Q 值：

$$y = r + \gamma Q'(s', \mu'(s'; \theta^{\mu'}); \theta^{Q'})$$

其中 $s'$ 是下一状态，$\mu'(s')$ 是目标动作，$\gamma$ 是折扣因子，$\mu'$ 是目标 Actor 网络，$Q'$ 是目标 Critic 网络。

Critic 网络的优化目标是最小化以下损失函数：

$$L(\theta^Q) = \frac{1}{N} \sum_{i} \left( Q(s_i, a_i; \theta^Q) - y_i \right)^2$$

其中 $y_i$ 是目标值，$\theta^Q$ 是 Critic 网络的参数。

2. 策略更新（Actor 网络）

Actor 网络通过最大化 Critic 网络的 Q 值来优化策略，其目标函数为：

$$J(\theta^\mu) = \frac{1}{N} \sum_{i} Q(s_i, \mu(s_i; \theta^\mu); \theta^Q)$$

使用梯度上升法更新 Actor 网络：

$$\nabla_{\theta^\mu} J \approx \frac{1}{N} \sum_{i} \nabla_a Q(s, a; \theta^Q) \big|{a=\mu(s)} \nabla{\theta^\mu} \mu(s; \theta^\mu)$$

3. 目标网络更新

目标网络采用软更新方式，缓慢地向当前网络靠近：

$$\theta^{Q'} \leftarrow \tau \theta^Q + (1 - \tau) \theta^{Q'}$$ $$\theta^{\mu'} \leftarrow \tau \theta^\mu + (1 - \tau) \theta^{\mu'}$$

其中 $\tau \in (0, 1)$ 是软更新系数。

算法流程

: 初始化 Actor、Critic 网络和它们对应的目标网络，初始化经验回放池。

class DDPGAgent: def __init__(self, state_dim, action_dim, max_action, gamma=0.99, tau=0.005, buffer_size=100000, batch_size=64): self.actor = Actor(state_dim, action_dim, max_action) self.actor_target = Actor(state_dim, action_dim, max_action) self.actor_target.load_state_dict(self.actor.state_dict()) self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=1e-4) self.critic = Critic(state_dim, action_dim) self.critic_target = Critic(state_dim, action_dim) self.critic_target.load_state_dict(self.critic.state_dict()) self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3) self.max_action = max_action self.gamma = gamma self.tau = tau self.replay_buffer = ReplayBuffer(buffer_size) self.batch_size = batch_size def select_action(self, state): state = torch.FloatTensor(state.reshape(1, -1)) action = self.actor(state).detach().cpu().numpy().flatten() return action def train(self): if self.replay_buffer.size() < self.batch_size: return states, actions, rewards, next_states, dones = self.replay_buffer.sample(self.batch_size) states = torch.FloatTensor(states) actions = torch.FloatTensor(actions) rewards = torch.FloatTensor(rewards).unsqueeze(1) next_states = torch.FloatTensor(next_states) dones = torch.FloatTensor(dones).unsqueeze(1) # 计算 critic 的损失 with torch.no_grad(): next_actions = self.actor_target(next_states) target_q = self.critic_target(next_states, next_actions) target_q = rewards + (1 - dones) * self.gamma * target_q current_q = self.critic(states, actions) critic_loss = nn.MSELoss()(current_q, target_q) self.critic_optimizer.zero_grad() critic_loss.backward() self.critic_optimizer.step() # 计算 actor 的损失 actor_loss = -self.critic(states, self.actor(states)).mean() self.actor_optimizer.zero_grad() actor_loss.backward() self.actor_optimizer.step() # 更新目标网络参数（软更新） for target_param, param in zip(self.critic_target.parameters(), self.critic.parameters()): target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data) for target_param, param in zip(self.actor_target.parameters(), self.actor.parameters()): target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data) def add_to_replay_buffer(self, state, action, reward, next_state, done): self.replay_buffer.add(state, action, reward, next_state, done)

深度确定性策略梯度算法 (DDPG) 详解与实现