1. 从基础PPO到进阶PPO2:为什么Hopper-v4需要更精细的调优?
如果你之前跟着我的文章用PPO算法玩过Pendulum-v1,可能会觉得PPO挺“稳”的,调调参数就能出不错的效果。但当你把同样的代码搬到Hopper-v4环境时,很可能就傻眼了:那个单腿机器人要么瘫在地上起不来,要么抽搐两下就摔倒,训练曲线像心电图一样波动,收敛速度慢得让人抓狂。我刚开始踩这个坑的时候,也一度怀疑是不是代码写错了。其实,这不是代码问题,而是环境特性对算法提出了更高的要求。
Hopper-v4是个连续控制环境,目标是让一个二维的单腿机器人学会向前跳跃并保持平衡。它的状态空间有11维,包括关节角度、角速度、身体位置等;动作空间是3维,对应三个关节的扭矩。听起来好像不复杂,但难点在于:奖励函数非常稀疏且包含惩罚项。机器人不仅要学会跳,还要避免“摔倒”(触地惩罚),同时动作不能太“费电”(控制成本惩罚)。这就导致智能体在探索初期很难获得正向奖励,很容易陷入局部最优——比如直接躺平,虽然不跳,但至少不会因为乱动而扣分。
基础PPO算法在这里显得有点“力不从心”。它的策略梯度估计可能方差很大,特别是在奖励稀疏的情况下;它的重要性采样如果比例(ratio)失控,更新一步就可能让策略崩掉;它一次只用一个episode的数据来更新,数据效率太低。所以,我们需要一套“组合拳”来优化,这就是PPO2的由来。它不是颠覆PPO,而是在PPO的框架上,针对像Hopper-v4这类更复杂、更敏感的环境,做了几处关键的手术刀式的改进。核心思路就三点:让优势估计更稳定、让策略输出更可控、让数据利用更充分。接下来,我就带你一步步拆解这些优化技巧,并附上我调试了无数次的代码和参数,保证你能复现出那个活蹦乱跳的Hopper。
2. 稳定训练的核心:优势函数(Advantage)的批归一化
优势函数 A(s, a) 是PPO更新的灵魂,它告诉智能体“当前动作比平均动作好多少”。如果 A 的估计不准或者波动太大,策略更新就会像醉汉走路,东倒西歪。在Hopper-v4里,由于奖励包含正负项且量级可能不同,计算出的 td_delta(时序差分误差)和后续的 advantage 很容易出现数值不稳定,有的步是很大的正数,有的步是很大的负数。
2.1 为什么简单的GAE(广义优势估计)还不够?
我们通常用GAE来估算优势函数,它平衡了偏差和方差,是个很好的工具。但即使用了GAE,在一个episode内部或者不同episode之间,advantage 的数值分布可能差异巨大。想象一下,Hopper偶然跳了一步,这一步的奖励可能很高,导致这一小段轨迹的 advantage 显著大于其他趴着的时刻。如果直接把这一批数据扔进去训练,神经网络会过度关注那些 advantage 绝对值大的样本,而忽略了其他样本的信号,这会导致策略更新不稳定,甚至发散。
我最初没做归一化时,经常看到 actor_loss 剧烈震荡,策略一会儿激进一会儿保守,机器人学得精神分裂。批归一化(Batch Normalize) 在这里的作用,就是对每一批用于更新的 advantage 进行标准化,减去均值,除以标准差,将其转换为均值为0、标准差为1的分布。这样做有两个巨大的好处:
- 稳定梯度:无论原始优势值是多少,归一化后都处在相近的数值范围,使得策略网络(Actor)的梯度幅度更可控,更新更平滑。
- 加速收敛:网络不再需要费力去适应动态范围变化巨大的输入信号,可以更专注于学习状态-动作映射关系本身。
2.2 在代码中如何实现?关键在 mini_batch 函数
这个技巧的实现位置非常关键,不是在计算GAE的时候,而是在构造训练数据加载器(DataLoader)的时候。我们来看核心的 mini_batch 函数,它作为 collate_fn 传递给 DataLoader。
import torch
from functools import partial
def mini_batch(batch, mini_batch_size):
"""
将一个大batch拆分成多个小mini-batch,并对每个mini-batch内的advantage进行归一化。
batch: 一个元组,包含 (state, action, old_log_prob, advantage, td_target)
"""
state, action, old_log_prob, adv, td_target = batch
batch_size = state.size(0)
indices = torch.randperm(batch_size) # 随机打乱索引
mini_batches = []
for start in range(0, batch_size, mini_batch_size):
end = start + mini_batch_size
idx = indices[start:end]
mb_state = state[idx]
mb_action = action[idx]
mb_old_log_prob = old_log_prob[idx]
mb_adv = adv[idx]
mb_td_target = td_target[idx]
# 关键步骤:对mini-batch内的advantage进行归一化
if len(mb_adv) > 1: # 确保有多个样本才能计算标准差
mb_adv = (mb_adv - mb_adv.mean()) / (mb_adv.std() + 1e-8) # 加个极小值防止除零
mini_batches.append((mb_state, mb_action, mb_old_log_prob, mb_adv, mb_td_target))
return mini_batches
# 在PPO2的__init__中,这样绑定参数
self.min_batch_collate_func = partial(mini_batch, mini_batch_size=self.minibatch_size)
注意,这里是对每个 mini_batch 独立做归一化,而不是对整个epoch的数据做。这是因为PPO要进行多轮(k_epochs)更新,每次用打乱后的数据,如果基于全局统计量归一化,会破坏数据独立性并引入偏差。这种“在线”、“局部的归一化”是稳定PPO训练的一个非常实用的trick。实测下来,加上这个操作后,Hopper-v4的训练曲线平滑了很多,策略性能的提升也更快更稳。
3. 策略网络输出改造:从高斯分布到Beta分布
在连续动作空间中,PPO通常用高斯分布(正态分布)来表示策略,即给定一个状态,输出每个动作维度的均值和标准差,然后从中采样。这在很多环境中工作良好,但用在Hopper-v4上有个潜在问题:高斯分布的理论范围是负无穷到正无穷,而Hopper-v4的动作空间通常被限制在 [-1, 1] 或 [-2, 2] 之间。虽然我们可以用 tanh 把输出压到这个范围,但高斯分布的“长尾”特性意味着它总会以一定的概率密度分布在边界之外,采样后经过裁剪(clip)会改变真实的动作分布,从而在计算对数概率 log_prob 时产生误差,这个误差在重要性采样中会被放大。
3.1 Beta分布的优势:天生就在[0,1]区间
Beta分布是定义在区间 [0, 1] 上的连续概率分布,由两个形状参数 α 和 β 控制。它的概率密度函数在边界处可以趋于0,这意味着智能体可以学会“自觉地”将动作概率集中在有效范围内,避免了边界裁剪带来的理论问题。对于动作边界对称的环境(如 [-1, 1]),我们可以很方便地将Beta分布输出的 [0, 1] 线性映射到 [low, high]。
我自己的实验对比非常明显:使用高斯分布时,策略网络需要额外学习如何通过 tanh 和后续处理来“模拟”一个边界分布,初期探索效率低,且容易在边界附近产生高方差更新。换成Beta分布后,策略网络直接输出α和β,通过一个简单的 MaxMinScale 将采样值 a_beta ~ Beta(α,β) 映射到目标区间,动作的探索更加“规矩”,训练初期策略改进的方向也更明确。
3.2 代码实现:修改策略网络和动作转换
首先,我们需要一个能输出Beta分布参数的策略网络头。这里假设我们的基础网络 policyNet 已经可以根据 dist_type 参数来切换输出层。
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Beta, Normal
class policyNet(nn.Module):
def __init__(self, state_dim, hidden_dims, action_dim, dist_type='beta'):
super().__init__()
self.dist_type = dist_type
# 共享的特征提取层
layers = []
prev_dim = state_dim
for h_dim in hidden_dims:
layers.append(nn.Linear(prev_dim, h_dim))
layers.append(nn.ReLU())
prev_dim = h_dim
self.shared = nn.Sequential(*layers)
# 根据分布类型定义输出层
if dist_type == 'beta':
# Beta分布需要为每个动作维度输出两个参数: alpha, beta
self.alpha_head = nn.Linear(prev_dim, action_dim)
self.beta_head = nn.Linear(prev_dim, action_dim)
# 初始化输出为正数,Beta分布参数需大于0
nn.init.constant_(self.alpha_head.bias, 1.0)
nn.init.constant_(self.beta_head.bias, 1.0)
else: # 默认为高斯分布
self.mean_head = nn.Linear(prev_dim, action_dim)
self.log_std_head = nn.Parameter(torch.zeros(1, action_dim))
def get_dist(self, state, action_bound=1.0):
features = self.shared(state)
if self.dist_type == 'beta':
# 用softplus确保参数为正
alpha = F.softplus(self.alpha_head(features)) + 1e-4
beta = F.softplus(self.beta_head(features)) + 1e-4
dist = Beta(alpha, beta)
else:
mean = self.mean_head(features)
log_std = self.log_std_head.expand_as(mean)
std = torch.exp(log_std)
dist = Normal(mean, std)
return dist
在PPO2代理中,我们需要增加动作的转换函数,用于在Beta分布采样值与环境实际动作范围之间进行映射。
class PPO2:
def __init__(self, ...):
# ... 其他初始化 ...
self.dist_type = dist_type
self.action_low = torch.tensor(action_space.low, device=device)
self.action_high = torch.tensor(action_space.high, device=device)
def _action_fix(self, act):
"""将策略网络输出的动作(Beta分布时为0~1)映射到环境实际范围"""
if self.dist_type == 'beta':
# 线性映射: 0 -> action_low, 1 -> action_high
return act * (self.action_high - self.action_low) + self.action_low
# 高斯分布通常用tanh,这里省略
return act
def _action_return(self, act):
"""将环境实际范围的动作映射回策略网络使用的范围(用于log_prob计算)"""
if self.dist_type == 'beta':
# 逆映射
return (act - self.action_low) / (self.action_high - self.action_low)
return act
def policy(self, state):
state = torch.FloatTensor([state]).to(self.device)
action_dist = self.actor.get_dist(state)
raw_action = action_dist.sample()
env_action = self._action_fix(raw_action)
return env_action.cpu().detach().numpy()[0]
在 update 函数中计算新的对数概率时,一定要记得用 _action_return 把存储的动作转换回网络对应的空间,这样才能和分布对象正确计算 log_prob。这个细节很容易出错,一旦弄错,ratio 的计算就全乱了。
4. 提升数据效率:多Episode数据合并与训练策略
基础PPO通常是收集一个episode的数据,马上就用这些数据更新策略 k_epochs 轮,然后清空缓冲区,继续下一个episode。这种方式在简单环境没问题,但在Hopper-v4这种需要大量探索的环境里,数据效率太低。一个episode可能只有几十步(如果很快摔倒),用这么少的数据反复更新,很容易过拟合到当前这个糟糕的策略上,导致学习停滞。
4.1 收集多个Episode再更新
PPO2的一个核心改进是:我们不再用一个episode的数据更新,而是用一个固定容量的缓冲区,收集多个episode的轨迹,攒够一定量后再一次性进行多轮更新。这类似于离线策略算法中的“经验回放”思想,但区别在于,PPO2收集的仍然是当前策略产生的数据(on-policy),只是延迟更新。这样做的好处是:
- 数据多样性增加:多个episode的样本混合在一起,包含了策略在不同状态下的探索结果,减少了更新的方差。
- 更新更稳定:用更大、更混合的批次进行更新,梯度方向更具代表性,避免了因单个episode的偶然性(比如运气好跳了一下)导致的策略突变。
- 计算更高效:减少了策略更新(反向传播)的频率,增加了数据收集的比重,整体上更能充分利用计算资源。
4.2 实现细节:数据准备与DataLoader的使用
在代码中,这体现在 data_prepare 和 update 方法里。我们维护一个列表 samples_list,里面每个元素是一个deque,存储一个完整episode的 (s, a, r, s', done) 元组。
def data_prepare(self, samples_list: List[deque]):
"""处理多个episode的数据,分别计算优势,然后合并"""
state_pt_list, action_pt_list = [], []
old_log_probs_pt_list, advantage_pt_list, td_target_pt_list = [], [], []
for sample in samples_list: # 遍历每个episode
# 对单个episode进行预处理,计算优势等
state_i, action_i, old_log_probs_i, advantage_i, td_target_i = self._one_deque_pp(sample)
# 存入列表
state_pt_list.append(state_i)
action_pt_list.append(action_i)
old_log_probs_pt_list.append(old_log_probs_i)
advantage_pt_list.append(advantage_i)
td_target_pt_list.append(td_target_i)
# 将所有episode的数据在batch维度拼接起来
state = torch.cat(state_pt_list)
action = torch.cat(action_pt_list)
old_log_probs = torch.cat(old_log_probs_pt_list)
advantage = torch.cat(advantage_pt_list)
td_target = torch.cat(td_target_pt_list)
return state, action, old_log_probs, advantage, td_target
注意,_one_deque_pp 内部会为每个episode独立计算GAE,因为优势估计依赖于该episode的奖励序列。计算完后再合并,这样保证了时序上的正确性。合并后的大数据集,我们用PyTorch的 DataLoader 来管理,并配合前面提到的 mini_batch 函数进行小批量处理和优势归一化。
def update(self, samples_list: List[deque]):
state, action, old_log_probs, advantage, td_target = self.data_prepare(samples_list)
# 创建内存数据集和加载器
d_set = memDataset(state, action, old_log_probs, advantage, td_target)
train_loader = DataLoader(
d_set,
batch_size=self.sgd_batch_size, # 一个大batch,如512
shuffle=True,
drop_last=True,
collate_fn=self.min_batch_collate_func # 这里会拆分成小batch并归一化优势
)
# 进行k_epochs轮更新
for _ in range(self.k_epochs):
for state_, action_, old_log_prob, adv, td_v in train_loader:
# ... 计算损失、反向传播、更新网络 ...
这里的 sgd_batch_size 指的是每次从 DataLoader 取出的“大batch”大小,而 minibatch_size 是在 collate_fn 中进一步拆分的大小。我通常设置 sgd_batch_size=512, minibatch_size=64 或 128。对于Hopper-v4,我建议收集大约 4-8 个episode的数据(约 2000-4000 步)后再进行一次更新,效果比逐episode更新好得多。
5. 针对Hopper-v4的超参数调优实战
把上面的三大优化技巧组合起来,我们已经有了一个强大的PPO2算法骨架。但是,要让Hopper真正跳得又远又稳,还需要精细的超参数调优。这部分没有银弹,但有一些我反复实验得出的经验值和建议方向,可以帮你少走弯路。
5.1 网络结构与学习率
Hopper-v4的状态和动作空间不算特别高维,但任务需要一定的表示能力。我建议使用比简单环境更深的网络。
- Actor/Critic 网络:
[256, 256, 256]的三层MLP效果不错。尝试过更宽或更深的网络,有时提升不大,反而增加过拟合风险。激活函数用ReLU就行。 - 学习率:这是关键中的关键。PPO对学习率很敏感。由于我们用了多episode数据和归一化,学习率可以比标准PPO设得更低一些。
actor_lr:1e-4到3e-4之间。我最终稳定在1.5e-4。critic_lr: 价值函数学习可以稍快一点,设为5e-4到1e-3之间。我用5.5e-4。 一定要使用Adam优化器,它的自适应学习率特性在这里很有帮助。
5.2 PPO相关参数
- GAE参数 (λ):控制优势估计中多远视。
λ=0.95是常见起点,但在Hopper-v4中,我发现λ=0.9有时更好,因为它降低了远期奖励的权重,让智能体更关注近期平衡,有助于稳定学习。 - 裁剪范围 (ε):PPO的裁剪参数。标准值是
0.2。在Hopper-v4中,由于我们用了Beta分布和优势归一化,策略更新可以更“大胆”一点,我尝试了0.25甚至0.3,发现能加快初期学习速度,但需要配合更小的学习率。我建议从0.25开始。 - 更新轮数 (k_epochs):用一批数据更新多少次。数据量大了之后,
k_epochs不用太多,否则容易过拟合。4到6是一个不错的范围。我设为4。 - 折扣因子 (γ):
0.99是标准值,对于Hopper这种有持续奖励的任务很合适,不需要改动。
5.3 训练流程参数
- 每次更新的数据量:由
off_buffer_size控制。这不是传统经验回放的大小,而是触发一次策略更新所需收集的最小步数。对于Hopper,我设置off_buffer_size=2048或4096。这意味着智能体会先探索收集至少这么多步的经验(可能分布在多个episode),然后才进行一次多轮更新。 - 最大步数 (max_episode_steps):Gym环境默认是1000,但对于学习阶段,设为
500或300可以更快地结束表现不好的episode,提高数据收集效率。等策略稳定后,可以再放开。 - 总训练回合数 (num_episode):Hopper-v4要达到接近满分(约3000分以上),需要相当多的样本。准备好训练
8000到15000个episode。耐心很重要,后期分数会稳步上升。
下面是一个整合了所有优化和调参建议的配置示例,你可以直接用它作为起点:
cfg = Config(
env,
save_path='./ppo2_hopper_models',
seed=42,
# 网络参数
actor_hidden_layers_dim=[256, 256, 256],
critic_hidden_layers_dim=[256, 256, 256],
# agent参数
actor_lr=1.5e-4,
critic_lr=5.5e-4,
gamma=0.99,
# 训练参数
num_episode=12000,
off_buffer_size=4096, # 收集这么多步再更新
off_minimal_size=4000,
max_episode_steps=500,
PPO_kwargs={
'lmbda': 0.9, # GAE参数
'eps': 0.25, # PPO裁剪范围
'k_epochs': 4, # 每次数据更新轮数
'sgd_batch_size': 512, # DataLoader的大batch
'minibatch_size': 64, # 实际训练的小batch
'action_bound': 1, # 根据环境调整
'dist_type': 'beta' # 使用Beta分布
}
)
把这些参数扔进去训练,你应该能看到一个比较平滑的学习曲线。初期可能几百个episode分数都没什么起色(这是正常的,在探索),一旦它偶然发现跳起来的技巧,分数会有一个快速的跃升,之后逐渐精进。训练完成后,用 play 函数加载最佳模型观察,你会看到一个灵活的单腿机器人持续向前跳跃,那种成就感是对调试代码最好的回报。记住,强化学习实验周期长,一次训练可能要好几个小时,做好记录(比如用WandB),多尝试几组参数,你会对这些优化技巧有更深的体会。
396



被折叠的 条评论
为什么被折叠?



