Flow Matching 与一致性模型：生成范式的新统一

扩散模型的概率流 ODE 将生成过程表述为从噪声到数据的确定性映射。但 ODE 路径并非唯一——不同的漂移和扩散系数定义了不同的路径。一个自然的问题随之而来：是否存在一条"最优"路径？Flow Matching 给出了肯定的回答：最优传输路径是直线。一致性模型则进一步追问：如果路径已经是最优的，能否一步走完？

一、Flow Matching 的动机

1.1 扩散模型 ODE 路径的弯曲问题

概率流 ODE 的采样路径一般是弯曲的。以 VP-SDE 对应的概率流 ODE 为例，从噪声 $x_T$ 到数据 $x_0$ 的轨迹是弯曲的——模型需要先在一个方向上移动，然后转向另一个方向。这意味着：

需要 many 步 ODE 求解才能精确追踪弯曲路径
数值误差在弯曲处累积，导致采样质量下降
弯曲路径的本质是前向过程与反向过程之间的"耦合不匹配"——前向过程加噪的方式决定了反向路径的形态

更具体地，VP-SDE 的前向过程是 $x_t = \sqrt{\bar{\alpha}_t}x_0 + \sqrt{1-\bar{\alpha}_t}\varepsilon$ ，这定义了一种特定的噪声-数据插值方式。当 $\bar{\alpha}_t$ 按余弦调度衰减时，插值路径是非线性的——数据信号和噪声的比例变化不均匀，导致反向路径弯曲。

1.2 最优传输：直线的启示

最优传输理论（Optimal Transport）提供了一个基本的优化准则：在所有将源分布 $\pi_0$ 映射到目标分布 $\pi_1$ 的传输方案中，最优传输方案使传输成本（通常为二次成本 $\|x_1 - x_0\|^2$ ）最小。

对于二次成本，最优传输映射具有一个优美的性质：轨迹是直线。 即从 $x_0$ 到 $x_1$ 的路径为：

x_t = (1-t)x_0 + t x_1, \quad t \in [0, 1]

其中 $(x_0, x_1)$ 是按最优传输方案配对的样本对。直线路径的斜率恒定：

\frac{dx_t}{dt} = x_1 - x_0 = v_{\text{OT}}

速度场是常数——但这是条件速度，即给定配对 $(x_0, x_1)$ 时的速度。条件路径确实是直线，一步 Euler 即可精确求解。然而，边缘路径是所有条件路径的叠加，实际速度场 $v_t(x) = \mathbb{E}_{p(x_1|x_t)}[x_1 - x_0]$ 并非常数——不同 $x_t$ 处的后验 $p(x_1|x_t)$ 不同，导致边缘轨迹弯曲。因此，从采样的角度看，即使条件路径是直线，仍需多步 ODE 求解来追踪边缘路径，或通过 Reflow 逐步将边缘路径拉直。

当然，这是在已知最优配对 $(x_0, x_1)$ 的前提下。在训练时我们并不知道最优配对——这是 Flow Matching 需要解决的核心问题。

二、条件流匹配的训练目标

2.1 Flow Matching 目标

Flow Matching 的训练目标是学习一个向量场 $v_t(x)$ ，使得 ODE $dx = v_t(x)\, dt$ 的边缘分布 $p_t(x)$ 匹配目标分布的演化路径。直接优化这个目标是不可行的，因为 $p_t(x)$ 未知。

Lipman et al. (2023) 的核心发现是：条件向量场的期望等于无条件向量场。 具体地，定义条件向量场 $u_t(x|x_1)$ ——给定目标样本 $x_1$ 时从噪声 $x_0$ 到 $x_1$ 的向量场，则无条件向量场为：

v_t(x) = \int u_t(x|x_1)\, \frac{p_t(x|x_1)}{p_t(x)}\, p(x_1)\, dx_1 = \mathbb{E}_{p(x_1|x_t)}\left[u_t(x_t|x_1)\right]

因此，训练 Flow Matching 只需要最小化：

\mathcal{L}_{\text{CFM}} = \mathbb{E}_{t, q(x_0), p(x_1)}\left[\|v_\theta(x_t, t) - u_t(x_t|x_1)\|^2\right]

其中 $x_t$ 是沿条件路径从 $x_0$ 到 $x_1$ 的插值， $u_t$ 是条件目标速度。

2.2 条件流匹配等价于无条件流匹配

一个精妙的理论结果表明：条件流匹配（CFM）的梯度与无条件流匹配（FM）的梯度完全相同（Lipman et al. 2023, 定理 2）：

\nabla_\theta \mathcal{L}_{\text{CFM}} = \nabla_\theta \mathcal{L}_{\text{FM}}

这意味着我们不需要知道真实的边缘分布 $p_t(x)$ 或无条件向量场 $v_t(x)$ ——只需在条件路径上训练，等价于在无条件路径上训练。这是一个巨大的计算简化，因为条件路径是解析已知的（例如直线插值），而无条件路径涉及复杂的高维积分。

2.3 替代推导路径：特征线法

苏剑林在《构建 ODE 的一般步骤（下）》中提供了从第一性原理推导条件流匹配的替代路径。这一推导不从向量场的条件-无条件等价性出发，而是从连续性方程入手：

\partial_t p_t(x) + \nabla_x \cdot (p_t(x)\, v_t(x)) = 0

连续性方程是概率守恒的数学表述——概率密度沿速度场的演化必须满足质量守恒。给定初值条件 $p_0 = \pi_0$ （噪声分布）和终值条件 $p_1 = \pi_1$ （数据分布），我们需要找到一个速度场 $v_t$ 使得连续性方程同时满足两个边界条件。

特征线法的核心思想是：将偏微分方程转化为沿特征线的常微分方程。对于连续性方程，特征线就是粒子在速度场 $v_t$ 下的运动轨迹 $x(t)$ 。利用格林函数可以构造满足初值条件的解，然后通过调整速度场使终值条件也得到满足。这一过程自然导出了条件向量场的构造——给定目标 $x_1$ ，特征线从 $x_0$ 到 $x_1$ 的最短路径就是直线。

这一替代推导的独特优势在于：它允许使用任意简单分布（不限于高斯）作为先验 $\pi_0$ ，因为连续性方程对先验分布的形式没有限制。同时，从偏微分方程出发的视角提供了更深的物理直觉——Flow Matching 相当于在求解一个传输问题，而非仅仅拟合一个向量场。最终结果与 Lipman et al. 的条件流匹配形式上一致，但推导路径的不同为理解这一框架提供了互补的视角。

2.4 OT-CFM：最优传输条件流匹配

当条件路径取为最优传输路径（直线插值 $x_t = (1-t)x_0 + tx_1$ ）时，条件速度为常数：

u_t(x_t|x_1) = x_1 - x_0

训练目标简化为：

\mathcal{L}_{\text{OT-CFM}} = \mathbb{E}_{t, q(x_0), p(x_1)}\left[\|v_\theta(x_t, t) - (x_1 - x_0)\|^2\right]

其中 $x_t = (1-t)x_0 + tx_1$ ， $x_0 \sim \mathcal{N}(0, I)$ ， $x_1 \sim p_{\text{data}}$ 。

注意：这里 $x_0$ 和 $x_1$ 是独立采样的——配对 $(x_0, x_1)$ 不是最优传输配对。独立配对产生的路径不是严格的最优传输路径，但 OT-CFM 的理论保证表明，即使使用独立配对训练，学习到的向量场也会在训练过程中隐式地优化配对，使路径趋于直线。

更严格的做法是使用 Mini-batch OT：在每个 mini-batch 内求解离散最优传输问题（如 Sinkhorn 算法），找到 batch 内 $x_0$ 和 $x_1$ 之间的最优配对，然后用这些配对计算训练目标。这进一步加速了路径的直线化。

DDPM 路径 vs Flow Matching 路径

Loading visualization...

左侧：DDPM 的弯曲采样路径；右侧：Flow Matching 的直线采样路径。同一噪声→数据映射。

const W = container.clientWidth;
const H = container.clientHeight;
const margin = {top: 25, right: 20, bottom: 40, left: 50};
const iW = (W - margin.left - margin.right) / 2 - 15;
const iH = H - margin.top - margin.bottom;

svg.append("text").attr("x", margin.left + iW/2).attr("y", 14).attr("text-anchor","middle").attr("font-size","13px").attr("font-weight","600").attr("fill","#8b5cf6").text("DDPM 弯曲路径");
svg.append("text").attr("x", margin.left + iW + 30 + iW/2).attr("y", 14).attr("text-anchor","middle").attr("font-size","13px").attr("font-weight","600").attr("fill","#10b981").text("Flow Matching 直线路径");

// Data points (targets)
const dataPoints = [
  {x: 1.5, y: 1.2}, {x: -1.2, y: -0.8}, {x: 0.3, y: 1.8},
  {x: -1.8, y: 0.5}, {x: 1.0, y: -1.5}, {x: -0.5, y: 1.0}
];

const {xS: xSL, yS: ySL} = setupPanel(gL);
const {xS: xSR, yS: ySR} = setupPanel(gR);

// DDPM curved paths
function genDDPMPaths() {
  const paths = [];
  dataPoints.forEach(target => {
    // Start from noise
    const noise = {x: d3.randomNormal(0, 1)(), y: d3.randomNormal(0, 1)()};
    const path = [{t: 0, x: noise.x, y: noise.y}];
    const N = 100;
    for (let i = 1; i <= N; i++) {
      const t = i / N;
      // Curved interpolation (cosine-like schedule)
      const s = 0.5 * (1 - Math.cos(Math.PI * t));
      // Add curvature: initial deviation then correction
      const curve = Math.sin(Math.PI * t) * 0.8;
      const cx = noise.x * (1 - s) + target.x * s + curve * (target.y - noise.y) * 0.3;
      const cy = noise.y * (1 - s) + target.y * s - curve * (target.x - noise.x) * 0.3;
      path.push({t, x: cx, y: cy});
    }
    paths.push(path);
  });
  return paths;
}

// Flow Matching straight paths
function genFMPaths() {
  const paths = [];
  dataPoints.forEach(target => {
    const noise = {x: d3.randomNormal(0, 1)(), y: d3.randomNormal(0, 1)()};
    const path = [];
    const N = 100;
    for (let i = 0; i <= N; i++) {
      const t = i / N;
      const x = (1 - t) * noise.x + t * target.x;
      const y = (1 - t) * noise.y + t * target.y;
      path.push({t, x, y});
    }
    paths.push(path);
  });
  return paths;
}

const ddpmPaths = genDDPMPaths();
const fmPaths = genFMPaths();

// Draw data points
function drawTargets(g, xS, yS) {
  dataPoints.forEach(p => {
    g.append("circle").attr("cx", xS(1)).attr("cy", yS(p.y * 0.8 + p.x * 0.1))
      .attr("r", 5).attr("fill", "#10b981").attr("opacity", 0.7);
  });
}

// Animation
let animProgress = 0;
let playing = true;

const controls = d3.select(container).append("div")
  .attr("style","text-align:center; margin-top:8px; font-size:13px;");
const playBtn = controls.append("button").text("暂停")
  .attr("style","margin-right:12px; padding:2px 12px; cursor:pointer; border:1px solid #999; border-radius:3px;");
const slider = controls.append("input").attr("type","range").attr("min",0).attr("max",100).attr("value",0)
  .attr("style","width:200px;");

function render(p) {
  drawPaths(gL, ddpmPaths, xSL, ySL, "#8b5cf6", p);
  drawPaths(gR, fmPaths, xSR, ySR, "#10b981", p);
}

render(0);

playBtn.on("click", () => {
  playing = !playing;
  playBtn.text(playing ? "暂停" : "播放");
});
slider.on("input", e => {
  animProgress = +e.target.value / 100;
  render(animProgress);
});

function animate() {
  if (playing && animProgress < 1) {
    animProgress += 0.005;
    if (animProgress > 1) animProgress = 1;
    slider.property("value", animProgress * 100);
    render(animProgress);
  }
  requestAnimationFrame(animate);
}
animate();

三、OT-CFM 的深入分析

3.1 为什么直线路径更好？

直线路径的优势不仅仅是美学上的，而是有严格的理论保证。

更少的离散化误差。 ODE 求解器的局部截断误差与被积函数的高阶导数成正比。直线路径的速度场是常数（高阶导数为零），因此 Euler 方法的局部截断误差为零——一步求解就是精确解。弯曲路径的速度场高阶导数非零，截断误差随步长增大而快速增长。

更均匀的优化难度。 在弯曲路径上，不同时间段的学习难度不均匀——弯曲处需要更精细的模型容量来拟合快速变化的速度场。直线路径的速度场在所有时间段上变化平缓（甚至恒定），优化难度均匀分布。

更快的收敛。 Liu et al. (2023) 的 Rectified Flow 证明：在直线路径上训练的模型，其神经 ODE 的 Lipschitz 常数更小，意味着更少的 ODE 步数即可达到给定的传输精度。这直接转化为采样速度的提升。

3.2 Reflow：将弯曲路径拉直

即使初始训练使用了直线路径，如果 $x_0$ 和 $x_1$ 之间的配对不是最优的，学到的 ODE 路径仍然可能是弯曲的。Rectified Flow 提出了 reflow 操作来解决这个问题：

用已训练的模型生成配对 $(\varepsilon, \hat{x}_1)$ ，其中 $\varepsilon \sim \mathcal{N}(0, I)$ ， $\hat{x}_1$ 是模型从 $\varepsilon$ 采样得到的输出
用这些"已配对"的数据重新训练模型

每经过一轮 reflow，配对变得更优（因为模型在逐步改善噪声-数据映射），路径变得更直。理论上，经过无穷次 reflow 后，边缘路径趋于直线，此时一步 ODE 即可完成生成。但实践中有限次 reflow 只能让路径"更直"而非"完美直线"，仍需少量 ODE 步数。

Reflow 的数学基础是：训练后的模型 $v_\theta$ 诱导了一个从 $\pi_0$ 到 $\pi_1$ 的确定性映射 $T_\theta$ 。以 $T_\theta(\varepsilon)$ 替代 $x_1$ 重新训练，相当于在 $T_\theta$ 诱导的配对上优化——如果 $T_\theta$ 已经是好的映射，新的配对更接近最优传输配对。

四、一致性模型：将 ODE 路径蒸馏为单步映射

4.1 一致性约束

一致性模型（Song et al., 2023）的核心思想是：学习一个函数 $f_\theta(x, t)$ ，使得对于 ODE 路径上的任意两点 $(x_t, t)$ 和 $(x_{t'}, t')$ ，函数值相同：

f_\theta(x_t, t) = f_\theta(x_{t'}, t'), \quad \forall\, t, t' \in [0, T]

其中 $x_t$ 和 $x_{t'}$ 是同一条 ODE 轨迹上的两个点。特别地，当 $t' = 0$ 时：

f_\theta(x_t, t) = f_\theta(x_0, 0) = x_0

这意味着：给定 ODE 路径上任意一个噪声水平的样本 $x_t$ ，函数 $f_\theta$ 直接映射到原始数据 $x_0$ ——一步生成。

4.2 一致性函数的参数化

为了满足一致性约束， $f_\theta$ 不能是任意的神经网络。Song et al. 提出了一种巧妙的参数化：

f_\theta(x, t) = c_{\text{skip}}(t)\, x + c_{\text{out}}(t)\, F_\theta(c_{\text{in}}(t)\, x, c_{\text{emb}}(t))

其中 $F_\theta$ 是一个自由形式的神经网络， $c_{\text{skip}}$ 、 $c_{\text{out}}$ 、 $c_{\text{in}}$ 、 $c_{\text{emb}}$ 是时间相关的系数。一致性约束要求：

c_{\text{skip}}(0) = 1, \quad c_{\text{out}}(0) = 0

这保证了 $f_\theta(x_0, 0) = x_0$ ——当输入已经是干净数据时，函数是恒等映射。其他系数的设计使得训练稳定且高效。

4.3 一致性蒸馏

一致性蒸馏利用已训练的扩散模型（或 Flow Matching 模型）作为教师，将多步 ODE 蒸馏为单步映射。

训练过程如下：

采样数据 $x_0$ 和时间步 $t$
前向一步得到 $x_t$
从 $x_t$ 出发，用教师模型执行一步 ODE（从 $t$ 到 $t - \Delta t$ ），得到 $x_{t-\Delta t}$
计算一致性损失： $\|f_\theta(x_t, t) - f_{\theta^-}(x_{t-\Delta t}, t - \Delta t)\|^2$

其中 $\theta^-$ 是 $\theta$ 的指数移动平均（EMA）版本，用于稳定训练——这是一个类似 BYOL/EMA 的自监督学习技巧，防止模型坍缩。

直觉上，一致性蒸馏要求模型满足：对 ODE 轨迹上相邻两步的输出保持一致。 如果每一步都与下一步一致，那么沿整条轨迹传播下来，任意一步的输出都等于 $x_0$ 。

4.4 一致性训练

一致性训练（Consistency Training, CT）不需要预训练的教师模型，直接从数据中学习一致性函数。关键修改是将教师模型的一步 ODE 替换为解析的前向过程：

采样 $x_0$ 和时间步 $t$
前向加噪得到 $x_t = \sqrt{\bar{\alpha}_t}\, x_0 + \sqrt{1-\bar{\alpha}_t}\, \varepsilon$
取 $t' = t - \Delta t$ ，计算 $x_{t'} = \sqrt{\bar{\alpha}_{t'}}\, x_0 + \sqrt{1-\bar{\alpha}_{t'}}\, \varepsilon$ （使用同一个 $\varepsilon$ ）
一致性损失： $\|f_\theta(x_t, t) - f_{\theta^-}(x_{t'}, t')\|^2$

一致性训练的本质是：利用前向过程的解析性质，而非预训练模型，来提供"轨迹上相邻点"的监督信号。 这使得一致性模型可以从零开始训练，无需先训练一个扩散模型再蒸馏。

4.5 工业应用

一致性模型的思想已经催生了多个工业级应用，验证了少步生成在实际场景中的可行性：

SDXL Turbo（Sauer et al., 2023）采用对抗扩散蒸馏（Adversarial Diffusion Distillation, ADD）方法，将 Stable Diffusion XL 的采样步数从 50 步压缩到 1-4 步，实现了实时文生图。ADD 结合了对抗训练损失和蒸馏损失——对抗损失保证少步生成的感知质量，蒸馏损失保持与教师模型的分布一致性。

LCM-LoRA（Luo et al., 2023）将潜在一致性蒸馏（Latent Consistency Distillation）以 LoRA 适配器的形式应用于 Stable Diffusion，无需重新训练基础模型即可实现 2-8 步生成。LoRA 的低秩结构使得蒸馏后的权重可以叠加到任意 SD 模型上，大幅降低了部署成本。

这两个应用从不同角度体现了一致性思想的实用价值：SDXL Turbo 追求极致的速度-质量权衡，LCM-LoRA 则强调适配的灵活性。它们共同表明，将多步扩散过程蒸馏为少步映射是一个可行的工程路线。

一致性蒸馏

Loading visualization...

ODE 路径上的点逐步被蒸馏为单步映射。初始：多点→多步；终态：任意点直接映射到 x₀。

const W = container.clientWidth;
const H = container.clientHeight;
const margin = {top: 25, right: 20, bottom: 40, left: 50};
const iW = W - margin.left - margin.right;
const iH = H - margin.top - margin.bottom;

const svg = d3.select(container).append("svg").attr("width", W).attr("height", H);
const g = svg.append("g").attr("transform", `translate(${margin.left},${margin.top})`);

// Scales
const xS = d3.scaleLinear().domain([0, 1]).range([0, iW]);
const yS = d3.scaleLinear().domain([-3, 3]).range([iH, 0]);

// Axes
g.append("g").attr("transform",`translate(0,${iH})`).call(d3.axisBottom(xS).ticks(10).tickFormat(d => `t=${d.toFixed(1)}`));
g.append("g").call(d3.axisLeft(yS).ticks(6));
g.append("text").attr("x",iW/2).attr("y",iH+32).attr("text-anchor","middle").attr("fill","#666").attr("font-size","11px").text("时间 t（噪声水平 → 数据水平）");
g.append("text").attr("transform","rotate(-90)").attr("x",-iH/2).attr("y",-38).attr("text-anchor","middle").attr("fill","#666").attr("font-size","11px").text("x");

// Data point (target)
const x0_val = 1.5;

// Generate ODE path points
const nSteps = 8;
const pathPoints = [];
for (let i = 0; i <= nSteps; i++) {
  const t = i / nSteps;
  const x = (1 - t) * 0 + t * x0_val + Math.sin(Math.PI * t) * 0.8; // slightly curved path
  pathPoints.push({t, x});
}

// Distillation progress (0 = before, 1 = after)
let distillProgress = 0;

function render(p) {
  g.selectAll(".viz").remove();

// Draw ODE path (curved line)
  const line = d3.line().x(d => xS(d.t)).y(d => yS(d.x)).curve(d3.curveBasis);
  g.append("path").attr("class","viz").attr("d", line(pathPoints))
    .attr("fill","none").attr("stroke","#8b5cf6").attr("stroke-width",2).attr("opacity",0.4)
    .attr("stroke-dasharray","6,3");

// Draw path points
  pathPoints.forEach((pt, i) => {
    g.append("circle").attr("class","viz")
      .attr("cx", xS(pt.t)).attr("cy", yS(pt.x))
      .attr("r", 5).attr("fill","#8b5cf6").attr("opacity",0.3 + 0.4*(1-p));
  });

// Consistency mapping arrows (progressively becoming direct)
  // As distillation progresses, all points map directly to x0
  const arrowOpacity = Math.min(1, p * 2);

if (p > 0.1) {
    // Direct mapping arrows (consistency model output)
    pathPoints.forEach((pt, i) => {
      if (i === nSteps) return; // skip x0 itself
      const startX = xS(pt.t);
      const startY = yS(pt.x);
      // Interpolate between multi-step and single-step
      const multiStepX = xS(pathPoints[Math.min(i+1, nSteps)].t);
      const multiStepY = yS(pathPoints[Math.min(i+1, nSteps)].x);
      const directX = xS(1);
      const directY = yS(x0_val);
      // Blend: at p=0, arrows point to next step; at p=1, all point to x0
      const endX = (1-p) * multiStepX + p * directX;
      const endY = (1-p) * multiStepY + p * directY;

g.append("line").attr("class","viz")
        .attr("x1", startX).attr("y1", startY)
        .attr("x2", endX).attr("y2", endY)
        .attr("stroke", "#ef4444").attr("stroke-width", 1.5)
        .attr("opacity", arrowOpacity * (0.3 + 0.5 * (i / nSteps)))
        .attr("marker-end", "url(#arrowRed)");
    });
  }

// x0 marker (always visible)
  g.append("circle").attr("class","viz")
    .attr("cx", xS(1)).attr("cy", yS(x0_val))
    .attr("r", 7).attr("fill","#10b981").attr("opacity",0.8);
  g.append("text").attr("class","viz")
    .attr("x", xS(1) + 10).attr("y", yS(x0_val) + 4)
    .attr("fill","#10b981").attr("font-size","12px").attr("font-weight","600")
    .text("x₀");

// Noise point
  g.append("circle").attr("class","viz")
    .attr("cx", xS(0)).attr("cy", yS(pathPoints[0].x))
    .attr("r", 5).attr("fill","#6b7280").attr("opacity",0.6);
  g.append("text").attr("class","viz")
    .attr("x", xS(0) - 5).attr("y", yS(pathPoints[0].x) - 10)
    .attr("fill","#6b7280").attr("font-size","11px").text("ε");

// Phase label
  const phase = p < 0.3 ? "多步 ODE 求解" : p < 0.7 ? "一致性蒸馏中..." : "单步映射";
  g.append("text").attr("class","viz")
    .attr("x", iW/2).attr("y", 15).attr("text-anchor","middle")
    .attr("fill","#333").attr("font-size","13px").attr("font-weight","600")
    .text(phase);
}

render(0);

// Arrow marker
svg.append("defs").append("marker").attr("id","arrowRed")
  .attr("viewBox","0 0 10 10").attr("refX",8).attr("refY",5)
  .attr("markerWidth",5).attr("markerHeight",5).attr("orient","auto")
  .append("path").attr("d","M 0 0 L 10 5 L 0 10 z").attr("fill","#ef4444");

// Controls
const controls = d3.select(container).append("div")
  .attr("style","text-align:center; margin-top:8px; font-size:13px;");

controls.append("span").text("蒸馏进度: ");
const slider = controls.append("input").attr("type","range").attr("min",0).attr("max",100).attr("value",0)
  .attr("style","width:300px;");

slider.on("input", e => {
  distillProgress = +e.target.value / 100;
  render(distillProgress);
});

五、生成模型的统一视角

5.1 四种范式，一个 ODE

扩散模型、Flow Matching、一致性模型和 MeanFlow，从 ODE 的视角看，是同一条路径的四种不同利用方式：

扩散模型 定义了一条从数据到噪声的前向 SDE，然后学习反向 SDE（或等价的概率流 ODE）进行采样。路径的形态由前向过程的噪声调度决定，一般是弯曲的。

Flow Matching 重新定义了前向过程——不再是离散加噪，而是从噪声到数据的连续插值。最优传输插值使条件路径为直线，但边缘路径仍需多步 ODE 求解；通过 Reflow 可以逐步拉直边缘路径，减少所需步数。

一致性模型 不关心路径的形态，只关心路径的端点。它学习一个满足一致性约束的函数，使得 ODE 路径上任意一点都能直接映射到 $x_0$ 。这是对 ODE 路径的"端到端蒸馏"。

MeanFlow 保留了 ODE 的速度场形式，但将建模目标从瞬时速度切换为平均速度。平均速度天然适用于大步长场景，无需 Reflow 或蒸馏即可实现单步生成。

四者的关系可以表示为：

\text{扩散模型} \xrightarrow{\text{概率流 ODE}} \text{ODE 路径} \xrightarrow{\text{最优传输}} \text{Flow Matching} \xrightarrow[\text{端到端蒸馏}]{\text{平均速度}} \text{一致性模型 / MeanFlow}

5.2 采样效率的递进

四种范式的采样效率递进：

范式	采样步数	路径性质	训练复杂度
DDPM	1000	离散马尔可夫链	标准
DDIM	20-50	确定性 ODE	标准
Flow Matching	10-20	直线 ODE	中等
一致性蒸馏	1-2	单步映射	需要教师模型
一致性训练	1-2	单步映射	较高
MeanFlow / iMF	1	平均速度映射	从零训练，无需蒸馏

每种加速都是在特定维度上的优化：DDIM 利用了 ODE 的确定性；Flow Matching 优化了路径形态；一致性模型跳过了路径，直接学习端点映射；MeanFlow 重新定义了速度场的语义，使单步推理成为自然结果。

5.3 质量与速度的权衡

采样步数越少，速度越快，但质量可能下降。关键问题是：单步生成能否保持多步生成的质量？

当前的经验答案是"接近但未完全达到"。一致性模型在单步生成上已经获得了令人印象深刻的结果（如 CIFAR-10 32×32 上 1-NFE 的 FID 3.55，对比 DDPM 多步采样的 3.17），但仍有差距。差距的来源在于：

一致性约束是一个硬约束——它要求所有噪声水平上的输出一致，但不同噪声水平提供的信息量不同
单步映射的信息容量有限——一次前向传播需要同时完成"全局结构识别"和"细节精修"
训练不稳定性——一致性模型的训练需要精细的超参数调节

六、应用：Stable Diffusion 3 与何恺明团队的突破

6.1 Stable Diffusion 3 的 Flow Matching

Stable Diffusion 3（Esser et al., 2024）是目前最知名的公开使用 Flow Matching 的模型。SD3 的技术报告《Scaling Rectified Flow Transformers for High-Resolution Image Synthesis》明确阐述了从 DDPM 切换到 Rectified Flow 的设计决策：论文通过系统实验对比了多种噪声调度和训练目标，发现 Rectified Flow（Flow Matching 的特例，使用直线插值路径）在相同计算预算下显著优于 DDPM 的预测噪声目标。

Flow Matching 的直线路径在高维潜空间中的数值稳定性优于 DDPM 的弯曲路径，原因在于：DDPM 的前向过程定义了非线性的信噪比调度，导致反向 ODE 的速度场在时间轴上剧烈变化，Euler 求解器在弯曲处产生较大截断误差；而 Flow Matching 的条件速度场是常数，边缘速度场的变化也远比 DDPM 平缓，数值精度更高。SD3 还提出了针对 Rectified Flow 的时间步采样策略（logit-normal 采样），使训练更集中于模型最难学习的时间段，进一步提升了采样效率。

在视频生成领域，Wan2.2 将 OT-CFM 从 2D 图像扩展到 3D 时空联合空间，在视频的时空维度（如 16 帧 $\times$ $480 \times 840$ 像素）上定义直线传输路径，技术细节见 Wan2.2：视频世界模型的边界。

6.2 何恺明团队的 MeanFlow 与 iMF

何恺明团队在 2025 年提出 MeanFlow（NeurIPS 2025 Oral），随后发布改进版 iMF（Improved Mean Flow）。MeanFlow 将建模目标从瞬时速度切换为平均速度（详见上文），而 iMF 解决了 MeanFlow 在实际训练中暴露的两个核心挑战：

训练目标的重新参数化：原始 MeanFlow 的训练目标依赖于网络自身的输出，导致训练不稳定。iMF 将目标重新表述为对瞬时速度 $v$ 的损失，通过预测平均速度 $u$ 的网络进行参数化，将问题转化为更稳定的标准回归问题
灵活的分类器自由引导：原始 MeanFlow 在训练时固定引导尺度（guidance scale），牺牲了推理时的灵活性。iMF 将引导机制表述为显式条件变量，通过上下文条件化（In-context Conditioning）机制处理多样化条件输入，不仅恢复了灵活性，还减小了模型尺寸并提升了性能

iMF 从零训练、无需蒸馏，在 ImageNet 256×256 上以单步生成（1-NFE）取得了 1.72 FID，大幅缩小了与多步方法的差距。这些工作表明，从瞬时速度到平均速度的视角转换，为生成模型的单步推理开辟了一条独立于蒸馏的技术路线。

七、从瞬时速度到平均速度：MeanFlow

苏剑林在《生成扩散模型漫谈（三十）》中提出了一个基本的反思：ODE 本来是 $\Delta t \to 0$ 的极限概念，我们却要它在 $\Delta t$ 很大的场景下工作——让一个为无穷小步长设计的数学工具去完成大跨度跳跃，这无异于"强模型所难"。Flow Matching 学习的瞬时速度 $\dot{x}(t)$ 是 $t$ 处的切线方向，只有当步长趋于零时才精确成立；当我们用它做大步长 Euler 积分时，截断误差不可避免。

MeanFlow（何恺明团队，NeurIPS 2025）的核心思想正是从这一反思出发：将建模目标从 ODE 的瞬时速度 $\dot{x}(t)$ 切换为平均速度

\bar{v}(t) = \frac{x_1 - x_0}{1 - 0} = x_1 - x_0

平均速度是有限时间间隔上的位移与时间之比，天然适用于大步长场景。训练目标变为：学习一个网络 $u_\theta(x_t, t)$ 直接预测位移 $x_1 - x_0$ ，即从噪声到数据的位移向量。推理时只需一步：

x_1 = x_0 + u_\theta(x_0, 0)

MeanFlow 与一致性模型的区别值得仔细辨析。一致性模型学习的是端到端映射 $f(x_t, t) \to x_0$ ，即给定任意噪声水平的样本直接输出干净数据——这是一种"跳过路径"的策略。MeanFlow 学习的是位移 $\Delta x = x_1 - x_0$ ，保留了 ODE 的物理直觉：速度场描述了状态的变化率，平均速度描述了有限时间内的总位移。前者关注映射的端点，后者关注位移本身——两者都实现了单步生成，但 MeanFlow 的目标更直接地对应了传输过程的物理意义。

MeanFlow 的优势还体现在两个方面。第一，它不需要蒸馏预训练模型——可以直接从数据中训练平均速度场，而一致性蒸馏必须依赖一个已训练的教师模型。第二，它不需要多步 ODE 求解中的数值误差累积——平均速度本身就是为有限步长设计的，不存在截断误差的概念。改进版 iMF（Improved Mean Flow，2025）进一步通过瞬时速度损失的重新参数化和上下文条件化机制，在 ImageNet 256×256 上以单步生成（1-NFE）取得了 1.72 FID，从零训练无需蒸馏。

从扩散模型的弯曲路径出发，Flow Matching 通过最优传输找到了直线路径，一致性模型则跳过了路径直接映射端点，MeanFlow 将建模目标从瞬时速度切换为平均速度，为单步生成提供了更自然的物理基础。四种方法在 ODE 视角下统一：它们都是在从噪声到数据的映射中寻找效率与质量的最优权衡。当路径足够直、映射足够好，单步生成不再是梦想——这是生成模型正在走向的未来。

参考文献

苏剑林. 生成扩散模型漫谈（十七）：构建ODE的一般步骤（下）. https://kexue.fm/archives/9497
苏剑林. 生成扩散模型漫谈（二十八）：分步理解一致性模型. https://kexue.fm/archives/10633
苏剑林. 生成扩散模型漫谈（三十）：从瞬时速度到平均速度. https://kexue.fm/archives/10958
Lipman, Y., et al. (2023). Flow Matching for Generative Modeling. ICLR 2023.
Song, Y., et al. (2023). Consistency Models. ICML 2023.
Liu, X., et al. (2023). Flow Straight and Fast: Learning to Generate and Transfer Data with Rectified Flow. ICLR 2023.
Geng, Z., et al. (2025). Mean Flows for One-step Generative Modeling. NeurIPS 2025.
Geng, Z., et al. (2025). Improved Mean Flows: On the Challenges of Fastforward Generation. arXiv:2512.02012.
Esser, P., et al. (2024). Scaling Rectified Flow Transformers for High-Resolution Image Synthesis. ICML 2024.
Sauer, A., et al. (2023). Adversarial Diffusion Distillation. arXiv:2311.17042.
Luo, S., et al. (2023). Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference. arXiv:2310.04378.

一、Flow Matching 的动机#

1.1 扩散模型 ODE 路径的弯曲问题#

1.2 最优传输：直线的启示#

二、条件流匹配的训练目标#

2.1 Flow Matching 目标#

2.2 条件流匹配等价于无条件流匹配#

2.3 替代推导路径：特征线法#

2.4 OT-CFM：最优传输条件流匹配#

三、OT-CFM 的深入分析#

3.1 为什么直线路径更好？#

3.2 Reflow：将弯曲路径拉直#

四、一致性模型：将 ODE 路径蒸馏为单步映射#

4.1 一致性约束#

4.2 一致性函数的参数化#

4.3 一致性蒸馏#

4.4 一致性训练#

4.5 工业应用#

五、生成模型的统一视角#

5.1 四种范式，一个 ODE#

5.2 采样效率的递进#

5.3 质量与速度的权衡#

六、应用：Stable Diffusion 3 与何恺明团队的突破#

6.1 Stable Diffusion 3 的 Flow Matching#

6.2 何恺明团队的 MeanFlow 与 iMF#

七、从瞬时速度到平均速度：MeanFlow#

相关概念#

参考文献#

相关文章