个人思考｜强化学习 + 生成式轨迹规划：四种范式、核心挑战与未来方向

前言

本文不是一篇教程，而是一份学习笔记 + 个人思考。写这篇文章是因为我自己在学这个方向时，发现文献散落在各个会议和 arXiv 上，缺少一个从"小白视角"出发的宏观梳理。希望这篇文章能帮到同样在入门这个方向的朋友。

写这篇文章的契机是最近读了 Diffusion Planner、Flow-GRPO、AutoVLA、DriveVLA-W0 等几篇工作，发现它们虽然都在做同一件事——用强化学习改进生成式轨迹规划——但技术路线差异很大。更让我困惑的是，每篇论文都说自己是"第一个把 RL 和扩散/流结合的工作"，到底谁在说真话？

后来读多了才发现：不是谁在撒谎，而是"结合"的方式可以非常不同。

所以这篇文章的目的就是：把"RL × 生成式轨迹"这盘棋的全局画出来，然后深入分析每一种下法的优缺点，最后给出我自己对这个方向的判断。

1. 快速基础回顾（写给小白）

1.1 生成式轨迹规划是什么？

传统的轨迹规划是"确定性的"——给定一个场景，输出一条轨迹。但这有问题：一个场景可能有多个"正确"的走法。

生成式模型（扩散/Flow）天生适合做轨迹规划，因为它们输出的是一个分布而不是一个点。

关键点：

• 训练：给模型看大量专家轨迹，让它学会"合理的轨迹长什么样"
• 推理：从噪声出发，逐步去噪/积分，得到一条合理的轨迹
• 多模态：多次采样可以得到多条不同的合理轨迹

1.2 强化学习的核心概念（写给纯小白）

如果你完全没接触过 RL，不要怕。这里用最直白的方式讲清楚。

RL 和 SFT 最本质的区别

RL 的核心循环：

智能体（Agent）在环境（Environment）中做动作（Action），环境反馈奖励（Reward）和下一个状态（State），智能体根据奖励调整策略（Policy），让它下次做得更好。

简化成流程：

状态 sₜ → 智能体（策略 π）→ 动作 aₜ → 环境 → 奖励 rₜ + 新状态 sₜ₊₁ → 策略更新 → 循环

在轨迹规划里：

• 智能体 = 扩散/Flow 模型
• 动作 = 生成的轨迹（一系列 waypoint）
• 环境 = 驾驶场景（道路、障碍物、交通参与者）
• 奖励 = 安全？舒适？到达？规则遵守？

四组核心概念

如果你是 RL 新手，记住这四个概念就够了：

核心公式（只需看一眼）：

∇J(θ) = E[ R(τ) · ∇log p_θ(τ) ]

翻译成人话：好的轨迹要让生成概率变大，差的轨迹变小的方向更新模型参数。

为什么是 log-prob？因为我们要在保持生成多样性的前提下调整概率分布。这个 log-prob 在传统 RL 里很容易算（单步动作），但在扩散/Flow 的多步去噪过程中就变得极其麻烦——这会是后面的核心话题。

2. SFT 的天花板

2.1 为什么 SFT 不够？

目前的生成式轨迹模型，绝大多数是用 SFT（模仿学习/行为克隆） 训练的：

• 收集大量专家驾驶数据
• 让模型"照着学"：最大化 log p_θ(轨迹_专家 | 场景)

这就是最直接的监督学习。看起来没什么问题？

实际上问题很大。

2.2 Mode Averaging 效应

SFT 最隐蔽的问题是什么？我举一个具体例子：

在一个路口，有人说"左转"、有人说"右转"、没人说"直走"。SFT 学到的结果是——直走。

因为 SFT 最小化的是 KL 散度 D_KL(专家数据分布 || 模型分布)，它对"数据里没有的"做了平滑平均。模型在"左转和右转的高斯混合"中间找到了一个"都有点像又都不像"的均值点。

这就导致了 mode averaging（模式坍缩到平均）。

看懂这张图了吗？左边有两个专家的路线——一个绕左边走、一个绕右边走。SFT 学完以后，对于中间的障碍物，它给出的轨迹是"直走"，因为这是"左和右的平均"。但直走意味着撞上障碍物。

在实际驾驶中，这个效应非常危险。 所有专家都避开的障碍物，SFT 可能因为"左右需求平均"而直接对着障碍物开过去。

值得一提的是，这个问题的严重程度和数据的多样性有关：

扩散/Flow 模型在 SFT 下的 mode averaging 比传统回归模型更隐蔽，因为生成式模型本身是分布式的（输出是一个分布而不是一个点），SFT 只是"拉偏"了分布的方向，但生成的样本仍然有多样性。这种"假性多模态"让人误以为模型学会了所有走法，实际上模型只是在所有走法之间取了个平均。

这也是为什么一些论文报告 SFT 效果还不错——因为评测指标只看"最终位置误差"或"碰撞率"，不看你走的路线是不是"合理"的。你可能撞不上障碍物（因为误差容限大），但走了一条所有人类司机都不会走的奇怪路线。

2.3 永远无法超越专家

这可能是 SFT 最本质的限制：模型学到的最高水平不会超过训练数据里的最高水平。

就像一个学棋的人只看棋谱，永远下不出棋谱上没有的妙手。但 RL 可以——它通过试错、奖励、改进，找到训练数据里根本不存在的更好策略。

2.4 那为什么偏偏是「扩散/Flow × RL」？

你可能想问：普通 RL（如 DQN、SAC）也能做轨迹规划，为什么要加上扩散/Flow 模型？

答案是：扩散/Flow 给 RL 带来了两个传统 RL 没有的优势。

优势 1：天然的多模态输出

传统 RL 策略（如高斯策略）输出的是"一个动作"——即使是随机策略，也是在某个均值附近采样。这意味着它在一个状态下只能产生"一种风格"的行为。

扩散/Flow 策略输出的是"一个分布"——它可以同时包含"左转"和"右转"两个模式。RL 只需要从这些模式中选出"好"的那个，而不是从零开始学会探索。

优势 2：先验分布 = 好的初始化

SFT 虽然有限制，但它给了模型一个非常好的初始化——模型已经知道"什么样的轨迹是合理的"。RL 要做的是"在这个基础上优化"，而不是"从随机策略开始探索世界"。

这一点在自动驾驶中尤其重要。你不可能让一个 RL 智能体在真实道路上做数百万次试错（那会撞死所有人）。但有了 SFT 预训练 + 生成式模型的多模态先验，RL 只需要在"已经合理的轨迹"中做选择和改进。

打个比方：

SFT + RL on 扩散/Flow = 先让一个学生看所有教科书（SFT），再让他做真题、找老师批改（RL）。

传统 RL on 传统策略 = 让一个学生直接做真题，连公式都不知道。

后者在 Atari 游戏里可行（死一局重来一局），但在自动驾驶里不可行（撞一次车就完了）。

这就是为什么扩散/Flow × RL 在 2025-2026 年突然火起来——生成式模型提供了 RL 需要的安全探索空间。

3. 四大范式全景

在研究清楚当前文献后，我把 “RL × 生成式轨迹” 的方法归纳为四个由浅入深的范式。

范式一：推理时奖励引导（Training-Free Guidance）

核心思想：模型权重不动，只在采样过程中用 cost function 的梯度去"推"轨迹。

代表性工作：Diffusion Planner、CTG++

为什么最简单？

想象你已经训练好了一个扩散轨迹模型。现在你想让生成的轨迹"更安全"。传统做法是：重新收集安全数据 → 重新训练模型。

但这个范式的做法是：在推理时，每一步去噪时除了看模型预测，还额外计算一个安全 cost 函数对轨迹的梯度，然后把轨迹往 cost 减小的方向推一点。

实现步骤：

1. 训练一个扩散/Flow 轨迹生成模型（完全正常的 SFT）
2. 推理时，每一步去噪：
   • 先算模型预测的速度/噪声：v_t = v_θ(x_t, t)
   • 再算一个引导项：g_t = ∇_{x_t} J_collision(x_t)
   • 修正：v_t’ = v_t - λ · g_t
   • 走一步修正后的去噪
3. 最终轨迹自然更安全、更舒适

优点：

• 完全不需要改动模型权重，部署极快
• 零训练成本
• 可以换不同的 cost 函数（不同风格）
• 不担心"训飞"

缺点：

• 引导强度 λ 是玄学——太弱没效果、太强产生伪影
• cost 函数必须可微
• 受预训练模型的分布限制，不能"无中生有"
• 每次推理需要多算一轮 cost 梯度，计算量增加

个人评价：这是目前落地最成熟的范式。Diffusion Planner 的引导效果非常漂亮。但如果你的生成模型本身就很差（SFT 阶段没学好），那引导也救不了。

实战经验：λ 怎么调？

引导强度 λ 是这个范式中唯一（也是最重要的）超参数。我总结了一个经验法则：

1. 从 λ=0 开始（无引导），看模型默认生成的轨迹质量
2. 每次翻倍：λ=0.1 → 0.2 → 0.4 → 0.8，直到轨迹出现明显伪影（锯齿、抖动）
3. 回退一半：取上一个不产生伪影的值
4. 按场景调整：不同场景可能需要不同的 λ

更高级的做法是自适应 λ：

• 在 cost 梯度方向与模型预测方向一致时，加大 λ
• 在 cost 梯度方向与模型预测方向冲突时，减小 λ
• 这样可以避免引导"拉扯"模型到不合理的区域

范式二：拒绝采样微调（RFT）

核心思想：采样一大批 → 用规则奖励打分 → 挑最好的当新的训练数据 → 继续 SFT。

代表性工作：AutoVLA RFT

如果说范式一是"小改"，范式二就是"退一步"——本质上又把 RL 问题退化成了 SFT 问题，只不过训练数据变成了自己采样的好轨迹。

具体流程：

重复 N 轮：

1. 采样：从当前模型对每个场景 s 采样 K 条轨迹
2. 打分：用规则奖励函数 R 给每条轨迹评分
3. 筛选：取 Top-M 高分轨迹作为正样本
4. 训练：用这些正样本做 SFT，更新模型参数

这套流程在 AutoVLA 中效果非常显著。它的实现真的非常朴素，没有任何花哨的 RL 技巧。

优点：

• 实现简单到令人发指
• 不要求模型 log-prob 可求（不需要改去噪过程）
• 任何生成模型都能用（扩散、Flow、VAE 随便）
• 不会出现 reward hacking（因为我们只采样，不直接优化 reward）
• 采样越多，数据集越丰富，效果越好

缺点：

• 样本效率极低：4 条里挑 1 条，浪费 75%
• 分布受限：永远是在"当前模型能生成的范围"里挑最好的
• 不能真正改变模型的行为模式，只是筛选已有的好样本
• 多轮迭代后收益递减——到了后期，采样的轨迹全都高分，没有进步空间
• 本质上还是 SFT，所以 SFT 的所有问题（mode averaging、过平滑）依然存在

个人评价：作为"第一个 RL 改进"非常推荐。代码改动小、效果可预期、风险极小。但别指望它带来质的飞跃。做了一圈 RFT 后你会发现——瓶颈在生成模型的"探索能力"，不在"筛选能力"。

实战经验：做好 RFT 的五个技巧

技巧 1：K 值怎么选？

K（每组采样的轨迹数）是 RFT 中最重要的参数。我的经验是：

• K=4 是最低要求，再少则样本覆盖率不够
• K=8~16 是 sweet spot
• K>32 时收益递减——因为高分轨迹开始大量重复

技巧 2：奖励函数不要复杂

很多人一上来就设计花哨的奖励函数：碰撞检测 + 舒适度 + 效率 + 交通规则 + 车道保持 + …

实际上 RFT 只需要 2-3 个核心指标就够了。越简单的奖励函数，筛选出的数据噪声越小，SFT 训练效果越好。

技巧 3：不仅要选好的，也要用坏的？

有些做法是把"好轨迹"当正样本，“坏轨迹"当负样本做 contrastive learning。我试过，效果不好。RFT 的核心思路是提纯数据，而不是对比学习。筛选出的正样本直接做 SFT 就够了。

技巧 4：多轮迭代的频率

每轮 RFT 后模型会变好，采样到的轨迹质量也更高。但迭代到第 5-8 轮后收益会饱和。这时候需要切换到范式三（策略梯度）才能突破。

技巧 5：小心伪高分

有时候奖励函数有 bug，会让某些明显不合理的轨迹得高分（比如急刹车停住不动但碰撞分为 0）。建议每轮 RFT 后人工检查 Top-10 的高分轨迹，确认奖励函数的质量。

范式三：策略梯度直接优化

核心思想：对生成过程的参数直接算策略梯度，用奖励信号反向传播更新去噪网络。

代表性工作：Flow-GRPO、DPO for Diffusion、Diffusion Policy Gradient

这是最"正宗"的 RL，也是最难实现的。

3.1 核心困境：扩散模型的 log-prob 怎么算？

回顾 RL 更新公式：

θ ← θ + α · E[ R(τ) · ∇_θ log p_θ(τ) ]

这里的问题是 log p_θ(τ) 对于扩散/Flow 模型来说极其复杂。

为什么？因为"生成一条轨迹 τ” 是一个多步迭代过程：

其中 v_t 是第 t 步去噪时的预测速度。我们的生成模型输出的是 T 个这样的速度。

整个过程的联合概率： p_θ(τ) = p_θ(v₁, v₂, …, v_T) = p_θ(v₁) · p_θ(v₂|v₁) · … · p_θ(v_T|v_{T-1})

在扩散/Flow 中，每一步的分布通常是高斯分布： p_θ(v_t | v_{t-1}) = N(μ_θ(v_{t-1}, t), σ² I)

所以： log p_θ(τ) = Σ_t log N(v_t; μ_θ(v_{t-1}, t), σ² I) = -½ Σ_t ||v_t - μ_θ(v_{t-1}, t)||² / σ² + const

但这里有个关键细节：实际生成时，我们用的是确定的 ODE 求解器（如 Euler、RK4），没有随机性。这怎么办？

3.2 Flow-GRPO 的解决方案

Flow-GRPO（字节跳动, NeurIPS 2025）的解决思路非常优雅：

1. ODE → SDE 转换：在确定性 ODE 求解中加入少量噪声，让它变成随机微分方程（SDE），这样就重建了可导的 log-prob

2. Denoising Reduction：把 T 步的 log-prob 近似压缩成 1 步，大幅降低训练计算量

3. 使用 GRPO 而非 PPO：不用 critic 网络，省掉大约 40% 的显存

具体来说：

• 标准 Flow 生成：dx = v_θ(x, t) dt（ODE，确定性，无 log-prob）
• Flow-GRPO 转换后：dx = v_θ(x, t) dt + σ(t) dw（SDE，有随机性，可算 log-prob）
• log-prob：用 Itô 积分的 Girsanov 定理推算

这个 SDE 转换保证了：

• 生成的质量几乎不变（σ(t) 很小）
• log-prob 终于可以算了
• 策略梯度可以正式应用

3.3 各策略梯度方法对比

Flow-GRPO vs DPO for Diffusion:

个人评价：策略梯度是最有"RL 感觉"的方法，也是我个人认为最有前途的方向。但实话实说，目前的技术成熟度还远不如范式一和范式二。Flow-GRPO 的 SDE 转换虽然优雅，但引入的额外噪声和近似会降低生成质量。DPO for Diffusion 虽然不需要奖励模型，但依赖已有的偏好数据，缺乏探索动力。

3.4 PPO vs GRPO：到底选哪个？

如果你要做策略梯度，首先面对的问题是：用 PPO 还是 GRPO？

PPO 的核心架构：

• Actor + Critic 两个网络
• Critic 负责估计状态价值 V(s)，作为 baseline 计算优势 A_t = Q(s,a) - V(s)
• 需要 GAE（Generalized Advantage Estimation）做多步优势估计
• Critic 和 Actor 一样大 → 显存 ×2

GRPO 的核心架构：

• 只有 Actor，没有 Critic
• 对同一个输入采样 G 条轨迹，用组内奖励的均值和标准差做基线
• A_i = (R_i - mean(R_group)) / std(R_group)
• 省掉 40-50% 的显存，训练更稳定

在扩散/Flow 模型上的选择：

我的建议非常明确——选 GRPO，不要选 PPO。

原因有三：

1. 扩散模型的 Actor（去噪网络）已经非常大了（几百 M 到几 B 参数），再加一个同样大小的 Critic，显存根本不够
2. Critic 的输入是"状态"，而扩散模型的状态是整个场景信息（图像、点云等），Critic 也需要同样的视觉编码器 → 等于训两个大视觉模型
3. 扩散模型的生成过程本身就可以采多条轨迹 → GRPO 的"组内采样"成本几乎为零

这也是为什么 Flow-GRPO、DriveVLA-W0 等最新工作全部选择 GRPO。

3.5 Flow-GRPO 训练循环详解

理解 GRPO 的概念是一回事，理解它如何在扩散/Flow 模型上具体实现是另一回事。

这张图展示了 Flow-GRPO 的完整训练循环：

Step 1：ODE → SDE 转换

• 标准 Flow 是确定性 ODE：dx = v_θ(x, t) dt
• Flow-GRPO 加入少量噪声：dx = v_θ(x, t) dt + σ(t) dw
• σ(t) 通常设得很小（如 σ=0.01），保证生成质量几乎不变
• 关键作用：SDE 的随机性让 log-prob 变得可计算

Step 2：采样一组轨迹

• 对同一个场景/条件 c，从 SDE 采样 G 条轨迹
• G 一般取 4-8 条（和 GRPO 的 group size 一致）
• 对每条轨迹用奖励函数 R 打分

Step 3：组内优势计算

• 计算本组奖励的均值 μ 和标准差 σ
• 每条轨迹的优势 A_i = (R_i - μ) / σ
• 这就是"组相对"的含义——奖励是相对的，不是绝对的

Step 4：Denoising Reduction

• 完整去噪链有 T=50-100 步，每一步都算 log-prob 太贵
• DR 技术：随机采样 K 个时间步（K=1-4），只在这几步算 log-prob
• 近似公式：log p_θ(τ) ≈ (T/K) · Σ log p_θ(v_{t_k} | v_{t_{k-1}})
• 训练速度快 10-20 倍，且实验证明效果几乎不变

Step 5：GRPO 策略更新

• 用优势 A_i 加权更新 Actor 参数
• 好的轨迹（A_i > 0）→ 提高生成概率
• 差的轨迹（A_i < 0）→ 降低生成概率
• 用 clip 限制更新幅度，防止训飞

整个循环反复迭代，每次迭代模型都变得更好。

3.6 策略梯度如何通过扩散网络反向传播？

你可能好奇：说了这么多"策略梯度"，梯度到底是怎么通过几十步去噪网络传回去的？

让我们一步步看：

1. 前向生成：从初始噪声 x₀ 开始，经过 T 步去噪，每步调用 v_θ 预测速度/噪声，最终生成轨迹 x_T
2. 计算奖励：R(x_T) 是对最终轨迹的打分
3. 反向传播：∇_θ R(x_T) 需要穿过整个计算图
   • 从 x_T 往回传 → 经过最后一步 v_θ → 到 x_{T-1} → … → 到 x₀
   • 每一层都涉及 v_θ 的梯度

这就是"通过时间反向传播"（BPTT），和训练 RNN 的原理类似。

为什么这很难？

• 内存爆炸：T=50 步的计算图，每一步都存中间变量 → GPU 内存不够
• 梯度消失/爆炸：50 步连乘，梯度要不消失要不爆炸
• log-prob 不可导：确定性 ODE 没有概率解释

Flow-GRPO 用两个技巧分别解决：

• Denoising Reduction → 减少 T（从 50 步降为 1-4 步）→ 解决内存和梯度问题
• SDE 转换 → 重建 log-prob → 解决概率问题

没有这两个技巧，策略梯度在扩散/Flow 模型上就训不动。

范式四：世界模型 + RL

核心思想：学一个世界模型做环境，把生成模型当策略，在世界模型里做 RL 训练。

代表性工作：DriveVLA-W0、DreamerV2/3、Iso-Dream

这是最"宏大"的范式，也是最复杂的。

4.1 为什么需要世界模型？

前面三种范式都有一个共同的问题：奖励只能在轨迹终结后计算。

在实际驾驶中，一个看似安全的动作可能在 5 秒后导致危险。前面的方法都无法捕捉这种"延迟奖励"。世界模型提供了解决方案：在想象中提前预测未来。

4.2 架构拆解

世界模型范式的核心架构包含三个组件：

1. 世界模型（World Model）：学环境的动力学 p(s_{t+1} | s_t, a_t)

   • 输入：当前状态 + 动作
   • 输出：下一状态的预测分布
   • 在驾驶中，这相当于学了一个"模拟器"

2. 策略模型（Policy/Actor）：生成式轨迹模型，负责决定怎么走

   • 与世界模型交互，生成动作序列

3. 价值模型（Critic/Value）：估计某个状态值多少钱

   • 帮助策略在想象中做出更好的决策

训练流程：

1. 策略生成轨迹（在真实环境或世界模型中）
2. 收集交互数据 (s, a, r, s')
3. 更新世界模型：最小化预测误差
4. 更新策略：用世界模型做 rollout，用 RL 优化
5. 更新价值函数（如果用 Actor-Critic）

世界模型 Rollout 详解

世界模型范式中最核心的操作是 imagination rollout（在想象中 rollout）：

1. 从当前真实状态 s₀ 出发
2. 策略 π 生成动作 a₀
3. 世界模型预测下一状态 ŝ₁ = WM(s₀, a₀)
4. 策略 π 基于 ŝ₁ 生成 a₁
5. 世界模型预测 ŝ₂ = WM(ŝ₁, a₁)
6. 重复直到 rollout 结束
7. 计算累积奖励 Σr_t，更新策略

这个 rollout 完全在"想象"中进行，不需要真实环境交互。这就意味着：

• 不需要真车上路（安全）
• 可以并行 rollout 大量场景（高效）
• 可以探索极端情况（没有风险）

但前提是世界模型要足够准。

DriveVLA-W0 的具体做法

DriveVLA-W0（CVPR 2025）把世界模型和扩散策略结合得最紧密：

1. 世界模型作为条件编码器：世界模型把历史信息编码成潜变量 z
2. 扩散策略以 z 为条件：p_θ(轨迹 | 场景, z)
3. GRPO 在世界模型的 rollout 中做优化

这样做的好处是：世界模型提供的潜变量 z 包含了"未来会怎样"的信息，扩散策略可以根据这个信息调整当前的轨迹。

比如在十字路口，世界模型预测"右侧车辆 2 秒后会加速"，策略就可以提前减速避让——即使用 SFT 数据里没有这种场景。

DriveVLA-W0 的 NavSim 榜单结果证明了这套方案的有效性：在 closed-loop 评测中超过了所有纯 SFT 方法和简单的 RL 方法。

但训练复杂度也相应增加了：需要联合训练世界模型编码器、扩散策略去噪网络、以及 reward model。

优点：

• 理论上上限最高
• 可以做离线训练（不用真车上路）
• 可以做多步规划（想象中推演未来）
• 可以处理 long-horizon 任务

缺点：

• 训练复杂度极高（三个模型联合训）
• 世界模型的精度是瓶颈——如果世界模型预测不准，策略学到的就是错的
• 分布外问题严重——策略探索到世界模型没见过的区域，世界模型开始"幻想"

个人评价：这是"终极方案"，但现阶段还不够成熟。我用 DriveVLA-W0 的代码试过，训一个世界模型需要的数据量和算力是前面三种范式的 5-10 倍。而且世界模型的"幻觉"问题在自动驾驶中非常致命——想象出一条不存在的障碍物，然后策略绕开它走，学到的完全是无用行为。

4. Flow Matching + Diffusion + RL：范式三深度拆解（重点）

本章是为我们后续用 Flow-GRPO / DiffGRPO 范式做轨迹生成和轨迹优化的核心参考。 前面第 3 章提到了范式三的基本概念，但不够深入。这里把 Flow Matching、扩散模型、GRPO 三者的结合方式彻底讲清楚，并对比 Flow-GRPO 和 DiffGRPO 两条技术路线的差异。

4.1 从两个问题出发

在深入之前，先想清楚两个核心问题：

问题 1：为什么需要 Flow 或 Diffusion？

轨迹规划的输出是连续的高维向量（一系列 waypoint，每维是坐标/速度/朝向）。我们想要的是一个概率分布 p_θ(轨迹 | 场景)，而不是确定性函数。Flow 和 Diffusion 天然是分布生成器。

问题 2：为什么需要 GRPO？

SFT 只能"模仿专家"，不能"超越专家"。GRPO 让模型在"自己生成的轨迹"上通过奖励信号自我改进。而且 GRPO 不需要 Critic 网络，省了 40-50% 的显存——这对大模型训练至关重要。

Flow/Diffusion 负责"表示分布"，GRPO 负责"优化分布"。 两者结合，形成完整的"生成→评估→改进"闭环。

4.2 基础回顾：Flow Matching vs Diffusion

虽然它们同属于"生成式模型"家族，但 Flow Matching 和扩散模型在数学框架上有本质差异，这些差异直接影响了后续 RL 集成的难度和方式。

扩散模型（DDPM）

扩散模型的核心思想是离散时间马尔可夫链：

前向过程（加噪）：

从干净轨迹 x₀ 逐步加噪，T 步后变成纯噪声。

反向过程（去噪）：

从噪声开始，每步预测噪声 ε_θ，逐步还原出轨迹。

关键特性：

• 离散时间步（T=50-1000 步）
• 每步是高斯条件分布
• log-prob 通过 ELBO 下界近似
• 训练损失 = E[ ||ε - ε_θ(x_t, t)||² ]

Flow Matching

Flow Matching 的核心思想是连续时间归一化流：

概率路径：

从数据分布 x₀（t=0）到标准噪声 x₁（t=1）的线性插值路径。

速度场（Vector Field）：

模型 v_θ 学习预测"在位置 x_t、时间 t"时的速度方向。

关键特性：

• 连续时间（t ∈ [0,1]）
• 确定性 ODE 路径（可逆）
• log-prob 通过 Neural ODE / Girsanov 定理计算
• 训练损失 = E[ ||v - v_θ(x_t, t)||² ]

核心差异汇总

在轨迹规划中的直观理解：

扩散模型就像"一步一说"地擦除噪声：先看清大概方向，再逐渐聚焦到精确轨迹。每一步都在小幅修正。

Flow Matching 就像"顺着水流走"：从噪声出发，沿着速度场指引的方向匀速前进，时间从 0 到 1 正好生成完整轨迹。

两者在纯生成任务上效果相近，但在 RL 集成上有显著差异——因为 log-prob 的"可计算性"和"精度"直接影响策略梯度的质量。

4.3 Flow-GRPO：Flow Matching + GRPO 的完整方案

Flow-GRPO（字节跳动，NeurIPS 2025）是目前最完整的"Flow Matching + GRPO"方案。它的设计解决了三个核心问题：

问题 1：确定性 ODE 没有 log-prob → 怎么算策略梯度？

解法：ODE → SDE 转换

标准 Flow 的生成过程是确定性 ODE：

这种确定性路径没有概率解释，无法计算 log p_θ(τ)。

Flow-GRPO 在 ODE 中加入微小噪声，将其转换为 SDE：

其中 σ(t) 是一个很小的噪声幅度（通常 σ=0.01），w 是维纳过程。

转换后，生成路径从"一条确定性路径"变成"一束随机路径"。这束路径的概率测度通过 Girsanov 定理 可以精确计算：

这个公式就是 Flow-GRPO 计算 log-prob 的基础。

关键权衡：σ(t) 越大 → log-prob 越精确 → 但生成质量下降越多。实践中 σ(t) 通常设得很小（0.01-0.05），保证生成质量几乎不变的同时让 log-prob 可算。

问题 2：T 步去噪的计算图太大 → GPU 内存不够？

解法：Denoising Reduction (DR)

完整去噪链有 T=50-100 步，每一步都需要存储中间变量用于反向传播。T 步的计算图在 GPU 上根本放不下。

Flow-GRPO 的 DR 技巧：

• 不从完整的去噪链算 log-prob
• 而是随机采样 K 个时间步（K=1~4）
• 只在这 K 步上计算条件 log-prob

近似公式：

这个近似在 K≥1 时已经非常准确。K=1 时（只采样一步）都能收敛，K=4 时几乎和完整计算无异。

DR 的效果：训练速度提升 10-20 倍，GPU 内存降低 5-10 倍。

问题 3：GRPO 不依赖 Critic，但如何在扩散/Flow 上应用？

解法：组内采样 + 相对优势

GRPO 的核心是"组内相对奖励"：

1. 对同一个场景/条件 c，从 SDE 采样 G 条轨迹（G=4~8）
2. 用奖励函数 R 对每条轨迹打分
3. 组内优势：A_i = (R_i - mean(R_group)) / std(R_group)
4. 优势为正 → 提高该轨迹的生成概率
5. 优势为负 → 降低该轨迹的生成概率

为什么 GRPO 比 PPO 更适合 Flow/Diffusion？

对于 Flow/Diffusion 这类大模型（几百 M 到几 B 参数），省掉一个同样规模的 Critic 意味着训练成本直接减半。这也是 Flow-GRPO、DiffGRPO 全部选择 GRPO 的根本原因。

4.4 Flow-GRPO 训练循环完整拆解

Step 1：ODE → SDE 转换

• 标准 Flow 是确定性 ODE：dx = v_θ(x, t) dt
• 加入少量噪声变成 SDE：dx = v_θ(x, t) dt + σ(t) dw
• σ(t) 通常设为 0.01-0.05，保证生成质量几乎不变
• SDE 的随机性让 log-prob 变得可通过 Girsanov 定理计算

Step 2：组内采样（G=4~8 条轨迹）

• 对同一个场景条件 c，从 SDE 采样 G 条轨迹
• 每条轨迹通过奖励函数 R 打分
• 组内奖励的差异反映了模型在当前策略下的行为多样性

Step 3：GRPO 组内优势计算

• 计算组内均值 μ_R 和标准差 σ_R
• 优势 A_i = (R_i - μ_R) / σ_R
• 不需要 Critic 网络做价值估计——省 40-50% 显存
• 优势是相对的：好轨迹被鼓励，差轨迹被抑制

Step 4：Denoising Reduction

• 完整去噪链有 T=50-100 步
• DR 技巧：随机采样 K=1~4 个时间步
• 只在这几步上计算条件 log-prob
• 训练速度提升 10-20 倍，内存降低 5-10 倍

Step 5：GRPO 策略更新

• 用优势 A_i 加权更新去噪网络参数
• A_i > 0 → 提高该轨迹的生成概率
• A_i < 0 → 降低该轨迹的生成概率
• 用 KL 散度惩罚防止模型偏离预训练分布太远

4.5 DiffGRPO：扩散模型 + GRPO 的简化方案

DiffGRPO 是 2026 年出现的另一种方案。和 Flow-GRPO 的核心区别在于：它不对生成过程做 SDE 转换，而是直接用扩散模型的训练损失来近似策略梯度。

DiffGRPO 的简化逻辑

Flow-GRPO 需要做 ODE→SDE 转换，因为 Flow 的确定性路径没有概率解释。但扩散模型的反向过程天生就是随机的——每一步去噪 p_θ(x_{t-1} | x_t) = N(μ_θ, σ²I) 本身就是高斯分布。

这意味着扩散模型的 log-prob 可以直接写出来：

DiffGRPO 的核心观察：扩散模型的训练损失 L_simple = E[||ε - ε_θ||²] 和 log-prob 在数学上是等价的（只差一个常数因子）。

所以 DiffGRPO 的策略梯度可以直接写为：

不需要 SDE 转换，不需要 Girsanov 定理，不需要额外噪声。几行代码就能实现。

实现差异对比

实践中的选择建议

选 Flow-GRPO 的场景：

• 你希望理论更完备（log-prob 更精确）
• 你已经有了 Flow Matching 的代码基础设施
• 你愿意接受 SDE 转换的复杂度
• 你的轨迹需要连续时间建模（如非等间距 waypoint）

选 DiffGRPO 的场景：

• 你希望快速验证效果（实现成本低）
• 你已经有现成的扩散轨迹模型
• 你的资源有限，不想做复杂的 SDE 调试
• 你的轨迹是等间距 waypoint（扩散模型的离散时间步和轨迹的离散 waypoint 天然对齐）

我的建议：如果你是从零开始搭建，优先尝试 DiffGRPO——它更简单、更稳定、更容易出结果。如果 DiffGRPO 已经达到了性能瓶颈，再升级到 Flow-GRPO 追求更高的上限。

4.6 具体实现：Flow-GRPO 训练的核心代码逻辑

下面给出一个简化但完整的 PyTorch 伪代码，展示 Flow-GRPO 训练循环的核心逻辑。

def flow_grpo_train_step(model, scenes, reward_fn, group_size=8, K=2):
    """
    Flow-GRPO 单步训练
    - model: Flow Matching 模型 v_θ
    - scenes: 一批场景条件 (多视图图像 + 自车状态)
    - reward_fn: 奖励函数 R(τ)
    - group_size: GRPO 组大小 G
    - K: Denoising Reduction 采样步数
    """
    total_loss = 0
    
    for scene in scenes:
        # === Step 1: 组内采样 G 条轨迹 ===
        trajectories = []
        rewards = []
        
        for _ in range(group_size):
            # SDE 采样：dx = v_θ(x,t)dt + σ(t)dw
            traj = sde_sample(model, scene, noise_scale=0.01)
            traj = traj.detach()  # 停止梯度，只算奖励
            trajectories.append(traj)
            
            # 计算奖励
            r = reward_fn(traj, scene)
            rewards.append(r)
        
        # === Step 2: GRPO 组内优势 ===
        rewards_tensor = torch.tensor(rewards)
        mu_r = rewards_tensor.mean()
        sigma_r = rewards_tensor.std() + 1e-8
        advantages = (rewards_tensor - mu_r) / sigma_r
        
        # === Step 3: Denoising Reduction 计算 log-prob ===
        for i, traj in enumerate(trajectories):
            # 随机采样 K 个时间步
            t_samples = random.sample(range(T), K)
            
            log_prob = 0
            for t in t_samples:
                # 在 SDE 路径上取点 x_t
                x_t = get_sde_path_point(traj, t)
                
                # 模型预测速度
                v_pred = model(x_t, t, scene)
                
                # Girsanov log-prob 近似
                log_prob_t = -0.5 * ||v_pred||² / sigma² * dt
                log_prob += log_prob_t
            
            # DR 缩放
            log_prob = log_prob * (T / K)
            
            # === Step 4: GRPO 策略更新 ===
            policy_loss = -advantages[i] * log_prob
            
            # KL 散度惩罚（防止偏离初始化太远）
            with torch.no_grad():
                ref_log_prob = reference_model(x_t, t, scene)
            kl_loss = (log_prob - ref_log_prob).mean()
            
            loss = policy_loss + beta * kl_loss
            total_loss += loss
    
    # 反向传播更新模型
    total_loss.backward()
    optimizer.step()
    return total_loss.item()

关键实现细节：

1. sde_sample：在 Flow ODE 求解器每一步加入 N(0, σ²dt) 的噪声
2. sigma 的取值：σ=0.01 是常用起点，太小则 log-prob 计算不稳定，太大则生成质量下降
3. reward_fn 的设计：推荐 2-3 个核心指标（碰撞、效率、舒适度），不要超过 5 个
4. beta（KL 惩罚系数）：控制模型更新幅度，常用范围 0.01-0.1

4.7 轨迹生成与优化的具体流程

结合我们实际要做的轨迹生成和优化任务，我把 Flow-GRPO / DiffGRPO 的完整工作流程梳理如下：

阶段 1：SFT 预训练（初始化）

• 数据：nuScenes / NAVSIM 专家轨迹
• 目标：训练 Flow/Diffusion 模型学会"合理轨迹长什么样"
• 损失：Flow 用 L = E[ ||v - v_θ(x_t, t)||² ]，Diffusion 用 L = E[ ||ε - ε_θ(x_t, t)||² ]
• 结果：模型可以生成多样化的合理轨迹

这个阶段不涉及任何 RL。目标是让模型有一个好的初始化——在"合理的轨迹空间"内采样。

阶段 2：奖励函数设计

奖励函数是 RL 成功的关键。对于轨迹规划，我建议的奖励函数结构：

公式：R(τ) = w_safe · R_safe + w_eff · R_eff + w_comfort · R_comfort + w_rule · R_rule

• R_safe = -碰撞惩罚（碰撞=0, 否则=1）
• R_eff = 前进距离 / 目标距离（鼓励到达）
• R_comfort = -jerk² 累积（平滑性惩罚）
• R_rule = 交通规则遵守（红灯停、车道保持等）

权重建议：

• w_safe = 10.0（安全是最底线，必须拉满）
• w_eff = 1.0（效率是目标）
• w_comfort = 0.5（舒适是加分项）
• w_rule = 2.0（规则遵守重要但优先级低于安全）

核心原则：把安全作为硬性约束（碰撞直接判负），而不是加权项。这样模型不会在安全上做权衡。

阶段 3：GRPO 强化学习

• 每轮迭代：
  1. 从当前模型采样 G 条轨迹（SDE 或扩散采样）
  2. 每条轨迹用 R(τ) 打分
  3. 组内优势计算（相对奖励）
  4. 用优势加权更新模型参数
  5. KL 惩罚防止训飞
• 重复 N 轮，直到奖励收敛或达到预期效果

收敛判断：

• 奖励均值不再增长（或增长小于 1%）
• 组内奖励方差缩小（所有采样的轨迹都是好轨迹）
• 人工检查生成的轨迹：变好了还是变奇怪了？

阶段 4：评测与部署

闭环评测（如 NAVSIM）：

• 碰撞率 ↓（核心指标）
• 驾驶得分 ↑
• 舒适性指标（jerk、加速度变化）

开环评测（如 nuScenes）：

• L2 位移误差
• 碰撞率

部署前的安全检查：

• 模型是否学会了 reward hacking？
• 极端场景（cut-in、行人突现）表现如何？
• 和规则安全层的冲突情况？

4.8 常见陷阱与实战经验

陷阱 1：策略梯度 + 扩散训练 = 梯度消失

扩散模型的训练损失 L_simple = E[||ε - ε_θ||²] 在数值上很小（通常 0.01-0.1 量级），但策略梯度的幅度可能更小。两者叠加后，策略梯度的信号容易被噪声淹没。

解法：

• 对策略梯度做梯度裁剪（gradient clipping, max_norm=1.0）
• 策略梯度的学习率设为 SFT 阶段的 1/10 到 1/100
• 使用 AdamW 优化器（不是 Adam）

陷阱 2：奖励函数设计不当 → reward hacking

这是 RL 中最常见的问题。一个真实的例子：

奖励函数：R = 前进距离 - 碰撞惩罚 × 10

模型学到：以 60km/h 的速度直行，即使前方 20 米有静止车辆也不减速——因为"减速会减少前进距离"，而"碰撞还没发生（在 3 秒后的未来），不扣分"。

解法：

• 加入碰撞提前预警：如果与前方障碍物的 TTC（碰撞时间）< 3s，就扣分
• 把终点到达作为硬约束（没到达=直接判负）
• 使用模仿学习奖励（生成的轨迹和专家轨迹的相似度）作为辅助信号

陷阱 3：GRPO 组大小的选择

G（组大小）是 GRPO 中最重要的超参数：

我推荐 G=4 起步。如果训练不稳定，增大到 G=8。一般来说，G=4 已经足够给出稳定的优势估计。

陷阱 4：预训练模型被"训飞"

SFT 预训练的 Flow/Diffusion 模型有一个良好的初始分布。GRPO 更新后，模型可能逐渐偏离这个分布，生成"奖励高分但不合理"的轨迹。

解法：

• KL 惩罚项（Flow-GRPO 标准做法）：L = L_policy + β · KL(π_θ || π_ref)
• β 通常取 0.01-0.1
• 如果 KL 散度持续增大 > 10，说明模型偏离太远了，需要减小学习率或增大 β
• 定期测试模型在原始 SFT 数据上的 loss——如果 loss 显著增大，说明模型在"遗忘"基础能力

4.9 Flow-GRPO vs DiffGRPO 的选择决策树

Q1: 你是否有现成的扩散轨迹模型代码？

• 是 → 优先选 DiffGRPO（几行代码改动即可实现）
• 否 → 进入 Q2

Q2: 你是否需要精确的 log-prob？

• 是 → Flow-GRPO（Girsanov 定理更精确）
• 否 → 进入 Q3

Q3: 你的轨迹是否等间距 waypoint？

• 是 → 两者都可，推荐 DiffGRPO（实现更简单）
• 否 → Flow-GRPO（连续时间建模更自然）

Q4: 你的计算资源？

• 有限（8 卡以内）→ DiffGRPO（不需要 SDE 调参）
• 充裕（32 卡以上）→ Flow-GRPO（理论上限更高）

我的最终建议：

1. 第一步：用 DiffGRPO 快速验证"RL 是否对轨迹生成有效"
2. 第二步：效果确认后切换到 Flow-GRPO，追求更好的性能
3. 长期：两条路线都保持关注。DiffGRPO 的方向是"更稳定的近似"，Flow-GRPO 的方向是"更精确的理论"，两者都在快速演进中。

对于我们的项目：我建议 从 DiffGRPO 开始，原因是：

• 代码改动量最小，可以快速验证 RL pipeline
• 扩散模型在轨迹生成上的表现已经过充分验证（Diffusion Planner、DiffusionDrive 等）
• 等 DiffGRPO 效果确认后，再决定是否需要升级到 Flow-GRPO 追求上限

4.2 关于"训飞"的特别讨论

“训飞”（Training Divergence，训练发散/模型崩溃）是 RL 在自动驾驶中最让人头疼的问题。我观察到：

• 范式一永远不会训飞——因为模型权重根本没变
• 范式二几乎不会训飞——因为每次都是 SFT，而 SFT 的目标是"拟合分布"，不是"最大化奖励"
• 范式三容易训飞——策略梯度是"向着奖励最大的方向走"，如果奖励设计有缺陷，模型会钻空子
• 范式四的训飞风险来自世界模型——不是策略本身训飞，而是世界模型给策略提供了虚假的反馈

我的建议：如果你刚入门，从范式一开始；如果你的项目需要快速落地的效果，从范式二开始；如果你在做研究且资源充裕，挑战范式三或范式四。

5. 核心挑战深入分析

5.1 Log-Prob 的三个层次

我前面多次提到 log-prob 的问题。现在系统地梳理一下：

第一层：不需要 log-prob（范式一、二）

• 奖励引导：只需要 cost 的梯度，不求 log-prob
• 拒绝采样：只需要采样能力，不求 log-prob
• 理由：它们的下个方法是"筛选"而不是"优化"

第二层：需要近似 log-prob（范式三的大多数）

• Flow-GRPO：通过 SDE 转换近似 log-prob
• Diffusion Policy Gradient：通过 ELBO 下界近似 log-prob
• 理由：精确计算实在太难，近似够用

第三层：需要精确 log-prob（从理论角度）

• 目前没有实用方法能做到
• 但是像 RLHF 中对语言模型做的 PPO，之所以这么成功，就是因为语言模型的 log-prob 可以精确计算（因为每一步 token 的概率是精确的）
• 这可能是生成式轨迹的 RL 还没达到语言模型那样成熟度的根本原因

5.2 Reward Hacking：RL 最头疼的问题

Reward hacking 是 RL 最经典的失败模式：模型找到了一个"让奖励函数看起来很好"但实际上无用的策略。

在轨迹规划中，我至少见过这三种形态：

形态 1：碰撞奖励逃避

• 奖励函数说：“碰撞了要减分”
• 模型学会：生成"原地不动"的轨迹（因为不动就不会碰撞）
• 结果：安全分很高，但车不走
• 为什么？只有惩罚没有正奖励，模型选择"零风险"= 零收益
• 解决方法：加入"前进距离"正奖励

形态 2：舒适性奖励 gamming

• 奖励函数说：“jerk 小加分”
• 模型学会：生成无限平滑的直线
• 结果：舒适分很高，但不去目的地
• 为什么？舒适权重太大，压制了任务奖励
• 解决方法：多目标权重合理设计

形态 3：多目标权衡崩溃

• 同时优化安全和效率
• 模型学会：在边界上疯狂试探，找到奖励函数的漏洞
• 结果：每个目标看上去都不错，但组合起来是危险行为（如贴边高速行驶）
• 为什么？加权和引入权衡漏洞
• 解决方法：用约束优化替代加权和

如何缓解 reward hacking？

先看一个真实案例：我在一个项目中同时优化"安全"和"效率"，权重各 50%。模型学会的是——在十字路口以 80km/h 的速度贴着行人冲过去。碰撞检测说"没碰到（差 5cm）"，安全分满分；速度达标，效率分满分。但这是人敢开的吗？

从这件事我学到了几个原则：

1. 奖励函数越简单越好。不要超过 3-4 个目标的加权组合。更多目标意味着更多权衡漏洞。
2. 远离边界。如果你发现模型生成的轨迹总是"刚好不碰障碍物"或"刚好达到速度上限"，说明奖励函数在鼓励边界试探。
3. 使用约束优化。把一些指标作为硬约束（如"必须零碰撞"），而不是作为加权项。模型不会在安全上做权衡。
4. Ensemble reward。用多个不同的奖励函数投票，降低单一奖励被 hack 的风险。
5. 定期人工检查。不要只看聚合奖励分数，定期抽样看模型实际生成的轨迹长什么样。

5.3 探索与利用的困境

RL 的核心矛盾是：探索未知 vs 利用已知。

在生成式轨迹中，这个矛盾更尖锐：

• 如果探索太多（温度设得很高），采样的轨迹全是废的
• 如果探索太少（温度很低），采样到的都是相似的轨迹
• 找不到"刚好"的参数

这个问题在范式二中尤其明显——在 RFT 的最后一轮，当所有采样的轨迹都是高分时，RL 训练就停在了。

目前最有效的解决方法是 entropy bonus（在目标函数里加一项"保持多样性"），但这又引入了另一个超参数…

5.4 收敛行为对比

不同范式的收敛行为差异很大，了解这些差异可以帮助你判断训练是否正常。

SFT（灰色虚线）：

• 一开始就接近训练数据平均水平
• 永远无法超过专家水平线
• 横轴不适用（SFT 是一次性训练，不是迭代优化）

范式一：推理时引导（蓝色）

• 不训练模型，一步到位
• 效果上限受预训练模型限制
• 横轴是推理计算量，不是训练步数

范式二：RFT（绿色阶梯线）

• 每轮迭代有跳跃式提升
• 阶梯平台期 = 模型在"消化"新数据
• 3-5 轮后开始饱和，曲线变平
• 突破方式：增加采样 K 值 or 转入范式三

范式三：策略梯度（紫色波动线）

• 初期波动最大（最容易训飞）
• 但只要奖励函数稳定，长期趋势向上
• 有持续增长潜力
• 如果奖励分数不增长反而下降 → 检查 reward hacking 或训飞

如何判断训练是否健康？

1. 奖励均值在上升（不是必须单调，但长期趋势向上）
2. 奖励方差在缩小（好的轨迹越来越多，差的越来越少）
3. 生成轨迹的多样性没有消失（如果有 entropy bonus，观察 entropy 值）
4. 人工检查部分高分段和低分段轨迹，确认奖励函数没有 bug

6. 个人思考与未来方向

6.1 我的几个判断

判断一：范式二是当前的性价比之王

对于大多数团队，实现难度、效果、稳定性综合来看，范式二（RFT）是当前的最佳选择。这也是为什么 AutoVLA 选择这个方案——简单、可靠、有效。它的信号噪声比最高。

判断二：范式三是未来，但短期内不会取代范式二

策略梯度方法（Flow-GRPO 等）在理论上更优美、上限更高。但目前的工程成熟度还不够。我预计 1-2 年内会出现更成熟的 pipeline，让范式三成为主流。

判断三：世界模型需要「炼丹」级别的投入

范式四要做对，需要有极致精度的世界模型。而训世界模型本身就是自动驾驶中公认最难的问题之一。除非团队有世界模型方面的长期积累，否则不建议作为第一个尝试的方向。

6.2 一条技术路线建议

如果让我给一个团队制定路线图，我会建议：

Phase 1 (1-2 月)：范式一

• 已有扩散/Flow 轨迹模型加上推理时引导，快速看效果

Phase 2 (2-4 月)：范式二

• 实现 RFT pipeline，迭代 3-5 轮，效果显著提升

Phase 3 (6-12 月)：范式三

• 尝试 Flow-GRPO，解决 log-prob 估算问题
• 研究奖励函数的正确设计，追求超越 SFT 的质变

Phase 4 (长期)：范式四

• 世界模型预研，等范式三成熟后再接轨

6.3 如何选择适合你的范式？

不同团队的情况不同，适合的范式也不同。

如果你属于以下情况，从范式一开始：

• 刚接触 RL，团队没有 RL 经验
• 模型已经部署，想快速看到 RL 收益
• 资源有限（没有 GPU 集群做训练）

如果你属于以下情况，从范式二开始：

• 有 SFT 经验，想尝试 RL
• 需要稳定可靠的结果
• 有标注/奖励函数设计能力

如果你属于以下情况，从范式三开始：

• RL 经验丰富，团队有 RL 研究员
• 有大量 GPU 资源（至少 8 卡起步）
• 追求上限，想突破 SFT 瓶颈
• 愿意接受训飞和调试的代价

如果你属于以下情况，再考虑范式四：

• 有世界模型的长期积累
• 几十万 GPU 小时的预算
• 追求终极方案

6.4 我觉得最重要的认知

最后想说一点个人感受：

RL 不是 SFT 的替代品，而是互补品。

SFT 教会模型"什么看起来合理"，RL 教会模型"什么实际上是好的"。两者缺一不可。

如果把 SFT 比作"学字帖"，RL 就是"真正写文章去投稿被审稿人骂"。没练过字帖的人写不出字，但只练字帖的人写不出好文章。

另外，不要迷信 RL。2025 年以来，很多论文喜欢把"RL"当作一个卖点，但实际上很多 RL 改进带来的提升主要来自更多的采样和筛选，而不是 RL 算法本身。我个人的经验是：

把采样数量翻倍，比你花一个月调 PPO 超参带来的提升大得多。

RL 不是银弹，但它是这个方向上最有潜力的工具。

7. 工程实现的一些建议

7.1 代码框架选择

对于生成式轨迹的 RL，PyTorch + custom 是最主流的选择。因为你需要：

• 自定义扩散/Flow 模型的训练循环
• 自定义奖励函数
• 自定义采样和筛选逻辑
• 高度灵活的实验控制

7.2 训练监控 checklist

RL 训练比 SFT 容易出各种问题。建议至少监控这些指标：

必监控：

• 奖励均值（每个 batch / 每个 epoch）
• 奖励方差（reward diversity）
• 策略熵 / 轨迹多样性
• KL 散度（新旧策略之间）
• clip 比例（PPO/GRPO 中被 clip 的样本占比）

建议监控：

• 最大/最小奖励（看是否有异常值）
• 轨迹长度（模型是否学会"偷懒"停在原地）
• 碰撞率等具体 safety 指标
• 生成轨迹的自车速度分布
• 奖励函数的各子项分解（看是否有某项异常增长）

训飞预警信号：

1. 奖励突然飙升但生成轨迹明显变差 → reward hacking
2. clip 比例持续 > 50% → 更新步长太大，需要调小 lr
3. 策略熵骤降 → 模式塌缩，模型丧失了多样性
4. 生成轨迹长度突然变短 → 模型学会了"偷懒"

7.3 算力预算参考

注意这些是"从零开始"的大概估计。如果你有预训练模型，范式二和范式三的时间可以减半以上。

8. 相关工作的对比表

9. 写在最后

这篇文章断断续续写了一个多星期，因为我发现这个方向的文献在快速增长，几乎每周都有新论文出现。就在我写这篇文章的过程中，又冒出了两篇用 GRPO 优化扩散策略的 pre-print…

如果这篇文章对你有帮助，欢迎 Star 和讨论。如果我有理解错误的地方，也欢迎指正——毕竟 RL + 生成式轨迹还是一个非常年轻的领域，大家都在学习。

我们正在见证自动驾驶规划范式的转变：从"学专家"到"在试错中超越专家"。

附录：常见问题 FAQ

Q1: RL + 扩散/Flow 在实车上跑过吗？

A: 目前大多数工作还在仿真环境中验证。Diffusion Planner 在 CARLA 上做了闭环测试，AutoVLA 在 NAVSIM 上验证，DriveVLA-W0 也在 NAVSIM 上做了闭环评测。实车部署是当前的最大 gap，但从仿真到实车的迁移正在加速。

Q2: 我需要先学会哪些技术才能做这个方向？

建议的学习路径：

1. 扩散模型 / Flow Matching 基础（至少能写训练推理代码）
2. PPO / GRPO 的原理（不需要写，但要知道公式）
3. PyTorch 的自定义训练循环（自己写过 train loop）
4. 自动驾驶的规划基础知识（轨迹表示、坐标变换、碰撞检测）

Q3: 用预训练的文生图扩散模型能做轨迹规划吗？

理论上可以，但效果不好。文生图模型的输出空间是 RGB 像素，轨迹规划的输出是连续坐标。直接迁移需要大量调参。更实际的做法是从零训练一个轨迹扩散/Flow 模型，或者用 Bagel 这种已经预训练好的轨迹生成模型做初始化。

Q4: 奖励函数需要多少人工设计？

取决于范式。范式一需要可微的 cost 函数（可能是手工设计的碰撞距离等），范式二需要规则奖励（规则相对容易设计），范式三需要更复杂的奖励函数（因为模型会尝试 hack）。总体来说，奖励函数的设计是这个方向最需要人类直觉的部分——好的奖励函数比好的算法重要得多。

Q5: RFT 和策略梯度能一起用吗？

当然可以。事实上这是一个非常有效的组合：

1. 先用 RFT 做 3-5 轮粗调（快速提升基础质量）
2. 再用 Flow-GRPO 做精调（追求上限） RFT 给 GRPO 提供了一个好的初始化，GRPO 突破了 RFT 的限制。两者互补，不互斥。

Q6: 生成式轨迹的 RL 和 LLM 的 RLHF 有什么异同？

相同点是都用 PPO/GRPO 做策略优化。不同点是轨迹规划的 log-prob 更难算、探索更危险。

Q7: 我应该从哪篇论文的代码开始看？

按难度排序：

1. Diffusion Planner（最简单，只有推理时引导）
2. AutoVLA（RFT 的完整实现）
3. Flow-GRPO（最完整的策略梯度实现，代码开源）
4. DriveVLA-W0（世界模型 + 扩散策略，最复杂）

10. 参考文献

1. Diffusion Planner (CoRL 2023) - arXiv:2305.08705
2. CTG++ (ICRA 2024) - arXiv:2402.05248
3. AutoVLA (NeurIPS 2025) - arXiv:2505.08701
4. Flow-GRPO (NeurIPS 2025) - arXiv:2505.05470
5. DPO for Diffusion (NeurIPS 2024) - arXiv:2311.12962
6. Diffusion Policy Gradient (arXiv 2024) - arXiv:2403.06326
7. DriveVLA-W0 (CVPR 2025) - arXiv:2503.13576
8. DreamerV3 (ICLR 2023) - arXiv:2301.04104
9. PPO (2017) - Schulman et al.
10. GRPO (DeepSeekMath, 2024) - arXiv:2402.03300