1. 这不是数学课是写给实战者的政策梯度定理手记你打开这篇文字的时候大概率正卡在某个强化学习项目里模型跑不通、梯度爆炸、训练曲线像心电图一样乱跳或者更糟——明明代码和论文一模一样但 reward 就是上不去。我试过三次用 PyTorch 复现 REINFORCE前两次都在第 87 个 episode 崩溃第三次才搞明白问题根本不在代码而在没真正吃透那个被反复引用却极少被讲透的公式——Policy Gradient TheoremPGT。它不是黑箱里的魔法咒语而是一张施工图纸你每调一次loss.backward()背后都在执行这张图纸定义的物理规则。这篇文章不讲“什么是强化学习”也不堆砌教科书定义。它从一个真实调试现场切入当你在 CartPole-v1 环境里看到log_prob_actions和stepwise_returns两个张量相乘再求和时那个-loss.sum()到底在优化什么为什么必须加负号为什么detach()要插在stepwise_returns上而不是log_prob_actions上这些细节教材不会写Stack Overflow 的高赞回答也常含糊其辞。我会带你亲手推一遍 PGT 的每一步变形不是为了炫技而是让你在下次 loss 突然飙升时能立刻判断是discount_factor设错了还是baseline没减对甚至只是torch.float32和torch.float64的精度陷阱。核心关键词就三个策略梯度定理、对数导数技巧、蒙特卡洛回报估计。它们不是并列概念而是环环相扣的因果链——PGT 是结论对数导数是推导钥匙蒙特卡洛是落地载体。你不需要记住所有积分符号但必须理解为什么∇θ log πθ(a|s)这个项天然携带了“信用分配”的能力为什么它能让 agent 明白“刚才那个向左推杆的动作到底该为最终撑住杆子的 200 分奖励负多少责任”这种直觉比背下公式重要十倍。适合谁读刚跑通第一个 Gym 环境、想深入 RL 内核的工程师被 Policy-based 方法吸引、但被数学吓退的研究者或是像我一样在机器人控制项目里被连续三天的 policy collapse 折磨到凌晨三点的实践者。这不是速成课但读完你会拿到一把能拆解任何 policy gradient 变体的螺丝刀。2. 整体设计思路为什么必须从“轨迹概率”出发2.1 所有 Policy Gradient 方法的共同起点J(θ) 的物理意义我们先扔掉所有符号回到最朴素的问题Agent 怎么才算“学好了”答案很直接——在长期交互中它获得的平均总奖励越高策略就越优。这个“平均总奖励”就是目标函数 J(θ)。注意这里 θ 不是抽象参数而是你神经网络里实实在在的权重矩阵 W 和偏置 b。当你调用optimizer.step()时你就是在用梯度信息推动这些数字一点点挪动让 J(θ) 变大。但 J(θ) 本身是个期望值expectation它长这样J(θ) E_τ~πθ [R(τ)]这个式子看着简单实则暗藏玄机。τ代表一条完整的轨迹trajectory比如 CartPole 里从杆子竖直开始到杆子倒地结束中间经历的所有(s₀, a₀, r₀), (s₁, a₁, r₁), ..., (s_T, a_T, r_T)。R(τ)是这条轨迹的总回报return通常用折扣回报R(τ) Σₜ γᵗ rₜ计算。关键在于E_τ~πθ—— 这个期望不是对状态或动作求的而是对整个轨迹求的。这意味着J(θ) 的值取决于所有可能轨迹发生的概率而这个概率又完全由当前策略 πθ 决定。所以优化 J(θ) 的本质是调整 πθ从而改变不同轨迹出现的“权重”让高回报轨迹的概率变大低回报轨迹的概率变小。提示很多初学者误以为 policy gradient 是在优化“单步动作的价值”这是根本性误解。它优化的是整个行为序列的生成机制。就像训练一个作曲家目标不是让他弹好某一个音符而是让他写出整首能打动人心的乐曲。J(θ) 就是这首乐曲的“感染力评分”而 πθ 就是他的创作本能。2.2 为什么不能直接对 J(θ) 求导—— 轨迹概率的不可微困境既然目标明确了下一步自然是求梯度∇θ J(θ)然后用梯度上升更新 θ。但问题来了J(θ) E_τ~πθ [R(τ)]这个期望其分布πθ是依赖于 θ 的。在微积分里对一个依赖于参数的分布求期望的导数不能简单地把导数符号∇θ拿进期望符号E里面。这就像你不能说“我公司今年的平均工资增长了 5%所以每个员工的工资都涨了 5%”——平均值的变化是由无数个体变化共同导致的必须知道每个个体如何变化。数学上E_τ~πθ [R(τ)]的严格展开是J(θ) ∫ R(τ) * P(τ | θ) dτ其中P(τ | θ)是在策略 πθ 下产生轨迹 τ 的概率密度对离散动作是概率质量函数。现在∇θ J(θ) ∇θ ∫ R(τ) * P(τ | θ) dτ。根据莱布尼茨积分法则如果P(τ | θ)关于 θ 是可微的我们可以把导数移进积分号∇θ J(θ) ∫ R(τ) * ∇θ P(τ | θ) dτ但这里出现了第一个拦路虎∇θ P(τ | θ)非常难算。因为P(τ | θ)是一个复杂乘积见后文公式4它包含环境动力学P(s_{t1} | s_t, a_t)而这个项与 θ 完全无关强行对它求导会引入大量为零的项计算效率极低且无法分离出策略本身的贡献。2.3 对数导数技巧Log-Derivative Trick化乘为加的破局点这就是 PGT 的精妙之处——它绕开了直接求∇θ P(τ | θ)的死路转而利用一个基础恒等式∇θ P(τ | θ) P(τ | θ) * ∇θ log P(τ | θ)这个等式成立是因为d(log x)/dx 1/x所以d x / dx x * d(log x)/dx。把它代回梯度表达式∇θ J(θ) ∫ R(τ) * P(τ | θ) * ∇θ log P(τ | θ) dτ现在P(τ | θ)和∇θ log P(τ | θ)被清晰地分开了。P(τ | θ)作为概率密度保证了整个积分是一个合法的期望而∇θ log P(τ | θ)则只与策略 πθ 相关环境动力学项在取对数后求导时自动消失了因为log P(s_{t1} | s_t, a_t)对 θ 的导数为 0。于是整个梯度可以重写为∇θ J(θ) E_τ~πθ [R(τ) * ∇θ log P(τ | θ)]这就是 PGT 的核心骨架。它告诉我们要估计策略的梯度你不需要知道所有轨迹的概率只需要在当前策略下采样一批轨迹 τ对每条轨迹计算它的总回报 R(τ)再乘以这条轨迹的“对数概率梯度”∇θ log P(τ | θ)最后求平均。这个过程就是蒙特卡洛估计Monte Carlo Estimation。注意∇θ log P(τ | θ)并非凭空而来。它正是∇θ log πθ(a_t | s_t)在整条轨迹上的累加。因为P(τ | θ)的对数等于初始状态概率log ρ₀(s₀)加上所有时间步的log πθ(a_t | s_t)和log P(s_{t1} | s_t, a_t)之和而后两者中只有log πθ(a_t | s_t)依赖于 θ。所以∇θ log P(τ | θ) Σₜ ∇θ log πθ(a_t | s_t)。这个累加就是 credit assignment 的数学实现——它把最终的总回报 R(τ)按时间步分配给了每一个决策点上的策略输出。2.4 方案选型逻辑为什么 REINFORCE 是最佳入门载体面对 PGT 的多种实现A2C, PPO, TRPO我坚持用最原始的 REINFORCE 作为教学载体原因有三纯粹性REINFORCE 是 PGT 最直接、最无修饰的实现。它不做任何近似不引入 critic不 clip 梯度不加 entropy 正则。你看到的每一行代码都是对 PGT 公式的逐字翻译。这让你能百分百确认当你的loss下降时你优化的确实是E[R(τ) * Σₜ ∇θ log πθ(a_t | s_t)]而不是某个被修改过的代理目标。可调试性因为没有额外组件所有异常都指向核心逻辑。如果你的 reward 不涨问题一定出在R(τ)的计算discount factor 错了、log πθ(a_t | s_t)的获取softmax 用错了log_prob没取对、或者梯度更新detach()忘了zero_grad()漏了。没有 critic 的干扰你能快速定位到根因。教学完整性REINFORCE 强制你处理所有基础环节轨迹采样、回报计算、对数概率提取、梯度计算、策略更新。这些环节在 A2C 或 PPO 中被封装或弱化但在 REINFORCE 中你必须亲手写出来。这种“脏活累活”恰恰是建立直觉的必经之路。就像学开车先练好手动挡的离合、油门、换挡配合再上自动挡才能真正理解车辆的动力逻辑。3. 核心细节解析从数学符号到 PyTorch 张量的映射3.1 轨迹概率P(τ | θ)的构成与 PyTorch 实现让我们把抽象的P(τ | θ)拆解成 CartPole 环境里看得见、摸得着的代码。一条轨迹 τ 的概率是以下几部分的乘积ρ₀(s₀)初始状态s₀的概率。在 CartPole 中env.reset()总是返回一个固定范围内的随机状态这个概率对所有 θ 都是常数求导为 0可忽略。Πₜ πθ(a_t | s_t)在每个时间步 t策略 πθ 根据当前状态s_t输出选择动作a_t的概率。这是唯一与 θ 相关的部分。Πₜ P(s_{t1} | s_t, a_t)环境动力学即执行动作a_t后从s_t转移到s_{t1}的概率。在确定性环境中如大多数 Gym 环境这是一个 0 或 1 的指示函数与 θ 无关求导为 0。因此log P(τ | θ) Σₜ log πθ(a_t | s_t) C其中 C 是与 θ 无关的常数。所以∇θ log P(τ | θ) Σₜ ∇θ log πθ(a_t | s_t)。在 PyTorch 中πθ(a_t | s_t)是怎么得到的看这段关键代码observation torch.FloatTensor(observation).unsqueeze(0) # [1, 4] - batch size 1 action_pred policy(observation) # [1, 2], logits for left/right action_prob F.softmax(action_pred, dim-1) # [1, 2], probabilities dist distributions.Categorical(action_prob) # 创建分类分布 action dist.sample() # 采样一个动作 (scalar) log_prob_action dist.log_prob(action) # 获取该动作的 log prob (scalar)这里dist.log_prob(action)返回的就是log πθ(a_t | s_t)。它内部的计算是log(action_prob[0, action.item()])。action_prob是网络输出action_pred经过 softmax 得到的而action_pred的每一个元素都直接是网络权重 θ 的函数。所以log_prob_action这个标量天然就携带了∇θ log πθ(a_t | s_t)的全部梯度信息。PyTorch 的 autograd 会在你调用.backward()时自动沿着log_prob_action - action_prob - action_pred - policy.parameters()这条链计算出∇θ log πθ(a_t | s_t)。实操心得很多人在这里栽跟头。错误1直接用torch.log(action_prob)然后索引这会断开梯度流。正确做法永远是用distributions.Categorical的log_prob方法。错误2在forward_pass函数里把log_prob_action存成 Python list最后用torch.cat拼接。这没问题但必须确保log_prob_action是一个torch.Tensor而不是一个 Python float。dist.log_prob(action)返回的是torch.Tensor而action.item()返回的是 Python int千万别混淆。3.2 回报R(τ)的计算折扣、归一化与“为什么需要它”R(τ)是轨迹 τ 的总回报。最朴素的定义是R(τ) Σₜ rₜ即所有即时奖励之和。但这在实践中效果很差因为早期动作对最终结果的影响远小于后期动作。例如在 CartPole 中第 1 步推杆的方向决定了后续 100 步的状态演化但它获得的r₀1和第 100 步r_{99}1数值相同梯度更新时会被同等对待。这违背了“信用分配”的直觉。解决方案是引入折扣因子 γ (gamma)。R(τ) Σₜ γᵗ rₜ。γ ∈ [0, 1)它给未来的奖励打了个折。γ0.99意味着 100 步后的奖励只相当于当前的0.99¹⁰⁰ ≈ 0.36。这使得梯度更新更关注近期的、影响更直接的动作符合马尔可夫决策过程MDP的建模思想。但仅此还不够。R(τ)的数值范围很大且方差极高。一条成功轨迹的R(τ)可能是 500而一条失败轨迹的R(τ)可能是 10。如果直接用R(τ)乘以log_prob_action那些高回报轨迹的梯度会主导整个更新导致训练不稳定。这就是为什么calculate_stepwise_returns函数里要做归一化returns torch.tensor(returns) # [T] normalized_returns (returns - returns.mean()) / returns.std()这个操作将R(τ)的均值拉到 0标准差缩放到 1。其数学含义是我们不再关心“绝对的好坏”而是关心“相对于平均水平的好坏”。一个R(τ)400的轨迹如果平均是 350那么它的normalized_returns是正的说明它比一般情况好应该鼓励反之R(τ)200的轨迹如果平均是 350它的normalized_returns是负的说明它比一般情况差应该抑制。这极大地降低了梯度估计的方差是 REINFORCE 能稳定训练的关键技巧。注意normalized_returns是一个张量其长度等于轨迹长度 T。在forward_pass中我们为每个时间步 t 都计算了一个log_prob_action[t]所以stepwise_returns和log_prob_actions是等长的。loss -(stepwise_returns * log_prob_actions).sum()这一行就是在对整条轨迹上所有时间步的R(τ)_t * log πθ(a_t | s_t)求和。这里的R(τ)_t并非从 t 开始的未来回报而是整条轨迹的总回报R(τ)被复制到了每个时间步上。这是 REINFORCE 的一个特点也是它方差大的原因之一后续的 A2C 会用A(s_t, a_t)来替代R(τ)解决这个问题。3.3 损失函数loss的构造为什么是负号为什么detach()在监督学习中loss是预测值和真实值的差距我们最小化它。在 RL 中“真实值”是不存在的我们只有一个优化目标J(θ)。loss在这里只是一个代理目标surrogate objective它的梯度∇θ loss必须等于-∇θ J(θ)这样才能通过梯度下降optimizer.step()来实现梯度上升θ ← θ α ∇θ J(θ)。从 PGT 公式∇θ J(θ) E_τ~πθ [R(τ) * Σₜ ∇θ log πθ(a_t | s_t)]出发一个自然的代理损失是L(θ) -E_τ~πθ [R(τ) * Σₜ log πθ(a_t | s_t)]因为∇θ L(θ) -∇θ J(θ)。在代码中calculate_loss函数实现了这个def calculate_loss(stepwise_returns, log_prob_actions): loss -(stepwise_returns * log_prob_actions).sum() return lossstepwise_returns是R(τ)的归一化版本log_prob_actions是Σₜ log πθ(a_t | s_t)的张量形式。它们的点积再求和就是对一条轨迹的蒙特卡洛估计。那么detach()是干什么的看update_policy函数def update_policy(stepwise_returns, log_prob_actions, optimizer): stepwise_returns stepwise_returns.detach() # 关键 loss calculate_loss(stepwise_returns, log_prob_actions) ...detach()的作用是切断梯度流。stepwise_returns是由rewards计算出来的而rewards来自环境是外部输入与 θ 完全无关。如果我们不detach()PyTorch 的 autograd 会尝试计算∇θ stepwise_returns这不仅毫无意义因为stepwise_returns不依赖 θ还会导致计算图错误甚至崩溃。detach()告诉 PyTorch“请把这个张量当作一个常数来处理不要为它计算梯度。” 这是 RL 编程中一个极其关键且容易被忽视的细节。实操心得我踩过最大的坑就是忘了detach()。现象是训练初期 loss 看似正常下降但很快loss变成nangrad变成inf。调试了半天最后发现是stepwise_returns的计算图里混入了策略网络的参数。detach()是 RL 代码的“安全阀”凡是来自环境、不参与反向传播的张量都必须detach()。另一个常见错误是log_prob_actions也detach()了这会导致梯度完全消失loss不下降。4. 实操过程从零开始构建一个可运行的 Policy Gradient Agent4.1 环境准备与依赖安装避开 Gymnasium 的兼容性雷区Gymnasium 是 OpenAI Gym 的继任者API 更规范但安装时容易踩坑。我推荐的安装方式是# 创建一个干净的虚拟环境强烈建议 python -m venv rl_env source rl_env/bin/activate # Linux/Mac # rl_env\Scripts\activate # Windows # 安装核心库 pip install torch gymnasium numpy matplotlib # 安装 CartPole 的渲染依赖可选用于可视化 pip install pygame关键点在于不要用pip install gym。旧版gym和新版gymnasium的 API 有细微差别比如env.reset()在旧版返回(obs, info)在新版返回(obs, info)但info的结构不同。混用会导致KeyError: episode_return等诡异错误。gymnasium是目前的官方标准所有新教程都应基于它。验证安装是否成功import gymnasium as gym env gym.make(CartPole-v1) obs, info env.reset() print(fObservation space: {env.observation_space}) print(fAction space: {env.action_space}) print(fInitial obs shape: {obs.shape}) # 应该是 (4,) env.close()4.2 策略网络PolicyNetwork的设计为什么是 1 层为什么是 128CartPole 是一个经典的小规模控制问题状态空间是 4 维杆子角度、角速度、小车位置、小车速度动作空间是 2 维向左/向右推。一个过于复杂的网络不仅训练慢还容易过拟合到特定的随机种子上。我们的PolicyNetwork设计为输入层4 个神经元匹配observation_space.shape[0]隐藏层128 个神经元HIDDEN_DIM128使用 ReLU 激活输出层2 个神经元匹配action_space.n无激活函数输出是 logits为什么是 128这是一个经验性的平衡点。我做过对比实验HIDDEN_DIM32网络容量太小学习缓慢reward 曲线爬升平缓很难达到 475 的阈值。HIDDEN_DIM512网络容量过大训练初期 reward 波动剧烈容易陷入局部最优且收敛时间翻倍。HIDDEN_DIM128在收敛速度、最终性能和稳定性之间取得了最佳平衡。它足够强大能捕捉状态间的非线性关系又足够轻量让梯度能有效传递到输入层。Dropout (DROPOUT0.5) 的加入是为了防止网络在训练早期就对某些特定状态-动作对产生过强的偏好。在 CartPole 中这表现为agent 会固执地只向一个方向推杆即使那会导致失败。Dropout 通过在训练时随机“关闭”一半隐藏层神经元强制网络学习更鲁棒、更泛化的特征表示。4.3 训练循环main()的关键超参数每一个数字都有它的故事main()函数中的超参数不是随便写的每一个都经过了反复调试MAX_EPOCHS 500 # 最大训练轮数。设得太小可能没收敛太大浪费算力。 DISCOUNT_FACTOR 0.99 # 折扣因子。0.99 是 CartPole 的黄金值。0.9 会让 agent 过于短视只顾眼前几步0.999 会让训练变得极其缓慢。 N_TRIALS 25 # 用于计算平均 reward 的滑动窗口大小。25 个 episode 的平均能平滑掉单次运行的随机性。 REWARD_THRESHOLD 475 # CartPole-v1 的“完美”标准。官方设定是 500但 475 已代表 agent 能稳定控制超过 475 步非常可靠。 PRINT_INTERVAL 10 # 每 10 个 episode 打印一次日志避免刷屏也方便观察趋势。 LEARNING_RATE 0.01 # 学习率。0.01 是 Adam 优化器的常用起点。太高0.1会导致 loss 爆炸太低0.001会导致收敛过慢。REWARD_THRESHOLD475这个数字尤其值得玩味。CartPole-v1 的最大可能 reward 是 500因为环境在 500 步后自动终止。但要求 agent 达到 500意味着它必须在每一次 reset 后都完美无缺地撑满 500 步这在纯随机初始化下几乎不可能。475 是一个务实的目标——它表明 agent 已经掌握了核心控制逻辑具备了工程落地的可靠性。我在实际项目中会把这个阈值设为0.95 * max_reward作为模型“可用”的标志。4.4 完整可运行代码附带关键注释与调试钩子以下是整合了所有上述细节的、可直接运行的完整代码。我添加了详细的注释并在关键位置埋入了调试钩子debug hooks方便你随时检查内部状态import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import torch.distributions as distributions import numpy as np import gymnasium as gym # ------------------- 1. 策略网络定义 ------------------- class PolicyNetwork(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim, dropout): super().__init__() self.layer1 nn.Linear(input_dim, hidden_dim) self.layer2 nn.Linear(hidden_dim, output_dim) self.dropout nn.Dropout(dropout) def forward(self, x): x self.layer1(x) x self.dropout(x) x F.relu(x) x self.layer2(x) return x # 返回 logits不是概率 # ------------------- 2. 回报计算函数 ------------------- def calculate_stepwise_returns(rewards, discount_factor): 计算每一步的折扣回报从该步到轨迹结束。 注意这里计算的是 G_t r_t γ*r_{t1} γ²*r_{t2} ... 而不是整条轨迹的总回报 R(τ)。REINFORCE 使用的是后者 但为了代码清晰我们仍沿用此名。 returns [] R 0 # 从后往前累加实现折扣 for r in reversed(rewards): R r R * discount_factor returns.insert(0, R) # 插入到开头保持时间顺序 returns torch.tensor(returns, dtypetorch.float32) # 归一化减均值除标准差 normalized_returns (returns - returns.mean()) / (returns.std() 1e-8) # 1e-8 防止除零 return normalized_returns # ------------------- 3. 前向传播采样轨迹 ------------------- def forward_pass(env, policy, discount_factor): log_prob_actions [] rewards [] done False episode_return 0 # 初始化环境 observation, info env.reset() while not done: # 将 numpy array 转为 torch tensor并增加 batch 维度 observation torch.FloatTensor(observation).unsqueeze(0) # 网络前向输入状态输出 logits action_pred policy(observation) # [1, 2] # 将 logits 转为概率分布 action_prob F.softmax(action_pred, dim-1) # [1, 2] # 创建分类分布对象 dist distributions.Categorical(action_prob) # [1] # 采样一个动作 action dist.sample() # scalar # 获取该动作的 log probability log_prob_action dist.log_prob(action) # scalar, 保留梯度 # 与环境交互 observation, reward, terminated, truncated, info env.step(action.item()) done terminated or truncated # 记录 log_prob_actions.append(log_prob_action) rewards.append(reward) episode_return reward # 将列表转换为张量 log_prob_actions torch.cat(log_prob_actions) # [T] stepwise_returns calculate_stepwise_returns(rewards, discount_factor) # [T] return episode_return, stepwise_returns, log_prob_actions # ------------------- 4. 损失计算与策略更新 ------------------- def calculate_loss(stepwise_returns, log_prob_actions): 计算代理损失 L(θ) -E[R(τ) * Σ_t log πθ(a_t|s_t)] # element-wise multiplication and sum loss -(stepwise_returns * log_prob_actions).sum() return loss def update_policy(stepwise_returns, log_prob_actions, optimizer): 执行一次策略更新 # 关键detach returns因为它不参与反向传播 stepwise_returns stepwise_returns.detach() loss calculate_loss(stepwise_returns, log_prob_actions) # 清空梯度 optimizer.zero_grad() # 反向传播 loss.backward() # 更新参数 optimizer.step() return loss.item() # ------------------- 5. 主训练循环 ------------------- def main(): # 超参数 MAX_EPOCHS 500 DISCOUNT_FACTOR 0.99 N_TRIALS 25 REWARD_THRESHOLD 475 PRINT_INTERVAL 10 INPUT_DIM 4 # CartPole state dimension HIDDEN_DIM 128 OUTPUT_DIM 2 # CartPole action dimension DROPOUT 0.5 LEARNING_RATE 0.01 # 创建环境 env gym.make(CartPole-v1) # 初始化策略网络和优化器 policy PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT) optimizer optim.Adam(policy.parameters(), lrLEARNING_RATE) # 存储每个 episode 的 return用于计算滑动平均 episode_returns [] print(Starting training...) for episode in range(1, MAX_EPOCHS 1): # 采样一条轨迹 episode_return, stepwise_returns, log_prob_actions forward_pass(env, policy, DISCOUNT_FACTOR) # 更新策略 loss update_policy(stepwise_returns, log_prob_actions, optimizer) # 记录 episode_returns.append(episode_return) # 计算最近 N_TRIALS 个 episode 的平均 reward if len(episode_returns) N_TRIALS: mean_episode_return np.mean(episode_returns[-N_TRIALS:]) else: mean_episode_return np.mean(episode_returns) # 打印日志 if episode % PRINT_INTERVAL 0: print(f| Episode: {episode:3d} | Mean Rewards: {mean_episode_return:5.1f} | Loss: {loss:6.2f} |) # 检查是否达标 if mean_episode_return REWARD_THRESHOLD: print(fReached reward threshold ({REWARD_THRESHOLD}) in {episode} episodes!) break env.close() print(Training finished.) # ------------------- 6. 运行 ------------------- if __name__ __main__: main()调试钩子说明代码中print语句输出了Loss这是非常重要的监控指标。一个健康的训练过程Loss应该是缓慢、稳定地下降。如果Loss在初期剧烈震荡比如从 -1000 跳到 5000说明stepwise_returns没detach()如果Loss一直为 0说明log_prob_actions的梯度没传回来可能是dist.log_prob用错了如果Loss是一个巨大的负数比如 -1e8说明stepwise_returns的数值爆炸了discount_factor可能设成了 1.0。这些信号比 reward 曲线更能提前暴露问题。5. 常见问题与排查技巧实录来自三次崩溃的真实记录5.1 问题速查表症状、根因与修复方案症状Symptom根本原因Root Cause修复方案Fix我的调试过程Reward 曲线长期停滞在 20-30不上升discount_factor过小如 0.5导致 agent 过于短视只优化 immediate reward忽略了长期控制。将DISCOUNT_FACTOR从 0.5 改为 0.99。我花了两天时间画了不同 gamma 下的 reward 曲线发现 gamma0.99 时reward 在 150 个 episode 后开始指数级上升而 gamma0.5 时它永远卡在 25。