Flow and Diffusion Models

0. 本讲导读

这门课的名字叫「用随机微分方程做生成式 AI」。所以第一讲要回答的问题只有两个，但都很硬：

1. 「生成一张狗的图片」这句话，在数学上到底是什么意思？ 只要还停留在"生成得好不好"这种主观判断上，就没法写出损失函数、没法做梯度下降。我们需要把它变成一个有精确定义的数学任务。
2. 假设我们已经知道要采样哪个分布，用什么机器去采？ 答案是：模拟一条微分方程。从一团纯噪声出发，让它沿着某个"速度场"流动，流到时间 $t=1$ 时，它就变成了一张图片。

本讲不涉及任何训练算法——怎么学那个速度场是第 2 讲（flow matching）和第 3 讲（score matching）的事。本讲只干一件事：把"采样机器"的零件全部造好并说清楚每个零件的类型和维度。具体地说，我们会依次定义：向量场（vector field）、常微分方程（ODE）、流（flow）、布朗运动（Brownian motion）、随机微分方程（SDE），然后给出模拟它们的数值算法（Euler、Heun、Euler–Maruyama），最后用连续性方程（continuity equation）和 Fokker–Planck 方程把"轨迹的运动"和"分布的演化"这两件事严格地连起来。

最后这一步是全课的数学地基。整门课后面所有的定理——边际化技巧（marginalization trick）、flow matching 损失的等价性、ODE 与 SDE 给出同一条概率路径、guidance 的推导——追到底都是在用连续性方程或 Fokker–Planck 方程。所以本讲会把附录 B 里那个 Fokker–Planck 的完整证明一步不落地做完，包括分部积分那一步为什么边界项会消失。

1. 从「生成」到「采样」：把问题形式化

1.1 我们要生成的东西是向量

先看几种常见的数据模态（data modality），以及怎么把它们放进计算机：

三个例子的共同点：展平之后都是一个欧氏空间中的向量。这就是本课贯穿始终的第一个约定。

一个显著的例外是文本：语言模型（如 ChatGPT）把文本建模成离散对象（一串 token），而不是 $\R^d$ 中的点。连续数据 $z \in \R^d$ 是本课的主线；离散数据的扩散模型放在第 5 讲讲。

1.2 「生成得好」是主观的，「概率大」不是

假设提示词是"一张狗的图片"。什么样的输出算成功？直觉上会有一个连续谱：一团彩色噪声（毫无用处）$\to$ 模糊的四条腿生物（很差）$\to$ 一只清晰的猫（画错了动物）$\to$ 一只在草地上的边境牧羊犬（很棒）。这个排序是主观的，没法直接优化。

关键的转换是：不要问"这张图好不好"，改问"这张图在真实世界的狗图片中出现的可能性有多大"。同样的四个例子，换成概率语言就是：不可能出现 $\to$ 极罕见 $\to$ 不太可能（它是猫不是狗）$\to$ 非常可能。主观的"好"就被替换成了客观的"似然大"。

形式化地，我们假设"所有可能的狗图片"服从一个数据分布（data distribution） $\data$，它是定义在图像空间 $\R^d$ 上的一个概率分布，其概率密度（probability density）是一个函数

满足 $\int_{\R^d} \data(z)\,\dd{z} = 1$。看起来像狗的图片 $z$，$\data(z)$ 就大；一团噪声，$\data(z)$ 就几乎是 0。

图像的数据集可以从互联网收集；视频可以用 YouTube；蛋白质结构可以用 RCSB Protein Data Bank（PDB）里数十万个实验解析出的结构。数据集越大，它作为 $\data$ 的代理就越准确。

1.3 条件生成：把提示词加进来

实际使用时我们几乎从不做无条件生成，而是希望"根据提示词 $y$ 生成"，例如 $y = $ "一只狗在雪山背景的山坡上奔跑"。这在数学上就是从条件分布（conditional distribution）中采样。

值得强调的是，条件情形的困难不是"对每个 $y$ 训一个模型"，而是要训一个可以被任意 $y$ 条件化的模型。好消息是：无条件情形的所有技术都能相当直接地推广到条件情形。因此前三节我们几乎只讨论无条件情形，心里记着条件生成才是最终目标。

1.4 生成模型 = 把简单分布搬运成复杂分布

抽象地说，生成模型（generative model）就是一个能返回 $z \sim \data$（至少是近似）样本的算法。本课采用的具体构造方式是：

• 先取一个容易采样的初始分布（initial distribution） $\simple$。绝大多数情况下就取标准高斯 $\simple = \N(0, I_d)$——因为 torch.randn 一行就能采。
• 再造一台确定性或随机的"搬运机器"，把 $X_0 \sim \simple$ 连续地变形成 $X_1 \sim \data$。

2. 记号与概率论工具箱

后面所有推导都要反复用到几个概率论事实。这一节把它们集中列出并说清楚每个对象的类型，读到后面卡住时可以回来查（对应讲义附录 A）。

2.1 随机向量与密度

在 $d$ 维欧氏空间 $\R^d$ 中，向量 $x = (x^1,\dots,x^d)$，标准内积 $\inner{x}{y} = \sum_{i=1}^d x^i y^i$，范数 $\norm{x} = \sqrt{\inner{x}{x}}$。我们考虑取值在 $\R^d$ 的随机变量（random variable, RV）$X$，其概率密度函数（probability density function, PDF）是连续函数 $p_X : \R^d \to \R_{\ge 0}$，使得任意事件 $A \subseteq \R^d$ 的概率为

约定：对全空间积分时省略积分区间（$\int \equiv \int_{\R^d}$）；随机变量 $X_t$ 的密度 $p_{X_t}$ 简记为 $p_t$。记号 $X \sim p$ 表示 $X$ 服从密度 $p$。

生成建模中最常见的密度是 $d$ 维各向同性高斯（isotropic Gaussian）：

其中均值 $\mu \in \R^d$、标准差 $\sigma \in \R_{>0}$。注意指数上是 $\norm{x-\mu}^2 = \sum_i (x^i - \mu^i)^2$，所以各坐标是独立的——这个事实在后面拆解 $\Lap$ 项时会用到。

2.2 期望与无意识统计学家定律

随机变量的期望是在最小二乘意义下最接近 $X$ 的常向量：

计算随机变量的函数的期望时用无意识统计学家定律（law of the unconscious statistician, LOTUS）：

这条式子在 Fokker–Planck 的证明里是核心桥梁——它把"对随机轨迹取期望"翻译成"对密度做积分"，从而让分部积分成为可能。需要指明对哪个随机变量取期望时写作 $\E_X[f(X)]$。

2.3 条件密度、条件期望与塔性质

给定两个随机变量 $X, Y \in \R^d$，其联合密度 $p_{X,Y}(x,y)$ 的边际（marginal）为

当 $p_Y(y) > 0$ 时，条件密度定义为 $p_{X\mid Y}(x\mid y) := \dfrac{p_{X,Y}(x,y)}{p_Y(y)}$，贝叶斯公式（Bayes' rule）为

条件期望是在最小二乘意义下最接近 $X$ 的函数 $g_\star(Y)$（对比：期望是最接近的常数）：

对每个固定的 $y$ 单独取内层括号的最小值（用 2.2 节的结论），得到

塔性质（tower property）：$\E\big[\E[X\mid Y]\big] = \E[X]$。它在 Fokker–Planck 证明的第 3 步是关键一环（我们先对给定 $X_t$ 求条件期望，再对 $X_t$ 求期望）。

最后一条常用等式：对任意两个随机变量 $X, Y$ 和函数 $f(X,Y)$，由 LOTUS 与条件期望定义可得

2.4 记号速查

3. 常微分方程、向量场与流

上一节把生成变成了"从 $\data$ 采样"。这一节开始造采样机器。核心想法：让一个点沿着一个速度场运动。

3.1 三个对象：轨迹、向量场、ODE

先定义轨迹（trajectory）——一个从时间到空间的函数：

再定义向量场（vector field）——在每个时刻、每个位置指定一个速度：

常微分方程（ordinary differential equation, ODE）就是要求轨迹在每一点的速度恰好等于该点的向量场值，外加一个初值条件：

3.2 流：把所有初值的答案打包成一个映射

ODE 是"给定一个 $x_0$，问 $X_t$ 是多少"。如果我们想一次性回答所有起点的问题，就得到流（flow）：

它满足

给定初值 $X_0 = x_0$，ODE 的轨迹就是 $X_t = \psi_t(x_0)$。所以：

3.3 存在唯一性：Picard–Lindelöf 定理

写下一个方程不等于它有解。对 ODE 必须问两个问题：解存在吗？解唯一吗？

为什么这个定理对我们是"好消息而不是负担"？因为在机器学习里向量场 $u_t$ 由神经网络参数化，而神经网络（在有限参数、常见激活函数下）总是导数有界的。所以流在我们关心的所有情形下都存在且唯一。

3.4 算例一：线性向量场（把计算真的做出来）

讲义 Example 4：取 $u_t(x) = -\theta x$，其中 $\theta > 0$ 是常数。断言流为

这个流在做什么？它以指数速度把所有点吸向原点：$t\to\infty$ 时 $\psi_t(x_0)\to 0$，且收敛率与初始位置成正比。$\theta$ 越大收缩越快。这个例子在下面第 8 节会作为 Ornstein–Uhlenbeck 过程的"无噪声骨架"再次出现。

3.5 算例二：矩阵线性场与旋转（为连续性方程做铺垫）

更一般地，取 $u_t(x) = A x$，其中 $A \in \R^{d\times d}$ 是常数矩阵。则流是矩阵指数

验证：$\frac{\dd{}}{\dd{t}}\exp(tA) = A\exp(tA)$（逐项求导即可），故 $\frac{\dd{}}{\dd{t}}\psi_t(x_0) = A\exp(tA)x_0 = A\psi_t(x_0) = u_t(\psi_t(x_0))$。✓ 取 $A = -\theta I_d$ 就回到上一个例子。

取 $d = 2$ 和

则 $\exp(tA) = \begin{pmatrix}\cos\omega t & -\sin\omega t \\ \sin\omega t & \cos\omega t\end{pmatrix}$ 是旋转矩阵，流就是以角速度 $\omega$ 绕原点匀速旋转。

这个例子有个重要性质：它的散度为零，

4. 数值模拟：Euler 方法与 Heun 方法

上一节的两个例子都能写出闭式解，但那是因为向量场极其简单。一旦 $u_t$ 是一个几亿参数的神经网络，就绝无可能解析地算出 $\psi_t$。唯一的出路是数值模拟。

4.1 Euler 方法：从导数定义直接读出来

推导的起点就是导数的定义。对小的 $h > 0$：

把 $\approx$ 换成 $=$，就得到 Euler 方法（Euler method）：初始化 $X_0 = x_0$，然后

其中 $h = n^{-1} > 0$ 是步长（step size），$n \in \N$ 是模拟步数。走完 $n$ 步就从 $t=0$ 到了 $t=1$。

4.2 Euler 方法的误差：为什么它是一阶方法

4.3 Heun 方法：一次"预测-校正"换来一个数量级

Heun 方法（Heun's method）用两次向量场求值换更高精度：

直觉：Euler 完全相信"出发点的速度"，而 Heun 先用 Euler 探路探到 $X'_{t+h}$，在那里再测一次速度，然后用两次速度的平均值重走这一步。这就是梯形积分法则。

本课绝大多数场合用 Euler / Euler–Maruyama 就够了。

4.4 最小 PyTorch 实现

下面的抽象与课程 lab 中的一致：把"方程"（提供漂移系数/扩散系数）和"模拟器"（决定怎么走一步）分开。

import torch
from abc import ABC, abstractmethod


class ODE(ABC):
    @abstractmethod
    def drift_coefficient(self, xt: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
        """向量场 u_t(x)。
        xt: (bs, dim)  当前位置
        t : ()         当前时间（标量）
        返回: (bs, dim) 与 xt 同形状的速度
        """
        ...


class Simulator(ABC):
    @abstractmethod
    def step(self, xt: torch.Tensor, t: torch.Tensor, h: torch.Tensor) -> torch.Tensor:
        """走一步：从时刻 t 的 xt 走到时刻 t+h。"""
        ...

    @torch.no_grad()
    def simulate(self, x: torch.Tensor, ts: torch.Tensor) -> torch.Tensor:
        # x : (bs, dim) 初始状态，位于 ts[0]
        # ts: (nts,)    时间网格，通常 torch.linspace(0.0, 1.0, n + 1)
        for i in range(len(ts) - 1):
            t = ts[i]
            h = ts[i + 1] - ts[i]          # 步长，允许非均匀网格
            x = self.step(x, t, h)
        return x                            # (bs, dim) 终点 X_1


class EulerSimulator(Simulator):
    """X_{t+h} = X_t + h * u_t(X_t)"""
    def __init__(self, ode: ODE):
        self.ode = ode

    def step(self, xt, t, h):
        return xt + self.ode.drift_coefficient(xt, t) * h      # (bs, dim)


class HeunSimulator(Simulator):
    """预测-校正：先 Euler 探一步，再用两端速度的平均重走。"""
    def __init__(self, ode: ODE):
        self.ode = ode

    def step(self, xt, t, h):
        u_now  = self.ode.drift_coefficient(xt, t)             # (bs, dim)
        x_pred = xt + u_now * h                                # X'_{t+h}, (bs, dim)
        u_next = self.ode.drift_coefficient(x_pred, t + h)     # (bs, dim)
        return xt + 0.5 * h * (u_now + u_next)                 # (bs, dim)

用第 3.4 节的线性向量场来验证实现的正确性——这是唯一能和闭式解逐位比对的场景：

class LinearODE(ODE):
    """u_t(x) = -theta * x，闭式流 psi_t(x0) = exp(-theta * t) * x0"""
    def __init__(self, theta: float):
        self.theta = theta

    def drift_coefficient(self, xt, t):
        return -self.theta * xt                                # (bs, dim)


theta = 2.0
x0 = torch.randn(512, 2)                                       # (512, 2)
exact = torch.exp(torch.tensor(-theta * 1.0)) * x0             # psi_1(x0)

for n in [10, 100, 1000]:
    ts = torch.linspace(0.0, 1.0, n + 1)
    e_euler = (EulerSimulator(LinearODE(theta)).simulate(x0.clone(), ts) - exact).norm(dim=-1).mean()
    e_heun  = (HeunSimulator (LinearODE(theta)).simulate(x0.clone(), ts) - exact).norm(dim=-1).mean()
    print(f"n={n:5d}  euler={e_euler:.3e}  heun={e_heun:.3e}")

# 观察：n 每放大 10 倍，euler 的误差约缩小 10 倍（一阶），
#       heun 的误差约缩小 100 倍（二阶）。这正是 4.2 / 4.3 节推导的结论。

5. 流模型：用神经网络参数化向量场

零件齐了，现在组装第一台生成器。

5.1 随机性从哪来？

我们的目标是生成 $z\sim\data$ 的样本，而样本必须是随机的——每次运行要给出不同的狗。但 ODE 是完全确定的：给定 $x_0$，$X_1 = \psi_1(x_0)$ 是一个确定的点。矛盾怎么解决？

答案很简单：把随机性全部塞进初值。取一个容易采样的初始分布 $\simple$（默认 $\N(0,I_d)$），令 $X_0 \sim \simple$。这样 $X_1 = \psi_1(X_0)$ 就是随机变量 $X_0$ 经过确定映射 $\psi_1$ 的像，自然也是随机的。

5.2 流模型的定义

把向量场换成神经网络向量场（neural network vector field） $u^\theta_t$，即一个参数为 $\theta$ 的参数化函数

于是流模型（flow model）由下面这组方程描述：

我们的目标是让轨迹的终点 $X_1$ 服从数据分布：

其中 $\psi^\theta_t$ 是 $u^\theta_t$ 诱导的流。

5.3 采样算法（Algorithm 1）

把 Euler 方法套进流模型，就得到讲义的 Algorithm 1：

@torch.no_grad()
def sample_flow_model(u_theta, n: int, bs: int, dim: int, device="cpu"):
    """Algorithm 1：从流模型采样。
    u_theta(x, t) -> (bs, dim) 神经网络向量场
    返回: (bs, dim) 近似服从 p_data 的样本
    """
    h = 1.0 / n
    x = torch.randn(bs, dim, device=device)          # X_0 ~ p_init = N(0, I_d), (bs, dim)
    t = torch.zeros(1, device=device)                # ()
    for _ in range(n):
        x = x + h * u_theta(x, t)                    # X_{t+h} = X_t + h u_t(X_t), (bs, dim)
        t = t + h
    return x                                         # X_1, (bs, dim)

6. 布朗运动：随机性的原子

到目前为止一切都是确定性的。要把 ODE 升级成 SDE，我们需要一个"随机的时间增量"，它就是布朗运动。

6.1 随机过程与布朗运动的定义

先明确类型。一个随机过程（stochastic process） $(X_t)_{0\le t\le 1}$ 满足：

换句话说，同一个随机过程模拟两次会得到不同的曲线，因为演化本身就是随机的。这与 ODE 形成鲜明对比：ODE 的随机性只在起点，SDE 的随机性弥漫在整条路径上。

6.2 三个必须亲手算一遍的性质

6.3 路径无限长，但二次变差有限

讲义里有一句很漂亮的话："布朗运动的路径是连续的（你可以一笔画出来而不抬笔），但它们是无限长的（所以你永远画不完)"。这句话可以算出来。

6.4 模拟布朗运动

由正态增量与独立增量，模拟方法直接从定义读出：令 $W_0 = 0$，然后

def simulate_brownian(bs: int, dim: int, n: int, T: float = 1.0):
    """按定义模拟布朗运动：W_{t+h} = W_t + sqrt(h) * eps
    返回: (bs, n + 1, dim) 完整轨迹
    """
    h = T / n
    w = torch.zeros(bs, dim)                       # W_0 = 0, (bs, dim)
    traj = [w.clone()]
    for _ in range(n):
        w = w + (h ** 0.5) * torch.randn(bs, dim)  # 注意是 sqrt(h)，不是 h
        traj.append(w.clone())
    return torch.stack(traj, dim=1)                # (bs, n + 1, dim)


# 数值验证 6.2 与 6.3 节的三条结论
traj = simulate_brownian(bs=20000, dim=1, n=500, T=1.0)        # (20000, 501, 1)
print("Var(W_1) =", traj[:, -1, 0].var().item())               # 理论值 T = 1.0
print("Var(W_0.5) =", traj[:, 250, 0].var().item())            # 理论值 0.5

incr = traj[:, 1:, 0] - traj[:, :-1, 0]                        # (20000, 500)
print("二次变差 =", (incr ** 2).sum(dim=1).mean().item())        # 理论值 T = 1.0
print("路径长度 =", incr.abs().sum(dim=1).mean().item())         # 理论值 T*sqrt(2/(pi*h)) 约 17.8
# 把 n 从 500 改成 2000：二次变差仍然约等于 1，而路径长度约翻倍到 35.7。

7. 随机微分方程与 Euler–Maruyama 方法

7.1 先把 ODE 改写成不含导数的形式

第 6.2 节告诉我们布朗运动处处不可微，所以我们不能把随机项直接加进 $\frac{\dd{}}{\dd{t}}X_t = u_t(X_t)$ 里——加完之后左边的导数不存在了。因此必须先找到一个不使用导数的等价 ODE 表述。

7.2 SDE 的定义

现在给每一步再加上一份来自布朗运动的贡献：

其中 $\sigma_t \ge 0$ 称为扩散系数（diffusion coefficient）（本课中它是一个只依赖时间的标量，不依赖位置，也不是矩阵），$R_t(h)$ 是随机误差项，满足标准差 $\E[\norm{R_t(h)}^2]^{1/2}\to0$（当 $h\to0$）。上式描述的就是一个随机微分方程（stochastic differential equation, SDE）。习惯上用下面这个符号化记法：

还有一个重要的结构性差别：SDE 没有流映射 $\psi_t$ 了。因为 $X_t$ 不再由 $X_0$ 唯一决定——演化本身是随机的，同一个起点能长出无穷多条不同的轨迹。这也意味着后面讲义里凡是用到"流"的地方（比如第 3 讲的一些构造），都只对 ODE 成立。

如果这是一门随机分析课，我们会花好几周从头构造布朗运动、用随机积分（stochastic integration）与 Itô–Riemann 和构造出 $X_t$，并严格证明这个定理。本课的重点在机器学习，所以直接引用结论。

7.3 Euler–Maruyama 方法

如果 SDE 的抽象定义让你不适，那么换个问法马上就清楚了：我该怎么在电脑上模拟它？最简单的格式叫 Euler–Maruyama 方法，它之于 SDE 就相当于 Euler 方法之于 ODE。初始化 $X_0 = x_0$，然后迭代

其中 $h = n^{-1} > 0$ 是步长。换句话说：朝 $u_t(X_t)$ 迈一小步，再加一点被 $\sqrt h\,\sigma_t$ 缩放的高斯噪声。

class SDE(ABC):
    @abstractmethod
    def drift_coefficient(self, xt, t):
        """u_t(x)，返回 (bs, dim)"""
        ...

    @abstractmethod
    def diffusion_coefficient(self, xt, t):
        """sigma_t，广播成 (bs, dim)"""
        ...


class EulerMaruyamaSimulator(Simulator):
    """X_{t+h} = X_t + h * u_t(X_t) + sqrt(h) * sigma_t * eps,  eps ~ N(0, I_d)"""
    def __init__(self, sde: SDE):
        self.sde = sde

    def step(self, xt, t, h):
        drift = self.sde.drift_coefficient(xt, t)              # (bs, dim)
        diff  = self.sde.diffusion_coefficient(xt, t)          # (bs, dim)
        eps   = torch.randn_like(xt)                           # (bs, dim) 每步全新采样
        return xt + drift * h + diff * torch.sqrt(h) * eps     # 注意 sqrt(h)


class BrownianMotion(SDE):
    """u = 0, sigma = const：SDE 退化成（带缩放的）布朗运动"""
    def __init__(self, sigma: float):
        self.sigma = sigma

    def drift_coefficient(self, xt, t):
        return torch.zeros_like(xt)                            # (bs, dim)

    def diffusion_coefficient(self, xt, t):
        return self.sigma * torch.ones_like(xt)                # (bs, dim)

8. 算例：Ornstein–Uhlenbeck 过程的闭式解

讲义的 Example 6 给出了本课第一个真正的 SDE 例子。它值得完整算一遍，因为它是唯一一个能同时写出闭式解、闭式分布和闭式极限的非平凡例子，后面所有关于"噪声调度"的直觉都可以在这里检验。

8.1 定义

取常数扩散系数 $\sigma_t = \sigma \ge 0$ 和常数线性漂移 $u_t(x) = -\theta x$（$\theta > 0$），得到

它的解 $(X_t)_{0\le t\le1}$ 称为 Ornstein–Uhlenbeck（OU）过程。两股力量在角力：

• 漂移 $-\theta x$ 把过程推回中心 $0$（方向永远与当前位置相反，离得越远推得越猛）；
• 扩散 $\sigma$ 不断注入新的噪声，把过程往外推。

8.2 闭式解：积分因子法

8.3 均值与方差：不用随机积分也能算

上面的闭式解要配合 Itô 等距（Itô isometry）才能算出方差。下面给一个完全初等的推导，只用第 7.3 节的 Euler–Maruyama 更新式——这条路径对没学过随机分析的读者更友好，而且结论完全一样。

class OUProcess(SDE):
    """dX_t = -theta * X_t dt + sigma dW_t"""
    def __init__(self, theta: float, sigma: float):
        self.theta, self.sigma = theta, sigma

    def drift_coefficient(self, xt, t):
        return -self.theta * xt                                # (bs, dim)

    def diffusion_coefficient(self, xt, t):
        return self.sigma * torch.ones_like(xt)                # (bs, dim)


theta, sigma, T = 0.25, 1.0, 20.0
x0 = 5.0 * torch.ones(50000, 1)                                # (50000, 1) 全部从 x0 = 5 出发
ts = torch.linspace(0.0, T, 4001)                              # h = 0.005
xT = EulerMaruyamaSimulator(OUProcess(theta, sigma)).simulate(x0, ts)

import math
m_theory = math.exp(-theta * T) * 5.0                          # e^{-theta T} x0
v_theory = sigma ** 2 / (2 * theta) * (1 - math.exp(-2 * theta * T))
print(f"均值  模拟={xT.mean():.4f}  理论={m_theory:.4f}")        # 约 0.034
print(f"方差  模拟={xT.var():.4f}  理论={v_theory:.4f}")         # 约 2.0 = sigma^2/(2 theta)

9. 扩散模型：用 SDE 做生成

造第二台生成器的方式和第一台完全一样：把 SDE 的核心零件——向量场 $u_t$——换成神经网络 $u^\theta_t$，初值取自 $\simple$。

9.1 采样算法（Algorithm 2）

@torch.no_grad()
def sample_diffusion_model(u_theta, sigma_fn, n: int, bs: int, dim: int, device="cpu"):
    """Algorithm 2：从扩散模型采样。sigma_fn(t) -> 标量。sigma_fn = 0 时退化为 Algorithm 1。"""
    h = 1.0 / n
    x = torch.randn(bs, dim, device=device)              # X_0 ~ p_init, (bs, dim)
    t = torch.zeros(1, device=device)
    for _ in range(n):
        eps = torch.randn_like(x)                        # (bs, dim) 每步全新噪声
        x = x + h * u_theta(x, t) + sigma_fn(t) * (h ** 0.5) * eps
        t = t + h
    return x                                             # X_1, (bs, dim)

9.2 ODE 采样 vs SDE 采样

10. 连续性方程：分布如何被向量场输运

到这里，我们已经会造采样机器了。但有一个根本问题一直悬着：

我们模拟的是单条轨迹 $X_t$，而我们真正关心的是整个分布 $p_t$。这两者是怎么联系起来的？给定向量场 $u_t$ 和扩散系数 $\sigma_t$，$p_t$ 到底怎么演化？

回答这个问题的，是本节的连续性方程和下一节的 Fokker–Planck 方程。它们是整门课的数学地基：第 2 讲的边际化技巧、第 3 讲的 score matching、第 4 讲的"ODE 与 SDE 等价"、第 5 讲的 guidance，追到底全部是在用它们。

10.1 两个微分算子

先把工具定义清楚，注意输入输出的类型——这是最容易出错的地方。

散度（divergence）作用在向量场上，输出标量场：

其中 $v^i_t$ 是 $v_t$ 的第 $i$ 个坐标分量。

拉普拉斯算子（Laplacian）作用在标量场上，输出标量场：

还有一条马上要用的乘积法则：对标量场 $p$ 和向量场 $v$，

10.2 连续性方程

10.3 一个能验算到底的高斯例子

抽象定理不落地就没用。下面用第 3.4 节的线性向量场，把连续性方程逐项验证一遍。

11. Fokker–Planck 方程与它的完整证明

连续性方程处理的是 ODE。加上噪声之后会发生什么？答案是多出一个拉普拉斯项。

11.1 证明的两块工具

证明的核心技巧是使用测试函数（test function） $f:\R^d\to\R$，即无穷次可微、且只在一个有界区域内非零（紧支撑 / compact support）的函数。

11.2 必要性证明：若 $X_t\sim p_t$，则 Fokker–Planck 成立

11.3 充分性：为什么反过来也对

11.4 用 OU 过程验算 Fokker–Planck

光有证明还不够，我们再把定理套在第 8 节的 OU 过程上验算一次。这次验算的是平稳分布——它必须让 Fokker–Planck 的右边恰好为零。

11.5 三个方程的关系

12. 收束：flow 模型与 diffusion 模型的全景

把本讲的所有零件装配起来，一台生成器长这样：

唯一空着的格子是训练。本讲反复说"目标是让 $X_1\sim\data$"，但从没说过怎么达到这个目标。这不是疏漏，而是因为这件事本身很微妙：

损失函数应该长什么样？最自然的写法是 $\norm{u^\theta_t(x) - u^{\text{target}}_t(x)}^2$，但我们根本不知道 $u^{\text{target}}_t$ 是什么——它依赖于未知的 $\data$。

第 2 讲的答案分三步走，每一步都建立在本讲的地基上：

1. 先构造一条容易的"条件"路径。固定一个数据点 $z\sim\data$，定义条件概率路径 $p_t(\cdot\mid z)$（例如 $\N(\alpha_t z,\beta_t^2I_d)$），使得 $p_0(\cdot\mid z) = \simple$、$p_1(\cdot\mid z) = \delta_z$。这条路径的向量场 $u_t(x\mid z)$ 可以用本讲的连续性方程反解出闭式解。
2. 用边际化技巧把条件的拼成边际的。令 $p_t(x) = \int p_t(x\mid z)\data(z)\dd{z}$，则边际向量场是条件向量场的后验加权平均。这个"边际化技巧"的证明，就是把每个 $p_t(\cdot\mid z)$ 的连续性方程对 $z$ 积分再交换积分与散度——完全是本讲 §10 的工具。
3. 把不可算的边际目标换成可算的条件目标。用 §2.2 的"期望 = 最小二乘最优常数"引理的条件版本，证明回归到边际向量场与回归到条件向量场的损失只差一个与 $\theta$ 无关的常数，因此梯度相同。于是训练目标变成了完全可算的形式。

本课的三个母题在这里第一次全部现身，后面每一讲都会再遇到它们：

本讲小结

关键公式速查

本讲最容易踩的五个坑

1. Euler–Maruyama 里把 $\sqrt h$ 写成 $h$。不报错，但步长细化后噪声会消失，SDE 退化成 ODE。
2. 以为神经网络输出的是流。网络给的是瞬时速度，必须模拟才能得到终点——这就是采样慢的根本原因。
3. 混淆 $\E[X\mid Y=y]$（函数）与 $\E[X\mid Y]$（随机变量）。见 §2.3。
4. 忘了 SDE 没有流映射。凡是用到 $\psi_t^{-1}$ 或"轨迹可逆"的论证，只对 ODE 成立。
5. Taylor 展开时把二阶项当成 $O(h^2)$ 丢掉。对确定性项没错，但 $(\Delta W)^2 = O(h)$，丢了它就丢掉了整个拉普拉斯项。

延伸阅读

本讲直接相关的原始论文

• Score-Based Generative Modeling through Stochastic Differential Equations (Song et al., 2020) — 本讲开篇引言"Creating noise from data is easy; creating data from noise is generative modeling"的出处。第一次把 diffusion 完整地写成连续时间 SDE，并给出与之同边际的 probability flow ODE。读它可以提前看到本讲母题 (b) 的完整答案。
• Denoising Diffusion Probabilistic Models (Ho et al., 2020) — 引爆整个领域的那篇。它用的是离散时间马尔可夫链语言，和本讲的连续时间语言对照着读，能看清"离散步数"与"步长 $h$"的关系。
• Flow Matching for Generative Modeling (Lipman et al., 2022) — 第 2 讲的正主。本讲 §12 预告的三步走全部出自这里。建议本讲学完立刻读它的第 2、3 节。
• Flow Straight and Fast: Rectified Flow (Liu et al., 2022) — 与 flow matching 几乎同期的独立工作，用"把轨迹拉直"的视角切入。轨迹越直，Euler 方法所需步数越少——正好呼应 §4.2 的误差分析。

教材式的系统读物

• Flow Matching Guide and Code (Lipman et al., 2024) — 本课讲义大量图表的来源（包括 §3.2 的网格形变图）。如果你想要一份比讲义更长、覆盖更广（含流形上的 flow matching）的参考书，就是它。
• Stochastic Interpolants: A Unifying Framework for Flows and Diffusions (Albergo et al., 2023) — 从"随机插值"这个更一般的角度统一了 flow 和 diffusion，把本讲 §11.5 那张三方程对照表推到了极致。数学味最重的一篇，适合已经吃透 Fokker–Planck 之后读。

看看这些方程最终能造出什么

• High-Resolution Image Synthesis with Latent Diffusion Models (Rombach et al., 2022) — Stable Diffusion 的原始论文。把本讲的 SDE 搬到 VAE 的隐空间里跑，这就是第 4 讲"latent space"的主题。
• Scaling Rectified Flow Transformers for High-Resolution Image Synthesis (Esser et al., 2024) — Stable Diffusion 3。它用的正是 rectified flow + Transformer 架构，是"本课理论 = 工业界现状"最直接的证据。
• Scalable Diffusion Models with Transformers / DiT (Peebles & Xie, 2023) — 把 U-Net 换成 Transformer，第 4 讲架构部分的必读。
• Movie Gen: A Cast of Media Foundation Models (Polyak et al., 2024) — Meta 的视频生成模型，直接用 flow matching 训练。想看本讲的数学在几十亿参数规模上怎么落地，读它的方法一节。

数学背景补充

• Øksendal, Stochastic Differential Equations: An Introduction with Applications — 想把 §7.2 里"$\dd{W_t}$ 到底是什么"彻底搞清楚（Itô 积分、Itô 公式、鞅），这是标准入门教材。本讲 §8.2 的积分因子法在它的第 5 章有完整的严格版本。
• Evans, Partial Differential Equations, 第 7 章 — §11.3 用到的"抛物型 PDE 在给定初值下解唯一"就出自这里。

动手

• 课程 Lab 1（课程网站 diffusion.csail.mit.edu）— 本讲的代码全部对应 Lab 1：实现 ODE/SDE 抽象类、EulerSimulator/EulerMaruyamaSimulator，然后模拟布朗运动和 OU 过程，把 §8.3 的闭式解与模拟结果画在一起对照。强烈建议在读第 2 讲之前做完。