ARTICLE DETAIL

资讯详情

深耕网站建设、视觉设计与SEO优化的一线实战洞察。

Diffusion Transformer数学推导与PyTorch最小可跑实现

Diffusion Transformer数学推导与PyTorch最小可跑实现

第一次把 diffusion transformer 的代码从公式抄到能跑,我在单卡机器上盯着 loss 曲线看了三个小时——前 200 步掉得很漂亮,第 300 步之后开始上下抖动,最后停在某个明显偏高的平台上不再下降。那会儿我把问题归咎于学习率、数据、batch size,折腾了一整圈,最后发现是我把 adaLN 的调制分支初始化成了常规的正态分布,导致每个 block 在训练一开始就把主干特征搅乱了。这个坑让我意识到一件事:diffusion transformer 这种东西,光会调库是不够的,前向加噪那套数学、Transformer 里的条件注入方式、损失函数到底在优化什么,这三块必须自己在纸上推一遍,否则出问题时你连从哪儿查都不知道。

这篇是我这个系列的第一部分,只讲“数学地基”和“最小可跑实现”。具体来说,会把扩散过程的前向链和闭式解拆开算一遍、把 Transformer 那半边(注意力、patchify、时间步条件注入、adaLN-Zero 的零初始化)的数学形式写清楚、然后把两边接起来的损失函数推导和 PyTorch 代码骨架给出来。适合两类人看:一类是已经跑过 Stable Diffusion 那套 U-Net 架构、想搞明白为什么现在大家都在往 Transformer 骨架上迁的人;另一类是被公式劝退过、想找一个“从符号到代码”的对照表的人。不需要你会推导变分下界,但需要你知道什么是高斯分布、什么是矩阵乘法、能看懂 PyTorch 的nn.Module。系列第二部分我会讲采样器、CFG、以及把模型真正训到出图的那套工程细节,这篇先把地基打完。

1. 先把问题摆清楚:为什么扩散模型要换掉 U-Net

1.1 卷积骨架的天花板在哪

U-Net 在扩散模型里统治了好几年,它的优势是明确的:卷积自带局部性和平移等变性这两个归纳偏置,天然适合图像这种二维网格数据;skip connection 让浅层的高频细节能直接送到深层,重建质量好;而且下采样-上采样的结构让感受野随深度指数级扩大,计算量却是线性的。这套设计在 512×512 这个尺度上极其高效,我在实际项目里用 U-Net 训 256×256 的模型,单卡 24G 显存能把 batch 开到 64 左右,收敛也很稳。

但它的局限同样明显,而且随着分辨率上去会越来越痛。第一,感受野是靠堆层数堆出来的,要建模“左上角的物体和右下角的物体之间的关系”这种长程依赖,你得堆很深,而且中间要经过多次下采样,信息在瓶颈处已经被压得很扁了。第二,U-Net 的超参结构非常“手工”——几层、每层多少个 block、attention 加在哪几个 resolution 上,这些选择没有统一的最优解,换个分辨率就得重新调结构。第三,也是最关键的:当你希望模型规模能像语言模型那样“加大参数量就变强”的时候,U-Net 的 scaling 曲线不够平滑,加大 depth 会带来梯度问题,加大 width 的收益又很快饱和。

Transformer 恰好补的就是这三块。自注意力是全局的,任意两个 token 之间都是一步可达,长程依赖不需要靠深度去换;结构极其规整,所有 block 长得一模一样,扩参就是简单地把层数或宽度乘上去;而且它已经在语言模型上被验证过 scaling law,这套经验可以直接搬。这就是 diffusion transformer 这条路的核心动机——不是为了时髦,是为了拿到一条更可预测的规模化曲线。

1.2 把图像当成句子读:patchify 的核心直觉

Transformer 吃的是序列,图像是二维网格,中间得有个转换。这个转换就是 patchify:把 H×W×C 的图切成 p×p 的小块,每块拉平成一个向量,再线性投影到 d 维,就得到了一串长度为 N=(H/p)×(W/p) 的 token 序列。这个操作你可以理解成“把图像当成一句话来读,每个 patch 是一个词”。

这里有个非常容易搞混的点,我必须提前说清楚:如果你在像素空间做 patchify,token 数会爆炸。256×256 的图,p=2 的话是 128×128=16384 个 token,注意力复杂度是 O(N²),16384² 这个量级根本跑不动。所以实际做法几乎都是在潜空间(latent space)上做——先用一个自编码器把 256×256×3 压成 32×32×4 之类的潜表示,再在这个 32×32 的网格上 patchify,p=2 得到 256 个 token。256 个 token、768 维隐层,这个规模就完全可控了,注意力矩阵是 256×256,一次前向的计算量在单卡上毫无压力。

为什么 p 取 2 而不是 4 或 8?这是计算量和表达力的折中。p 越小,token 越多,空间细节保留得越好,但注意力成本按平方涨;p 越大,token 越少越省算力,但每个 token 融合的空间范围变大,细节会糊。在 32×32 的潜空间上,p=2 得到 256 个 token,p=4 只有 64 个——64 个 token 描述一张图实在太少了,你会明显看到生成结果的结构崩塌。我自己实测过 p=4 的配置,FID 会差一大截,而且小物体的边缘会糊成一片。所以业界的默认配置基本是潜空间 32×32 配 p=2。

1.3 三种骨架的横向对比

在动手写代码之前,先把选型的账算清楚。下面这张表是我自己在几个项目里对比下来总结的,不是绝对结论,但能帮你判断自己该走哪条路。

维度纯 U-Net纯 Transformer (DiT)混合(卷积下采样 + Transformer 主干)
长程建模靠深度堆,间接全局一步可达兼顾,但结构复杂
结构规整度低,超参多高,block 完全同构中
扩参可预测性一般好,接近线性可预测中
高分辨率成本线性增长,友好平方增长,需要分块或窗口介于两者之间
训练稳定性好,成熟需要 adaLN、qk-norm 等技巧好
上手难度低,教程多中,细节坑多高

我的建议很直接:如果你目标是 256×256 到 512×512 这一档、想验证一个新想法、或者需要可控的扩参实验,走纯 Transformer 骨架;如果你要做的是超大分辨率、或者是需要极强局部细节的任务(比如某些图像修复场景),卷积的局部性还是不能完全丢掉,混合结构更务实。别一上来就追求“纯血”,架构选择是为目标服务的,不是为信仰服务的。

2. 扩散过程那一半数学:从加噪到闭式采样

2.1 前向链:每一步只加一点点高斯噪声

扩散模型的前向过程定义成一个马尔可夫链,从干净数据 x₀ 出发,每一步加一点高斯噪声:

q(x_t | x_{t-1}) = N(x_t; sqrt(1 - beta_t) * x_{t-1}, beta_t * I)

这里 beta_t 是一个预先设定的方差调度(variance schedule),取值在 (0,1) 之间,通常从 1e-4 线性或余弦地增长到 0.02,总步数 T 一般取 1000。注意均值项里的 sqrt(1-beta_t) 这个系数不是随手写的——它是为了保证方差不爆炸。如果直接写成 x_t = x_{t-1} + noise,每一代的方差都是上一代加 beta,走到第 1000 步数值早就飘到天上去了。乘上 sqrt(1-beta_t) 之后,每一步都做了一次“方差保留”的缩放,整体信号能量被控制在合理范围。

我习惯把这一步理解成“往一杯水里滴墨水,每次滴一点点,同时把杯子里的水倒掉一点点保持总量不变”。倒掉的那部分就是 sqrt(1-beta_t) 带来的收缩,它保证了过程不会数值发散。

2.2 重参数化:为什么可以一步跳到任意 t

马尔可夫链是一步一步走的,但训练的时候我们显然不想真的循环 1000 次。这里就要用到重参数化(reparameterization)技巧。令 alpha_t = 1 - beta_t,alpha_bar_t = 连乘 alpha_1 到 alpha_t,那么可以证明:

q(x_t | x_0) = N(x_t; sqrt(alpha_bar_t) * x_0, (1 - alpha_bar_t) * I)

对应的采样写法就是最常用的那一行:

x_t = sqrt(alpha_bar_t) * x_0 + sqrt(1 - alpha_bar_t) * eps,其中eps ~ N(0, I)

这个式子的推导用的是高斯分布的可加性:两个独立高斯的和还是高斯,均值相加、方差相加。反复代入 T 次,就能把连乘合并成 alpha_bar。它的意义极大——训练时任何 t 的样本都可以一步采样出来,不需要真的跑 t 步链。这就是为什么扩散模型的训练可以完全并行。

alpha_bar_t 这个量决定了整个训练的难度分布。我按 T=1000、线性调度(beta 从 1e-4 到 0.02)手算了一组数,你可以对照着感受一下:

talpha_bar_t(约)含义
01.000干净图像
1000.896保留约 90% 信号,轻微噪声
2600.497信噪比约 0 dB,半信半疑
5000.078只剩 7.8% 信号,噪声占主导
10004e-5几乎纯噪声

算的过程不复杂:log(alpha_bar_t) ≈ -sum(beta_i) - sum(beta_i²)/2。以 t=500 为例,sum(beta_i) ≈ 500×1e-4 + (500²/2)×1.99e-5 ≈ 2.5375,二阶修正约 0.008,所以 log(alpha_bar) ≈ -2.546,取指数得到 0.078。这个数字说明一个问题:在线性调度下,后一半步数基本是在纯噪声里空转。t=500 时信号已经只剩不到 8%,模型在这个区间能学到的东西非常有限,但计算量一点都不少。这就是为什么后来大家改用余弦调度(cosine schedule)——它让 alpha_bar 的下降曲线更均匀,中段的有效训练区间被拉长,同样的 T 下采样质量会更好。

2.3 反向过程与变分下界:MSE 是怎么被“逼”出来的

前向是加噪,我们真正要学的是反向:从纯噪声还原图像。反向过程也建模成高斯:

p_theta(x_{t-1} | x_t) = N(x_{t-1}; mu_theta(x_t, t), sigma_t² * I)

关键是均值 mu_theta 怎么参数化。这里有个很漂亮的结论:给定 x_t 和 x_0,真实的后验 q(x_{t-1} | x_t, x_0) 是解析可得的,均值为

mu_tilde = [sqrt(alpha_{t-1}) * beta_t / (1 - alpha_bar_t)] * x_0 + [sqrt(alpha_t) * (1 - alpha_bar_{t-1}) / (1 - alpha_bar_t)] * x_t

方差为beta_tilde_t = beta_t * (1 - alpha_bar_{t-1}) / (1 - alpha_bar_t)。既然后验是已知的,那训练目标就很自然了——让预测分布去逼近真实后验,用 KL 散度衡量。把 KL 展开、忽略与 theta 无关的常数项,得到的是变分下界(ELBO)里的一个二次项:

L_t = E[ (1 / (2*sigma_t²)) * || mu_tilde(x_t, x_0) - mu_theta(x_t, t) ||² ]

到这里还是“预测均值”。再往下走一步:既然 x_t = sqrt(alpha_bar_t) x_0 + sqrt(1-alpha_bar_t) eps,把均值公式里的 x_0 用 x_t 和 eps 反解出来代进去,你会发现 mu_theta 和 mu_tilde 的差,本质上是“模型预测的噪声”和“真实加的噪声”之差。于是损失可以重写成:

L_simple = E_{t, x_0, eps}[ || eps - eps_theta(x_t, t) ||² ]

这就是所有扩散模型里最常见的那一行 MSE。值得强调的是:这一步不只是等价变换,还丢掉了前面的权重系数 1/(2*sigma_t²)。丢掉权重是个工程决定,不是数学必然。理论上加权会更“正确”(因为它反映了不同 t 下预测难度不同),但实践发现去掉权重后模型反而更容易学,因为高噪声区间的样本本来就更难预测,如果按理论加权会把这些难样本的权重压得很低,反而学不好。这个权衡我在第 4 节还会展开。

2.4 采样器的选择:DDPM 与 DDIM 的差别到底在哪

训练完之后要采样,采样器决定了从噪声到图像怎么走回去。最原始的 DDPM 采样是随机性的,每一步都注入新的噪声:

x_{t-1} = mu_theta(x_t, t) + sigma_t * z,z 是标准高斯(t>0 时),t=0 时 z=0

DDIM 的思路是把这个过程改成确定性的。当 eta=0 时,采样公式变成:

x_{t-1} = sqrt(alpha_bar_{t-1}) * x0_hat + sqrt(1 - alpha_bar_{t-1}) * eps_hat

其中 x0_hat 是从当前预测的噪声反解出来的干净图像:x0_hat = (x_t - sqrt(1-alpha_bar_t) * eps_hat) / sqrt(alpha_bar_t)。这个式子有个巨大的好处——它不要求 t 和 t-1 相邻。你可以只取 50 个甚至 20 个时间步,从 1000 步里等距跳着走,速度提升 20 到 50 倍,而图像质量下降很有限。我实测下来,20 步 DDIM 和 1000 步 DDPM 在视觉上的差距,远小于耗时上的差距。

不过要注意一点:DDIM 步数太少时会丢细节,尤其是纹理丰富的地方,容易出现“涂抹感”。我的经验是 50 步是个甜点,20 步以下就开始明显掉质量了。这个跟调度方式也有关,余弦调度在少步数下比线性调度更稳。

3. Transformer 那一半数学:注意力、切块与条件注入

3.1 多头注意力写成矩阵是什么样子

标准的缩放点积注意力:

Attention(Q, K, V) = softmax(Q @ K^T / sqrt(d_k)) @ V

其中 Q、K、V 都是 [N, d_k] 的矩阵。除以 sqrt(d_k) 的原因是:如果 q 和 k 的每个分量都是独立的标准正态,那它们的点积方差是 d_k,维度一高点积的数值就会很大,softmax 之后会退化成近似 one-hot,梯度几乎为零。除以 sqrt(d_k) 把方差归一化回 1,这是注意力能训起来的关键细节之一。

多头就是把 d 维拆成 h 份,每份 d/h 维,各自做注意力再拼回去。以 d=768、h=12 为例,每个头 64 维。多头的好处不是“算得更准”,而是“能同时关注不同类型的关系”——我自己的观察是,训完之后有些头明显在管局部纹理,有些头在管全局布局,虽然没有人显式指派。

复杂度这块要算清楚:注意力矩阵是 N×N,所以时间和显存都是 O(N²d)。N=256、d=768 时,一次注意力的 FLOPs 大约是 4N²d ≈ 2e8,12 层就是 2.4e9,单张 A100 上跑一次前向是毫秒级。但如果你把 N 拉到 1024(对应更高分辨率的潜空间),成本就是 16 倍,这时候就得考虑窗口注意力或者分块了。

3.2 patchify 的尺寸账:token 数怎么算

这个账必须会算,不然你连显存炸了都不知道为什么。公式很朴素:

N = (H / p) * (W / p)

输入patch 大小token 数注意力矩阵大小
32×32 潜空间2256256×256
32×32 潜空间46464×64
64×64 潜空间210241024×1024
256×256 像素空间810241024×1024
256×256 像素空间21638416384×16384(不可行)

最后一行就是前面说的那个坑:像素空间配小 patch,注意力矩阵有 2.68 亿个元素,光存这个矩阵 fp16 就要 536MB,再乘以层数和 batch,直接原地爆炸。所以潜空间不是可选项,是必需品。

patch 嵌入的实现就是一个卷积:nn.Conv2d(in_ch, d, kernel_size=p, stride=p)。用卷积而不是真的做切块再拼,是因为卷积核和步长都等于 p 的时候,它干的事恰好就是“不重叠切块 + 线性投影”,而且 GPU 上的实现效率更高。这个细节很多人第一次看代码会懵,觉得怎么没看到 reshape。

3.3 时间步和类别条件怎么塞进去

扩散模型必须知道当前是第几步,不然它没法判断该去掉多少噪声。条件注入方式主要有三种,差异很大:

第一种是in-context conditioning:把时间步和类别的嵌入当成额外的 token,直接拼到序列前面,让注意力自己去处理。这个最省事,几乎不改结构,但效果一般,因为条件信息和图像 token 混在一起,模型需要额外的容量去区分它们。

第二种是cross-attention:在 block 里加一个额外的交叉注意力层,query 来自图像 token,key 和 value 来自条件嵌入。灵活度最高,能处理变长条件(比如文本),但多了一层注意力和一堆参数,训练也更容易不稳。

第三种是adaLN(adaptive layer norm):不用额外 token,也不用额外注意力,直接把条件嵌入通过一个 MLP 映射成缩放和偏移参数,去调制 LayerNorm 的输出。原话是modulate(x, shift, scale) = x * (1 + scale) + shift。这种方式参数最少、计算最省,而且效果在类别条件任务上是最好的。代价是它不太适合变长条件,所以文本条件通常还是回到 cross-attention。

我用下来最直接的感受是:如果你的条件维度固定(时间步、类别、分辨率、甚至一个固定长度的小向量),闭眼选 adaLN;如果条件是可变长的文本序列,那没得选,cross-attention 或者混合方案。

3.4 adaLN-Zero:为什么零初始化能救训练

这是整个架构里最容易踩坑、也最值得讲的一个细节。adaLN 的调制分支一般是这样接的:时间步嵌入 → SiLU → Linear(d, 6d) → 拆成 6 个向量(shift、scale、gate 各两组,一组给注意力,一组给 MLP)。关键在于这个 Linear 的输出层要做零初始化。

为什么?因为零初始化之后,scale=0、shift=0,x * (1+0) + 0 = x,也就是每个 block 在训练开始时是恒等映射。整个网络在第一步就等价于“patch 嵌入 + 最后一层线性”,主干是通的,梯度能顺畅地从头传到尾。随着训练进行,调制参数慢慢偏离零,block 才开始真正起作用。

如果按常规做正态初始化,训练一开始每个 block 都会往特征里注入一个随机的缩放和偏移,12 层叠起来,特征的方差会指数级放大或缩小——这就是我开头说的那个坑,loss 卡在平台上不降,看起来像学习率问题,其实是初始化问题。顺便说一句,gate 那一路也是零初始化,等于说残差分支一开始是被完全关掉的,这也是 identity 性质的一部分。

这个设计还有个附带好处:它让训练早期的模型等价于一个浅层模型,收敛特别快,前三五百步 loss 掉得很陡。我对比过零初始化和普通初始化,同样的配置下前者能早收敛大概 20% 的步数。

4. 把两边接起来:训练目标与损失函数落地

4.1 从加权 ELBO 到“去掉权重”的工程取舍

第 2 节推到了 L_simple,这里把取舍讲透。理论上完整的 ELBO 是每一项带权重的和,权重是 1/(2*sigma_t²),而 sigma_t² 在 t 大时接近 1,在 t 小时接近 beta_1=1e-4。也就是说理论目标会给小 t(低噪声)的项分配高达 10⁴ 量级的权重,给大 t 的项分配 1 量级的权重。

这个加权看起来合理——低噪声时预测得准不准确实更影响最终画质。但工程上直接这么干会出问题:不同 t 的损失量级差四个数量级,梯度尺度极不平衡,训练会非常不稳定。更麻烦的是,高噪声区间的样本被过度压制之后,模型学不会怎么从纯噪声里“起形”,采样的时候前面几步就崩了,后面再怎么修也救不回来。

所以通行的做法就是直接扔掉权重,所有 t 一视同仁。这个决定牺牲了理论上的最优性,换来了训练稳定和采样质量。我自己的经验是,如果你发现生成的图整体偏灰、结构感弱,可以试试加一个温和的加权(比如权重正比于 SNR 的某个幂次),但千万别用理论权重,那个基本一定崩。

4.2 eps / x0 / v 三种预测目标的换算

模型可以预测三样东西:噪声 eps、干净图 x0、或者速度 v。三者数学上完全等价,可以互相换算,但训练动力学差别不小。

由x_t = sqrt(abar) x0 + sqrt(1-abar) eps,可以解出:

  • 预测 eps 时:x0_hat = (x_t - sqrt(1-abar) * eps_hat) / sqrt(abar)
  • v 的定义:v = sqrt(abar) * eps - sqrt(1-abar) * x0

由 v 反解:x0 = sqrt(abar) * x_t - sqrt(1-abar) * v,eps = sqrt(abar) * v + sqrt(1-abar) * x_t。

(这两个式子代进去验证一下就能确认,我当初推的时候还怀疑过符号,实际展开就明白了。)

为什么要有 v 预测?因为 eps 预测在 t 很小的时候有问题:此时 abar 接近 1,x0_hat 的式子里除以 sqrt(abar) 接近除以 1,还好;但 x_t 和 eps 项的量级关系导致信噪比极高,模型稍微预测错一点点,反解出来的 x0 就偏得很远,损失被放大。用 v 预测相当于在 eps 和 x0 之间做了个平滑插值,低噪声时它更接近预测 x0,高噪声时更接近预测 eps,整体梯度尺度更均衡。我的实测结论是:T=1000 的常规配置下 eps 预测够用,但如果步数很少或者噪声调度很密,v 预测会明显更稳。

4.3 可跑的 PyTorch 代码骨架

时间步嵌入用的是正弦位置编码,和 Transformer 里那套一样,只是把位置下标换成了时间步:

import math import torch import torch.nn as nn def modulate(x, shift, scale): return x * (1 + scale) + shift class TimestepEmbedder(nn.Module): def __init__(self, d, freq_dim=256): super().__init__() self.freq_dim = freq_dim self.mlp = nn.Sequential( nn.Linear(freq_dim, d), nn.SiLU(), nn.Linear(d, d) ) def forward(self, t): half = self.freq_dim // 2 freqs = torch.exp( -math.log(10000.0) * torch.arange(half, device=t.device) / half ) args = t[:, None].float() * freqs[None] emb = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) return self.mlp(emb)

block 的实现要注意两处:LayerNorm 关掉仿射(elementwise_affine=False),因为缩放偏移由 adaLN 提供;调制层的最后一层零初始化。

class DiTBlock(nn.Module): def __init__(self, d, heads): super().__init__() self.norm1 = nn.LayerNorm(d, elementwise_affine=False) self.attn = nn.MultiheadAttention(d, heads, batch_first=True) self.norm2 = nn.LayerNorm(d, elementwise_affine=False) self.mlp = nn.Sequential( nn.Linear(d, 4 * d), nn.GELU(approximate="tanh"), nn.Linear(4 * d, d) ) self.ada = nn.Sequential(nn.SiLU(), nn.Linear(d, 6 * d)) nn.init.zeros_(self.ada[-1].weight) nn.init.zeros_(self.ada[-1].bias) def forward(self, x, c): s1, sc1, g1, s2, sc2, g2 = self.ada(c).chunk(6, dim=-1) h = modulate(self.norm1(x), s1, sc1) h, _ = self.attn(h, h, h, need_weights=False) x = x + g1.unsqueeze(1) * h h = modulate(self.norm2(x), s2, sc2) x = x + g2.unsqueeze(1) * self.mlp(h) return x

训练一步的核心就是采样 t、采样 eps、构造 x_t、算 MSE:

def train_step(model, x0, opt, T=1000): b = x0.shape[0] t = torch.randint(0, T, (b,), device=x0.device) eps = torch.randn_like(x0) abar = alpha_bar[t].view(b, 1, 1, 1) # 预先算好的表 x_t = abar.sqrt() * x0 + (1 - abar).sqrt() * eps pred = model(x_t, t) loss = ((pred - eps) ** 2).mean() opt.zero_grad() loss.backward() opt.step() return loss.item()

注意alpha_bar一定要预先算成一张表放在显存里,不要在每个 batch 里现场连乘,那个开销白白浪费。另外 t 的采样分布也有讲究:均匀采样是最常见的,但如果你发现模型在某一段 t 上明显学不好,可以对那段做过采样。

5. 实操:一张 24G 卡上的最小可行 DiT

5.1 参数量和显存的纸面计算

先算参数量,这块算清楚了心里才有底。以 d=768、12 层、12 头、p=2、潜空间 32×32 为例:

每个 block 里,注意力四个投影矩阵 4d² ≈ 236 万,MLP 两个矩阵 8d² ≈ 472 万,加起来约 708 万。调制分支 d×d + d×6d ≈ 413 万?不对,算细一点:Linear(d, 6d)是 768×4608 ≈ 354 万,加上前面的 SiLU 之前的投影可以忽略。所以每个 block 约 1060 万,12 层就是 1.27 亿。

再看首尾:patch 嵌入Conv2d(4, 768, 2, 2)约 1.2 万,最后一层Linear(768, p*p*out_ch)约 1.2 万,时间步 MLP 大概 40 万。这些加起来占比极小。

所以这个配置大概在 1.3 亿参数上下。用 AdamW 训练,参数 fp32 是 520MB,一阶二阶动量各 520MB,梯度 520MB,光这些就 2GB 左右。混合精度下参数和梯度用 fp16/bf16 存可以砍一半,但优化器状态还是 fp32。

激活值的账更麻烦。每个 token 是 768 维,256 个 token,一个样本一层的激活是 256×768≈19.7 万个元素,fp16 下约 0.39MB。一层里需要保存的张量包括注意力的 QKV、注意力输出、两次 LayerNorm 的输出、MLP 中间层(这个是大头,4d 宽,1.57MB),加起来一层约 4MB。12 层就是 48MB 一个样本,batch=64 就是 3GB。加上参数和优化器,总计 5 到 6GB,24G 卡跑 batch=64 是比较宽松的,跑到 128 问题也不大。

我实测下来的经验值:这个配置在 24G 卡上 batch=96 是安全线,再往上开始 OOM。如果显存吃紧,开梯度检查点(gradient checkpointing),激活显存能砍到 1/3 左右,代价是训练速度慢 20% 到 30%。

5.2 训练循环的关键几行

除了上面的单步逻辑,还有几个地方必须处理对。第一,EMA(指数滑动平均)几乎是必开的,对采样质量提升非常明显,衰减系数取 0.9999。第二是学习率 warmup,前 5000 步线性从 0 爬到 1e-4,之后余弦衰减,这个对稳定性影响很大。第三是梯度裁剪,max_norm 取 1.0,防止个别 batch 炸掉。

ema = {k: v.clone().detach() for k, v in model.state_dict().items()} @torch.no_grad() def update_ema(model, ema, decay=0.9999): for k, v in model.state_dict().items(): if v.dtype.is_floating_point: ema[k].mul_(decay).add_(v.detach(), alpha=1 - decay) else: ema[k].copy_(v)

还有一个细节我踩过:alpha_bar表的精度要用 float64 算完再转 float32,不然 t 接近 1000 的时候,连乘出来的值下溢到 0,sqrt(1-abar)变成 1,倒是不影响,但1/sqrt(abar)会变成 inf。这个 bug 只在特定 t 上出现,非常难查。

5.3 训练曲线怎么读

我一般看三个信号。第一是 loss 的整体趋势,正常的曲线应该是前期陡降、中期缓慢下降、后期在一个平台上小幅波动。如果 1000 步内没有任何下降,八成是初始化或者数据的问题,别急着调学习率。

第二是 loss 的方差。健康的训练里,相邻 batch 的 loss 波动应该在一定范围内,如果突然出现尖刺又立刻恢复,多半是某个 batch 的数据有问题或者梯度爆炸被裁剪掉了。如果波动越来越大,那就是学习率太高或者模型开始发散。

第三是抽样看效果,这个比 loss 曲线重要得多。每 5000 步用固定的几个随机种子采样一次,用同样的种子看变化,你能很直观地看到模型从“纯噪声”到“有色块”到“有结构”的过程。我一般会存成网格图,方便对比。这里有个小技巧:用固定的种子序列,不要每次随机,不然你分不清是模型变好了还是种子抽得好。

6. 踩坑记录与速查表

6.1 五个最常见的崩点

第一个是前面说的 adaLN 零初始化,症状是 loss 卡在平台、生成图全是灰蒙蒙的噪声。检查方法很粗暴:把模型初始化后直接跑一次前向,输出应该接近全零(因为最后一层通常也是零初始化)或者至少方差很小,如果输出方差很大,那肯定是某个分支初始化错了。

第二个是alpha_bar的索引错位。t 是从 0 开始还是从 1 开始,alpha_bar[t]还是alpha_bar[t-1],这个差一位会导致训练时用的噪声水平和采样时对不上,症状是训练 loss 很好但采样出来全是糊的。我第一次就栽在这,查了两天才发现。

第三个是 LayerNorm 没关仿射。如果 adaLN 的调制和 LayerNorm 自带的缩放偏移同时存在,两者会打架,训练能收敛但效果上限明显低。症状不太明显,容易被忽略,但对比实验能看出来。

第四个是时间步嵌入的频率尺度。用 10000 做底数在 T=1000 的时候,高频部分的周期远小于步长,等于那几维基本没信息。有些实现会把频率范围调窄,让 1000 个步长能被充分区分。这个不影响收敛,但影响模型对精细噪声水平的判断。

第五个是混合精度下的 softmax。fp16 做 softmax 时,如果输入有较大的正值,exp 会溢出成 inf。现在的框架大多会自动处理(把 softmax 转到 fp32),但如果你自己写了注意力,一定要记得这一条。

6.2 问题速查表

症状最可能原因排查手段
loss 完全不降学习率过大 / 初始化错打印初始前向的输出方差
loss 降但采样全糊alpha_bar 索引错位核对训练和采样的 t 定义
训练后期突然发散无梯度裁剪 / 学习率未衰减加 max_norm=1.0,开余弦衰减
生成图结构对但纹理脏步数太少 / v 预测未启用采样步数从 20 提到 50
显存 OOM 但参数不多激活未做 checkpoint开梯度检查点
同样种子结果差异大未开 EMA / 随机性来源多固定种子 + 开 EMA
高噪声步采样崩权重项未去掉确认损失是纯 MSE

最后补充一个我自己总结的判断标准:如果你不确定某个改动是好是坏,别只看 loss,一定要用固定种子跑一组采样图对比。扩散模型的 loss 和生成质量之间的相关性没有想象中那么强,同一个 loss 水平下,采样质量的差异可以很大。我现在的习惯是每改一次结构就存一组 64 张的采样网格,用同样的种子,这样累积下来就是一个很直观的对比库,比任何指标都可靠。

返回列表