强化学习学习记录（三）：TRPO、PPO、DDPG 与 SAC

19. 第 14 章：TRPO 算法

从 TRPO 开始，Actor-Critic 的问题不再只是“能不能更新”，而是“更新步子能不能稳”。TRPO 的全称是 Trust Region Policy Optimization，也就是信任区域策略优化。

它接在 Actor-Critic 后面。Actor-Critic 已经把 REINFORCE 的完整回报 $G_t$ 换成了优势或 TD 误差，训练更稳定一些。但它本质上还是策略梯度方法：沿着让策略变好的方向更新参数。

普通策略梯度最大的问题是：如果更新步子太大，新策略可能突然变得很差。

TRPO 的核心想法是：

策略可以更新，但每次不能离旧策略太远。只允许在一个“信任区域”里更新。

这个“离得远不远”，用 KL 散度衡量。

从 Actor-Critic 到 TRPO。

Actor-Critic 的 Actor 更新可以写成：

这里：

表示动作 $a$ 比当前状态的平均水平好多少。

如果优势大于 $0$，就提高这个动作概率；如果优势小于 $0$，就降低这个动作概率。

但深度网络策略不是线性函数。即使梯度方向是对的，步长太大也可能把策略改坏。比如旧策略本来是：

一次更新后如果变成：

这就不是“小幅改进”，而是几乎换了一个策略。旧策略采样得到的数据也不再可靠。

TRPO 要解决的就是这个问题。

TRPO 的目标：既要提升策略，又不能离旧策略太远。

设旧策略是：

新策略是：

TRPO 希望新策略的性能不低于旧策略：

先看策略性能差异。可以把新旧策略的差写成：

这里：

是折扣状态访问分布。

这个式子的意思是：

如果新策略在自己会访问到的状态上，选出来的动作相对旧策略有正优势，那么新策略就比旧策略好。

但这个式子很难直接优化，因为它里面有：

也就是说，我们要评估一个还没训练好的新策略，却需要先知道它会访问哪些状态。

替代目标：先用旧策略的数据估计新策略。

TRPO 做了一个近似：如果新策略和旧策略足够接近，那么它们访问状态的分布也差不多。

于是把：

近似成：

然后定义替代目标：

但动作 $a$ 仍然来自新策略 $\pi_{\theta'}$。为了能用旧策略采样到的数据，TRPO 再使用重要性采样：

于是实际优化的核心目标变成：

这里的比值：

叫重要性采样比率。

它衡量的是：

对同一个动作 $a$，新策略给它的概率是旧策略的多少倍。

KL 散度和信任区域。

如果新旧策略差得太远，上面的近似就不可靠。所以 TRPO 加了一个约束：

KL 散度衡量两个概率分布有多不一样。离散动作下：

在 TRPO 里：

• $p$ 是旧策略分布。
• $q$ 是新策略分布。
• $\delta$ 是最大允许变化幅度。

所以 TRPO 的最终优化问题是：

约束为：

直观理解：

新策略要让优势加权目标变大，但不能和旧策略差太远。

近似求解：一阶目标，二阶约束。

TRPO 的原始约束优化不好直接解，所以做泰勒近似。

令：

对目标函数做一阶近似：

其中：

是替代目标的梯度。

对 KL 约束做二阶近似：

其中 $H$ 是 KL 散度对策略参数的黑塞矩阵。

于是问题变成：

约束为：

这个形式有解析解：

因此：

这个式子是 TRPO 的核心更新方向。

可以把它理解成：

• $g$ 告诉我们目标函数希望往哪个方向变好。
• $H$ 告诉我们这个方向会让策略分布变化多大。
• $\delta$ 限制最大允许变化。
• $H^{-1}g$ 是在 KL 几何下修正后的更新方向。

为什么需要共轭梯度。

上面的公式里有：

但神经网络参数很多，$H$ 是一个巨大矩阵，直接求逆几乎不可行。

TRPO 不直接求：

而是把问题改成解线性方程：

解出来：

这个 $x$ 就是更新方向。

共轭梯度法的作用就是：在不显式构造 $H$ 的情况下，求近似的 $x$。

它只需要能算：

也就是黑塞矩阵和某个向量 $p$ 的乘积。

代码中的函数：

def hessian_matrix_vector_product(self, states, old_action_dists, vector):

就是计算：

具体做法是：

1. 计算旧策略和新策略之间的平均 KL。
2. 对 KL 求一次梯度。
3. 把这个梯度和向量 vector 点乘。
4. 再求一次梯度。

对应思想是：

这叫 Hessian-vector product。

共轭梯度代码在干什么。

代码：

def conjugate_gradient(self, grad, states, old_action_dists):
    x = torch.zeros_like(grad)
    r = grad.clone()
    p = grad.clone()
    rdotr = torch.dot(r, r)
    for i in range(10):
        Hp = self.hessian_matrix_vector_product(states, old_action_dists, p)
        alpha = rdotr / torch.dot(p, Hp)
        x += alpha * p
        r -= alpha * Hp
        new_rdotr = torch.dot(r, r)
        if new_rdotr < 1e-10:
            break
        beta = new_rdotr / rdotr
        p = r + beta * p
        rdotr = new_rdotr
    return x

这里要解的是：

变量含义：

• grad：就是 $g$。
• x：当前求出来的近似解。
• r：残差，表示当前还差多少没解好。
• p：当前搜索方向。
• Hp：黑塞矩阵乘搜索方向。

循环结束后返回的 x 就近似等于：

为什么还要线性搜索。

TRPO 前面做了泰勒近似。既然是近似，就可能出现两个问题：

1. 新策略虽然按公式更新了，但真实目标没有变好。
2. 新策略的真实 KL 超过了约束 $\delta$。

所以 TRPO 还要做线性搜索。

更新方向先算出来：

最大步长系数是：

候选更新为：

如果这个候选更新不满足条件，就缩小步长：

其中：

代码中：

coef = self.alpha ** i
new_para = old_para + coef * max_vec

就是不断尝试更短的步长。

只有满足两个条件才接受：

if new_obj > old_obj and kl_div < self.kl_constraint:
    return new_para

也就是：

并且：

如果找不到合适的新参数，就返回旧参数。

广义优势估计 GAE。

TRPO 需要优势函数：

本章使用 GAE，也就是 Generalized Advantage Estimation。

先定义 TD 误差：

一步优势估计：

两步优势估计：

三步优势估计：

GAE 把不同步数的优势估计加权平均：

其中：

当：

只看一步 TD：

方差小，但偏差可能大。

当：

接近看完整多步回报，偏差小，但方差变大。

所以 $\lambda$ 是在偏差和方差之间做平衡。

代码：

def compute_advantage(gamma, lmbda, td_delta):
    td_delta = td_delta.detach().numpy()
    advantage_list = []
    advantage = 0.0
    for delta in td_delta[::-1]:
        advantage = gamma * lmbda * advantage + delta
        advantage_list.append(advantage)
    advantage_list.reverse()
    return torch.tensor(advantage_list, dtype=torch.float)

为什么从后往前算？因为：

后一个优势 $A_{t+1}$ 会被当前 $A_t$ 用到，所以代码倒序计算。

TRPO 代码主线。

TRPO 的网络结构和 Actor-Critic 很像：

self.actor = PolicyNet(...)
self.critic = ValueNet(...)

但区别是：

self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)

这里只给 Critic 配了优化器。Actor 不用普通 Adam 直接更新，而是用 TRPO 的信任域更新。

核心更新函数是：

def update(self, transition_dict):

先算 TD 目标：

代码：

td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)

再算 TD 误差：

代码：

td_delta = td_target - self.critic(states)

然后用 GAE 算优势：

advantage = compute_advantage(self.gamma, self.lmbda, td_delta.cpu()).to(self.device)

保存旧策略下实际动作的 log 概率：

old_log_probs = torch.log(self.actor(states).gather(1, actions)).detach()

保存旧策略分布：

old_action_dists = torch.distributions.Categorical(
    self.actor(states).detach())

然后 Critic 按 Actor-Critic 的方式更新：

critic_loss = torch.mean(
    F.mse_loss(self.critic(states), td_target.detach()))

最后 Actor 用 TRPO 方式更新：

self.policy_learn(states, actions, old_action_dists, old_log_probs, advantage)

surrogate objective 代码。

代码：

def compute_surrogate_obj(self, states, actions, advantage, old_log_probs, actor):
    log_probs = torch.log(actor(states).gather(1, actions))
    ratio = torch.exp(log_probs - old_log_probs)
    return torch.mean(ratio * advantage)

这里：

log_probs

是新策略下实际动作的 log 概率：

old_log_probs 是旧策略下实际动作的 log 概率：

所以：

ratio = torch.exp(log_probs - old_log_probs)

对应：

最终：

torch.mean(ratio * advantage)

对应替代目标：

policy_learn 代码。

代码主线：

surrogate_obj = self.compute_surrogate_obj(...)
grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())
obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()
descent_direction = self.conjugate_gradient(obj_grad, states, old_action_dists)
Hd = self.hessian_matrix_vector_product(states, old_action_dists, descent_direction)
max_coef = torch.sqrt(2 * self.kl_constraint /
                      (torch.dot(descent_direction, Hd) + 1e-8))
new_para = self.line_search(...)
torch.nn.utils.convert_parameters.vector_to_parameters(
    new_para, self.actor.parameters())

逐步对应公式：

1. 算替代目标：

2. 对 Actor 参数求梯度：

3. 用共轭梯度求：

4. 计算最大可行步长：

5. 线性搜索找满足 KL 约束且目标变好的参数。

6. 用新参数替换 Actor 参数。

离散动作和连续动作的区别。

CartPole 是离散动作，所以 Actor 输出动作概率：

代码用：

torch.distributions.Categorical(probs)

Pendulum 是连续动作，所以 Actor 输出高斯分布的均值和标准差：

动作从高斯分布采样：

代码用：

torch.distributions.Normal(mu, std)

连续动作版本的策略网络：

mu = 2.0 * torch.tanh(self.fc_mu(x))
std = F.softplus(self.fc_std(x))
return mu, std

其中：

• tanh 把均值限制在一定范围。
• softplus 保证标准差为正。

TRPO 和 PPO 的关系。

TRPO 的约束是：

它很稳定，但实现复杂，因为要用：

• KL 二阶近似
• Hessian-vector product
• 共轭梯度
• 线性搜索

PPO 后面会把这个思想简化。PPO 不再显式求解复杂约束，而是用裁剪目标限制策略变化。

所以可以这样理解：

• TRPO：严格限制新旧策略的 KL 距离。
• PPO：用更简单的 clipping 近似限制策略变化。

PPO 是 TRPO 思想的工程化简化版本。

TRPO 的四个关键卡点。

这一节最后把 TRPO 最容易混的四个点放在一起看：重要性采样、泰勒近似和 Hessian、线性搜索、GAE。

重要性采样解决的是：

核心公式是：

放到 TRPO 里，旧策略是：

新策略是：

所以重要性采样比率是：

这个比率的含义是：同一个动作 $a$，新策略给它的概率是旧策略的多少倍。

泰勒近似解决的是：TRPO 原来的带约束优化问题太难直接解，所以在当前参数附近做局部近似。

目标函数用一阶近似：

其中：

表示目标函数上升最快的方向。

KL 约束用二阶近似：

这里的 $H$ 是 KL 散度对策略参数的 Hessian 矩阵。它衡量的是：参数往某个方向动一点，会让策略分布变化多大。

所以 TRPO 的近似问题是：

约束为：

它的解是：

但神经网络参数很多，不能直接求 $H^{-1}$，所以用共轭梯度解：

从而得到：

线性搜索解决的是：上面的更新方向来自近似，直接走完整步可能不安全。所以沿着同一个方向不断缩短步长：

直到同时满足：

和：

所以线性搜索不是重新找方向，而是确认这一步走多远安全。

GAE 解决的是：TRPO 需要优势函数 $A_t$，但真实优势不知道。

TD 误差是：

GAE 把后续多个 TD 误差加权累积：

递推形式是：

所以代码要从后往前算。$\lambda$ 越小越像一步 TD，方差小但偏差可能大；$\lambda$ 越大越像 MC，偏差小但方差更大。

最后把四个点串起来：

• 重要性采样：用旧策略数据估计新策略目标。
• Hessian 和二阶近似：衡量策略参数变化会让策略分布变化多大。
• 线性搜索：沿同一方向缩短步长，保证目标提升且 KL 不超标。
• GAE：用多步 TD 误差给动作估计更稳定的优势。

小结。

TRPO 解决的问题是：

它的核心约束是：

它的核心优化目标是：

它的近似解是：

实现时不直接求 $H^{-1}$，而是用共轭梯度解：

再用线性搜索保证：

并且：

我最后用三句话记这一章：

• TRPO 是 Actor-Critic 框架下更稳定的策略优化方法。
• 它用 KL 散度限制新旧策略距离，避免策略一步更新过大。
• 它用共轭梯度和线性搜索近似求解带 KL 约束的策略优化问题。

参考链接：

• 学习平台：TRPO 算法
• 原教材：TRPO 算法
• 配套代码：第 11 章 TRPO

20. 第 15 章：PPO 算法

PPO 接在 TRPO 后面看最顺。它保留“新策略不要离旧策略太远”的想法，但把 TRPO 复杂的二阶约束换成了更容易写代码的目标函数。PPO 的全称是 Proximal Policy Optimization，近端策略优化。

TRPO 的思想很好：限制新旧策略距离，让策略不要一次更新太猛。但 TRPO 实现复杂，需要：

• KL 约束
• Hessian-vector product
• 共轭梯度
• 线性搜索

PPO 继承 TRPO 的核心思想：

但它用更简单的目标函数来实现这个限制。

PPO 和 TRPO 的关系。

TRPO 的优化目标是：

约束为：

这里的核心仍然是重要性采样比率：

它表示：新策略对当前动作的概率，相比旧策略放大或缩小了多少。

如果：

说明新策略更倾向于这个动作。

如果：

说明新策略更不倾向于这个动作。

TRPO 通过 KL 约束控制 $r_t(\theta)$ 不要变化太极端。PPO 的思路是：不再复杂地解 KL 约束，而是在目标函数里直接惩罚或截断这种变化。

PPO 有两种形式：

• PPO-Penalty：把 KL 散度作为惩罚项放进目标函数。
• PPO-Clip：直接把重要性采样比率截断在一个范围内。

实践中 PPO-Clip 更常用。

PPO-Penalty。

PPO-Penalty 把 TRPO 的 KL 约束放进目标函数中。

TRPO 是带约束优化：

约束为：

PPO-Penalty 把它改成无约束优化：

这里：

• 第一项 $r_t(\theta)A_t$ 鼓励策略提升。
• 第二项 $\beta D_{\mathrm{KL}}$ 惩罚新旧策略差太远。
• $\beta$ 控制惩罚强度。

如果实际 KL 太大，说明新策略变化太猛，就增大 $\beta$：

如果实际 KL 太小，说明更新太保守，就减小 $\beta$：

更具体地：

如果：

说明策略变化太小，惩罚太强，因此：

如果：

说明策略变化太大，惩罚太弱，因此：

否则：

PPO-Penalty 的直觉是：

不硬性禁止新策略走太远，而是在目标函数里给“走太远”加罚分。

从 TRPO 约束到 KL 惩罚。

PPO-Penalty 来自 TRPO。

TRPO 的目标是：

约束为：

其中：

TRPO 的意思是：让策略朝优势方向变好，但新策略不能离旧策略太远。

PPO-Penalty 不再把 KL 写成硬约束，而是把 KL 放进目标函数里当作惩罚项：

这里：

• $r_t(\theta)A_t$ 负责让策略变好。
• $D_{\mathrm{KL}}(\pi_{\mathrm{old}}\|\pi_\theta)$ 衡量新旧策略距离。
• $\beta$ 控制 KL 惩罚强度。

如果 $\beta$ 很大，策略更新会更保守；如果 $\beta$ 很小，策略更新会更激进。

PPO-Penalty 会根据实际 KL 动态调整 $\beta$。令：

如果：

说明新策略离旧策略太远，KL 惩罚不够强，所以：

如果：

说明更新太保守，KL 惩罚太强，所以：

否则：

所以 PPO-Penalty 的一句话理解是：

把 TRPO 的 KL 硬约束变成 KL 软惩罚，并通过自适应 $\beta$ 控制策略更新幅度。

如果写成 PyTorch loss，因为优化器默认最小化，所以要取负号：

伪代码：

log_probs = torch.log(actor(states).gather(1, actions))
ratio = torch.exp(log_probs - old_log_probs)

new_dist = torch.distributions.Categorical(actor(states))
old_dist = torch.distributions.Categorical(old_probs)
kl = torch.mean(torch.distributions.kl.kl_divergence(old_dist, new_dist))

actor_objective = torch.mean(ratio * advantage - beta * kl)
actor_loss = -actor_objective

if kl > 1.5 * target_kl:
    beta *= 2
elif kl < target_kl / 1.5:
    beta /= 2

两个期望和拉格朗日惩罚。

TRPO 原来是带约束优化：

拉格朗日乘数法的思想是把约束变成惩罚项：

这里 $\beta$ 是惩罚强度。$\beta$ 越大，新旧策略距离的惩罚越强。

PPO-Penalty 的目标写成：

第一个期望：

表示状态 $s$ 来自旧策略 $\pi_{\theta_k}$ 的状态访问分布。

第二个期望：

表示动作 $a$ 也是旧策略在状态 $s$ 下采出来的。

实际代码中，这两个期望就是对旧策略采来的 batch 求平均。

PPO-Clip。

PPO-Clip 是更常用的 PPO 版本。它不显式计算 KL 惩罚，而是直接限制重要性采样比率。

重要性采样比率为：

普通的策略目标是：

如果 $A_t>0$，说明动作好，最大化目标会让 $r_t(\theta)$ 变大，也就是提高这个动作概率。

如果 $A_t<0$，说明动作差，最大化目标会让 $r_t(\theta)$ 变小，也就是降低这个动作概率。

但问题是：$r_t(\theta)$ 可能变得太大或太小，导致策略更新过猛。

PPO-Clip 直接把 $r_t(\theta)$ 限制在：

截断函数为：

PPO-Clip 的目标函数是：

这里用 min 的目的是：只取更保守的那个目标，防止策略从极端概率变化中继续获得收益。

情况一：优势为正。

如果：

说明动作好，策略应该提高这个动作概率。

但 PPO 不允许无限提高，只允许：

也就是说，如果 $\epsilon=0.2$，那么新策略对这个动作的概率最多相对旧策略提高到：

倍左右。

情况二：优势为负。

如果：

说明动作差，策略应该降低这个动作概率。

但 PPO 不允许无限降低，只允许：

如果 $\epsilon=0.2$，那么新策略对这个动作的概率最多相对旧策略降低到：

倍左右。

所以 PPO-Clip 的一句话理解是：

好动作可以提高概率，但别提高太多；差动作可以降低概率，但别降低太多。

为什么 PPO-Clip 更常用。

PPO-Clip 不显式使用 KL 惩罚，而是直接限制概率比率：

它的目标函数是：

PPO-Clip 的直觉是：

• 如果 $A_t>0$，说明动作好，可以提高动作概率，但最多提高到 $1+\epsilon$ 附近。
• 如果 $A_t<0$，说明动作差，可以降低动作概率，但最多降低到 $1-\epsilon$ 附近。

所以：

时，通常希望概率比率大致被限制在：

PPO-Penalty 和 PPO-Clip 的区别：

为什么截断后梯度会变为 0。

PPO-Clip 的目标是：

其中：

当：

有：

所以：

PPO 取较小值：

这个式子已经不含 $r$，因此：

而 $r$ 才是和新策略参数 $\theta$ 有关的量，所以该区域不会继续推动新策略提高该动作概率。直觉是：好动作可以增加概率，但超过 $1+\epsilon$ 后不再给额外奖励。

PPO 的代码结构。

PPO 仍然是 Actor-Critic 框架：

self.actor = PolicyNet(...)
self.critic = ValueNet(...)

和 TRPO 不同，PPO 的 Actor 也直接用 Adam 优化：

self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)
self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)

这就是 PPO 比 TRPO 简单的地方：它不需要共轭梯度和线性搜索。

PPO 的重要超参数：

self.epochs = epochs
self.eps = eps

其中：

• epochs：同一批 on-policy 数据重复训练几轮。
• eps：clip 范围 $\epsilon$。

PPO 的 update 主线。

先把数据转成张量：

states
actions
rewards
next_states
dones

每条数据都是：

然后算 TD 目标：

代码：

td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)

再算 TD 误差：

代码：

td_delta = td_target - self.critic(states)

再用 GAE 算优势：

代码：

advantage = rl_utils.compute_advantage(
    self.gamma, self.lmbda, td_delta.cpu()
).to(self.device)

然后保存旧策略下实际动作的 log 概率：

old_log_probs = torch.log(
    self.actor(states).gather(1, actions)
).detach()

注意这里必须 .detach()。因为旧策略概率应该作为固定基准，不应该在后续多轮更新中一起变化。

为什么 PPO 可以对同一批数据训练多轮。

代码中：

for _ in range(self.epochs):

表示同一批采样数据会被训练多轮。

这听起来和 on-policy 有点矛盾。因为策略更新后，数据已经不是新策略采的了。

PPO 的处理方式是：用旧策略概率作为基准，通过比率：

追踪新策略和旧策略的差距。

再用 clip 限制：

所以 PPO 可以在一定范围内重复使用同一批 on-policy 数据，而不让策略偏离太远。

PPO 的数据属性。

PPO 通常归类为：

它确实会对同一批数据训练多个 epoch，但这不等于 off-policy，也不等于 offline RL。

PPO 的流程是：

1. 用当前策略 $\pi_{\theta_k}$ 和环境交互，采集一批数据。
2. 保存旧策略概率：

3. 用这批数据更新几轮。
4. 用 ratio 和 clip 限制新策略别离旧策略太远：

5. 更新完后丢掉这批数据，用新策略重新采样。

所以 PPO 是近似 on-policy。它允许短期复用最近一批数据，但不长期维护 replay buffer。

对比：

因此：

PPO 仍然需要不断和环境交互采新数据。

episode、rollout 和 epoch。

episode 是强化学习里的“一整局”。

从初始状态开始：

一直交互到终止：

这一整条轨迹就是一个 episode。

rollout 是按某个策略采样出来的一段或一批轨迹。它可以是完整 episode，也可以只是一个 episode 的片段，还可以是多个 episode 拼成的一批数据。

所以：

但：

epoch 是神经网络训练里的概念，表示用已有数据完整训练一轮。

在 PPO 里：

for _ in range(self.epochs):
    ...

表示同一批刚采来的 rollout 数据，会被拿来重复训练多轮。

所以三者区别是：

PPO 的典型流程可以写成：

PPO-Clip 损失函数代码。

核心代码：

log_probs = torch.log(self.actor(states).gather(1, actions))
ratio = torch.exp(log_probs - old_log_probs)
surr1 = ratio * advantage
surr2 = torch.clamp(ratio, 1 - self.eps, 1 + self.eps) * advantage
actor_loss = torch.mean(-torch.min(surr1, surr2))

逐句对应：

新策略下实际动作的 log 概率：

比率：

也就是：

未截断目标：

截断目标：

PPO 目标：

代码里是 loss，所以要取负号：

因为 PyTorch 优化器默认是最小化 loss，而 PPO 原目标是最大化策略目标。

Critic loss 和 Actor-Critic 一样：

代码：

critic_loss = torch.mean(
    F.mse_loss(self.critic(states), td_target.detach()))

PPO 和 TRPO 的核心区别。

TRPO 是：

约束：

PPO-Clip 是：

TRPO 是显式约束 KL，求解复杂。

PPO 是隐式限制概率比率，实现简单。

所以可以这样记：

• TRPO：用 KL 约束限制新旧策略距离。
• PPO-Penalty：用 KL 惩罚限制新旧策略距离。
• PPO-Clip：用概率比率截断限制新旧策略距离。

离散动作和连续动作 PPO。

离散动作下，Actor 输出动作概率：

代码使用：

torch.distributions.Categorical(probs)

连续动作下，Actor 输出高斯分布参数：

动作从高斯分布采样：

代码使用：

torch.distributions.Normal(mu, sigma)

连续动作版本中：

mu = 2.0 * torch.tanh(self.fc_mu(x))
std = F.softplus(self.fc_std(x))

其中：

• tanh 用来限制均值范围。
• softplus 用来保证标准差为正。

收束。

PPO 可以用一句话收束：

PPO 是 Actor-Critic 框架下的安全策略更新方法，它不像 TRPO 那样显式求解 KL 约束，而是用 KL 惩罚或概率比率截断，让 Actor 在优势方向上更新但不要一次改太猛。

其中：

• Critic 负责估计价值和优势。
• Actor 负责更新策略。
• PPO-Penalty 用 KL 惩罚控制更新幅度。
• PPO-Clip 用 ratio 截断控制更新幅度。
• PPO 是 online on-policy，只是短期复用最近 rollout 做多个 epoch。

小结。

PPO 解决的问题和 TRPO 一样：

TRPO 的方法是显式约束：

PPO 的方法更简单。PPO-Penalty 把 KL 放进目标函数：

PPO-Clip 直接截断概率比率：

本章最重要的是理解这个比率：

它表示新策略相对旧策略对当前动作的概率变化。

PPO-Clip 的最终直觉是：

• 如果动作好，增加它的概率，但最多增加到 $1+\epsilon$ 附近。
• 如果动作差，降低它的概率，但最多降低到 $1-\epsilon$ 附近。
• 因此 PPO 可以稳定地多轮更新同一批数据，而不让策略偏离太远。

参考链接：

• 学习平台：PPO 算法
• 原教材：PPO 算法
• 配套代码：第 12 章 PPO

21. 第 16 章：DDPG 算法

到 DDPG 时，动作空间从离散动作变成连续动作。这里不能再像 DQN 那样枚举所有动作取最大值，只能让 Actor 直接输出一个连续动作。DDPG 的全称是 Deep Deterministic Policy Gradient，深度确定性策略梯度。

前面 PPO、TRPO 都是 Actor-Critic 框架下的随机策略算法：

它们输出的是动作概率分布，再从分布中采样动作。

DDPG 不一样。DDPG 学的是确定性策略：

也就是说，给定状态 $s$，Actor 直接输出一个具体动作 $a$。

DDPG 主要解决两个问题：

1. DQN 可以 off-policy，但难以处理连续动作空间。
2. PPO/TRPO 可以处理连续动作，但通常是 on-policy，样本效率较低。

DDPG 的目标是结合两边的优点：

为什么连续动作不能直接用 DQN。

DQN 学的是动作价值函数：

选动作时用：

如果动作是离散的，比如：

那可以把所有动作都算一遍，选最大的。

但如果动作是连续的，比如倒立摆环境中动作是一个连续力矩：

那动作有无限多个，不可能枚举所有动作再取最大。

DDPG 的思路是：既然不能枚举动作，那就再训练一个 Actor 网络，直接输出让 $Q$ 尽量大的动作：

所以 DDPG 里：

• Critic 学 $Q_\omega(s,a)$，负责评价状态动作对。
• Actor 学 $\mu_\theta(s)$，负责输出连续动作。

确定性策略和随机策略的区别。

随机策略输出一个分布：

例如：

然后从这个分布中采样动作。

确定性策略直接输出动作：

例如在连续动作环境中：

这就是实际要执行的动作。

所以：

确定性策略的好处是适合连续动作。坏处是探索能力弱，因为同一个状态总会输出同一个动作。

所以 DDPG 在执行动作时会加噪声：

代码里通常用高斯噪声或 OU 噪声。

确定性策略梯度。

DDPG 的 Actor 目标是让 Critic 评价更高：

这句话很重要。

Actor 的输出是动作：

Critic 评价这个动作：

所以 Actor 想最大化：

对 Actor 参数 $\theta$ 求梯度，用链式法则：

这个公式就是确定性策略梯度的核心。

它可以这样理解：

• $\nabla_a Q_\omega(s,a)$：如果动作 $a$ 往某个方向变一点，$Q$ 会怎么变。
• $\nabla_\theta \mu_\theta(s)$：Actor 参数 $\theta$ 怎么影响动作输出。
• 两者相乘：参数怎么改，才能让 Actor 输出更高价值的动作。

所以 DDPG 的 Actor 不是直接用：

因为它没有概率分布。它直接通过 Critic 的 $Q$ 值反向传播来更新 Actor。

DDPG 的四个网络。

DDPG 有四个网络：