告别DQN的离散局限：用DDPG和TD3搞定机器人连续动作控制（附PyTorch实战代码）

从离散到连续：DDPG与TD3在机器人控制中的实战进阶

机器人手臂精准抓取、无人机稳定飞行、自动驾驶汽车平滑转向——这些场景都需要对连续动作空间进行精细控制。传统DQN等算法在离散动作领域表现出色，但面对连续控制任务时却显得力不从心。本文将带你深入理解DDPG和TD3这两种专为连续控制设计的强化学习算法，并通过PyTorch实战演示如何实现机器人手臂的精准控制。

1. 连续动作控制的挑战与突破

在CartPole这类简单环境中，我们只需要决定"向左推"或"向右推"这样的离散动作。但现实世界的控制问题要复杂得多——机器人手臂的每个关节需要精确到度的旋转角度，无人机的每个电机需要精确到毫秒的PWM信号。这些动作不再是几个离散选项，而是可以在一定范围内任意取值的连续变量。

连续动作空间带来了几个关键挑战：

1. 动作空间无限大：无法像离散动作那样枚举所有可能动作
2. 策略梯度估计困难：传统的策略梯度方法在连续空间中方差较大
3. 探索效率问题：在广阔的动作空间中随机探索效率低下

DDPG(Deep Deterministic Policy Gradient)和它的改进版TD3(Twin Delayed DDPG)正是为解决这些问题而生。它们结合了DQN的价值函数学习和策略梯度的直接优化，形成了一种actor-critic架构：

• Actor：负责输出连续动作
• Critic：评估动作价值，指导actor更新

# 连续动作空间与离散动作空间的对比 discrete_actions = ["left", "right", "up", "down"] # 离散动作 continuous_actions = [0.253, -1.472, 2.835] # 连续动作(如三维空间中的力向量)

2. DDPG算法深度解析

DDPG可以看作是DQN向连续动作空间的扩展，它保留了DQN中的几个关键组件：

2.1 DDPG核心架构

DDPG包含四个神经网络：

• Actor网络：根据状态输出确定性动作
• Critic网络：评估状态-动作对的Q值
• 对应的目标网络：分别为target_actor和target_critic

这种双重网络结构借鉴了DQN中的目标网络思想，用于稳定训练过程。

import torch import torch.nn as nn class Actor(nn.Module): def __init__(self, state_dim, action_dim, max_action): super(Actor, self).__init__() self.layer1 = nn.Linear(state_dim, 400) self.layer2 = nn.Linear(400, 300) self.layer3 = nn.Linear(300, action_dim) self.max_action = max_action def forward(self, state): x = torch.relu(self.layer1(state)) x = torch.relu(self.layer2(x)) x = torch.tanh(self.layer3(x)) * self.max_action return x

2.2 关键实现细节

1. 动作缩放：Actor网络输出通常使用tanh激活函数将动作限制在[-1,1]范围内，然后根据实际需求进行缩放
2. 探索噪声：训练时为动作添加噪声(常用OU噪声或高斯噪声)以促进探索
3. 软更新：目标网络采用软更新方式(θ' ← τθ + (1-τ)θ')而非硬更新

# OU噪声实现示例 class OUNoise: def __init__(self, action_dim, mu=0, theta=0.15, sigma=0.2): self.action_dim = action_dim self.mu = mu self.theta = theta self.sigma = sigma self.state = np.ones(self.action_dim) * self.mu self.reset() def reset(self): self.state = np.ones(self.action_dim) * self.mu def sample(self): dx = self.theta * (self.mu - self.state) dx += self.sigma * np.random.randn(self.action_dim) self.state += dx return self.state

2.3 DDPG的局限性

尽管DDPG在连续控制任务中表现出色，但它也存在几个问题：

1. Q值高估：Critic网络容易高估Q值，导致策略性能下降
2. 超参数敏感：对学习率、噪声参数等设置较为敏感
3. 训练不稳定：策略可能因Q值的微小变化而剧烈波动

这些问题促使了TD3算法的诞生，它通过三个关键技术解决了DDPG的缺陷。

3. TD3：DDPG的稳健升级版

TD3(Twin Delayed DDPG)通过三项关键技术显著提升了DDPG的稳定性和性能：

3.1 TD3的三大创新

1. 双重Critic网络(Clipped Double Q-learning)：

   • 维护两个独立的Critic网络，取两者中较小的Q值作为目标
   • 有效防止Q值的高估

2. 延迟策略更新(Delayed Policy Updates)：

   • Critic网络更新多次后才更新一次Actor网络
   • 让价值估计更准确后再优化策略

3. 目标策略平滑(Target Policy Smoothing)：

   • 为目标动作添加噪声并裁剪
   • 使策略对动作扰动更鲁棒

# TD3的双Critic实现 class Critic(nn.Module): def __init__(self, state_dim, action_dim): super(Critic, self).__init__() # 第一个Q网络 self.layer1 = nn.Linear(state_dim + action_dim, 400) self.layer2 = nn.Linear(400, 300) self.layer3 = nn.Linear(300, 1) # 第二个Q网络 self.layer4 = nn.Linear(state_dim + action_dim, 400) self.layer5 = nn.Linear(400, 300) self.layer6 = nn.Linear(300, 1) def forward(self, state, action): sa = torch.cat([state, action], 1) q1 = torch.relu(self.layer1(sa)) q1 = torch.relu(self.layer2(q1)) q1 = self.layer3(q1) q2 = torch.relu(self.layer4(sa)) q2 = torch.relu(self.layer5(q2)) q2 = self.layer6(q2) return q1, q2

3.2 TD3与DDPG性能对比

在实际应用中，TD3几乎在所有连续控制任务上都优于DDPG，特别是在高维动作空间中优势更加明显。

4. PyTorch实战：机械臂控制

让我们通过一个完整的PyTorch实现，演示如何使用TD3算法训练机械臂到达指定位置。我们使用PyBullet的机械臂模拟环境，它提供了真实的物理仿真。

4.1 环境设置

首先安装必要依赖并初始化环境：

pip install pybullet gym numpy torch

import pybullet_envs import gym env = gym.make("KukaBulletEnv-v0") state_dim = env.observation_space.shape[0] action_dim = env.action_space.shape[0] max_action = float(env.action_space.high[0])

4.2 TD3智能体实现

以下是TD3智能体的核心代码：

class TD3: def __init__(self, state_dim, action_dim, max_action): self.actor = Actor(state_dim, action_dim, max_action).to(device) self.actor_target = Actor(state_dim, action_dim, max_action).to(device) self.actor_target.load_state_dict(self.actor.state_dict()) self.critic = Critic(state_dim, action_dim).to(device) self.critic_target = Critic(state_dim, action_dim).to(device) self.critic_target.load_state_dict(self.critic.state_dict()) self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=3e-4) self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=3e-4) self.max_action = max_action self.total_it = 0 def select_action(self, state, noise=None): state = torch.FloatTensor(state.reshape(1, -1)).to(device) action = self.actor(state).cpu().data.numpy().flatten() if noise is not None: action = (action + noise).clip(-self.max_action, self.max_action) return action def train(self, replay_buffer, batch_size=256, gamma=0.99, tau=0.005, policy_noise=0.2, noise_clip=0.5, policy_freq=2): self.total_it += 1 # 从回放缓冲区采样 state, action, next_state, reward, done = replay_buffer.sample(batch_size) with torch.no_grad(): # 添加噪声并裁剪动作 noise = (torch.randn_like(action) * policy_noise).clamp(-noise_clip, noise_clip) next_action = (self.actor_target(next_state) + noise).clamp(-self.max_action, self.max_action) # 计算目标Q值(取两个Critic中的最小值) target_Q1, target_Q2 = self.critic_target(next_state, next_action) target_Q = torch.min(target_Q1, target_Q2) target_Q = reward + (1 - done) * gamma * target_Q # 更新Critic网络 current_Q1, current_Q2 = self.critic(state, action) critic_loss = F.mse_loss(current_Q1, target_Q) + F.mse_loss(current_Q2, target_Q) self.critic_optimizer.zero_grad() critic_loss.backward() self.critic_optimizer.step() # 延迟策略更新 if self.total_it % policy_freq == 0: # 计算Actor损失 actor_loss = -self.critic.Q1(state, self.actor(state)).mean() self.actor_optimizer.zero_grad() actor_loss.backward() self.actor_optimizer.step() # 软更新目标网络 for param, target_param in zip(self.critic.parameters(), self.critic_target.parameters()): target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data) for param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()): target_param.data.copy_(tau * param.data + (1 - tau) * target_param.data)

4.3 训练循环与结果可视化

完整的训练流程如下：

def train_td3(env_name="KukaBulletEnv-v0", max_timesteps=1e6): env = gym.make(env_name) state_dim = env.observation_space.shape[0] action_dim = env.action_space.shape[0] max_action = float(env.action_space.high[0]) kwargs = { "state_dim": state_dim, "action_dim": action_dim, "max_action": max_action, } policy = TD3(**kwargs) replay_buffer = ReplayBuffer(state_dim, action_dim) state, done = env.reset(), False episode_reward = 0 episode_timesteps = 0 episode_num = 0 for t in range(int(max_timesteps)): episode_timesteps += 1 # 选择动作并添加探索噪声 if t < 10000: action = env.action_space.sample() else: noise = np.random.normal(0, max_action * 0.1, size=action_dim) action = policy.select_action(np.array(state), noise) # 执行动作 next_state, reward, done, _ = env.step(action) done_bool = float(done) if episode_timesteps < env._max_episode_steps else 0 # 存储转换到回放缓冲区 replay_buffer.add(state, action, next_state, reward, done_bool) state = next_state episode_reward += reward # 训练智能体 if t >= 10000: policy.train(replay_buffer) if done: print(f"Episode {episode_num+1} Reward: {episode_reward:.2f} Timesteps: {episode_timesteps}") state, done = env.reset(), False episode_reward = 0 episode_timesteps = 0 episode_num += 1 env.close()

在训练过程中，我们可以观察到机械臂从完全随机运动逐渐学会精准抓取目标物体的过程。典型的训练曲线会显示随着时间推移，成功率和奖励稳步上升。

5. 高级技巧与优化策略

要让DDPG/TD3在实际应用中发挥最佳性能，还需要掌握以下高级技巧：

5.1 噪声策略选择

• OU噪声：适合惯性系统，具有时间相关性
• 高斯噪声：实现简单，在大多数任务中表现良好
• 自适应噪声：随着训练进展逐渐减小噪声幅度

# 自适应噪声实现 class AdaptiveNoise: def __init__(self, action_dim, initial_std=0.2, min_std=0.01, decay_rate=0.9995): self.action_dim = action_dim self.std = initial_std self.min_std = min_std self.decay_rate = decay_rate def sample(self): noise = np.random.randn(self.action_dim) * self.std self.std = max(self.std * self.decay_rate, self.min_std) return noise

5.2 超参数调优指南

关键超参数及其影响：

5.3 实际部署注意事项

1. 仿真到现实的迁移：

   • 在仿真中训练时添加域随机化
   • 使用动力学随机化增强鲁棒性

2. 实时性考虑：

   • 优化神经网络推理速度
   • 考虑使用量化或剪枝技术

3. 安全机制：

   • 设置动作限制和安全检查
   • 实现紧急停止功能

# 安全动作限制示例 def safe_action(action, lower_bounds, upper_bounds): """ 确保动作在安全范围内 :param action: 原始动作 :param lower_bounds: 动作下限 :param upper_bounds: 动作上限 :return: 安全动作 """ return np.clip(action, lower_bounds, upper_bounds)

在真实机器人上部署时，建议先在仿真环境中充分验证算法性能，然后采用渐进式部署策略，从简单任务开始逐步增加复杂度。