生成模型
是怎么长出来的

第0章 工具箱：这本书只要你会六件事

翻开一篇生成模型的论文，你大概会在摘要还没读完的地方就撞见一个下标叠着下标的公式，旁边跟着几个从没见过的希腊字母，然后就想合上电脑。这一章要做的事很小：把接下来二十三章会反复用到的六件事，用二十分钟讲完，每件事配一道能马上自测的题。读完这一章，你不会变成数学家，但论文里那些公式会从一整页天书，变成几个认识的老朋友换了身新衣服。

0.1 一张照片、一段视频、一段录音，怎么变成一堆数字

把一张 512×512 的彩色照片放大到能看清单个像素，每个像素点其实是三个数：红、绿、蓝各自的亮度，通常是 0 到 255 之间的一个整数。整张照片因此是 512×512×3 = 786,432 个数，排成一个高、宽各 512、最后再叠三层的数字格子。这类可以有任意多个轴的数字格子，统一叫张量：一串孤零零的数是一维张量，一张表是二维，一张彩色照片这样的是三维。视频只是在这个立方体后面再接一个轴——时间，把很多张照片按拍摄顺序叠起来，变成四维。声音完全是另一回事：它不占宽和高，只有时间这一个轴，每一个瞬间记一个数，代表那一刻的气压。一秒钟、16000 次采样的单声道录音，就是 16,000 个数排成一条线，比刚才那张照片的格子扁得多，却也长得多。

张量(tensor)：可以有任意多个轴的数字格子。一条数列是一维，一张表是二维，一张彩色照片这类多轴数组统称张量，轴的个数越多，说明这堆数被组织的方式越复杂。

0.2 向量、矩阵、通道是什么，矩阵乘法又在做什么

上一节把 512×512×3 这三个数分别叫了高、宽、通道，这一节把它们各自的名字钉牢。只有一串数、没有表格结构的一堆数，比如 [0.2, −1.4, 3.0]，叫向量——可以把它想成「一个东西的若干个属性写成一排」。把好几个向量摞成一张有行有列的表，就是矩阵。而通道说的不是「另起一张表」，是在同一个行列位置上，往纵深方向再叠几层：512×512 这个格子里的每一个位置，都摞着三层数（红、绿、蓝），这三层就是三个通道。矩阵乘法在干什么：把一组数按一组权重重新混合一遍，输出的每一个数，都是输入那一整排数按各自份额凑出来的加权和。比如输入是 [2, 3]，权重是 [0.5, 1]，乘出来就是 2×0.5 + 3×1 = 4——一个新数，由两个旧数各自贡献一部分拼出来。后面几乎每一章的网络内部，都是成千上万次这种加权重新混合摞在一起。

向量(vector)：一串有顺序的数。矩阵(matrix)：把若干向量摞成的一张有行有列的表。

通道(channel)：在同一个行列位置上纵深叠着的几层数，RGB 照片每个像素点上叠的那 3 层就是 3 个通道。

0.3 神经网络训练的时候到底在调什么

神经网络说到底是一个函数：塞进去一串数，吐出来一串数。输入可以是刚才那张照片展开的 786,432 个数，输出可以是一个数——这张照片是猫的可能性有多大。中间发生的事，就是上一节那种加权重新混合，一层接一层地做很多次，每一层用到的权重都是一批独立的数，摞起来常常有几百万、几千万个。这些权重就是旋钮：最开始它们是随机填的，网络这时候输出的是胡言乱语。训练不改网络的结构，只改这些旋钮的数值——一次训练看一批例子，把每个旋钮往某个方向拧一点点，很多批之后，网络吐出来的数就越来越像该有的样子。学会认猫这句话翻译过来，就是找到一组能让网络在猫照片上稳定吐出高分的旋钮数值。

神经网络(neural network)：由很多层加权重新混合堆起来的一个函数，输入一串数，输出一串数，层与层之间的权重就是训练时被调整的对象。

0.4 损失函数和梯度，怎么知道往哪拧

光知道要拧旋钮还不够，得知道往哪边拧、拧多少。损失函数负责第一件事：把现在的输出离目标差多远压缩成一个数。假如网络对一张猫照片给出的分数是 0.3，而目标是 1.0（满分确定是猫），一种常见的算法是把两者的差平方：(0.3 − 1.0)² = 0.49。这一个数越大，说明当前这组旋钮越差；越接近 0，说明网络吐出的答案越接近目标。梯度负责第二件事：对每一个旋钮单独回答「把你稍微调大一点，这个 0.49 会变大还是变小，变化多快」。把所有旋钮都按各自梯度给出的方向，反着挪一小步——冲着让损失变小的方向走——这一整套算损失、算梯度、反向挪一步的循环，重复几十万次，就是训练。这套循环有个名字，梯度下降。

损失函数(loss function)：把「当前输出离目标差多远」压成的一个数，数越小说明当前这组旋钮越好。

梯度(gradient)：对每个旋钮分别给出「往哪个方向调，能让损失这个数变小」的方向和快慢。反复按梯度的反方向调整旋钮，这套循环叫梯度下降(gradient descent)。

0.5 为什么说采样就是掷一次不均匀的骰子

高斯分布是那条最有名的钟形曲线：中间高，两边对称地往下滑，由两个数完全确定——均值（曲线最高点在哪）和标准差（曲线有多宽）。它有两个好记的锚点：反复从这条曲线上抽数字，大约 68% 的结果会落在均值±一个标准差这个范围里，大约 95% 会落在均值±两个标准差里。采样说的是真的抽一个数出来，不是去算这条曲线的平均值——就像掷一颗不均匀的骰子，六个面出现的概率不一样，但每次掷出来的，都是实实在在的某一面，不是六个面的加权平均。均值是 0、标准差是 1 的高斯分布是这本书里出现次数最多的一条曲线，后面每一章的加噪声、随机初始化，抽的都是它。

高斯分布(Gaussian distribution)，也叫正态分布(normal distribution)：由均值和标准差决定的钟形曲线，68% 的抽样落在一个标准差以内，95% 落在两个标准差以内。

采样(sampling)：按照某个分布，实际抽出一个具体的数（或一整组数），不是计算这个分布的平均值。

0.6 期望、方差，以及为什么全书都在说分布

期望是如果采样无穷多次，平均下来会是多少——按每个结果出现的可能性加权平均，不是简单地把几个数加起来除以个数。方差衡量这些采样结果散得有多开：每个采样值离期望有多远，把这个距离平方之后再求期望，散得越开，方差越大。这里有一条后面反复用到的性质：两个互相独立的随机数相加，得到的新数，方差是两者的方差直接相加，不需要开根号也不需要打折。全书反复出现分布这个词，是因为生成模型要学的从来不是一张确定的图——给定画一只猫这个条件，世界上存在无数张不同的、都合理的猫的照片，模型要学会的是这一整群照片背后每一种猫长什么样、各自有多大可能性，也就是这群照片的分布，而不是死记住某一张。生成一张新图，做的正是上一节说的采样：从学到的分布里掷一次骰子，抽一个具体的结果出来。

期望(expectation)：按每个结果出现的可能性加权平均之后的那个数，也叫均值。

方差(variance)：采样结果离期望有多远的平方、再求期望，衡量散开的程度；两个独立随机数相加，方差直接相加。

第1章 三条线，同一个问题

设想有一个模型，见过一百万张猫的照片，没有两张长得一样。你让它画一只猫，它翻遍这一百万张记忆，得给你一个交代——但它该给你哪一张？世界上没有一张标准猫，这一百万张里的每一张都是合理的答案，也没有哪一张比别的更该被选中。这个看似只属于猫的小麻烦，翻译成数学语言之后，会变成后面二十二章几乎每一页都在解的同一个问题。

这一层要给整本书搭上第一块能跑的砖：一个比真实图片分布简单无数倍、却已经没法用一个公式写全的一维分布，以及从它里面掷一次骰子的办法。第 0 章讲的都是零件，这里第一次把「分布」和「采样」这两个词用在一个真正需要它们的例子上。

1.1 让机器画一只猫，它该给你哪一张

选项三点破的，是这一整本书要处理的核心麻烦：给定一个条件（画一只猫、说一句话、拍一段海浪），符合条件的合理结果从来不是一个，而是一整群，模型要学的正是第0章讲过的分布——这一群结果背后，每一种具体样子各自有多大可能性。生成一张新图，做的是第0章那个动作：从学到的分布里采样一次，抽一个具体的结果出来，不是去计算这一群结果的平均值。

问题在于，模型不可能凭空生成这个分布，得有一个起点。这个起点必须简单到我们随时能从它身上掷一次骰子——最常用的选择就是第0章那条均值 0、标准差 1 的高斯分布，一个完全由两个数字决定、闭着眼睛都能采样的东西。终点则是真实世界里那一百万张猫的照片、或者一段真实的海浪录音，复杂到没有人能写出它的公式，我们手里只有一堆真实存在过的样本，没有描述它的解析表达式。画一只猫要解的问题，翻译成一句话就是：找一条从起点到终点的路，把「从简单分布采样」这件容易事，变成「从复杂分布采样」这件难事。图像、视频、语音这三条线，接下来二十二章要解的，都是这同一句话的不同版本。

1.2 图像、视频、语音，哪条线的原始数字个数最吓人

起点那条高斯分布，第0章已经讲完了它的全部细节。终点这一头呢？终点的第一层麻烦，甚至还轮不到「分布长什么样」，纯粹是「一条数据本身有多大」。这件事图像、视频、语音三条线的答案差得很远，而且差出来的方式会决定后面好几章的日程。

三个数字放在一起看，反差很扎眼：1024×1024 的图像是 3,145,728 个数；这段 5 秒 720p 视频是 334,540,800 个数，比同分辨率的一张图片多出两个数量级；10 秒钟的语音反而只有 240,000 个数，比那张百万像素级的图片还要少。视频用「多乘一个轴」这一个简单动作，就把体量甩开图像和语音一大截，这也是为什么第 9 到 13 章要用整整五章篇幅，专门处理怎么把这个数字压下去。

1.3 同一个问题，三条线各自多出来的是哪堵墙

选项三点出的三堵墙，接下来分别看。图像要处理的是像素之间隔得很远也要互相呼应这件事——两只眼睛的颜色要配对，对称的花纹要对齐，这类关系能跨越大半张图，而最直接的做法往往一次只看得见一小块邻域，够不着这么远。视频把这堵墙原样继承下来，还要再加一条：这一帧和下一帧必须是同一个世界里合理的连续动作，一步走错，画面就会闪烁或者穿模。语音的两堵墙是完全不同的性质：相位是波形里人耳几乎听不出、却会让逐点比较的误差公式极其敏感的一个量；实时则是一条图像和视频生成过程里几乎不存在的硬指标——很多场景要求生成的速度追得上播放的速度，慢一拍都不行。

1.4 论文自己说的话，要跟本站自己推出来的话一样信吗

接下来二十二章会写满数字：某个调度在第几步跌破一半、某个采样器比另一个快多少倍、某个模型的 FID 分数是多少。这些数字的来路并不一样，读的时候也不该用一个尺度去信。本站把数字分成三种读法，不是为了摆出一套复杂的标注系统，是因为混着读会出事——把论文作者自己实验出来的一个分数，和本站自己用公式当场推出来的一个数字，用同一种口气讲出来，读者会分不清哪个数字旁边站着一个可以马上验证的按钮，哪个数字背后是别人做过、本站没有重新做过的一次实验。

第一种数字，本站在正文里直接给出，不加任何限定语，因为旁边往往就跟着一个能让你自己按一下验证的实验室；第二种数字是论文作者自己报告的实验结果，正文里照常写出来，不会句句加免责声明，但每一章末尾会有一处折叠起来的提醒，一次性说清这一章里哪几个数字属于这一类，没有经过第三方复现。这两种数字在正文里读起来几乎一样干脆，区别全在能不能现场验证。

第三种数字是本站自己从多个来源交叉推出来的、或者论文没写清楚、要去翻配置文件才查得到的，这一类不会拖到章末才交代，而是在它出现的那一句话里就直接说明来路，比如「这个数论文没给，是从社区镜像仓库的配置文件里读到的」这样一句话，紧跟在数字后面。

1.5 24 章怎么连起来，三条线在哪分岔

把接下来二十二章画成一张图，会看见一件从上一节就能猜到的事：图像线排在最前面，也压得最长；视频线要等图像线那一整套机器搭完才分岔；语音线在第 1 章这个分岔点上，几乎立刻就走了自己的路。

第2章 为什么不能直接把图画出来

上一章说，让机器画一只猫，正确答案不是一张，是一整群，模型要学的是这一群猫背后的分布。这句话说起来轻巧，但真要让一个神经网络吐出一张图，第一反应几乎所有人都一样：找一堆猫的照片，把网络的输出和这些照片逐张比对，比对得越接近，损失越小，训练得越好。这条最直接的路，正是这一章要认真走一遍、然后看着它接连在两个不同的地方撞墙的路。

这一层要给第1级那个能采样的双峰分布，配上第一个生成器——虽然这个生成器会当场失败。前一级只关心真实数据长什么样，这一层第一次让某个模型尝试去模仿它，而失败的方式，会精确对上这一章要推出的那条数学结论。

2.1 为什么把网络调成直接吐像素，吐出来的是一团模糊

第二个选项错在哪，值得认真走一遍这条路才看得清。给网络输入一个条件，直接输出一整张图的像素值，用均方误差衡量输出和某张真实图片逐像素的差距——这是最直接想到的办法，训练循环第0章已经讲过：算损失、算梯度、往让损失变小的方向挪一步。这条路真的能训，网络也确实会一直变得更准，问题出在准的方向，不是我们以为的那个方向。

把这件事搬回图片上：给定「画一只猫」这个条件，真实世界里合理的猫的照片有几十万张，每一张的每个像素值都不一样。均方误差训练出来的网络，会把每个像素都朝着这几十万张图在这个像素位置上的平均值靠拢——花纹被平均掉了，胡须的位置被平均掉了，边缘变成一片渐变的灰色。这不是网络训练得不够、也不是网络不够大，是损失函数本身要的就是平均，换更大的网络、训练更久，只会让它更精确地逼近这个平均值，不会让它突然学会随机挑一张。这也不是一个为了教学才编出来的玩具问题：变分自编码器的解码器用的正是这种逐像素重建损失，这正是那类模型生成的图片一直偏模糊、偏平滑的数学根源，2.4 节会回来处理它。

2.2 找一个裁判来打分，能不能绕开这堵墙

把这个裁判的想法认真搭起来，就是生成对抗网络的路子。一个生成器负责画图，一个判别器负责判断输入的图是真实数据还是生成器画出来的，两者对抗训练——生成器想办法骗过判别器，判别器想办法不被骗过。这条路真的走通过，而且走得很远：训出来的图确实能又清晰又逼真，因为判别器一旦发现某种一眼假的特征（比如模糊、渐变），就会专门惩罚它，生成器被逼着放弃这些容易被识破的偷懒办法。

生成对抗网络(Generative Adversarial Network, GAN)：由一个生成器和一个判别器对抗训练出来的生成模型，生成器负责画，判别器负责判断真假，两者互相逼迫着变强。

但清晰不等于覆盖全。LDM 论文在引言里说得很直接：GAN 令人满意的结果，一直被局限在变化幅度相对有限的数据上，因为它那套对抗训练的过程，没法轻松扩展到给复杂的、多模态的分布建模上——原文是「the promising results of GANs have been revealed to be mostly confined to data with comparably limited variability as their adversarial learning procedure does not easily scale to modeling complex, multi-modal distributions」。翻译成上一节的语言：GAN 确实能避开均方误差那种取平均的模糊，但它换来的麻烦是，判别器只要求生成器骗过自己，不要求生成器把真实分布里的每一种可能都覆盖到——生成器完全可以只在几种安全的、容易骗过判别器的样子上反复画，放弃那些判别器不容易判断、但确实存在于真实数据里的边缘情况。

这句话不是一句无法验证的评价。LDM 论文在 4.2 节专门用 Precision 和 Recall 两个指标量化过这件事：Precision 衡量生成的图有多像真的，Recall 衡量生成的图覆盖了真实分布里多大一部分。同一张 LSUN-Bedrooms 数据集的评测表里，一个叫 ProjectedGAN 的模型 FID 只有 1.52，是全表最低也就是最好，可它的 Recall 只有 0.34，是全表最低也就是最差；换成扩散模型 ADM，FID 涨到 1.90，Recall 却跳到 0.51。同一张表上，FID 说 ProjectedGAN 的图更像真的，Recall 说它覆盖的范围只有扩散模型的三分之二左右。论文自己的结论是，扩散模型这类基于似然、天然倾向覆盖全部模式的训练方式，在 Precision 和 Recall 上持续超过 GAN 类方法。

2.3 一步太难，为什么拆成很多小步就不会错

往一张图里掺一点点高斯噪声，这件事简单到甚至不需要训练——第0章讲过怎么从高斯分布采样，往原图上直接加一份随机数就行，谁都会做，而且结果是唯一确定的：同一张原图、同一份噪声，加出来的结果就是那一个。这件容易到不会出错的事，倒过来问一句就翻了面：能不能训练一个网络，专门学怎么去掉一点点噪声？

这正是扩散概率模型的起点。这类模型最早的思路借自非平衡态热力学：气体分子经过很多次微小的随机碰撞，从有序状态扩散成无序状态，这个过程原则上可以倒着推回去。加噪声对应扩散的方向，去噪声对应倒着走回去。DDPM 论文说清楚了倒着走为什么可行：当每一步扩散只添加很小量的高斯噪声时，只需要把采样链的每一步转移也设成条件高斯分布就够了，这样能得到一个特别简单的神经网络参数化——原文是「When the diffusion consists of small amounts of Gaussian noise, it is sufficient to set the sampling chain transitions to conditional Gaussians too, allowing for a particularly simple neural network parameterization」。「一步很小」是关键：小到网络这一步要做的，不再是从一堆天差地别的答案里选一个，而是在给定点附近，猜一个几乎唯一确定的方向。

2.4 VAE 是不是也这样，它后来去哪了

上一节的答案里藏着一个容易被忽略的老朋友。在扩散模型之前，另一条路子——变分自编码器，也在尝试走不逐像素比较这条路，只是走法不一样：它训练一个编码器，把图片压缩成一小串数，再训练一个解码器，把这串数还原回图片，压缩和还原绑在一起训练。但解码器还原图片时，用的依然是逐像素的重建损失，2.1 节推出来的那条结论原样成立——解码器输出的图，一样会因为均方误差的平均效应，带上模糊、偏平滑的痕迹。VAE 没有靠拆成很多步这条路子解决模糊问题，它的清晰度问题没有被这条思路本身解决。

变分自编码器(Variational Autoencoder, VAE)：由编码器和解码器组成的一对网络。编码器(encoder)把输入压缩成一小串数（潜码），解码器(decoder)再把这串数还原回原来的样子，两者绑在一起训练，让压缩和复原互相成立。

但 VAE 没有因此出局，它换了一个岗位。LDM 论文没有让扩散模型直接在像素空间里工作，而是先训练一个 VAE，把图片压缩到一个小得多的潜空间，再让扩散那一整套加噪、去噪的机器，在这个压缩过的空间里工作，最后再用 VAE 的解码器把结果还原回像素。论文把这一步叫感知压缩：VAE 负责删掉图片里那些人眼几乎看不出、却占了大部分数据体量的高频细节，扩散模型负责在剩下的、语义层面的空间里学真正复杂的那部分分布。VAE 解码器自己输出图片时依然偏模糊这件事，在这套组合里几乎不再是麻烦——因为最后拿去重建的不是一串从头训练的随机潜码，而是扩散模型精心迭代出来、专门对应某一张具体图的一个点，解码器在这个点附近的重建反而是准的。第 6 章会把这整套压缩器怎么训练、怎么和扩散模型接起来，仔细过一遍。

第3章 加噪：一条可以随时跳的路

拿一张照片，给每个像素加上一个很小的随机数，看上去几乎没变；再加一次，还是几乎没变；加到第一千次，屏幕上只剩一片雪花。毁掉一张图这件事谁都会做，难的是反过来走。我们先把毁掉这条路认真走一遍，因为它容易到有一个公式，能让你跳过中间九百九十九次，一步算出第一千次的样子。

这一层要给第 1 级那个能采样的一维分布加上一条毁掉它的路：一个只有乘法和加法、一个待训练参数都没有的前向过程。前两级跑的都是「数据本身长什么样」，还没有任何东西随时间变化。

3.1 掺一千次噪声，图还剩下什么

先把一步写下来。最朴素的写法就是直接加：新的数组等于旧的数组，加上一份高斯噪声，噪声的强度用一个小数 β_t 控制。这个写法能用，它真的会把图毁掉，我们先认真走它一段。

麻烦出在方差上。方差衡量一组数散开的程度，两个互相独立的随机量相加，方差直接相加。所以每加一步，整个数组的方差就往上涨 β_t。DDPM 用的那串 β 从 0.0001 线性涨到 0.02，一千个数加起来正好是 10.05。假设原图的像素值方差是 1，跑完一千步方差变成 11.05，标准差 3.32。

补救的办法就在右边那一栏里。加噪之前先把旧数组乘上一个略小于 1 的系数 c，这一步之后方差变成 c² · 1 + β_t。想让它还等于 1，就得让 c² = 1 − β_t，也就是 c = √(1−β_t)。这个根号不是为了好看，它是方差守恒方程的唯一解。DDPM 论文把这一步写成一个条件分布（式 2），意思和下面这行一模一样。

顺带说一件容易被跳过去的事。式 2 里每一步的 ε 都是新抽的，和前面所有步抽到的都没关系。这个独立性是下一节那个闭式解的全部本钱，如果哪一步偷懒把上一步的噪声拿来再用一次，式 2 单看还是对的，闭式解就塌了。

3.2 训练时真要一步一步加一千次吗

训练一次是这样的：抽一张图，抽一个时刻 t，把图加噪到 t，让网络去猜加进去的是什么。t 是随机抽的，抽到 800 就得从原图老老实实走 800 次乘加。一个批次几百张图、每张抽一个不同的 t，一轮训练几十万个批次，光是加噪这件不需要学习的事就要吃掉大半的算力。

但是两步是可以并成一步的。把第二步式子里的 x_t−1 换成它自己的展开式，看看会得到什么。记号上先做个简化，DDPM 定义 α_t = 1 − β_t，这样式 2 就是信号乘 √α_t、噪声乘 √(1−α_t)。

前向过程(forward process)：把干净数据一步步加噪直到信号被毁掉的那条固定的路。论文里也叫扩散过程(diffusion process)。它没有参数，所以不参与训练，只是训练时用来现场造数据的工具。

训练循环因此长成 DDPM 里 Algorithm 1 的样子，短到能背下来：抽一张图，从 1 到 1000 之间均匀抽一个 t，抽一份 ε，用式 4 一次乘加得到 x_t，然后让网络看着 x_t 和 t 去猜那份 ε。整条前向链在训练里从来没有被真的跑过一次。

3.3 β 按等差数列挑，哪里不对

调度这张表得有人来填。DDPM 的填法很朴素，T 取 1000，β 从 0.0001 线性涨到 0.02，一千个等差的数（§4）。挑这么小的数有两个理由，一是相对于压到 [−1, 1] 的数据要足够小，前向和反向才有近似相同的函数形式；二是要让终点尽量接近标准高斯，他们量出来的差距是每维 10⁻⁵ 比特。

这套数在 256×256 的图上工作得很好。一年后 Improved DDPM 在 32×32 和 64×64 上重跑，发现它不对劲，原话是这条调度「掉向零掉得快得多，毁信息毁得比需要的更快」（§3.2）。这句话听起来像风格评价，但它是有数的。

Improved DDPM 的改法是掉头填另一张表。他们不再去填 β，而是直接规定 ᾱ 这条曲线长什么样，再倒推回 β。想要的形状是中间近似匀速下降、两头平缓，他们挑了一个余弦的平方。

末尾那个截断同样有具体理由。不截断的话 β 在最后几步会顶到 1.0000，ᾱ 直接塌到 3.75e-33，而反向过程里要除以 √ᾱ，那一步就是除零。

3.4 哪一刻信号和噪声一样多

先把这个数定下来。x_t 里信号那一项的系数是 √ᾱ_t，噪声那一项的系数是 √(1−ᾱ_t)。比较两者的能量，就是比较它们的平方，于是很自然地得到一个比值。

把线性调度的 SNR 列出来，尺度感马上就有了：t = 1 时是 9999，t = 100 时 8.71，t = 400 时 0.242，t = 1000 时 0.0000404。九个数量级。取了对数之后 λ 从 +9.21 一路走到 −10.12，全程 19.33，这才是一根能画能读的尺。而 SNR = 1、也就是 λ = 0 的那一刻，线性调度落在 t = 260，cosine 落在 t = 497。上一节那张表里最有用的就是这两个数。

回头看这一章的标题。把 t 当成「第几步」是一种误解，t 真正的身份是这根尺上的一个刻度：给定调度，t 和 λ 之间是一一对应的，说「走到 t = 500」和说「走到 λ = −2.46」是同一句话。同一个模型换一套调度，同一个 t 对应的难度就变了，但同一个 λ 对应的难度不变。这是后面几章能把 t 换成别的参数、能跳着采样、能把两篇论文的记号对上的根本原因。

第4章 去噪：网络到底在学什么

上一章我们把一张图毁了一千次，每一步都有公式，一步都不用猜。现在把录像倒过来放。倒放的第一帧看起来一点都不难——屏幕上那团雪花只比前一帧多了一丁点噪声，按理说去掉那一丁点就行了。可到底去掉哪一丁点？这一章就在回答这个问题，而答案最后会塌成一个你在第 0 章就见过的东西：一个平方差。

这一层要给第 3 级那条加噪的路加上一个回头的走法：一个去噪器，外加一整条采样循环。前三级只会毁东西，还造不出任何新东西。

4.1 倒着走一步，凭什么猜得准

先把第二个选项错在哪讲清楚，因为它离真相只差一层。给定 x_t，可能的 x_t−1 确实有无穷多个，它们各自的可能性有大有小。要知道谁的可能性大，就得知道整个数据集里什么样的图更常见。这个分布写成符号是 q(x_t−1 | x_t)，它需要遍历所有可能的图，算不出来。

DDPM 的做法是绕过去。如果我们额外知道这条轨迹的起点 x₀，那么给定 x_t 和 x₀，中间那一步 x_t−1 的分布就是一个能写出来的高斯，均值是 x₀ 和 x_t 的一个加权平均（式 7）。

于是整件事被压缩成一句话：反向一步里唯一不知道的是 x₀。而上一章的式 4 告诉我们，知道 x₀ 和知道那份被掺进去的 ε 是同一回事，因为给定 x_t，两者可以互相解出来。网络要输出什么，到这里就被锁定了，剩下的只是选哪一种写法。

4.2 一堆吓人的数学，最后为什么塌成一个平方差

训练目标不是从天上掉下来的。DDPM 优化的是负对数似然的一个变分上界（式 3），写出来是一串对数和期望，第一眼看上去和「让网络猜噪声」毫无关系。中间发生了什么，值得走一遍，因为走完你会发现这一路上没有任何一步是魔法。

扔掉权重这件事还有一个副作用值得看。原来的权重 β_t²/(2σ_t²α_t(1−ᾱ_t)) 在 t 小的时候特别大，扔掉之后等于把小 t 的那些项降了权。DDPM 自己解释说这是好事：t 小时网络面对的是「去掉极小量噪声」这种几乎没有难度的任务，把它们压下去，网络才能把力气花在 t 大的硬活上。

4.3 预测噪声和预测原图明明等价，为什么差这么多

DDPM 把这件事做成了消融实验，两种参数化配两种目标，四格里有三格能跑出来。

这张表的读法不是「ε 更好」。前两行和第三行说明，在完整变分界下两种参数化打成平手（13.22 对 13.51）。差别是在换上简化目标之后才炸开的：ε 配简化目标把 FID 从 13.51 压到 3.17，μ̃ 配简化目标直接训不起来。也就是说，简化目标和 ε 参数化是一对，拆开任何一个都不成立。

4.4 网络在逼近的那个东西，能不能直接写出来

式 14 要网络最小化 ‖ε − ε_θ‖²。平方误差有一个所有人都该知道的性质：它的最小值点是条件期望。也就是说，训练到极限时，网络输出的已经不再是那一次抽到的那份噪声，它给出的是在看到这个 x_t 和这个 t 的前提下，噪声的平均值。

这句话有个很实在的后果。那个平均值是一个确定的函数，由数据分布和调度表共同决定，和网络长什么样、用什么优化器、训多少步都没有关系。网络只是在逼近它。既然如此，只要数据分布简单到能算，我们就能把这个函数直接写出来，看一眼网络在追的到底是什么。第 1 章那个一维高斯正合适。

分子分母里那对 (1−ᾱ) 和 √(1−ᾱ) 可以约掉一层，写成 √(1−ᾱ_t)(x − √ᾱ_tm) / (ᾱ_ts² + 1 − ᾱ_t)，两种写法完全一样。重要的是它的形状：对 x 而言这是一条直线。斜率在 t = 1 时只有 0.0400，到 t = 500 时 1.0200，到 t = 1000 时 1.0000，截距则从 −0.0400 走到 −0.006353。整个「网络」就是一次乘法加一次加法。

4.5 那个加回去的随机项，删掉会发生什么

σ_t 有两个现成的取法，DDPM §3.2 说两者实验结果相近，并且各自在一个极端情形下是最优的：取 β_t 对 x₀ 本身就是标准高斯的情形最优，取 β̃_t 对 x₀ 固定成一个点的情形最优。两者的差别在 t 大的时候几乎为零（t = 1000 时都是 0.14142），在 t 小的时候才拉开（t = 2 时是 0.01095 对 0.00738）。

下一章会把这件事再翻一次。DDIM 也要把随机项删掉，删完之后却不会塌成平均脸，因为它在删掉这一项的同时改了另外两项，让整条路不再是「逐步取平均」，而是沿着一条固定的轨道滑过去。这两件事看起来都叫「确定性采样」，得到的东西完全不同。

第5章 一千步太慢

上一章那条采样循环是对的，它也确实能造出东西来。问题是你按下回车之后要等。等的原因不在显卡不够快，在于那一千步必须一步一步来——第 700 步的输入是第 701 步的输出，一步不算完，下一步的网络前向根本没有输入可喂。整章要解决的就是这一件事。

这一层要给第 4 级那条采样循环加上跳步的能力：让它在不碰网络、不碰训练的前提下，从一千步缩到几十步。前四级跑的都是「每一步都必须走」的情况，还没有任何东西可以被跳过。

5.1 一千步慢在哪里

先把账算清楚。DDPM 在 §4 写明所有实验都取 T = 1000，理由是这样采样时需要的网络前向次数和当时的同类工作对得上。训练时网络被调用一次，采样时网络被调用一千次，这两个一千的性质完全不同。

数量级是什么样的？Improved DDPM 把 T 提到 4000 之后在 §4 里说，生成单张样本要在一块当时的现代 GPU 上花几分钟。DDIM 论文则给了一条更有用的规律（§5.1）：生成一张图所需的时间，随采样轨迹的长度线性增长。线性这件事既是坏消息也是好消息——坏在一千步就是一千倍，好在只要能把步数砍到二十，时间也就跟着砍到五十分之一。

5.2 反向过程凭什么一步都不能跳

这个观察值得再往下挖一层，因为它解释的不只是跳步。上一章我们从一条马尔可夫链出发，一路推到式 14。DDIM 反过来问：如果扔掉「前向必须是一条一步接一步的链」这个假设，只保留式 4 那些边缘分布，还剩多少自由度？

答案是剩下一整族。可以构造出一大批不同的前向过程，它们每一个时刻的边缘分布都和式 4 一模一样，只是把 x_t−1 同时依赖 x_t 和 x₀，不再是一条链。这一族里的每一个成员对应一个采样过程，而 DDIM 的定理 1 说：这一族的训练目标，彼此之间只差一个权重和一个常数。

这条结论的形状比它的推导重要得多。它说的是：训练和采样之间的接口，只有「在噪声水平 t 上的噪声预测」这一个函数。接口之外的一切——走几步、每步跨多远、要不要撒随机——都是采样时才决定的事。后面几章还会再用到它，因为流匹配、蒸馏、各种求解器，做的都是在同一个接口上换一种走法。

5.3 两篇论文的 α 是不是同一个东西

在读 DDIM 的公式之前，必须先处理一件会让你调试三天的事。DDPM 里 α_t = 1 − β_t 是单步的系数，连乘起来才是 ᾱ_t。DDIM 论文里没有 ᾱ 这个记号，它直接用 α_t 表示 DDPM 的 ᾱ_t。

记号重载：DDIM 论文中的 α_t，等于 DDPM 论文中的 ᾱ_t，也就是前 t 个 (1−β) 的连乘。DDIM 在附录 C.2 自己用一段彩色标注说明了这件事，并给了三条理由：这样只需要选一组超参数，减少派生变量之间的来回引用；便于引入推广形式与加速形式，因为它的推断过程不再由扩散过程推动；以及 α_1:T 和 1 到 T 之间存在一一对应，而 β_t 没有这个性质。

5.4 跳一步的公式长什么样

有了前面两节，更新式几乎可以自己推出来。既然网络能在任意噪声水平上认出噪声，那么站在 x_t 上想去 x_s（s 比 t 小，中间隔多远都行），最自然的动作只有两步。

DDIM 在 §4.2 给出跳步的具体做法：从 1 到 T 里挑出一个递增子序列，长度为 S，只在这些时刻上走。子序列上每一点的边缘分布仍然由式 4 保证是对的，所以中间跳过的那些时刻从来没有被需要过。§4.3 还指出，把式 12 改写一下就能看出它是某个常微分方程的欧拉法积分——欧拉法是数值求解里最朴素的那一种，把一条曲线近似成一串直线段，步子越短越准。这句话后面会兑现成一条很干净的误差规律。

5.5 η 从 0 调到 1，中间是什么

DDIM 把 σ_t 的取法参数化成一个数 η，写在式 16 里。这个式子的作用是把两个已知的端点连起来，中间的部分按比例插值。

5.6 两张表，为什么只有一张你能自己验

这张表支持的结论是 DDIM 论文 §5.1 自己下的那一句：DDIM 在 20 到 100 步之内达到 1000 步模型的质量，相当于 10 倍到 50 倍的加速。你相信这些数字，靠的是你相信作者；本站没有 CIFAR10，没有那个训练好的 UNet，也跑不动 FID 所需要的五万张样本。它是一份转述。

第二张表你可以自己按出来，而且它给出了第一张表给不了的东西：一条精确的规律。步数每翻一倍，误差就减半（5.299e-02 除以 2.522e-02 等于 2.10），这正是欧拉法一阶精度的签名，和 DDIM §4.3 那句「式 12 可以看成某个常微分方程的欧拉积分」严丝合缝。它能支持的结论是关于求解器的；它不能支持任何关于图像质量的结论。

第6章 潜空间：把算力花在看得见的地方

把一张照片存成 JPEG，压缩到十分之一体积，拿去和原图放在一起看，多数人分不出哪张是哪张。丢掉的那九成数据，丢的是你的眼睛原本就分辨不出的东西——一小块几乎同色的天空里那些像素到像素的微弱抖动，人从来没有认真看过。上一章那条一千步的采样循环，跑在整张图的每一个像素上，正好踩在同一个账上：它没工夫区分哪块是天空、哪块是发丝，每个位置都按同样的力气去猜。

这一层要给第 4、5 级那个已经能跑、能跳步的采样循环换一个战场：不再直接对着整张图工作，而是先把图压小，让整条加噪、去噪的机器在压小后的空间里跑，最后再翻译回像素。前五级的每一步计算都摊在原始分辨率上，还没有人问过这些计算是不是都花得值。

6.1 压缩掉的九成，你看得出少了什么吗

扩散模型在像素空间里干的事，恰好没有这么讲究。第 3 到第 5 章那条加噪、去噪的机器，不管某个位置是发丝还是天空，都按同一套公式去处理：一样的噪声、一样的一次网络前向、一样多的算力。这不是网络偷懒，是像素空间这个战场本身没有给它「跳过不重要的地方」这个选项——它拿到的输入就是一整张等大的数组，式 4 和式 14 对数组里的每一个位置都一视同仁。

先把量级摆出来。第 3 章那个 256×256 的例子有 65,536 个像素；换成 1024×1024，像素数变成 1,048,576，整整 16 倍。第 5 章说清楚了这一千步没法并行，每一步的网络前向都得老老实实排队；而每一步要处理的位置数又跟着分辨率涨了 16 倍，涨出来的这部分不会因为「步数不能并行」就有任何折扣，它老老实实叠在每一步头上，一千步一起承受。LDM 论文引用 ADM 的说法印证了这笔账有多贵：训练最强的那批扩散模型常常要花掉数百个 GPU 天，具体数字是 150 到 1000 个 V100 天（LDM §1）。这还是在没有算上把分辨率继续推高的情况下。

LDM 论文把学习一个数据分布这件事拆成两段来看（LDM §1）：第一段是感知压缩，删掉高频细节，但几乎不涉及语义上的变化；第二段才是真正的生成模型去学数据的语义和结构组成。像素空间里的扩散模型，被迫把这两段工作压在同一套网络、同一份计算里。

6.2 压缩到多小才合适，怎么试出来的

第 2 章已经埋下了这件事的雏形：VAE 训练一个编码器把图压成一小串数，一个解码器把它还原回去，两者绑在一起训练。LDM 把这套压缩器接到扩散模型前面——编码器先把图压进一个小得多的潜空间，扩散的加噪、去噪整条机器只在这个潜空间里工作，最后用解码器把结果翻译回像素。压缩多少合适，不是拍脑袋定的，论文把从几乎不压到压得很狠的整个区间都跑了一遍。

潜空间(latent space)：编码器把原始数据压缩后落脚的那个更小的空间，里面的每一个点仍然对应一张（近似）合法的图，只是坐标数少了很多。扩散模型在这里训练、在这里采样，只有最后一步才经过解码器翻回像素。

论文把压缩倍数记成 f，编码器把边长压缩到原来的 1/f，试了 f ∈ {1, 2, 4, 8, 16, 32} 这整整六档（LDM §4.1），其中 f = 1 就是完全不压缩、退化回像素空间扩散。两头都不好：f 太小，潜空间和像素空间没差多少，训练进度慢，第 6.1 节那笔账基本没省下来；f 太大，压缩器把太多信息一起删掉了，扩散模型能力再强也补不回来，样本质量早早地就卡在一个不高的地方不再上涨。

论文自己的结论写得很直接：LDM-4 和 LDM-8 提供了取得高质量合成结果的最佳条件（LDM §4.1）。这不是一个可以从头推导出来的数，是把六档都跑一遍、拿 FID 和采样速度一起比较之后选出来的经验区间——后面大多数基于 LDM 这条路线的模型，用的压缩倍数都落在这个区间里。

6.3 「压缩了六十四倍」和「压缩了四十八倍」，说的是同一件事吗

把 f = 8 这一档的具体数字摆出来，一个容易被混着说的地方马上就会露出来。一张 1024×1024 的图，边长压缩到 1/8，潜空间的空间网格变成 128×128，也就是 16,384 个格子——这是空间上的压缩，1,048,576 个像素格子变成 16,384 个潜空间格子，比例是 1/64。

但潜空间的每个格子不是一个数，是一个小向量。原始像素每个位置有 3 个通道（红绿蓝），LDM 常用的潜空间设定是每个格子 4 个通道。真正要数的是这张潜空间数组总共装了多少个数值：16,384 个格子乘 4 个通道，是 65,536 个数值；而原图是 1,048,576 个像素乘 3 个通道，是 3,145,728 个数值。两边一除，压缩倍数是 48 倍，不是 64 倍。

这两个数字都是真的，都能查到出处，问题只出在把哪一个安在「压缩了多少倍」这句话上。说「潜空间比像素空间小 64 倍」，说的是格子数；说「小 48 倍」，说的是真正要过网络的数值总量。后面几章但凡涉及算力账，用的都是数值个数这一条，因为网络处理的是数值，不是抽象的「位置」。

6.4 通道数从 4 涨到 16，又涨到 32，图什么

问题出在潜空间的「带宽」上。f 固定之后，空间上的格子数也就固定了，但装进每个格子里的信息量是有限的——4 个数能表达的细节，天生比 16 个数少。分辨率越高，同一个格子在原图上对应的区域携带的信息量通常也越丰富，4 通道这个瓶颈在低分辨率上还够用，到了高分辨率就先漏了。涨通道数是在说：宁可数值压缩倍数往下掉一些，也要保证每个格子能装下足够的信息，不让压缩器自己先漏成六三章那个 f=32 的下场。

涨通道数不是没有代价的。SD3 论文自己的对照实验显示：在 16 通道的潜空间上训练，需要更大的模型容量才能达到跟 8 通道相近的表现；深度加到 22 层时，8 通道和 16 通道之间的差距才变得可以忽略（Figure 10 caption）。换句话说，16 通道那份多出来的信息，扩散模型必须有足够的深度才吃得下去——深度不够的模型，学 16 通道反而不如学 8 通道来得准。通道数变多解决了「编码器漏信息」这一头的问题，把难题原样甩给了「扩散模型有没有本事学会这么复杂的潜空间」这一头。

6.5 一张图和一句话，该谁问谁答？

注意力机制(attention)在这里要解决的问题是：给潜空间里的每一个位置，配上一份从文字提示里挑出来的、跟它相关的信息。第 0 章讲过向量和矩阵，这里要做的事可以先用一个不严谨但管用的比方理解——每个位置带着一个问题去文字那边打听，文字那边给出一份和这个问题匹配程度不同的回答，匹配程度高的回答占的权重就大。

cross-attention：查询来自一种模态、键和值来自另一种模态的注意力机制。潜空间的每个位置发起查询，文字提示提供键和值，输出逐位置对应潜空间，形状和图像一致，文字有多长都不影响这个形状。

6.6 SDXL 把这条路线拉到多满？

SDXL 沿着这一整章的路线继续往前走，同时在好几个旋钮上一起使力。第一个旋钮是 UNet 本身的结构：早期 Stable Diffusion 在每个分辨率级别上都塞一个 transformer block（结构是 [1,1,1,1]），SDXL 把这套安排换成了一个不均匀的分布——最高分辨率那一级直接不放 transformer block，中间两级分别放 2 个和 10 个，同时把原来最低的那一级（8 倍下采样）整个去掉（SDXL §2.1）。这样调整之后 UNet 参数量涨到 2.6B，但这不是简单的整体放大三倍，是把计算力从「处理精细空间结构」的层挪到了「处理语义」的层。

第二个旋钮是文本编码器：SDXL 同时用了两个文本编码器（CLIP ViT-L 和 OpenCLIP ViT-bigG），把两者的输出在通道维度拼起来接进 6.5 节那套 cross-attention，另外还把 OpenCLIP 的池化文本向量额外接进网络（SDXL §2.1）。这部分文本编码器加起来是 817M 参数，本身不算进 UNet 的 2.6B 里，但一起决定了整个模型的部署体积。

第三个旋钮是两条跟分辨率、构图相关的微条件——之所以叫「微」，是因为它们不改变模型结构，只是往时间步嵌入上加了两小段额外信息。第一段是图像原始尺寸：LDM 这类两阶段模型训练时通常需要丢掉过小的图，SDXL 论文算过一笔账，如果直接按预训练分辨率过滤，会扔掉 39% 的数据（SDXL §2.2）；与其扔图，不如把每张图缩放前的真实高宽也编码成一份条件喂给网络，让模型自己学会「在什么原始尺寸下，图该长什么样」，推理时再把这个条件设成目标分辨率。

第二段是裁剪坐标：训练时批量处理图片常常需要随机裁剪，裁剪的位置如果不告诉模型，模型会把「裁剪导致的构图残缺」错当成一种正常的生成结果，SDXL 把裁剪的起始坐标也编码成条件喂进去，推理时把这个条件设成 (0, 0)，就能拿到构图完整、主体居中的图。

把这三个旋钮放在一起看，能看出这条路线走到了什么位置。SDXL 的每一处改动都是设计者盯着一个具体的失效现象——训练进度慢、小图被扔掉、裁剪构图残缺——手工调出来的答案，调法一个比一个精细：先是给不同分辨率级别分别配不同数量的 transformer block，接着让两个文本编码器分工，再往时间步嵌入里塞进两种和图像几何相关的条件。每一步都有效，但每一步也都需要有人先看出这个具体的失效现象，再设计一种专门的机制去堵它。

这就是这条路线目前撞上的墙：手工设计已经能榨出实实在在的收益，但每一次收益都要靠人盯着具体现象去调，调的地方越来越细——从压缩倍数，到通道数，到 transformer block 怎么分布，到往时间步嵌入里塞几段跟分辨率、裁剪相关的编码。继续往前走，边际收益正在变薄，而设计的复杂度还在涨。下一章要处理的问题就是：如果把这整套手工设计的 UNet 换掉，换成一种规模化本身就能决定该怎么长的结构，会发生什么。

第7章 扔掉 UNet

上一章那堵墙是这样的：SDXL 每往前挪一步，都要先有人盯着一个具体的失效现象——训练慢、小图被扔、构图被裁掉一块——再手工设计一种机制去堵它。这个流程本身就在提示一件事：UNet 那一整套下采样、上采样、跳跃连接，从一开始就是为图像量身定做的结构，量身定做的代价是每次改动都得重新量一遍尺寸。DiT 这篇论文问了一个更直接的问题：如果把这套量身定做的结构整个扔掉，换成一种几乎不针对图像做任何特殊设计的标准结构，会发生什么？

这一层要把第 6 级那个手工设计的去噪器，换成一套几乎不含图像专属结构的注意力网络。前六级的去噪器不管长什么样，骨架里都带着卷积、下采样、上采样这些专门为图像设计的部件，还没有人验证过这些部件是不是真的不可替代。

7.1 UNet 那套结构，是不是真的少不了？

UNet 里那套下采样、上采样、跳跃连接，不是随手加上去的，它编码了一条关于图像的假设：图像的结构是分层级的，局部的纹理、中等尺度的物体轮廓、整体的构图，各自适合在不同的空间分辨率上处理，所以网络也应该分层级地压缩、再分层级地放大，把不同层级的信息通过跳跃连接直接传过去。这条假设写进架构本身，就是归纳偏置(inductive bias)——网络在还没看到一个训练样本之前，就已经被这套结构逼着去用某种特定的方式处理数据。归纳偏置不是坏事：假设选对了，模型能用更少的数据学得更快；假设选得不合适，或者假设本身限制了规模化的空间，它就会变成一副越长越紧的枷锁。

7.2 图要先切成方块，切小一半代价涨多少？

把潜空间的网格切成小方块，每一块拉平、投影成一个固定长度的向量，这就是 patchify。给定 patch 边长 p，潜空间网格边长 I/f（I 是第 6 章那个原始图像边长，f 是 VAE 的压缩倍数），切出来的 token 数是：

patchify：把潜空间网格切成 p×p 的小方块，每一块拉平后线性投影成一个固定维度的向量，作为 transformer 的一个输入 token。切完之后再按标准 ViT 的做法加上位置编码（DiT 用的是正弦-余弦版本），因为 token 一旦被拉直成一条序列，原本的二维排列关系就丢了，需要额外告诉网络每个 token 原来在哪个位置。

DiT 论文特别指出一件容易被忽略的事：改变 p 对模型的参数量几乎没有影响，因为投影层的权重形状只取决于每块的像素数和目标维度，跟切出多少块无关；p 影响的只是 token 数，进而影响计算量（DiT §3.2）。这意味着同一套权重规模，通过调 p 就能换出好几种计算量档位，DiT 的实验里 XL 配置分出 /8、/4、/2 三档，参数量几乎相同（676M、675M、675M），Gflops 却分别是 7.39、29.05、118.64——差了 16 倍。

7.3 时间步和类别这两个条件，喂给谁听？

三种机制注入条件的方式完全不同。in-context 条件：把 t、c 的向量当成两个额外的 token，直接拼进图像 token 的序列里，跟处理 cls token 一样，不需要改动 transformer block 本身，几乎不增加新的计算量（DiT §3.2）。cross-attention 条件：把 t、c 单独编码成一个长度为 2 的序列，在每个 transformer block 里插入一层专门的 cross-attention（第 6 章那套机制的原样搬用），这是三者里开销最大的，大约给模型增加 15% 的计算量（DiT §3.2）。

第三种最值得细讲。自适应归一化(adaptive layer norm, adaLN)要解决的是另一件事：每一层在做归一化的时候，都会把数据缩放、平移到某个统一的范围，这中间有一组缩放系数和平移量。普通的归一化层里，这组系数是训练时学出来的固定参数，每次前向都一样；adaLN 的做法是不直接学这组系数，而是让网络看着 t 和 c 现场算出这组系数——同一层网络，喂进不同的条件，缩放和平移就不一样，整层的行为跟着条件一起变。这组系数只有两个：一个缩放、一个偏移，不管这一层有多少个 token，全部 token 共用同一组，这是它相对 cross-attention「粗糙」的地方。

adaLN-Zero在这个基础上多做一步：额外算出第三组系数——一个逐通道的缩放，乘在这一层输出、送入残差连接之前，并且把这组系数的初始化方式定成输出恒为零（DiT §3.2）。零初始化意味着训练刚开始的时候，这一整个 transformer block 的输出被这组系数乘成零，残差连接直接把输入原样传出去，整个 block 在训练第一步的行为等价于什么都没做。DiT 论文指出这个技巧借鉴自 ResNet 一系的做法——把每个残差块在初始化时设成恒等函数，能明显加速大规模训练（DiT §3.2）。

7.4 注意力的平方项，到底什么时候才追上线性项？

先把账目摊开，按乘加次数（MAC，一次乘法加一次加法算一次）来数，而不是笼统地说「注意力是平方复杂度」。一个 transformer block 里主要有三类矩阵乘法：

这张表带出一个不太直观的结果：DiT-XL/8、/4、/2 三档参数量几乎完全一样（676M、675M、675M——patchify 不改变投影层的权重形状，7.2 节已经算过这笔账），Gflops 却相差 16 倍，但如果把 Gflops 除以 token 数，每个 token 平均花掉的计算量几乎是同一个常数（约 0.46G）。这说明在 DiT 这个规模上，总计算量几乎完全由「线性项」主导，token 数翻倍，计算量跟着几乎翻倍，二次项那部分涨幅被线性项的体量盖住了，一直到某个 token 数之后，这个关系才会反过来。

现在解交叉点。二次项 2T²d 什么时候追上两个线性项的和 (4+2r)Td²？两边同时除以 Td，解出 T = (2+r)d，r=4 时就是 T=6d。

在 FLUX 这个规模的模型上（d=3072），把序列长度换算成实际会遇到的分辨率：1024×1024 时，算上文本 token，总序列长度是 4,608，这时候注意力矩阵只占总计算量的 20.0%；到了 2048×2048，序列长度涨到 16,896，占比才升到 47.8%——距离真正反超线性项，还差着一截。这和很多人凭直觉给出的说法正好相反：注意力的平方复杂度会在 1K 分辨率就成为扩散模型的主要成本，这句话在今天常见的生成分辨率上并不成立，真正的交叉点要到 2K 附近才出现。

这张账单还有另一面——显存。注意力矩阵本身是一个 T×T 的表，要不要把它完整地摆在显存里，不只是计算量的问题，也是空间的问题。1024×1024 分辨率下，图像 token 数 T=4,096，一个 T×T 的分数矩阵用 bf16（每个数 2 字节）存起来是 33.6MB；一个 FLUX 级别的模型有 24 个注意力头，24 个头一起是 0.81GB——这只是一层、一张图的数字，训练时一个批次里有很多张图、很多层，这部分显存会迅速滚雪球。这正是 FlashAttention 这类实现选择不把整个分数矩阵摆进显存、而是分块现算现丢的理由：省下来的不是计算量本身，是这张 33.6MB 表格在显存里占的位置。

第8章 把弯路拉直

第 5 章留下一堵墙：DDIM 能跳步，是因为它沿着一条弯曲的路径走了一条近似的捷径，步子迈大了，误差就跟着涨。那条从纯噪声通向数据分布的路径，从一开始就是弯的——越弯的地方，想走准就越需要小步子，这是那一章反复验证过的事。如果这条路径从一开始就被设计成一条直线，会发生什么？直线只需要知道起点和方向，按理说一步就该能走到终点。

这一层要把去噪器预测的目标从噪声换成速度场，并且在采样时加上分类器无关引导。前七级的采样路径都是弯的，需要几十到上百步小心地走；这一层要验证，把路径设计成直线之后，一步走到底在什么条件下是精确的，在什么条件下只是一个近似。

8.1 如果路径本身是直的，一步是不是就该走到底？

上一章的采样路径之所以弯，是因为它是被动推导出来的结果——先定义好怎么往数据里加噪声，再倒过来解那条对应的概率流方程，路径长什么样，是加噪声那条规则决定的，没有人主动设计过它的形状。Rectified Flow 换了一个思路：直接把路径定义成直线。给定一个数据点 X₀ 和一个噪声点 X₁——这里沿用全书的记法，下标 0 是数据、下标 1 是噪声，原始论文自己用的是反过来的记法（论文原文：「we set π0 to be the standard Gaussian distribution and π1 the data distribution」，即论文的 X0 是噪声、X1 是数据），这里把两个下标对调过来，和全书保持一致——中间时刻 t 的位置，就是这两点的线性插值，训练目标是让网络学会这条线段的速度：

这个训练目标和第 4、5 章预测噪声的目标，本质上是同一类东西——都是用均方误差去拟合一个目标值，只是目标从「噪声本身」换成了「两点之间的位移」。因为 X₁−X₀ 是一个不随 t 变化的常数，如果网络真的学到了这个目标，那么对某一对具体的 (X₀,X₁) 而言，它在这条线段上任何一点算出来的速度都应该是同一个向量。

但「训练目标要求路径是直的」和「训练出来的模型真的学到了一条直的路径」，是两件不同的事——这正是下一节要拆开看的地方。

8.2 每一条训练路径都是直的，学出来的那条路径也一定直吗？

这条道理不只是几何直觉，实验室里能直接算出数字。同一个一维高斯玩具问题（第 4、5 章那个 x₀~N(1, 0.5²)），换成 Rectified Flow 的方式重新推一遍最优速度场，再用不同步数的 Euler 法采样：

两条结论都藏在这张表里。第一条是真实的优势：步数相同时，RF 的误差大约只有 DDIM 的一半。第二条戳破了「一步走到底」的期待：RF 一步的误差是 1.000，和 DDIM 一步的 0.9907 几乎一样糟，直线路径的优势，只走一步时完全没体现出来。

这张表也留了一条退路。把数据分布的方差 s 一路调小、调到趋近于 0——所有数据几乎挤在同一个点上——这时候不同的 (X₀,X₁) 配对之间，路径还会不会互相交叉？答案是不会，因为终点几乎是同一个点，不同噪声起点连向同一个终点的直线，只在起点附近散开，彼此之间几乎不相交。这时候边缘化流真的是直的，RF 一步的误差降到 1.000000000000——不是「非常接近」精确，是浮点数精度范围内的精确。

8.3 路径不够直，能不能再把它拉直一次？

上一节看到，边缘化之后的流直不直，取决于训练路径会不会交叉，而真实数据几乎总会交叉。这不是一个只能被动接受的结果——RF 论文给出了一个能量化「有多不直」的指标，还给出一个能把它压下去的操作。

RF 论文接着证明了一件有用的事：把训练好的流反过来当成一个数据生成器，用它重新生成一批 (Z₀,Z₁) 配对，再用这批新配对重新训练一个新的流，这个操作叫 reflow。这不是随便配对——一个良定义的常微分方程，不同起点画出来的解路径，根据解的唯一性，彼此之间不可能在 t∈[0,1) 内相交（RF 关于「流不交叉」的性质）。

反复做这个操作，RF 给出一个可以量化的保证（Theorem 3.7）：连续做 K 次 reflow，这 K 次里最好的一次，它的不直程度有一个明确的上界。

8.4 图像和文字两路信息，要不要挤在同一套参数里？

论文给出的理由很直接：图像的 embedding 和文字的 embedding，概念上差别很大，所以用两套独立的权重分别处理（SD3 §4，MM-DiT 架构在这一节引入）。这等价于两个独立的 transformer，只是在算注意力的那一步，把两边的 token 序列拼接起来一起参与计算，让两种表示都能在各自的空间里工作，同时又能顾及到对方（SD3 原文：「this is equivalent to having two independent transformers for each modality, but joining the sequences of the two modalities for the attention operation, such that both representations can work in their own space yet take the other one into account」）。

8.5 训练时该在哪个噪声强度上多花功夫，是随便挑的吗？

前几章训练时，时间步 t 都是均匀随机抽出来的，0 到 1 之间每个值被抽到的概率一样。SD3 在这一点上做了一个具体的改动：不再均匀抽，而是从一个叫 logit-normal 的分布里抽——这个分布在 0 和 1 两端的密度很低，中间某个位置的密度最高，具体位置由一个参数 m 控制，m 是负数时偏向数据那一端（t 靠近 0），是正数时偏向噪声那一端（t 靠近 1）（SD3 §3.1：「enables us to bias the training timesteps towards either data p0 (negative m) or noise p1 (positive m)」）——这句话里 p0=数据、p1=噪声，和全书记法完全一致，不需要再做换算。

为什么不均匀抽更好？中间时刻的 t，对应的是「噪声和信号大致势均力敌」的状态，这时候网络要预测的速度场信息量最大，学起来最有用；越靠近两端，输入要么几乎是纯数据、要么几乎是纯噪声，网络更容易蒙对，练得再多边际收益也小。让训练多花时间在信息量大的区间，是这个改动背后的直觉。

第二个改动和分辨率有关。把一张纯色图像（所有像素值相同）加噪声，可以看成对同一个随机变量做 n 次独立观测再取平均，n 就是这张图有多少个像素（或者多少个 token）。观测次数越多，平均值的抖动就越小——n 个独立观测的均值，标准差会缩小到 1/√n 倍。SD3 把这个道理直接搬了过来，算出在时间步 t、像素数为 n 时剩余的不确定程度：

这个公式带来一个直接的推论：把图像的宽和高都翻倍，n 变成 4 倍，同一个 t 上的不确定程度就减半——原文写的是「doubling the width and height leads to half the uncertainty at any given time」。同一个数值的 t，在大图上实际代表的「离数据还有多远」，比在小图上要近得多；继续用同一套不考虑分辨率的时间步安排训练大图，相当于让大图在信息量最大的中间区间被系统性地训练不足。SD3 的做法是解出一个换算公式，给定小分辨率 n 上已经调好的 t_n，算出大分辨率 m 上能达到同样不确定程度的 t_m：

8.6 引导强度调大，到底是在做什么？

这两个写法代数上完全一样，但外推那个写法更直白地说明了 w 在干什么：w 越大，从无条件预测出发朝条件方向走的距离就越远，不只是走到条件预测那里，而是绕过它继续往前。这解释了为什么引导强度调太大会过饱和、丢多样性——朝一个方向不断外推，早晚会冲出「正常」图像该在的范围。

CFG 论文自己在 ImageNet 上报告，最好的 FID 出现在 w=0.1 到 w=0.3 之间（CFG §4：「We obtain the best FID results with a small amount of guidance (w = 0.1 or w = 0.3, ...)」），换算成 guidance_scale 大约是 1.1 到 1.3；而 Stable Diffusion 系列社区常用的默认值是 guidance_scale=7.5，对应 w=6.5——比论文自己认为的最佳区间高出二十倍不止。FID 衡量的是生成图像分布和真实图像分布有多接近，人眼觉得「好看」「贴合文字」，和这个统计意义上的接近，不是同一件事，这也是为什么两个数字会差这么远。

8.7 今天的开源图像模型，都在往哪几个方向走？

这本书从第 6 章到这里，一直跟着一条主线走——从 LDM 的潜空间压缩，到 DiT 扔掉 UNet，到 SD3 把图像和文字拆成两路参数。这条主线今天还在往前走，而且分成了几条并不相同的方向。

第一条是纯粹的规模路线。FLUX.2 的 dev 版本是一个 32B 参数的生成骨干；HunyuanImage 3.0 走的是另一种放大方式，总参数 80B，但用混合专家（MoE）架构，每处理一个 token 只激活其中 8 个专家，实际参与计算的部分远小于总参数量。两条路都是「更大」，但实现方式不一样——一个是老老实实把稠密网络做大，一个是把总容量做大、同时把每次实际计算量控制住。

第二条路线反过来，比的是「多小、多快」。Z-Image 是一个 6B 参数的单流 S3-DiT 模型，蒸馏之后 8 步就能出图；FLUX.2 klein 只有 4B 参数，走的也是把模型和步数都压到最小的路子。这条路线关心的不是能不能把质量做到最好，是能不能把同样过得去的质量做到最省。第三条路线的方向是多模态统一——不再只做「文字生成图像」这一件事，让同一个模型同时具备理解图像和生成图像的能力。这条路线这几年动作很多，但本书这一批论文材料没有覆盖到具体的架构细节，这里只标出方向，不展开讲。

还有一条贯穿这几条路线的趋势：文字编码器正在从 CLIP、T5 这类专用模型，换成完整的通用 VLM 或 LLM——FLUX.2 用 Mistral-3 24B 做文字编码器，Qwen-Image 用 Qwen2.5-VL，Lumina-Image 2.0 用 Gemma-2-2B。这带来一个不算小的代价：条件编码器本身可能比生成骨干网络还要大，部署的时候不再是一个模型，是两个大模型一起跑。

这一串名字里，没有一个能被称为「当前最好的图像生成模型」。原因很直接：这些模型评测用的基准、评测的方式都不一样，有的比 FID，有的比人类偏好投票，有的比特定风格下的生成质量，换一套评测标准，排在前面的名字就会变。FLUX.1 这个在下载量上名列前茅的系列，甚至没有一篇官方论文——它 19 层双流块加 38 层单流块的骨干结构，是从三个社区镜像仓库不约而同给出的配置文件里读到的，不是 Black Forest Labs 自己公布的数字。

第9章 多了一维时间

你已经会用扩散模型画一张图了。手边正好想要一段镜头：一只猫从地板跳到窗台。最直接的念头是——把这句话喂给模型，画出第一帧，再画第二帧、第三帧，一路画到第一百二十帧，按每秒二十四张的速度接起来放出来，不就是一段视频了吗？这一章先把这个念头认真走一遍，因为它撞的墙，正是后面所有设计的起点。

这一层要把第 1 级到第 8 级一直在处理的数据——一张图、一个一维分布——换成一串带时间轴的序列。前八级里时间要么不存在，要么只是加噪去噪过程自己的那个 t，画面本身永远只有一帧。这一层要让画面本身也随时间变化，而且要让相邻帧知道彼此的存在，不然它们连「相邻」这件事都不知道。

9.1 逐帧独立采样，第二帧的猫为什么不是同一只猫

这件事不用做实验也能想清楚，但做过一次就再也忘不掉。把同一句话喂给模型采样两次，得到的两张图从来不是同一张——耳朵形状、瞳孔颜色、光线角度都可能不同，这正是我们希望图像模型具备的性质：第 5 章讲过，一个训练好的去噪器配上一份新的初始噪声，就该给出一个新的、同样合理的样本。逐帧独立采样做的事情，是把这份「每次都不一样」的能力，原封不动地用在了一百二十次连续的采样上。让图像模型显得好用的那个性质，原样搬到视频上就成了缺陷。

9.2 时间信息该塞进网络的哪个环节

上一节那两条路都没让网络看到「这是第几帧」「前一帧发生了什么」。要把这些信息喂进去，最省事的办法是不发明新架构，直接在已经训练好、已经会画图的 2D UNet 上做手术。

Video Diffusion Models 就是这么做的。论文原话把前两步写得很直接：先把每个 2D 卷积换成「space-only 3D convolution」，比如把 3×3 卷积换成 1×3×3，帧轴单纯当批量轴；然后「insert a temporal attention block that performs attention over the first axis and treats the spatial axes as batch axes」，并且在每个时间注意力块里用「relative position embeddings」，让网络能分清帧的先后顺序，而不需要一个绝对的视频时间概念（§3）。

论文自己给出的理由是效率：分解式的时空注意力「is known to be a good choice in video transformers for its computational efficiency」，这个判断当时是在 16 帧、64×64 这个规模下做出的（§4.1），算力紧张到联合处理压根跑不起来。

9.3 十六帧封顶，怎么把视频拍得更长

这个最直接的办法有个名字，论文管它叫替换法：每一步采样时，把已知那一段直接替换成它自己按前向过程加噪之后的版本，强迫这部分数值对齐真实值，只让新的一段自由生成。听起来很合理，问题出在它只管住了数值，没有管住网络的预测方向——新的一段可以在数值对齐已知段的表面下，内容依然和已知段的语义脱节，因为网络从来没有被要求生成一个和已知段连贯的延续，它只是恰好被摆在了已知段旁边。

把这套修正写成公式：定义 x̂_a 为网络对已知段的重建、x̂_b 为网络对待生成段的原始预测（为了少写一层角标，这里把论文里的上标 a、b 改成了下标，意思不变）。

这套方法把 16 帧的模型延伸到了 64 帧（§4.3.3），用的是同一个思路反复应用：每往后生成一段，就把刚生成的这一段当成下一段的已知条件。它解决的是「能不能更长」，没有解决「一段视频里同时要塞进去的信息量本身有多大」——这才是下一节要算的账。

9.4 一段五秒的视频，要用掉多少个 token？

把六种真实存在的压缩方案摆在一起，才看得清这中间三十倍的差距具体分布在哪里。这里用到的公式是 BRIEF 给定的口径，1+(F−1)/D_T 是时间方向压缩之后剩下的 latent 帧数，那个「+1」来自下一章要讲的一个细节——3D VAE 对第一帧的处理方式和其余帧不一样。这里先照着用，不影响这一节要算的账。

这张表本身只是账本，真正要紧的是这些 token 最终要喂给谁——第 7 章那个花在注意力上的二次项。

第10章 在时间上也压

把一段视频逐帧摆开来看，第 30 帧和第 31 帧之间，除了猫的爪子往前挪了一点，地板、窗台、光线几乎一模一样。第9章那套办法——2D VAE 逐帧编码——对这份「几乎一样」视而不见，一百二十帧就老老实实编码一百二十次，把同一份信息重复存了一百二十遍。这一章要把这份重复利用起来。

这一层要给第9级那串带时间轴的序列，加上一层专门在时间方向上压缩的 VAE。上一级的六种方案里，不压时间维的那一种要付出 106 倍于单张图片的 token 代价；这一层要造出把这份代价压到零头的机器。

10.1 相邻帧几乎一样，2D VAE 在浪费什么？

这份差异有多大，直接决定了时间维上能压多狠而不丢东西。慢速运动的场景，相邻帧的差异可能只在几个像素上；快速运动的场景，相邻帧的差异会大得多——这也是本章末尾建造台阶要让你亲手量一遍的事。

10.2 卷积也能跨时间做，但为什么必须是因果的？

CogVideoX 和 Wan 都选了这条路。做法是把所有 padding 都垫在时间轴的开头，不垫在结尾——CogVideoX 的原话是「places all the paddings at the beginning of the convolution space… This ensures that future information does not influence the present or past predictions」。第 t 帧的输出只依赖它自己和更早的帧，从不依赖它之后的帧。

Wan 把这套设计写成了一个具体的例子（§4.1.1）：输入视频形状是 (1+T)×H×W×3，编码之后变成 (1+T/4)×H/8×W/8——开头那个「1」被单独处理，只做空间压缩，不参与时间方向的压缩，原文说这是跟随 MagViT-v2、专门用来更好地处理图像数据的做法。这就是为什么 latent 帧数不是简单的 F/D_T，而是接下来这条式子：

拿第9章算过的例子验一下：F=121，D_T=4 时，1+(121−1)/4=1+30=31，和第9章表1第二行的 latent 帧数正好吻合。

10.3 压缩率、通道数、画质，为什么不能三个都要？

这张表同时说明三件事。第一件是刚刚揭晓的：从 2D 换成 3D，闪烁从 93.2 降到 86.3，这一步几乎是白拿的。第二件看 A 到 C 这三行——压缩率固定在 8×8×4 不变，只把通道数从 8 一路加到 32，PSNR 跟着从 27.2 涨到 30.5，通道数能实打实换来质量，这和第6章 SD3 涨通道数的逻辑是同一件事。

第三件藏在 E 这一行，也是最容易被忽略的一件。把压缩率进一步推到 16×16×8，即便把通道数一口气加到 128——是基线的 32 倍——PSNR 不但没有继续涨，反而跌到 27.9，比 C 档（通道 32，PSNR 30.5）还要低。论文原话说得很直接：「when spatial-temporal compression is too aggressive (16×16×8), even if the channel dimensions are correspondingly increased, the convergence of the model also becomes extremely difficult」。压缩不是越狠越好，这是一个有拐点的权衡。

10.4 各家把时间压缩定在几倍，通道数又换来了什么？

HunyuanVideo 论文把自己的 VAE 拿去和另外几家的开源 VAE 对比，控制变量做得更干净——下采样因子全部锁定在 4×8×8，只看通道数不同带来的差别。

把各家实际用在产品里的取值摆在一起，能看出一条清楚的趋势：时间压缩几乎清一色定在 4 倍，例外是 Mochi 1 的 6 倍和 LTX-Video 的 8 倍；空间压缩正在从 8 倍这个老标准，往 16 倍甚至 32 倍迁移。

顺带说一句能不能拿来用的问题：这几家的开源协议并不统一。CogVideoX 的 2B 版是 Apache 2.0，5B 版换成了自家的 CogVideoX License；HunyuanVideo 用腾讯混元社区许可，明确不适用于欧盟、英国、韩国；Wan2.1/2.2 全系是 Apache 2.0，不带额外限制。同一张压缩率表格背后，能不能商用、能不能在哪个地区用，是完全独立的另一个维度。

10.5 空间压缩翻倍、patch 减半，token 数为什么没变？

第11章 时空 patch

第9章算过一段五秒视频要用掉十几万甚至四十多万个 token，第10章把这串数字里时间维那部分压掉了一大截。可这些 token 到底是怎么从一段视频里「长」出来的，两章都还没细说。压缩之后的视频，本质上是一个三维的方块——宽、高、时间，三个方向都有厚度。这一章要回答一个具体到不能再具体的问题：这个方块最后是怎么被切成一颗颗小块、拍平成一条 transformer 吃得下的序列，又是怎么被重新告诉每一块原来该摆在哪的。

这一层要把第10级那个三维的 latent 方块——时间、高、宽都已经被压缩过——切成一颗颗小方块，拍平成一条 token 序列，再给每一块一个能定位它原来在三维空间里哪个位置的编号。拍平这个动作本身会把方块原来的三维排列关系抹掉，不额外补上位置信息，模型就无从得知哪一块跟哪一块在时间上相邻、哪一块跟哪一块在空间上相邻。

11.1 一段视频，为什么可以看成一摞时空方块？

Sora 报告把这件事说得很直接：先训练一个「video compression network」，把视频压缩到时间空间都降维的隐空间——这正是第10章因果 3D VAE 在做的事，报告原话是「Sora is trained on and subsequently generates videos within this compressed latent space」。压缩完之后，「Given a compressed input video, we extract a sequence of spacetime patches which act as transformer tokens」——这串 patch 专门起了一个新名字，既不叫「帧」也不叫「像素块」，因为它们从一开始就不是纯空间的，也不是纯时间的。

这个实验室摆出一段视频原始的三维方块——时间、高、宽都有厚度，再摆出经过压缩和 patch 化之后剩下的方块，两者并排对比，能直接看见这一路压缩把方块削小了多少、最终落地成了多少个 token；真实模型的 patch 数动辄几万个，这里为了看得清楚只挑一小把摆出来。

11.2 原生分辨率、时长、宽高比训练，为什么反而更好？

在 patch 化之前，生成模型的通行做法是把每张图片、每段视频都缩放或裁剪到同一个固定尺寸，好凑成一批规整的数据一起训练。Sora 报告反过来做——「Our patch-based representation enables Sora to train on videos and images of variable resolutions, durations and aspect ratios」。

这件事能成立，根子在 patch 化本身不对输入尺寸做任何假设：一段视频不管多长、多宽、多高，切出来的 patch 数量按第9章那条公式自动算出来，不需要模型的输入层预先写死一个固定形状。传统卷积网络的末端通常要接一层和输入尺寸绑死的全连接层，缩放裁剪因此成了不得不做的预处理；patch 化配上天生能吃变长序列的 transformer，第一次让这层预处理变得没有必要。

11.3 patch 拍平成一串 token 之后，模型怎么知道每一块原来在哪？

RoPE(Rotary Position Embedding，旋转位置编码)：不是把位置信息加到 token 向量上，而是按 token 的位置对它的一部分维度做一次旋转操作。两个 token 之间的注意力分数，最终只取决于它们旋转角度的差，也就是只取决于两者位置的相对距离，不取决于各自的绝对位置。第9章提到 Video Diffusion Models 选的是「relative position embeddings」而不是绝对帧号，RoPE 正是把这个选择具体实现出来的一种办法。

HunyuanVideo 的 3D RoPE 把这件事说得很具体：先把每个坐标（时间 t、高 h、宽 w）各自算出一套旋转频率，再把注意力头的维度切成三段，每一段只用其中一个坐标去旋转，最后把三段拼回去（§4.2）。切法不是均分：

三个坐标各自的旋转频率之外，还有一个数字的来源要单独交代：patch 本身的三维厚度。HunyuanVideo 论文用符号 k_t×k_h×k_w 表示这个量，正文只给了符号，不含具体数字；第9章表1里用的「1×2×2」，来自 Open-Sora 2.0 附录 F.1 用 HunyuanVideo 做跨模型 token 数对比时所用的配置，和公开代码仓库的默认设置一致（C档，本站综合两处旁证推断，不是 HunyuanVideo 论文自己给出的数字）。

11.4 文字标注本身，是不是也是一个不断升级的生成问题？

11.5 拍下来的素材，要闯过几道关卡才能喂给模型？

SVD 的筛选流水线按顺序做四件事：先把长视频切成不含镜头切换的短片段，再过滤掉画面几乎不动的静止片段，然后用 CLIP 打一个视觉美学分，最后把画面里文字过多的片段也剔除掉。

切完片段之后，第二关是光流过滤：以每秒 2 帧的频率算稠密光流，把平均光流幅度低于某个门槛的片段判定为「静止场景」剔除掉——专门对付「画面几乎不动」这种偏差。第三关是 CLIP：分别对片段的首帧、中间帧、尾帧打一个视觉美学分，分数太低的片段也被剔除。第四关是文字检测：用现成的文字检测器 CRAFT 标出画面里所有文字的包围盒，文字覆盖面积超过画面 7% 的片段被剔除——SVD 论文说早期版本的模型学会了在生成的画面里塞入大量文字，这不是文字生成视频模型该有的行为。

第12章 注意力顶不住了

把一段五秒的720P视频喂进HunyuanVideo，等它吐出画面要十五分钟。这十五分钟里，九成时间只花在一件事上——一个在第七章里被证明「不值得担心」的操作，注意力。这一章要看着同一道算式，在视频上把那个结论整个翻过来。

这一层要给第11级那套时空patch加一层过滤：不再让每个token和其余全部token都算一遍注意力，只让它和一个局部邻域算。前11级跑的都是把token造出来、排好位置的事，还没有人问过要不要把每一对token都算一遍。

12.1 第七章说不用担心，视频上还这样吗

把这笔账摊开看。第七章的份额公式是share = T / (T + (2+r)·d)，T是token数，d是隐藏维度，r是MLP比自注意力多摊的倍数。DiT-XL在T=256、d=1152、r=4时，代入算出3.57%，和论文报告的3.6%对上。放到今天常见的生成分辨率，比如1024×1024、d取FLUX那一档的3072，token数是四千零九十六，同样代入公式，份额是四千零九十六除以四千零九十六加一万八千四百三十二，约18.2%——和FACTS.md里给出的另一个数字（1024×1024、含文本token共4608时占20.0%）差得不多，差的那一点来自要不要把文本token也算进T里。图像线上不管取哪个分辨率，二次项都还是配角。

12.2 明知更贵，为什么还选全时空注意力

三条理由值得逐条摊开。第一条是效果：论文引了多篇此前工作的对照，全时空注意力的生成质量，好于先空间后时间或者先时间后空间这类分开算的路。第二条是训练流程：一张静止图片可以被当成只有一帧的视频，用同一套全注意力模块处理，图像和视频从此共用一套训练代码和一套模型权重，不必为分开算的那条路单独维护一套时间维度的模块。第三条是工程生态：大语言模型社区这几年把全量的、不分块的自注意力优化到了极致，FlashAttention这类算子就是为这种形状的注意力设计的。选全时空注意力，意味着可以直接搬来这整套现成的加速代码，不用为分开算的那条路重新写一遍kernel。

12.3 贵出来的账单，陡到什么程度

选了更贵的那条路，贵多少总得有个数。CogVideoX团队直接做了对照——同一个模型，把全时空注意力换成分开算空间和时间的版本，在三档分辨率下各跑一次单次前向，量出的是H800上真实的墙钟时间，不是理论FLOP。

三档分辨率里，分辨率每往上跳一档，额外开销不是按同一个倍数涨，是越往后跳得越猛——从7.9%到67%，再到130%，涨幅本身在加速。

这份对照表量的是单次前向，一次真正的视频生成要跑几十次这样的前向，再叠上文本编码、VAE解码这些环节。把这些都算进去，STA论文给出了一个更直接的数字：HunyuanVideo生成一段5秒720P视频，总共945秒，其中注意力单独占了800秒，占比84.7%。这个数字已经是配好FlashAttention-3这个当时最快的精确注意力实现之后测出来的——算子本身优化到了极致，也没能把这个比例压下去，因为FlashAttention-3加速的是怎么算这个矩阵，没有改变要算多大的矩阵。

12.4 没人规定它该看哪儿，它自己怎么看

这里的15.52%和70%说的是同一件事的两个角度。先把每个query token的注意力分数按大小排序，划出一个以它为中心、覆盖全部token空间15.52%体积的局部窗口——这个窗口在空间和时间上都有一定宽度，不是只顾一头；再把落在这个窗口内的分数加起来，除以这个token全部的注意力分数，平均下来是70%。这个token剩下84.48%的可选范围，总共只贡献了30%的注意力。

这份局部性还有一层细节。不同的注意力头，专精的窗口大小并不一样——有的头只盯着很小的一块区域看细节，有的头把窗口开得很大去抓整体的上下文，论文把这个现象叫做头部专化。更重要的是，同一个头在不同的输入提示下，倾向的窗口大小基本保持一致，专化模式跟着头走，不太跟着内容走。

12.5 知道该看哪儿了，怎么真的省下计算

知道注意力集中在局部窗口，最直接的想法是照着这个窗口把注意力算一遍，窗口外的直接跳过。这类做法叫滑动窗口注意力，在处理长文本的模型里已经用了多年：每个token只和自己附近的一小圈token算注意力，窗口跟着token一起滑动。把这个想法原样搬到视频的三维token上，理应能省下大部分计算。

问题出在GPU怎么算这件事。FlashAttention把整个注意力矩阵切成一块一块的小方块，每一块里的query和key一起搬进片上高速缓存，算完再搬出去，这样才不用把整个T×T矩阵摊在显存里。如果每个token的窗口都是围绕它自己滑动的，相邻两个token的窗口只差一点点，同一块里不同的query，各自该保留哪些key并不完全一样——这样的块被称为混合块：块内一部分位置要算、一部分要丢，GPU没有办法只算需要的那一部分，只能把整块都算出来，再拿掩码盖掉不要的部分。省下来的只是最后要不要保留结果，没有省下计算本身。

STA换了一个更粗的滑动单位。它不再让窗口跟着每一个token滑动，而是先把token分成一块一块的瓦片——比如三维空间里12×24×24个token算一块——让同一块瓦片里的全部token，共享同一份要看的key瓦片范围。这样一来，一块的query只对应一份完全确定的key范围，块要么整块保留、要么整块丢弃，不再有块内一部分要一部分不要的情况。同样的局部性，换一个滑动的单位，GPU就能把省下来的计算真正省掉。

滑动瓦片注意力(Sliding Tile Attention, STA)：把滑动窗口的单位从单个token换成一整块瓦片，让每块的query只对应一份确定的key瓦片集合，消除混合块的做法。

两档差出来的1.89倍，买的是模型完全不用再碰一次的省心；微调那一步只用了8块H100、8小时，换来的是耗时再降近一半，而生成质量几乎没有变化——VBench这项综合评测的总分只掉了0.09个百分点。免训练版本更适合等不起重新训练的场景，微调版本更适合能接受一次性投入、追求更快速度的场景，两者面对的是同一份局部性，只是要不要为了再多榨一点速度多付一笔训练成本。

12.6 稀疏之后，那个平方项去哪儿了

省下计算量，最终该看到的效果是——token数翻倍，耗时不该跟着翻两倍以上，该更接近翻一倍。HunyuanVideo 1.5的官方耗时表，正好给了这个对照。

帧数从121涨到241，接近翻倍。不开稀疏时，耗时从2.0084秒涨到5.5070秒，涨了2.74倍——比帧数本身的涨幅高出不少，这正是二次项在起作用：帧数翻倍，token数也大致翻倍，而二次项跟着token数的平方涨，理应比token数本身涨得更猛。开了稀疏之后，耗时从1.5638秒涨到2.9475秒，涨了1.88倍，已经很接近帧数本身的涨幅——这就是稀疏化真正买到的东西：不是让每一步都变快一个固定倍数，是把耗时随帧数增长的规律，从比平方还猛，压回了接近一次方。

Wan的技术报告用另一套记号把这条规律写成了公式。DiT一层的计算量正比于α·b·s·h²+β·b·s²·h，s是token序列长度，h是隐藏维度，b是批大小，α对应线性层（投影、MLP）的开销，β对应注意力层的开销；论文里非因果注意力（Wan用的这一种）的β，前向传播是4，反向传播是8。

论文的结论写得很直接：序列长度一旦到了一百万，注意力的计算时间能占到端到端训练时间的95%。

显存这边的规律不一样。GPU要为激活值（反向传播算梯度需要保留下来的中间结果）占用的显存，正比于γ·L·b·s·h——这一项只跟着s线性涨，不像计算量那样跟着s平方涨。γ这个系数由具体实现决定，普通大语言模型大约是34，DiT因为要同时处理视频token、文本提示、还有时间步这三种输入，γ能超过60。序列长度到一百万、批大小为1时，一个14B参数的DiT，光是激活值占用的显存就能超过8TB——这个数字远超单张GPU、甚至单台服务器能提供的显存，这也是为什么大规模视频模型训练离不开跨设备切分序列这类并行策略。

12.7 峰值成本，能不能干脆不随时长涨

MAGI-1走了一条不同的路，不再继续优化某一步注意力怎么算，而是换掉一次性处理整段视频这个前提。它把视频按24帧切成一段一段的分块——按24帧每秒的帧率算，正好是一秒钟一块——让噪声水平随时间单调递增：靠前的块噪声水平低、更接近生成完成，靠后的块噪声水平高、还处在早期的去噪阶段。模型只需要在任意时刻，同时持有正在推进的这几个相邻分块，不需要把整段视频从头到尾都摊在显存里。

分块自回归(chunk-wise autoregressive)：把序列切成固定长度的块，按顺序逐块生成，同一时刻只需要在场的是当前块和它依赖的少数邻近块，而不是整条序列。

这样带来的好处很直接：推理的峰值成本，不再随视频总时长增长——不管最终要生成5秒还是50秒，任意时刻同时在场、占用显存和计算的，都只是固定数量的几个分块，多出来的时长只是让这个滚动窗口往前多滑动几次，不会让某一时刻的峰值负担跟着堆高。这也顺带带来另一个好处：因为生成本来就是按时间顺序、一块接一块推进的，前面的块可以边生成边往外吐，不需要等整段视频全部生成完才能看到第一帧，天然适合流式播放这类场景。

第13章 条件怎么接进来

把一张你自己拍的照片喂给一个训练好的文生视频模型，让它接着往下演——模型会愣住。它从出生到现在，见过的输入只有一份纯噪声和一句话，从没见过「这一帧已经定了」这种要求。这一章看三个团队，怎么各自把这道从没被问过的问题，接出一条真正能用的线路。

这一层要给采样这一步开一个口子：允许序列里不同的token各自带着自己的时间步，第一帧对应的token可以被钉在一个很低的时间步上，其余token照常参与去噪。前12级造出来的每一步，还都是整段序列共享同一个时间步在走。

13.1 凭空生成和接着这张照片往下演，是同一件事吗

这不是一个新问题，是这本书第一次真正遇到「部分已知、部分未知」的生成任务。前面十二章的训练目标从来只有一种：给一段带时间轴的噪声轨迹，学会把它变回数据。图生视频要求的是另一件事——同一条轨迹里，有一部分（第一帧）从起点就已知道答案，其余部分仍然从噪声开始。模型要同时做到两件事：完全保留已知的那部分，又不能让已知和待生成的部分脱节成两段互不相关的内容。

接下来三节要看的，是三个团队对「怎么把这部分已知信息接进去」给出的三种完全不同的答案：Wan给模型的输入多开几条通道；LTX-Video放开「所有token共享一个时间步」这条从没被要求过的假设；HunyuanVideo一边替换token、一边单独给模型补一次语义理解。三条路解决的是同一个问题，但没有一条是显而易见的。

13.2 多出来的通道，怎么才能不搅乱原来的模型

Wan给出的第一种答案，思路很直白：把条件图编码成和视频latent同样形状的东西，沿通道这一维直接拼上去，让模型的输入变宽。参考图先和一串全零帧沿时间轴拼起来，凑成一段和目标视频等长的引导视频，送进Wan-VAE编码，得到条件latent z_c；再准备一份二值掩码，标出哪些位置已知、哪些待生成，按VAE的时间压缩倍数重新排列，和视频本身的噪声latent z_t一起，沿通道轴拼成一个更宽的输入。

这样一拼，模型的输入通道数就变了。原来的T2V模型只认c个通道，现在z_t、z_c各占c个通道，掩码再占s个通道，总数变成2c+s，比原来宽出一倍还多。多出来的这些通道得有一层新的投影，才能接进模型原本的隐藏维度，而这层投影是随机初始化还是另有讲究，决定了微调一开始模型会不会被带偏。

零初始化(zero initialization)：把新增的投影层权重全部设为0，使微调起点的模型行为与新增输入无关、与原模型完全一致，新增能力靠后续训练逐步长出来，不是一开始就介入。

掩码和通道拼接负责的是细节这个维度——它告诉模型哪些像素是钉死的、要原样保留。Wan还单独加了一条通道，处理大意这个维度：把条件图送进CLIP的图像编码器，抽出一份全局特征，经过一个三层MLP投影，通过独立的一路交叉注意力注入模型——这一路和文本走的是同一种机制，只是喂的是图像的全局语义，不是逐像素细节。两条通道分工不同，一条保真，一条达意。

13.3 一段视频里，非要所有token共享同一个时间步吗

这份不需要新增参数，正是这个方案被称为三条路里最省事一条的原因。Wan要多开2c+s个通道、接一层新投影、还要另配一路CLIP加交叉注意力；HunyuanVideo要做token替换、外加一整套语义注入模块。LTX-Video要做的只是把「一个样本一个t」放宽成「一个token一个t」，把原本给整个样本用的那份机制，原样搬给每个token单独用一份，模型结构一行没改，模型见过的参数量一个没多。图生视频能力不是靠加零件换来的，是靠放松一条从没被要求过的假设换来的。

13.4 只做token替换，模型就懂这张图在说什么了吗

HunyuanVideo接图生视频的第一步和LTX-Video的思路不太一样，走的是token替换：把参考图编码出的latent，直接当成第一帧的latent使用，对应的时间步设成0，其余帧的处理和T2V训练完全一致。这一步单独看，和LTX-Video条件帧t设成0利用的是同一条整流流插值公式在t=0时的精确性质。

但只做到这一步还不够。token替换保证的是第一帧像素细节被原样保留，管的是重建，不是理解——模型能看到这帧latent，不代表能像理解文本提示那样，读懂画面里是什么内容、接下来大概率会发生什么。一份为像素重建优化的VAE latent，不天然包含「这是什么」这层语义信息。

HunyuanVideo的做法是单独补一条语义通路：把参考图送进模型本来就用来编码文本提示的那个多模态大语言模型，取出一份语义图像token，拼接进视频latent token序列里，一起参与全量注意力。这条通路和token替换各管一段：token替换保重建、保细节；语义注入保理解、保内容的连贯性。

13.5 patchify这一步，凭什么不能让VAE自己做

第11章讲过标准流程：VAE把像素压缩成latent，再由一个独立的patchify层，把相邻几个latent格子拼成一个token，送进transformer。典型配置是VAE做8×8×4的时空压缩、通道从3提到16，patchify再拼2×2×1，两步合起来是1:1024的像素:token比。LTX-Video的问题是：VAE本身就是一个可学习的压缩器，为什么还要在它后面再接一个不参与学习的拼接操作？

LTX-Video把patchify直接挪进VAE编码器内部，让VAE一步到位压缩到token粒度：32×32×8的时空压缩，配128个通道，不再需要额外的patchify层。算一下压缩率：每个token对应的像素是32×32×8=8192个，是典型方案1024或2048的四倍；把RGB三通道也算进去，一个token吃进32×32×8×3=24576个像素值，压缩到128个latent通道，24576/128=192倍，这就是论文说的1:192总压缩率，是典型方案1:48或1:96的两倍。

把patchify交给VAE解决的是压缩率的问题，LTX-Video还顺手解决了另一个问题：压缩率越高，扩散采样留下的残余误差在解码时越容易变成明显的伪影，因为编码器把高频细节压得更狠，解码器要凭更少的信息把它们猜回来。LTX-Video的解法是让VAE解码器多干一件事：不只是把latent转换回像素，还承担最后一步去噪——解码器额外接收时间步作为条件，直接从一个还带着少量噪声的latent，一步输出干净的像素，而不是先在latent空间去噪完，再交给一个只管转换、不管去噪的解码器。

去噪解码器(denoising decoder)：VAE解码器额外以扩散时间步为条件，在把latent转换成像素的同时完成最后一步去噪，直接输出像素空间的清晰结果，不把去噪和解码当成两个互不相关的步骤。

13.6 画面和声音，能不能先出一个再配上另一个

这不是HunyuanVideo这一个模型的问题，是先画面、后声音这个两阶段流程本身的结构性代价。声音生成模型只能通过画面生成完之后留下的某种摘要（CLIP特征、字幕，或任何形式的中间表示）去猜测发生了什么，这份摘要不管做得多精细，都是对原始时间轴的一次压缩，压缩就会丢信息。Ovi和LTX-2给出的方案是把这两阶段合并成一次：用一个模型，同一次前向，同时把画面和声音都生成出来，让两者在生成过程的每一步都能互相看到对方最新的状态，不必等一方彻底定型之后，另一方才开始工作。

13.7 权重能下载，是不是就等于能拿去商用

这本书讲到的视频模型，开源二字底下藏着至少三个互相独立的问题：权重能不能下载？下载下来能不能商用？训练过程和数据是不是也公开、可复现？三个问题的答案经常并不一致，混着用开源这一个词，容易把「能看到权重」误当成「什么都能做」。

训练成本这件事本身就很少被公开。Open-Sora 2.0是少数把训练成本拆开公布的项目：256px文生视频阶段用了2240个GPU-day，花费10.75万美元；256px图生/文生视频联合阶段384个GPU-day，1.84万美元；768px阶段1536个GPU-day，7.37万美元；三个阶段加起来4160个GPU-day，共计19.96万美元——按每GPU每天24小时、每小时2美元反算，4160×24×2=19.968万美元，和论文报的数字对得上。这份透明度在同类项目里并不常见，多数模型的训练成本只能靠社区自己估算。

显存门槛从8GB到60GB，跨度接近八倍——同一类「消费级显卡够不够用」的问题，不同模型给出的答案差着一个数量级。许可证这边的跨度同样大，而且更容易被忽略。

第14章 声音在计算机里是什么

戴上耳机，或者点开手机里录音笔存的一段话，你听到的是一段连续的声音，没有格子，没有像素，似乎也没有什么可以拆开来数的东西。但只要这段声音能存成一个文件，它在计算机里就必须是一串数字——前十三章画的每一张图，最后也是一堆数字，只是这堆数字排列的方式，和声音完全不是一回事。

这一层要给建造台阶换一种原料：从图像的像素格子换成声音的波形数组。前十三级处理的数据，不管压缩成什么样，骨子里都是空间格子；这一级要接入一条完全没有空间、只有时间的一维数组，还要让读者亲手验证量化这件事到底在干什么。

14.1 一段录音在电脑里到底是什么

声音本身是空气压强随时间的起伏。有人说话、乐器振动、喇叭震颤，都是在推动周围的空气一下一下地压缩和舒张，这股压强变化以固定速度向外传播，撞到耳膜或者话筒的振膜上，让它跟着一起振动。录音要做的事情很直接：用话筒把这股连续变化的压强变成一段连续变化的电压，再每隔很短的时间量一次这个电压，记下一个数。量得越勤，记下来的这串数字就越能还原原来那条连续曲线的细节，这个「量得多勤」就是采样率，单位是赫兹，表示每秒钟量多少次。

数字给到具体的场景里才有分量。16kHz 是很多语音识别系统常用的采样率，意思是一秒钟量 16000 次，每次记一个数，一秒钟的录音就是 16000 个数排成一条线，正是第0章已经算过的那句话。24kHz 是 Tacotron 2 这类高质量语音合成常用的采样率，一秒钟是 24000 个数。把这两个数字摆到第0章那张 512×512 的彩色照片旁边——那张照片是 786432 个数——一秒钟的语音听起来是小巫见大巫：16000 也好，24000 也好，都只是那张照片零头的零头。

采样率(sampling rate)：每秒钟对连续信号测量的次数，单位赫兹（Hz）。16kHz 表示一秒钟测 16000 次，测得越勤，记录下来的数字越能贴近原始的连续曲线。

第0章还说过一句更扎心的话：图像好歹有高、宽、通道三个轴可以互相参照，声音只有时间这一个轴，每个时刻孤零零一个数，不知道自己往左往右挨着的是谁在做什么形状。这条只有一个轴、数字个数看起来又不多的数组，会在下一节暴露出它真正的麻烦——麻烦根本不在「数字有多少个」，而在「这些数字必须按什么顺序被造出来」。

14.2 为什么不能像图像一样直接把波形画出来

认真走一遍这条最朴素的路：把生成一段波形，看成逐点预测的问题——给定前面已经生成的所有采样点，网络输出下一个采样点最可能是什么。这正是 2016 年 WaveNet 的做法，论文把整段波形的联合概率，直接写成一串条件概率相乘：p(x) = ∏_t p(x_t | x₁,…,x_t−1)（WaveNet 式 1）。每一个采样点的分布，都要看着它前面所有已经出现过的采样点来定。这套写法有个名字。

自回归(autoregressive)：把一整条序列的生成，拆成一步接一步的条件预测——每一步都以前面已经生成的全部内容为条件，预测下一步该是什么。

问题来了：给定前面几万个采样点，网络要怎么看到足够长的历史，才能预测得准？最简单的卷积网络，每层只能把感受野往外扩一点点，摞很多层才能看到够长的历史，层数很快就会多到训练不动。

感受野的问题解决了，下一步是要不要用扩张因果卷积把每一步都算成一个具体的实数。这里论文没有选最直接的均方误差回归。

类别分布要求每一步给全部可能值都算一个概率，16 位整数存的波形有 65536 种可能值，这个数量级直接输出softmax 层会太大。WaveNet 用了一次非线性压扩，把取值范围先收窄到 256 档，14.3 节马上要讲这一步具体怎么做。用这套完整方案训出来的 WaveNet，在 Table 1 的主观评分里第一次把合成语音的自然度推过了拼接合成：英语上 WaveNet 拿到 4.21 分，同一批测试里最好的拼接合成基线是 3.86 分，统计参数合成的基线只有 3.67 分（满分 5 分的 MOS，§3.2）。

这笔代价有多大，HiFi-GAN 论文的 Table 1 专门测过：在一块 V100 GPU 上，WaveNet（混合逻辑斯谛输出版本）合成语音的速度只有 0.07kHz，也就是实时率 0.003——生成 1 秒钟的音频，要在 GPU 上跑 333 秒（这一行的 CPU 那一栏论文原文是空的，没有测；本站核对过原始表格，速度数字标在 GPU 那一栏，不是 CPU）。GPU 本该最擅长同时处理大量数据，但一整块 GPU 在这里几乎是闲置的——它能同时算的是一层里的很多个卷积核，算不出「还没生成的下一个采样点」，16000 次前向必须一次接一次地排队做完，这正是自回归结构焊死的那条串行链条。这个数字，就是第 1 章埋下的「实时」这堵墙第一次真正现身，也是接下来几章一直在想办法拆掉的东西。

14.3 μ-law：256 个档位怎么分给一个连续信号

WaveNet 的解法不是重新设计量化的档位数，而是在量化之前先用一个非线性函数，把小信号「拉伸」、把大信号「压缩」，让原本挤在 0 附近的大量小幅度样本被拉开，分到更多的档位。这个非线性函数来自电话通信里的老技术，论文原文写成 μ-law 压扩变换（式 1）。

把几个具体的幅度代进式 1 就能看出这条曲线有多不客气。幅度只有 0.01 的一个很轻的信号，压扩之后是 0.2285，对应到 256 档里的第 157 档；幅度到 0.5 的一个响亮得多的信号，压扩之后是 0.8757，对应第 239 档。0.01 只是满幅度的百分之一，却已经被分到了超过一半档位之后的位置——256 个档位里，前 157 档全部留给了幅度不到 0.01 的那一小段区间，因为语音绝大部分时间的能量就落在这一小段里。

14.4 拼接和参数合成，各自撞在哪堵墙上

拼接合成的思路很朴素：先录一个足够大的语料库，把它切成一个个小单元，需要合成一句新话时，用动态规划从库里搜出一串代价最小的单元序列拼接起来。这条路的天花板很清楚——库里没有的韵律组合，无论怎么搜都拼不出来；单元和单元的接缝处，音高、响度、频谱经常对不上，拼接处的不连续听得出来；换一个新的说话人，几乎要把这一整套语音库重新录一遍。

统计参数合成换了一种思路：不存语音波形本身，存一套参数化的声学模型（通常基于源—滤波器假设，把发声过程简化成一个激励源经过一个频谱滤波器），用 HMM 或者神经网络逐帧预测这些参数，再用声码器合成波形。它的天花板出在两处：源—滤波器假设本身把复杂的发声过程简化得太厉害；逐帧独立预测又缺了帧与帧之间的强约束。Tacotron 2 论文对这条路的评价很直接：合成出来的音频「经常显得沉闷、不自然」（§1）。

这正是 WaveNet 被看作一次转折的原因。它既不用查库拼接，也不做参数化的中间层，直接对波形本身的联合分布建模，Table 1 那 4.21 分不只是比某一条老路高一点，而是第一次让「直接生成波形」这件事，在质量上反超了两条经营多年的老路。代价当然也摆在明面上——14.2 节算过的那 333 秒，直到第 20 章才有真正意义上的解法。

第15章 Mel 频谱：丢掉相位换来可学习

上一章把生成一秒钟语音焊死成一万六千次串行前向，代价是 GPU 上要跑三百多秒。图像那条线早就学会了一次前向并行输出一整张图的所有像素，语音能不能抄同一份作业，一次前向直接并行吐出整段波形？这一章先让你去撞一次这堵墙，因为撞完这一下，你才会明白为什么几乎所有语音合成系统，中间都插了一层看着多余的东西。

这一层要在波形和网络之间插一层前端：前十四级要么面对空间格子，要么面对上一级刚接进来的原始一维波形；这一级要把波形先切成帧、做傅里叶变换、再按人耳的尺子重新分箱，换出一套网络真正学得动的中间表示。

15.1 一次性并行回归波形，会撞在哪

相位(phase)：一个周期性波形在它自己的循环里，此刻正走到哪个位置。同一个频率、同一个幅度的两段波，只要各自的相位不同，逐点数值就可能完全不一样，人耳却基本分辨不出这种差别。

15.2 为什么要先把波形切成一帧一帧

傅里叶变换(Fourier transform)：把一段波形拆解成很多个不同频率的正弦波的叠加，并算出每个频率各占多大的能量。

解法很直接：既然一次性变换会摊平时间，那就别一次性做，把整段波形先切成一小段一小段有重叠的帧，每一帧单独做一次傅里叶变换，再把结果按时间顺序排起来。这样每一个时刻都对应着「当下这一小段里各个频率各有多响」，时间信息被保留在了帧与帧之间。

切帧之后再做的这一串傅里叶变换，有自己的名字。

短时傅里叶变换(Short-Time Fourier Transform, STFT)：切帧之后逐帧做傅里叶变换、按时间顺序排列。输出是二维数组：一维是时间，一维是频率。

cos 和 sin 那两个探测器的读数还各自携带着一件事：它们的比例决定了这一帧里这个频率分量此刻走到了周期中的哪个位置，正是上一节说的相位。STFT 幅度只取两个读数的平方和，相位信息——也就是 cos 和 sin 这两个读数各自的正负与比例——被直接丢在了外面。这件事在第16章会变得非常要紧：丢掉的东西，合成语音的时候还得想办法猜回来。

频谱(spectrum)：一段信号里各个频率各占多大能量的分布。STFT 算出来的是随时间变化的频谱，通常画成横轴是时间、纵轴是频率、颜色深浅代表能量的一张图。

15.3 为什么人耳的尺子和傅里叶的尺子不是一把

既然人耳按比例感觉频率，那就把频率轴按人耳的感觉重新画一条尺子，让这条新尺子上的等距离，对应人耳听起来差不多大小的音高变化。这条尺子有两套互相不兼容的公式，都还在广泛使用。

1000Hz 代入 HTK 公式，算出来是 999.986 mel——这不是巧合，1000Hz 约等于 1000 mel 正是设计这套公式时选定的锚点。同一把尺子上，700Hz 是 781.173 mel，8000Hz 只有 2840.023 mel：频率翻了 11.4 倍，mel 值只涨了 3.6 倍，低频区被拉得更开，高频区被压得更紧，这正是上一段预测门里揭晓的那件事的定量版本。

Slaney 公式在 1000Hz 处分段：低于 1000Hz 是一段直线，高于 1000Hz 换成对数曲线。同样代入 1000Hz，Slaney 给出的是 15.0，不是接近 1000 的数——两套公式压根不是同一把尺子的不同版本，只是恰好用了同一个名字。

15.4 连续的尺子怎么变成八十个数

有了 Mel 这把尺子，还差最后一步：STFT 给出的是几百甚至上千个频率 bin，网络不需要这么细，通常只要几十到一百个 Mel 通道。要把上千个 bin 压缩成几十个 Mel 通道，标准做法是搭一组三角形滤波器，每个滤波器负责把一段频率范围的能量加权合并成一个数。

动手搭一组这样的滤波器，分五步走。第一步，在你关心的频率范围（比如 125Hz 到 7.6kHz）里，用 Mel 公式把两端转换成 Mel 值，在这两个 Mel 值之间均匀切出「通道数+2」个点——均匀切的是 Mel 轴，不是 Hz 轴，这一步正是上一节那把新尺子真正派上用场的地方。第二步，把这些均匀分布的 Mel 点，用 Mel 公式的反函数逐个转换回 Hz，得到一组疏密不均的边界频率——在 Mel 轴上等距，换回 Hz 轴之后，低频区的点会更密、高频区的点会更疏。

第三步，相邻三个边界频率确定一个三角形滤波器：左脚在前一个边界，峰值在中间那个边界，右脚在后一个边界，边界之间线性升高再线性降低。第四步，把这个三角形采样到 STFT 实际输出的那些离散频率 bin 上——每个 bin 落在三角形的哪个位置，就乘上对应的权重。第五步，因为 Mel 轴上等宽的三角形换回 Hz 轴之后宽窄不一，宽的滤波器会自然覆盖更多能量，为了让各个通道输出的量级公平，通常还要按每个滤波器的宽度做一次归一化。

Mel 滤波器组(mel filterbank)：一组三角形加权窗，每一个把 STFT 输出里一段频率范围的能量加权合并成一个数，窗的宽度在 Hz 轴上随频率增高而变宽，因为它们的边界在 Mel 轴上才是均匀的。

15.5 Mel 真正压缩的是什么

16kHz、hop 256、80 维 Mel 的配置下，帧率是 16000/256=62.5Hz，一秒钟有 62.5 帧，每帧 80 个数，一秒钟总共 5000 个 Mel 数值。原始波形一秒钟是 16000 个数。两者相除，5000/16000=0.3125，压缩倍数是 16000/5000=3.2 倍——不是几十倍，只是三倍多一点，甚至不如第6章那张 f=8、4 通道 VAE 表里随便一行的压缩倍数。

把这一章的两件事拼起来看，就是 Tacotron 2 实际用的配置：50 毫秒帧长、12.5 毫秒帧移、Hann 窗、80 通道 Mel、覆盖 125Hz 到 7.6kHz，log 压缩动态范围（论文还试过 5 毫秒帧移去匹配 WaveNet 的条件输入频率，结果分辨率提得太高反而带来更多发音问题，§2.2）。用这套配置训出来的系统，MOS 达到 4.526，逼近真人录音的 4.582（Table 1）。下一章要处理的，正是这一章故意丢掉的那样东西——相位——在合成阶段怎么被猜回来。

第16章 猜回相位