简介：面向逆强化学习（IRL）研究者与 Java 开发者的示例代码包，聚焦真实奖励函数未知场景下的算法设计与实验验证。项目涵盖学徒学习、网格世界任务、单阶段博弈等经典案例，并附带按逆强化学习需求改造过的 BURLAP 代码库快照，便于在既有强化学习框架中直接搭建和扩展实验。压缩包内共 497 个文件，主体为 484 个 Java 源文件，辅以少量 XML 与 POM 配置、外部 jar 依赖、许可与说明文档，整体仅 2.29MB，轻量而完整。已有 1046 人浏览学习。核心代码包含网格世界环境、学徒学习算法、多智能体性能绘图、单阶段正规型博弈等模块，并接入多个线性规划求解器和强化学习接口工具，可直接用于算法调试、结果可视化、对比实验与二次开发；若想从零理解逆强化学习如何从专家示范中恢复奖励函数，这份示例与配套 BURLAP 快照也能提供完整的学习路径。
1. 逆强化学习示例代码：一份能直接跑出回报函数的 Java IRL 教程
逆强化学习（Inverse Reinforcement Learning，IRL）解决的是强化学习的反向问题——手里只有专家轨迹，没有奖励函数，要把专家行为背后隐含的回报函数推断出来。IRLTutorial 这份示例代码就是围绕这个目标组织的：一套基于 Java 的网格世界 IRL 实现，从 MDP 建模、专家轨迹生成，到最大熵 IRL 的权重迭代，每一步都有可运行代码和对应输出。我拆这份资源前最大的顾虑是“Java 写 IRL 会不会很别扭”，毕竟主流教程几乎全是 Python。实际跑下来发现，只要把特征期望、值迭代、权重更新这些核心逻辑用类拆清楚，Java 的直观程度反而比脚本更好——每个栅格、每个状态转移都看得见。适合两类人：一类是刚读完 IRL 论文、想动手验证公式推导的研究生；另一类是必须在 Java 技术栈里做决策建模、却没有现成 Python 环境的工程师。它不是把论文复述一遍，而是把你推到“能自己改参数、自己加特征”的位置。
2. IRL 原理与算法选型：为什么教程押注最大熵而不是线性规划
2.1 逆强化学习的问题设定：四元组里少一个 R，多了一堆轨迹
先把这个资源第一眼看上去最抽象的东西讲明白。标准强化学习是在 (S, A, P, R) 四元组里求解最优策略，奖励 R 是已知输入；逆强化学习则相反，四元组里 R 是未知的，额外输入的是专家轨迹集合 D = {ξ₁, ξ₂, …, ξ_N}。每一条轨迹 ξ 是一个状态序列，比如网格世界里从左上角走到终点的一串格子编号。核心假设只有一个：专家在他自己的回报函数下是“接近最优”的，我们要从行为反推那个隐藏的回报。
为什么不能直接统计轨迹频率来恢复回报？因为能解释同一批轨迹的回报函数有无穷多个。比如一条从起点到终点笔直前进的路径，既可以解释成“终点奖励特别高”，也可以解释成“每走一步扣 5 分，绕路会被更重地惩罚”——这两个回报函数产生的行为几乎一样。这就是 IRL 的 ill-posed（病态）特性。所以动手写代码之前必须先回答一个问题：你打算给回报函数加哪种先验约束？这份示例代码选的约束是线性回报假设，R(s) = θ^T φ(s)，其中 φ(s) 是状态特征，θ 是待学习权重。线性假设不是唯一选择，但它是后续所有算法的地基：一方面 θ 的维度与特征同规模，另一方面在最大熵 IRL 里它的梯度更新会干净到可以直接对着公式写代码。
需要提醒的是，轨迹在这个框架里是“状态序列”而不是“动作序列”。很多第一次接触 IRL 的人会把专家数据录成上下左右的动作，加载时才发现特征期望无从算起。状态序列里天然包含位置信息，动作序列还得多做一步状态转移还原，示例代码直接采用状态序列，省掉这层麻烦。
2.2 最大熵 IRL 的核心思路：匹配特征期望，同时保持最大不确定性
最大熵 IRL（MaxEnt IRL，Ziebart 等人 2008 年提出）的出发点非常朴素：在“策略产生的特征期望与专家特征期望一致”这个约束下，选择熵最大的轨迹分布。为什么是熵最大？因为除了特征期望这个约束，我们对专家的内在偏好一无所知，熵最大等价于“不引入任何额外假设”，这是信息论里最诚实的做法。反过来，如果你直接找一个“恰好让专家轨迹概率最高”的回报，很容易过拟合到几条轨迹上。
把这个想法翻译成公式。轨迹 ξ 的概率正比于 exp(θ^T φ(ξ))，也就是回报加权后的指数分布。约束条件是策略下的特征期望等于专家特征期望：E_P[φ] = μ_E。用拉格朗日乘子法求解时有个漂亮的结论——拉格朗日乘子本身就是 θ，目标函数对 θ 的梯度恰好是特征期望之差：
∇θ = μ_E − μ(θ)
其中 μ_E 是专家轨迹的特征期望，μ(θ) 是当前权重下策略产生的特征期望。梯度上升更新 θ 即可。所以 MaxEnt IRL 的实现主线非常短：前向计算策略 → 算 μ(θ) → 拿 μ_E 减它 → 更新 θ → 重复。这也是我拆这份 Java 代码时最先确认的地方：主循环不超过五十行，其余全是数据结构、I/O 和日志，结构很清晰。
2.3 三条技术路线对比：示例代码为什么不用线性规划和学徒学习
IRL 的经典路线不止 MaxEnt 一条，教程选择它是有原因的。我做了个对比，方便你判断自己场景该用哪个。
| 路线 | 核心思想 | 对次优轨迹容错性 | 实现复杂度 | 适用场景 |
|---|---|---|---|---|
| Ng & Russell 线性规划 | 求使专家策略最优的回报集合，线性规划求解 | 差，轨迹稍带噪声就无解 | 低 | 演示用、小规模确定性环境 |
| Abbeel & Ng 学徒学习 | 迭代匹配策略，最大化最小边际 | 中，要求策略等价 | 中 | 只需要复现策略，不关心回报形式 |
| MaxEnt IRL | 特征期望匹配 + 熵最大化 | 好，天然假设随机最优 | 中 | 回报可视化、行为预测、轨迹生成 |
学徒学习在实际工程里也常见，它通过迭代求解一个最大化最小 margin 的回报来让学徒策略贴近专家策略。但它的输出是“一个能复现行为的策略”，轨迹概率分布没有概率解释，你很难回答“这条轨迹出现的概率是多少”。MaxEnt IRL 的输出则是完整分布，后续做行为预测或者轨迹生成都顺手。示例代码选 MaxEnt 不是因为它最先进，而是因为它最适合教学——每一行梯度代码都能对应到 2.2 里的公式，这是另外两条路线做不到的。
2.4 在 Java 里把 MDP 定义死：先写常量，再谈泛化
任何 IRL 实现的第一步都是把 MDP 定义成一个确定性的数据结构，而不是散落在各个方法参数里。这份教程用一个 GridWorld 类固定网格尺寸、方向动作和终止状态。我的习惯也是先写死、跑通、再谈泛化，否则调试时连“状态 17 是哪个格子”都要算半天。
public class GridWorld { public static final int W = 6; // 网格宽度 public static final int H = 6; // 网格高度 public static final int N = W * H; // 状态总数 36 public static final int START = 0; // 起点，左上角 public static final int GOAL = N - 1; // 终点，右下角 public static final int[] ACTIONS = {0, 1, 2, 3}; // 上、右、下、左 public static final double GAMMA = 0.9; // 折扣因子 public static final double LR = 0.05; // 梯度上升学习率 public static final double BETA = 3.0; // softmax 温度 public static int nextState(int s, int a) { int x = s % W; int y = s / W; switch (a) { case 0: y = Math.max(0, y - 1); break; // 上，撞墙留在原地 case 1: x = Math.min(W - 1, x + 1); break; case 2: y = Math.min(H - 1, y + 1); break; case 3: x = Math.max(0, x - 1); break; } return y * W + x; } }这段代码的几个参数各有讲究。GAMMA 取 0.9 是 IRL 里比较中庸的值，太大值迭代收敛慢，太小学出的回报会偏向短期目标；BETA 控制 softmax 策略的随机程度，影响整个梯度更新的稳定性，后面避坑章节会专门展开。nextState 里用了四个 Math 边界函数，把“撞墙回弹”直接揉进转移逻辑，这样整个工程里没有任何一处需要单独判边界，也避免了多个类重复实现同一段逻辑造成的状态不一致。这类常量是全工程唯一允许出现“魔法数字”的地方，其他模块都必须从它派生，这是我拆代码时比较认可的一点。
3. 示例代码的 Java 工程结构：从网格世界到特征期望，类怎么拆
3.1 工程形态与构建方式：先 Maven 编译，再 exec 插件跑 Main
拿到的源码是标准 Maven 目录结构，核心代码在 src/main/java/irl 包下，专家轨迹数据放在 src/main/resources。没有花哨的第三方库，唯一依赖是 JUnit。这种零依赖设计对学习资源很重要——你不需要为跑通示例去配 PyTorch 或者 NumPy 环境，一个 JDK 就够了。构建和运行命令如下：
cd IRLTutorial mvn -q compile mvn -q exec:java -Dexec.mainClass="irl.Main" \ -Dexec.args="src/main/resources/expert_traj.txt"如果你不习惯 Maven，直接用 javac 也可以跑，命令更直观：
javac -d out src/main/java/irl/*.java java -cp out irl.Main src/main/resources/expert_traj.txt我一般会优先用 Maven 的方式，因为后续如果读者想加日志框架或者画图库，改 pom.xml 比手工维护 classpath 省事。exec 插件把 mainClass 和 args 都写死在命令行，主要好处是运行参数肉眼可见：轨迹文件路径变了，直接改 -Dexec.args 就行。这里唯一要注意的是工作目录，Maven exec 默认在项目根目录执行，相对路径要基于根目录写，否则会报 FileNotFoundException——我见过不少第一次跑的人卡在这一步。
3.2 类职责划分：六个类各自只管一件事
这份代码的类设计是它比脚本式教程好读的关键原因。各文件职责如下：
| 类名 | 职责 | 关键输出 |
|---|---|---|
| GridWorld | 网格世界常量与状态转移 | 全局 MDP 定义 |
| TrajectoryLoader | 读取专家轨迹文件并校验 | List<int[]> |
| FeatureExtractor | 轨迹 → 特征期望向量 | double[] μ_E |
| MaxEntIRL | 前向策略计算 + 权重更新主循环 | double[] θ |
| Diagnostics | 收敛日志输出 | 控制台文本 |
| Main | 组装以上模块 | 最终回报热力图打印 |
这个拆分最大的好处是：你想换特征或者换轨迹格式，只动一个类，其他类完全不知道。后面第 6 章我会专门讲怎么只改 FeatureExtractor 就换一种特征表达，这个优点会在实战中体现得很明显。相比之下，很多 Python 教程把特征提取、值迭代、梯度更新写在同一个文件里，读起来快，改起来痛。
3.3 轨迹格式与加载校验：半截路径会让特征期望少算一步
专家轨迹文件一行是一条轨迹，状态编号用空格分隔。例如一行 “0 1 7 13 19 25 31 32 33 34 35” 表示从左上角出发，绕到右下角终点。TrajectoryLoader 的职责不只是读文件，更关键的是校验轨迹是否合法：
public static List<int[]> load(String path) throws IOException { List<int[]> trajectories = new ArrayList<>(); int minLen = Integer.MAX_VALUE; for (String line : Files.readAllLines(Paths.get(path))) { if (line.trim().isEmpty()) continue; int[] states = Arrays.stream(line.trim().split("\\s+")) .mapToInt(Integer::parseInt).toArray(); if (states[states.length - 1] != GridWorld.GOAL) { throw new IllegalArgumentException( "轨迹未终止于 GOAL: " + Arrays.toString(states)); } minLen = Math.min(minLen, states.length); trajectories.add(states); } System.out.println("Loaded " + trajectories.size() + " trajectories, min length=" + minLen); return trajectories; }这里有两个容易被忽略的设计。第一，它强制校验最后一位必须是 GOAL，这条判断能挡住大量“半截轨迹”——如果哪批数据是从中途截断的，特征期望会漏掉终点附近的访问次数，学出的回报在终点区域会明显偏小。第二，它顺手统计了最短轨迹长度并打印，这个信息在调节特征期望时很有用，第 5 章会讲到轨迹太短导致的副作用。IRL 的特征期望是“状态被访问的频率”，不是“状态是否被访问”，所以轨迹长度信息必须保留，不能让 loader 只返回一个集合匆匆了事。
3.4 把轨迹变成特征期望：一条轨迹归一化，一批轨迹再平均
特征选择决定了 θ 的可解释性。示例代码采用 one-hot occupancy 特征：φ(s) 是一个维度为 36 的向量，只在当前状态那一维为 1，其余为 0。一条轨迹的特征期望等于每个状态访问次数除以轨迹长度，避免“走得多就累计大”的偏差；然后除以轨迹条数，得到整个专家集合的平均特征期望。
public static double[] expertFeatureExpectation(List<int[]> trajectories) { double[] mu = new double[GridWorld.N]; for (int[] traj : trajectories) { for (int s : traj) { mu[s] += 1.0 / traj.length; // 先按轨迹长度归一化 } } for (int i = 0; i < mu.length; i++) { mu[i] /= trajectories.size(); // 再按轨迹条数平均 } return mu; }这两个除法次序不能换。先除以长度是消除轨迹长短差异，后除以条数是得到期望定义。如果你反过来，长轨迹会在特征期望里占据主导地位，而且 dominant 的还不是状态频率而是“这条轨迹覆盖了多少格子”，整个梯度方向都会被带偏。计算完之后可以把 mu 打印成 6×6 矩阵看一眼：起点和终点附近的访问频率应该最高，中间路径次之，完全没走过的区域是 0。这一眼检查比任何单元测试都直观，我每次拿到新的专家数据都会先做这一步再进主循环。
4. 核心循环逐段拆解：值迭代、软策略与梯度上升的完整流程
4.1 前向强化学习：给定 θ 先恢复一个值函数
MaxEnt IRL 的内层是一个标准强化学习求解器。给定当前权重 θ，我们把它当成即时回报，用值迭代求出每个状态的值函数 V(s)。这是后面软策略和状态访问频率的基础，也是最容易写错数值的地方。
double[] valueIteration(double[] theta) { double[] V = new double[GridWorld.N]; double[] Vn = new double[GridWorld.N]; for (int iter = 0; iter < 1000; iter++) { double delta = 0; for (int s = 0; s < GridWorld.N; s++) { if (s == GridWorld.GOAL) { Vn[s] = 0; continue; } double best = -Double.MAX_VALUE; for (int a : GridWorld.ACTIONS) { int s2 = GridWorld.nextState(s, a); double q = theta[s2] + GridWorld.GAMMA * V[s2]; best = Math.max(best, q); } Vn[s] = best; } for (int s = 0; s < GridWorld.N; s++) { delta = Math.max(delta, Math.abs(Vn[s] - V[s])); } double[] tmp = V; V = Vn; Vn = tmp; if (delta < 1e-6) break; } return V; }注意这里 Q(s,a) 用的即时回报是 theta[s2]，也就是转移后状态的回报，而不是当前状态 s 的回报。这两种写法在确定性转移下结果一致，但在边界回弹这种“动作可能不改变状态”的场景下会略有差别。示例代码统一取后继状态回报，和 R(s) = θ^T φ(s) 的定义保持一致。值迭代终止阈值 1e-6 是时间和精度的折中，教程把它作为常量暴露而不是内联，方便读者观察阈值大小对结果的影响。如果你把阈值放宽到 1e-4，迭代次数能省三分之一，θ 的最终值差别很小，但 V 的精度会直接影响后面的梯度。
4.2 软策略构造与状态访问频率：从值函数到稳态分布
MaxEnt IRL 不用硬 max 策略，而是用 softmax：π(a|s) ∝ exp(β Q(s,a))。这里 β 是温度参数，β 越大策略越贪心，越小越随机。有了策略之后，需要计算从起点出发、按该策略游走时各状态被访问的期望频率 μ(s)，这本质上是求解一个马尔可夫链的状态访问分布。
double[] stateFreq(double[] theta) { double[][] P = new double[GridWorld.N][GridWorld.N]; double[] mu = new double[GridWorld.N]; double[] V = valueIteration(theta); // 先构造软策略下的状态转移矩阵 for (int s = 0; s < GridWorld.N; s++) { if (s == GridWorld.GOAL) { P[s][GridWorld.GOAL] = 1.0; // 终点是吸收态 continue; } double[] q = new double[GridWorld.ACTIONS.length]; double maxQ = -1e9; double sum = 0; for (int a = 0; a < GridWorld.ACTIONS.length; a++) { int s2 = GridWorld.nextState(s, a); q[a] = theta[s2] + GridWorld.GAMMA * V[s2]; maxQ = Math.max(maxQ, q[a]); } for (int a = 0; a < GridWorld.ACTIONS.length; a++) { q[a] = Math.exp(BETA * (q[a] - maxQ)); // 减去 maxQ 防止指数爆炸 sum += q[a]; } for (int a = 0; a < GridWorld.ACTIONS.length; a++) { P[s][GridWorld.nextState(s, a)] += q[a] / sum; } } // 迭代求解访问频率 mu[GridWorld.START] = 1.0; for (int it = 0; it < 10000; it++) { double[] tmp = new double[GridWorld.N]; for (int s = 0; s < GridWorld.N; s++) { for (int s2 = 0; s2 < GridWorld.N; s2++) { tmp[s2] += mu[s] * P[s][s2]; } } double diff = 0; for (int s = 0; s < GridWorld.N; s++) { diff = Math.max(diff, Math.abs(tmp[s] - mu[s])); } System.arraycopy(tmp, 0, mu, 0, GridWorld.N); if (diff < 1e-9) break; } return mu; }这段代码有两个细节值得反复看。第一，softmax 的指数运算前减掉了 maxQ，这是数值稳定技巧——Q 值的量级可能随 θ 增长到几十甚至上百，不减去最大值的话 exp 直接就溢出了。第二，终点被设成吸收态，访问频率一旦流入终点就不再出来，这样才能和专家轨迹的特征期望对齐。μ 的迭代本质上是幂法求马尔可夫链稳态分布，10000 次上限对 36 个状态的网格绰绰有余。如果你修改了 GridWorld 的 START，这里必须同步改 mu 的初始赋值，否则算法永远不会从正确的位置出发，这个问题在避坑章节会再提一次。
4.3 梯度上升主循环：把特征期望差灌进权重
核心主循环比大多数人想象得短。给定专家特征期望和当前策略的特征期望，梯度就是两者之差，直接沿这个方向更新 θ：
double[] theta = new double[GridWorld.N]; for (int epoch = 0; epoch < 500; epoch++) { double[] muPolicy = stateFreq(theta); double[] grad = new double[GridWorld.N]; double maxGrad = 0; for (int i = 0; i < GridWorld.N; i++) { grad[i] = expertMu[i] - muPolicy[i]; // 梯度 = 特征期望差 maxGrad = Math.max(maxGrad, Math.abs(grad[i])); theta[i] += GridWorld.LR * grad[i]; // 梯度上升 } if (epoch % 50 == 0) { Diagnostics.log(epoch, maxGrad, theta); } }注意这里是梯度上升而不是下降，因为目标是对数似然函数，而 MaxEnt 的似然函数关于 θ 是凹的，沿梯度方向走就是在逼近极大值。学习率 LR 在这里起决定性作用：0.05 在 36 维特征下通常够用，但如果特征换成高维的（后面的扩展会讲到），可能需要降到 0.01。每 50 轮打印一次日志，输出 maxGrad 和 θ 的前几维，你就能直观看到训练过程。maxGrad 的量级是判断收敛的第一手信息——它从 0.x 一路降到 0.01 以下，说明策略的特征期望在逼近专家；如果它停滞在 0.1 以上还上下抖动，说明温度或学习率需要调整。
4.4 收敛判据与日志解读：看见优化过程而不是只给结果
这份代码的 Diagnostics 类承担了把黑匣子拆开的任务。它在每个日志点输出三类信息：当前 epoch、maxGrad 值、θ 的摘要。θ 摘要不是打印全部 36 个数，而是打印最大权重和对应状态编号，这样你不用在控制台翻页就能判断“哪个格子被学出高回报”。
提示：判断收敛时，别只盯着 maxGrad 的绝对值。正确做法是同时观察它的下降趋势——如果它在 0.06 上下震荡三十轮不降，说明 β 太小策略太随机，梯度信号弱；如果它单轮骤降到 1e-4 以下，要警惕过拟合，这时候学出的 θ 只在训练轨迹上有效，换一条轨迹就崩。
另一个容易被忽略的观察点是 θ 本身的形状。学完 500 轮后把 θ 按 6×6 打印，正常的回报热力图应该是终点附近高、起点附近低、路径上有渐变。如果看到全图只有一个亮点，其他全是负数，大概率是轨迹数据量不足的问题，对应第 5 章的 5.3 小节。
5. 常见问题与避坑：跑 IRL 示例代码最容易翻车的五个细节
跑 IRL 这类迭代算法，很大一部分时间花在排错上。这一章是我对照这份示例代码实际跑过之后总结出来的血泪经验，按“现象 → 原因 → 解决”写，方便你直接对照排查。
5.1 梯度爆炸：日志里的 maxGrad 冲到几百，θ 变成 NaN
现象：跑几十轮后 Diagnostics 输出的 θ 出现 NaN，之后所有输出都是 NaN，程序还没报错。
原因：最常见的是学习率初始值太高，梯度累积后震荡放大；其次是特征期望计算里某个状态被零除——比如轨迹文件中出现空行，如果 loader 没跳过空字符串，1.0 / 0 会直接算成 Infinity。虽然 3.3 的 loader 已经跳过空行，但你自己改数据格式时很容易把过滤逻辑改丢。
解决：把学习率降到 0.01 起步，同时在权重更新处加一个裁剪拐杖：
theta[i] = Math.max(-5.0, Math.min(5.0, theta[i] + GridWorld.LR * grad[i]));这个裁剪不是漂亮方案，但它能保证程序活下来。我一般会在调试期保留裁剪，确认算法逻辑没问题之后再摘掉。顺手补一条判断：如果裁剪生效后 θ 大量落在 ±5.0 边界上，说明不是数值问题而是梯度方向本身有问题，这时候回头查特征期望才是正路。
5.2 值迭代不收敛：内层循环跑满 1000 轮还在算
现象：程序整体耗时飙升，4.1 的 valueIteration 里 delta 迟迟降不到 1e-6，主循环一个 epoch 要等几秒。
原因：把 GAMMA 设成了 0.99 甚至 1.0。折扣因子越接近 1，回报向后传播需要的迭代轮数越多。6×6 的网格还扛得住，一旦你按第 3 章的思路把网格改成 10×10，每轮值迭代的代价直接翻几倍。
解决：GAMMA 保持在 0.9 附近，把迭代上限保持 1000，同时把收敛阈值从 1e-6 放宽到 1e-4。如果你的场景确实需要长视界，那就把上限提到 5000 而不是无限循环，并在 delta 连续 20 轮不下降时强制 break——无限循环是调速大敌，跑挂一次就记住了。
5.3 学出的回报热力图全图一个亮点，其余格子全是负值
现象：θ 打印成热力图后，只有 GOAL 附近一个格子是正的，其他全是 0 或负数，但用这个 θ 生成的策略路径又和专家轨迹高度重合。
原因：这是典型的特征期望覆盖不足。专家轨迹太短（比如只有两三步）导致访问频率几乎只集中在局部；或者轨迹条数太少，只有一两条，μ_E 里大部分维度是 0，梯度在这些维度上毫无信号。
解决：先把 expertMu 打印成 6×6 矩阵看一眼覆盖率，再去补数据。经验值是至少 10 条轨迹，每条长度不低于网格对角线的一半（6×6 网格就是不少于 6 步）。如果数据确实有限，另一个补救办法是换特征——用 2.2 提到的高斯核平滑特征代替 one-hot，让相邻格子共享梯度信号，这在轨迹稀疏时能明显改善 θ 的形状。
5.4 权重震荡不收敛：maxGrad 在 0.05 到 0.2 之间来回摆
现象：梯度不下降，日志里 maxGrad 像心跳一样往复，θ 的符号也在正负之间横跳。
原因：softmax 温度 BETA 设置不当。BETA 太小，策略接近均匀随机，特征期望对 θ 的变化不敏感，梯度信号弱且噪声大；BETA 太大，softmax 退化成 hardmax，梯度变成断崖，更新一步就冲过头。
解决：BETA 从 1.0 开始，逐步加到 5.0。按我的经验，2 到 10 之间梯度最稳。更省心的做法是退火：每 100 轮把 BETA 乘 1.2，上限 10。退火的好处是前期探索、后期收敛，和模拟退火的思路同源，在 4.3 的主循环里只需要加一行代码。
5.5 结果不可复现：相同参数和轨迹，两次运行 θ 完全不同
现象：完全相同的命令、相同的输入文件，跑两次输出两组差别明显的 θ。
原因：最常见的是轨迹生成阶段用了不带种子的 Random，或者值迭代用了随机初始化。示例代码的轨迹如果是手工构造的还相对安全，但一旦你真想用程序生成专家轨迹，没固定种子就会引入随机性。另一个隐蔽因素是控制台日志的线程打印顺序，看起来像结果变了，其实只是输出次序错乱。
解决：所有随机源一律固定种子：
Random rnd = new Random(42);这个 42 是惯例，换成任意固定整数都行。IRL 的可复现性和 RL 一样，是评估代码正确性的底线——种子不固定时，你看到的“收敛曲线”可能是随机性调参调出来的错觉，那比不收敛更危险，因为它给你虚假信心。
6. 验证与进阶：三招确认你学到的回报函数是真的
6.1 用轨迹似然做定量评估
θ 学出来之后，第一件事不是看热力图，而是算一个数字：专家轨迹在学到的 θ 下的平均对数似然。对每条轨迹 ξ，其对数似然正比于 Σ_{s∈ξ} θ·φ(s)，即轨迹上所有状态的回报之和。算出来后和均匀随机权重下的同批轨迹似然对比。如果学到的 θ 把专家轨迹的似然抬升了几个数量级，说明回报确实捕捉到了专家偏好；如果提升不到一个数量级，大概率是特征或数据的问题，回头查第 5 章对应条目。
6.2 画两条曲线判断收敛：梯度范数的下降曲线，θ 形状的稳定性
Diagnostics 已经把每 50 轮的 maxGrad 和 θ 打印出来了，把这组输出重定向到 CSV，画两条曲线。第一条是 maxGrad 随 epoch 下降的曲线，用于确认优化没有问题——平滑下降是健康信号，锯齿状下降说明 BETA 偏大，平台期说明学习率偏小。第二条是 θ 的高维可视化，直接把 36 维画成 6×6 热力图逐个 epoch 对比，看形状是否稳定。这条更苛刻：即使 maxGrad 已经很小，θ 的形状可能还在缓慢漂移，漂移意味着没完全收敛，需要多跑几轮或者调大 BETA。
6.3 向函数逼近特征扩展：只改一个类就能换特征表达
one-hot 特征的教学价值高，但它不是唯一的。把特征换成“到终点的距离势函数”或者“自定义障碍密度特征”时，整个工程只需要改 FeatureExtractor 一个类，值迭代、状态访问频率、梯度更新全部不动。这也解释了第 3 章为什么要按职责拆六个类——你现在可以体会一下，如果所有逻辑都揉在单个脚本里，换特征意味着重写一半代码。扩展时只记住一条：特征的维度变了，theta 的初始化数组长度要跟着变，否则会越界。从 one-hot 换到低维特征后，你会发现梯度下降的轮数变少了，但 θ 的可解释性也随之下降——这就是表达力和可解释性的取舍，教程把这层边界留给你自己体会。
我最初跑这份示例代码时，也掉进过 5.1 的梯度爆炸坑，当时以为公式写错了，反复检查两小时，最后发现只是学习率设了 0.5。从那以后，我每次拿到任何一份 IRL 示例代码，都会强制按先打印特征期望覆盖率、再检查梯度量级、最后看热力图形状的顺序走一遍，这个习惯帮我省下大量排查时间。这份教程的源码包解压后按第 3 章的 Maven 命令就能直接复现所有输出，希望你也能从“看懂公式”迈到“能改参数、能自己加特征”这一步，希望帮到你。
本文还有配套的精品资源，点击获取
