返回论文笔记资料库
arXiv 2017强化学习论文笔记

PPO

TRPO Lite

原始论文

Proximal Policy Optimization Algorithms

论文作者

John Schulman · Filip Wolski · Prafulla Dhariwal · Alec Radford · Oleg Klimov

发表版本
正式发表信息尚未核实
arXiv 首次提交
arXiv:1707.06347
引用此论文 · BibTeX

引用信息对应所链接的论文版本,作者为原论文作者。

@misc{reinforcementlearningppo2017,
  title = {{Proximal Policy Optimization Algorithms}},
  author = {John Schulman and Filip Wolski and Prafulla Dhariwal and Alec Radford and Oleg Klimov},
  year = {2017},
  eprint = {1707.06347},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1707.06347}
}
本页内容

2017 年想用深度强化学习训练一个策略,大概有三种选择,各有各的毛病。

DQN 在 Atari 上很强,碰到连续控制(例如机器人关节要输出多大的力)就不太行。一般的策略梯度方法实现简单,但很浪费数据,每批交互数据只能用来更新一次。TRPO 比较省数据,也比较稳,可是要解一个带约束的优化问题,得用共轭梯度法近似二阶信息,代码复杂;网络里如果有 dropout,或者策略与价值函数共享参数,TRPO 也不好处理。

OpenAI 的 Schulman 是 TRPO 的第一作者。这篇 PPO(Proximal Policy Optimization)是他和同事给出的简化版,目标是保留 TRPO 的数据效率与稳定性,但只用一阶优化,也就是一般的 SGD 或 Adam。作者在结论里说,从普通的策略梯度实现改成 PPO,只要改几行代码。(实际要改的地方多得多,后面会讲)

后来 InstructGPT 用 PPO 微调语言模型,PPO 也就成了 RLHF 最常用的强化学习算法。

定义问题

最常见的策略梯度估计量是:

g^=E^t[∇θlog⁡πθ(at∣st) A^t]\hat g = \hat{\mathbb{E}}_t\left[\nabla_\theta \log \pi_\theta(a_t\mid s_t)\,\hat A_t\right]

E^t\hat{\mathbb{E}}_t 是对一批样本取平均。用自动微分实现时,会写一个目标函数,让它的梯度刚好等于上式:

LPG(θ)=E^t[log⁡πθ(at∣st) A^t]L^{PG}(\theta) = \hat{\mathbb{E}}_t\left[\log \pi_\theta(a_t\mid s_t)\,\hat A_t\right]

收集数据很贵,自然会想对同一批轨迹多做几步优化。作者说这么做没有理论依据,实验上常导致破坏性的大幅更新:策略一下子跳得太远,表现崩掉,又因为之后收集的数据都来自这个坏策略,很难救回来。

TRPO 的处理方式是在更新时加上约束:

max⁡θ E^t[πθ(at∣st)πθold(at∣st)A^t]s.t.E^t[KL[πθold(⋅∣st), πθ(⋅∣st)]]≤δ\max_\theta\ \hat{\mathbb{E}}_t\left[\frac{\pi_\theta(a_t\mid s_t)}{\pi_{\theta_{\text{old}}}(a_t\mid s_t)}\hat A_t\right] \quad \text{s.t.}\quad \hat{\mathbb{E}}_t\left[\mathrm{KL}\left[\pi_{\theta_{\text{old}}}(\cdot\mid s_t),\ \pi_\theta(\cdot\mid s_t)\right]\right] \le \delta

新旧策略之间的 KL 散度不能超过 δ\delta。这就是「信赖域」:只在旧策略附近找更好的策略。

理论上其实更支持用惩罚项取代约束,也就是最大化目标再减去 β⋅KL\beta\cdot\mathrm{KL}。TRPO 没这么做,因为很难挑出一个在各种问题上都好用的 β\beta,甚至同一个问题在训练的不同阶段,合适的 β\beta 也会变。作者也试过固定 β\beta 加 SGD,结果不够好。

所以问题是,能不能只用一阶方法,也能在同一批数据上放心地多跑几轮,又不让策略跳得太远?

解决问题

概率比与裁剪

先定义新旧策略的概率比:

rt(θ)=πθ(at∣st)πθold(at∣st)r_t(\theta) = \frac{\pi_\theta(a_t\mid s_t)}{\pi_{\theta_{\text{old}}}(a_t\mid s_t)}

刚开始更新时 θ=θold\theta=\theta_{\text{old}},所以 rt=1r_t=1。TRPO 最大化的目标可以写成 LCPI=E^t[rt(θ)A^t]L^{CPI}=\hat{\mathbb{E}}_t[r_t(\theta)\hat A_t],CPI 指 conservative policy iteration。没有约束的话,最大化它会让 rtr_t 被推得很远。

PPO 的主要目标是:

LCLIP(θ)=E^t[min⁡(rt(θ)A^t, clip(rt(θ),1−ϵ,1+ϵ)A^t)]L^{CLIP}(\theta) = \hat{\mathbb{E}}_t\left[\min\left(r_t(\theta)\hat A_t,\ \mathrm{clip}\left(r_t(\theta), 1-\epsilon, 1+\epsilon\right)\hat A_t\right)\right]

ϵ\epsilon 是超参数,论文的默认值是 0.2。min 里的第一项就是 LCPIL^{CPI};第二项把概率比裁剪到 [1−ϵ,1+ϵ][1-\epsilon, 1+\epsilon];最后取两者中较小的那个。

为什么要取 min?我们拿几个数字实际算一遍。假设旧策略选某个动作的概率都是 0.30,更新后变成不同的值,再搭配正或负的优势:

python
import torch

eps = 0.2
logp_old = torch.log(torch.tensor([0.30, 0.30, 0.30, 0.30, 0.30]))
p_new = torch.tensor([0.33, 0.39, 0.18, 0.45, 0.18], requires_grad=True)
adv = torch.tensor([2.0, 2.0, -1.0, -1.0, 2.0])

ratio = torch.exp(torch.log(p_new) - logp_old)
unclipped = ratio * adv
clipped = torch.clamp(ratio, 1 - eps, 1 + eps) * adv
objective = torch.min(unclipped, clipped)
objective.sum().backward()

print(ratio.detach())      # tensor([1.1000, 1.3000, 0.6000, 1.5000, 0.6000])
print(objective.detach())  # tensor([ 2.2000,  2.4000, -0.8000, -1.5000,  1.2000])
print(p_new.grad)          # tensor([ 6.6667,  0.0000,  0.0000, -3.3333,  6.6667])

实现上通常存的是对数概率,所以概率比写成两者相减再取指数。逐个看这五个样本:

  1. 好动作,稍微变多(r=1.1r=1.1,A^=2\hat A=2):还在范围内,两项相同,梯度正常,继续把概率往上推。
  2. 好动作,已经变太多(r=1.3r=1.3):裁剪项是 1.2×2=2.41.2\times2=2.4,比未裁剪的 2.6 小,min 选中裁剪项。裁剪项对参数的梯度是零,这个样本不再推动更新。
  3. 坏动作,已经压得够低(r=0.6r=0.6,A^=−1\hat A=-1):裁剪项 0.8×(−1)=−0.80.8\times(-1)=-0.8 比未裁剪的 −0.6-0.6 小,同样选中裁剪项,梯度归零。
  4. 坏动作,概率反而变高(r=1.5r=1.5):未裁剪项 −1.5-1.5 更小,min 选它,梯度是负的,把概率往下拉。
  5. 好动作,概率反而变低(r=0.6r=0.6,A^=2\hat A=2):未裁剪项 1.2 比裁剪项 1.6 小,min 选它,梯度照样把概率往上推。

第 2、3 个样本体现了裁剪的作用,已经往正确方向走过头的样本,不能再提供更多奖励。第 4、5 个样本体现了 min 的作用,往错误方向走的样本不受裁剪保护,照样受罚。作者的说法是,概率比的变化只有在让目标变好时才被忽略,让目标变差时一定会算进去。因此 LCLIPL^{CLIP} 是未裁剪目标的一个悲观下界。

原论文 Figure 1:单个时间步的 L^CLIP 关于概率比 r 的函数。左图为优势大于 0 的情况,r 超过 1+ε 后曲线变平;右图为优势小于 0 的情况,r 低于 1−ε 后曲线变平。两图的红点标出优化起点 r=1。
原论文 Figure 1(Schulman 等人),取自 PDF 第 3 页,arXiv 许可,学术引用。

这张图把刚才的五个样本画成了曲线。左图是优势为正,红点在 r=1r=1 起步,往右走时目标线性增加,超过 1+ϵ1+\epsilon 就变平,再往右也拿不到更多;往左走(概率变低)则一路下降,没有任何保护。右图是优势为负,方向相反,低于 1−ϵ1-\epsilon 之后变平。

在 r=1r=1 附近,LCLIPL^{CLIP} 和 LCPIL^{CPI} 的一阶近似相同,所以第一步的梯度和没有裁剪时一样。两者只在参数离开 θold\theta_{\text{old}} 之后才分开。

原论文 Figure 2:从旧策略参数沿 PPO 一次更新的方向做线性插值时,四个量的变化。蓝线为平均 KL,橙线为 L^CPI,绿线为裁剪项,红线为 L^CLIP。横轴 0 是旧参数,1 是更新后的参数。
原论文 Figure 2(Schulman 等人),取自 PDF 第 4 页,arXiv 许可,学术引用。

这张图换个角度看同一件事。作者在 Hopper-v1 上做第一次 PPO 更新,然后把参数从旧值(横轴 0)沿着更新方向插值到新值(横轴 1),再往外延伸。橙线 LCPIL^{CPI} 一路往上,看起来走得越远越好;蓝线的 KL 也一路增加。红线 LCLIPL^{CLIP} 则在 1 附近达到最高点后下降,那里的 KL 约 0.02。裁剪目标自己就有一个「别再往前」的顶点,不需要额外的约束。

另一个选项:自适应的 KL 惩罚

作者也提出了一个替代方案,作为重要的比较基准。目标函数是概率比乘优势再减去 β⋅KL\beta\cdot\mathrm{KL},每次更新后测一次实际的平均 KL dd,再调整 β\beta:

  • d<dtarg/1.5d < d_{\text{targ}}/1.5:β←β/2\beta \leftarrow \beta/2,惩罚太重,放松一点。
  • d>dtarg×1.5d > d_{\text{targ}}\times1.5:β←β×2\beta \leftarrow \beta\times2,跑太远了,罚重一点。

1.5 和 2 是经验值,作者说算法对它们不太敏感,β\beta 的初始值也很快会被调整过来。偶尔会有某次更新的 KL 离目标很远,但很少见。

完整的算法

实际训练时,策略网络常和价值网络共享参数,所以目标要合并策略项、价值函数误差与熵奖励:

LtCLIP+VF+S(θ)=E^t[LtCLIP(θ)−c1LtVF(θ)+c2S[πθ](st)]L^{CLIP+VF+S}_t(\theta) = \hat{\mathbb{E}}_t\left[L^{CLIP}_t(\theta) - c_1 L^{VF}_t(\theta) + c_2 S[\pi_\theta](s_t)\right]

LtVF=(Vθ(st)−Vttarg)2L^{VF}_t=(V_\theta(s_t)-V^{\text{targ}}_t)^2 是价值函数的平方误差,SS 是熵,用来鼓励探索。

优势的估计用截断版的 GAE(generalized advantage estimation):

A^t=δt+(γλ)δt+1+⋯+(γλ)T−t−1δT−1,δt=rt+γV(st+1)−V(st)\hat A_t = \delta_t + (\gamma\lambda)\delta_{t+1} + \cdots + (\gamma\lambda)^{T-t-1}\delta_{T-1}, \qquad \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)

δt\delta_t 是单步的时序差分误差,λ\lambda 控制要往后看多远;λ=1\lambda=1 时就退化成 A3C 用的有限长度估计。这里的 rtr_t 是环境奖励,别和前面的概率比 rt(θ)r_t(\theta) 搞混,原论文两个都用 rr。

整个流程是 Algorithm 1:

  1. NN 个并行的 actor,各用当前的策略 πθold\pi_{\theta_{\text{old}}} 跑 TT 步,算出每一步的优势。
  2. 用这 NTNT 条数据,以大小为 MM 的小批量跑 KK 个 epoch,优化上面的目标。
  3. θold←θ\theta_{\text{old}} \leftarrow \theta,回到第 1 步。

拿论文的 MuJoCo 设置算一下。每次迭代收集 T=2048T=2048 步,小批量 64、跑 10 个 epoch,相当于每批数据做 2048/64×10=3202048/64\times10=320 次梯度更新。一般的策略梯度方法,同一批数据只做 1 次。Atari 的设置是 8 个 actor 各跑 128 步,共 1,024 步,小批量 256、3 个 epoch,每批数据做 12 次更新,裁剪参数 ϵ=0.1\epsilon=0.1,并随训练线性递减到 0。

(有意思的是,后来 InstructGPT 用 PPO 微调语言模型时,每批数据只跑了一个 epoch,PPO 最得意的「同一批多用几次」反而没用上。)

讨论

哪一种替代目标最好

第一组实验比较不同的替代目标(surrogate objective),每种都扫了一遍超参数。测试环境是 7 个 MuJoCo 连续控制任务,每个训练 100 万步、跑 3 个随机种子。分数取最后 100 个回合的平均总奖励,再把每个环境归一化成随机策略 0 分、最好的结果 1 分,最后把 21 次结果平均成一个数字。策略是两层各 64 单元的 MLP,不共享参数,也不加熵奖励。

设置平均归一化分数
不裁剪、不惩罚-0.39
裁剪,ϵ=0.1\epsilon=0.10.76
裁剪,ϵ=0.2\epsilon=0.20.82
裁剪,ϵ=0.3\epsilon=0.30.70
自适应 KL,dtarg=0.003/0.01/0.03d_{\text{targ}}=0.003 / 0.01 / 0.030.68 / 0.74 / 0.71
固定 KL,β=0.3/1/3/10\beta=0.3 / 1 / 3 / 100.62 / 0.71 / 0.72 / 0.69

整理自原论文 Table 1。

不裁剪也不惩罚的版本是负分,主要因为 HalfCheetah 上的分数比随机策略还差,正是前面说的破坏性大幅更新。裁剪版以 ϵ=0.2\epsilon=0.2 最好;两种 KL 惩罚的最佳设置落在 0.72 到 0.74,差距不大,但都低于裁剪。作者也试过在对数空间做裁剪,没有更好。

和其他算法比

原论文 Figure 3:七个 MuJoCo 环境(HalfCheetah、Hopper、InvertedDoublePendulum、InvertedPendulum、Reacher、Swimmer、Walker2d)训练一百万步的学习曲线,比较 A2C、A2C + Trust Region、CEM、PPO (Clip)、Vanilla PG Adaptive 与 TRPO。
原论文 Figure 3(Schulman 等人),取自 PDF 第 7 页,arXiv 许可,学术引用。

紫线是 PPO。比较对象包括调好的 TRPO、交叉熵方法(CEM)、自适应步长的一般策略梯度、A2C,以及加上信赖域的 A2C。作者的结论是 PPO 在几乎所有环境上都胜出。差距最大的是 Walker2d,PPO 到 3,000 左右,其他方法都在 1,200 以下;HalfCheetah 也明显领先。Swimmer 是例外,TRPO(浅蓝线)最后略高于 PPO。

作者另外在 Roboschool 的 3D 人形机器人上展示了 PPO,任务包括往前跑、追逐随机移动的目标,以及一边被方块砸一边从地上爬起来。这组实验只有学习曲线与画面,没有和其他算法比较。

Atari:学得快,最终分数互有胜负

Atari 的比较对象是 A2C 和 ACER,三者用同样的网络架构,A2C 与 ACER 的超参数是针对这组游戏调过的。49 款游戏,每款 3 次实验,用两种指标各算一次每个算法赢了几款游戏:

指标A2CACERPPO平局
整个训练期间的平均回合奖励118300
最后 100 个回合的平均奖励128191

整理自原论文 Table 2。

第一个指标偏向学得快的方法,第二个偏向最终表现。PPO 在前者明显领先,最终表现则是 ACER 赢得更多。附录里每款游戏的分数,两边都有极端的例子。Enduro 上 A2C 和 ACER 都是 0 分,PPO 有 758;Kangaroo 是 45、50 对 9,929。反过来,Gopher 上 ACER 有 37,802,PPO 只有 2,933;DemonAttack 是 38,808 对 11,378。作者对 ACER 的评价是表现相近,但 PPO 简单得多。

裁剪真的在起作用吗

PPO 很快成了默认算法,后续研究也开始追问它的效果从哪里来。

MIT 的 Engstrom 等人在 2020 年的 Implementation Matters in Deep Policy Gradients 把焦点放在官方实现里的一些「小细节」上。例如价值函数的损失也做裁剪、用折扣回报的标准差缩放奖励、正交初始化、Adam 学习率退火、观测值归一化与裁剪、全局梯度范数裁剪到 0.5。论文本身没有强调这些细节。Engstrom 等人的结论是,PPO 相对 TRPO 的累积奖励优势,大部分来自这些代码层面的优化。

他们还测了概率比。PPO 训练过程中,最大的概率比会持续超过 1+ϵ1+\epsilon,裁剪并没有把策略关在这个范围内。回到刚才的代码就能理解。裁剪只让超出范围的样本梯度归零,但参数是所有样本共享的,其他样本的梯度照样会把参数往前推,顺带把已经超出范围的那个样本推得更远。第一个 epoch 开始时所有 rt=1r_t=1,那一步和没有裁剪完全一样,步子迈多大取决于目标函数的陡峭程度。

他们又做了一个 PPO-NoClip:保留这些代码细节,但去掉裁剪。在 Walker2d、Hopper、Humanoid 上,它的分数分别是 2,867、2,371、831,标准 PPO 是 3,292、2,513、806。Walker2d 上仍差了约 400 分,Hopper 的差距落在置信区间附近,Humanoid 反而是没有裁剪的版本略高。保留裁剪、去掉代码细节的最小版本 PPO-M,三项都比 PPO-NoClip 低。作者的结论是,裁剪的重要性常常不及这些代码细节。

另一份常被引用的整理是 Huang 等人 2022 年在 ICLR 博客发表的 The 37 Implementation Details of Proximal Policy Optimization。他们逐行对照 OpenAI baselines 的实现,整理出 13 个核心细节,以及 Atari、连续控制、LSTM 等场景下的额外细节。例如优势归一化是在每个小批量内做,不是整批做;价值函数裁剪这一项,Engstrom 等人找不到它有帮助的证据,另一份大规模研究甚至认为它有害。他们也提到,连原始实现本身跑出来的结果都不太一致。

这些研究没有推翻 PPO,它在这些实验里仍是表现最好的设置之一。它们修正的是「为什么有效」的说法。裁剪目标让多个 epoch 的更新比较安全,但要稳定复现论文的数字,那些没写进论文的代码细节同样重要。

用在语言模型上

用在语言模型上时,每个 token 是一个动作,整段回答是一条轨迹。InstructGPT 在 PPO 之外,又加了一项对 SFT 模型的 KL 惩罚,避免模型为了讨好奖励模型而跑得太远。后来 DeepSeek 的 GRPO 去掉了价值网络,改用同一道题多个回答的分数互相比较来估计优势,那个 clip 加 min 的写法则沿用了下来。

结论

PPO 的核心只有一行目标函数。clip 让往对的方向走太远的样本不再加分,min 让往错的方向走的样本照样扣分,同一批数据就能放心多跑几轮。

真要自己写的话,论文的公式只能带你走一半。优势归一化、奖励缩放、价值函数裁剪这些细节论文没写,成绩却很吃它们,照着那份 37 个细节的清单一条条对过去最省事。

这几年大家一直在拆 PPO 的零件,DPO 拆掉了强化学习,GRPO 拆掉了价值网络。那个 clip,倒是一直留到了现在。