炼丹手的奇幻之旅：从 GAN 到 Diffusion Model，AI 图像生成的进化史

Posted on In

引言：曾几何时，AI 生成的图片还只是一堆充满马赛克和诡异光影的“赛博涂鸦”。而如今，只要你在 Midjourney 或 Stable Diffusion 中敲下几个提示词，几秒钟内，一幅足以让顶级画师都为之惊叹的完美画作便跃然屏上。这场视觉革命的背后，绝非一蹴而就。从 GAN 的“左右互搏”到 Diffusion 的“破坏与重建”，AI 图像生成经历了一次又一次的范式转移。今天，让我们拨开繁复的论文迷雾，深入探究这条从 GAN 到 Diffusion Model 的进化之路。

第一阶段：拓荒时代与 GAN 的“左右互搏”

2014 年，Ian Goodfellow 提出了生成对抗网络（GAN, Generative Adversarial Networks），这被认为是深度学习生成领域的一个重要里程碑。GAN 的核心思想非常优雅且具有博弈论的浪漫色彩：让两个神经网络互相“掐架”。

1. GAN 的核心架构：造假者与鉴赏家

GAN 由两个部分组成：

  • 生成器：就像一个高明的“造假者”，它的任务是从随机噪声中生成逼真的图像，试图以假乱真。
  • 判别器：就像一个经验丰富的“鉴赏家”，它的任务是接收一张图片，并判断这张图片是来自真实数据集，还是由生成器捏造的。

两者在训练过程中不断博弈：生成器拼命提升造假技术骗过判别器，判别器则拼命提升鉴别能力识破生成器。最终，当判别器无法分辨真假（输出概率为 0.5）时，生成器就学到了真实数据的分布，能够生成高质量的图像。

早期的 PyTorch 伪代码长这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import torch
import torch.nn as nn

# 简单的生成器
class Generator(nn.Module):
    def __init__(self, latent_dim):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 28*28), # 假设生成 MNIST 大小的图像
            nn.Tanh()
        )
    def forward(self, z):
        return self.model(z)

# 简单的判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(28*28, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 1),
            nn.Sigmoid() # 输出真假概率
        )
    def forward(self, img):
        return self.model(img)

2. GAN 的繁荣与困境

在随后的几年里，GAN 迎来了大爆发，从 DCGAN 到 StyleGAN，生成图像的分辨率从 32x32 一路飙升到 1024x1024，甚至能够生成逼真的人脸。

然而，GAN 有着几个致命的“阿喀琉斯之踵”：

  1. 模式崩解：生成器可能会发现只要生成某几张绝对安全的图片就能骗过判别器，于是它丧失了多样性，只生成相同的人脸或相似的风景。
  2. 训练极不稳定：生成器和判别器需要极其精细的平衡。如果判别器太强，生成器会彻底摆烂（梯度消失）；如果判别器太弱，生成器会乱造一通。
  3. 缺乏多样性控制：在 GAN 的隐空间中，很难做到对图像特征的精确、连续控制。

第二阶段：黎明前的探索——VAE 与 Flow-based Models

在 GAN 大放异彩的同时，学术界并没有停止寻找更优的生成范式。其中最具代表性的是变分自编码器（VAE）和流模型。

  • VAE (Variational Autoencoders)：VAE 不再像 GAN 那样对抗，而是将图像编码到一个符合高斯分布的隐空间中，然后再从隐空间解码重建图像。它的优势是训练稳定，隐空间连续（方便插值生成），但缺点是生成的图像往往比较模糊（因为基于像素的 MSE 损失倾向于生成均值图像）。
  • Flow-based Models (流模型)：如 Glow、NICE。通过一系列可逆的数学变换，将复杂的图像分布映射为简单的正态分布。虽然数学上极其完美，能精确计算似然，但计算代价极高，且生成质量并未超越 GAN。

尽管这些方法没有成为最终的答案，但它们为后来的 Diffusion Model 提供了极其重要的数学启示（尤其是 VAE 的变分推断思想）。

第三阶段：范式转移——Diffusion Model 的“加噪与去噪”

2020 年，Jonathan Ho 等人发表了著名的 DDPM（Denoising Diffusion Probabilistic Models）论文，标志着 Diffusion 模型的正式破局。随后，OpenAI、Stability AI 等公司将这一技术发扬光大，彻底终结了 GAN 在图像生成领域的统治地位。

1. 核心直觉：破坏与重建

Diffusion 的灵感源自非平衡热力学。想象你把一滴墨水滴入一杯清水中，随着时间推移，墨水逐渐扩散，最终变成一杯浑浊的灰水（信息完全丢失，变成纯噪声）。这个过程是不可逆且确定的。

Diffusion Model 的核心就在于：既然我们无法直接逆转物理定律，那我们能不能训练一个神经网络，让它一步一步地学会把这杯“灰水”还原成“墨水滴入前”的状态？

2. 前向过程：给图片“下毒”

给定一张真实的清晰图像 x0x_0，我们向其中逐步添加高斯噪声，总共添加 TT 步。每一步的加噪公式为：

xt=αtxt−1+1−αtϵx_t = \sqrt{\alpha_t} x_{t-1} + \sqrt{1 - \alpha_t} \epsilon

其中 ϵ\epsilon 是标准高斯噪声。

由于高斯分布的优良数学性质，我们不需要一步步算，可以直接从 x0x_0 得到任意时刻 tt 的加噪图像 xtx_t（重参数化技巧）：

xt=αˉtx0+1−αˉtϵx_t = \sqrt{\bar{\alpha}_t} x_0 + \sqrt{1 - \bar{\alpha}_t} \epsilon

3. 反向过程：神医“解毒”

反向过程是 Diffusion 生成的关键。我们有一个 U-Net 神经网络，它的任务是：给定加噪后的图像 xtx_t 和当前的时间步 tt，预测出上一步的图像 xt−1x_{t-1}（或者预测出加进去的噪声 ϵ\epsilon）。

训练过程极其简单粗暴：

  1. 拿一张真实图片 x0x_0。
  2. 随机选一个时间步 tt，生成纯噪声 ϵ\epsilon。
  3. 根据公式得到加噪图 xtx_t。
  4. 把 xtx_t 和 tt 喂给 U-Net，让它预测噪声。
  5. 计算 L2 Loss：Loss=∣∣ϵ−ϵθ(xt,t)∣∣2Loss = ||\epsilon - \epsilon_\theta(x_t, t)||^2。

为什么 Diffusion 比 GAN 好训？
因为它的目标极其明确、稳定！它就是一个最纯粹的回归问题（MSE Loss），不需要像 GAN 那样在对抗的纳什均衡中如履薄冰。

4. 核心代码实现

下面是一段基于 PyTorch 的简版 Diffusion 核心代码，感受一下其优雅的数学逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import torch
import torch.nn as nn
import numpy as np

class SimpleDiffusion(nn.Module):
    def __init__(self, model, image_size=64, timesteps=1000):
        super().__init__()
        self.model = model # 这通常是一个 U-Net
        self.timesteps = timesteps
        
        # 预先计算各种 beta 和 alpha 调度
        self.betas = self.linear_beta_schedule(timesteps)
        self.alphas = 1. - self.betas
        self.alphas_cumprod = torch.cumprod(self.alphas, axis=0)
        self.sqrt_alphas_cumprod = torch.sqrt(self.alphas_cumprod)
        self.sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - self.alphas_cumprod)

    def linear_beta_schedule(self, timesteps):
        # 线性 beta 调度
        beta_start = 0.0001
        beta_end = 0.02
        return torch.linspace(beta_start, beta_end, timesteps)

    def forward_process(self, x_start, t, noise=None):
        # 前向加噪过程：直接由 x_0 得到 x_t
        if noise is None:
            noise = torch.randn_like(x_start)
            
        sqrt_alphas_cumprod_t = self.sqrt_alphas_cumprod[t][:, None, None, None]
        sqrt_one_minus_alphas_cumprod_t = self.sqrt_one_minus_alphas_cumprod[t][:, None, None, None]
        
        # 公式: x_t = sqrt(alpha_bar_t) * x_0 + sqrt(1 - alpha_bar_t) * noise
        return sqrt_alphas_cumprod_t * x_start + sqrt_one_minus_alphas_cumprod_t * noise

    def train_step(self, x_start):
        # 训练步骤
        batch_size = x_start.shape[0]
        
        # 1. 随机采样时间步 t
        t = torch.randint(0, self.timesteps, (batch_size,), device=x_start.device).long()
        
        # 2. 生成真实噪声
        noise = torch.randn_like(x_start)
        
        # 3. 前向加噪得到 x_t
        x_t = self.forward_process(x_start, t, noise)
        
        # 4. 模型预测噪声
        predicted_noise = self.model(x_t, t)
        
        # 5. 计算 MSE Loss
        loss = nn.functional.mse_loss(noise, predicted_noise)
        return loss

第四阶段：工程奇迹——Latent Diffusion 与 Stable Diffusion

虽然 DDPM 解决了生成质量和训练稳定性的问题，但它有一个致命缺陷：太慢了，太吃显存了！
由于 Diffusion 是在像素空间进行加噪和去噪的，如果你要生成一张 1024x1024 的高清图，U-Net 每一步都要处理几百万个像素，并且要循环几百步（通常是 1000 步）。这在消费级显卡上是不可能完成的。

2021 年底，慕尼黑大学和 Runway 发表了 High-Resolution Image Synthesis with Latent Diffusion Models，并开源了著名的 Stable Diffusion，彻底引爆了 AI 绘画圈。

1. 潜空间的降维打击

Stable Diffusion 的核心创新在于引入了感知压缩。它不再在像素空间做 Diffusion，而是：

  1. 编码：使用一个预训练好的 VAE（变分自编码器）的 Encoder，将 512x512x3 的高清图片压缩成 64x64x4 的低维隐变量表示。
  2. Diffusion 过程：在 64x64x4 这样极小的潜空间上进行加噪和去噪！计算量呈指数级下降。
  3. 解码：去噪完成后，使用 VAE 的 Decoder 将 64x64x4 的特征图还原回 512x512x3 的像素图像。

2. 文本控制：CLIP 与 Cross-Attention

如果 AI 只能随机生成图片，那它只是个玩具。SD 的强大在于它能听懂人类的语言。
Stable Diffusion 借用了 OpenAI 的 CLIP 模型，将人类输入的文本提示词编码成特征向量。然后，在 U-Net 去噪的过程中，通过 交叉注意力机制 将文本特征注入到图像特征中。

这样一来，网络在预测“这一块应该是什么像素”时，会时刻参考着“一只戴着墨镜的赛博朋克猫”这个文本约束。

为什么 Diffusion 彻底击败了 GAN？

如果你关注近期的顶会论文数量或者工业界的落地方案，你会发现 GAN 的生存空间被严重挤压。核心原因在于：

  1. 多样性与保真度的双赢：GAN 容易模式崩解，只能生成有限类型的图；而 Diffusion 基于 Langevin 动力学采样，天生具有极强的多样性，同时通过强大的 U-Net 保证了极高的图像质量。
  2. 可控性降维打击：得益于潜空间的连续性和灵活的注意力机制，Diffusion 模型衍生出了 ControlNet（线稿控制生成）、IP-Adapter（图像风格迁移）、LoRA（特定画风微调）等极其强大的控制插件生态。这种精确且多样的控制力，是 GAN 望尘莫及的。
  3. 算力友好（训练层面）：虽然 Diffusion 推理比单次前向传播的 GAN 慢，但 Diffusion 的训练过程极其稳定，不需要繁琐的超参调节来平衡网络。这让大厂能够轻松利用海量 GPU 集群不断 Scale up 模型参数。

结语：从像素到艺术的终点与起点

从 GAN 极具想象力的左右互搏，到 VAE 的隐空间探索，再到 Diffusion Model 在潜空间中的精雕细琢，AI 图像生成的进化史，本质上是人类对高维数据分布建模能力的进化史。

当然，技术演进并未停止。如今的 Consistency Models 试图将 Diffusion 的多步采样压缩到一步；而结合大语言模型的 Sora 等视频生成模型，正在将 Diffusion 的边界拓展到时间的维度。

作为开发者和“炼丹手”，我们非常幸运能身处在这个波澜壮阔的时代。技术不再是阻挡创造力的壁垒，借助于这些开源的强大模型，每一个拥有想象力的人，都能成为数字世界的造物主。