DDPM 深度剖析：变分推断视角下的去噪扩散概率模型

1. DDPM 的诞生：为什么是 2020 年？#

1.1 在 DDPM 之前：两段独立的历史#

扩散概率模型并非凭空出现——它由两条独立发展的理论脉络交汇而成。

历史脉络 A：变分推断

1
2002 VAE (Kingma & Welling)
2
  - 变分下界 (ELBO)
3
  - 重参数化技巧
4
  - 重构 + KL 正则化
5

6
2019 Sohl-Dickstein et al.
7
  - 扩散概率模型 (Deep Unsupervised Learning using Nonequilibrium Thermodynamics)
8
  - 马尔可夫前向 + 逆向
9
  - 但太慢，生成需 ~1000 步

历史脉络 B：Score Matching

1
2011 Score Matching (Hyvarinen)
2
  - 学 ∇_x log p(x) — 不需要归一化常数
3

4
2019 Song et al. — Noise Conditional Score Network (NCSN)
5
  - 用 Score Matching 学噪声尺度下的对数密度梯度
6
  - 朗之万采样生成
7

8
2021 Song et al. — Score SDE
9
  - 把 NCSN 统一到 SDE 框架

2020 年，Ho et al. 把两条脉络合二为一：

DDPM = Sohl-Dickstein 扩散的工程化 + Score Matching 的数学优雅 + 简单的 MSE 训练目标

1.2 一句话概括 DDPM#

DDPM 是一个分两步走的生成模型：① 预设一个将数据逐步破坏成纯噪声的前向过程（马尔可夫链）；② 训练一个神经网络去学习逆向过程——从噪声一步步恢复出原始数据。用变分推断证明，训练等价于简单的 MSE（预测噪声或 $x_0$ ）。

1.3 DDPM 论文信息#

1
论文: "Denoising Diffusion Probabilistic Models" (DDPM)
2
作者: Jonathan Ho, Ajay Jain, Pieter Abbeel
3
单位: Google Brain, UC Berkeley
4
发表于: NeurIPS 2020
5
引用: > 15,000 次 (截至 2024)
6
开源: https://github.com/hojonathanho/diffusion

2. 前向过程：预设的加噪马尔可夫链#

2.1 马尔可夫链定义#

设原始数据为 $x_0 \sim q(x_0)$ （真实数据分布）。前向过程定义为一个 $T$ 步马尔可夫链，每一步添加少量高斯噪声：

q(x_t | x_{t-1}) = \mathcal{N}\left(x_t; \sqrt{1 - \beta_t} x_{t-1}, \beta_t I\right)

其中 $\{\beta_t\}_{t=1}^T$ 是噪声调度（noise schedule），满足 $0 < \beta_1 < \beta_2 < \cdots < \beta_T < 1$ ， $\beta_t$ 随 $t$ 递增。

1
def forward_step(xt_minus_1, beta_t):
2
    """前向过程的单步: x_{t-1} → x_t"""
3
    mean = torch.sqrt(1 - beta_t) * xt_minus_1
4
    std  = torch.sqrt(beta_t)
5
    noise = torch.randn_like(xt_minus_1)
6
    return mean + std * noise

2.2 关键性质：闭式分布#

不用逐步递推！ 通过重参数化技巧，任意时刻 $t$ 的分布可以直接写出：

q(x_t | x_0) = \mathcal{N}\left(x_t; \sqrt{\bar\alpha_t} x_0, \; (1 - \bar\alpha_t) I\right)

其中：

\alpha_t = 1 - \beta_t, \quad \bar\alpha_t = \prod_{s=1}^t \alpha_s = \prod_{s=1}^t (1 - \beta_s)

推导：

设 $\epsilon_1, \epsilon_2, \ldots, \epsilon_t \sim \mathcal{N}(0, I)$ 独立，则：

\begin{aligned} x_t &= \sqrt{\alpha_t} x_{t-1} + \sqrt{1-\alpha_t} \epsilon_1 \\ &= \sqrt{\alpha_t \alpha_{t-1}} x_{t-2} + \sqrt{1-\alpha_t} \epsilon_1 + \sqrt{\alpha_t(1-\alpha_{t-1})} \epsilon_2 \\ &= \cdots \\ &= \sqrt{\bar\alpha_t} x_0 + \sqrt{1 - \bar\alpha_t} \epsilon \end{aligned}

其中 $\epsilon \sim \mathcal{N}(0, I)$ 是标准高斯噪声。

1
def closed_form_forward(x0, t, alphas_cumprod):
2
    """
3
    闭式前向分布: q(x_t | x_0)
4

5
    参数:
6
        x0: (batch_size, ...) 原始数据
7
        t:  (batch_size,) 时间步 (整数或浮点)
8
        alphas_cumprod: (T,)  cumprod 数组
9
    返回: (batch_size, ...) 在 t 时刻加噪后的数据
10
    """
11
    idx = t.long()  # 安全取整数索引
12
    sqrt_alpha_bar = torch.sqrt(alphas_cumprod[idx])
13
    sqrt_one_minus  = torch.sqrt(1 - alphas_cumprod[idx])
14
    noise = torch.randn_like(x0)
15
    B, C, H, W = x0.shape
16
    reshape_shape = (B, 1, 1, 1)
17
    return sqrt_alpha_bar.view(*reshape_shape) * x0 \
18
         + sqrt_one_minus.view(*reshape_shape) * noise

2.3 噪声调度的直观理解#

$\sqrt{\bar\alpha_t}$ 和 $\sqrt{1-\bar\alpha_t}$ 随时间步变化：

$t = 0$ ： $\sqrt{\bar\alpha_t} \approx 1.0, \sqrt{1-\bar\alpha_t} \approx 0$ ，对应原始数据
$t = 500$ ：两者约各占一半，噪声和数据混合
$t = T$ ： $\sqrt{\bar\alpha_t} \approx 0, \sqrt{1-\bar\alpha_t} \approx 1.0$ ，接近纯噪声

时刻	信号占比	噪声占比	含义
$t = 0$	高	极低	原始数据
$t = 500$	中等	中等	噪声和数据各占一半
$t = T$	极低	高	接近纯噪声

核心洞察：当 $t = T$ 时， $\bar\alpha_T \approx 0$ ，所以 $x_T \approx \mathcal{N}(0, I)$ ——前向过程把任意数据分布变成了标准高斯噪声。

2.4 常见噪声调度#

1
class NoiseSchedule:
2
    """三种常见噪声调度。"""
3

4
    @staticmethod
5
    def linear(T, beta_start=1e-4, beta_end=0.02):
6
        """线性调度 (DDPM 原始论文使用)。"""
7
        betas = torch.linspace(beta_start, beta_end, T)
8
        return betas
9

10
    @staticmethod
11
    def cosine(T, s=0.008):
12
        """余弦调度 (改进版, 噪声衰减更平滑)。"""
13
        steps = torch.arange(T + 1)
14
        # \bar\alpha_t = cos²( (t/T + s)/(1+s) * π/2 )
15
        alphas_cumprod = torch.cos((steps / T + s) / (1 + s) * (torch.pi / 2)) ** 2
16
        alphas_cumprod = alphas_cumprod / alphas_cumprod[0]  # 归一化: \bar\alpha_0 = 1
17
        betas = 1 - alphas_cumprod[1:] / alphas_cumprod[:-1]
18
        return betas
19

20
    @staticmethod
21
    def sigmoid(T, beta_start=1e-4, beta_end=0.02):
22
        """S 形调度 (介于线性和余弦之间)。"""
23
        betas = torch.linspace(-6, 6, T)
24
        betas = torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
25
        return betas

1
ᾱ_t 曲线对比:
2

3
1.0 ─────────────────────────────────────────
4
     ╲  Linear     (更快变噪声)
5
      ╲
6
       ╲ Cosine    (更平滑)
7
        ╲
8
         ╲
9
          ──────────────────────── 0.0  t

3. 逆向过程：学习的去噪分布#

3.1 逆向分布的必要性#

如果能精确知道 $q(x_{t-1} | x_t)$ ，就可以从纯噪声 $x_T \sim \mathcal{N}(0, I)$ 精确恢复数据 $x_0$ 。

但 $q(x_{t-1} | x_t)$ 不可直接计算（需要对所有 $x_0$ 积分），所以用神经网络 $p_\theta(x_{t-1} | x_t)$ 来近似：

p_\theta(x_{t-1} | x_t) = \mathcal{N}\left(x_{t-1}; \mu_\theta(x_t, t), \sigma_t^2 I\right)

3.2 逆向过程的参数化#

均值参数化（最直觉的写法）：

p_\theta(x_{t-1} | x_t) = \mathcal{N}\left(x_{t-1}; \mu_\theta(x_t, t), \tilde\beta_t I\right)

但更常用的是直接预测噪声或 $x_0$ ，而不是直接预测均值——因为这让目标函数成为简单的 MSE。

3.3 均值与噪声的关系#

由前向过程的闭式公式，可以反解出均值：

\mu_t(x_t, x_0) = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \sqrt{1 - \alpha_t} \epsilon \right)

其中 $\epsilon$ 是注入的噪声。由 $x_t = \sqrt{\bar\alpha_t} x_0 + \sqrt{1-\bar\alpha_t} \epsilon$ ，得：

x_0 = \frac{x_t - \sqrt{1-\bar\alpha_t} \epsilon}{\sqrt{\bar\alpha_t}}

代入均值表达式：

\mu_t(x_t, x_0) = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \beta_t \cdot \frac{x_t - \sqrt{\bar\alpha_t} x_0}{\sqrt{1-\bar\alpha_t}} \right)

或者，直接用噪声 $\epsilon$ 和 $x_0$ 来表达（这是神经网络实际预测的）：

\mu_t(x_t, t) = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \frac{\beta_t}{\sqrt{1-\bar\alpha_t}} \cdot \epsilon_\theta(x_t, t) \right)

网络 $\epsilon_\theta(x_t, t)$ 预测注入的噪声 $\epsilon$ ，从而反推均值。

4. 变分推断与 ELBO#

4.1 生成模型的对数似然目标#

我们想最大化生成数据的对数似然 $\log p_\theta(x_0)$ 。但 $\log p_\theta(x_0)$ 直接计算困难（需要对所有隐变量积分），所以用变分推断引入隐变量 $x_{1:T}$ ：

\log p_\theta(x_0) = \log \int p_\theta(x_{0:T}) \, dx_{1:T}

4.2 ELBO 的引入#

对任意分布 $q(x_{1:T} | x_0)$ （建议分布，即前向过程），用 Jensen 不等式得到变分下界 (ELBO)：

\log p_\theta(x_0) \geq \mathbb{E}_{q} \left[ \log \frac{p_\theta(x_{0:T})}{q(x_{1:T}|x_0)} \right] = \mathcal{L}

展开 $p_\theta(x_{0:T}) = p(x_T) \prod_{t=1}^T p_\theta(x_{t-1}|x_t)$ ， $q(x_{1:T}|x_0) = \prod_{t=1}^T q(x_t|x_{t-1})$ ，得到 ELBO 的分项形式：

\mathcal{L} = \underbrace{-\log p(x_T)}_{-\mathcal{L}_T} + \sum_{t=1}^T \underbrace{\mathbb{E}_q \left[ D_{\mathrm{KL}}(q(x_{t-1}|x_t, x_0) \| p_\theta(x_{t-1}|x_t)) \right]}_{-\mathcal{L}_{t-1}} + \underbrace{\mathbb{E}_q \left[ \log p_\theta(x_0 | x_1) \right]}_{-\mathcal{L}_0}

4.3 ELBO 三项的物理含义#

1
ELBO = -[ L_T + L_{T-1} + ... + L_1 + L_0 ]
2
        ↓       ↓         ↓       ↓
3
      终点    中间步    中间步   重构项
4
     KL项    KL项      KL项    重构损失

ELBO 包含三项，每项对应不同的训练阶段：

项	名称	含义	训练时是否需要
$\mathcal{L}_T$	终点先验 KL	$q(x_T \mid x_0)$ 与 $p(x_T)$ 的 KL， $T$ 足够大时自动满足	❌
$\mathcal{L}_{t-1}$	去噪匹配项	$q(x_{t-1} \mid x_t, x_0)$ （可解析）与 $p_\theta(x_{t-1} \mid x_t)$ 的 KL	✅ 核心
$\mathcal{L}_0$	重构项	在 $t = 1$ 时从 $x_1$ 重构 $x_0$	✅（可与 $\mathcal{L}_1$ 合并）

4.4 关键： $q(x_{t-1} | x_t, x_0)$ 有闭式解#

定理：给定 $x_0$ 和 $x_t$ ，逆向条件分布 $q(x_{t-1} | x_t, x_0)$ 也是高斯分布，可以直接写出均值和方差：

q(x_{t-1} | x_t, x_0) = \mathcal{N}\left(x_{t-1}; \tilde\mu_t(x_t, x_0), \tilde\beta_t I\right)

其中：

\tilde\mu_t(x_t, x_0) = \frac{\sqrt{\bar\alpha_{t-1}} \beta_t}{1 - \bar\alpha_t} x_0 + \frac{\sqrt{\alpha_t}(1 - \bar\alpha_{t-1})}{1 - \bar\alpha_t} x_t

方差：

\tilde\beta_t = \frac{1 - \bar\alpha_{t-1}}{1 - \bar\alpha_t} \cdot \beta_t

1
def reverse_posterior_mean(x0, xt, t, alphas_cumprod, betas):
2
    """
3
    计算 q(x_{t-1} | x_t, x_0) 的均值 (闭式)。
4
    这是在 ELBO 中，用于计算 L_{t-1} KL 项的 target mean。
5
    """
6
    alpha_bar_t   = alphas_cumprod[t]
7
    alpha_bar_tm1 = alphas_cumprod[t - 1]
8
    alpha_t       = 1 - betas[t]
9

10
    # 从 xt 解出注入的噪声
11
    sqrt_alpha_bar_t   = torch.sqrt(alpha_bar_t)
12
    sqrt_one_minus     = torch.sqrt(1 - alpha_bar_t)
13
    eps                = (xt - sqrt_alpha_bar_t * x0) / sqrt_one_minus
14

15
    # 计算均值 (用噪声表示)
16
    sqrt_alpha_bar_tm1 = torch.sqrt(alpha_bar_tm1)
17
    beta_t             = betas[t]
18

19
    # 方法 1: 用 x0 和 xt 表示
20
    mean = (sqrt_alpha_bar_tm1 * beta_t / (1 - alpha_bar_t)) * x0 \
21
         + (torch.sqrt(alpha_t) * (1 - alpha_bar_tm1) / (1 - alpha_bar_t)) * xt
22

23
    # 方法 2: 用噪声 ε 表示 (更常用, 神经网络预测 ε)
24
    mean_eps = (xt - torch.sqrt(1 - alpha_bar_t) * beta_t / (1 - alpha_bar_t).sqrt() * eps) \
25
             / alpha_t.sqrt()
26

27
    return mean_eps

4.5 ELBO 的简化#

在 DDPM 论文中， $\mathcal{L}_{t-1}$ 简化为：

\mathcal{L}_{t-1} \approx \mathbb{E}_{t, x_0, \epsilon} \left[ \frac{\beta_t^2}{2 \sigma_t^2 (1-\alpha_t)(1-\bar\alpha_t)} \left\| \epsilon - \epsilon_\theta(\sqrt{\bar\alpha_t}x_0 + \sqrt{1-\bar\alpha_t}\epsilon, t) \right\|^2 \right]

论文发现，去掉复杂的系数后，简化为：

\mathcal{L}_{t-1}^{\text{simple}} = \mathbb{E}_{t, x_0, \epsilon} \left\| \epsilon - \epsilon_\theta(x_t, t) \right\|^2

这意味着：训练 DDPM 等价于训练一个 MSE 损失——预测注入的噪声 $\epsilon$ ！

5. 三种参数化方式#

5.1 噪声预测 $\epsilon$ -prediction#

网络输出：注入的噪声 $\epsilon$ 目标： $\epsilon_\theta(x_t, t) \approx \epsilon$

\mathcal{L}_{\text{simple}} = \mathbb{E}_{t, x_0, \epsilon} \left[ \| \epsilon - \epsilon_\theta(x_t, t) \|^2 \right]

1
def loss_eps_prediction(model, x0, t, alphas_cumprod):
2
    """DDPM 标准噪声预测损失。"""
3
    eps = torch.randn_like(x0)
4
    xt = torch.sqrt(alphas_cumprod[t]) * x0 + torch.sqrt(1 - alphas_cumprod[t]) * eps
5
    pred_eps = model(xt, t)
6
    return F.mse_loss(pred_eps, eps)

5.2 $x_0$ 预测 (x-prediction)#

网络输出：原始数据 $x_0$ 目标： $\hat{x}_0 = x_\theta(x_t, t) \approx x_0$

由 $x_0 = (x_t - \sqrt{1-\bar\alpha_t} \epsilon) / \sqrt{\bar\alpha_t}$ ：

x_0 = \frac{x_t - \sqrt{1 - \bar\alpha_t} \epsilon_\theta(x_t, t)}{\sqrt{\bar\alpha_t}}

1
def loss_x0_prediction(model, x0, t, alphas_cumprod):
2
    """x0 预测损失。"""
3
    eps = torch.randn_like(x0)
4
    xt = torch.sqrt(alphas_cumprod[t]) * x0 + torch.sqrt(1 - alphas_cumprod[t]) * eps
5
    pred_x0 = model(xt, t)
6
    return F.mse_loss(pred_x0, x0)

5.3 速度预测 v-prediction#

网络输出：速度向量 $v = \alpha_t \epsilon - \sqrt{\bar\alpha_t} x_0$ 目标： $v_\theta(x_t, t) \approx v$

由 $x_t = \sqrt{\bar\alpha_t} x_0 + \sqrt{1-\bar\alpha_t} \epsilon$ ，对 $t$ 求导得：

v = \frac{dx_t}{dt} = -\frac{d\sqrt{\bar\alpha_t}}{dt} x_0 + \frac{d\sqrt{1-\bar\alpha_t}}{dt} \epsilon

在实际中，DDPM++ 论文使用：

v = \sqrt{\bar\alpha_t} \epsilon - \sqrt{1-\bar\alpha_t} x_0

1
def loss_v_prediction(model, x0, t, alphas_cumprod):
2
    """速度预测损失 (DDPM++ / ADM 采用)。"""
3
    eps = torch.randn_like(x0)
4
    sqrt_ab = torch.sqrt(alphas_cumprod[t])
5
    sqrt_1m = torch.sqrt(1 - alphas_cumprod[t])
6
    xt = sqrt_ab * x0 + sqrt_1m * eps
7

8
    # 真实速度
9
    v = sqrt_ab * eps - sqrt_1m * x0
10

11
    pred_v = model(xt, t)
12
    return F.mse_loss(pred_v, v)

5.4 三种参数化对比#

维度	噪声预测 (DDPM)	x0 预测	速度预测 (DDPM++)
网络输出	$\epsilon$	$x_0$	$v$
损失函数	MSE	MSE	MSE
低噪声时 ( $t \to 0$ )	好	最好	好
高噪声时 ( $t \to T$ )	好	差	好
训练稳定性	高	中	高
典型应用	DDPM, SD 1/2/xl	—	ADM, DiT, MMDiT

6. 训练与采样完整流程#

6.1 训练算法#

1
def ddpm_train_step(model, x0, alphas_cumprod, betas):
2
    """
3
    DDPM 训练步 (Algorithm 1, Ho et al. 2020)。
4
    """
5
    B = x0.shape[0]
6

7
    # 1) 采样时间步 t ~ Uniform{1, ..., T}
8
    t = torch.randint(0, len(alphas_cumprod), (B,), device=x0.device)
9

10
    # 2) 采样噪声 ε ~ N(0, I)
11
    eps = torch.randn_like(x0)
12

13
    # 3) 前向加噪 (闭式)
14
    sqrt_ab  = alphas_cumprod[t] ** 0.5
15
    sqrt_1m  = (1 - alphas_cumprod[t]) ** 0.5
16
    xt = sqrt_ab.view(-1, *([1] * (x0.dim() - 1))) * x0 \
17
       + sqrt_1m.view(-1, *([1] * (x0.dim() - 1))) * eps
18

19
    # 4) 计算损失 (噪声预测)
20
    eps_theta = model(xt, t)
21
    loss = F.mse_loss(eps_theta, eps)
22

23
    return loss
24

25

26
def train_ddpm(model, dataloader, T, beta_schedule_fn):
27
    """完整 DDPM 训练循环。"""
28
    betas = beta_schedule_fn(T)
29
    alphas = 1 - betas
30
    alphas_cumprod = torch.cumprod(alphas, dim=0)
31

32
    for epoch in range(num_epochs):
33
        for batch in dataloader:
34
            x0 = batch.to(device)
35
            loss = ddpm_train_step(model, x0, alphas_cumprod, betas)
36

37
            optimizer.zero_grad()
38
            loss.backward()
39
            optimizer.step()

6.2 采样算法（DDPM 原版）#

1
@torch.no_grad()
2
def ddpm_sample(model, alphas_cumprod, betas, shape, T):
3
    """
4
    DDPM 采样 (Algorithm 2, Ho et al. 2020)。
5
    从 x_T ~ N(0, I) 开始，T 步逆向去噪。
6
    """
7
    # 1) 从纯噪声开始
8
    xt = torch.randn(*shape, device=device)
9

10
    # 2) 逐步逆向去噪 (t = T, T-1, ..., 1)
11
    for t in reversed(range(T)):
12
        t_batch = torch.full((shape[0],), t, device=device)
13

14
        # 预测噪声
15
        eps_theta = model(xt, t_batch)
16

17
        # 估计 x_0
18
        sqrt_ab  = alphas_cumprod[t] ** 0.5
19
        sqrt_1m  = (1 - alphas_cumprod[t]) ** 0.5
20
        x0_pred  = (xt - sqrt_1m * eps_theta) / sqrt_ab
21

22
        # 计算均值
23
        beta_t    = betas[t]
24
        alpha_t   = 1 - beta_t
25
        mean = (xt - (beta_t / sqrt_1m) * eps_theta) / alpha_t ** 0.5
26

27
        # 如果不是最后一步，加随机噪声
28
        if t > 0:
29
            std = (1 - alphas_cumprod[t - 1] / alphas_cumprod[t]) ** 0.5 * beta_t ** 0.5
30
            xt = mean + std * torch.randn_like(xt)
31
        else:
32
            xt = mean
33

34
    return xt

注意：原版 DDPM 需要 1000 步才能生成高质量图像——这太慢了，所以后来有了 DDIM 等加速方法。

6.3 DDIM 加速采样#

DDIM（Denoising Diffusion Implicit Models, Song et al., 2021）放弃了马尔可夫假设，用非马尔可夫逆向过程实现确定性且更快的采样：

1
@torch.no_grad()
2
def ddim_sample(model, alphas_cumprod, betas, shape,
3
                 num_steps=50, eta=0.0):
4
    """
5
    DDIM 采样 (Song et al., 2021)。
6
    num_steps << T (比如 T=1000, num_steps=50)
7

8
    eta = 0:   完全确定性 (DDIM)
9
    eta = 1:   随机马尔可夫 (等效 DDPM)
10
    """
11
    T = len(alphas_cumprod) - 1
12
    # 选择子序列
13
    step_list = torch.linspace(0, T - 1, num_steps, dtype=torch.long).tolist()
14
    seq = step_list[::-1]  # 倒序: [T-1, ..., 0]
15

16
    # 从纯噪声开始
17
    xt = torch.randn(*shape, device=device)
18

19
    for i, t in enumerate(seq):
20
        t_batch = torch.full((shape[0],), t, device=device)
21

22
        # 预测噪声
23
        eps_theta = model(xt, t_batch)
24

25
        # 估计 x_0
26
        sqrt_ab  = alphas_cumprod[t] ** 0.5
27
        sqrt_1m  = (1 - alphas_cumprod[t]) ** 0.5
28
        x0_pred  = (xt - sqrt_1m * eps_theta) / sqrt_ab
29

30
        # 下一个时间步
31
        t_next = seq[i + 1] if i + 1 < len(seq) else 0
32
        sqrt_ab_next = alphas_cumprod[t_next] ** 0.5
33
        sqrt_1m_next = (1 - alphas_cumprod[t_next]) ** 0.5
34

35
        # DDIM 确定性方向
36
        pred_eps = eps_theta
37
        xt_next = sqrt_ab_next * x0_pred + sqrt_1m_next * pred_eps
38

39
        # 如果要随机性 (eta > 0)
40
        if eta > 0:
41
            std = eta * ((1 - alphas_cumprod[t_next]) / (1 - alphas_cumprod[t]) * betas[t]) ** 0.5
42
            xt_next = xt_next + std * torch.randn_like(xt)
43

44
        xt = xt_next
45

46
    return xt

DDIM 的关键洞察： $t \to t-1$ 的转移不需要是随机的——只要 $x_{t-1}$ 能从 $x_t$ 推出 $x_0$ ，就是合法的逆向过程。

6.4 DDPM vs DDIM vs Flow Matching 对比#

维度	DDPM (马尔可夫)	DDIM (非马尔可夫)	Rectified Flow
逆向过程	随机（加噪声）	确定性（可选随机性）	ODE（确定性）
采样步数	1000（慢）	20-50（快）	10-50（快）
轨迹形状	弧线	取决于噪声调度	直线（OT 最优）
训练目标	MSE( $\epsilon$ )	同 DDPM	MSE( $v$ )
轨迹可视化	发散	集中	最短

7. 与 Score Matching 的理论联系#

7.1 Score Matching 的核心#

Score Matching 的目标是训练一个得分网络 $s_\theta(x, t)$ 来估计对数密度梯度：

s_\theta(x, t) \approx \nabla_x \log p_t(x)

得分匹配损失（Hutchinson 估计器）：

\mathcal{L}_{\text{SM}} = \mathbb{E}_{x \sim p_{\text{data}}} \left[ \operatorname{tr}\left( \frac{\partial s_\theta(x)}{\partial x} \right) + \frac{1}{2} \| s_\theta(x) \|^2 \right]

7.2 DDPM 与 Score Matching 的等价性#

核心联系：DDPM 预测的噪声 $\epsilon_\theta(x_t, t)$ 与得分函数成正比：

\epsilon_\theta(x_t, t) = -\sigma_t \nabla_{x_t} \log p_t(x_t)

其中 $\sigma_t = \sqrt{1 - \bar\alpha_t}$ 是噪声标准差。

推导：

$p_t(x_t) = \int p(x_0) q(x_t | x_0) dx_0$
$q(x_t | x_0) = \mathcal{N}(\sqrt{\bar\alpha_t} x_0, \sigma_t^2 I)$
$\nabla_{x_t} \log q(x_t | x_0) = -\frac{x_t - \sqrt{\bar\alpha_t} x_0}{\sigma_t^2} = -\frac{\epsilon}{\sigma_t}$
所以 $\nabla_{x_t} \log p_t(x_t) = \mathbb{E}_{q(x_0|x_t)}[-\frac{\epsilon}{\sigma_t}]$

1
def score_from_eps(eps_theta, t, alphas_cumprod):
2
    """
3
    从噪声预测网络得到得分函数 ∇_x log p_t(x)。
4
    """
5
    sigma_t = torch.sqrt(1 - alphas_cumprod[t])
6
    score = -eps_theta / sigma_t  # s_θ(x_t, t) ≈ -ε / σ
7
    return score
8

9

10
def eps_from_score(score, t, alphas_cumprod):
11
    """
12
    从得分函数恢复噪声预测。
13
    """
14
    sigma_t = torch.sqrt(1 - alphas_cumprod[t])
15
    return -sigma_t * score

7.3 为什么 DDPM 比纯 Score Matching 更好训练？#

维度	纯 Score Matching	DDPM
学习目标	$\nabla \log p(x)$ （得分函数）	$\epsilon$ （噪声）
额外计算	需要 Hessian 或 Hutchinson 估计	不需要
采样方式	朗之万动力学（慢，不精确）	直接从 $x_T$ 逆向（快）
训练稳定性	差（得分函数在高维空间容易爆炸）	好（MSE 损失有界）

DDPM 通过引入预设前向过程和可闭式计算的 KL 目标，绕过了纯 Score Matching 的 Hessian 估计难题——这是它最重要的工程贡献。

8. 方差参数化：固定 vs 学习#

8.1 DDPM 的方差设计#

原版 DDPM 将逆向方差 $\beta_t$ 固定为前向方差：

\sigma_t^2 = \beta_t

论文发现，学习方差并不会带来显著提升，反而增加训练难度。

1
# DDPM 原版: 方差固定
2
def ddpm_variance(t, betas):
3
    """逆向过程的方差（固定为 β_t）。"""
4
    return betas[t]
5

6

7
# DDPM++ (改进版): 学习方差
8
class LearnedVarianceUNet(nn.Module):
9
    """输出均值 + log 方差。"""
10
    def forward(self, xt, t):
11
        out = self.backbone(xt, t)
12
        mean, log_var = out.chunk(2, dim=1)
13
        log_var = torch.clamp(log_var, -10, 10)
14
        return mean, log_var
15

16

17
def ddpmpp_sample(model, alphas_cumprod, betas, shape, T):
18
    """DDPM++ 采样 (学习方差版本)。"""
19
    xt = torch.randn(*shape, device=device)
20

21
    for t in reversed(range(T)):
22
        t_batch = torch.full((shape[0],), t, device=device)
23
        mean, log_var = model(xt, t_batch)
24

25
        # 混合: 固定 + 学习
26
        fixed_var = betas[t]
27
        learned_var = log_var.exp()
28
        var = (1 - alphas_cumprod[t - 1] / alphas_cumprod[t]) * betas[t]
29

30
        std = var ** 0.5
31
        xt = mean + std * torch.randn_like(xt)
32

33
    return xt

9. Classifier Guidance（分类器引导）#

9.1 为什么需要引导？#

无条件 DDPM 生成质量不错，但无法控制类别。Classifier Guidance 用外部分类器注入类别信息：

\hat{p}_\phi(y | x_t) \propto p(x_t | y)^{\gamma}

对应的引导得分：

\widehat{\nabla_{x_t} \log p(y | x_t)} = \gamma \cdot \nabla_{x_t} \log p_\phi(y | x_t)

9.2 引导下的逆向分布#

\hat{\epsilon}_\theta(x_t, t | y) = \epsilon_\theta(x_t, t) - \sqrt{1 - \bar\alpha_t} \cdot \gamma \cdot \nabla_{x_t} \log p_\phi(y | x_t)

1
def classifier_guidance(eps_theta, x_t, t, classifier, y, gamma=1.0):
2
    """
3
    分类器引导 (Dhariwal & Nichol, 2021)。
4

5
    在无类别噪声预测上叠加分类器梯度。
6
    """
7
    # 分类器对 x_t 求梯度
8
    x_t.requires_grad_(True)
9
    logits = classifier(x_t, t)
10
    log_probs = torch.log_softmax(logits, dim=-1)
11
    target_log_prob = log_probs.gather(-1, y.unsqueeze(-1)).squeeze(-1)
12
    grad = torch.autograd.grad(target_log_prob.sum(), x_t)[0]
13

14
    # 引导噪声预测
15
    sigma_t = ...  # 噪声标准差
16
    guided_eps = eps_theta - gamma * sigma_t * grad
17
    return guided_eps

关键：引导强度 $\gamma$ 控制类别保真度和多样性之间的 trade-off。 $\gamma = 1$ 是标准引导， $\gamma$ 越大，生成越精确但越缺乏多样性。

9.3 CFG vs Classifier Guidance#

维度	Classifier Guidance	Classifier-Free Guidance
是否需要	单独训练分类器	无需额外网络
训练方式	分类器单独训，DDPM 单独训	DDPM 联合训练条件 + 无条件
质量	高（专用信号）	高（隐式引导）
多样性	低（强引导降低）	可控（由 $w$ 调节）
典型使用	ADM, Guided Diffusion	SD 1/2/xl, SD3, FLUX

**CFG（无分类器引导）**是主流：

\hat{\epsilon}_\theta(x_t, t | c) = (1 + w) \cdot \epsilon_\theta(x_t, t, c) - w \cdot \epsilon_\theta(x_t, t, \emptyset)

1
def cfg_eps(eps_cond, eps_uncond, w):
2
    """无分类器引导 (CFG)。"""
3
    return (1 + w) * eps_cond - w * eps_uncond

10. DDPM 的完整 PyTorch 实现#

1
import math
2
import torch
3
import torch.nn as nn
4
import torch.nn.functional as F
5
from torch.utils.data import DataLoader
6

7

8
class SinusoidalTimeEmbedding(nn.Module):
9
    """DDPM 标准时间步嵌入。"""
10

11
    def __init__(self, dim):
12
        super().__init__()
13
        self.dim = dim
14

15
    def forward(self, t):
16
        device = t.device
17
        half = self.dim // 2
18
        embeddings = math.log(10000) / (half - 1)
19
        embeddings = torch.exp(torch.arange(half, device=device) * -embeddings)
20
        embeddings = t[:, None] * embeddings[None, :]
21
        embeddings = torch.cat([embeddings.sin(), embeddings.cos()], dim=-1)
22
        return embeddings
23

24

25
class ResidualBlock(nn.Module):
26
    """带 GroupNorm + SiLU 的残差块。"""
27

28
    def __init__(self, in_ch, out_ch, time_emb_dim, dropout=0.1):
29
        super().__init__()
30
        self.norm1 = nn.GroupNorm(32, in_ch)
31
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, padding=1)
32
        self.time_mlp = nn.Sequential(
33
            nn.SiLU(), nn.Linear(time_emb_dim, out_ch * 2)
34
        )
35
        self.norm2 = nn.GroupNorm(32, out_ch)
36
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, padding=1)
37
        self.dropout = nn.Dropout(dropout)
38

39
        # 残差连接
40
        self.shortcut = nn.Conv2d(in_ch, out_ch, 1) if in_ch != out_ch else nn.Identity()
41

42
    def forward(self, x, t_emb):
43
        h = self.norm1(x).swish()
44
        h = self.conv1(h)
45

46
        # 调制: AdaGN 风格
47
        t = self.time_mlp(t_emb)
48
        shift, scale = t.chunk(2, dim=-1)
49
        h = h * (1 + scale[:, None, :, :]) + shift[:, None, :, :]
50

51
        h = self.dropout(h)
52
        h = self.norm2(h).swish()
53
        h = self.conv2(h)
54

55
        return h + self.shortcut(x)
56

57

58
class DDPMUNet(nn.Module):
59
    """简化版 DDPM U-Net。"""
60

61
    def __init__(self, in_channels=3, base_channels=128, channel_mults=(1, 2, 4, 8)):
62
        super().__init__()
63
        self.time_embed_dim = base_channels * 4
64
        self.time_mlp = nn.Sequential(
65
            SinusoidalTimeEmbedding(base_channels),
66
            nn.Linear(base_channels, self.time_embed_dim),
67
            nn.SiLU(),
68
            nn.Linear(self.time_embed_dim, self.time_embed_dim),
69
        )
70

71
        # Encoder
72
        chs = [base_channels]
73
        for mult in channel_mults:
74
            chs.append(base_channels * mult)
75

76
        self.encoder = nn.ModuleList()
77
        for i in range(len(chs) - 1):
78
            self.encoder.append(
79
                ResidualBlock(chs[i], chs[i + 1], self.time_embed_dim)
80
            )
81

82
        # Bottleneck
83
        self.bottleneck = ResidualBlock(chs[-1], chs[-1], self.time_embed_dim)
84

85
        # Decoder
86
        self.decoder = nn.ModuleList()
87
        for i in reversed(range(len(chs) - 1)):
88
            self.decoder.append(
89
                ResidualBlock(chs[i + 1], chs[i], self.time_embed_dim)
90
            )
91

92
        # 输出层
93
        self.final = nn.Sequential(
94
            nn.GroupNorm(32, base_channels),
95
            nn.SiLU(),
96
            nn.Conv2d(base_channels, in_channels, 3, padding=1),
97
        )
98

99
    def forward(self, xt, t):
100
        """返回噪声预测 ε_θ(x_t, t)。"""
101
        t_emb = self.time_mlp(t)
102

103
        # Encoder
104
        hs = []
105
        for block in self.encoder:
106
            xt = block(xt, t_emb)
107
            hs.append(xt)
108

109
        # Bottleneck
110
        xt = self.bottleneck(xt, t_emb)
111

112
        # Decoder with skip connections
113
        for block in self.decoder:
114
            xt = torch.cat([xt, hs.pop()], dim=1)
115
            xt = block(xt, t_emb)
116

117
        return self.final(xt)

11. DDPM 的局限与后续发展#

11.1 DDPM 的三大局限#

局限	描述	影响
推理速度	需要 1000 步，生成极慢	实际应用受限
隐空间缺失	直接在像素空间加噪，计算量大	512×512 以上极慢
无条件生成	文本条件需要额外引导机制	CFG 引入计算开销

11.2 DDPM 之后的演进时间线#

1
2020 DDPM (Ho et al.) — MSE 训练, 1000 步推理
2
  │
3
2021 DDIM (Song et al.) — 非马尔可夫, 20-50 步
4
  │
5
2021 Classifier-free Guidance (Ho & Salimans)
6
  │
7
2022 Latent Diffusion (Rombach et al.) — VAE 压缩到隐空间 ★
8
  │
9
2022 Score SDE (Song et al.) — 统一 SDE 框架
10
  │
11
2022 Consistency Models (Song et al.) — 蒸馏到 1 步
12
  │
13
2022 DiT (Peebles & Xie) — Transformer 替换 UNet
14
  │
15
2023 SDXL (Rombach et al.) — 级联扩散, 1024px
16
  │
17
2024 Rectified Flow (Liu et al.) — 最优传输, 直线路径
18
  │
19
2024 SD3 (Esser et al.) — MMDiT 双流架构 ★
20
  │
21
2024 FLUX (Black Forest Labs) — RF + MMDiT, 12B

12. 总结#

12.1 核心公式速查#

名称	公式
前向加噪	$x_t = \sqrt{\bar\alpha_t} x_0 + \sqrt{1 - \bar\alpha_t} \epsilon$
逆向均值	$\mu_t = \frac{1}{\sqrt{\alpha_t}} \left(x_t - \frac{\beta_t}{\sqrt{1 - \bar\alpha_t}} \epsilon_\theta\right)$
训练目标	$\mathbb{E}_{t, x_0, \epsilon}[\, \\| \epsilon - \epsilon_\theta(x_t, t) \\|^2\,]$
DDIM 采样	$x_{t-1} = \sqrt{\bar\alpha_{t-1}} \hat{x}_0 + \sqrt{1 - \bar\alpha_{t-1}} \epsilon_\theta$
CFG	$\hat\epsilon = (1 + w) \epsilon_c - w \epsilon_u$
Score 联系	$\epsilon_\theta = -\sigma_t \nabla_{x_t} \log p_t(x_t)$

12.2 一句话总结#

DDPM 用”预设前向 + 变分推断 + 简单 MSE”的三角组合，绕过了纯 Score Matching 的计算难题，把扩散模型从理论可行的方法变成了实际可训练的生成模型——这是 2020 年最重要的生成建模突破之一，也是后续所有扩散改进（Latent Diffusion、DiT、MMDiT、Rectified Flow、FLUX）的起点。

12.3 推荐资源#

1
论文:
2
  - DDPM (Ho et al., 2020): "Denoising Diffusion Probabilistic Models"
3
  - DDIM (Song et al., 2021): "Denoising Diffusion Implicit Models"
4
  - Score SDE (Song et al., 2021): "Score-Based Generative Modeling through SDEs"
5
  - CFG (Ho & Salimans, 2022): "Classifier-Free Diffusion Guidance"
6
  - Latent Diffusion (Rombach et al., 2022): "High-Resolution Image Synthesis with Latent Diffusion Models"
7

8
代码:
9
  - hojonathanho/diffusion (官方实现)
10
  - openai/guided-diffusion (ADM)
11
  - CompVis/stable-diffusion (LDM)
12
  - lucidrains/DDPM-pytorch
13

14
数学参考:
15
  - Lilian Weng 博客: "What are Diffusion Models?" (最好的技术解读)
16
  - Angus Gilmour 博客: "Deriving the DDPM Training Objective"

Federico