PyTorch手写扩散模型:为何要亲手拆解噪声还原花卉?
本文不聊DALL-E或Stable Diffusion的黑盒原理,而是带你从零构建一个去噪扩散模型。我们使用Oxford 102花卉数据集,通过正向加噪和逆向去噪两个过程,训练一个带有注意力机制的U-Net模型。文章详细拆解了数学公式背后的代码实现,包括如何处理时间步嵌入、如何设计跳跃连接,以及如何使用DDIM调度器在
为什么非要自己动手写一遍扩散模型
如今说起AI画图,Stable Diffusion、Midjourney几乎是脱口而出的名字。工具本身确实强,可它们把最要紧的“扩散机制”包得太严实了。结果就是不少人只会在Prompt里一个劲堆关键词,图像究竟如何从满屏噪点里长出来,却说不上来。
扩散模型(Diffusion Model)的底层思路并不复杂:先毁掉,再拼回来。把一张清楚的照片一点点搅成纯噪声,再让一个神经网络学会把这个过程倒着走一遍,这个网络也就掌握了“造图”的本事。
行业大势这里不展开,直接上手。我们用
PyTorch搭一个去噪扩散模型,训练数据挑的是经典的Oxford 102花卉数据集,目的很明确——让模型能从随机噪声里把清晰的花朵还原出来。期间会讲到正向扩散的数学推导、U-Net里的注意力机制,还有推理阶段怎么靠DDIM调度器把生成速度提上去。
扩散模型离不开的两个过程
要弄懂扩散模型,先得把两个方向相反的过程分开看:正向扩散(Forward Diffusion)和逆向扩散(Reverse Diffusion)。
正向扩散:噪声是一步步加进去的
假设手上有一张清晰的花卉照片$x_0$,正向扩散要做的就是往里面掺噪声。掺法不是一口气倒完,而是拆成$T$步(一般取$T=1000$)一点点来。
到第$t$步时,往图像$x_{t-1}$里加入少量高斯噪声$ε_{t-1}$,就得到$x_t$。公式如下:
$$ x_t = \sqrt{1 - \beta_t} \cdot x_{t-1} + \sqrt{\beta_t} \cdot \epsilon_{t-1} $$
式中的$\beta_t$是事先定好的噪声调度参数,时间步越往后,噪声占的比重越高。走到第1000步,原图的信息基本被噪声盖住,$x_T$看上去就是一张纯粹随机的噪点图。
训练时不必一步步迭代去算任意时刻$t$的噪声图像。借助重参数化技巧,从$x_0$可以直接算出$x_t$:
$$ x_t = \sqrt{\bar{\alpha}_t} \cdot x_0 + \sqrt{1 - \bar{\alpha}_t} \cdot \epsilon $$
这里的$\bar{\alpha}_t$是累积系数。这个性质很要紧,有了它,训练时可以随机挑一个时间步$t$,直接生成对应的噪声图像$x_t$,前$t-1$步不用从头模拟一遍。
逆向扩散:把噪声一层层剥掉
正向过程好比把水搅浑,逆向过程则是让浑水重新变清。我们要训一个模型,给它噪声图像$x_t$和时间步$t$,让它预测出图里混着的噪声$ε$。
只要模型预测噪声够准,从$x_t$里减掉预测出的噪声,就能得到干净一些的$x_{t-1}$。从$x_T$(纯噪声)出发,把这个动作重复50到1000次,一张清晰的$x_0$就出来了。
有个细节不能忽略:模型除了看图,还得知道眼下处在哪个时间步。噪声多的时候($t$大),模型得放手去噪;噪声少的时候($t$小),又得收着点、把细节留住。所以时间步$t$会作为额外信息一并喂给模型。
数据处理与可视化
我们使用 datasets库加载Oxford 102花卉数据集,共102类花卉、约8000张图片。为了压计算成本,所有图片统一缩到$64 \times 64$像素,像素值归一化到$[-1, 1]$区间。
from datasets import load_dataset
import torch
from torchvision.utils import make_grid
import matplotlib.pyplot as plt
# 加载数据
dataset = load_dataset("huggan/flowers-102-categories", split="train")
# 简单的预处理:调整大小并归一化
def transforms(examples):
# 假设这里包含了Resize和Normalize操作
# 实际代码中需使用torchvision.transforms
pass
dataset.set_transform(transforms)
# 创建DataLoader
train_dataloader = torch.utils.data.DataLoader(
dataset, batch_size=4, shuffle=True
)训练开始前,不妨先直观感受一下正向扩散的效果。可以借助[[保留3]][[保留4]]库,也可以自己手写代码,往一张干净图片上按不同比例叠加噪声。DDIMScheduler(来自 diffusers
from util import DDIMScheduler
noise_scheduler = DDIMScheduler(num_train_timesteps=1000)
clean_images = next(iter(train_dataloader))["input"]
noise = torch.randn(clean_images.shape)
# 查看时间步 200, 400, ..., 1000 的效果
for step in range(200, 1001, 200):
timesteps = torch.tensor([step-1] * 4).long()
noisy_images = noise_scheduler.add_noise(clean_images, noise, timesteps)
# 可视化 noisy_images...时间步往上走,花朵的轮廓会一点点糊掉,颜色彼此混在一起,最终只剩一片没有意义的雪花点。模型要学的“逆过程”,起点正是这里。
搭建去噪用的U-Net模型
扩散模型的主力军是 U-Net。它最初为生物医学图像分割而设计,但在去噪任务上表现极佳。原因在于它的对称结构:编码器(Encoder)负责提取特征并下采样,解码器(Decoder)负责恢复分辨率并上采样,中间通过跳跃连接(Skip Connections)传递细节信息。
不过,在扩散模型中,标准的 U-Net 还不够,我们需要解决两个问题:
- 时间感知:模型需要知道当前处理的是哪一步的噪声。
- 全局关联:卷积核只能看局部,而花朵的花瓣可能分布在图像的不同位置,需要全局上下文。
时间步嵌入(Time Embedding)
整数 $t$ 没法直接送进卷积层,模型必须先拿到时间步信息。为此,这里借用了 Transformer 位置编码里的正弦嵌入思路,把标量 $t$ 变成向量。
import torch.nn as nn
import math
def sinusoidal_embedding(timesteps, dim):
half_dim = dim // 2
emb = math.log(10000) / (half_dim - 1)
emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
emb = timesteps.float().unsqueeze(1) * emb.unsqueeze(0)
emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=-1)
return emb得到向量之后,再由一个多层感知机(MLP)做变换。变换结果会在 U-Net 的每一层与图像特征相加,卷积操作因此带上了“时间信息”。
引入注意力机制
为了解决卷积局部性的问题,我们在 U-Net 的瓶颈层和部分上下采样块中加入了自注意力机制(Self-Attention)。具体来说,使用的是缩放点积注意力(Scaled Dot-Product Attention)。
特征图在图像处理中要展平成序列。以 $128 \times 64 \times 64$ 的特征图为例,它相当于长度 $4096$ 的序列,其中每个元素为128维。序列里每个像素与其他像素的关系由注意力机制计算,长距离依赖就是这样捕捉到的。
class Attention(nn.Module):
def __init__(self, dim, heads=4, dim_head=32):
super().__init__()
self.scale = dim_head ** -0.5
self.heads = heads
hidden_dim = dim_head * heads
self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
self.to_out = nn.Conv2d(hidden_dim, dim, 1)
def forward(self, x):
b, c, h, w = x.shape
qkv = self.to_qkv(x).chunk(3, dim=1)
q, k, v = map(lambda t: rearrange(t, 'b (h c) x y -> b h c (x y)', h=self.heads), qkv)
q = q * self.scale
sim = einsum('b h d i, b h d j -> b h i j', q, k)
attn = sim.softmax(dim=-1)
out = einsum('b h i j, b h d j -> b h i d', attn, v)
out = rearrange(out, 'b h (x y) d -> b (h d) x y', x=h, y=w)
return self.to_out(out)这段代码中,rearrange 来自 einops这个库的用途是灵活变换张量维度。有了注意力机制,模型处理某个像素时可以“看到”图像其他部分的信息,生成结构完整的花朵离不开这一点。
U-Net 整体架构
U-Net 的下采样和上采样各有四个阶段,隐藏层维度依次是 128, 256, 512, 1024。下采样块由两个卷积残差块加一个注意力模块组成,注意力模块只在特定层启用。编码器同层的特征图经跳跃连接拼到解码器对应层,空间细节得以保留。
class UNet(nn.Module):
def __init__(self, in_channels=3, hidden_dims=[128, 256, 512, 1024], image_size=64):
super().__init__()
# 初始化卷积层、下采样块、上采样块、注意力模块等
# ... (省略具体初始化代码,参考前文描述)
def forward(self, sample, timesteps):
# 1. 时间步嵌入
t_emb = sinusoidal_embedding(timesteps, self.hidden_dims[0])
t_emb = self.time_embedding(t_emb)
# 2. 初始卷积
x = self.init_conv(sample)
r = x.clone() # 残差连接备用
skips = []
# 3. 下采样路径 (Encoder)
for block1, block2, attn, downsample in self.down_blocks:
x = block1(x, t_emb)
skips.append(x)
x = block2(x, t_emb)
x = attn(x) # 应用注意力
skips.append(x)
x = downsample(x)
# 4. 瓶颈层
x = self.mid_block1(x, t_emb)
x = self.mid_attn(x)
x = self.mid_block2(x, t_emb)
# 5. 上采样路径 (Decoder)
for block1, block2, attn, upsample in self.up_blocks:
x = torch.cat((x, skips.pop()), dim=1) # 跳跃连接
x = block1(x, t_emb)
x = torch.cat((x, skips.pop()), dim=1)
x = block2(x, t_emb)
x = attn(x)
x = upsample(x)
# 6. 输出层
x = self.out_block(torch.cat((x, r), dim=1), t_emb)
out = self.conv_out(x)
return {"sample": out}参数量约为1.3亿。放到 $64 \times 64$ 的图像生成任务上看,这属于中等规模:表达能力有保障,消费级GPU也能训练。
训练策略
训练扩散模型的目标非常明确:最小化预测噪声与真实噪声之间的差异。
损失函数
损失函数选的是 L1(平均绝对误差),没有用 L2(均方误差)。原因在于实践中 L1 生成的图像边缘往往更锐利,L2 虽然数学上更平滑。去噪任务里,L1 的表现通常也更稳健。
$$ Loss = || \epsilon_{pred} - \epsilon_{true} ||_1 $$
训练循环
在每个训练步骤中:
- 从 DataLoader 取一批干净图像 $x_0$。
- 随机采样时间步 $t$(均匀分布从 0 到 999)。
- 生成随机噪声 $\epsilon$。
- 根据公式计算噪声图像 $x_t$。
- 将 $x_t$ 和 $t$ 输入 U-Net,得到预测噪声 $\epsilon_{pred}$。
- 算出 Loss,再做反向传播。
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-5)
lr_scheduler = get_scheduler("cosine", optimizer=optimizer, num_warmup_steps=300, num_training_steps=total_steps)
for epoch in range(100):
model.train()
for step, batch in enumerate(train_dataloader):
clean_images = batch["input"].to(device) * 2 - 1 # 归一化到 [-1, 1]
noise = torch.randn(clean_images.shape).to(device)
# 随机采样时间步
timesteps = torch.randint(0, 1000, (clean_images.shape[0],)).long().to(device)
# 生成噪声图像
noisy_images = noise_scheduler.add_noise(clean_images, noise, timesteps)
# 预测噪声
noise_pred = model(noisy_images, timesteps)["sample"]
# 计算损失
loss = F.l1_loss(noise_pred, noise)
loss.backward()
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()优化器选的是 AdamW,学习率调度用余弦退火。前期靠 Warmup 让梯度稳住,后期借余弦衰减把收敛做细。
从噪声生成图像
训练结束,模型就学会了去噪。推理却比训练麻烦一些,要一步一步迭代着来。
DDIM 采样器
训练用了1000个时间步,推理不必这么多。DDIM(Denoising Diffusion Implicit Models)属于确定性采样方法,步数少到50步也能生成高质量图像。
生成流程是这样:
- 先从标准正态分布里采出纯噪声 $x_T$。
- 然后让 $t$ 从 $T$ 递减到 $0$:
- 把 $x_t$ 和 $t$ 送进模型,预测出噪声 $\epsilon$。
- 按 DDIM 公式算出 $x_{t-1}$。
- 最后输出 $x_0$。
@torch.no_grad()
def generate(model, device, num_inference_steps=50):
# 初始化纯噪声
image = torch.randn((1, 3, 64, 64)).to(device)
scheduler = DDIMScheduler(num_train_timesteps=1000)
scheduler.set_timesteps(num_inference_steps)
for t in scheduler.timesteps:
# 预测噪声
model_output = model(image, t)["sample"]
# 更新图像
image = scheduler.step(model_output, t, image).prev_sample
return image结果展示
训练满100个 Epoch 后,模型画出的花卉已经带上明显的类别特征。$64 \times 64$ 的分辨率摆在那里,细节丰富不到哪去,可花瓣的颜色、形状和整体构图都挺自然。
盯住中间过程看,会发现:
- $t=800$ 时还只是一团模糊色块,颜色的分布倒隐约可辨。
- 到 $t=400$,花朵轮廓冒了出来,背景和主体开始分开。
- $t=0$ 时图像清晰了,纹理细节也被修了回来。
从混沌走向有序,扩散模型的吸引力就在这儿。它不靠 GAN 那种判别器对抗来生成图像,走的是学习数据分布去噪路径的路子,把图像一点点“雕刻”出来。
总结与展望
一个完整的扩散模型流程,就这样用 PyTorch 手写出来了。从数学推导到代码落地,关键在两处:正向加噪的马尔可夫链性质,以及逆向去噪时 U-Net 对时间、空间特征的捕捉。
这个简易模型当然还有不少地方可以改:
- 分辨率:$64 \times 64$ 偏低,实际应用一般走潜空间扩散(Latent Diffusion),先在低维潜空间去噪,再解码回高维图像,Stable Diffusion 就是这么做的。
- 条件生成:模型现在是无条件的,只能随机生成花卉。想做 Text-to-Image,就得接入文本编码器(如 CLIP),把文本嵌入当作额外条件喂给 U-Net。
- 加速采样:DDIM 之外还有 DPM-Solver 等更先进的采样器,推理步数能压到10步以内。
扩散模型不是什么黑魔法,只是概率论和深度学习的一次优雅结合。几百行代码亲手敲下去,看着噪声一点点变成花朵,对生成式 AI 的理解会比调用任何 API 都来得深。