1. 从零理解PPO:为什么说它是强化学习的“稳定器”?
如果你玩过强化学习,肯定对策略梯度(Policy Gradient, PG)方法不陌生。简单来说,PG就是让智能体(Agent)通过不断试错,根据获得的奖励来调整自己的行为策略,目标是让长期累积的奖励最大化。这听起来很美好,对吧?但实际操作过的人都知道,PG有个让人头疼的毛病:训练过程极其不稳定。
想象一下教一个机器人走路。你用PG方法,今天它可能因为某次尝试获得高奖励,于是“大步流星”地更新策略,结果明天就直接摔个四脚朝天,策略性能暴跌。这种策略更新幅度过大、来回震荡的问题,在强化学习里被称为策略崩溃。我早期用PG训练倒立摆时,经常看到奖励曲线像过山车一样,好不容易涨上去,下一秒就跌入谷底,非常折磨人。
Proximal Policy Optimization (PPO) 算法,就是为了解决这个“稳定性”问题而生的。你可以把它理解为PG算法加了一个“安全阀”或者“稳定器”。它的核心思想非常直观:允许策略更新,但不允许新策略和旧策略相差太远。这就好比教小孩学骑车,你扶着他,允许他左右摇晃找平衡,但一旦他要摔倒了(策略偏离太远),你就立刻把他拉回来(限制更新幅度)。
PPO实现这个目标主要有两种技术路径,一种是基于KL散度的惩罚项,另一种就是我们今天要实战的 PPO-Clip。Clip,顾名思义就是“裁剪”。它在计算策略更新的损失函数时,不会让新旧策略的概率比(ratio)无限制地变化,而是用一个裁剪区间(比如[0.8, 1.2])把它限制住。这样,无论优势函数(Advantage Function,可以理解为某个动作比平均表现好多少)告诉我们应该进行多大的更新,最终策略的调整幅度都被限制在一个安全的范围内。
我为什么特别喜欢在连续控制任务(比如我们今天的Pendulum-v0)中用PPO呢?原因有三点。第一,上手简单,核心思想就一句话“限制更新幅度”,代码实现起来比一些复杂的算法直观。第二,样本效率相对较高,它允许我们用同一批收集到的经验数据(experience)进行多次小批量的策略更新,这比传统PG每收集一批数据只能更新一次要高效。第三,也是最重要的,训练过程真的稳了很多。你不再需要像伺候PG那样小心翼翼地调整学习率,生怕它“炸掉”。PPO的鲁棒性让它成为了从学术研究到工业落地(比如游戏AI、机器人控制)中最受欢迎的强化学习算法之一。
2. 认识我们的“训练场”:Pendulum-v0环境详解
在开始写代码之前,我们得先彻底了解我们要解决的任务是什么。OpenAI Gym里的 Pendulum-v0 是一个经典的连续控制环境,目标非常直观:让一个倒立摆从任意初始角度摆动起来,并保持竖直向上(平衡)的状态。
这个环境虽然看起来比Atari游戏或者机械臂抓取简单,但它包含了连续控制问题的几个核心挑战,非常适合作为我们学习PPO的“新手村”。我们先来看看环境给了我们哪些信息,又期望我们输出什么。
状态空间(State Space):环境每一步会给我们一个包含3个浮点数的观测值(observation)。注意,这里说的“状态”在Gym的语境里通常就是观测值。这3个数分别是:
cos(theta):摆锤角度(相对于竖直向上位置)的余弦值。sin(theta):摆锤角度的正弦值。theta_dot:摆锤的角速度。
为什么不直接给角度 theta 呢?因为角度本身具有周期性(比如359度和1度很近),用正弦和余弦来表示能更好地被神经网络理解。所以,我们的神经网络输入层就是3个神经元,对应这3个观测值。
动作空间(Action Space):这是连续控制任务和离散任务(比如上下左右)最大的不同。我们需要输出的是一个在 [-2.0, 2.0] 区间内的连续值。这个值代表施加在摆锤转轴上的扭矩(torque)大小。正数表示向一个方向用力,负数表示向反方向用力。输出“2”就是施加最大正向扭矩,“-1.5”就是施加中等大小的反向扭矩。
奖励函数(Reward):环境的原始奖励计算公式是 - (theta^2 + 0.1 * theta_dot^2 + 0.001 * action^2)。这个公式需要仔细理解:
theta^2:惩罚摆锤偏离竖直向上的角度。角度越大(越偏离平衡),惩罚(负奖励)越大。这是主要优化目标。0.1 * theta_dot^2:惩罚角速度过大,希望摆锤能平稳地停下来,而不是剧烈晃动。0.001 * action^2:惩罚使用过大的力,鼓励用更节能、更柔和的方式控制。
所以,智能体的目标就是最大化这个负数的绝对值(或者说最小化这个惩罚的总和)。理想情况下,当摆锤完美静止在竖直向上位置时,theta和theta_dot都为0,如果此时也不用力(action=0),那么奖励就是0,这是能达到的最高分。但注意,初始角度是随机的,所以一开始奖励会是一个很大的负数。
我在实战中发现,这个原始奖励信号对于学习初期不太友好,因为值始终为负,且范围波动大。因此,一个常见的技巧是对奖励进行归一化(Reward Shaping)。比如在原始文章代码里,作者做了 (r + 8.1) / 8.1 的处理,这相当于将奖励平移缩放,使其分布更集中在0附近,可以显著加速训练初期的收敛。我们后面也会采用类似的技巧。
3. 搭建PPO的“大脑”:Actor-Critic网络架构设计
PPO通常采用Actor-Critic(演员-评论家)架构,这是理解其代码实现的关键。你可以想象成有两个神经网络在协同工作:
- Actor(演员,也叫策略网络 Policy Network):负责“做事”。它根据当前环境状态,决定采取什么动作。在Pendulum-v0中,就是输出一个介于-2到2之间的扭矩值。
- Critic(评论家,也叫价值网络 Value Network):负责“评价”。它评估在当前状态下,遵循当前策略,未来能获得多少累积奖励(状态价值)。它不直接指导动作,而是为Actor的更新提供方向(优势估计)。
下面我们用PyTorch来具体实现这两个网络。我会详细解释每一层设计的考量。
3.1 策略网络(Actor / Pi-Net):输出动作分布
对于连续动作空间,我们通常假设动作服从一个高斯(正态)分布,然后让神经网络输出这个分布的参数:均值(mu, μ)和标准差(sigma, σ)。智能体每一步从这个分布中采样,得到一个具体的动作。这样做的好处是引入了探索性:即使对于同一个状态,输出的动作也会有轻微波动,有助于尝试更多可能性。
import torch
import torch.nn as nn
import torch.nn.functional as F
class PiNet(nn.Module):
def __init__(self, state_dim=3, action_dim=1):
super(PiNet, self).__init__()
# 共享的特征提取层
self.shared_net = nn.Sequential(
nn.Linear(state_dim, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, 256),
nn.ReLU(), # 深层网络有助于拟合复杂策略
)
# 输出均值mu的头
self.mu_head = nn.Linear(256, action_dim)
# 输出标准差sigma的头
self.sigma_head = nn.Linear(256, action_dim)
# 初始化技巧:将最后一层mu的权重和偏置初始化得小一些,有助于训练初期稳定
nn.init.orthogonal_(self.mu_head.weight, gain=0.01)
nn.init.constant_(self.mu_head.bias, 0.0)
# sigma输出通常初始化为一个较小的正值,代表初始探索率
nn.init.constant_(self.sigma_head.bias, -0.5)
def forward(self, x):
x = self.shared_net(x)
mu = self.mu_head(x)
sigma = self.sigma_head(x)
# 对mu进行缩放,限制到动作空间[-2, 2]
mu = torch.tanh(mu) * 2.0
# 对sigma使用softplus确保其为正,并加上一个很小的下限(如0.001)防止数值问题
sigma = F.softplus(sigma) + 1e-4
return mu, sigma
关键点解析:
- 共享层:我们先用几层全连接网络从状态中提取高级特征。这里用了三层,对于Pendulum-v0来说足够复杂了。
- 均值头(mu_head):输出一个值,经过
tanh激活函数被压缩到[-1, 1],然后乘以2,就映射到了我们需要的[-2, 2]动作范围。tanh在零点附近梯度大,有利于学习。 - 标准差头(sigma_head):输出一个值,通过
F.softplus函数(log(1+exp(x)))确保其为正数。加上一个小的偏置(如1e-4)是为了防止标准差为0导致无法采样。标准差决定了探索的幅度:标准差大,动作随机性强;训练后期,我们通常希望标准差变小,使策略更确定。
3.2 价值网络(Critic / V-Net):评估状态好坏
价值网络的结构相对简单,它的任务就是回归一个标量值,即状态价值V(s)。
class VNet(nn.Module):
def __init__(self, state_dim=3):
super(VNet, self).__init__()
self.value_net = nn.Sequential(
nn.Linear(state_dim, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, 256),
nn.ReLU(),
nn.Linear(256, 1), # 输出单个价值标量
)
# 初始化输出层权重,使初始价值估计在合理范围
nn.init.orthogonal_(self.value_net[-1].weight, gain=1.0)
nn.init.constant_(self.value_net[-1].bias, 0.0)
def forward(self, x):
return self.value_net(x)
价值网络和策略网络的前面几层可以共享,但为了简单和稳定,我们通常像这样分开构建两个独立的网络。价值网络的输出层不需要特殊的激活函数,因为它要拟合的奖励值范围可以是任意的。
4. PPO-Clip的核心实现:一步步拆解更新逻辑
有了网络,接下来就是PPO算法最核心的部分:如何利用收集到的数据来更新这两个网络。PPO是一种**同策略(on-policy)**算法,意味着它用来更新的数据必须是由当前策略(或与当前策略非常接近的旧策略)收集的。整个流程可以概括为:收集数据 -> 计算优势 -> 多次小批量更新 -> 用新策略覆盖旧策略。
我们先定义一些关键的超参数,这些值是我经过多次实验调整后,对Pendulum-v0比较友好的设置:
# 超参数配置
HORIZON = 128 # 每个批次收集的步数(轨迹长度)
K_EPOCHS = 10 # 对同一批数据执行策略更新的轮次
GAMMA = 0.99 # 折扣因子,衡量未来奖励的重要性
LAMBDA = 0.95 # GAE(广义优势估计)中的平滑参数
CLIP_RATIO = 0.2 # PPO-Clip中的裁剪范围
LR_ACTOR = 3e-4 # 策略网络学习率
LR_CRITIC = 1e-3 # 价值网络学习率
4.1 数据收集与存储
我们首先需要让智能体与环境交互,收集一个批次(batch)的经验数据。这些数据包括:状态(s),动作(a),奖励(r),下一个状态(s_),是否结束(done)。
class PPOBuffer:
def __init__(self, state_dim, action_dim, size=HORIZON):
self.state_buf = np.zeros((size, state_dim), dtype=np.float32)
self.action_buf = np.zeros((size, action_dim), dtype=np.float32)
self.reward_buf = np.zeros(size, dtype=np.float32)
self.next_state_buf = np.zeros((size, state_dim), dtype=np.float32)
self.done_buf = np.zeros(size, dtype=np.float32)
self.value_buf = np.zeros(size, dtype=np.float32) # 存储旧价值网络输出的V(s)
self.log_prob_buf = np.zeros(size, dtype=np.float32) # 存储旧策略下该动作的对数概率
self.ptr, self.path_start_idx = 0, 0
self.max_size = size
def store(self, s, a, r, s_, done, v, logp):
assert self.ptr < self.max_size
self.state_buf[self.ptr] = s
self.action_buf[self.ptr] = a
self.reward_buf[self.ptr] = r
self.next_state_buf[self.ptr] = s_
self.done_buf[self.ptr] = done
self.value_buf[self.ptr] = v
self.log_prob_buf[self.ptr] = logp
self.ptr += 1
def get(self):
# 返回整批数据,并重置指针
data = dict(state=self.state_buf, action=self.action_buf, reward=self.reward_buf,
next_state=self.next_state_buf, done=self.done_buf,
value=self.value_buf, log_prob=self.log_prob_buf)
self.ptr, self.path_start_idx = 0, 0
return {k: torch.as_tensor(v, dtype=torch.float32) for k, v in data.items()}
在交互循环中,我们不仅存储基本的转移元组,还会用旧策略网络和旧价值网络(即更新前的网络)来计算当前状态的价值v和采取动作的对数概率logp。这是PPO实现的关键,因为后续计算优势函数和概率比时需要这些“旧”的参考值。
4.2 计算广义优势估计(GAE)
优势函数A(s, a) = Q(s, a) - V(s),衡量了在状态s下采取动作a比平均情况好多少。直接计算Q值比较困难,PPO通常采用广义优势估计(GAE),这是一种用价值函数V(s)来估计优势的、低方差的方法。
def compute_gae_and_returns(self, last_value, gamma=GAMMA, lam=LAMBDA):
"""计算GAE优势函数和回报(Returns)"""
rewards = self.reward_buf
values = self.value_buf
dones = self.done_buf
advantages = np.zeros_like(rewards)
returns = np.zeros_like(rewards)
last_gae_lam = 0
# 从后向前递推计算
for t in reversed(range(len(rewards))):
if t == len(rewards) - 1:
next_non_terminal = 1.0 - dones[t]
next_value = last_value # 使用下一个状态的价值估计
else:
next_non_terminal = 1.0 - dones[t]
next_value = values[t+1]
# TD误差:r + γ*V(s') - V(s)
delta = rewards[t] + gamma * next_value * next_non_terminal - values[t]
# GAE: 对TD误差进行指数衰减的加权和
last_gae_lam = delta + gamma * lam * next_non_terminal * last_gae_lam
advantages[t] = last_gae_lam
# 回报 = 优势 + 价值
returns[t] = advantages[t] + values[t]
# 对优势进行标准化(减去均值,除以标准差),有助于训练稳定性
advantages = (advantages - np.mean(advantages)) / (np.std(advantages) + 1e-8)
self.adv_buf = advantages
self.ret_buf = returns
GAE的计算是PPO中的一个精华。参数lam(λ)在0到1之间,它控制了偏差和方差的权衡。λ=0时,优势估计就是一步的TD误差(高偏差,低方差);λ=1时,优势估计就是蒙特卡洛的回报减去价值函数(低偏差,高方差)。通常取0.95是一个不错的折中。对优势进行标准化是一个非常重要的技巧,它能确保不同批次的数据尺度一致,让梯度更新更稳定。
4.3 PPO-Clip策略损失函数
这是PPO算法得名的核心。我们有了新旧策略的概率比 ratio = π_new(a|s) / π_old(a|s),以及计算好的优势估计 adv。最朴素的策略梯度损失是 -log(π_new) * adv。PPO-Clip通过裁剪ratio,构造了一个更保守的损失函数:
def update(self, data):
states, actions, log_probs_old, returns, advantages = data['state'], data['action'], data['log_prob'], data['return'], data['advantage']
for _ in range(K_EPOCHS):
# 1. 用当前策略网络计算新的动作分布和对数概率
mu_new, sigma_new = self.actor(states)
dist_new = torch.distributions.Normal(mu_new, sigma_new)
log_probs_new = dist_new.log_prob(actions).sum(dim=-1, keepdim=True)
# 2. 计算概率比 (ratio)
ratio = torch.exp(log_probs_new - log_probs_old) # 等价于 π_new / π_old
# 3. 计算裁剪前后的损失
surr1 = ratio * advantages
surr2 = torch.clamp(ratio, 1.0 - CLIP_RATIO, 1.0 + CLIP_RATIO) * advantages
# 4. PPO-Clip 策略损失:取两者中较小的那个,然后取负(因为要最大化)
actor_loss = -torch.min(surr1, surr2).mean()
# 5. 价值网络损失:拟合回报(Returns)
values_pred = self.critic(states)
critic_loss = F.mse_loss(values_pred, returns)
# 6. 可选:添加熵奖励(Entropy Bonus)鼓励探索
entropy = dist_new.entropy().mean()
entropy_bonus = -0.01 * entropy # 通常用一个很小的系数
# 7. 总损失 = 策略损失 + 价值损失 + 熵奖励
total_loss = actor_loss + 0.5 * critic_loss + entropy_bonus
# 8. 反向传播与优化
self.optimizer.zero_grad()
total_loss.backward()
# 可以添加梯度裁剪防止爆炸
torch.nn.utils.clip_grad_norm_(self.actor.parameters(), 0.5)
torch.nn.utils.clip_grad_norm_(self.critic.parameters(), 0.5)
self.optimizer.step()
# 9. 更新“旧”网络参数
self._update_old_policy()
逐行解读:
surr1:这是未经裁剪的策略梯度目标。如果优势为正(动作好),我们希望增大这个动作的概率(ratio增大)。surr2:这是经过裁剪的目标。torch.clamp将ratio限制在[1-CLIP, 1+CLIP]之间。如果ratio超出这个范围,就用边界值代替。torch.min(surr1, surr2):这是PPO-Clip的精髓。它总是选择更保守(更小)的那个目标。当优势为正且ratio过大时,裁剪版本(surr2)更小,限制了策略过度优化;当优势为负且ratio过小时,裁剪版本同样更小,限制了策略过度恶化。这确保了更新是“近端”的。- 熵奖励:在损失中加入策略分布的熵的负数(
-entropy),并乘以一个很小的系数(如0.01),可以鼓励策略保持一定的随机性,防止过早收敛到局部最优。这在训练初期尤其有用。 - 梯度裁剪:对梯度范数进行裁剪是训练深度RL模型的常用稳定技巧。
- 更新旧网络:在一轮K次更新完成后,将当前策略网络和价值网络的参数复制给“旧网络”,用于下一轮数据收集。
5. 实战调优:让Pendulum-v0快速立起来的技巧
理论说完,代码也有了,但直接跑起来可能效果并不理想。强化学习被称为“炼丹”不是没有道理的,超参数和技巧的调整至关重要。下面分享几个我在调优Pendulum-v0时总结的实战经验。
5.1 超参数敏感度分析与调优指南
PPO的超参数不算太多,但每个都影响显著。我制作了一个表格,总结了关键超参数的作用、常用范围和针对Pendulum-v0的调优建议:
| 超参数 | 作用与影响 | 常用范围 | Pendulum-v0调优建议 |
|---|---|---|---|
| 学习率 (LR) | 控制参数更新步长。太大易震荡,太小收敛慢。 | [1e-5, 1e-3] | Actor网络建议稍小(如3e-4),Critic网络可稍大(如1e-3)。可以尝试学习率衰减。 |
| 批次步数 (HORIZON) | 每次更新前收集的经验步数。影响方差和更新频率。 | 128 - 2048 | Pendulum-v0环境简单,128-256足够。太大会导致更新延迟,太小方差高。 |
| 更新轮次 (K_EPOCHS) | 对同一批数据重复利用进行更新的次数。 | 3 - 15 | 建议8-10次。太小数据利用不充分,太大容易过拟合到当前批次数据。 |
| 折扣因子 (GAMMA) | 衡量未来奖励的现值。越接近1,智能体越有远见。 | 0.9 - 0.999 | 连续控制任务通常设0.99。如果想让它更快平衡,可尝试0.995。 |
| GAE参数 (LAMBDA) | 权衡优势估计的偏差与方差。 | 0.9 - 0.99 | 0.95是经典值,在Pendulum-v0上效果很好,通常不需调整。 |
| 裁剪系数 (CLIP) | 控制新旧策略差异的最大幅度。PPO稳定性的关键。 | 0.1 - 0.3 | 默认0.2。如果训练不稳定(奖励剧烈波动),可尝试减小到0.1。如果收敛太慢,可略微增大到0.25。 |
| 熵系数 | 鼓励探索的强度。 | [0, 0.05] | 初期可设为0.01帮助探索,训练中后期可逐渐衰减至0或一个很小的值。 |
我的调优流程:
- 先用一组保守的默认参数跑起来:比如LR=3e-4, HORIZON=256, K_EPOCHS=10, CLIP=0.2。
- 观察训练曲线:主要看
episode_reward(每局总奖励)和episode_length(每局步数,Pendulum-v0固定为200)。理想情况是奖励稳步上升并最终稳定在高位(接近0)。 - 如果奖励不上升:
- 检查奖励函数:是否做了归一化?原始奖励始终为负可能导致学习信号弱。尝试
reward = (reward + 8) / 8。 - 增大探索:调大熵系数,或者检查策略网络输出的初始标准差是否过小。
- 稍微增大学习率或CLIP系数。
- 检查奖励函数:是否做了归一化?原始奖励始终为负可能导致学习信号弱。尝试
- 如果奖励剧烈震荡(过山车):
- 这是PPO最常见的问题。首先减小学习率,这是最有效的手段。
- 其次,减小CLIP系数,比如从0.2降到0.15,加强更新限制。
- 检查梯度裁剪是否开启,梯度范数限制可以设为0.5或1.0。
- 可以尝试减小K_EPOCHS,避免对同一批数据过度优化。
- 如果收敛后性能不佳:
- 尝试增大网络容量(如增加隐藏层神经元数量)。
- 微调GAE的lambda,向1.0靠近可能提升最终性能(但可能增加方差)。
5.2 网络结构与奖励工程的微调
除了超参数,网络本身的设计和奖励信号的处理也大有可为。
网络结构:原始文章用了3层隐藏层(64, 128, 256)。对于Pendulum-v0,这个结构有点“杀鸡用牛刀”。我实测下来,一个两层的网络(如64 -> 64)通常就能很好地完成任务,而且训练更快。你可以从简单的网络开始,如果欠拟合(奖励上不去)再加深加宽。另外,可以考虑在Actor和Critic网络的第一层共享特征提取层,但要注意两者学习目标不同,有时分开更稳定。
奖励工程:这是加速收敛的“魔法”。环境原始奖励一直是负数,我们可以将其“平移”到正负均衡的区间。
# 原始奖励在 [-16.273, 0] 之间,通过以下变换将其映射到大约 [-1, 1] 附近
reward_shifted = (reward + 8) / 8
# 或者更激进一点,只保留角度的惩罚作为主要信号
reward_shaped = - (theta**2) * 0.1 # 忽略角速度和动作的微小惩罚,聚焦主要目标
第二种方法属于“奖励塑形”(Reward Shaping),直接修改了奖励函数以更直接地表达我们的目标。这在学术上可能有争议,但在工程实践中非常有效,能极大缩短训练时间。关键是要谨慎,避免引入“奖励黑客”(Reward Hacking),即智能体找到一种奇怪的方式获得高奖励却未完成真正任务。
5.3 训练过程可视化与Debug
不要只盯着最终奖励!在训练过程中,实时监控更多指标能帮你快速定位问题。
- 策略熵(Entropy):监控策略分布的熵。熵值从高到低缓慢下降是健康的,说明智能体从探索转向利用。如果熵值骤降,可能意味着策略过早收敛到次优解。
- 裁剪频率(Clip Fraction):计算在更新过程中,有多少比例的
ratio被裁剪了(即落在了[1-clip, 1+clip]区间之外)。如果裁剪频率很高(比如>20%),说明新旧策略差异很大,可能CLIP设得太小,或者学习率太大。 - 价值损失(Value Loss):Critic网络的损失应该随着训练逐渐下降并趋于平稳。如果价值损失一直很大或震荡,说明Critic学得不好,会影响Actor的更新方向。可以尝试增大Critic的学习率,或者增加其网络容量。
- 优势估计的均值和标准差:优势应该近似均值为0。如果均值显著偏离0,可能说明优势估计有偏。标准差过大也可能导致训练不稳定。
我常用的调试方法是,先让智能体在简单环境下(比如训练初期)跑几个episode,把它的动作、状态、奖励全部打印或画出来。看看它是不是在“乱动”,还是已经有了一些有规律的行为。这比只看数字曲线直观得多。
6. 避坑指南与效果展示:从失败到成功
最后,结合我自己的踩坑经历,总结几个新手最容易遇到的问题和解决方案。
坑1:奖励一直是负值且没有上升趋势。
- 可能原因:学习率太低;网络初始化不当;奖励尺度问题(始终为很大的负数)。
- 解决:首先对奖励进行归一化。检查网络输出,确保Actor输出的动作在有效范围内(-2到2),Critic输出没有异常值。适当提高学习率。
坑2:训练初期奖励上升,但很快崩溃(NaN或急剧下降)。
- 可能原因:学习率过高;梯度爆炸;策略更新幅度太大导致策略崩溃。
- 解决:这是PPO最典型的“不稳定性”表现。立即降低学习率(比如降一个数量级)。确保使用了梯度裁剪(
clip_grad_norm_)。检查CLIP系数是否过小,导致有效更新信号太弱。
坑3:智能体似乎学会了,但表现不稳定,时好时坏。
- 可能原因:批次大小(HORIZON)太小,导致优势估计方差大;熵系数衰减太快,探索不足。
- 解决:适当增大HORIZON。在训练中后期再逐步衰减熵系数,或者保持一个很小的固定值。
坑4:训练速度很慢。
- 可能原因:网络太大;K_EPOCHS设置过高;没有使用GPU。
- 解决:简化网络结构。对于Pendulum-v0,K_EPOCHS=5~8可能就够了。如果可能,使用CUDA加速(
model.to(‘cuda’),tensor.to(‘cuda’))。
当你成功调通所有参数后,训练过程应该是这样的:最初几百个episode,奖励从-1500左右快速上升到-500以内,说明智能体意识到了要减少角度偏差。随后一两千个episode,奖励缓慢爬升,逐渐接近-200以内,此时摆锤已经能大部分时间停留在竖直位置附近。继续训练,奖励会逐渐逼近0,并且曲线变得平稳。最终,在可视化窗口里,你会看到那个倒立摆从随意下垂的状态,被智能体用恰到好处的力矩“啪”地一下摆起,然后稳稳地停在最上方,只有微小的抖动。那一刻的成就感,就是驱动我们不断“炼丹”的最大动力。
148



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



