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

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

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

核心机制与改进点

DDPG 之所以在连续控制任务中表现优异，主要得益于以下几个关键设计：

适用于连续动作空间：直接输出连续值动作，无需像传统方法那样对动作进行离散化。
确定性策略：与随机策略不同，DDPG 输出的是每个状态下一个确定的最优动作，这简化了梯度计算。
目标网络机制：使用延迟更新的目标网络，有效稳定了训练过程，避免了参数波动过大导致的震荡。
经验回放（Replay Buffer）：通过存储交互经验并随机采样，打破了数据间的时间相关性，显著提升了样本利用率。
双网络架构：Actor 网络负责生成动作，Critic 网络评估动作质量，两者协同优化。

算法公式推导

理解 DDPG 的核心在于掌握其更新逻辑。Critic 网络利用 Bellman 方程更新目标 Q 值：

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

其中 $s'$ 是下一状态，$\mu'$ 是目标 Actor 网络，$Q'$ 是目标 Critic 网络，$\gamma$ 为折扣因子。 Critic 网络的优化目标是最小化以下损失函数：

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

对于策略更新（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)$

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

![\theta^{Q'} \leftarrow \tau \theta^Q + (1 - \tau) \theta^{Q'} ]

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) 详解与 PyTorch 实现