像素炼金术：从 GAN 到 Diffusion，AI 图像生成的进化之路与硬核原理解析

Posted on In

编者按： 从模糊不清的噪点，到以假乱真的照片；从漫长的等待，到输入提示词按下回车的瞬间惊艳。AI 图像生成技术在过去几年里经历了一场堪比“寒武纪大爆发”的进化。今天，我们就来拨开 Midjourney 和 Stable Diffusion 背后的魔法迷雾，硬核解析这场从 GAN 到 Diffusion 的技术革命。

引言：创造力的机器重塑

几年前，如果有人告诉你，机器可以根据一句“一只在赛博朋克城市里戴着墨镜的猫”瞬间生成一张大师级别的插画，你可能会觉得这是科幻小说里的情节。然而，今天这已经成为数百万设计师、开发者甚至普通人的日常。

在这场视觉盛宴的背后，并不是一蹴而就的魔法。AI 图像生成的发展史，是一部充满天才洞察的算法进化史。在这条长河中，有两位绝对的“主角”：生成对抗网络（GAN）和扩散模型。

理解它们，不仅仅是理解两篇顶会的 Best Paper，更是理解 AI 是如何从“模仿数据”走向“理解世界”的。本文将带你深入这两大模型的内部机制，看看像素是如何被“炼制”出来的。

第一阶段：左右互搏的奇迹 —— GAN（生成对抗网络）

2014 年，Ian Goodfellow 提出了 GAN（Generative Adversarial Networks）。在很长一段时间里，GAN 是图像生成领域的绝对霸主，从 StyleGAN 到 CycleGAN，它在无监督学习领域掀起了一场风暴。

1. 核心思想：“伪造者”与“鉴定专家”的猫鼠游戏

GAN 的原理非常符合人类的直觉。想象一个制造假钞的骗子（生成器，Generator）和一个鉴别假钞的警察（判别器，Discriminator）。

  • 生成器： 负责接收一个随机噪声，试图将其转换为逼真的图像。
  • 判别器： 负责接收图像，并判断这张图是来自真实数据集，还是由生成器伪造的。

在训练过程中，两者互相博弈。生成器不断提升造假技术以骗过判别器，判别器不断提升鉴别能力以识破生成器。这就是所谓的“对抗”。当达到纳什均衡时，判别器无法分辨真假（输出概率为 0.5），此时生成器就已经具备了强大的图像生成能力。

2. 硬核数学推导与损失函数

GAN 的目标函数是一个极小极大博弈问题：

min⁡Gmax⁡DV(D,G)=Ex∼pdata(x)[log⁡D(x)]+Ez∼pz(z)[log⁡(1−D(G(z)))]\min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))]

  • 对于判别器 DD：我们要最大化这个函数。即让 D(x)D(x)（对真图的判断）趋近于 1，让 D(G(z))D(G(z))（对假图的判断）趋近于 0。
  • 对于生成器 GG：我们要最小化这个函数。即让 D(G(z))D(G(z)) 趋近于 1，让判别器把自己的假货当成真品。

3. GAN 的阿喀琉斯之踵

尽管 GAN 能生成极其清晰的图像，但它有几个致命的缺点：

  1. 训练极其不稳定： 由于是动态博弈，很容易出现“模式崩溃”。生成器可能发现只要生成某一种能骗过判别器的图（比如全是模糊的人脸），就可以躺平，导致输出多样性极差。
  2. 难以控制： 随机噪声 zz 与生成图像的特征之间没有明确的对应关系，很难通过控制 zz 来精准改变图像的某个细节（比如“让眼睛变大”）。

第二阶段：打破重组的艺术 —— 扩散模型

就在 GAN 陷入瓶颈时，扩散模型横空出世。2020 年，Jonathan Ho 等人发表了 DDPM（Denoising Diffusion Probabilistic Models），彻底改写了图像生成的游戏规则。如今的 Midjourney、DALL-E 3 和 Stable Diffusion，其底层核心无一例外都是扩散模型。

1. 核心思想：“破坏”与“重建”

如果说 GAN 是对抗，那么 Diffusion 就是合作。它的灵感来源于物理学中的热力学扩散现象（墨水滴入水中最终完全混合无法还原）。

Diffusion 分为两个过程：

  • 前向过程（加噪）： 给一张清晰的原图，一步步给它加上高斯噪声，直到它完全变成一张纯高斯噪声图（就像把一滴墨水搅拌到完全均匀）。这个过程是确定且不可逆的。
  • 逆向过程（去噪）： 这是魔法发生的地方。我们训练一个神经网络，让它学习如何从一张纯噪声图中，一步步地把噪声剔除，最终还原出一张清晰的、从未见过的全新图像。

2. 硬核数学原理：马尔可夫链与重参数化

前向过程：
给定真实图像 x0x_0，我们定义一个时间步 tt（从 0 到 TT）。每一步我们向图像中添加微小的方差为 βt\beta_t 的高斯噪声。这是一个马尔可夫链过程：

q(xt∣xt−1)=N(xt;1−βtxt−1,βtI)q(x_t | x_{t-1}) = \mathcal{N}(x_t; \sqrt{1 - \beta_t}x_{t-1}, \beta_t I)

DDPM 的一个极其优雅的数学特性是：我们可以直接从 x0x_0 采样得到任意时刻 tt 的噪声图 xtx_t，而不需要一步步计算。利用重参数化技巧：

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

其中 αˉt=∏s=1t(1−βs)\bar{\alpha}_t = \prod_{s=1}^t (1 - \beta_s)，ϵ∼N(0,I)\epsilon \sim \mathcal{N}(0, I) 是纯高斯噪声。

逆向过程与损失函数：
在逆向过程中，模型的任务是预测每一步加入的噪声。我们通常使用 U-Net 作为噪声预测器 ϵθ\epsilon_\theta。

损失函数出奇的简单，本质上是预测噪声与真实噪声之间的均方误差（MSE）：

Lsimple=Et,x0,ϵ[∣∣ϵ−ϵθ(xt,t)∣∣2]\mathcal{L}_{simple} = \mathbb{E}_{t, x_0, \epsilon} \left[ ||\epsilon - \epsilon_\theta(x_t, t)||^2 \right]

3. 为什么 Diffusion 战胜了 GAN？

  • 训练极其稳定： 不再有对抗网络的动态博弈，模型只是在简单地做“减去噪声”的回归任务，不会发生模式崩溃。
  • 惊人的多样性： 因为是从高斯噪声开始逐步去噪，初始状态的微小差异都会导致最终生成完全不同但都符合逻辑的图像，完美覆盖了数据分布的各个角落。
  • 极其适合引入文本条件： 这是 Diffusion 统治 AIGC 的关键。我们很容易通过 Cross-Attention（交叉注意力机制）将文本特征注入到 U-Net 中，引导去噪过程。

第三阶段：工业革命的引擎 —— 潜在扩散模型（LDM）与 Stable Diffusion

虽然 DDPM 效果好，但它有一个致命缺点：太慢且太吃显存。因为它直接在像素空间（比如 512x512x3）进行大量的矩阵运算。

Stable Diffusion（潜在扩散模型）的出现解决了这个问题，它将扩散模型推向了普通人的消费级显卡。

1. 核心创新：感知压缩

Stable Diffusion 引入了变分自编码器来进行空间压缩。

  1. 编码器： 将 512x512x3 的高清图像压缩到一个极小的潜在空间（Latent Space，比如 64x64x4）。
  2. Diffusion 过程： 在这个极小的 64x64x4 的潜在空间中进行复杂的加噪和去噪运算。计算量瞬间缩小了几十倍！
  3. 解码器： 去噪完成后，将潜在表示解码还原回 512x512x3 的像素空间。

2. 架构全解析：文本是如何控制图像的？

Stable Diffusion 不仅仅是 Diffusion，它是一个庞大的系统，包含三大核心组件：

  • Text Encoder（文本编码器）： 通常使用 CLIP 的 Text Transformer，将你的 Prompt（如“一只可爱的狗”）转化为高维特征向量。
  • U-Net（噪声预测器）： 负责 Latent 空间的去噪。这里使用了 Cross-Attention 机制，让 U-Net 在预测噪声时，时刻“参考”文本向量的意见。
  • VAE（自编码器）： 负责图像的压缩与重建。

代码实战：动手实现一个简单的 Diffusion 模型去噪网络

为了让大家更直观地感受 Diffusion 的魔力，我们使用 PyTorch 编写一个极简版的 Diffusion 噪声预测（U-Net 的核心逻辑与加噪/去噪过程）。

注：完整训练需要大量数据和算力，以下代码展示了核心的前向加噪与反向去噪的数学计算逻辑。

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# ==========================================
# 1. 定义一个极简的噪声预测网络 (实际应用中是复杂的 U-Net)
# ==========================================
class SimpleNoisePredictor(nn.Module):
    def __init__(self):
        super().__init__()
        # 这里的网络非常简化，实际 SD 拥有几百层 ResNet 和 Attention
        self.net = nn.Sequential(
            nn.Linear(32 * 32 + 1, 128), # 输入: 图片 + 时间步 t
            nn.ReLU(),
            nn.Linear(128, 128),
            nn.ReLU(),
            nn.Linear(128, 32 * 32) # 输出: 预测的噪声
        )

    def forward(self, x, t):
        # x: [batch_size, 32*32], t: [batch_size, 1]
        x_flat = x.view(x.size(0), -1)
        t_flat = t.view(t.size(0), 1)
        inp = torch.cat([x_flat, t_flat], dim=1)
        return self.net(inp).view(x.size(0), 1, 32, 32)

# ==========================================
# 2. 扩散模型核心数学计算
# ==========================================
class DiffusionProcess:
    def __init__(self, num_timesteps=1000):
        self.num_timesteps = num_timesteps
        # 初始化 Beta 调度表
        self.betas = torch.linspace(0.0001, 0.02, num_timesteps)
        self.alphas = 1.0 - self.betas
        # 计算累积乘积 alpha_bar
        self.alpha_bar = torch.cumprod(self.alphas, dim=0)

    # 前向过程：直接给定 x_0 和 t，计算带噪图片 x_t (重参数化技巧)
    def add_noise(self, x_0, t):
        noise = torch.randn_like(x_0)
        # 获取对应的 alpha_bar_t
        alpha_bar_t = self.alpha_bar[t].view(-1, 1, 1, 1)
        
        # 核心公式: x_t = sqrt(alpha_bar_t) * x_0 + sqrt(1 - alpha_bar_t) * noise
        x_t = torch.sqrt(alpha_bar_t) * x_0 + torch.sqrt(1 - alpha_bar_t) * noise
        return x_t, noise

# ==========================================
# 3. 模拟训练与推理流程 (伪代码演示逻辑)
# ==========================================
if __name__ == "__main__":
    # 假设我们的真实图片是 1x32x32 的随机张量 (代表手写数字等)
    x_0 = torch.randn(4, 1, 32, 32) 
    
    model = SimpleNoisePredictor()
    diffusion = DiffusionProcess(num_timesteps=1000)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)

    # --- 训练阶段 ---
    model.train()
    for epoch in range(100): # 仅作演示，epoch设小
        optimizer.zero_grad()
        
        # 1. 随机采样时间步 t
        t = torch.randint(0, diffusion.num_timesteps, (x_0.size(0),))
        
        # 2. 前向加噪，获得 x_t 和真实的噪声
        x_t, true_noise = diffusion.add_noise(x_0, t)
        
        # 3. 让模型预测噪声
        # 将 t 归一化到 [0, 1] 之间以输入网络
        t_norm = t.float() / diffusion.num_timesteps 
        predicted_noise = model(x_t, t_norm)
        
        # 4. 计算 MSE Loss (预测噪声 vs 真实噪声)
        loss = nn.MSELoss()(predicted_noise, true_noise)
        
        loss.backward()
        optimizer.step()

    print("Training finished. Model learned to predict noise!")

    # --- 推理/生成阶段 (反向过程) ---
    # 实际推理需要从 t=T 开始，逐步去噪到 t=0
    # 这里仅展示数学公式逻辑：
    model.eval()
    with torch.no_grad():
        # 从纯高斯噪声开始
        x_t = torch.randn(1, 1, 32, 32) 
        
        # 反向迭代 (此处为极度简化的单步演示，实际需要从 T 循环到 0)
        # 伪代码：预测噪声 -> 根据公式减去噪声，得到 x_{t-1}
        print("Starting reverse denoising process to generate new image...")

在这段代码中，我们看到了 Diffusion 模型最核心的哲学：

  1. 不预测图像本身，而是预测污染图像的“噪声”。
  2. 重参数化技巧使得我们可以在任意时间步 tt 直接获取带噪图像，极大提高了训练效率。

第四阶段：AIGC 的未来狂想

从 GAN 的对抗博弈，到 Diffusion 的打破重组，AI 图像生成的进化不仅仅是算法的更替，更是计算哲学的改变。我们不再是强求机器直接“画出”结果，而是教会机器理解事物从有序到无序的规律，并赋予它们逆转这一过程的能力。

如今，随着 DiT (Diffusion Transformer) 架构的崛起（Sora 和 Stable Diffusion 3 的核心），Diffusion 正在与另一种强大的神经网络架构 Transformer 融合，向着更高清、更长（视频生成）、更具物理世界常识的方向迈进。

我们正处在一个激动人心的时代。GAN 点燃了 AIGC 的火种，而 Diffusion 则将其燎原。下一次像素炼金术的突破，也许就在你阅读这篇文章的此刻，正在某间实验室里悄然发生。

参考资料与推荐阅读：

  1. Generative Adversarial Nets (Goodfellow et al., 2014)
  2. Denoising Diffusion Probabilistic Models (Ho et al., 2020)
  3. High-Resolution Image Synthesis with Latent Diffusion Models (Rombach et al., 2021) - Stable Diffusion 基础论文
  4. What are Diffusion Models? - Lilian Weng’s Blog (强烈推荐的硬核技术博客)