DDPG 算法直觉

DDPG 算法直觉

DDPG 是一种面向连续动作空间的 off-policy Actor-Critic 算法，它将 DPG 与 DQN 的经验回放、目标网络等稳定训练机制结合，使智能体能够直接学习连续控制任务中的动作策略。

DDPG 算法类型

off-policy

DDPG 训练中采样时需要添加噪声 \(a_t=μ(s_t∣θ^μ)+N_t\) ，并维护 replay buffer 收集旧策略采样的经验；而学习/优化的目标策略则是 \(μ(s)\)。产生经验的策略和优化学习的目标策略不同，所以 DDPG 是 off-policy

deterministic policy gradient

DDPG 是基于确定性策略梯度的深度 Actor-Critic 算法。与随机策略不同，Actor 不输出动作概率分布，而是直接根据状态生成一个连续动作 \(a=μ(s∣θ^μ)\)。Actor 的优化目标是让自己输出的动作在 Critic 中获得更高的 (Q) 值，因此更新方向来自在线 Critic 对动作的梯度。

算法直觉

DDPG维护四个网络，一组在线网络与 一组目标网络：

• 在线 Actor，负责输出当前动作：\(μ(s∣θ^μ)\)
• 在线 Critic，负责评价 状态 | 动作 价值：\(Q(s,a∣θ^Q)\)
• 目标 Actor，只用于算 TD target：\(μ'(s∣θ^{μ'})\)
• 目标 Critic，只用于算 TD target：\(Q'(s,a∣θ^{Q'})\)

在线网络负责学习，目标网络负责提供稳定标签

由于数据来自 replay buffer，很多 transition 是旧策略或加噪声行为策略产生的。DPPG会反复使用旧数据，相比 A2C/PPO 之类的 on-policy 算法（主要用当前策略刚采样的数据 - rollout）；旧数据 + TD bootstrap + 神经网络，误差更容易累积或放大。

故DDPG 借鉴了 DQN 的 target network 思想，用慢更新的 target actor/critic 构造更稳定的 TD target，从而缓解深度 off-policy actor-critic 中 target 随在线网络剧烈变化的问题。

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim, max_action):
        super().__init__()
        self.max_action = max_action
        self.net = nn.Sequential(
            nn.Linear(state_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 256),
            nn.ReLU(),
            nn.Linear(256, action_dim),
            nn.Tanh()
        )
		# Actor forward：输入状态 state，直接输出当前策略给出的连续动作。
    def forward(self, state):
        return self.max_action * self.net(state)
        
class Critic(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim + action_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 256),
            nn.ReLU(),
            nn.Linear(256, 1)
        )
		# Critic forward：输入状态 state 和动作 action，拼接后输出这个状态-动作对的 Q 值。
    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)
        return self.net(x)

actor = Actor(state_dim, action_dim, max_action).to(device)
critic = Critic(state_dim, action_dim).to(device)

target_actor = copy.deepcopy(actor)
target_critic = copy.deepcopy(critic)

1. 采样

在线 Actor 网络输入环境状态直接输出动作，并添加噪声以保证探索：

\[ a_t=μ(s_t∣θ^μ)+N_t \]

state_tensor = torch.FloatTensor(state).unsqueeze(0).to(device)

with torch.no_grad():
    action = actor(state_tensor).cpu().numpy()[0]

noise = np.random.normal(0, exploration_std, size=action_dim)

# 添加噪声
action = action + noise

action = np.clip(action, -max_action, max_action)

环境执行动作，收集 \(r_t, s_{t+1}\)，把 transition 存入 replay buffer：

\[(s_t,a_t,r_t,s_{t+1}) \]

replay_buffer.add(state, action, reward, next_state, done)

state, action, reward, next_state, done = replay_buffer.sample(batch_size, device)

2. 从 buffer 中采样 batch

3. 构造 TD target

从 replay buffer 采样一批 transition，基于每一条 transition，目标 Actor 负责输出下一个动作（不需要探索）：

\[ a'_{i+1}=μ'(s_{i+1}) \]

目标 Critic 评估 状态 | 动作 价值：

\[Q'(s_{i+1},a'_{i+1}) \]

基于 Bellman 方程得到 TD target (Advantage)：

\[y_i =r_i + \gamma Q'(s_{i+1},a'_{i+1}) \]

典型的 Q-learning 式 bootstrapping target

4. 优化

在线 Critic （梯度更新）

在线 Critic 优化目标是接近 TD-target: \(y_i\)，基于以上得到的 target，最小化 MSE loss 优化：

\[L=(Q(s,a)−y)^2 \]

Critic 的更新就是普通的均方误差反向传播：

\[θ^Q←θ^Q−α∇_{θQ}L \]

💡

如果用同一个 Critic 算 TD target 又让它自我拟合，就会出现：网络一边改预测值，一边改自己的训练标签。target 会跟着在线网络剧烈变化，训练容易震荡。在DDPG 中 Critic 更新时用 慢更新的Critic 估计下一步价值，在线更新的Critic 估计当前价值，再最小化二者误差做优化，目的是减少 bootstrapping target 自己快速变化导致的训练不稳定。

PPO/A2C 通常直接用当前/旧 critic 计算 value target，不额外维护 target critic；由于它们主要使用当前策略刚采样的数据，并且 GAE/return target 在一批更新中相对固定，所以 target 震荡问题比 DDPG 轻。DDPG 是 off-policy + replay buffer + Q-learning 式 bootstrapping，旧数据反复训练，如果 target 也用快速变化的在线 critic。因此更需要 target network 来稳定 TD target。

with torch.no_grad():
		# 通过 target_network 构造 target
    next_action = target_actor(next_state)
    target_q = target_critic(next_state, next_action)
    
    # TD target (bellman)
    y = reward + gamma * (1 - done) * target_q

current_q = critic(state, action)

critic_loss = F.mse_loss(current_q, y)

critic_optimizer.zero_grad()
critic_loss.backward()
critic_optimizer.step()

在线 Actor （梯度更新）

在线 Actor 优化目标是是让自己输出的动作能被 Critic 打更高分：

\[J(\theta^\mu)=\mathbb{E}_{s \sim \rho^\beta}\left[Q(s,\mu_{\theta^\mu}(s))\right] \]

实际训练用 minibatch 近似期望：

\[\nabla_{\theta^\mu} J\approx\frac{1}{N}\sum_{i=1}^{N}\left[\nabla_a Q(s_i,a)\big|_{a=\mu_{\theta^\mu}(s_i)}\nabla_{\theta^\mu}\mu_{\theta^\mu}(s_i)\right] \]

写成最小化 loss就是：

\[L_{\text{actor}} = -\frac{1}{N} \sum_{i=1}^{N} Q(s_i,\mu_{\theta^\mu}(s_i)) \]

更新时用在线 Critic 的动作梯度更新在线 Actor

\[\theta^\mu\leftarrow\theta^\mu-\alpha_\mu\nabla_{\theta^\mu} L_\mu \]

actor_action = actor(state)

actor_loss = -critic(state, actor_action).mean()

actor_optimizer.zero_grad()
actor_loss.backward()
actor_optimizer.step()

目标网络 （soft update）

主网络负责快速学习，target network 负责提供相对稳定的学习目标。target critic 和 target actor 不参与梯度更新，只从主网络慢慢复制：

\[θ^{Q'}←τθ^{Q'}+(1−τ)θ^{Q'} \]

\[θ^{μ'}←τθ^{μ'}+(1−τ)θ^{μ'} \]

\(\tau\) 远小于 1 ，比如 0.001。target value 变化更慢，从而提高训练稳定性。

def soft_update(source_net, target_net, tau):
    for source_param, target_param in zip(source_net.parameters(), target_net.parameters()):
        target_param.data.copy_(
            tau * source_param.data + (1 - tau) * target_param.data
        )

soft_update(actor, target_actor, tau=0.005)
soft_update(critic, target_critic, tau=0.005)

---

算法流程图

GPT制作 仅作参考

---

引用

1. Lillicrap, T.P., Hunt, J.J., Pritzel, A., Heess, N., Erez, T., Tassa, Y., Silver, D. and Wierstra, D. (2016) ‘Continuous control with deep reinforcement learning’, International Conference on Learning Representations (ICLR). Available at: arXiv:1509.02971.