深入理解扩散模型 (Diffusion Model)：从原理到实践

阶段	时间步	描述	状态
原始	T=0	干净的数据	清晰的图像/信号
早期	T=250	轻度噪声	细节开始模糊
中期	T=500	中度噪声	主要结构仍可见
后期	T=750	重度噪声	仅剩轮廓
最终	T=1000	纯噪声	完全随机

前向过程（训练时）：从 T=0 到 T=T，逐渐添加噪声 逆向过程（生成时）：从 T=T 到 T=0，逐步去除噪声生成图像

2. 前向扩散过程 (Forward Process)#

2.1 数学定义#

前向过程是一个预设的马尔可夫链，它逐步向数据添加高斯噪声。假设原始数据为 $x_0$ ，前向过程定义为：

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

其中 $\beta_t$ 是第 $t$ 步的噪声调度参数， $0 < \beta_1 < \beta_2 < \cdots < \beta_T < 1$ 。

2.2 关键性质：可直接采样任意时刻#

得益于高斯噪声的重参数化性质，我们可以直接计算出任意时刻 $t$ 的噪声图像 $x_t$ ：

x_t = \sqrt{\bar{\alpha}_t} x_0 + \sqrt{1 - \bar{\alpha}_t} \epsilon

其中：

$\epsilon \sim \mathcal{N}(0, I)$ 是标准高斯噪声
$\alpha_t = 1 - \beta_t$
$\bar{\alpha}_t = \prod_{i=1}^{t} \alpha_i$

这个性质非常关键：我们不需要逐步迭代就能直接得到任意时刻的噪声图像，这大大简化了训练过程。

2.3 前向过程代码实现#

1
import torch
2
import numpy as np
3

4
def forward_diffusion(x0, t, betas):
5
    """
6
    前向扩散过程：直接从 x0 计算 xt
7
    x0: 原始图像 tensor
8
    t: 时间步
9
    betas: 噪声调度序列
10
    """
11
    alphas = 1 - betas
12
    alpha_bars = torch.cumprod(alphas, dim=0)
13

14
    # 确保 t 是一维张量
15
    t = t.unsqueeze(-1) if t.dim() > 0 else t
16

17
    # 采样噪声
18
    epsilon = torch.randn_like(x0)
19

20
    # 重参数化采样
21
    sqrt_alpha_bar = torch.sqrt(alpha_bars[t])
22
    sqrt_one_minus_alpha_bar = torch.sqrt(1 - alpha_bars[t])
23

24
    xt = sqrt_alpha_bar * x0 + sqrt_one_minus_alpha_bar * epsilon
25

26
    return xt, epsilon

3. 逆向去噪过程 (Reverse Process)#

3.1 学习逆向分布#

逆向过程是扩散模型的核心——我们需要一个神经网络来学习 $p_\theta(x_{t-1} | x_t)$ 。

理论上，逆向分布也是高斯分布：

p_\theta(x_{t-1} | x_t) = \mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))

其中 $\mu_\theta$ 和 $\Sigma_\theta$ 是由神经网络预测的参数。

3.2 简化预测目标#

为了简化训练，DDPM 论文提出了一个关键技巧：让网络预测噪声 $\epsilon_\theta$ ，而不是直接预测均值。

由前向过程的公式：

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}}

因此，预测噪声就等价于预测原始图像，简化了学习目标。

3.3 逆向过程代码实现#

1
import torch
2
import torch.nn.functional as F
3

4
def p_sample(model, xt, t, betas):
5
    """
6
    从 xt 采样 xt-1
7
    """
8
    t = torch.tensor([t])
9

10
    # 模型预测噪声
11
    epsilon_theta = model(xt, t)
12

13
    # 提取参数
14
    beta_t = betas[t]
15
    alpha_t = 1 - beta_t
16
    alpha_bar_t = alpha_t.prod()  # 简化的 cumprod
17

18
    # 计算均值
19
    mean = (1 / torch.sqrt(alpha_t)) * (
20
        xt - (beta_t / torch.sqrt(1 - alpha_bar_t)) * epsilon_theta
21
    )
22

23
    # 如果是最后一步，直接返回均值
24
    if t[-1] == len(betas) - 1:
25
        return mean
26

27
    # 计算方差
28
    variance = beta_t
29

30
    # 采样
31
    noise = torch.randn_like(xt)
32
    return mean + torch.sqrt(variance) * noise
33

34
def reverse_process(model, shape, betas):
35
    """
36
    从纯噪声生成图像
37
    """
38
    # 从纯噪声开始
39
    xt = torch.randn(shape)
40

41
    # 逐步去噪
42
    for t in reversed(range(len(betas))):
43
        xt = p_sample(model, xt, t, betas)
44

45
    return xt

4. 噪声调度 (Noise Scheduling)#

4.1 为什么需要噪声调度？#

噪声调度（Noise Scheduling）决定了噪声如何随时间步增加——它直接影响模型的训练稳定性和生成质量。

4.2 常见的调度策略#

调度类型	特点	应用
线性 (Linear)	均匀递增	DDPM
余弦 (Cosine)	平滑衰减	Stable Diffusion
二次 (Quadratic)	前期慢后期快	early β scheduling
Scaled Linear	缩放线性	OpenAI guided diffusion

4.3 噪声调度可视化#

4.3 噪声调度对比#

不同调度策略下噪声水平的变化对比：

1
噪声水平
2
  1.0 │                                                    ▓▓▓▓▓▓▓▓▓▓
3
      │                                          ▓▓▓▓▓▓▓▓
4
  0.8 │                                 ▓▓▓▓▓▓▓▓
5
      │                        ▓▓▓▓▓▓▓▓         ← 二次 (Quadratic)
6
  0.6 │               ▓▓▓▓▓▓▓▓         ●───●───●───●───●───●───●───●───●
7
      │      ▓▓▓▓▓▓▓▓        ← 余弦 (Cosine)  ─────────────────────────
8
  0.4 │ ▓▓▓▓▓▓▓▓  ●───●───●───●───●───●───●───●───●───●───●───●───●───●───●
9
      │          ← 线性 (Linear)    ────────────────────────────────
10
  0.2 │
11
      │
12
  0.0 │●───────────────────────────────────────────────────────────────
13
      └────────────────────────────────────────────────────────────────
14
        T=0                                                  T=1000

调度类型	特点	前期噪声增长	后期噪声增长	适用场景
线性 (Linear)	均匀递增	慢	快	DDPM 原始论文
余弦 (Cosine)	平滑衰减	很慢	很快	Stable Diffusion
二次 (Quadratic)	前期慢后期快	很慢	很快	早期实验

推荐：现代扩散模型（如 Stable Diffusion）普遍采用余弦调度，因为它在训练前期保持较高的信号水平，有助于模型学习有意义的特征。

4.4 调度策略代码对比#

1
def get_betas_schedule(schedule_type, T, beta_start=1e-4, beta_end=0.02):
2
    """生成不同类型的噪声调度序列"""
3

4
    if schedule_type == "linear":
5
        # 线性调度：从 beta_start 线性增加到 beta_end
6
        return torch.linspace(beta_start, beta_end, T)
7

8
    elif schedule_type == "cosine":
9
        # 余弦调度：更平滑的过渡
10
        steps = T + 1
11
        x = torch.linspace(0, T, steps)
12
        alphas_cumprod = torch.cos(((x / T) + 0.008) * torch.pi / 2) ** 2
13
        alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
14
        betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
15
        return torch.clip(betas, beta_start, beta_end)
16

17
    elif schedule_type == "quadratic":
18
        # 二次调度：前期慢后期快
19
        return beta_start + (beta_end - beta_start) * (torch.linspace(0, 1, T) ** 2)

5. U-Net 骨干网络#

5.1 为什么选择 U-Net？#

大多数扩散模型使用 U-Net 作为噪声预测网络，原因在于：

编码器-解码器结构：能捕捉多尺度特征
跳跃连接：保留低级细节信息，对重建图像至关重要
对称性：编码器和解码器镜像对称，简化设计

5.2 U-Net 在扩散模型中的改进#

1
class DiffusionUNet(nn.Module):
2
    def __init__(self, in_channels=3, out_channels=3, base_channels=128):
3
        super().__init__()
4

5
        # 编码器（下采样）
6
        self.enc1 = ResidualBlock(in_channels, base_channels)
7
        self.enc2 = ResidualBlock(base_channels, base_channels * 2)
8
        self.enc3 = ResidualBlock(base_channels * 2, base_channels * 4)
9

10
        # 瓶颈
11
        self.bottleneck = ResidualBlock(base_channels * 4, base_channels * 4)
12

13
        # 解码器（上采样）
14
        self.dec1 = ResidualBlock(base_channels * 8, base_channels * 2)  # 拼接跳跃连接
15
        self.dec2 = ResidualBlock(base_channels * 4, base_channels)
16
        self.dec3 = ResidualBlock(base_channels * 2, out_channels)
17

18
        # 时间步嵌入
19
        self.time_mlp = nn.Sequential(
20
            SinusoidalPosEmb(base_channels),
21
            nn.Linear(base_channels, base_channels * 4),
22
            nn.SiLU(),
23
            nn.Linear(base_channels * 4, base_channels)
24
        )
25

26
    def forward(self, x, t):
27
        # 编码
28
        e1 = self.enc1(x)
29
        e2 = self.enc2(F.max_pool2d(e1, 2))
30
        e3 = self.enc3(F.max_pool2d(e2, 2))
31

32
        # 瓶颈 + 时间嵌入
33
        b = self.bottleneck(e3)
34
        t_emb = self.time_mlp(t)
35

36
        # 解码（带跳跃连接）
37
        d1 = self.dec1(torch.cat([F.interpolate(b, e3.shape[2:], mode='nearest'), e3], dim=1))
38
        d2 = self.dec2(torch.cat([F.interpolate(d1, e2.shape[2:], mode='nearest'), e2], dim=1))
39
        d3 = self.dec3(torch.cat([F.interpolate(d2, e1.shape[2:], mode='nearest'), e1], dim=1))
40

41
        return d3

5.3 关键组件#

残差块 (Residual Block)：包含 Group Normalization 和 SiLU 激活
时间步嵌入 (Time Embedding)：使用正弦位置编码让网络感知当前时间步
注意力机制：在高级特征上加入自注意力，增强全局建模能力

6. 条件扩散 (Conditional Diffusion)#

6.1 分类器引导 (Classifier Guidance)#

为了让扩散模型根据条件生成（如文本描述），早期方法使用分类器引导：

\hat{\epsilon} = \epsilon_\theta(x_t, t) + s \cdot \nabla_x \log p_\phi(y|x_t)

其中 $s$ 是引导强度， $\nabla_x \log p_\phi(y|x_t)$ 是分类器梯度。

6.2 无分类器引导 (Classifier-Free Guidance)#

无分类器引导是更优雅的方案，不需要额外的分类器：

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

其中：

$c$ 是条件（如文本嵌入）
$\emptyset$ 是空条件（无条件）
$w$ 是引导强度（通常 5-15）

引导强度的经验值

$w = 1$ ：无引导
$w = 3-5$ ：轻度引导，保留多样性
$w = 7-10$ ：中度引导，平衡质量与多样性
$w = 12-15$ ：强度引导，高质量但多样性降低

6.3 交叉注意力机制#

在 Stable Diffusion 等模型中，文本条件通过交叉注意力机制注入：

1
文本嵌入 → Cross-Attention → U-Net 特征

这允许模型在生成过程中”关注”文本的不同部分。

7. 扩散模型 vs GAN#

特性	扩散模型	GAN
训练稳定性	稳定，使用简单的 MSE 损失	不稳定，需要精心平衡对抗训练
生成多样性	高	中等，容易发生模式坍缩
推理速度	慢（需要多步迭代）	快（单步生成）
损失函数	简单的重构/MSE 损失	对抗损失
理论基础	渐近理论	博弈论
超参数敏感性	中等	高

推理加速

虽然扩散模型推理慢，但有多种加速方法：

DDIM：使用非马尔可夫噪声调度，减少步数到 20-50 步
LCM (Latent Consistency Models)：直接在潜在空间生成，4-8 步即可
SDXL-Turbo：单步或极少步生成

8. 现代扩散模型应用#

8.1 图像生成#

模型	特点	开源
Stable Diffusion	Latent Diffusion，高效	✅
DALL-E 3	GPT-4V 驱动，高保真	❌
Imagen	超分辨率级联，文字渲染强	❌
Midjourney	艺术风格优化	❌
SDXL	1024px 大图支持	✅

8.2 视频生成#

Sora：OpenAI 的视频生成模型，基于扩散变换器
Stable Video Diffusion：Stability AI 的开源视频扩散
Runway Gen-2/3：创意视频生成

8.3 3D 生成#

Point-E：OpenAI 的 3D 点云生成
DreamFusion：Google 的 3D 物体生成
Zero-1-to-3：从单图重建 3D

8.4 音频合成#

AudioLDM：基于扩散的音频生成
Riffusion：音乐生成
SPEAR-TTS：文本转语音

9. 核心公式总结#

前向过程（第 t 步）：

x_t = \sqrt{\bar{\alpha}_t} x_0 + \sqrt{1 - \bar{\alpha}_t} \epsilon, \quad \epsilon \sim \mathcal{N}(0, I)

逆向过程均值：

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

无分类器引导：

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

10. 总结与展望#

扩散模型的核心创新在于：

渐进式生成：通过多步迭代逐步去除噪声，生成高质量样本
稳定训练：简单的 MSE 损失替代对抗训练
条件生成：通过引导机制实现灵活的条件控制
潜在空间：Latent Diffusion 大幅提升效率

当前挑战：

推理速度仍有提升空间
长视频生成的一致性问题
3D 内容生成的质量和效率

未来方向：

端到端的单步或少步模型
扩散模型与语言模型的深度融合
多模态统一生成框架

参考资料#

Ho, J., et al. (2020). “Denoising Diffusion Probabilistic Models.” NeurIPS.
Rombach, R., et al. (2022). “High-Resolution Image Synthesis with Latent Diffusion Models.” CVPR.
Ho, J., et al. (2022). “Cascaded Diffusion Models for High Fidelity Image Generation.” JMLR.
Ho, J., & Salimans, T. (2022). “Classifier-Free Diffusion Guidance.” NeurIPS Workshop.
Peebles, W., & Xie, Y. (2023). “Scalable Diffusion Models with Transformers.” ICCV.