从GAN到扩散模型：DDPM原理详解与PyTorch实现实践

生成式模型这两年的风向变化，圈内感知其实比外界看到的还要剧烈。曾经提到生成式AI，几乎所有人第一反应都是GAN，从人脸生成到超分辨率，对抗训练几乎是唯一解。但如今Diffusion扩散模型成了绝对主角，无论是图像、音频还是多模态生成，范式已经从“生成对抗博弈”转为“逐步去噪重建”。这篇文章不端着，我从最直观的类比讲起，把扩散模型的数学原理掰开揉碎，再用PyTorch一步步搭一个能跑的DDPM（Denoising Diffusion Probabilistic Models）实现，最后把我在实际训练中踩过的坑、调参的经验一并交代清楚。不管你是刚接触生成式模型的新手，还是想从GAN切到扩散模型的老手，读完应该都能建立一套清晰的操作认知。

1. 范式之争：GAN的软肋与扩散模型的接棒逻辑

1.1 GAN的三大难解之痛

GAN（Generative Adversarial Network）的核心思路是用一个生成器G和一个判别器D互相博弈：G试图生成以假乱真的样本，D则努力分辨真假。理论上这个min-max博弈的均衡点就是生成分布完全等于真实分布，现实中的操作却远没那么理想。

第一痛是训练稳定性。判别器和生成器的能力稍有失衡，损失就会剧烈震荡，甚至直接模式崩塌（Mode Collapse），生成出来的样本千篇一律。我早年调GAN做图像生成时，最头疼的就是反复调整判别器结构、学习率、标签平滑这些超参数，每次训练都像开盲盒，同一个配置换个随机种子结果可能天差地别。

第二痛是多样性缺失。GAN的生成质量往往不错，但多样性明显不足。原因在于训练目标本质上是一个分布匹配过程，生成器只要找到一条能“骗过”判别器的路径就会固守己见，导致生成结果在低维流形上反复打转。用FID（Fréchet Inception Distance）指标来评价，GAN在真实分布覆盖度上天然吃亏。

第三痛是缺乏可控性。GAN的隐空间（Latent Space）虽然能通过插值做一些语义操作，但隐空间的几何结构并不是我们期望的“均匀、连续、有语义”，需要做大量额外工作去约束。这也直接导致后续很多可控生成任务，比如把文本变成图像、把姿态变成人像，GAN做起来极其吃力。

1.2 扩散模型赢在哪里

扩散模型跟GAN完全不是一个思路。它不搞对抗，而是把生成过程定义成“加噪再除噪”两段流程：前向过程给真实图像逐步叠加高斯噪声，直到完全变成一张纯噪声图；反向过程则训练一个神经网络，从纯噪声出发一步步把图像“恢复”出来。生成问题就从一个博弈问题变成了一个去噪优化问题，核心是让网络学会“如何预测每一步的噪声”。

这个转变带来的直接好处很明显。第一是训练稳定，因为损失函数就是简单的MSE（均方误差），没有判别器，没有对抗平衡，只要数据没问题，训练过程基本不会发散。第二是多样性好，扩散模型的目标是拟合完整的数据分布，样本覆盖度明显优于GAN，这意味着FID、IS等指标上的表现更好。第三是可控性自然，因为前向过程本身就是逐步加噪的马尔可夫链，我们可以通过类别条件、文本条件来引导反向生成过程，做条件生成就像给网络多喂一个输入那么简单。

从GAN到扩散模型，本质上是把“制造逼真样本”这个目标换成了“理解数据结构”这个目标。生成器不再只盯着怎么骗过判别器，而是学会观察一张图像在不同噪声水平下是什么样子，这种更本质的建模方式让扩散模型在很多场景下都能“降维打击”GAN。

1.3 不只是画图：扩散模型的应用版图

虽然扩散模型最出圈的是图像生成，但它的应用范围远不止于此。文本到图像生成是大家最熟知的场景，从早期的低分辨率生成到现在的超高清大图，背后都是扩散模型的能力升级。除此之外，图像编辑、图像修复、超分辨率、风格迁移、视频生成、音频合成甚至蛋白质结构预测，扩散模型都有完整的落地路径。

音频领域尤其值得一提。扩散模型可以对声谱图逐步去噪，生成自然流畅的语音，也能用于音乐生成、语音克隆。视频生成则是把扩散过程从二维图像扩展到三维时空，模型需要同时去噪空间帧和时序帧，复杂度骤增但效果也是传统方法难以比拟的。

还有一个被低估的方向是科学计算领域，比如蛋白质折叠。扩散模型通过预测三维结构的残基坐标逐步去噪，能够生成以前只能在实验室里费力推断的蛋白质空间结构，这在生物医药领域的想象空间非常大。所以不要以为扩散模型只是“AI画图”的底层技术，它本质上是一种通用的数据生成框架，凡是能定义“加噪过程”的数据类型，都可以套用这套范式。

2. 先别看公式：扩散模型的直觉与类比理解

2.1 一个墨滴入水的局面：前向加噪怎么理解

想象你往一杯清水里滴入一滴墨水。一开始墨水是集中在一个小区域里，轮廓清晰，信息密度极高。随着时间推移，墨水不断扩散，颜色逐渐均匀地分布到整杯水里，最终整杯水变成淡淡的灰色，你再也看不出当初那滴墨水的任何形状。这个过程完全不可逆，原始位置信息被彻底破坏。

扩散模型的前向过程就是这个“墨水扩散”的数学版。给定一张清晰图像x₀，我们在每一步t给它叠加一点高斯噪声，经过T步之后，图像的原始信息被噪声稀释得无影无踪，得到的x_T近似服从标准正态分布，也就是一张纯噪声图。

这里有个极其重要的细节：每一步的加噪是个马尔可夫过程，也就是当前状态只依赖于上一步状态。但因为我们每一步加的都是高斯噪声，整条链可以一步到位计算，即从x₀直接算出任意t时刻的加噪结果x_t，而不需要真的一步步迭代。这个闭式解的数学基础源自高斯分布的叠加性质，也是后面代码里能高效实现前向加噪的关键。

2.2 逆时间而行：反向去噪的直觉去噪的直觉

前向过程是做“破坏”，反向过程就是学习“修复”。如果我们可以估计出每一步加噪散落的噪声ε，就能从x_t中把它减掉，恢复出一个接近x_{t-1}的图像。把这个操作从T步一直执行到第0步，就得到了生成的图像。

可以这么想：前向过程把图像推下了悬崖，反向过程是让网络一步步把图像拉回山顶。每走一步只负责最小的修正，累积起来就能完成一个极其精细的重建任务。这与GAN“一步到位生成图像”的设计形成了鲜明对比——扩散模型把困难任务拆成了上千个简单子任务，每个子任务只是去除一点噪声，网络学起来自然压力小很多。

还有一种更好的直觉：一张真实图像在各类噪声水平下的形态你是能观察到的。网络上对图像加噪去噪的研究早已有之，但扩散模型的关键革命在于，训练时它让网络看遍了所有程度的噪声，采样时它从纯噪声开始反复运用这个去噪能力。所以模型的“想象力”来自对图像结构的大量观察，而不是对抗博弈中的投机取巧。

2.3 为什么偏偏是UNet当去噪网络

去噪网络需要同时满足几个条件：第一，输入输出都是图像，所以得是像素级别的映射；第二，要能感知“当前在第几步”，同一个去噪操作在第100步和第900步本质上应该完全不同；第三，要有足够的感受野，因为去噪过程既需要局部纹理细节，也需要全局结构信息。

UNet天然满足这些需求。它的编码器-解码器结构配合跳跃连接，能把浅层的空间细节直接传递到深层解码器，避免信息在压缩过程中丢失。同时UNet的不同层天然形成了多尺度特征，既能处理局部噪声也能把握全局结构。而时间步信息通过正弦位置编码（Sinusoidal Embedding）注入到每个残差块中，让网络清楚知道自己处于哪个去噪阶段。

后来很多改进的扩散模型也尝试过用Transformer结构，比如直接基于ViT做去噪器，效果依然不错，但UNet因为参数效率更高、归纳偏置更匹配图像任务，在很长一段时间里都是扩散模型的主力骨架。做复现的时候，先用UNet打底，再逐步换骨干，是比较稳妥的路线。

3. 数学原理拆解：KL散度、重参数化与噪声预测损失

3.1 前向过程的参数化：一套优雅的闭式解

前向过程定义为一个固定的马尔可夫链。设原始图像为x₀，每一步按照预先设定的方差βₜ向x₍ₜ₋₁₎添加高斯噪声：

q(xₜ | xₜ₋₁) = N(xₜ; √(1-βₜ) xₜ₋₁, βₜ I)

这里βₜ是一个从β₁递增到β_T的方差调度表，DDPM原文用的是线性调度，从1e-4逐渐增加到0.02。因为每一步都是高斯分布，累积效果依旧高斯，我们可以直接表示出q(xₜ | x₀)。令αₜ = 1 - βₜ，ᾱₜ = ∏ₛ₌₁ᵗ αₛ，则：

q(xₜ | x₀) = N(xₜ; √(ᾱₜ) x₀, (1 - ᾱₜ) I)

这个闭式解的推导只要反复用到“两个高斯随机变量相加仍是高斯，均值相加、方差相加”这条性质。代码里通常用重参数化（Reparameterization Trick）来采样：

xₜ = √(ᾱₜ) x₀ + √(1 - ᾱₜ) ε，其中 ε ~ N(0, I)

有了这条公式，训练时不必真的循环T步去逐步加噪，直接从x₀跳到任意xₜ，效率极高。这也是扩散模型能被高效训练的关键之一。

3.2 反向过程与变分下界：为什么要最小化KL散度

反向过程同样定义为一个马尔可夫链，但它的转移核要交给神经网络去学习：

p_θ(x₍ₜ₋₁₎ | xₜ) = N(x₍ₜ₋₁₎; μ_θ(xₜ, t), Σ_θ(xₜ, t))

训练目标是最小化反向分布与真实前向后验分布之间的差异。由于真实后验q(x₍ₜ₋₁₎ | xₜ, x₀)是有闭式解的（只要我们额外知道x₀），所以每个去噪步骤的KL散度都是可以计算的。理论上我们要优化的是负对数似然的变分下界（VLB），也就是：

L_VLB = E_q [ Σₜ D_KL( q(x₍ₜ₋₁₎ | xₜ, x₀) || p_θ(x₍ₜ₋₁₎ | xₜ) ) ]

这个形式很直观：网络要学着逼近“完美的去噪分布”。变分推断的框架在这里起的作用是，把不能直接优化的对数似然，替换成一组可以逐项优化的KL散度。

3.3 简化损失函数：一切收敛到噪声预测MSE

推导的另一种路线是直接把目标简化为预测噪声。因为真实后验的均值可以写成：

μ̃ₜ = (1/√(αₜ)) ( xₜ - (βₜ/√(1-ᾱₜ)) ε )

也就是说，如果网络能预测出混合在xₜ中的噪声ε，就能还原出x₍ₜ₋₁₎的均值。把μ_θ参数化为：

μ_θ(xₜ, t) = (1/√(αₜ)) ( xₜ - (βₜ/√(1-ᾱₜ)) ε_θ(xₜ, t) )

代入KL散度并忽略掉权重项，最终所有目标都归结为让网络预测的噪声越来越接近真实混入的噪声：

L_simple = E_{t, x₀, ε} [ || ε - ε_θ( √(ᾱₜ) x₀ + √(1-ᾱₜ) ε, t ) ||² ]

这就是大家在代码里看到的那个极其简单的MSE损失。它背后的逻辑其实十分惊人：一个看似复杂的生成模型，最终只需要学习“这张被噪声污染的图里面，噪声到底是什么”这一个任务。这个简化过程我第一次读到的时候非常震撼，因为GAN里一堆对抗损失、梯度惩罚、谱归一化，到这里几乎全部消失了。

3.4 推导中容易被忽略的关键细节

有几个细节在推导过程中容易忽略，但直接影响实现的理解。第一，前向过程的方差βₜ是固定不学习的，整个训练过程只更新反向网络参数，这跟VAE把先验方差也学出来的做法不同，少了一半的优化难度。第二，KL散度中除了去噪项，还有一个先验匹配项和一个重建项，在实际训练时先验匹配项几乎没有梯度贡献，重建项在T很大时也被淡化，所以简化损失足以覆盖训练信号。第三，Σ_θ(xₜ, t)在DDPM原文中被固定为βₜ，不参与学习，但在后续改进工作中可以单独学习。理解这些细节，至少能帮你调试扩散模型时快速判断异常出在哪一个环节。

4. PyTorch从零复现：数据、UNet、训练与采样全流程

4.1 环境与依赖准备

复现DDPM不需要太重的依赖，PyTorch 1.13或2.x版本都行。我这里使用MNIST手写数字数据集做演示，因为28×28图像分辨率低，CPU能跑，GPU训练更是几分钟就能出效果。如果你想直接挑战高分辨率数据，建议先确认显存大于8GB，再把batch size调小。

代码的组织结构我分为四个模块：调度参数与加噪函数、时间嵌入、UNet骨干、训练与采样脚本。调度参数本质上只是预先算好的一堆常数，放在类里方便全局引用。

import torch import torch.nn as nn import torch.nn.functional as F import math T = 1000 beta_start, beta_end = 0.0001, 0.02 betas = torch.linspace(beta_start, beta_end, T) alphas = 1.0 - betas alphas_cumprod = torch.cumprod(alphas, dim=0) sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod) sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - alphas_cumprod)

这段代码计算了整个前向过程的累积产品。为什么要累积乘积？因为ᾱₜ表示从x₀到xₜ的信息保留比例。当t越来越大，ᾱₜ趋向于0，xₜ里几乎不再含有原始图像信息。这是整个去噪链条里的“时间表”。

4.2 数据准备与前向加噪函数

数据部分直接用torchvision加载MNIST，归一化到[-1, 1]区间。这个细节非常重要，因为最终的纯噪声x_T服从标准正态分布，如果数据本身不在零均值范围，网络从纯噪声出发生成的样本也会有整体偏置，效果会打折扣。

from torchvision import datasets, transforms transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) dataloader = torch.utils.data.DataLoader(dataset, batch_size=128, shuffle=True)

前向加噪函数直接利用闭式解一步到位完成：

def q_sample(x0, t, noise=None): if noise is None: noise = torch.randn_like(x0) sqrt_alpha = sqrt_alphas_cumprod[t].view(-1, 1, 1, 1) sqrt_one_minus_alpha = sqrt_one_minus_alphas_cumprod[t].view(-1, 1, 1, 1) return sqrt_alpha * x0 + sqrt_one_minus_alpha * noise

这里的t是长度为batch size的随机时间步向量，每个样本对应一个随机时刻。让网络一次训练看到不同噪声水平的样本，是整个训练策略的核心“课程”。

4.3 UNet核心模块实现

UNet实现我分为三个部分：时间嵌入模块、残差块、骨架结构。时间嵌入借鉴Transformer的位置编码思路，把时间步t映射成一个高维向量，再通过MLP注入到特征图。

class SinusoidalPositionEmbeddings(nn.Module): def __init__(self, dim): super().__init__() self.dim = dim def forward(self, time): half_dim = self.dim // 2 emb = math.log(10000) / (half_dim - 1) emb = torch.exp(torch.arange(half_dim, device=time.device) * -emb) emb = time[:, None] * emb[None, :] return torch.cat([emb.sin(), emb.cos()], dim=-1) class ResidualBlock(nn.Module): def __init__(self, in_channels, out_channels, time_emb_dim): super().__init__() self.time_mlp = nn.Sequential(nn.SiLU(), nn.Linear(time_emb_dim, out_channels)) self.norm1 = nn.GroupNorm(8, in_channels) self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1) self.norm2 = nn.GroupNorm(8, out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1) self.shortcut = nn.Conv2d(in_channels, out_channels, 1) if in_channels != out_channels else nn.Identity() def forward(self, x, t): h = F.silu(self.norm1(x)) h = self.conv1(h) h = h + self.time_mlp(t)[:, :, None, None] h = F.silu(self.norm2(h)) h = self.conv2(h) return self.shortcut(x) + h

为什么要GroupNorm而不是BatchNorm？因为每个样本的噪声水平不同，BatchNorm用在纯噪声上去统计batch统计量并不合适，容易引入跨样本干扰。GroupNorm对单个样本做归一化，在这个场景下稳定得多。

UNet骨架采用经典的编码器-解码器结构。编码器逐层下采样提取语义特征，解码器通过跳跃连接融合编码器各级特征恢复空间细节。

class UNet(nn.Module): def __init__(self, in_channels=1, out_channels=1, time_emb_dim=128): super().__init__() self.time_embedding = SinusoidalPositionEmbeddings(time_emb_dim) self.inc = nn.Conv2d(in_channels, 64, 3, padding=1) self.down1 = ResidualBlock(64, 64, time_emb_dim) self.down2 = ResidualBlock(64, 128, time_emb_dim) self.down3 = ResidualBlock(128, 256, time_emb_dim) self.pool = nn.MaxPool2d(2) self.mid = ResidualBlock(256, 256, time_emb_dim) self.up1 = ResidualBlock(512, 128, time_emb_dim) self.up2 = ResidualBlock(256, 64, time_emb_dim) self.up3 = ResidualBlock(128, 64, time_emb_dim) self.upsample = nn.Upsample(scale_factor=2, mode='nearest') self.outc = nn.Conv2d(64, out_channels, 3, padding=1) def forward(self, x, t): t_emb = self.time_embedding(t) x1 = self.inc(x) h1 = self.down1(x1, t_emb) h = self.pool(h1) h2 = self.down2(h, t_emb) h = self.pool(h2) h3 = self.down3(h, t_emb) h = self.mid(h3, t_emb) h = self.upsample(h) h = torch.cat([h, h2], dim=1) h = self.up1(h, t_emb) h = self.upsample(h) h = torch.cat([h, h1], dim=1) h = self.up2(h, t_emb) h = self.up3(h, t_emb) return self.outc(h)

通道拼接的时候需要注意维度对齐。编码器向下采样一次，分辨率减半，解码器上采样一次恢复分辨率，所以cat操作发生在同一分辨率层级上。这里的down1、down2、down3输出顺序是h1、h2、h3，解码方向与之对应的是h2、h1，代码里已经对齐。

4.4 训练循环：几行代码背后的深层逻辑

训练循环看起来非常简单，几乎只有几行代码。每次迭代随机采样t，随机采样噪声ε，用闭式解构造xₜ，让模型预测噪声ε，然后计算MSE损失。

def train(model, dataloader, optimizer, epochs, device): model.train() for epoch in range(epochs): total_loss = 0.0 for x, _ in dataloader: x = x.to(device) t = torch.randint(0, T, (x.shape[0],), device=device).long() noise = torch.randn_like(x) x_noisy = q_sample(x, t, noise) pred_noise = model(x_noisy, t) loss = F.mse_loss(pred_noise, noise) optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print(f'Epoch {epoch+1}, loss: {total_loss / len(dataloader):.6f}')

为什么训练这么简单？核心在于闭式解把“漫长马尔可夫链的观测”压缩成了单步计算。我们不是在训练网络模拟整条链，而是在任意锚点让网络学会局部去噪，不同t叠加起来就是完整的反向过程。这也是一个相当反直觉的学习策略：反复训练网络做“只需去噪一步”的小任务，最后采样时却能走完整条链。

训练时还有几个隐藏但非常重要的细节。第一，t是随机采样的，这样模型在每个噪声水平上都能获得足够监督信号。第二，损失并没有对不同t做加权，因为噪声预测本身在所有t上都是等量纲的MSE，网络会自动平衡各阶段的难度。第三，优化器一般用Adam或AdamW，学习率建议2e-4左右，不需要太复杂的学习率调度。

4.5 采样推理流程：从纯噪声一步步还原

训练完成之后，生成过程是反向的。先从标准正态分布采样一个x_T，然后从T-1循环到0，每一步使用网络预测的噪声计算x₍ₜ₋₁₎的均值，并加上一个对应方差的高斯扰动。

@torch.no_grad() def p_sample(model, x, t, device): t_tensor = torch.full((x.shape[0],), t, device=device, dtype=torch.long) pred_noise = model(x, t_tensor) sqrt_recip_alphas = torch.sqrt(1.0 / alphas).to(device) pred_mean = sqrt_recip_alphas[t] * (x - betas[t] * pred_noise / sqrt_one_minus_alphas_cumprod[t]) if t > 0: posterior_variance = betas[t] * (1.0 - alphas_cumprod[t - 1]) / (1.0 - alphas_cumprod[t]) noise = torch.randn_like(x) return pred_mean + torch.sqrt(posterior_variance) * noise else: return pred_mean def sample(model, shape, device): x = torch.randn(shape, device=device) for t in reversed(range(0, T)): x = p_sample(model, x, t, device) return x

最后一步不加噪声的原因很直观：如果最后一步还注入随机扰动，生成的样本会带着额外的高频噪声，看起来脏脏的。而在中间步骤中加噪声是必要的，因为去噪网络的训练数据天然包含了这种随机性，采样过程必须模拟训练分布才能让网络发挥正常。我见过不少人把最后一步也加了噪声，导致生成图里总有一层“雪花”——原因就在这。

4.6 条件生成：让扩散模型听懂指令

前面的实现是标准的无条件生成，模型只负责随机生成数字。实际项目里大量需求是条件生成，比如“给我一张数字8的图”。实现条件生成的改动非常小，只要把类别标签嵌入到时间步嵌入附近即可。常见的做法有两类：一是把label embedding加到time embedding上，二是作为额外通道拼接到输入图像上。MNIST demo里用第一种就足够：

class ConditionalUNet(nn.Module): def __init__(self, num_classes=10, **kwargs): super().__init__() self.label_embedding = nn.Embedding(num_classes, 128) self.unet = UNet(**kwargs) def forward(self, x, t, labels): t_emb = self.unet.time_embedding(t) label_emb = self.label_embedding(labels) ...

训练时随机丢弃标签的做法叫“Classifier-Free Guidance”，简单说就是让模型同时学会有条件和无条件生成，采样时再通过一个引导强度把条件信号放大。这个技巧是目前所有高分扩散模型生成效果惊艳的核心原因，值得单独展开研究。这篇主要聚焦基础实现，条件生成就先开个头，后续可以单独写一篇。

5. 实战避坑：训练不稳定、采样慢与显存不足的根源

5.1 训练常见问题与排查清单

扩散模型的训练比GAN稳定很多，但这不代表没有坑。我自己跑MNIST和CIFAR-10时遇到过几类问题，每次都能靠排查清单快速定位。

如果loss始终不下降，大概率是数据归一化出了问题。图像没有归一化到[-1, 1]时，前向过程计算出的xₜ和标准噪声差距过大，模型学不到有效信号。在MNIST里，用ToTensor后像素范围是[0,1]，必须再用Normalize((0.5,),(0.5,))转换到[-1,1]，这个步骤忘了，哪怕训练十轮loss也不会有明显下降。

如果生成的图像模糊或结构混乱，第一看看训练步骤是否太少。DDPM在MNIST上通常需要20到50个epoch才能出现清晰数字，少于这个数量，模型还没学够高频细节。第二个可能原因是采样时步长使用不当，比如直接拿训练时的完整1000步来采样没问题，但如果你自己写了加速采样逻辑，步数少了而噪声注入没同步调整，就容易糊。

如果训练爆显存，优先检查batch size和图像分辨率，其次是网络通道数。64×64以上分辨率建议先把channel缩到64或32，毕竟目标只是验证流程，没必要一上来就堆大模型。

5.2 采样速度与步数权衡：DDIM思路速览

DDPM的完整采样需要1000次网络推理，这在真实场景里太慢了。解决思路是引入DDIM（Denoising Diffusion Implicit Models），它允许跳步采样，比如从1000步压缩到50步，效果几乎不损。

直觉上的解释是：DDPM的采样链本质是一条扩散反向链，而DDIM把这条链“垂直到更短”的序列上，每一步的更新策略改成确定性去噪再加一个可控噪声。这意味着不再受原始马尔可夫链的步数约束，可以任意跨步。如果你想在项目里快速出图，DDIM几乎是必学的加速方案。基础实现里的p_sample改成p_sample_ddim，主要是换成DDIM专属的更新公式。

@torch.no_grad() def ddim_step(model, x, t, prev_t, eta=0.0, device='cpu'): t_tensor = torch.full((x.shape[0],), t, device=device, dtype=torch.long) pred_noise = model(x, t_tensor) alpha_t = alphas_cumprod[t].to(device) alpha_prev = alphas_cumprod[prev_t].to(device) if prev_t >= 0 else torch.tensor(1.0, device=device) std_dev = eta * torch.sqrt((1 - alpha_prev) / (1 - alpha_t) * (1 - alpha_t / alpha_prev)) pred_x0 = (x - torch.sqrt(1 - alpha_t) * pred_noise) / torch.sqrt(alpha_t) mean = torch.sqrt(alpha_prev) * pred_x0 + torch.sqrt(1 - alpha_prev) * pred_noise if eta > 0 and t > 0: mean = mean + std_dev * torch.randn_like(x) return mean

这里的eta控制随机性，eta=0时采样变成完全确定性，生成的样本集合内部一致性高，适合做编辑任务；eta>0时会保留部分随机性，生成结果更多样。实际项目里通常先试eta=0，需要多样性再加到0.5左右。

5.3 混合精度与EMA：大规模训练的两个必备技巧

如果你把MNIST demo往更大规模的数据集上扩展，两个技巧必须尽快安排。第一是混合精度训练（AMP），把网络参数前向和反向的精度降到FP16，损失计算用FP32，能同时降低显存占用并提速。PyTorch的torch.cuda.amp包直接支持，改动量极小。

第二是EMA（Exponential Moving Average），也就是对模型参数做指数滑动平均。训练过程中维护一份参数副本，它比当前参数更平滑，生成的图像细节往往更好。用GAN的术语来说，这相当于给生成器一个“记忆”，避免最后几步优化动荡导致模型回退。很多论文中的效果对比，实际上都是用了EMA以后的版本，所以你自己复现时不要漏掉这个细节。

@torch.no_grad() def update_ema(ema_model, model, decay=0.9999): for ema_param, param in zip(ema_model.parameters(), model.parameters()): ema_param.data.mul_(decay).add_(param.data, alpha=1 - decay)

采样时用ema_model代替model，效果会有肉眼可见的提升。MNIST下可能差距不大，但到了人脸生成这类精细任务，EMA几乎是决定清晰度的关键。

5.4 评估生成效果：不只是看“像不像”

生成模型做完了，怎么判断好坏？业内常用两个指标：FID和IS。IS衡量生成样本的清晰度和多样性，但计算依赖一个分类网络，比较局限。FID则比较真实样本与生成样本在特征空间里的分布距离，越小说明两组分布越接近。

实操经验是：FID在训练初期下降很快，后期会进入平台期，这时候可以考虑增大采样步数、增加EMA decay来继续压指标。另外如果你是在小数据集上做实验，FID波动会比较大，多跑几次采样取平均才可靠。

还有一个容易被忽视的点：贝斯扩散模型生成的样本质量对随机种子有一定依赖。同一个checkpoint，换一个采样种子，FID可能差一两个点。评估时用固定种子序列采样，才方便对比版本差异。

5.5 扩散模型的局限性：不能只会吹捧

尽管扩散模型很强大，但它也不是没有软肋。最大问题是采样速度慢，即便有DDIM加速，距离实时生成还有距离，工业级落地下一步的生成往往要通过蒸馏技术把大模型压成一步或几步采样的小模型。另一个问题是可控性仍有限，文本引导虽然效果不错，但在复杂组合场景下依然会出现语义丢失或属性混淆。此外，扩散模型往往是自回归式地从纯噪声重建，如果掌握不好生成过程的中间状态，很难天然支持“半途继续改图”这类交互式创作。

理解这些局限，不是为了泼冷水，而是让你在做技术选型时更理性。当项目需要高精度的可控生成时，可能用扩散模型加条件控制网络更合适；当项目预算紧张、要求实时出图时，GAN或者蒸馏后的扩散模型仍是值得考虑的方向。

结语：从GAN到扩散模型，变化的只是范式，不变的是对分布的理解

我在实际项目里用GAN和扩散模型都搭过生成pipeline，最大的体会是：扩散模型把“生成”这个抽象任务具象成了一个可分解的、可解释的工程问题，调试起来舒服太多了。它的数学和实现门槛并不比GAN高，反而因为损失函数简单，更容易让初学者把精力放到数据、网络结构和采样细节上。

最后再分享一个小技巧：如果你在MNIST或CIFAR-10上训练扩散模型，把训练过程中的中间检查点保存下来，观察不同epoch的生成效果变化，你会看到模型从“只会生成模糊色块”到“清晰地写出手写数字”的完整演化过程。这个过程对理解生成式模型的范式变革特别有价值。别急着追求大模型，先用小规模把原理和代码吃透，收益远大于跟风堆资源。