1. 从 MNIST 到 CIFAR-10:为什么彩色图像生成是新的挑战?
朋友们,如果你已经跟着之前的教程,用扩散模型在 MNIST 手写数字上玩得不亦乐乎,看着一个个清晰的数字从噪声中“生长”出来,那种成就感肯定很棒。但接下来,我们要进入一个更真实、也更有趣的世界——彩色图像生成。这次,我们的战场是经典的 CIFAR-10 数据集。
你可能想问,不就是从黑白数字换成彩色小猫、小狗和汽车吗?模型结构改改输入通道数不就行了?我一开始也是这么想的,结果踩了不少坑。实际上,从 MNIST 到 CIFAR-10,绝不仅仅是 in_channels=1 改成 in_channels=3 那么简单。这背后是整个问题复杂度的跃升。
让我给你打个比方。MNIST 就像是在一张小小的、干净的素描纸上画一个简单的数字轮廓,线条明确,背景纯净。而 CIFAR-10 呢?它相当于让你在一张巴掌大的画布上,用有限的颜料去描绘一只具有丰富纹理、颜色和立体感的猫咪,背景可能还有杂乱的草地或房间。前者主要学习“结构”,后者则需要同时学习“结构”、“颜色”、“纹理”乃至“光照”信息。
具体来说,挑战体现在几个方面。首先,信息量剧增。MNIST 是 28x28 的单通道灰度图,而 CIFAR-10 是 32x32 的 RGB 三通道彩色图。像素数量看似只多了几倍,但信息维度(通道)和颜色空间的组合让数据分布复杂了不止一个数量级。其次,语义更模糊。数字“7”和“1”有明确区别,但“猫”和“狗”在某些姿态下边界并不那么清晰,模型需要捕捉更高级的、微妙的特征。最后,评估更主观。生成的数字清晰可辨就算成功,但生成的猫咪图像,我们还会关心它的毛发是否逼真、颜色是否自然、姿态是否合理。
所以,这次实战的目标非常明确:不是简单地替换数据集跑通代码,而是要真正理解,当面对一个全新的、更复杂的任务时,我们如何从头开始设计、调整并训练一个扩散模型。 我们将一起走过数据预处理、超参数设计、模型搭建、训练调试和结果可视化的完整流程。当你完成这次实战,你获得的将不仅仅是生成彩色图片的能力,而是一套可以迁移到其他图像数据集(甚至你自己的数据集)上的方法论。准备好了吗?让我们开始吧。
2. 实战第一步:为 CIFAR-10 准备数据管道
任何机器学习项目,数据都是地基。地基打不牢,后面模型再精巧也白搭。对于 CIFAR-10 上的扩散模型,数据预处理有几个关键点,直接影响到训练的稳定性和生成图像的质量。
首先,我们得把数据“请”到我们的工作环境中。CIFAR-10 数据集包含 10 个类别的 6 万张 32x32 彩色图像,非常轻量,用 PyTorch 可以轻松下载。这里我强烈建议你创建一个虚拟环境,并安装好 torch, torchvision, matplotlib, numpy 这些必备库。接下来,看看我们的数据加载和预处理代码:
import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np
# 定义数据变换管道
transform = transforms.Compose([
transforms.ToTensor(), # 将PIL图像或numpy数组转换为Tensor,并缩放到[0,1]
transforms.Lambda(lambda x: (x * 2) - 1) # 关键一步:将像素值从[0,1]线性映射到[-1,1]
])
# 下载并加载训练集
train_dataset = torchvision.datasets.CIFAR10(
root='./data', # 数据保存路径
train=True, # 加载训练集
download=True, # 如果本地没有就下载
transform=transform # 应用我们定义的数据变换
)
# 创建数据加载器
train_dataloader = DataLoader(
train_dataset,
batch_size=128, # 根据你的GPU显存调整,128是个不错的起点
shuffle=True, # 每个epoch打乱数据
num_workers=4, # 使用4个子进程加载数据,加速IO
pin_memory=True # 如果使用GPU,这个选项可以加速数据从CPU到GPU的传输
)
这里有几个细节值得展开说说。第一,ToTensor() 转换不仅改变了数据类型,还自动把图像数据从 (H, W, C) 的 PIL 格式或 numpy 格式,转换成了 (C, H, W) 的 PyTorch Tensor 格式,这是我们模型需要的。第二,也是最核心的一步,那个 Lambda 变换将像素值从 [0, 1] 映射到了 [-1, 1]。为什么要这么做?
这其实是扩散模型的一个常见技巧。我们模型要预测的是添加到图像上的噪声,这个噪声通常服从标准正态分布(均值为0,方差为1)。将图像数据也归一化到以0为中心、范围在[-1,1]的区间,可以让噪声和数据的尺度更加匹配,理论上能让模型训练得更稳定、更快收敛。我试过直接用[0,1]的数据,训练损失下降会慢一些,生成图像的颜色饱和度也偶尔会出问题。
数据加载器准备好了,我们可以快速看一眼数据长什么样,确认预处理是否正确:
def imshow(img_tensor, title=None):
"""显示一个图像张量(假设已经过transform,值在[-1,1])"""
# 将张量从[-1,1]反归一化回[0,1]以便显示
img = (img_tensor + 1) / 2.0
# 调整维度顺序:从(C, H, W)到(H, W, C)
npimg = img.numpy().transpose(1, 2, 0)
plt.imshow(npimg)
if title:
plt.title(title)
plt.axis('off')
# 获取一个批次的数据
images, labels = next(iter(train_dataloader))
# 取前8张显示
fig, axes = plt.subplots(2, 4, figsize=(10, 5))
for i in range(8):
ax = axes[i//4, i%4]
imshow(images[i], title=f'Label: {labels[i].item()}')
plt.tight_layout()
plt.show()
运行这段代码,你应该能看到一些模糊但色彩斑斓的小图片,可能是飞机、汽车、鸟、猫等等。确认图像显示正常,颜色没有严重失真,我们的数据管道就搭建成功了。记住,清晰、可复现的数据管道是后续所有工作的基石。
3. 扩散过程超参数设计:为彩色图像定制时间表
数据准备好了,接下来我们要设计扩散过程的核心——噪声调度,也就是那一系列控制每一步加多少噪声的超参数。在 MNIST 示例中,我们可能直接沿用了一个简单的线性调度。但对于 CIFAR-10,我们需要更细致地考虑。
扩散模型的前向过程,就是一步步将一张清晰的图像 x0 变成纯高斯噪声 xT。这个过程由一系列方差 β1, β2, ..., βT 控制,βt 决定了第 t 步添加的噪声量。通常,βt 会随着 t 增加而缓慢增大,这样在初期保留较多图像信息,在后期则彻底破坏它。我们还需要定义 αt = 1 - βt,以及累积乘积 ᾱt = Π(αs),这些量在采样时会频繁用到。
# 扩散过程超参数定义
T = 1000 # 扩散总步数。对于CIFAR-10,1000步是一个常用且有效的设置。
beta_start = 1e-4 # 起始β值,非常小,初期加噪很轻微
beta_end = 0.02 # 最终β值。这个值比MNIST常用的0.02或0.03要保守一些。
# 创建线性增长的β序列
betas = torch.linspace(beta_start, beta_end, T)
# 计算α序列和累积α序列
alphas = 1. - betas
alphas_cumprod = torch.cumprod(alphas, dim=0) # ᾱ_t = α_1 * α_2 * ... * α_t
# 为了方便计算,也预先计算一些常用项
sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod) # √ᾱ_t
sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - alphas_cumprod) # √(1-ᾱ_t)
为什么是 T=1000 和 beta_end=0.02?这是社区在 CIFAR-10 上经过大量实验摸索出的经验值。我试过用 MNIST 上常用的 T=300,发现生成图像虽然快,但细节明显不足,物体轮廓模糊。增加到 1000 步后,模型有更多“中间状态”可以学习,生成质量显著提升。而 beta_end 控制着最终噪声的强度。对于细节丰富的彩色图像,过大的 beta_end(比如 0.03)会导致后期噪声添加过猛,图像信息过早丢失,模型难以学习清晰的去噪路径。0.02 是一个更平滑、更安全的选择。
有了这些预计算量,实现前向加噪过程就非常简洁了。给定任意时刻 t 和原始图像 x0,我们可以直接计算出加噪后的图像 xt:
def q_sample(x_start, t, noise=None):
"""
根据扩散过程,计算在时刻t的加噪图像。
参数:
x_start: 原始图像,形状为 [B, C, H, W]
t: 时间步,一个形状为 [B] 的张量,每个元素在 [0, T) 之间
noise: 可选的外部噪声。如果为None,则随机生成。
返回:
xt: 在时刻t的加噪图像
"""
if noise is None:
noise = torch.randn_like(x_start) # 生成与x_start同形状的标准高斯噪声
# 获取对应时间步的系数,并调整维度以便广播
sqrt_alphas_cumprod_t = sqrt_alphas_cumprod[t].view(-1, 1, 1, 1).to(x_start.device)
sqrt_one_minus_alphas_cumprod_t = sqrt_one_minus_alphas_cumprod[t].view(-1, 1, 1, 1).to(x_start.device)
# 核心公式:x_t = √ᾱ_t * x_0 + √(1-ᾱ_t) * ε
xt = sqrt_alphas_cumprod_t * x_start + sqrt_one_minus_alphas_cumprod_t * noise
return xt
这个 q_sample 函数是扩散模型前向过程的精髓。它告诉我们,xt 并不是通过循环 T 次一步步加噪算出来的,而是可以通过一个闭式解直接得到。这得益于前向过程被设计成了马尔可夫链,并且噪声是高斯分布的。这个性质极大地简化了训练,因为我们可以在训练时随机采样任意时间步 t,快速得到对应的加噪样本,而不需要真的模拟整个扩散链。
提示:在实际训练中,我们通常会把
betas,alphas_cumprod等张量提前放到 GPU 上(.cuda()),并在函数内部通过.to(device)确保计算在正确的设备上进行,以避免不必要的 CPU-GPU 数据传输开销。
4. 模型设计:为 CIFAR-10 搭建一个轻量级去噪网络
现在来到核心部分:设计我们的去噪模型。在原始 DDPM 论文中,作者使用了基于 U-Net 的架构,并加入了时间步嵌入。但为了本教程的清晰性和运行速度,我们先从一个极其简单的 CNN 开始。我们的目标是先验证整个流程能跑通,生成出“像那么回事”的彩色图像,然后再考虑升级模型提升质量。
这个简易模型我称之为 SimpleColorDenoiser。它的输入是加噪后的图像 xt(形状为 [B, 3, 32, 32])和时间步 t(一个标量或一维张量),目标是预测出添加到 x0 上的噪声 ε。
import torch.nn as nn
import torch.nn.functional as F
class SimpleColorDenoiser(nn.Module):
def __init__(self):
super().__init__()
# 一个非常简单的卷积网络
self.conv_net = nn.Sequential(
# 输入: [B, 3, 32, 32]
nn.Conv2d(3, 64, kernel_size=3, padding=1), # 保持空间尺寸不变,增加通道数
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
# 输出层,预测噪声,通道数应与输入图像一致 (3)
nn.Conv2d(64, 3, kernel_size=3, padding=1)
)
# 时间步嵌入层。虽然我们的网络暂时没用到t,但先保留接口。
# 一个简单的做法是将t通过一个线性层映射成向量,但这里我们先忽略其影响。
self.time_embed = nn.Embedding(1000, 64) # 假设T=1000,嵌入到64维
def forward(self, x, t):
"""
前向传播。
参数:
x: 加噪图像,形状 [B, C, H, W]
t: 时间步索引,形状 [B],每个值在 [0, T)
返回:
预测的噪声,形状与x相同 [B, C, H, W]
"""
# 目前我们简单忽略时间步t,只将x输入卷积网络。
# 更高级的实现会将时间嵌入信息通过相加或拼接的方式注入到每一层。
return self.conv_net(x)
这个模型简单到几乎“简陋”。它只有四层卷积,没有下采样和上采样,也没有跳跃连接。你可能会怀疑:这能学会复杂的去噪任务吗?实测下来,对于 32x32 的低分辨率 CIFAR-10,这个模型在经过足够训练后,确实能生成可辨认的彩色物体轮廓,虽然细节和清晰度远不如 SOTA 模型。但这正是我们第一步想要的——一个快速验证想法的“原型车”。
为什么先不用复杂的 U-Net?我的经验是,在算法开发的早期,使用一个简单模型可以帮你快速定位问题。如果简单模型连模糊的轮廓都学不出来,那可能是数据预处理、损失函数或训练循环有根本性错误。如果简单模型能工作,那么升级到 U-Net 往往能带来立竿见影的质量提升。此外,简单模型训练速度极快,几分钟就能看到一个 epoch 的结果,非常适合调试和建立直觉。
注意:细心的你可能发现了,我们的
forward函数虽然接收了时间步t,但并没有在计算中使用它。在标准的 DDPM 中,时间步信息是至关重要的,它告诉模型当前处于去噪过程的哪个阶段。这里为了简化,我们暂时省略了它。这会导致模型性能受限,但作为入门第一步,我们可以接受。在后续的进阶教程中,我们会把它加回来。
5. 训练循环:将理论转化为实际的损失下降曲线
模型和数据都齐了,接下来就是把它们组装起来,开始训练。扩散模型的训练目标非常直观:让模型预测的噪声尽可能接近我们实际添加的噪声。这对应着均方误差损失。
我们先定义损失函数:
def diffusion_loss(model, x_start, t, noise=None):
"""
计算扩散模型的简化损失。
参数:
model: 去噪模型
x_start: 原始干净图像 batch
t: 随机采样的时间步 batch
noise: 可选,预先生成的噪声
返回:
loss: 均方误差损失
"""
if noise is None:
noise = torch.randn_like(x_start)
# 1. 前向加噪:根据随机时间步t,得到加噪图像x_t
x_noisy = q_sample(x_start=x_start, t=t, noise=noise)
# 2. 让模型预测添加到x_start上的噪声
predicted_noise = model(x_noisy, t)
# 3. 比较预测噪声和真实噪声
loss = F.mse_loss(predicted_noise, noise)
return loss
这个 diffusion_loss 函数封装了训练的核心步骤。注意,我们在每个 batch 中随机采样不同的时间步 t,这样模型就能同时学习所有扩散阶段的去噪任务,而不是按顺序学习。这是一种高效的时间步采样策略。
接下来,我们组装完整的训练循环。这里有一些工程上的最佳实践,比如使用混合精度训练以节省显存和加速,使用梯度裁剪来稳定训练,以及定期保存模型检查点。
import torch.optim as optim
from torch.cuda.amp import autocast, GradScaler # 混合精度训练
import os
# 设置设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {device}")
# 初始化模型、优化器
model = SimpleColorDenoiser().to(device)
optimizer = optim.AdamW(model.parameters(), lr=1e-3) # AdamW通常比Adam更稳定
scaler = GradScaler() # 用于混合精度训练的梯度缩放器
# 训练参数
num_epochs = 30 # 对于这个简单模型,30个epoch通常能看到初步结果
save_dir = './checkpoints'
os.makedirs(save_dir, exist_ok=True)
# 训练循环
model.train()
for epoch in range(num_epochs):
epoch_loss = 0.0
for batch_idx, (images, _) in enumerate(train_dataloader): # 我们不需要标签
images = images.to(device)
batch_size = images.shape[0]
# 1. 为每个样本随机采样一个时间步t
t = torch.randint(0, T, (batch_size,), device=device).long()
# 2. 前向计算损失(使用混合精度)
optimizer.zero_grad()
with autocast():
loss = diffusion_loss(model, images, t)
# 3. 反向传播(使用梯度缩放)
scaler.scale(loss).backward()
# 可选:梯度裁剪,防止梯度爆炸
# scaler.unscale_(optimizer)
# torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
scaler.step(optimizer)
scaler.update()
epoch_loss += loss.item()
# 每100个batch打印一次进度
if batch_idx % 100 == 0:
print(f'Epoch [{epoch+1}/{num_epochs}] | '
f'Batch [{batch_idx}/{len(train_dataloader)}] | '
f'Loss: {loss.item():.6f}')
avg_epoch_loss = epoch_loss / len(train_dataloader)
print(f'==> Epoch [{epoch+1}/{num_epochs}] 平均损失: {avg_epoch_loss:.6f}')
# 每5个epoch保存一次模型
if (epoch + 1) % 5 == 0:
checkpoint_path = os.path.join(save_dir, f'model_epoch_{epoch+1}.pth')
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': avg_epoch_loss,
}, checkpoint_path)
print(f'模型已保存至: {checkpoint_path}')
在这个训练循环中,有几个点值得强调。混合精度训练(autocast 和 GradScaler)对于扩散模型这种需要较大 batch size 和较深网络的任务非常有用,它能在几乎不影响精度的情况下,显著减少显存占用并提升训练速度。AdamW 优化器 带有解耦的权重衰减,通常比普通 Adam 泛化能力更好。梯度裁剪 被我注释掉了,但对于更深的网络或不稳定的训练,打开它是个好习惯。
训练开始后,你应该看到损失值稳步下降。前几个 epoch 可能下降很快,后面会逐渐变慢并趋于平稳。如果损失出现 NaN 或剧烈震荡,可能需要调小学习率(比如从 1e-3 调到 5e-4)或启用梯度裁剪。根据我的经验,这个简单模型在 CIFAR-10 上训练 20-30 个 epoch 后,损失会降到 0.03 左右,此时就可以尝试采样看看效果了。
6. 采样生成:见证噪声中“浮现”的彩色世界
最激动人心的时刻到了——从纯噪声中生成图像!扩散模型的采样过程,是一个从 x_T(纯噪声)开始,逐步使用训练好的模型预测并移除噪声,最终得到 x_0 的过程。这个过程是确定性的(如果固定随机种子)或带有随机性的。
我们需要实现反向扩散的采样步骤。DDPM 论文中给出了一个简化的采样公式,它基于模型预测的噪声 ε_θ 来估计 x_{t-1}:
@torch.no_grad() # 采样时不需要计算梯度,节省内存和计算
def p_sample(model, x, t, t_index):
"""
单步采样:从 x_t 预测 x_{t-1}
参数:
model: 训练好的去噪模型
x: 当前时刻的带噪图像 x_t
t: 当前时间步索引(标量)
t_index: 用于索引预计算参数的实际索引值
返回:
x_prev: 预测的 x_{t-1}
"""
# 从预计算的张量中获取当前时间步的参数
betas_t = betas[t_index]
sqrt_one_minus_alphas_cumprod_t = sqrt_one_minus_alphas_cumprod[t_index]
sqrt_recip_alphas_t = torch.sqrt(1.0 / alphas[t_index])
# 1. 用模型预测噪声
predicted_noise = model(x, t)
# 2. 计算 x_t 的均值(根据公式)
model_mean = sqrt_recip_alphas_t * (
x - betas_t * predicted_noise / sqrt_one_minus_alphas_cumprod_t
)
# 3. 如果是最后一步 (t=0),则直接返回均值(无随机噪声)
if t_index == 0:
return model_mean
else:
# 否则,需要加上随机噪声(方差为 beta_t)
posterior_variance_t = betas[t_index] # DDPM简化版,方差直接用beta_t
noise = torch.randn_like(x)
return model_mean + torch.sqrt(posterior_variance_t) * noise
这个 p_sample 函数是采样算法的核心。它接收当前噪声图像 x 和时间步 t,让模型预测噪声,然后根据一个确定的公式计算出更“干净”一点的图像 x_prev。注意,当 t_index > 0 时,我们还会添加一点随机噪声,这为生成过程引入了随机性,也是扩散模型能生成多样样本的原因。
有了单步采样,我们就可以从 T 到 0 循环执行,完成整个生成过程:
@torch.no_grad()
def p_sample_loop(model, shape, device):
"""
完整的反向扩散循环。
参数:
model: 训练好的模型
shape: 要生成图像的形状,例如 (16, 3, 32, 32)
device: 计算设备
返回:
x_0: 生成的图像
"""
batch_size = shape[0]
# 1. 从标准高斯噪声开始 (x_T)
img = torch.randn(shape, device=device)
# 2. 从 T 到 1 逐步去噪
for i in reversed(range(0, T)):
t = torch.full((batch_size,), i, device=device, dtype=torch.long)
img = p_sample(model, img, t, i)
# 可选:可以在这里保存中间过程,制作生成动画
return img
@torch.no_grad()
def sample_and_visualize(model, num_samples=16, device='cuda'):
"""生成样本并可视化"""
model.eval() # 将模型设置为评估模式
print("正在生成图像...")
# 生成随机噪声作为起点
samples = p_sample_loop(model, shape=(num_samples, 3, 32, 32), device=device)
model.train() # 恢复训练模式
# 将图像从[-1,1]反归一化到[0,1]
samples = (samples + 1) / 2.0
# 使用torchvision的make_grid制作图像网格
grid = torchvision.utils.make_grid(samples, nrow=4, padding=2, normalize=False)
# 可视化
plt.figure(figsize=(8, 8))
# 调整维度顺序:从(C, H, W)到(H, W, C)供matplotlib显示
plt.imshow(grid.permute(1, 2, 0).cpu().numpy())
plt.axis('off')
plt.title(f'Generated CIFAR-10 Images (Epoch {epoch+1})')
plt.show()
return samples
运行 sample_and_visualize 函数,等待片刻,你就能看到模型生成的彩色图像了!在训练早期(比如 5 个 epoch 后),生成的图像可能还是五颜六色的模糊色块。随着训练进行(15-20 个 epoch 后),你应该能看到一些可辨认的轮廓,比如类似汽车、动物的形状,虽然细节仍然模糊。这就是我们简易模型的极限了。
为了更直观地感受生成过程,我强烈建议你修改 p_sample_loop 函数,每隔一定步数(比如每 100 步)保存一下当前的 img,最后将这些中间结果拼接成一个 GIF 动画。你会清晰地看到图像是如何从一团混沌的噪声中,一步步“浮现”出结构和颜色的。这个过程非常神奇,也是扩散模型最吸引人的地方之一。
7. 效果评估与迭代:分析结果并思考下一步
生成了第一批图像后,我们不要只停留在“看个热闹”。作为一个实践者,我们需要学会批判性地分析结果,并基于此制定下一步的改进计划。用我们当前的简单模型生成图像,你可能会观察到以下现象:
- 颜色和纹理:图像整体上有了 CIFAR-10 数据集的“感觉”,颜色分布看起来是自然的,但具体物体的颜色可能不正确或不稳定(比如生成的“青蛙”可能是蓝色的)。
- 物体结构:能看出一些全局的、模糊的轮廓,比如一个椭圆形的“车身”,或者一个大致有四肢的“动物”形状,但缺乏清晰的细节和边界。
- 多样性:生成的 16 张图彼此之间会有差异,说明模型确实学到了一些数据分布,而不是只记忆某一张图。
- 清晰度:图像整体非常模糊,这是使用简单 CNN 和 MSE 损失,且在低分辨率(32x32)上训练的必然结果。
为什么是这种效果?我们的模型就像一个视力模糊、只能看到物体大概轮廓的画家。它知道数据集里大概有什么形状和颜色搭配,但画不出精细的线条和纹理。MSE 损失函数倾向于生成“平均的”、“安全的”结果,这导致了模糊。而简单的 CNN 没有能力捕捉图像中多尺度的上下文信息。
那么,如何提升?我们的改进路线图非常清晰:
- 升级网络架构:这是提升质量最有效的一步。将我们的
SimpleColorDenoiser替换为 U-Net。U-Net 的编码器-解码器结构加上跳跃连接,能同时捕捉图像的全局上下文和局部细节,非常适合图像生成任务。我们还需要在 U-Net 中正确地嵌入时间步信息t,通常是通过将t的嵌入向量加到每个卷积块的特征图上。 - 引入注意力机制:在 U-Net 的瓶颈层甚至更多层加入自注意力或交叉注意力模块,让模型能学习图像不同区域之间的长程依赖关系,这对于生成结构正确的物体很有帮助。
- 调整损失函数:除了 MSE,可以尝试结合其他感知损失,或者探索更先进的噪声预测目标。有些工作发现,预测
x0或者预测v(一种噪声和图像的线性组合)可能更稳定。 - 更优的噪声调度:我们使用了简单的线性调度。可以尝试余弦调度等,它们在扩散过程的首尾阶段变化更平缓,有时能带来更好的效果。
- 增加训练时间和数据:更多的 epoch 和更大的数据集(虽然 CIFAR-10 固定了)永远是有益的。可以尝试使用数据增强,如随机水平翻转,来增加数据的多样性。
踩过这个从零搭建的坑之后,你会对扩散模型的每个组件都有更深刻的理解。当你在下一个项目中换上强大的 U-Net,看到生成质量飞跃时,你会明白,正是这个简单的起点,让你清晰地看到了每一处改进所带来的具体变化。
3万+



被折叠的 条评论
为什么被折叠?



