这一讲只讲三件事:这个数怎么算出来(loss)、 一个数怎么变成 6,710 亿个导数(反向传播)、 拿到导数之后那一步该迈多大(梯度下降与优化器)。 —— 一条链,从一个数走到一次更新。
这一讲另有一份讲义(授课稿)。
讲义写的是怎么讲:每一段的目的、讲到哪里该停、常见的误解、 被问到了怎么答。内容本身在你现在看的这份正文里。
两个用法。自己上台讲:照着讲义讲,台词、切图、时间都写着。 自学:把讲义整份丢给 AI,你会得到一个既有这一讲全部背景、 也知道该怎么讲的助教,让它带你走一遍。
左边是四个模型,右边是四条注意力构成(一格=一层,这是 专题三那张编年史表里同一套配色)。 先点左边一个,再点右边一个就连上;再点一次左边可以拆掉。
对上了。这四条其实就是当下的四条主流路线:
而这一讲要问的是另一半 —— 上面这些都是「推理时怎么省」。 训练的时候,这四家谁都躲不开同一张账单。
专题一跟着一个 token 走完了前向 —— 模型吐出了它的猜测。 这一讲从那一刻接着往下走:猜错了,然后呢?
「猜得多离谱」会被压成一个数。不是一张表,不是一个向量 —— 一个数。
而训练这件事,从头到尾就是在做一件事: 拿这一个数,去决定6,710 亿个参数各自该往哪边挪、挪多少。
✋ 这里台下一定会有人举手:一个数怎么可能决定 6,710 亿个东西?信息量根本不够。
问得对,而这一问的答案就是整讲的主线: 那 6,710 亿个方向不是从这个数里读出来的,是从它算出来的。
信息不在这个数里 —— 它在网络的结构里, 在那一次前向留下的每一个中间值里。 loss 只是个起点,链式法则负责把它展开成 6,710 亿份。 记住这句话,第二节那笔「激活为什么扔不掉」的账 就不用解释了。要展开,就得留着展开时要用的东西。
所以这一讲就三件事,顺着这条链走一遍:
三件事,一条链。 —— 链的一头是一个数,另一头是 6,710 亿次「挪一点点」。
⛔ 这一讲不讲什么 —— 先说清楚,免得你等一个不会来的答案。
⭐⭐⭐ 具体说:第二、四、五节里那些细账, 以及全讲所有点得开的折叠块 —— 都属于上面这两类。 它们是专题五的预习,跳过去不影响这一讲的三件事。
反向传播和梯度下降是原理,它们几十年不变; 而「放不放得下」是当下这一代硬件的处境,换一代机器就变。 把两者混在一起讲,读者会以为原理也是会过期的。
📐 先把场景钉住,不然后面每个数你都不知道它在说哪一档。
这一讲所有的账,默认都按 DeepSeek-V3 预训练的真实配置算: 序列长度 4,096,global batch 从 3,072 条爬到 15,360 条。
V3 对外说的是 128K 上下文,但那是预训练之后 两段各一千步的扩展;真正跑掉 14.8T token 的那一段,是在 4K 上。 本讲凡是出现 128K 的地方,都会明说那是扩训场景, 并给出跟 4K 的换算 —— 不标场景的数字没有意义,这也是全讲第③条判据。
反向传播不是「再跑一遍」。它要付两样东西: 大约两倍于前向的算力,以及 —— 更要命的。一路累加、不能提前扔掉的中间激活。
📌 先把「激活」这个词钉死 —— 它在这一讲出现六十多次, 而它有三个都很常见的意思。
一句话:本讲看到「激活」两个字单独出现,指的就是 前向留下来、反向还要用的那堆中间结果。
不过在算这笔账之前,得先把起点说清楚 —— 整条链是从一个叫 loss 的数开始往回走的, 而那个数本身,值得先花两分钟。
这一讲后面所有的账,都是为了让一个数变小。 —— 先把这个数说清楚。
模型读完前面的字,要猜下一个字。它不是只报一个答案,而是给词表里每一个词打一个概率。 —— 然后我们翻开正确答案,只看它给对的那个词打了多少分。
📌 分数变概率靠 softmax:取指数(保证为正), 再除以总和(保证和为 1)。本讲后面它出现十几次,都是这一个动作; 专题三注意力那张图的「权重加起来等于 1」也是它。
loss = −ln p (p = 模型给正确那个词的概率)
先说清 logits 是从哪儿来的,不然下面那张图一上来就是「一排分数」, 没人知道这排数为什么正好是 129,280 个。
词表 129,280、残差流宽度 7,168 取自 DeepSeek-V3 配置;LM head 的参数量与那 0.99 GiB 都是本脚本现算并 assert 住的。
⚠️ 图里两个方块不成比例(真实差 18 倍,画不下);层内部结构不在这一格,见专题一。
好,那上面那句 −ln p 里的 p 是怎么来的?中间隔着两步。
模型最后一层吐出来的,是一排原始分数 —— 这排数就叫 logits。 它可正可负、没有范围,还不是概率。
⭐ 完整的交叉熵其实是对整个词表求和;只因为标签是 one-hot(只有一格是 1),那个和里只剩一项非零 —— 所以「只看一个」是 one-hot 的结果,不是定义。
⚠️ 反过来验证:标签不是 one-hot 时(label smoothing、蒸馏的软标签),每一项就真的都会出现在 loss 里。数都是本脚本现算并 assert 住的;fp32 上限取 3.4028e+38。
✋ 先把那个 0.6964 的口径钉死 —— 它不是你在训练曲线上看到的那个 loss。
式子确实是同一个 −ln p,但上面那张图为了画得下,
把口径缩了两层:词表只有 5 个词,而且只看一个位置。
要读它,就得跟同一个词表下的瞎猜比:
5 个词瞎猜是 −ln(1/5) = 1.61。
—— 所以 0.6964 的全部含义是「比瞎猜好一点」,
不是「已经训得很好了」。
训练日志里那个 loss = 真词表 129,280 个词 +
一整个 batch 所有位置取平均。
它瞎猜的起点是 −ln(1/129,280) = 11.77
—— 就是 1.0 那把尺的顶端,也是训练曲线的第 0 步。
⭐ 跟着来的一条,很多人栽在这儿: loss 的数值大小,一半是词表定的,不是模型好坏单独定的。 同一个模型换一个更大的词表,loss 会自己变大 —— 所以词表不一样的两个模型,loss 不能直接比 (要比就得换成「每个字节多少 bit」这种跟分词无关的口径)。
两个性质,一个漂亮、一个救命。
① 给所有 logits 加同一个数,概率完全不变。 —— 所以 logits 的绝对大小不重要,只有「差」重要; 指数干的事,就是把「差」变成「比」。
② 可别真直接取指数 —— 会炸。
真实 logit 可能几十上百,而 e¹⁰² 已经远远超出 fp32 的上限。
所以所有实现都先减去这排里的最大值再取指数 ——
靠的正是上面那条平移不变,数学等价,数值不炸。
它跟 6.4 那个 z-loss 是同一件事的两面: 一个是事后不让它炸,一个是事前不让分数长那么大。
✋ 那现场那一问呢 —— 「猜错的那些词,怎么没参与 loss 的计算?」
它们参与了,只是不以自己的名义 —— 它们全在 softmax 的分母里。
正确答案的概率 = 它自己的指数 ÷ 所有格子的指数之和
—— 而那个和里,装着词表里每一个词。
⇒ 上面 Ⓒ 那一格是实算的证明:只把一个「错」的分数抬高一格、
正确那一格一个字不改,loss 照样从 0.6964 涨到 0.9702。
而求导之后,它们全部显形。 对错的那些,梯度就是 +它现在占的概率 —— 占得越多,被压得越狠。那一排加起来正好是 0。
⭐ 一句话分清:loss 的式子里看不见它们,梯度里看得见;
而训练只用梯度。
📌 再深一层:完整的交叉熵其实是对整个词表求和,
只因为标签是 one-hot(只有一格是 1),那个和里只剩一项非零。
—— 所以「只看一个」是 one-hot 的结果,不是交叉熵的定义。
反过来验证:标签不是 one-hot 时(label smoothing、蒸馏的软标签),
每一项就真的都会出现在 loss 里。
为什么是这个式子 —— 它其实很讲道理。
ln 2。d(−ln p)/dp = −1/p —— 概率越低的位置,梯度越大,
所以模型先去救它错得最离谱的那些。
这里原来写的是「不然模型会只顾着把已经很有把握的地方
再推高一点点」—— 那句推不出来:换成线性的 1−p,
导数恒为 −1,模型对「已经有把握的」和「完全没把握的」是无差别的,
并不会偏向前者。方向正好说反了。📌 这个东西的正式名字叫交叉熵,也叫负对数似然。 —— 三个名字,同一个式子。
先扔掉对数。就问一件事:模型给正确答案打了 0.4 分, 我们要给它一个惩罚分,怎么定?
最自然的办法:取倒数。
1 ÷ 0.4 = 2.5
这个 2.5 的意思是 —— 它跟「在 2.5 个词里闭着眼睛瞎猜」是一个水平。 (真有 2.5 个等可能的选项时,每个正好就是 0.4。)
这个倒数就是困惑度。 它一点都不神秘 —— 就是「1 除以你给正确答案打的那个分」。
| 给正确答案打的 p | 困惑度 = 1/p | 读作 |
|---|---|---|
| 0.8 | 1.25 | 几乎不用挑了 |
| 0.4 | 2.5 | 相当于在 2~3 个词里瞎猜 |
| 0.1 | 10 | 相当于在 10 个词里瞎猜 |
| 0.01 | 100 | 很糊涂 |
⛔ 那 −ln 是从哪冒出来的?
纯粹为了能把几千个位置加起来。
一条序列 4,096 个位置,每个位置一个概率。概率合并的规矩是相乘。
而 0.4 的 4,096 次方,计算机直接算出 0 —— 下溢了,根本表示不出来。
对数的性质正好治这个:ln(a×b) = ln a + ln b
—— 它把乘法变成加法。于是能相加、能求平均、也不会下溢。
ln(1/p) 写开就是 −ln p。就是这么来的,没有更深的道理。
而看结果的时候再取回指数,就回到了人能懂的那个数:
eloss = 困惑度 = 所有 1/p 的几何平均。
📐 验一遍:三个位置分别打 0.4 / 0.5 / 0.2。
走 loss 那条路(ln(1/p) 求平均再取指数)得 2.92;
直接算「1/p 的几何平均」也是 2.92。同一个数,两条路。
❓ 顺带一个卡住过的地方:log 1 为什么等于 0?
对数问的是一句话:从 1 出发,翻几次倍能走到这个数。
站在 1 上,每走一步翻一倍:1 → 2 → 4 → 8。 所以「8 的对数是 3」—— 走了三步。
那从 1 走到 1 要几步?零步,你已经站在那儿了。
这就是 log 1 = 0。
往回退一步就是除以 2,到 0.5 —— 所以 log 0.5 = −1。
比 1 大是正的,等于 1 是零,比 1 小是负的。
而这正好让 loss 这个公式在两头都站得住:
p = 1 → 困惑度 1 → 从 1 走到 1 不用走
→ loss = 0。满分对应零惩罚,不是凑的,是 log 1 = 0 自动给的。注意那个节奏:困惑度从 100 涨到 10,000 翻了一百倍, loss 只从 4.61 涨到 9.21 才翻一倍。 —— 对数在干的事,就是把「翻多少倍」压成「走多少步」。
词表有 129,280 个词,每个都有概率。 —— 而 loss 只用其中一个:模型给正确答案打的那个分。
正确答案是「猫」,模型给「猫」打 0.4,这个位置的 loss 就是 −ln 0.4。
至于「狗」「桌子」「的」各是多少 —— 一个都不看。
那另外 129,279 个白算了?没有 —— 它们跟正确答案抢概率。
所有词的概率加起来恒等于 1,这是死的。 —— 所以这是一场零和:别人高了,我这个就低了。 它们不进公式,但它们决定了分子上那个 p 被挤成多小。
说准一点,别把两层搞混(这一句我在课上说错过):
概率层没有什么「分母」—— 概率和恒为 1,纯零和。
softmax 内部确实有个会变的分母,但那是
exp(原始分数) 的和,在分数层。
笼统说「分母变大了」会让人以为概率和会变。它不会。
实测:把某个词的分数从 1.0 抬到 3.5,概率和 1.000000 → 1.000000 一动没动,
而正确那个词从 0.629 被挤到 0.175。
那「只看一个」是规定的,还是推出来的?推出来的。
完整的式子不是「取一个概率」,而是在比两个分布: 一边是模型吐出来的那一整列概率,另一边是标准答案。
而标准答案长什么样? 正确那个词给 1,其余 129,279 个全给 0。 这种「一个 1、其余全 0」的写法叫 one-hot(独热)。
摊开算一遍就看见了(四个词的小例子,模型给猫 0.4、狗 0.35、桌子 0.15、的 0.10):
| 词 | 标准答案 q | 模型 p | 这一项 = −q × ln p |
|---|---|---|---|
| 猫(正确) | 1 | 0.40 | 0.9163 |
| 狗 | 0 | 0.35 | 0 —— 乘 0,整项消失 |
| 桌子 | 0 | 0.15 | 0 —— 乘 0,整项消失 |
| 的 | 0 | 0.10 | 0 —— 乘 0,整项消失 |
| 合计 | 0.9163 = −ln 0.4 | ||
所以不是「我们只看一个」—— 是那 129,279 项各自乘了一个 0,自己消失了。
这也是「交叉熵」那两个字的来历: 交叉 = 两个分布在比。而熵是一个分布跟自己比 —— 这正是后面那条自曝里被我讲混的两个量,根子在这儿。
📌 顺带一扇门:既然标准答案是「人写上去的」,它就可以不是 100%。
但预训练几乎都用硬的 one-hot。 所以在这一讲的范围内,「无脑当成 100%」就是准确描述。
这个口径带出一个反例,它比定义本身更值钱:模型可以非常自信地答错。
假设模型给某个错的词打 80%,给正确的词只打 1%。
这个位置的困惑度 = 1 ÷ 0.01 = 100。 —— 可它一点都不犹豫,它 80% 押在一个词上。它是斩钉截铁地答错了。
所以困惑度量的是模型有多准,不是模型有多犹豫。
自曝:这一条我在课上讲反过。 我当时拿「这个分布有多散」(也就是它的熵)当困惑度讲了 —— 那是另一个量。 同一个分布「一个词 90%、其余九个分一成」:熵完全一样, 可正确答案是那 90% 的词时 loss 0.11、是别人时 loss 4.50, 困惑度差 81 倍。熵量「自信」,loss 量「对不对」。一个模型完全可以低熵高 loss。
| loss nat/token | 换成 bit = nat × 1.4427 | 困惑度 = eloss | 大概是什么水平 | 「在几个词之间犹豫」 |
|---|---|---|---|---|
| 11.77 算出来的 | 16.98 | 129,280 | 刚初始化,还没学任何东西 | 在整个词表里均匀瞎猜 —— 这就是 loss 的上限 |
| 6.0 量级 | 8.66 | 403 | 学会了最基本的字频 | 相当于在几百个词里犹豫 |
| 4.0 量级 | 5.77 | 55 | 语法大致对了 | 几十个词 |
| 3.0 量级 | 4.33 | 20 | 像模像样的文本 | 二十个词上下 |
| 2.0 量级 | 2.89 | 7 | 现代大模型预训练末期大致落在这一档 | 七八个词 |
| 1.0 量级 | 1.44 | 3 | 几乎能背出来了 | 两三个词 —— 正常预训练到不了这里 |
⛔ 看最上面那一行 —— 它不是随手填的。
一个刚初始化、什么都没学的模型,对每个词的概率都一样,
也就是 p = 1 / 129,280。代进去:
loss = −ln(1 / 129,280) = ln 129,280 = 11.77
而它的困惑度正好就是 129,280 —— 整个词表。 「在 129,280 个词之间瞎猜」,这不就是瞎猜的定义吗。
所以这把尺的上端不是估的,是算出来的 —— 你换个词表大小,上端就跟着换(词表 129,280 这个数在专题一核过)。 而下端我没有 V3 的官方数字:表里「2.0 上下」是公开模型的大致量级, 当参照看,别当某个具体模型的实测值。
第二列是把 nat 换成 bit(除以 ln 2)。 换算本身没什么,值钱的是 bit 这个数怎么读。
bit 回答的是这个问题:把这个词从候选里挑出来,要问几个「是 / 不是」。 每问一次,候选减半 —— 所以要问几次,就是候选个数取以 2 为底的对数。
刚初始化时候选是整个词表,要问 16.98 次;训练到后期只要 2.89 次。
而候选变少,不是这个词自己变简单了 —— 是它前面那段上下文。 把 129,280 个候选压成等效 7 个,这就是模型前向干的活 —— 省下来的 14.09 个 bit,就是那 17,500 倍。
⛔ 说准一点:「等效 7 个」不是说真的只剩 7 个候选 —— 词表一直是 129,280 个,变的只是概率有多集中。 它的意思是「这份不均匀的分布,跟在 7 个等概率候选里挑,一样难」。
换算里不含任何实测值:困惑度 = e^loss,bit = log₂(困惑度) = loss ÷ ln2;词表 129,280 取自 DeepSeek-V3 配置。
⚠️ 「后期 loss 2.0 上下」是公开模型的大致量级,当参照看,别当某个具体模型的实测值。
⭐ 这两格原本是上一张图的 Ⓑ Ⓒ,2026-09-23 拆出来—— 为的是让课件那边能把它折叠起来。
换算里不含任何实测值:困惑度 = e^loss,bit = log₂(困惑度);词表 129,280 取自 DeepSeek-V3 配置。
一条现场能用的心算法:只要背两个数。
ln 2 ≈ 0.693 (记成 0.7) · ln 10 ≈ 2.303 (记成 2.3)
日志上 loss 从 3.0 掉到 2.3 —— 降了 0.7,困惑度直接减半,不用开计算器。
拿这把尺自己验一遍:
从 11.77 降到 2.0 共降 9.77,除以 0.7 = 14 次砍半,
2¹⁴ = 16,384 倍。
真值:困惑度 129,280 → 7.39,比值 17,496。
心算 16,384,真值 17,496 —— 只差不到 7%,量级一点没错。
这套只保量级。要小数点后两位还得算 —— 但训练现场你要的从来不是两位小数,是「这个数正常不正常」。
那「越到后面越贵」,到底贵在哪? —— 这句话本讲后面还会出现几次,这里一次说清。
⛔ 先排除一个听起来很顺、但其实是错的解释: 「因为对数尺度把后面压扁了」。不对 —— 比例上它一点没变: loss 每降 0.7,困惑度永远砍一半,跟你在 11 还是在 2 毫无关系。
真正的原因有两条。
| loss 降 1 | 困惑度 | 少掉多少个候选 |
|---|---|---|
| 11.77 → 10.77 | 129,314 → 47,572 | 81,742 个 |
| 6 → 5 | 403 → 148 | 255 个 |
| 3 → 2 | 20.1 → 7.4 | 12.7 个 |
| 2 → 1 | 7.4 → 2.7 | 4.7 个 |
① 绝对收益越来越小。同样是「降 1」,早期划掉八万多个候选, 到 2 附近只划掉不到 5 个 —— 因为剩下的本来就没几个了。
② 而这一条才是根子:剩下的那点不确定性,有一部分是语言本身固有的。
「下一个字」真的可以是好几个,谁都猜不准,包括人。
—— 所以到了后面,你不再是在学习,你是在撞天花板。
那部分熵是不可约的,模型再好也降不到 0。
📌 这也是为什么比较两个模型的 loss 只在同一个数据集、同一个 tokenizer 下才有意义 —— 换一份数据,那个天花板本身就换了。
这把尺后面要用三次: 3.5 判断「loss 下得够不够快」、 6.1 判断「飞了多少算飞」、 6.3 读那张表里的数。 —— 没有尺,那三处都只能靠感觉。
上面那把尺用了两个词:nat 和困惑度。 它们听起来是两个概念,其实连同 bit 在内,是同一个量的三种读法。
⭐ 「刚初始化 · 瞎猜」那一档(Ⓐ 最右)是自检:困惑度必须正好回到词表 129,280、bit 必须正好等于 log₂(词表)。脚本里 assert 钉着,对不上就是换算写错了。
⚠️ 「训练早中期 7.00」是示意档,「收敛附近 2.00」是公开模型的大致量级 —— 当参照看,别当某个具体模型的实测值。
先说 nat 和 bit —— 它们差的只是一个底数。
bit 是「一次二选一」的信息量:抛一枚硬币,把结果告诉你,你就拿到 1 bit。
它以 2 为底。
nat 是同一类东西,只是以 e 为底。
换算是死的:1 nat = 1.4427 bit。
那为什么我们这儿冒出来的是 nat?
纯粹因为 loss 的定义里写的是 ln。
当初要是定义成 −log₂ p,整套东西一模一样,
所有数字乘 1.4427 而已。这是个约定,不是什么深刻的选择。
至于 per token 那半截:它来自下面第三步那件事 —— 一条序列几千个位置、每个位置一个 loss、最后取平均。 所以整个单位读作「平均每个 token 多少 nat」。
⛔ 换成 bit 之后,这个数突然有了体感:它就是压缩率。
「模型平均要花多少个 bit,才能把下一个 token 记下来」 —— 语言模型本质上就是个压缩器,而 loss 就是它的压缩账单。
ln 129,280 = 11.77 nat = 16.98 bit。
而 log₂ 129,280 也正好是 16.98
—— 十二万九千个词里随便挑一个,本来就要花 17 个 bit。
这一档是自洽的,不是填上去的。2.0 nat = 2.89 bit。从 17 bit 压到不到 3 bit —— 这就是这个模型学到的全部东西,换算成压缩的样子。
📌 所以同一件事有三副面孔,按场合挑:
它们之间是恒等式,不是三套测量 —— 任何一个变了,另外两个必然跟着变。所以别把它们并排列出来当成三条证据。
上面算的是一个位置的 loss。而一条 4K 的序列里, 每个位置都在猜它的下一个字 —— 所以一条序列有 4,095 个 loss。
⛔ 是 4,095 不是 4,096 —— 最后那个字没有「下一个」可预测。这个 1 在别处不重要, 但它正是 1.2 那批账的分母,所以这里说准。
把它们全部取平均,就得到这一批的 loss。
口径来自 MaxText 训练脚本:loss = xent_sum ÷ total_weights,其中 total_weights 是遮掉 padding 与拼接边界之后真正算了的目标位置数;
序列 4,096、global batch 上限 15,360 取自 DeepSeek-V3 预训练配置。
「取平均」这三个字,是后面很多事情的根。
1.2 那张图的比方 —— 一屋子人各提各的要求,最后取平均。屋里坐的就是这些 token。
所以 batch 首先不是为了喂饱卡 —— 是为了别只听一个人的。 这条线一直通到 6 那节「训不崩」, 账在 3.5b。
几千亿个参数进去,出来的是一个数。不是一个向量,不是一张表 —— 一个数。
记住这件事。 —— 1.5 会告诉你,整个反向传播之所以划算,全靠这个「一」。
📐 单位是 nats / token(取的是自然对数)—— 3.3b 推学习率的单位时要用它。
这一问现场撞过,而且几乎人人会撞一次: 「你为什么总说 loss 只有一个数?我看到的是 —— 一个 token 有 129,280 个数,一条序列 4,095 个,再乘 batch 就更多了。」
答案:你说的那些全都存在,只是它们不都叫 loss —— 中间压缩了两次。
| 这一层是什么 | 有多少个数 | 它该叫什么 |
|---|---|---|
| 一个位置上,词表里每个词的分数 | 129,280 | logits / 概率 —— 这不是 loss |
| ↓ 第一次压缩:只取正确答案那一格,取负对数 | ||
| 一个位置的 loss | 1 | −ln p |
| 一条序列 | 4,095 | 每个位置一个 |
| 一步(按 V3 的 global batch 算) | 62,899,200(= 4,095 × 15,360 条) | 还是每个位置一个 |
| ↓ 第二次压缩:全部加起来,除以有效 token 数 | ||
| 最终 loss | 1 | 你在 loss 曲线上看到的那个点 |
那为什么非要压成一个数?—— 这不是为了好看。
「输出端只有一个数」,正是「反向只走一遍」的前提。
1.5 会讲:种子插在右边,而右边只有一个数,所以只插一次。
—— 可如果最终目标是 4,095 个数呢?那你就得插 4,095 次种子,
每个目标各走一遍。多目标优化之所以贵,根子就在这儿。
✋ 最后拆一个会让人觉得前后矛盾的地方:
「loss 是一个数」和「反向的种子有五亿多个数」—— 这两句同时成立,不打架。
loss 这个量确实是一个标量。
但对它求导之后,得到的是「loss 对每一个 logit 的偏导」——
那是每个位置 × 整个词表,约 5.3 亿个数(4,095 × 129,280;1.2 那张图画的就是它)。
⭐ 一句话分清:「loss 有几个数」问的是那个量本身; 「种子有几个数」问的是它的导数。前者是 1,后者是五亿多。
那么这一讲要干的事,现在可以用一句话说完了。
把这个数,从 11.77 挪到 2 附近。
而挪动它的唯一办法,是知道每一个参数该往哪边动一点点 —— 也就是这一个数对 6,710 亿个参数的偏导数。
问题来了: 6,710 亿个导数,怎么算得过来?
求导是高中的事。 这里难的是:要求快 6,710 亿个导数,而且每一步都要重求一遍。
不过「求导是高中的事」这句话会劝退一批人 —— 所以先花一格,把这一讲要用到的三个词说完。 没有极限、没有公式,三句话,一张图。
⚠️ Ⓐ 的 4.00 → 4.03、Ⓒ 的 ×2 / ×0.5 / ×3 都是编出来的示意数,唯一的作用是让「相除」和「相乘」这两件事看得见。⭐ 脚本里 assert 了两条:总兑换率必须真的是三个乘积,而且链条里要有一级是缩小的 —— 不然「乘起来」会被读成「越乘越大」,而那正是梯度消失/爆炸那一节要讲的反面。
⭐ 这一格刻意不碰极限:严格地说导数是「动的那一点点趋于 0 时的极限」,而这张图画的是差商。⛔ 对本讲够用 —— 而且 §1.1 那个「笨办法」用的正是差商,所以这里不严格反而接得更顺。
⭐⭐ 「兑换率」这个说法不是为了好听,它自带两个钩子,两个都是本讲自己的:一串数相乘,从哪头开始乘代价差两万年(§1.5);而单位对不上所以必须再乘一个折算系数(§3.3)。
⭐ 这一格原本是上一张图的第四格,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。
⚠️ 图里那个 7,168 是 V3 的残差流宽度;⛔ 注意机器里并没有一块方阵,真实的权重没有一块两边一样宽。
先纠一个很多人记混的词:不是 deviation,是 derivative。 deviation 是「偏差」—— 标准差 standard deviation 那个词, 跟这里完全不相干。偏导数是 partial derivative。
而 derive 的词源,比「导数」两个字生动得多: 拉丁语 dērīvāre = de(从…)+ rivus(河流)—— 字面意思是「从一条河里引一股水出来」。
📌 出处:Etymonline(derive / derivative)—— Latin derivare “to lead or draw off (a stream of water) from its source”, 来自 de rivo(de “from” + rivus “stream”);数学义自 1670 年代。
所以中文那个「导」字其实翻得很准 —— 导就是引导、引出。 只是今天一看到「导」大家先想到「指导」,那个引水的画面就丢了。
按这个画面,两个词一前一后就顺了。
先说导数(derivative)。
你有一条河:输入进去,输出出来。 导数问的不是「现在是多少」,是「输入挪一格,输出跟着挪几格」。
你没有换一条河 —— 你是从这条河里引出了第二条。 原来那条给的是「输入对应多少输出」;引出来这条给的是「动一格、动几格」。 同一个源头,两股水。
再说偏导数(partial derivative)—— 「偏」不是偏差。
现在输入不是一个数,是 6,710 亿个旋钮。 「输入挪一格」这个问法当场失效 —— 因为不知道是挪哪个。
partial 的办法很粗暴:一次只松开一个,其余全部夹住。 —— partial 的意思是「部分的」,而它部分在哪: 求导这件事只做了一部分,一次一个变量。
于是这个 6,710 亿维的问题,当场塌回成一维 —— 偏导数又变回了普通导数。 它不是一种更难的导数,它是把难题切成 6,710 亿个普通导数。
先看看笨办法长什么样 —— 这一步不能跳过, 不知道笨办法有多笨,就不会觉得反向传播有多神。
⛔ 笨办法(有限差分): 我想知道某个参数对 loss 有多大影响,就把它动一丁点, 整个网络重跑一遍前向,看 loss 变了多少。
那 6,710 亿个参数,就是6,710 亿次前向。
671e9 秒 ÷ 3.156e7 秒/年 = 21,261 年
(一次前向按一秒算 —— 已经极度乐观了)
而这还只是一步。训练要走几十万步。
所以反向传播真正解决的问题,不是「怎么求导」, 是怎么把 6,710 亿次前向压成一次。
起点就是 1.0 那个数 —— loss。 (它只有一个,这一点后面是全部关键。)
那第一个梯度是什么?拿最常见的交叉熵来说:网络最后吐出一个概率分布 —— 下一个字是「的」的概率 0.3、是「了」的概率 0.2…… 而正确答案是一个只有一格是 1、其余全是 0 的东西。
第一个梯度 = 你猜的,减去正确答案。
猜高了的地方是正数,该高没高的地方是负数。 就这么简单。这个差,就是整条反向链的种子。
而它不是凑巧长这样 —— 它是 1.0
那个 −ln p 求一次导的结果。
对 logits 求导(不是对概率求导),
−ln p 那一串恰好约化成 p − y
—— 模型给的概率,减去那个只有一格是 1 的正确答案。
跟 1.0 那一段接上:
同一个 −ln p,换个求导对象,给出两件不同的东西。
−1/p,
概率越低梯度越大。这解释的是动机:模型为什么会先去救错得最离谱的。p − y。
这给出的是实现:反向那条链的种子,一个减法就完事。一个解释「为什么想动」,一个给出「怎么动」—— 同一个 loss 的两张脸。
也正因为约化得这么干净,框架里它俩总是 融合成一个算子:分开算要先出概率再求导,合起来一步就到。 不是所有 loss 都这么好看,但这一对是今天的默认组合。
一个说准了才不会误导的细节:
那个「减」不是对概率求导,是对 logits 求导
—— 也就是 softmax 之前那一层的输出。
这个区别有实际后果:正因为约掉的是 softmax 那一步,
这个梯度才不会在 softmax 饱和的地方消失。softmax 和交叉熵总是成对出现,一半的原因就在这儿。
📌 「推一下(nudge),推多少跟差多远成正比」「想让一个神经元更亮有三条路」「改权重要按上游亮度成比例,回报最大」「众口难调,只能取平均;只听那张 2 的,网络会把所有图都判成 2」四个装置,取自 3Blue1Brown《What is backpropagation really doing?》官方讲义 —— 已逐条核过原文,图是我们自己重画的,例子换成了本讲一直在用的「下一个字」。
⚠️ 他在「按上游亮度成比例」那里顺带提了赫布理论(neurons that fire together wire together),但原文自己就说这个类比并不严格(未训练的网络并没有在「想」那个答案),所以只记在这儿,不画上图。
⭐ Ⓑ 与 §1.8 的那处接头(以及折起来那张与 §1.6 的那处),原文都没有,是本讲自己的合题 —— 3B1B 讲的是「反向传播在干嘛」,本讲要的是「它为什么这么费显存」。
📌 「改权重要按上游亮度成比例,回报最大」取自 3Blue1Brown《What is backpropagation really doing?》官方讲义("adjust the weights in proportion to their associated activations")—— 图是我们自己重画的。
⚠️ 他在这里顺带提了赫布理论(neurons that fire together wire together),但原文自己就说这个类比并不严格,所以只记在这儿,不画上图。
⭐ 「所以激活扔不掉」那一步是本讲自己的合题,3B1B 讲的是「反向传播在干嘛」,本讲要的是「它为什么这么费显存」。
✋ 这里现场问过一个很要紧的问题,而它照出一个洞: 反向的时候,是「把对的推上去、错的也各自推下去」,还是「只推对的那个, 其余是副作用」?
答案:都做 —— 而且是同一个动作。
那颗种子是「你猜的 − 正确答案」,它是一整排数,
词表上每一个字都占一格:
正确那格是 0.40 − 1 = −0.60(负号 = 把它推高);
其余每一格是 它自己的概率 − 0(正号 = 把它推低),
—— 0.20 那个被推的劲,正好是 0.10 那个的两倍。
⭐ 而这一排数加起来正好是 0。 概率总量是守恒的,所以「推上去」和「推下去」不是两件事, 是一次再分配。剩下那十二万多个概率≈0 的字,梯度也≈0 —— 它们本来就没占地方,不用动。
⛔ 顺带把两个口径说准,上面那张图的「样本」两个字容易误导:
① 一条长 4,096 的序列只有 4,095 个预测 —— 最后那个字没有「下一个」;
② loss 是按 token 平均的,不是按序列平均的 ——
分母是遮掉 padding 与拼接边界之后真正算了的目标位置数
(MaxText 里就叫 total_weights,loss = xent_sum ÷ total_weights)。
口径来自 MaxText 训练脚本:loss = xent_sum ÷ total_weights,其中 total_weights 是遮掉 padding 与拼接边界之后真正算了的目标位置数;
梯度只跑一次(value_and_grad 作用在那个标量上)。词表 129,280、序列 4,096 取自 DeepSeek-V3 预训练配置。
看 Ⓑ 那一排箭头的时候有个地方极容易读错,图上已经画明,这里再用字钉一遍: 一个位置往回传的那一支,不是「这个位置往哪边推」。
词表上每一行都拽着一个 7,168 维的向量, 129,280 行全部叠加,才得到那一支箭 —— 它是一个合力,不是一个方向。
「推高 / 推低」是词表某一格才有的说法,也就是 Ⓐ 那一层的事; 放大到「一个位置」这一层,那个说法就没有所指了 —— 所以 Ⓑ 里的箭头一律是中性色,不再分绿红。
⭐ 而这一支合力到底是怎么叠出来的,正是下一节 1.2c 整节要画的事。
那「每个 token 各跑一遍反向,再把 6,710 亿个梯度平均」这个想法呢? —— 它算出来跟实际做法一模一样。
因为求导是线性的:先把 loss 平均再求导,等于先各自求导再平均。 所以实际实现只跑一次反向,不是抄近路 —— 是它跟那个想法等价,但便宜几千万倍。
⭐ 真正值得记住的是:那个标量只是个把手,反向并不从它出发。 反向的起点是一个「每个位置 × 整个词表」的张量, 上面每一个数都是「你猜的 − 正确答案」再除以总数。 六千多万个位置的意见,一个都没有在 loss 那一步被抹掉 —— 它们是在后面一层层的矩阵乘里才被累加起来的。
⛔ 这里有一处特别自然、但会把整条链理解反的误解, 必须单独说:不同位置的那个 7,168,不能先加起来。
很容易这么想:一条序列 4,095 个位置、每个位置一个 7,168 长的向量, 那就把它们加起来求个平均,再拿这个平均往前传。 —— 这一步做了,整份梯度就错了。
因为第 i 个位置的责任,只能配第 i 个位置的输入。 权重梯度是「每一行各乘各的,乘完再加」;先把 δ 加起来再乘, 等于把第 3 个位置的责任配到了第 900 个位置的输入上 —— 那是另一个量。
所以「求和」这件事确实发生,只是不发生在 δ 上, 发生在权重梯度上,而且每一层各结一次账。 δ 从头到尾是一张「位置 × 宽度」的表, 位置那一维一路保留到最后。
线性层:权重梯度 = Σ_i(δ_i ⊗ x_i),沿位置维收缩;而对输入的梯度是逐位置的,不收缩。⚠️ 一个诚实的例外:attention 会让不同位置的 δ 互相混合 —— 因为前向时位置之间本来就互相看;
但那是 attention 的结构造成的,不是「求平均」,线性层那一路位置维严格独立。词表 129,280、宽度 7,168、层数 61 取自 DeepSeek-V3 配置。
⭐ 再往下一层:「结账」到底发生在哪一步? —— 现场问得很准:「是每个函数各做一次,还是把这一层算完再做?」
是前者:每一个带权重的算子各结一次账, 而且结账和往前传互不等待。
一个带权重的算子收到 δ 之后,做的是两件事:
① 结账 —— 把 δ 和这一层的输入相乘、沿位置求和,
得到这块权重的改动。位置那一维在这一笔里被吃掉了,这笔账不往下传。
② 往前传 —— 把 δ 乘上权重本身,得到上游该收到的责任。
位置那一维在这一笔里完整保留。
⭐⭐ 而这两笔,正是 1.6 那句 「反向要付两笔乘法,所以训练比推理贵三倍」里的那两笔。 —— 同一张 δ 表,两种收缩方式:一笔把位置维吃掉,一笔把位置维留着。
⛔ 两个特别容易错的地方:
① 权重梯度的桶是固定大小的,不随 token 数变大 ——
四千个位置只是往同一个桶里加了四千笔;这就是为什么整份梯度是
「每个参数一个数」,而不是「每个 token 一套参数」。
② 每层只加,不除。那个「÷ 总数」在最开头的种子里就做过一次了
—— 每层再除一遍的话,61 层就除了 61 次。
所以严格说这一步叫「求和」,不叫「求平均」:平均早就摊进每一笔里了。
顺带确认现场推到的那一步: 线性层的权重梯度只用本位置的输入 —— 而前面那些 token,是在前向的 attention 里就已经被搅进这个输入了, 不是反向的时候才被拉进来的。
⭐ 现场自己推到的那一步是对的:「我当前这个 token 得用生成我这个 token 的激活,也就是前面所有 token 都参与计算之后的激活」—— 线性层的权重梯度只用本位置的输入,
而前面那些 token 是在前向的 attention 里就已经被搅进这个输入了,不是反向时才拉进来的。⛔ 口径:V3 一层里没有任何一块 7,168 × 7,168 的方阵 —— 残差流是 7,168 宽,但每一块的另一边都是别的数(专家 7,168 → 2,048、MLA 把 KV 压到 512 那一档,而 o_proj 那一边是 16,384)。本图用专家 up 当例子。共 61 层。
⭐ 这一格原本是上一张图的第四格,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。
还有一层要说清:那个「平均」分几层? —— 现场的猜测是:序列内平均一次、本卡跨序列再平均一次、 micro-batch 之间再平均一次、跨卡再平均一次。
「分层次」这个直觉是对的,但实际是 —— 三层加法 + 一次除法。
⛔ 为什么不能每层各除一次?那就成了「平均的平均」。
各层的有效 token 数并不相等(padding、拼接边界、最后一批)——
一旦各自先除,token 少的那一批就被当成跟多的那批一样重。
而它不报错、不发散、曲线看着完全正常。
正确做法:一路只传两个数 —— 「loss 的和」和「token 的个数」,
最后拿前者除后者。
出处:MaxText 的梯度累积实现 —— 循环里 acc["loss"] += xent_sum、acc["total_weights"] += total_weights,循环外 grads ÷ acc["total_weights"]。
⚠️ 一个例外要说清:辅助损失(MoE 负载均衡这类)反而是除以 micro-batch 个数的 —— 因为它们本来就是「每个 micro-batch 一个平均值」。两套口径,别混。
⭐ 这一格原本是上一张图的第四格,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。
很多人脑子里的画面是「一个梯度值一层一层传下去」。不是这样。
往回传的是一整个张量,形状跟这一层的输出一模一样。 它的含义是:「loss 对我这一层输出的每一个位置,各摊多少责任」 —— 这一层输出有多少个数,它就有多少个数。本讲管它叫 δ。
⭐ 这里必须把 δ 的身份说破,否则后面全是黑话: δ 就是「激活的偏导数」。
这一层的输出就是激活。而 δ 的定义是「loss 对这一层输出的偏导数」 —— 所以我们不但求激活的偏导数,而且不求就没有反向: 要算第 k 层权重的梯度,先得知道 loss 对第 k 层输出有多在乎, 而那个数只能由第 k+1 层传回来。δ 就是那条链本身。
可「求它的导数」和「拿导数去改它」是两回事 —— 这是最容易混的一处:
| 求它的偏导数? | 拿这个导数去改它? | 算完怎么处置 | |
|---|---|---|---|
| 权重 | 求 | 改 | 跨卡求和(最后才除一次)、进优化器、每参数 2 字节 |
| 激活 | 求(就是 δ) | 不改 | 传给上一层,用完就扔,不进任何账 |
⭐ 为什么激活不改:它不是自由变量。 它是输入和权重算出来的结果 —— 想改激活,唯一的办法是改权重。 所以给激活配优化器状态、去「拧」它,没有意义。
❓ 那 δ 自己也是一整个张量,为什么它不出现在 1.7 那张显存账上? 因为它反向走到哪一层才有哪一层,用完立刻释放。 而激活要从前向一直挂到反向 —— 这就是 1.6 那座山的由来。 ⭐ 两个张量一样大,一个进账一个不进,差别只在活多久。
⛔ 顺带修一个很自然但会误导的说法: 「激活只是个中间传递的介质」。前向确实是 —— 可要真只是介质, 它前向用完就该扔。而它扔不掉,这件事本身就说明它在反向里还有活干: 每一层算自己权重梯度的时候,要把它当来料取出来用。 准确的说法是 —— 前向它是「传下去的东西」,反向传下去的换成了 δ, 而它变成了「拿出来对账的东西」。
每一层拿到这个上游传来的责任 δ之后,只做两件事(编号跟下面那张图一致:① 是前向那一次):
这两件事各是一次矩阵乘。前向一次、反向两次 —— 三倍算力就是从这儿来的。
但「数次数」还不够 —— 三次矩阵乘如果规模不一样,
1 + 2 根本不等于 3。 真正让它成立的是:这三次乘的
形状是同一组。设这一层是 [B,in] × [in,out]:
① 前向 X·W、② Xᵀ·dY、③ dY·Wᵀ。三个都是 B × in × out 这三个数相乘,
所以三块积的体积一样大,加起来才正好是 3 倍。
(下面那张图把这三块按真实比例画了出来。)
知道理由,才换得了情境: 最后一层不用往下游传 —— 省掉 ③,就是 2 倍; 冻住的层不更新权重。省掉 ②,也是 2 倍(3.8 的 LoRA 走的是这条)。 只记住「3×」这个数的人,这两问都答不了。
⚠️ 「3 倍」是矩阵乘口径的常用近似:只数 matmul,忽略 norm / 激活函数 / 偏置 / 通信。真实 step 里这些占比不大,但不是零
⛔ 图上第 ② 步那句「用前向存下来的输入」是整个专题的枢纽 —— 激活扔不掉、以及下一节那笔重算交易,全都挂在这一句上
上面那张图里立着两个 ᵀ:Xᵀ 和 Wᵀ。
先把这个记号拆掉,不然后面整段都读不进去。
① 它是什么 —— 行变列、列变行,一个数都没动
一个 2 行 3 列的表,转置之后变成 3 行 2 列: 原来的第一行,变成了现在的第一列。 数一个没少、值一个没变,变的只是「从哪个方向读」。
所以转置不花算力 —— 真实实现里常常连搬都不搬,只是换个读法。
② 为什么非它不可 —— 是形状把它逼出来的
矩阵乘有一条死规矩:左边那个的列数,必须等于右边那个的行数 —— 对上的那一维,乘完就被吃掉。
而反向要的两块结果,形状是被定死的: dW 必须跟 W 同形(不然优化器没法把它加到 W 上), dX 必须跟 X 同形(不然前一层接不住)。
| 摆法 | 被吃掉的那一维 | 为什么只能这么摆 | |
|---|---|---|---|
| ① 前向 | X[T×d_in]· W[d_in×d_out]= Y[T×d_out] |
d_in | 原本的摆法:把输入按权重混一遍 |
| ② 权重梯度 | Xᵀ[d_in×T]· dY[T×d_out]= dW[d_in×d_out] |
T(位置) | 要凑出 d_in×d_out,只有这一种摆法 |
| ③ 传给下游 | dY[T×d_out]· Wᵀ[d_out×d_in]= dX[T×d_in] |
d_out | 要凑出 T×d_in,只有这一种摆法 |
结果形状一旦定死,转置就是唯一摆得上的方式。 —— 它不是一步额外的运算,它是「怎么摆才对得上」的答案。
换成人话,两句
前向问的是「输入怎么混成输出」; ③ 问的是反过来那个问题 —— 「输出的责任怎么分回输入」。 同一张 W,换个方向读,写出来就是 Wᵀ。
而 ② 里 Xᵀ 的作用不一样:它把「位置」这一维摆到中间去,
好让它被吃掉。
—— 所有位置对这块权重的意见,就是在这一步被累加起来的。
这正是 1.2d 说的那笔「结账」:
位置维在这里消失,所以这一笔不往前传。
⭐ 这一格原本是上一张图的 Ⓑ,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。
⭐ 顺带说清图上那根橙色的线(现场也问了):
它表示 ② 里用的那块 Xᵀ 不是新算出来的 ——
就是 ① 前向时那个输入,被存下来了。
这根线就是「激活为什么扔不掉」的全部答案:
前向做完不能把 X 丢掉,因为反向算 dW 还要拿它当来料。
箭头顺着流向画:① 存下来 → ② 取用。
📌 「电路图 + 三个门(分发 / 交换 / 路由)」这个讲法取自 CS231n 的反向传播讲义 —— 图是我们自己重画的,数也是自己挑的。
⭐ 图上每个数都可以自己验:脚本里带 assert —— a 和 b 的梯度都是 4、c 的梯度是 −1,对不上就不让构建。
这一问是现场推出来的,而且推对了: 训练的时候,前面那些 token 猜没猜对,完全不影响这个位置。
因为每个位置的输入永远是真值,不是模型自己刚猜出来的那个字。 这件事有名字:teacher forcing。
⛔ 但有一处要说准:这不是「一个 token 一个 token 地去查」。
训练里 Q / K / V 一把算完、注意力一把做完,
所有位置同时。
—— 而这正是训练和推理最大的形态差别:
推理才是真的一个一个来,因为下一个字得等上一个字生成出来。
顺带一个小口径:「查前面的 K 和 V」严格说是 「前面和自己」—— 因果掩码允许看到自己这个位置,只是不能看后面。
出处(2026-09-22 现查,不是凭记忆):teacher forcing 这个词由 Williams & Zipser(1989)在循环网络上提出,1989 年原文写的是 “We call this technique teacher forcing”(多出 intuitively sensible 的那个版本出自两人 1995 年的综述章节);
scheduled sampling(训练中按概率混入模型自己的预测,用来缓解曝光偏差)出自 Bengio 等,arXiv 1506.03099(2015)。⚠️ 今天的大模型基本仍是纯 teacher forcing —— 并行那个好处太大,大到愿意忍着曝光偏差。
✋ 那代价是什么?—— 曝光偏差(exposure bias)。
训练时它从来没见过自己的错误,一直活在「前文永远是对的」那个世界里。
可推理时前文全是它自己生成的 ——
一旦错一个,它就走进了一个训练时从没见过的分布,而在那儿它没有任何经验。
这就解释了一个人人遇到过的现象:长文本生成为什么会越跑越偏。 不是它突然变笨了,是它走进了自己没被训练过的地方。
那为什么还这么干?
① 并行 —— 用自己的预测喂自己的话,第 t 个位置得等第 t−1 个算完,
一条 4,096 长的序列就得串行四千多次,训练慢到不可行。
② 早期不发散 —— 刚开始模型猜得一塌糊涂,拿它自己的输出喂自己,一步就飞了。
—— 所以这是一笔明知有代价、仍然划算的交易。
📌 出处(现查):teacher forcing 这个词由 Williams & Zipser(1989)在循环网络上提出; scheduled sampling(训练中按概率混入模型自己的预测,用来缓解曝光偏差)出自 Bengio 等,arXiv 1506.03099(2015)。 ⚠️ 今天的大模型基本仍是纯 teacher forcing。
因为偏导数是局部的。
⛔ ❓ 可这句话第一遍听完,通常会立刻冒出一个反对意见 —— 而且那个反对意见是对的。
「一个权重要影响到 loss,中间穿过的不是一个整数的乘,是一整个矩阵; 而且它的影响还取决于同一层里横着的那些参数 —— 它们彼此之间还有影响。 这么牵一发动全身,凭什么算得出来?」
这两条都成立,而且比听起来还要严重一点:
📌 词源:Etymonline(derive / derivative)—— Latin derivare “to lead or draw off (a stream of water) from its source”,来自 de rivo(de “from” + rivus “stream”);数学义自 1670 年代。⛔ 顺带纠一个常见的记混:deviation 是「偏差」(standard deviation),跟 derivative 不是一个词。
⚠️ Ⓒ 左边那把扇子是示意:画的是 3 跳 × 每层 6 个节点(216 条路)。右上角那个「232 位数」才是按真模型算的 —— 60 层、每层 7,168 宽。
⭐ 对照一下就知道反向传播省在哪:路径条数是 指数级,而反向真正做的矩阵乘只有 122 次(每层两次)—— 跟层数成正比。
那 partial derivative 神奇在哪? —— 神奇在这团「什么都牵扯什么」,最后被压进了两个数。
算某一个权重的梯度,你只需要两样东西 (1.3 反向那两笔里的第 ② 笔就是它):
❓ 那横向耦合去哪了?它已经在第二个数里面了。
不是被忽略,是算那个责任的时候,整层一次性算完了 —— 反向传回来的那个向量,本身就是「把下游所有东西、所有横向混合 都算进去之后」的结果。
所以「太复杂」这个感觉是对的。复杂是真的 —— 但那份复杂只付一次,按层付,不按参数对付。
代价也很清楚,而且正好接上 3.3b。
参数两两之间的相互作用叫二阶导,每两个参数就有一个数
—— 6,710 亿个参数根本存不下,所以我们故意不算它。
而「故意不算」的代价,就是必须小步走。
所以学习率这个东西 —— 不是谁发明了它,是我们放弃了二阶导,
所以不得不有它。
每一个算子只需要知道「我自己是怎么把输入变成输出的」, 就能写出自己的反向规则。 它完全不需要知道前面是什么、后面是什么、整个网络长什么样。
这就是为什么自动微分能做成一个通用库。
矩阵乘写一个 backward,softmax 写一个 backward,加法写一个 backward —— 然后框架只干一件事:按顺序倒着把它们串一遍。
没有任何人需要手推整个网络的导数。
反过来想才知道这有多可怕: 如果你非要写出「loss 对第一层某个权重」的解析式, 那个式子要穿过 61 层展开 —— 项数是天文数字,写不出来。
链式法则真正的意思是:你永远不用把它展开。 你只要把 61 个局部的小导数,按顺序乘起来。
这里要把 1.3 那两笔账跟「乘起来」这三个字焊在一起 —— 它们说的是同一件事。
1.2d 说每一层拿到上游的 δ 之后做两笔矩阵乘,其中第 ③ 笔是 「用这个 δ,乘上自己的权重」,结果传给下游。
那一乘,就是链式法则的一环; 而「自己的权重」,就是这个算子的局部导数。
—— 所以「61 个局部导数按顺序乘起来」不是一个比喻, 它就是反向那一趟里,第 ③ 笔被连做了 61 次。 第 ② 笔(算权重梯度)不在这条链上:它是从链上取值, 每一层各取各的,取完就交给优化器,不往下传。
这个区分后面一直有用:「梯度」这个词在本讲同时指两样东西 —— 第 ② 笔算出来的权重梯度(要 all-reduce、要进优化器、每参数 2 字节)和第 ③ 笔往回传的 δ(= 激活的偏导数)(用完就扔,不进任何账)。§1.8 那道 all-reduce 传的是前者。
❓ —— 那「乘起来」之后会怎样? 这一问有一个非常出名的答案,而它是链式法则最直接的后果。
⭐ Ⓐ 三条曲线、Ⓑ 那两个端点值、Ⓒ 那个 0.25,全是脚本算的,没有一个是抄来的:0.8 的 59 次方 ≈ 1.9e-06、1.2 的 59 次方 ≈ 46956,两者相差 10 个数量级;0.25 是 σ(1−σ) 的闭式最大值,脚本里还用一万个采样点复核了一遍。
⚠️ Ⓒ 只挑了激活函数这一截 —— 每层真正的兑换率还要乘上权重矩阵那一下(以及归一化那一下)。选它是因为它是这一格里唯一能当场算清楚的,⛔ 不是因为它是唯一的原因。
📌 出处与年份(完整的故事在讲义里):这件事 1991 年就被正式指出了 —— Hochreiter 的硕士论文《Untersuchungen zu dynamischen neuronalen Netzen》(慕尼黑工业大学)。⭐ 它是德文写的,从没在英文期刊上发表过。三年后 Bengio、Simard、Frasconi 在 IEEE Trans. Neural Networks 5(2):157–166 发表《Learning long-term dependencies with gradient descent is difficult》—— 标题就是结论。
⚠️ 这条的归属至今仍有争议,本讲只说「1991 年那篇论文正式指出」,不卷进优先权之争。⭐ 而有意思的是结局:2001 年 Hochreiter、Bengio、Frasconi、Schmidhuber 四个人合写了一章《Gradient flow in recurrent nets》—— 当年分头发现同一件事的两拨人,十年后坐到一起把它总结了。
⚠️ 还有一条口径要说清:这个问题最早是在循环网络上发现的,不是在我们这一格画的前馈网络上。⭐ 但它们是同一件事 —— 循环网络按时间展开之后,就是一个「层数 = 序列长度」的超深网络。那篇综述里报的实验跨度是 1000 步,换算过来就是一千层。
y = x + F(x),每层局部导数变成「1 + 某个数」—— 所有括号都取 1,1 的 61 次方还是 1,梯度总有一条不衰减的路直达任何一层。📌 出处:He 等,arXiv 1512.03385(ResNet);更干净的恒等通路推导在同一组人的 arXiv 1603.05027。⛔ 本格不展开那个式子 —— 「1 的 61 次方还是 1」已经是它的全部内容。
⚠️ 0.9 / 1.1 是举例的量级,不是某个模型的实测;层数 61 取自 DeepSeek-V3。两个连乘结果都是本脚本现算并 assert 住的。
先把病说准。一个参数的梯度 = 61 个局部导数连乘 —— 而连乘对「每一项平均是多少」极其敏感(上图左半那两行)。
注意这两个数离 1 都只有一成 —— 比上面那张图用的 ±20% 还近一半,塌得照样彻底。 连乘没有中间地带:不是指数塌,就是指数涨。 而且越靠近 1,越说明问题:连「每层只偏 10%」都扛不住 61 层, 那就不存在「小心一点就没事」这种可能。 这就是 2015 年之前「层一深就训不动」的全部原因。
顺手堵一个几乎人人都会踩的读法:「梯度小」≠「这一层不重要」。
梯度的含义是每挪一格有多少效果 —— 它小,说明这个参数钝,
也就意味着要达到同样的效果得挪得更远。
它不是不需要动,是比谁都更需要动。而 参数 − 学习率 × 梯度 偏偏给了它最小的步子。
这条「正好拧反了」是 3.3b 的开场,也是自适应优化器存在的全部理由。
残差做的事,数学上只有一步:把每一层从
y = F(x) 改成 y = x + F(x)。
于是这一层的局部导数从 ∂F/∂x 变成了
1 + ∂F/∂x。
这就是全部,剩下的都是它的推论。
∏ (1 + ∂Fi/∂x) 展开,里面有一项是
所有括号都取 1 —— 而 161 = 1。
不管中间那些权重是大是小,梯度总有一条不衰减的路直达任何一层。1 + 很小
—— 网络一开始等价于一个浅网络,训练过程再一层层把 F 学起来。所以「残差让模型能做深」不神秘:它把每一层的局部导数 从「某个数」变成了「1 + 某个数」。 —— 而 6.0 那张表里,爆炸和消失的根因正是 「局部导数偏离 1」。残差是从结构上把它钉在 1 附近; 6.5 那些手段(Pre-LN、初始化缩放)是在同一件事上再拧一道。
📌 出处:He 等,arXiv 1512.03385(ResNet)。 恒等通路那条更干净的推导在同一组人的 arXiv 1603.05027 《Identity Mappings in Deep Residual Networks》—— 它把「梯度可以不经过任何权重矩阵直达浅层」写成了一个式子。 本讲不展开那个式子:上面那句「1 的 61 次方还是 1」已经是它的全部内容。
tools/manim/。
出框层与消失层都是脚本当场算的,并有断言钉住。)上面刚说「我们故意不算二阶导」。可它到底是个什么东西?
一句话:二阶导是坡度自己的变化率。
一阶导(梯度)说的是「你动一格,loss 动几格」—— 坡度。
二阶导说的是「你动一格,坡度变几格」—— 翻译成画面就是
这个地方弯得有多急。
一阶导告诉你往哪走;二阶导告诉你这个坡还能保持多久。 —— 同样是陡坡,一个马上变平、一个一直陡下去, 该迈的步子完全不同;可一阶导看它俩是一样的。
数都是本脚本现算的:Hessian 4.502e+23 个数(按 bf16 = 9.00e+23 字节);换算基准一块 80 GiB ⇒ 1.05e+13 块,而权重 1.22 TiB 只要 16 块。
解它按 N³ = 3.02e+35 次运算,拿每秒 1e18 次的机器 ⇒ 9.57e+09 年。⚠️ 那台机器是随手设的换算基准,只用来给量级,不是在说某台具体的机器;宇宙年龄取 138 亿年。
它的用处很硬:最优步长可以算出来。
在一条抛物线上,最优步长 = 梯度 ÷ 二阶导,一步到底
—— 不用试,不用调。
而且它正好治 3.3b 那个「拧反了」:
灵的旋钮该少拧、钝的该多拧 ——
除以二阶导之后,不同参数才可比。
柯西 1847 年那篇文章末尾写的就是这个分工: 一阶负责从远处走过来,二阶负责最后收口 —— 而这一讲后半段要讲的,就是二阶收不起口,怎么办。
先说它原来的样子:求「f 等于零」的那个 x。 做法特别朴素 —— 先瞎猜一个点,在那个点上画一条切线, 看切线跟横轴在哪儿相交,就跳到那儿,当作下一个猜测。反复做。
一句话:用切线代替曲线。 曲线难解,切线是直线,一眼就能看出它在哪儿过零。 它快得惊人 —— 通常每迭代一次,正确的位数大致翻一倍。
那它怎么变成优化方法的?—— 求极小值,等于求「导数等于零」的那个点。
那就把求根的牛顿法,用在导数身上:原来是「减去 f 除以 f 的导数」, 现在变成 —— 减去导数,除以导数的导数。
也就是梯度 ÷ 二阶导。 —— 所以上面那句「最优步长 = 梯度 ÷ 二阶导」 不是另一个公式,它就是牛顿法本身。
还有一个等价的画面,一样准而且更好想:
牛顿法做优化,等于在你现在这一点上贴一条抛物线
—— 让它的高度、坡度、弯曲程度三样都跟真实曲线对上,
然后直接跳到那条抛物线的底。
⇒ 所以如果 loss 本身就是一条抛物线,一步就到底了
—— 这就是「一步到底」这句话的来历。
那深度学习为什么不用?两条,第一条上面已经算过:
中间还有一条路叫拟牛顿(L-BFGS 这一类): 不显式造那张表,用最近几步的梯度去近似它的作用。 在传统优化里很好用,但在超大规模 + mini-batch 噪声这种场景下一直没做起来。
📌 出处(现查):牛顿十七世纪先有了类似的做法, 但把它写成今天这个迭代式子的是 Raphson,1690 年 (Analysis aequationum universalis); ⚠️ 两个人当时都只把它用在多项式上。
⛔ 那为什么不用?—— 因为它的大小是参数量的平方。
多参数的时候二阶导不是一个数,是一张表:每两个参数之间一个数。 这张表叫 Hessian。
所以「我们故意不算二阶导」不是偷懒 —— 它压根不在可能性范围内。
⚠️ 那台「每秒百亿亿次」的机器是随手设的换算基准,
只用来给量级,不是在说某台具体的机器。数都在 topic04-fig-second.py
里现算并 assert 住。
✋ 最后一件事,而且这是这一讲最容易被中文坑到的一处:
Adam 里那个「二阶矩」不是「二阶导」。
| 二阶导(Hessian) | 二阶矩(Adam 的分母) | |
|---|---|---|
| 对谁做 | 对参数求两次导 | 对梯度取平方再求平均 |
| 得到什么 | 曲率 —— 这儿弯得多急 | 这个参数的梯度平常多大 |
| 属于哪一路 | 几何 | 统计 |
| 多少个数 | N 的平方 | N |
它们中文都带「二阶」,纯属巧合。
这个区别不是学究气 —— 它有一个很硬的后果, 3.5 那个 warmup 就卡在这儿:
Adam 除掉的是「陡」,它除不掉「弯」。
分母是梯度的均方根,所以不管这一步梯度多大,更新量都被拉回 η 的量级 —— 「坡有多陡」这件事,被它归一化没了。 可「坡弯得多急」它从头到尾没算过:手上那 N 个数里,没有这个信息。
所以以后碰到「梯度都被 Adam 处理过了,怎么还会不稳」—— 答案就在这一行:不稳不是「陡」造成的,是「弯」造成的,而弯不在 Adam 的账本里。
同样,「一阶动量」也不是一阶导 —— 它是梯度的滑动平均,那个「一阶」指的是统计上的一阶矩(期望)。
那为什么老有人说「Adam 的分母在估二阶导」?
因为效果上确实有某种事后可以建立的联系。
但那是后人回头加的解释,不是发明它的人的思路 ——
详见 3.3b,那一节从三代人各自要治的病讲起。
⭐ 而最能说明问题的是尺寸:Adam 用 2 个 N 个数,换了一条路,
它压根没打算去逼近那张 N² 的表。
这也是为什么它叫「自适应学习率」,而不叫「近似牛顿法」。
数学上两个方向都成立,算出来的结果一模一样。 区别只有一个 —— 你得把整条链走多少遍。
⭐ 这一格是结构,不是数据 —— 图上唯一的量是「 6,710 亿」,那是模型规模,前面已经立过。
📌 「正向模式 / 反向模式」是自动微分的标准术语;反向传播是反向模式用在神经网络上的那个特例。
tools/manim/。)所以反向传播成立的全部理由就一句话: 参数有几千亿个,而 loss 只有一个。
多输入、单输出。 如果 loss 不是一个数、而是一百万维的输出,这套就不划算了 —— 那时候反倒该用从前往后。
所以 1.1 那个问题的答案是:那 6,710 亿次前向, 压成的是一次反向。
这条判据可以直接迁移: 看到任何一个「求一大堆偏导」的问题,先数一下输入多、还是输出多 —— 它决定了你该从哪头开始。
🕰️ 而这件事第一次被写下来,据公开资料是 一篇没人读的硕士论文。
1970 年,赫尔辛基大学,一个叫 Seppo Linnainmaa 的学生在硕士论文里 提出了反向模式的自动微分 —— 也就是上面这整套「从输出往回推」的做法。
而那篇论文里一次都没提神经网络。 —— 他解决的是「一个复合函数怎么高效求导」这个纯数学问题。
神经网络那边要再等十六年,才有人把它接上去(1986 年那篇 Nature)。
这个形状前面其实已经出现过一次 ——
1.4 那个「梯度消失」,第一次被说清楚也是在
一篇硕士论文里(1991 年,慕尼黑,德文,从没在英文期刊发表)。
两次改变一切的东西,第一次出现时都是没人读的硕士论文。
1970 那条我核的是公开的传记与综述资料,
没有读到论文原件(芬兰语,未数字化)—— 当量级可靠的二手事实看,
所以正文写的是「据公开资料」而不是断言。
1991 那条(Hochreiter 的德文硕士论文)同样没读原件,
但它有 2001 年那篇四人合写的综述作为一手转述,可信度高一档。
两条都不要当成「我读过」来引用。
回头看 1.2d 那两笔里的第 ② 笔: 算自己权重的梯度,要用「前向时存下来的输入」—— 而那个输入,就是激活。
⛔ 这就是激活必须留着的根本原因 —— 不是谁设计得不好,是反向的数学本身要求它在场。
前向每算出一个中间结果,都得一直挂在那儿, 等反向走回来的时候用。整条网络走完,它们全都还在。
这一节的两笔账到此都立住了: 算力 3×(前向 1 + 反向 2); 显存里多出一整条从头挂到尾的激活。 而下一节要做的,就是拿第一样去换第二样。
真实是 61 层,而且每层内部还有若干个中间张量,山坡比图上细密得多
⛔ 山形画成直上直下是简化:真实曲线会因为 MoE 派发、attention 那几个大中间量而有凸起,但「顶点在前向末尾」这个结论不受影响
⚠️ 104.1 GiB 与 5.07 GiB 两个数是自己按算子推的(输入:V3 的 config + 官方参考实现的 MLA 前向),没有第三方背书;序列长度取 4,096、batch = 1,跟 Ⓐ 那座山同一个口径。
📌 图 Ⓑ 那两张卡片的读法: 它们是同一条序列的两种配置,不是两个模型。
两个数都是自己按算子推的(输入是 V3 的 config + 官方参考实现的 MLA 前向),没有第三方背书。 但就算差一倍,结论也不变:这个规模上,装不下。
📌 那「一堆中间结果」到底有多少?一句话给你个量级。
按 V3 的真实配置(4K 序列、一条)逐项数下来:一层约 1.73 GiB, 61 层合起来约 104.11 GiB。
对照一下:V3 的权重按 bf16 是 1,250 GiB —— 所以一条序列的激活 只有权重的约十二分之一。
但真正要记住的是这两样东西涨得不一样:权重是固定的,激活每多跑一条序列就多一份。 batch 到约 12 条,激活就追平权重;而训练的 batch 从来不止十几条。 —— 这才是下一节那笔交易存在的理由。
❓ 那这 1.73 GiB 里,最大的是哪一项? —— 这个问题必须在这儿答,因为下一节整节都在挑「该扔哪一个」。
不是 attention —— 是 MoE 的「九份复制」。
这一条直接决定了下一节的名单: 要省激活,先看的不是 attention,是那几份复制。 它也解释了一件反直觉的事 —— MoE 在参数账上很省 (每 token 只选中一小部分权重),在激活账上却要付九份的复制费。
逐项怎么数的、换到 128K 是多少 —— 都在下面这个折叠块里。属于「装不装得下」,本讲不要求。
这一小节可以整段跳过。 它是给要自己动手算的人看的 —— 上面那两个数从哪来,全在这儿。
基准单位先立住:一份 hidden 宽的张量
= 4,096 × 7,168 × 2 B = 56 MiB。
下面所有数都是它的倍数。(序列 4,096、batch 1、bf16。)
为什么是 4,096 而不是 128K —— V3 是在 4K 上做的预训练(14.8T token 全在这个长度上), 128K 是预训练之后两段各一千步的扩展。 本讲所有的账都按 4K 算;128K 只在需要对比的地方出现,并会标明它是扩训场景。
换算很简单:激活只认 token 总数(这一点 5.1 会专门论证), 所以 128K 的数就是把下面每个数 ×32(131,072 ÷ 4,096)。 唯一的例外是注意力分数矩阵 —— 它带 S²,要 ×1024。见下面第二条边界。
| 留下的张量 | 宽度 | 大小 |
|---|---|---|
| norm 的输入(= 残差入口,重算模式下唯一留的那份) | 7,168 | 56 MiB |
| norm 的输出 | 7,168 | 56 MiB |
| Q 降维结果(layernorm 前后各一份) | 2 × 1,536 | 24 MiB |
| KV 降维结果(含 RoPE 那 64 维) | 576 + 512 | 8.5 MiB |
| Q 展开后 | 128 头 × 192 = 24,576 | 192 MiB |
| K、V 解压后 | 128 头 × 256 = 32,768 | 256 MiB |
| attention 输出 | 128 头 × 128 = 16,384 | 128 MiB |
| logsumexp(fp32) | 128 | 2 MiB |
| 小计 | 约 722 MiB |
| 留下的张量 | 份数 × 宽度 | 大小 |
|---|---|---|
| norm 的输入 / 输出 | 2 × 7,168 | 112 MiB |
| 路由分数 | 256 | 2 MiB |
| 派发给专家的那份 | = 上一行本身,九个专家共用 | 0 MiB |
| gate / up / SwiGLU 乘积 | 3 × 9 份 × 2,048 | 432 MiB |
| 专家输出(合并前) | 9 份 × 7,168 | 504 MiB |
| 小计 | 约 1.03 GiB |
❓ 凭什么是这些张量?—— 判据只有一句: 反向的公式里要不要用到它。
框架只存反向真正会读的那几个量。按算子分,规律干净得出乎意料:
| 算子 | 反向要用什么 | 要存吗 |
|---|---|---|
加法 y = a + b |
导数恒等于 1,谁都不依赖 | 一个字节都不用存 |
逐元素乘 y = a × b |
算 a 的责任要用 b,算 b 的要用 a | 两个都得存 |
矩阵乘 y = x·W |
算 W 的梯度要用 x(1.3 第 ② 笔) | 存 x |
| 非线性 SiLU / GELU | 导数是输入的函数 | 存输入 |
| softmax | 导数能用输出表示 | 存输出 |
⭐ 加法白送,乘法和非线性要付钱。 而神经网络里几乎全是乘法和非线性 —— 所以「一层几十份」是必然的。
⚠️ 一个常见的误会:「加一个 bias 也会多一份激活。」 —— 它确实会在显存里短暂出现一块新缓冲,但它不进「留着等反向」那本账, 用完就释放。上面那张表记的是后者。
⭐ 再补一条,它是这张表里数目最大的来源: 不是每一份都跟输入一样宽。Q 展开后 24,576 宽,一份顶 3.4 份; K/V 解压后 32,768 宽,一份顶 4.6 份。 —— 所以「几十份」里有一半是被「宽」撑起来的,不只是「多」。
「9 份」是这张表里最值得停一下的地方 —— 而它出现在哪、不出现在哪,同样值得停一下。
9 = 被激活的 8 个路由专家 + 1 个共享专家。 九份出现在「出来」这一侧:每个专家各算各的,各产出一份中间结果和一份输出 —— 光「专家输出」这一项就 504 MiB。
⛔ 「进去」那一侧没有九份。
九个专家读的是同一块内存 —— 就是上面那行「norm 的输出」,
已经记过一次了。
⚠️ 实际跑起来常见的做法是先按专家把 token 重排成连续块(好做分组矩阵乘),
那个重排缓冲区确实是一份副本,top-9 就是每个 token 出现九次,4K 上 504 MiB。
但也有实现在反向里重做一遍重排、不把它存下来 ——
所以它是实现选择,这张「必需量」的表里不记。
(这一条 2026-09-22 现场纠过一次:原来这张表把它当必需量记了,虚报了 448 MiB。)
而它在专题一那张参数量的表上完全看不出来。 —— MoE 在参数账上很划算(每 token 只选中一小部分权重参与计算), 可在激活账上,它要付九份的复制费。
合起来:一层 MoE 块约 1.73 GiB,一层 dense 块约 1.24 GiB; 58 层 MoE + 3 层 dense ≈ 104.11 GiB。
📐 换到扩训那一档(128K):×32 = 一层 MoE 块约 55.39 GiB,全模型约 3331.39 GiB。
这个数是很多人记住的那个,但它是扩训阶段的账 —— 真正跑了 14.8T token 的那段预训练,这一项是 104.11 GiB。
⛔ 这张表的三条边界,讲的时候必须说清楚。
别因为「才 4 GiB」就放过它:上面整整一层 MoE 块的全部激活 加起来才 1.73 GiB —— 这一项自己就比那一整层还大。 在 128K 上它是压倒性的,在 4K 上它依然是单个最大的张量。 这条论点没有因为换基准而失效,只是从「吓人」变成「仍然第一」。
还有一项,它不在上面两张表里 —— 因为它不属于任何一层。
最后那个投影把 hidden 变成词表上的分数(logits),形状是
[序列长度, 词表]。V3 的词表是 129,280:
4,096 × 129,280 × 2 B = 1010 MiB
(一条 4K 序列)
把它跟上面那两张表放一起比一下:
它是整个模型里最大的单个张量, 而且 softmax 通常还要升到 fp32 去做 —— 那就再翻一倍。
所以真实实现几乎都不会把它整个物化出来: 把序列切成若干块,算一块的 loss、回一块的梯度,再算下一块。 —— 这跟 2 那节的重算是同一个思路, 只是换到了词表这一维上。
正因为主流实现都分块,它没有被算进上面的总账 —— 这是个口径选择,不是忘了。但你要是自己写训练循环、 又老老实实一次性算完整个 logits,这一块会突然出现在你的显存里。 扩训到 128K 那一档它是 31.6 GiB,届时它不分块就根本跑不动。
1.3 只讲到梯度算出来那一刻就停了。 可它离「被用掉」还隔着好几道 —— 而这几道每一道都是推理里不存在的。
⚠️ 图上不含任何量 —— 通信到底多大、能藏掉多少,是那张 batch 图和专题五的事。
⭐ 第 ⑤ 道那句「用完就扔」是本讲另一处的伏笔:正因为它一次性,它才敢用 bf16 存 —— 而一旦要做累积,它就变成累加量,得升回 fp32。
纯数据并行下,每一步要把整份梯度在所有卡之间汇总一遍。 量级很好算:参数量 × 每参数字节数。
关键在这儿:这笔通信量跟 batch 完全无关。 —— 参数有多少就传多少,你喂一条序列和喂一千条,传的是同样多的字节。
而计算量是随 batch 线性涨的。所以:
batch 越大,这笔通信被摊得越薄。
这一下就解释了两件原本看着不相干的事:
✋ 这里必须补一句,否则上面那段会被读歪: 爬 batch 买到的不是吞吐。
「batch 开大就更快」这句话有前提,而且前提正好卡在大规模训练这一档 —— 并行度一旦吃满,每步变贵的倍数正好抵掉步数变少的倍数。
所以在这个规模上,开大 batch 买到的是 通信被摊薄和梯度更稳 —— 不是「跑得快」。
那条曲线连同「该开多大」的完整取舍,在 3.5b —— 那一节里它跟另外两句民间话 (「大了才稳」「大了就不行」)摆在一起讲,三句凑成一组才完整。
「算」和「传」能叠在一起,是训练里最重要的一类优化 —— 而推理侧没有对应物:它没有反向, 也就没有这条可以边算边传的长尾巴。
裁剪那一道为什么藏不了、「逐层裁剪」为什么是另一件事 —— 图下面的落点写了。这里只留一句: 「这一步总共迈多大」才是跟 3.3 对话的那个量。
⭐⭐⭐ 一句话:梯度累积改的是时间线,不是总量。
边界:这一节只讲了「这一步存在、有多大、能不能藏起来」。 换个切法它是 all-reduce 还是别的形态、量各差多少 —— 专题五整讲的事。
通信量那个「参数量 × 每参数字节」是量级口径: 真实的环形汇总要来回搬,实际搬运量大约是它的两倍; 而 MoE 的专家部分走的又是另一套。当量级看。
这是全课第一次出现真正的取舍: 不是「有没有更好的办法」,而是两样东西只能选一样,你选哪个。
这一节留在主线上,是因为它接着 1.6 那个结论(反向要用中间结果,所以扔不掉)—— 「扔了再算回来」是这条因果链的下一步,而那条判据很值钱。 但具体省多少 GiB、哪一档划算属于「装不装得下」,那是 专题五 的事。本节相关的细账都收进折叠块了。
前向每算出一个中间结果就留着,是因为上一节那条 —— 反向要用。重算说:我不留了。
反向要用的时候,我从这一层的入口再往前跑一遍,现算出来。 就像游戏存档 —— 不存整个过程,只存一个存档点, 要用的时候从那儿重打一遍。
先把量级说清楚 —— 这才是要记住的东西。
这个兑换比例,夸张到不像是个「权衡」。
所以在大模型训练里,它默认就是开着的 —— 值得讨论的从来不是开不开,而是开到哪一档(图 Ⓑ 那三档)。
⚠️ 104.1 GiB / 5.07 GiB 是自己按算子推的估算(V3 的 config + 官方参考实现的 MLA 前向),当量级看;就算差一倍,「不对称」这个结论也不变
⭐ 「3× → 4×」是矩阵乘口径:重算等于把前向那一遍再买一次,所以多出来的正好是 1/3 —— ZeRO 论文原话也是这个数(33% re-computation overhead)
⭐ Ⓒ 那三个「同时在场」由 L/k + k 当场算出,脚本内 assert 最优点落在 √L、且两头等高 —— 这一格的全部意思就是那个等高
⛔ Ⓑ 里那两个百分比都按「一个 step」做分母(前向 + 反向 = 3 遍)。早先「选择性」那一档写的是 6%,那是拿一遍前向当分母的旧口径—— 并排摆着不能比,已统一。
📌 Ⓑ 里「选择性」那一档的 1.9% / 71%,推导过程与名次表见下一张图与本节正文;DeepSeek-V3 报告(arXiv 2412.19437)明写他们重算全部 RMSNorm 与 MLA 上投影 —— 正是那一档
对每一个中间张量问同一个问题: 把它扔掉、反向时重算回来,每省一个字节要付多少次浮点运算?
比值越小越该扔。就这一个数,整张排序表自己就出来了。
对线性层,这个数有闭式解,而且漂亮得出乎意料:
一个 [S,k] × [k,n] 的矩阵乘 ——
重算代价 2·S·k·n FLOPs,产出张量 S·n·2 字节(bf16)。
一除,每字节代价 = k。
这个闭式解压着一个前提:重算它只付它自己那一个算子。 成立的条件是它的输入还在。一旦上游那个张量也被扔了, 就得先把上游重算出来 —— 代价要沿链累加,不再等于这一个 k。 本讲的选择性重算名单都挑在「输入还在」的位置上,所以这条一直成立; 但你自己排名单时要盯着它。
重算一个线性层的输出,每字节要付的 FLOPs
恰好等于它的输入宽度。
S 和 n 全约掉了 ——
跟序列长度无关,跟输出多宽也无关。
所以「哪个线性层最该重算」这个问题,答案是看谁的输入最窄 —— 不用算,扫一眼 config 就知道。
这里要跟 1.6 那个排名对一下 —— 「最占地方的」和「最该扔的」是两个不同的排序。
1.6 排的是占多少,这一节排的是每省一字节付多少。 一个看绝对量,一个看比值 —— 它们没有任何理由一致。
而这一次,它们碰巧一致了 —— 1.6 里最占地方的那两项,正好都在最便宜的那一批。
这是运气,不是规律 —— 反例就在同一张表上:最贵的那一项(o_proj 的输出,每 GiB 付 17.59) 只占一层的 2.5%,扔它既不省地方又很贵。 所以下次换个模型,两个排序完全可能打架。真打架的时候,按比值挑,不按大小挑:判据是「每省一字节付多少」, 从来不是「谁最胖」。
attention 不是线性层:代价随 S² 涨,产出只随 S 涨。 一除,每字节代价随序列长度线性上升。
⭐ 线性层那条闭式解:一个 [S,k]×[k,n] 的矩阵乘,每字节代价 = k(重算 2·S·k·n FLOPs ÷ 产出 S·n·2 字节,S 和 n 全约掉)—— 所以它在图上必然是水平线
⚠️ 两条斜率分别是 V3 的 1.25(qk 192 / v 128)与 GPT-3 的 1.00(qk = v = 128);口径都是 causal 折半。⛔ 换个模型就得重画它自己那两条线(qk 192 / v 128)与 causal 折半的口径;换个模型斜率会变,但「它是斜的」不会变 —— 这才是要记的东西
⛔ 交点 13,107 不是工程阈值,它还取决于你拿哪条线性层做对照(图上四条给的交点各不相同)
📌 2022 那篇的收益数字(GPT-3 省 70% 付 2.7%)用的是未折半的 Megatron 口径;换成本图统一的 causal 口径,GPT-3 的 attention 占比是 1.37%
图上那两条斜率不同的线,就是这一节的全部内容 —— 一条平的(线性层,代价 = 输入宽度),一条在爬的(attention)。 斜率不同,就必然相交。
一条是常数(输入宽度),一条在往上爬 —— 那它们必然相交。
拿来对照的那条平线,要用最宽的那个线性层。对 V3 它是
o_proj(把 128 个头拼起来投回残差流),输入宽 128 × 128 = 16,384
—— 不是 d_model 的 7,168。
⛔ 为什么要特意说「不是 d_model」?因为我一开始就是这么错的。
这个交点早先写的是 5,734,就是拿 d_model(7,168)当了「最宽的线性层」。 在标准 MHA 上「头数 × 每头维度 = hidden」,所以那个等式成立; 而 MLA 把这条约束解除了 —— V3 是 128 头 × 128 = 16,384, 比 d_model 宽一倍。
反例一直印在 1.7 那张表上 (「attention 输出 128 头 × 128 = 16,384」)—— 隔了半节,没对上账。
判据:凡是「A = B」这种听起来像常识的架构关系, 换了架构就要重新验一遍。 —— 它不会报错,只会让后面每一个数都偏。
于是:1.25·S = 16,384 → S ≈ 13,107。
13,107 是个粗略交叉点,不是工程阈值。 它依赖 causal 折半的口径、依赖 V3 的头维度、依赖你拿哪个线性层做对照。 要记的是那句「两条线斜率不同所以必然相交」,不是这个数。
把 V3 在基准的 4K 上排一遍 —— 一层 MoE 块,按「每 GiB 要付多少 TFLOP」升序:
| 张量 | 省显存 | 重算代价 | 每 GiB 付 | 结论 |
|---|---|---|---|---|
| logsumexp(attention 副产物,fp32) | 0.002 GiB | ~0 | 0 | 白捡 |
| RMSNorm 输出(3 份,逐元素) | 0.121 GiB | ~0 | ~0 | 白捡 |
| SwiGLU 乘积 9 份(逐元素) | 0.141 GiB | ~0 | ~0 | 白捡 |
| K/V 解压(输入宽 512) | 0.250 GiB | 0.14 TFLOP | 0.55 | 划算 |
| Q 展开(输入宽 1,536) | 0.188 GiB | 0.31 TFLOP | 1.65 | 划算 |
| 专家输出 9 份(输入宽 2,048) | 0.492 GiB | 1.08 TFLOP | 2.20 | 划算 |
| attention 输出 | 0.125 GiB | 0.69 TFLOP | 5.50 | 边际 |
| gate / up / 路由 / 降维(输入宽 7,168) | 0.303 GiB | 2.33 TFLOP | 7.70 | 边际 |
| MLA 后的残差流(= o_proj 输出,输入宽 16,384) | 0.055 GiB | 0.96 TFLOP | 17.59 | 边际 |
这张表不用背,它是上面那条闭式解直接排出来的 —— 除了逐元素那几行(代价≈0)和 attention 那一行(随 S 动), 其余每一行的「每 GiB 付」就是各自的输入宽度换了个单位, 你拿 config 自己也能排一遍。 顺带自曝:这张表早先有一行是手填的, 「省显存 9.14 × 每 GiB 7.70」算出来是 70 TFLOP,那一栏却写着 39.08。 而这张表的卖点正是「你自己也能排一遍」。照着排的人会正好撞上它。现在整张表由闭式解生成,手改不了。
⛔ 回答那个直觉问题:「有没有占显存很小、算力却很大的东西?」 —— 有,就是 attention。但「有多极端」完全取决于你在哪个序列长度上问。
判据只有一条比值 —— 比值高的留,比值低的扔。 而这张表里只有 attention 这一行会随序列长度动,其余各行是输入宽度,跟 S 无关。
| attention 每 GiB 付 | 4K(本讲基准) | 128K(扩训) |
|---|---|---|
| 绝对值 | 5.50 | 175.92 |
| 跟最宽的线性层(o_proj,17.59)比 | 只有它的 31% | 贵 10 倍 |
| 在这张表里排第几 | 第 7 / 9(o_proj 和 gate/up 都更贵) | 第 9 / 9(最贵) |
| 结论那一栏 | 边际 | 绝不 |
同一个模型、同一条判据,只把序列长度从 4K 推到 128K —— attention 就从「还排在两个线性层后面」变成「比谁都贵 10 倍」。
别把话说过头:4K 上 attention 的比值是 5.50, 仍然高于下面那条「小于 3 全收下」的线 —— 所以按本讲自己的切法,它依然不进「收下」那一批。 变的是「它还是不是那个极端离群值」,不是「它突然该重算了」。 这个区别很重要:前者是事实,后者要看你把刀切在哪。
❓ 「小于 3」这个 3 是哪来的?我定的,不是算出来的。
它在表上的位置很清楚:专家输出那一行是 2.20,下一行 attention 输出是 5.50 —— 3 就落在这两行中间那个空当里,放 2.5 或者 5 结果完全一样。
而真正定这条线的东西不在这张表上:
它是你现在的兑换率 —— 一 GiB 显存对你值多少 TFLOP。
显存快爆了就往右挪(多扔几项,多付点算力),算力是瓶颈就往左挪。
所以别把 3 记成阈值 —— 要记的是「表是按比值排的,你只需要决定在哪儿切一刀」。 排序是客观的,切在哪是你的配置说了算。
照这条线切(把比值小于 3 的全收下来):一层省 1.19 GiB,付 1.53 TFLOP。 换算到一个 step(一层,前向 + 反向 = 3 遍 = 16.4 TFLOP): 多付 9.3% 的算力,换掉可重算池的 71%。
对比全量重算 —— 同一个 step 口径下是「多付 33%,换掉 95%」。 选择性重算的性价比还是高 2.7 倍,这就是它值得单独配的原因。
这两个数在 128K 上长得很不一样,而漂亮的是那一档。
128K 上同样切法是「只多付 1.9% 换 71%」,性价比高 13.1 倍 —— 确实够得上「一个数量级」。
为什么差这么多:分子(重算代价)∝ S, 分母(一个 step)在 128K 上被 S² 的 attention 撑着。 —— 所以序列越长,同一批重算看起来越便宜。 那个「1.9%」是长上下文专属的漂亮数字,别拿到 4K 上引用。
但方向没变:两个基准上选择性都明显划算。 而全量重算那个「多付 33% 换 95%」是尺度无关的 —— 它只取决于「前向跑两遍而不是一遍」,跟 S 一点关系都没有。
⛔ 顺带收紧一个口径:attention 那一部分的反向不是 2 倍,是 2.5 倍。
1.3 那个「反向 ≈ 前向两倍」对带权重的矩阵乘是严格的。 但这一讲处处假设用了 FlashAttention(1.7 边界②)—— 而 FlashAttention 为了省显存,反向时要把注意力分数重新算一遍。
FlashAttention-2 论文原话:「To get the FLOPs of the backward pass, we multiply the forward pass FLOPs by 2.5 (since there are 2 matmuls in the forward pass and 5 matmuls in the backward pass, due to recomputation).」(arXiv 2307.08691 §4.1)
这正是这一节主题的又一个实例:FlashAttention 省下的显存, 代价就是它自己内部也在重算。 —— 「没有免费的午餐」在这里有一个非常具体的价码。
代进本讲的占比:128K 上 attention 占一层前向 82.1%, 一个 step 是 3.41× 而不是 3×(按 3× 算会少算 12%); 4K 上 attention 只占 12.5%,是 3.06× —— 基本无碍。 本讲其余各处仍按 3× 的近似口径写,这是有意的简化,不是漏了。
「选择性重算多付 9.3%」和「全量重算多付三分之一」这两个百分比,早先分母不一样(一个除一遍前向、一个除整个 step), 并排比是不能比的 —— 而这一讲自己在 2.5 就写着「跨文献比这类比例前, 先确认对方折没折半」。已统一到 step 口径。
一条第一方证据:上面那条判据(每省一字节要付多少 FLOPs,= 产生它的那个算子的输入宽度)不是我们自己推着玩的。
DeepSeek-V3 的报告里写得很直白 —— 他们 「重算全部 RMSNorm 运算和 MLA 上投影」, 理由是「开销很小,却显著降低了存激活的显存需求」。
RMSNorm 输出和 MLA 上投影,正是这条判据算出来最便宜的那两类—— 逐元素的代价≈0,上投影的输入宽只有 512 / 1,536。 判据是我们自己推的,但推出来的名单跟人家实际配的对上了。这比多算一遍更有说服力。
📌 出处:arXiv 2412.19437 §3.2.3。
「选择性重算」这个概念出自 Korthikanti 等,Reducing Activation Recomputation in Large Transformer Models,arXiv 2205.05198(2022-05)。
它的判据跟 2.3 一模一样 —— 论文原话是:挑那些 「占显存不少、但重算起来不贵」的部分。
但它选出来要重算的,恰恰就是 attention —— QKᵀ、softmax、softmax dropout、以及 attention over V。 收益是:GPT-3 省 70% 激活显存只付 2.7% 算力; MT-NLG 省 65% 付 1.6%。
为什么结论会反过来?因为它的序列长度是 2,048。
但要用 GPT-3 自己的斜率算。它是标准 MHA,qk = v = 128,
所以斜率是 1.00,不是 V3 那个 1.25 ——
代进去是 1.00 × 2048 = 2,048。
而 GPT-3 自己最宽的线性层是 49,152(= 4h,MLP 降维的输入宽;V3 是 16,384,o_proj 的输入宽)。
2,048 远小于 49,152 —— 它落在自己交点的左边很远处。 在 2K 上,attention 真的是最划算的重算对象。论文没错。
判据一个字没改,结论却翻转了。但有一句要说准:
变的不只是序列长度。两个模型的斜率不同(1.00 vs 1.25)、 对照的线性层也不同(49,152 vs 16,384)—— 两条线都得重画。
而那个 49,152 我自己就写错过:原来写的是 12,288,
也就是 GPT-3 的 d_model。可这条判据要的是
产生那个张量的矩阵乘的输入宽度 —— MLP 降维层的输入是 4h。
V3 上我也犯过同一个错:拿 d_model 7,168 当最宽,漏掉了 o_proj 的输入 16,384(128 头 × 128),
交叉点因此一度算错(2.4 已改正)。这正是这一格自己在讲的那件事,我照样踩了两遍。
⭐ 「顺手套一条听起来像常识的关系」是最难发现的那一类错。
它不报错,也不会让你当场算崩 —— 它只是让后面每一个数都偏一点。 而且因为它听起来就是对的,你没有任何理由去怀疑它。
同一个毛病在这一讲里已经出现两次: V3 上把 d_model 当最宽的线性层(漏了 o_proj 的 16,384), GPT-3 上又把 d_model 当最宽的线性层(漏了 4h 的 49,152)。 —— 两次都是同一条「常识」,哪个模型上都不成立。
换句话说:能迁移的是那个形状,不是那些数。 —— 换个模型,你要重画两条线,而不是重记一组数字。
顺带自曝一处:这张图早先把 V3 的 1.25 直接套在 GPT-3 上, 标成了 2,560。—— 而这一讲从头到尾在讲「别拿 A 的常数套 B」。 判据:同一张图里出现两个模型时,每个模型的每一条线都要用它自己的常数。
一处口径要说明白,不然数字对不上:论文那个 2.7% 用的是 Megatron 传统公式,没有为 causal 折半。换成本课统一的 causal 口径, GPT-3 的 attention 占比是 1.37%。两个都对,只是约定不同 —— 跨文献比这类比例前,先确认对方折没折半。
顺带一句:这件事今天已经不用你操心了。 FlashAttention 天生就不把分数矩阵写进显存、反向时现算 —— 等于把论文那条建议内建成了默认行为。
⛔ 这里我原来写「所以现代框架的候选名单里 attention 根本不出现」—— 去翻了源码,完全说反了。
Megatron-LM 的选择性重算开关 --recompute-modules,
候选项里第一个就是 core_attn,
而且它是默认值(recompute_modules = ["core_attn"])。
先把话说准 —— 这里有三层,我原来只讲了一层。
recompute_granularity
的默认值是 None,也就是什么都不重算。
core_attn 是你主动打开 selective 之后,默认选中的那个模块。「If you are using transformer_engine as the transformer implementation, the core_attn is from transformer_engine and may be the fused version. For fused attention, you have no need to set 'core_attn' to recompute. Please check that the core_attn recompute is really needed.」
📌 transformer_config.py 里
if "core_attn" in self.recompute_modules: warnings.warn(...),2026-09 主干。
所以这不是「一个过期的默认值没人管」—— 而是有人发现了,但他没改默认值,他在旁边钉了一条警告。
为什么这样处理,比「直接改掉」更值得琢磨。
改默认值是要付代价的:别人照着旧默认跑出来的结果,从此复现不了。 —— 所以框架宁可留着一个不再最优的默认,也不愿意让历史结果失效。
于是这个默认值就成了一枚化石: 它记录的是 2,048 那个年代的最优解 —— 在那个长度上它对, 在长上下文上按我们这张表它是最不该动的那一个, 而在今天的融合 attention 下它干脆没什么可做。
判据不在于「这个开关该不该开」,而在于: 看到任何一个默认值,先问它是哪一年选出来的、当时的前提还在不在。 —— 而这一条对我自己也成立:我最初写的是「它还在那里当默认」, 那句话把三层揉成了一层,读者会以为一打开训练它就在偷偷重算 attention。
更值得看的是名单上的其余几项:
layernorm、moe_act、mla_up_proj
—— 分别对应 RMSNorm 输出、SwiGLU 乘积、K/V 解压与 Q 展开,按 2.3 那条判据算出来都很便宜。
方向完全一致。都落在这张表最便宜的那一批里。
但别说成「一个不多一个不少」:名单上还有 mlp / moe /
shared_experts,其中 mlp 对应的是表里第二贵、远在切线之上的 gate/up(最贵的是 o_proj 输出那一行)。
我们那条闭式解排出来的名单,和框架实际提供的选项对上了。
📌 megatron/core/transformer/transformer_config.py
的 recompute_modules 字段(2026-09 主干)。
判据:说「现代框架都不这么干了」之前,去 grep 一下那个框架。
这类断言听起来像常识,而它正好是最容易过期的一类。
这一节的落点,一句话: 反向要用中间结果,所以它们扔不掉; 但「扔掉再算回来」是一笔可以谈的交易 —— 而谈不谈得拢,靠的是一条能自己排出来的判据,不是背别人的结论。
两件不属于本讲那三件事的,收在下面的折叠块里: 重算可能算出不一样的东西(随机数、副作用、逐比特), 以及收益不能跨规模照抄(MFU / HFU 那套口径)。
前面算的是两本能算的账。可重算还有第三样代价, 它不在任何一本账上 —— 而且它不报错。
重算的前提是:把同一段前向再跑一遍,跑出来的要一模一样。 —— 有三种情况会让它不一样。
① 随机数 —— 这一条框架替你挡住了。
前向里有 dropout。如果重算时抽到的是另一套掩码, 那反向用的就不是前向那张网络了 —— 梯度直接是错的,而且没有任何报错。
PyTorch 的做法很干脆:把前向那一刻的随机数状态存下来,
重算前先恢复。
—— torch.utils.checkpoint 的
preserve_rng_state,默认就是 True。
而这一条正好解释了 3.7 那个清单里的第三项: checkpoint 里除了权重和优化器状态,还得存随机数状态 —— 原因是同一个:随机数是训练结果的一部分,不是「运行时的临时东西」。
② 副作用 —— 这一条没人替你挡。
如果那段前向除了返回结果,还顺手改了别的东西 —— 更新了一个滑动统计量、累加了一个计数器、写了一行日志。重算会把它再改一遍。
框架不会替你回滚这些,因为它根本不知道你改了什么。 —— 判据很简单:被重算的那一段,最好是个纯函数。
③ 逐比特不一致 —— 通常无害,但它有个具体的受害者。
同一段计算跑两遍,结果可能差在最后几位 —— 归约的顺序不同、挑的 kernel 不同,都会这样。
对训练本身,这个量级的差别基本没影响。 但它让「逐比特可复现」变难 —— 而那正是 6.6 里 PaLM 做到的那件事, 也是 6.2 那个「回滚 + 跳数据」的救火办法所依赖的前提。
一句话:重算把「算力 ↔ 显存」这笔交易谈成了, 但它同时悄悄引入了一个「结果要可重现」的要求。 —— 前两本账会告诉你划不划算,这一条不会:它只在出事的时候现身。
⛔ 同一个模型、同一个开关,换一个规模, 收益可能从正的变成负的。
原因不神秘:重算改变的是计算与访存的配比, 而这个配比在不同并行配置、不同芯片数下本来就不同。
由此推出一条通用规则(它不只对 remat 成立): 凡是会改变数据分片形状的参数,都不能跨规模照抄。 小规模上验过的结论,到目标规模上必须重验。
2.5 那个例子说明这条规则比听起来更狠: 序列长度也在这个名单里,而且它翻转的不是收益的大小, 是收益的正负号 —— 在 2K 上最该重算的那一项, 到 128K 上变成最不该动的那一项。
📌 另一个值得知道的量级 —— 而这个数可以直接算出来:
有用的活是 3 份(前向 1 + 反向 2),全量重算再加 1 份 —— 总共执行了 4 份。所以重算占已执行算力的四分之一。
这里我原来写的是「三分之一」 —— 那是把「比原来多付三分之一」(1 ÷ 3)和「占执行总量的多少」(1 ÷ 4) 搞混了。同一个 1 份,分母不同。 📌 顺带:那个「多三分之一」不是我们推的, ZeRO 论文原话就是「33% re-computation overhead」(arXiv 1910.02054 §3.2)。
这顺带解释了一个常见困惑 —— 为什么 MFU 看起来那么低: 分子里那一大块重算做了功,但按定义不算进「有效算力」。
说准一点:这里有两个指标,差的正好就是重算。
6ND 那一套)。全量重算时 HFU / MFU = 4 / 3
—— 就是上面那个「4 份里有 1 份是重算」。
所以看到一个 MFU 数字,第一件事是问它的分子取的哪一套。 —— 两篇论文报的 MFU 差 30%,可能只是一篇开了重算、一篇没开。
⛔ 而在长上下文上,「MFU 低」的主因不是重算。
重算最多让 MFU 变成 HFU 的 3/4(1.33 倍)。可 5.2 会算给你看:
128K 上 6ND 只数到真实算力的 17.9% ——
光这个口径差就是 5.6 倍。
⭐⭐⭐ 两个因子的大小随序列长度换位: 4K 上 6ND 只低估 1.14 倍,重算那 1.33 倍反而成了主因; 128K 上正好倒过来。
这条很实际:在长上下文上看到「MFU 只有 20%」就去关重算, 最多捞回四分之一 —— 真正该做的是先把 FLOP 口径对齐。
前面两节都在跟激活较劲。可把账摊开一看 —— 那个从头到尾一言不发的角色,才是最大的一块。
❓ 先花两句话把前提说清楚,不然下面那张账单看不懂。
训练的时候,同一个参数在显存里同时存着两份:
① 一份省地方的(bf16,2 字节)—— 前向和反向都拿它算;
② 一份精确的(fp32,4 字节)。专门用来记账,每一步的更新加在它身上。
这套做法就叫「混合精度」。 —— 为什么非得存两份,下一小节(3.2)整节都在回答。
混合精度训练下,每一个参数身上挂着五样东西 —— 而其中只有第一样是「模型本身」。
Adam:Kingma & Ba,arXiv 1412.6980(ICLR 2015);AdamW:Loshchilov & Hutter,arXiv 1711.05101(ICLR 2019)—— 那条「AdamW 不是新算法」带子里的那句是它摘要首句的意译(原文对 SGD 那半句还带个限定:按学习率换算之后才等价)
Muon:Keller Jordan 等 2024,作者 writeup kellerjordan.github.io/posts/muon。「只用于 2D 参数」「标量 / 向量 / 输入输出层仍用 AdamW」「per-step wallclock 比 AdamW 慢」三条都是原文
动量:Polyak 1964(heavy ball)/Nesterov 1983;AdaGrad:Duchi, Hazan, Singer, JMLR 2011(无 arXiv);RMSProp:Hinton 2012 Coursera 第 6 讲 —— 从未正式发表,这一条本身值得一提
另有三条省状态的岔路本图没画:Adafactor(arXiv 1804.04235,把 v 分解成一行加一列)、Lion(arXiv 2302.06675,只用梯度符号、单动量)、8-bit Adam(状态量化,不改算法)
⛔ 本图不含任何收敛速度的对照 —— 本课没有这些优化器的对照实测,画曲线就是编。图上只有结构与各自论文的定位
这一节只要记住一句:权重 2 字节,优化器那边 12 字节。
所以「显存里最大的一块是优化器状态」不是一个修辞 —— 它就是 2 比 12 这个比。
而且这 12 字节全是 fp32。下一小节说为什么它们非 fp32 不可。
⛔ 顺手拆掉一个最顽固的误解:「用了混合精度,显存不就省一半吗?」
常驻这一块,它一个字节都没省。 —— 两边算一遍,答案都是 16。
| 权重 | 梯度 | 动量 m | 二阶矩 v | 主权重 | 合计 | |
|---|---|---|---|---|---|---|
| 纯 fp32 | 4 | 4 | 4 | 4 | — | 16 B |
| 混合精度 | 2 | 2 | 4 | 4 | 4 | 16 B |
看那一列:权重和梯度各省了 2 字节, 可换来的是多出一份 4 字节的主权重 —— 2 + 2 正好被 4 吃掉。
那混合精度到底换来了什么?两样,都不是常驻显存。
判据:说「省显存」之前,先问省的是哪一块。 常驻和激活是两本账,一句「省一半」把它们混在一起, 结论就会在你最需要它的时候是错的(比如估一张卡装不装得下)。
图上那五格,为什么有三格是 fp32、两格是 bf16? 不用一格一格记 —— 根子上只有一个画面。
📌 Ⓑ 里每一个数都是脚本用一个真的 bf16 舍入函数算出来的(取 float32 的高 16 位,round-to-nearest-even,只用标准库 struct)。三条 assert 盯着:不到半格必须被舍回、跨一整格必须加得上、连加 1,000 次必须仍然等于 1.0。⭐ 判据:一张图要让人相信某个算术结果,就让脚本真的算那个算术。
📌 Ⓒ 那条「不是累不累加,是老的贡献会不会永远不走」是被一条第一方反证逼准的:DeepSeek-V3 技术报告(arXiv 2412.19437 §3.3.3)明说 AdamW 的一阶矩二阶矩用 bf16「未观察到性能下降」,而主权重、以及用于累积的梯度仍保 fp32。⛔ 判据(元级):一条判据被反例打中的时候,先别扔它 —— 多半是它的措辞比它的机制粗。
⭐ Ⓐ 顺带解掉 6.6 那条:fp16 需要 loss scaling 跟「16 位不够」无关 —— 它跟 bf16 一样是 16 位,只是把 3 位从指数挪给了尾数,于是指数位少了三位(五位对八位),能表示的最小正数抬高了三十多个数量级,小梯度直接下溢到零。
所以那 12 个 fp32 字节,装的正好是「老的贡献不走」的那几个; 两个 bf16 字节,装的正好是「用完就扔」的。 —— 这不是巧合,这是同一条判据画出来的线。
❓ 那梯度能不能是 fp32?能,而且有些实现就是。
最常见的场景是梯度累积:几个 micro-batch 的梯度要相加。 一直在 bf16 里加,小的会被大的吃掉 —— 累几次就掉精度了。 所以不少实现专门开一个 fp32 的 accumulator。
那样这一栏就是 4 字节,总账从 16 变 18。
📌 我们图上那个 16 是哪来的:它是
ZeRO 论文的经典口径 —— 2 字节权重 + 2 字节梯度 +
12 字节 fp32 那三份,原文写作 2Ψ + 2Ψ + KΨ = 16Ψ(混合精度 Adam 的 K = 12)。
arXiv 1910.02054。
所以这个数有出处,不是我们自己定的;但它是一种配置,不是定律。报这个数的时候要把口径一起报。
一处小订正:那两个 2 字节,论文里是 fp16,不是 bf16 —— 2019 年那会儿大家用的是 fp16。 今天普遍换成了 bf16,字节数一样,所以这张账一个字不用改; 但两者不是一回事(见 6.6 「bf16 要不要 loss scaling」那条)。
⛔ 一条第一方反证,把上面那句话逼得更准了。
DeepSeek-V3 的报告里明说:AdamW 的一阶矩和二阶矩都用 bf16, 「没有可观察到的性能退化」;而主权重和梯度仍然保 fp32 —— 梯度保 fp32 的理由,恰恰就是「要用于累积」。
方向没错,措辞太粗。真正的分界不是「累不累加」,是 会不会无限累加:
收紧后的判据:看它是不是「老的贡献永远不走」。 —— 永远不走的必须 fp32;会被衰减掉的、用完就扔的,低精度就够。
「必须 fp32」这句话要留个口子 —— 有人真的把它省掉了。
主权重之所以要 fp32,是因为四舍五入会把小更新整个抹掉。 而如果把它换成随机舍入 —— 按余数的大小决定进位的概率。那么被抹掉的部分,在多步之后期望上会被找回来。
那么判据其实比「累不累加」还要细一层: 真正致命的不是累加,是累加 + 每次都朝同一个方向抹零 —— 把这个偏差去掉,bf16 主权重就是可行的。
这不是推荐做法 —— 它要额外的支持,而 fp32 主权重便宜又省心。 放在这里是因为:知道一条规则「为什么成立」,才知道它什么时候可以不成立。
📌 出处:DeepSeek-V3 技术报告,arXiv 2412.19437 §3.3.3(原文分节是「低精度存储与通信」,不是 §3.2.3 那个重算小节)。 原文这句话几乎是逐条印证上面那张清单: 「用 BF16 而非 FP32 追踪 AdamW 的一阶和二阶矩,未观察到性能下降; 但主权重、以及用于 batch 累积的梯度,仍保留 FP32。」 —— 连「梯度因为要累积所以升回 fp32」这一条都写在里面。 顺带说明这张 16 字节的表不是定律。V3 这套配下来,每参数的账跟经典口径已经不是一个数了。
这条判据出了这一讲还能用:FP8 训练为什么难, 问的就是同一句 —— 精度往下压的时候,哪些量能压、哪些必须留住, 看的还是它累不累加。那是另一课的事。
⭐ 梯度下降比神经网络早了一百多年。 它出自 Augustin-Louis Cauchy(柯西)1847 年在法国科学院的一篇短文, 标题直译是《求解联立方程组的一般方法》。
他当时要解决的根本不是优化问题,是解方程。
那个年代解联立方程组的标准做法是消元。柯西开篇就指出它两个毛病: 很多情况下根本消不掉;就算消得掉,最后剩下那一个方程复杂得不像话 —— 哪怕原来那几个方程都挺简单。
⭐ 于是他换了个题:与其去解方程,不如去找一个函数的最小值。
他要求这个函数永远非负。多个方程怎么并成一个?原文里写得很干脆
—— u² + v² + w² + … = 0。
每个方程平方之后加起来,谁都不能是负的,那这个和等于零就等价于每一项都等于零。
—— 于是「解方程」变成了「把这个和降到零」。
⭐ 真正的发明不是微积分(那是牛顿和莱布尼茨的) —— 是这一下改题:把「解方程」改成「下山」。 我们今天训练模型,用的就是他这一下。
⭐ 原文末尾还有一句很值得看的:拿这个方法得到已经比较接近的值之后, 「可以再用线性的、或者说牛顿的方法」快速逼近。 —— 他非常清楚一阶方法和二阶方法各自的位置: 一阶负责从远处走过来,二阶负责最后收口。而这一讲 3.3b 讲的「为什么大家只好去估二阶导」,正是这条分工在几千亿参数上的下场。
📌 出处:A.-L. Cauchy,Méthode générale pour la résolution des systèmes d’équations simultanées,Comptes Rendus Hebd. Séances Acad. Sci. 25, 536–538(1847)。上面转述的两个毛病、平方和那一步、以及末尾那句牛顿法, 都出自原文(英译本)。
拿到了 6,710 亿个偏导数。—— 然后呢?往哪边挪。
每个参数挪一点点,loss 会变多少? 把每个参数的挪动量乘上它自己的偏导数,再全加起来。 —— 只要那一步挪得足够小,这是推得出来的,不是经验。
措辞要抠一下,因为它是这一节唯一的裂缝:「各项乘起来再加总」不是偏导数的定义(偏导数的定义是单变量的那个极限),它是一阶近似(全微分)。—— 所以它需要「挪得很小」这个前提,而这个前提就是下面那半节、以及整个 3.3b 要对付的东西。
要让 loss 降,就要让这个总和是负的。 每个参数都朝自己偏导数的反方向挪 —— 每一项都成了「负 × 正」, 加起来必然是负的。
「沿负梯度走 loss 一定降」是算出来的,不是经验之谈。 而且在所有「走同样远」的方向里它降得最快 —— 这就是「梯度是上坡最快方向」的另一面。
⛔ 那「挪得足够小」到底有多小?没有答案。
偏导数说的是「就在你脚下这一点,坡有多陡」, 它不保证一米之外那里还是这个坡。 步子一大,「保证下降」就失效 —— 你可能冲过谷底,落到对面比出发点还高的地方。
方向是确定的,步长是没有答案的。 —— 这一小节剩下的部分、以及 3.3b 整节,都在跟它较劲。
📌 Ⓑ 末尾那句「最快是相对于你怎么量一步」取自苏剑林《为什么我们偏爱各向同性?基于最速下降的理解》—— 原话是「梯度反方向是损失下降最快的方向,但这结论是有前提的,最关键的前提是它选取的度量是欧氏范数,如果换一个范数,那么最速方向也就变了」。⭐ 这句前提几乎所有教程都略过,而略过它,Muon 就只能被当成「又一个新优化器」。
📌 「球滚下山」「步长 ∝ 斜率所以不会冲过头」「落在哪个谷取决于起点」「高维时看那一列数的正负与相对大小」四个讲法,取自 3Blue1Brown《Gradient descent, how neural networks learn》官方讲义 —— 已逐条核过原文,图是我们自己重画的。
⭐ Ⓒ 那一整列负梯度,正是反向传播一遍算出来的那一份 —— 所以这一讲的第一节和第三节,接头就在这儿。
tools/manim/。)那张图留了句不好听的:落在哪个谷,取决于你从哪儿出发。 —— 一维图上这件事很吓人。下面这张是来拆它的。
📌 「critical point 分 local minima 与 saddle point」「判据是 Hessian 特征值全正与否」「沿负特征值方向可继续下降,但实践中很少这么做」「实测 never reach a real local minima」四条,取自李宏毅2021《类神经网络训练不起来怎么办(一):局部最小值与鞍点》投影片 —— 已逐条核过原文,图是我们自己重画的。
⭐ 他课上还引了《三体Ⅲ·死神永生》里那个能在高维取物的魔法师作比,投影片原话是「从三维空间看它是封死的,在更高维度里并不是」。⛔ 小说情节我们没核,所以只转述这一句,不展开 —— 图上的主比喻用我们自己的垭口。
⚠️ Ⓑ 刻意不给概率:「每个方向朝上朝下各半,所以 d 维全朝上的概率是 2 的 −d 次方」这句话听起来很顺,但特征值的符号并不独立,那个数是编的。只讲定义层面必然成立的部分。
⭐ 原片收尾那句也在本讲别处出现:更小的 batch 和动量都有助于逃离临界点 —— 噪声和惯性,正好是那张 batch 图与 Adam 那两格在讲的东西。
这张图切了两刀给你看剖面,而那个形状本来是三维的。 下面让它转起来。
tools/manim/。)❓ 「维度一多就不会有坑」—— 这句话是错的, 得改一个字。
四维能有一个四面封死的深坑,一千维也能有。 数学上没有任何东西禁止它。
⭐ 真正成立的是这句:一个又高又封闭的坑,在高维里极其罕见。 不是「封闭的坑不存在」,是「封闭」这件事本身就意味着它已经很低了。
为什么高度和封闭程度会挂钩? 想一下「封闭」要求什么 —— 所有方向都得朝上,一个都不能漏。 而你站得越高,脚下能往下走的地方就越多:下面还剩着一大片高度可以掉。 反过来,越接近最低处,能往下的方向越少,直到一个都不剩 —— 那才是谷底。
⭐⭐ 所以高维里那些让训练停下来的点,绝大多数是垭口,不是谷底 —— 而这不是因为谷底被禁止了,是因为谷底都在很低的地方,你还没走到。
这不只是推理 —— 有人真去量过。
把训练一直跑到梯度为零,然后数一数:这个点有多少方向是往上的?
—— 结果是,那个比例从来没到过 1。
换句话说:训练停下来的那些地方,总还剩一批方向是往下的。 —— 它没走,不是因为没路,是因为坡太平了。
✋ 那就顺带回答一个很常见的困惑:「参数多不是更难训吗?」
显存和算力上确实更难。但在「会不会卡死」这一项上,恰恰相反。 —— 两件事各论各的,别混成一句「大模型更难训」。
⛔ 而坏消息紧跟着就来:卡不住,不等于走得快。 垭口附近坡极平、梯度极小,而我们的步长又是「跟坡度成正比」的 —— 那就会在那儿磨很久很久。 接下来那一整串优化器,一多半就是在治这个。
📌 出处:Dauphin 等,Identifying and attacking the saddle point problem in high-dimensional non-convex optimization(arXiv 1406.2572,NeurIPS 2014)。 摘要原话:一般以为主要困难是「比全局最优高得多的局部极小大量存在」, 而他们论证「更深也更根本的困难来自鞍点的大量存在,而不是局部极小, 在高维问题上尤其如此」。
⛔ 顺带挡掉一个听起来很顺、其实是编的说法: 「每个方向朝上朝下各一半,所以 d 维全朝上的概率是 2 的 −d 次方」。 —— 那些方向的曲率符号并不互相独立,这个数没有依据。 本讲只讲定义层面必然成立的部分。
⭐ 而那篇论文真正要人记住的,是后半句: 鞍点周围是「高误差的大平台」(原文 high error plateaus), 它会严重拖慢学习,并且给你一种「已经到局部最小了」的错觉。 —— 真正的敌人不是「卡死」,是「磨」。
它还欠半句:卡不住,但垭口附近坡太平,会磨很久。 下面这张是那半句的第一个答案。
⭐ Ⓐ 两条轨迹、Ⓑ 三个箭头的长度、Ⓒ 那排柱子,全是脚本算的。loss 是自己造的一维函数 L(x) = 0.015x² + 0.45cos(1.1x),造它的唯一要求是「路上正好一个浅坑、一个深谷」—— 坑在哪、多深,是让脚本自己找出来的,不是我标上去的。四条 assert 盯着:没动量那条必须停在浅坑且梯度归零、有动量那条必须落进深谷、两者落点要拉开。
⭐ Ⓑ 特意挑的是绿轨迹正穿过浅坑的那一步,并 assert 了「这一步的梯度近乎为 0,而移动量仍然很大」 —— 这一条不成立的话,这张图就没什么可讲的了。
📌 这个主意有多老:1964 年。Polyak《Some methods of speeding up the convergence of iteration methods》—— 比反向传播那篇 Nature 还早 22 年。⭐ 他给这个方法起的名字是「小重球法」(the method of a small heavy sphere)—— 我们上面画的那个球,名字就是从这儿来的。
⭐⭐⭐ 而 Ⓑ 那个「梯度往回拉、惯性把它带走」的画面,原文逐字说过:「The motion proceeds not in the direction of the force (i.e. antigradient) because of the presence of inertia」—— 运动不沿着力(也就是负梯度)的方向走,因为有惯性。他还说那一项会让它沿着谷底走(转述;原文 along the bottom of the trough)。
⭐⭐ 最有意思的一条:Polyak 在 1964 年给的经验取值是 ρ = 0.8 – 0.99,而今天 Adam 的默认 β₁ = 0.9 —— 六十年过去,还在这个区间里。(脚本里拿这个区间 assert 了图上用的两个 β。)⭐ 他连调参顺序都写了:先把 ρ 设成 0 调好学习率,等收敛慢下来再把动量加上;并报告实测多数情况下比梯度法快,最多快到十倍(转述;原文 up to tenfold)。
⛔ 有一条我没能核实,所以不写:常有人说 1986 年那篇反向传播的 Nature 论文里就带了动量项。这一轮没拿到原文(链接 404),所以本讲不提这一条 —— 等拿到原文再说。
📌 讲法取自李宏毅《类神经网络训练不起来怎么办(一)》:他把动量写成「Movement = 上一步的移动 − 当前的梯度」(不只看梯度,还看上一步怎么动的),并在收尾写明 「smaller batch size and momentum help escape critical points」。⛔ 图是我们自己重画的,曲线和数都是自己跑的。
⭐ 上面那张图画的是「冲过浅坑」。它是真的,但它是三个机制里 日常最少用到的一个 —— 上一格刚说完,高维里封闭的坑本来就罕见。
① 冲过平地。 梯度接近零的时候,惯性还在。治的是「磨」,不是「卡」 —— 而鞍点周围那一大片高误差平台,正是这一条每天在对付的东西。
② 别再横着撞谷壁。 —— 这才是它在真实训练里最主要的作用,而且是三条里唯一每天都在生效的。 机制一句话:同号的放大,反号的抵消。
回想 3.3b 那个一边陡一边平的谷: 陡的方向左右横跳,平的方向慢慢蹭。
⭐ 所以动量本质上是一个筛子:它放大你一直朝着走的那个方向, 压掉你来回摆的那个方向。 —— 而深度网络的 loss 面普遍就是这种狭长的形状,所以它几乎总有用。
⭐ Polyak 1964 原文里那句「这一项会让它沿着谷底走」 说的正是这一条 —— 他在 1964 年就把它写成了「沿谷底走」, 跟上面那个标题是同一件事。
③ 平掉噪声。 小 batch 的梯度是带噪的,而动量是个滑动平均 —— 顺手就把抖动抹平了一层。
❓ 那它什么时候不管用?—— 这有个能算出来的上限。
经典动量(Polyak 那个,也是 PyTorch 的 SGD momentum)的更新是
速度 ← β × 速度 + 梯度。
梯度大小恒定时,这个速度会一直累,累到 1 ÷ (1 − β) 倍为止。
| β | 稳态放大 | 等效「记得住」多少步 |
|---|---|---|
| 0.80 | 5 倍 | 约 5 步 |
| 0.90(最常用) | 10 倍 | 约 10 步 |
| 0.99 | 100 倍 | 约 100 步 |
⭐ 这就是它全部的本钱。 β = 0.9 的时候,动量最多把有效步长放大到 十倍 —— 坑壁比这个高,它就是冲不出去。
所以「有时候不管用」不神秘,也不是调参没调好: 它带的动能是有限的,而且这个上限你现在就能算。 —— 上面那张图里它冲得过去,就是因为那个坑的深度正好在十倍以内。
⛔ 还有反面:它会冲过头。 越接近谷底,惯性越会把它带过去,于是在底部来回荡几次才停。 动量不是纯赚 —— 它拿「终点附近多晃几下」换「路上不停下来」。
⚠️ 两个都叫「动量」,但 Adam 里那个不放大幅度 —— 这一处很容易混。
速度 ← β×速度 + 梯度
—— 恒定梯度下累到 1/(1−β) 倍。它买的是速度。m ← β×m + (1−β)×梯度
—— 这是个归一化的滑动平均,恒定梯度下稳态就等于梯度本身,
一点不放大。它买的是方向的稳定,不是速度。⭐ 同一个名字,两件事:一个攒动能,一个去抖动。 Adam 的步长由 3.3b 那个 0.2 定,跟 β₁ 攒不攒速度无关。
⭐ 所以把动量介绍成「帮你逃出局部最小」,其实是抓了最不常用的那一面。 它每天真正在干的两件事是:在平台上不停下来,和在狭长谷里不横着撞。
tools/manim/。)这三张图把方向说完了 —— 顺着负梯度走 loss 就在降,维度一多基本卡不死,平地上还能靠惯性滑过去。 这一节只剩一个问题:那一步,到底该迈多大?
上一小节说清了「往哪边走」。这一小节只回答一个问题: 迈多大一步。
先看一行几乎所有人都写过的代码:
参数 ← 参数 − 学习率 × 梯度
📐 先把这一节接回 3.3 那位 1847 年的柯西。
他那篇文章末尾留了一句:用这个方法拿到已经比较接近的值之后, 「可以再用线性的、或者说牛顿的方法」快速逼近。
那句话把整件事切成了两半:一阶负责从远处走过来,二阶负责最后收口。
—— 而这一整节讲的就是「二阶收不起口,怎么办」。
量纲那套是严的,但它不是最快看见问题的那条路。 先用两个旋钮把结论看出来 —— 只用小学算术。
一台机器上只有两个旋钮,此刻误差是 1,000。
❓ 要把这 1,000 消掉,两个旋钮各该拧多少格?
甲:1,000 ÷ 100 = 10 格。
乙:1,000 ÷ 1 = 1,000 格。
该拧的圈数,跟灵敏度是反比 —— 灵的少拧,钝的多拧。
那 参数 ← 参数 − 学习率 × 梯度 实际给的是多少?
甲走 η × 100,乙走 η × 1
—— 100 : 1。
⛔ 需要的是 1 : 100, 它给的是 100 : 1 —— 不是差一点,是正好拧反。
后果分两头:灵的那个被猛拧,冲过头、来回震荡; 钝的那个几乎没挪,几千步都到不了位。 —— 整台机器被最钝的那个旋钮拖着走。
这个反比是在「把每个方向当成独立的、局部线性的」这个近似下算的 —— 真实的谷是弯的,方向之间还互相耦合。当直觉用,别当公式用。 下面那张「那一步该迈多大」图给的是同一件事更正规的版本。
而这一条,正好把 1.4 那个「梯度消失」翻译了一遍。
那里算出来:连乘之后最前面几层的梯度只剩 0.0016。 这句话最容易被读成「前面几层不重要」—— 恰恰相反。
梯度小 = 旋钮钝 = 要走的距离更长。 它不是不需要动,是比谁都更需要动 —— 而 SGD 偏偏给了它最小的步子。
这里有一处必须说准,否则两头会打架。
中间某一层若把信号压到 0.5 倍,上游的梯度确实是减半的;
翻倍的是「要达到同样效果,它得挪多远」。
—— 这两个量互为倒数,所以「梯度减半」和「要走的路翻倍」
说的是同一件事的两面。
混着说必然自相矛盾,所以本讲一律按这个口径:
梯度 = 每挪一格的效果,不是该挪多少。
两边的单位对不上。
梯度的含义是「这个参数变一点,loss 变多少」—— 单位是 loss ÷ 参数 (1.0 说过,loss 的单位是 nats/token。所以这里是 nats/token ÷ 参数)。 「参数」不是物理单位,权重本身无量纲。这里是把参数自身的尺度当单位用,它在这套推导里守恒所以推得动。 而且这推的是 SGD;Adam 除掉二阶矩后更新量本身就是参数尺度, 学习率的量纲跟这里不同(下面「那一步该迈多大」图的落点说这一条)。 可你要的是「参数该挪多少」。单位是参数本身。
所以中间必须乘一个东西把它折过来 —— 那就是学习率。 反推一下它的单位:参数² ÷ loss, 也就是 参数² · token / nat。
把这个单位念出来,就知道它不是一个纯数字: 里面同时含着「你的参数有多大」和「你的 loss 有多大」, 而 loss 的尺度跟词表大小有关(1.0 那把尺的上端是 ln V)。 —— 换个模型、换个词表、换个 batch,它就得重调。
全网络共用一个学习率,而不同参数的梯度尺度能差好几个数量级。 —— 下面两条轨迹同一个谷、同一套规则,只改了学习率。
📌 「同一个学习率,大了第二次更新就飞出地图之外、小了更新一百次还走不到谷底,所以不同参数应该有不同的 learning rate」这个两难取自 李宏毅《Training Tip》投影片(2025 秋 GenAI-ML 课程)。
⛔ 但他那两个具体数字我们没照抄 —— 抄一个别人挑出来的学习率,等于把别人的地形当成自己的。这里自己搭了谷、自己跑了两遍,每条轨迹都有 assert 盯着。
⚠️ 画面用的陡峭比是 25,不是正文说的「几个数量级」。第一版按 1,000 画,物理没错但画面废了:平方向几十步只挪几十像素,锯齿退化成一根竖线。⭐ 判据:要让人「看见」某个动态,参数按「看得见」选,真实量级交给公式外推。Ⓑ 第三行就是那条外推。
⭐ Ⓑ 那两个步数是闭式算的:平方向每步收缩 (1 − 1.9 ÷ 陡峭比),走到一半就是 log½ ÷ log(那个收缩率)。脚本里拿真跑一遍的结果对过账,差不超过 1 步。
tools/manim/。
门槛、±5% 的收敛/发散、以及左端那「三分之一」都是脚本当场跑出来并有断言钉住的。)别用梯度的大小,只用梯度的方向 —— 把每个参数自己的尺度先除掉。
❓ 可凭什么是「除」?—— 有标准答案,而且小到能当场验。
📌 「最优步长 = |一阶导| ÷ 二阶导」与「用一阶导去估二阶导」取自李宏毅(台大)Gradient Descent 课程投影片的讲法 —— 图是我们自己重画的。
⭐ 图上四个数都能当场验:抛物线 f = a·x² 上,一阶导 2ax ÷ 二阶导 2a = x,正好是到底的距离。脚本里带 assert。
⛔ 先纠一个几乎人人都这么说、却把思路带偏的说法: 「Adam 的分母是在估二阶导」。
这是后人回头加上去的解释,不是发明它的人的思路。 照这个理解走,你解释不了两件事:它为什么对稀疏数据特别管用, 以及它为什么会对「拿不准的方向」自动变谨慎。
真实那条路,出发点根本不在几何上 —— 在统计上。
① AdaGrad(2011):起点是罕见的词学不到东西。
作者当时想的不是神经网络,是文本。文本里「的」出现几百万次, 某个专业术语只出现三次 —— 而罕见的那些往往信息量最大。
可全网络共用一个学习率的话,那个术语这辈子学不到东西: 它只在偶尔出现的那几条样本上才有梯度,其余时候是零, 被常见特征拖着走。
⭐ 于是那个念头很自然:给每个参数配它自己的学习率, 而且见得越少的,步子该越大。
怎么知道见得多少?办法朴素得很 —— 把这个参数历史上的梯度平方全加起来。 天天有梯度的,这个和很大;罕见的,很小。然后除以它的根号。
⛔ 注意这里一个字都没提曲率、没提二阶导。 它从头到尾是个统计问题。详细出处见 3.4 —— 这个想法的出发点是 TF-IDF,不是曲率。
❓ 那「二阶矩」到底是个什么东西?—— 现在能说准了。
梯度的平方、取平均、再开根号 —— 这就是梯度的均方根。 翻译成人话:这个参数的梯度,平常大概多大。
⭐ 它不是曲率。它是这个旋钮最近这段时间的典型响应幅度 —— 一把尺子,而且是这个参数自己的尺子。
那除以它,究竟在干什么? 分子是当前这个梯度,分母是它平常多大。一除,得到的是 —— 「相对于它自己的常态,这一次算大还是算小」。 一个无量纲的数。
⭐ 不管这个参数本来的梯度是一百还是零点零一,除完之后 大家都在同一个刻度上 —— 这才是「自适应学习率」这个名字的真正含义: 不看绝对值,看相对于自己的常态。
先说「矩」。统计里的一阶矩就是期望,二阶矩就是平方的期望。 Adam 那个 v 就是梯度平方的滑动平均 —— 名字里那个「二阶」到此为止, 没有别的含义。
这里有一条值得较真的:它是未中心化的二阶矩。
也就是 E[g²],不是方差 —— 方差还要把均值减掉,
而 Adam 手里明明有 m(那就是均值),它偏偏没减。
而这不是疏忽,它正好是上面那条「信噪比」的来源。
梯度完全恒定时,m 和 √v 相等,比值是 1,走满步;
要是拿方差当分母 —— 恒定梯度的方差是 0,一除就炸了。
没减均值,这个比值才天然有上界。
那几何意义呢 —— 它确实有一个,只是不是大家以为的那个。
把 loss 曲面想成一个被拉得很长很扁的椭球: 有的方向梯度天天很大,有的方向常年很小。 Adam 做的事,是沿着每根坐标轴、按那根轴上梯度的典型大小,把轴各自重新标度一遍 —— 把这个拉长的东西压回各方向可比。
这叫对角缩放(diagonal preconditioning)。 它是个货真价实的几何操作 —— 可它缩放的依据是「这个方向平常动多大」, 不是「这个方向弯得多急」。
所以它治得了「各方向尺度差太多」,治不了「某个方向弯得急」 —— 3.5 那个 warmup 就是被后面这一条卡住的。
⭐ 还有一条边界值得记:它只会沿坐标轴缩放,不会转动坐标轴。 真正的耦合要是发生在轴与轴之间,逐坐标各缩各的就够不着 —— 这正是后来 Muon、Shampoo 那一路想补的方向:它们都不再是「逐坐标各缩各的」 (见 3.4)。
② RMSProp:起点是那把尺子会过期。
AdaGrad 有个致命伤 —— 那个和只增不减。走着走着分母越来越大, 步子越来越小,最后就停了。
Hinton 只改了一处:把「累加」换成「滑动平均」。
⭐ 背后的道理是这句:一个参数的「典型梯度大小」本身是会变的。 训练早期它大,后期它小。拿全部历史当尺子,等于拿一把过期的尺子量今天。
③ Adam:起点是分子分母口径不一致。
RMSProp 已经有尺子了(分母),可分子还是当前这一步的原始梯度,它会抖。 所以给分子也做一个滑动平均 —— 那就是动量。
⭐ 于是分子分母对齐了:都是「最近这段时间」的统计量。 分子管方向,分母管尺度。
而这一对齐,它顺手买到了一样没打算买的东西。 论文自己管这个比值叫信噪比:
⭐ 所以它同时干了两件事:把灵钝差异拉平,外加对拿不准的方向变谨慎。 —— 后面这件事没人设计,是那个形状白送的。
上面这几句,拿几个数当场算一遍就全清楚了。 Adam 只记两笔账:m 记方向,v 记大小。
更新式逐行照 Adam 原文 Algorithm 1(arXiv 1412.6980,已读原文):m ← β₁m + (1−β₁)g,v ← β₂v + (1−β₂)g²,m̂ = m/(1−β₁ᵗ),v̂ = v/(1−β₂ᵗ),θ ← θ − α·m̂/(√v̂ + ε);原文给的默认值 α=0.001、β₁=0.9、β₂=0.999、ε=10⁻⁸。Ⓐ Ⓑ 用这组默认值。
本课推导:+10/−10 交替时,m 的稳态在 ±(1−β₁)/(1+β₁)×10 ≈ ±0.53 之间跳,√v̂ 恒为 10,所以每步幅度是 0.053 个学习率 —— 脚本里拿这个闭式对了一遍真跑的结果。
Ⓑ 中间那条是「均值 2、标准差 10 的高斯噪声」,净走 0.19 是 3800 步稳态的平均;Ⓒ 用 β₂=0.95、学习率 0.1、噪声标准差 2 的一维二次谷,远处 0.92、谷底 0.19 两个数是 20 个随机种子的平均,图上画的是其中一个种子。它是玩具,只说明「谷底的梯度是噪声」这一件事。
谷底那个「约 0.2」跟本讲 Adam update RMS ≈ 0.2 那条(苏剑林的推导,纯噪声梯度下 √[(1−β₁)/(1+β₁)] ≈ 0.23)是同一件事:这里的「每步走几个学习率」取的是绝对值平均,口径略不同,量级一致。
Ⓐ 那一格「大小扔掉、只留方向」,后面 Muon 那几张图会做得更彻底: 它把整块更新矩阵的大小全部抹平,只留方向。同一个思路,更进一步。
⭐ 最后把两条路摆在一起 —— 这才是这一节真正的道理。
柯西那条路是几何的:看这个方向弯得多急,用曲率去定步长。 严谨,可在几千亿参数上付不起。
Adam 这条路是统计的:不看地形,看这个参数自己的历史 —— 它平常梯度多大,现在这一下算不算反常。
⭐ 两条路最后落在相似的地方,但出发点完全不同。 —— 而这也是为什么它叫「自适应学习率」, 而不是叫「近似牛顿法」。
现在关键的一步:Adam 的更新量大约是 「动量 ÷ 二阶矩的根号」—— 分子分母的量纲互相抵消。
📌 完整一点:真实的式子是
m̂ / (√v̂ + ε),那个 ε(常见 1e−8)是防止除零的。
而「量纲互相抵消」严格说只在 ε = 0 时成立 ——
ε 带着梯度的量纲,它正是这条「跟梯度尺度无关」的破口。
平时它小到无所谓;但梯度真的很小的时候(比如 6.5 讲的深层消失),
是 ε 而不是 √v̂ 在当分母。那一刻 Adam 就退回成了普通的 SGD。
也就是说,Adam 把梯度的量纲给除掉了 —— 这一步的大小,变成了一个跟梯度尺度无关的常数。
⛔ 那个常数不是 1,是 0.2。 我原来写错过:「量纲抵消了」只说明它是常数,没说明它等于 1。
实测它稳定在 0.2~0.3,而且不同尺寸的模型都一样。
而它有一个漂亮到不像话的闭式解 ——
在「梯度基本是噪声」这个近似下:
update RMS ≈ √[(1−β₁) / (1+β₁)]
代入 β₁ = 0.9:0.2294。跟实测对上了。
📌 出处:苏剑林《为什么 Adam 的 Update RMS 是 0.2?》(科学空间
kexue.fm/archives/11267)——
文中给了数值模拟(纯高斯梯度模拟出 0.225)与平均场近似两条路,
两边都落在同一个数上。
注意这个式子里只有 β₁,没有 β₂。 —— 两个 β 就此分工清楚:β₂ 管「记多久」,β₁ 管「每步迈多大」 (3.6 接着讲)。
所以学习率在 Adam 里换了身份:不再是折算系数,
而是直接乘在一个常数上 —— 每步每个参数挪 0.2 × 学习率。
这才是「Adam 学习率好调」的真正原因:它跟 loss 的尺度、
跟梯度的大小都脱钩了,只剩一个由 β₁ 定死的系数。
别的优化器只要把自己的 update 也对齐到 0.2, Adam 那套调好的学习率和权重衰减就能整套搬过去。 —— Kimi K2 从 Adam 迁到 Muon 用的就是这一招: update RMS 统一成 0.2,其余超参照抄。
📌 同一篇(苏剑林,科学空间)。 这是「量纲」这条线最实用的一个落点: 先把某个量做成常数,常数就能当接口用。
Adam 是每个数各除各的;Muon 把整块矩阵当一个东西来处理。 先认识它脚下那个词。
本课推导:转 30° 矩阵 (cos30°, −sin30°; sin30°, cos30°) ≈ (0.866, −0.5; 0.5, 0.866),乘 (3,4) 得 (0.598, 4.964),长度 5;反例 (1, 0.6; 0, 0.8) 乘 (3,4) 得 (5.4, 3.2),长度 6.28。脚本现算并断言。
出处:「半正交」(semi-orthogonal)一词取自 Muon 原作者博客:Newton-Schulz 迭代把更新换成「最近的半正交矩阵」(kellerjordan.github.io/posts/muon)。
正交矩阵只转不拉。那一块普通的矩阵呢? 它能拆成几个互不干扰的「频率」。
本课推导:[[2,1],[1,2]] 的奇异值分解 —— 两个频率的输入模式 (0.707, 0.707)、(0.707, −0.707),强度 3 和 1;numpy.linalg.svd 现算并断言,拆开再合 = 直接相乘也有断言。
注:「频率/振幅/能量」是类比,不是傅里叶变换本身:傅里叶的频率是固定的正弦波,这里的「频率」(奇异方向)由每块矩阵自己决定。共同点只在三条:互不干扰、各有强度、能量是强度平方和。
注:Ⓒ 右下那排配比条是随机数示意,不是任何模型的真实输出模式;6144×2048 只是举一个常见的门控矩阵形状。
有了「频率」这个词,Muon 的一步就说得清了。
出处:每一站都对着公开实现 github.com/KellerJordan/Muon 的 muon.py 写:momentum.lerp_(grad, 1−β)(β 默认 0.95)→ Nesterov 时 grad.lerp_(momentum, β) → X ÷ ‖X‖(Frobenius 范数)→ 五轮 X ← aX + (bA + cA²)X,A = XXᵀ,(a, b, c) = (3.4445, −4.7750, 2.0315) → 乘 max(1, 行/列)^0.5 → p.add_(update, alpha=−lr)。
出处:「嵌入、输出头、增益、偏置用 AdamW」:同一文件的说明与作者博客;博客写明输入输出层用 AdamW 是实测结论,不是理论推出来的。
注:强度条的数来自 topic04_muon_nums.py(现算并断言)。实现里还会把高的矩阵先转置再迭代、用 bfloat16 算 —— 这两样不改变上面的讲法,没画。形状系数各家写法不同(例如有的把整体大小对齐 Adam 的 0.2),这里画的是公开实现的写法。
中间那五轮矩阵乘,只是把每根推子各推一遍。
出处:系数 (3.4445, −4.7750, 2.0315)、5 轮、先除以 Frobenius 范数:Keller Jordan 博客与公开实现 muon.py。博客写明:系数按「0 附近斜率尽量大」来调,代价是只收敛到 1 附近而不是正好 1,实测不伤 loss;Newton–Schulz 能在 bfloat16 里稳定地跑,而另一种(耦合牛顿迭代)至少要 float32。
出处:「奇数次多项式与奇异值分解可交换」:Bernstein《Deriving Muon》(jeremybernste.in/writing/deriving-muon),经典三次 1.5x − 0.5x³ 出自 Kovarik 1970,也是该文举的最简单例子。
本课推导(topic04_muon_nums.py 现算并断言):5 轮后起点 ≥ 0.001 的落在 0.47~1.20;多跑几十轮在 0.68~1.13 之间晃;p(x) = x 的正根约 1.264,超过它就被越推越大(1.25 五轮还在,1.3 五轮就溢出)。
注:公开实现的说明里写的是「输出强度大致在 0.5~1.5」,比这里的单个多项式现算宽一些;我们只报自己算出来的数。
元素全变了,可它没有乱改。
本课推导:五轮多项式 p 满足 p(0) = 0、在 (0, 1] 上取正值(topic04_muon_nums.py 断言);更新与动量的内积 = Σ σᵢ·p⁽⁵⁾(σᵢ),因为两者共享同一组频率方向 —— 也有断言。
本课推导:余弦相似度 = Σσ / (√n · ‖σ‖),只由强度决定;示意矩阵强度 10/3/1/0.3/0.1/0.03 时为 0.56。「约三成格子正负号不同」随示意矩阵而变,只说明「逐元素看很不像」。
出处:「保留奇异向量、扔掉奇异值大小」这一说法:Bernstein《Deriving Muon》(we keep the singular vectors of the gradient but throw away the magnitudes of the singular values)。
一句大白话:Muon 是矩阵版的「只留正负号」。 再打个比方,就是一锅大锅饭。
注:本课比方:「大锅饭」「编制」「临时工」是讲课用的说法,不出自论文。Ⓐ 的碗数就是三个频率例子五轮后的强度(topic04_muon_nums.py 现算并断言),第四个方向强度 0 → 0。
本课推导:Ⓑ 每步 ±0.7、50 步随机游走,|终点| 的期望 = 0.7×√(2×50/π) ≈ 3.9;200 个随机种子实测平均 4.0(断言两者接近)。这一格只演示「一致性」这一个变量。
出处:「矩阵版取符号」这一说法:苏剑林《Muon 优化器赏析》把 Muon 写成 msign(矩阵符号函数),是逐元素 sign 的矩阵推广(kexue.fm/archives/10592)。
强弱比例都扔了,凭什么还更好?答案有两条,外加一份家谱。
出处:Keller Jordan《Muon: An optimizer for hidden layers in neural networks》(kellerjordan.github.io/posts/muon):低秩与「稀有方向」见 Why is it good to orthogonalize the update;Shampoo、Orthogonal-SGDM、Stochastic Spectral Descent 的关系见 Relationship to prior optimizers(后者那一小节作者 2025-07 补入)。
出处:Bernstein《Deriving Muon》(jeremybernste.in/writing/deriving-muon)Step 3:在 RMS→RMS 算子范数下约束更新,解是保留梯度的奇异向量、扔掉奇异值大小。图上「输出变化不超过上限」是这个约束的大白话版。
出处:Rprop:Riedmiller & Braun, IEEE ICNN 1993;signSGD:Bernstein 等, ICML 2018(arXiv 1802.04434);Shampoo:Gupta, Koren, Singer, ICML 2018;Orthogonal-SGDM:Tuddenham, Prügel-Bennett, Hare, arXiv 2202.07052;Stochastic Spectral Descent:Carlson, Cevher, Carin, AISTATS 2015;RMSProp 出自 Hinton 的 Coursera 课件,未正式发表。
出处:Moonlight:arXiv 2502.16982;Kimi K2:arXiv 2507.20534(MuonClip = Muon + QK-Clip:注意力最大 logit 超过阈值时按比例缩 Q、K 的权重;15.5T token 预训练零 loss spike)。苏剑林《Muon 优化器赏析》kexue.fm/archives/10592。
平面里最多两根互相垂直的箭头 —— 那模型里几千个维度,怎么装下更多的概念?
Anthropic 2022 年的《Toy Models of Superposition》研究的就是这件事: 概念个数超过维数时,模型让它们「几乎垂直」挤在一起,互相干扰一点点。这叫叠加。
它跟 Muon 是两件事:叠加说的是权重里装了什么,「几乎垂直」、个数可以超过维数; Muon 说的是每一步的更新长什么样,严格垂直、个数不超过短边维数。 别把一个当成另一个的解释。
下面这张总图,是高手看 Muon 的四个角度: Ⓐ「矩阵版取符号」、Ⓒ 那个方角,就是上面「大锅饭」和「推导」的另一种画法。
⭐ 讲法来源:苏剑林《Muon 优化器赏析:从向量到矩阵的本质跨越》,科学空间 spaces.ac.cn/archives/10592。Ⓐ 的三个特例、Ⓑ 的「迹」那个例子、Ⓒ 的范数视角、Ⓓ 的空窗解释,四条都取自该文 —— ⛔ 图是我们自己重画的,不是搬运
⚠️ Ⓒ 那个范数视角该文另引《Old Optimizer, New Norm: An Anthology》;⭐ 该文还考了一笔源流:2015 年的 Stochastic Spectral Descent 已经提出过大致相同的算法
⛔ 本图不含任何收敛速度对照 —— 本课没有这些优化器的对照实测,跟 3.1 那张图同一条规矩
⚠️ Ⓓ 那个「低于 1%」不出自上面那篇,出自 Muon 原作者的博客(kellerjordan.github.io/posts/muon):按 Llama 405B 的宽度和每批 token 数算出来的 FLOP 开销,不是我们量的墙钟时间。⛔ Newton-Schulz 是一串互相依赖的小矩阵乘,FLOP 少不代表时间短 —— 真要用请在目标配置上自己量(这正是本讲那条「不能跨规模照抄」)
⛔ 本图早先写的是「5% 以内 / 作者称 2%」,那个 2% 查无出处 —— Muon 原作者博客给的是 FLOP 开销低于 1%。2026-09-17 订正
🕰️ 顺带一句:Adam 原始论文(2014)那个收敛性证明,2018 年被指出是错的(Reddi 等,ICLR 2018)—— 补丁叫 AMSGrad,而大家继续用 Adam。一个东西能用,和它被证明过,是两回事。细节见下面的折叠块。
⛔ 🕰️ 这条「一路往上加」的线上,有一次很少被提的翻车。
Adam 原始论文(2014)是带收敛性证明的。 2018 年,有人指出那个证明是错的。
Reddi、Kale、Kumar,《On the Convergence of Adam and Beyond》 (ICLR 2018,arXiv 1904.09237)—— 摘要原话: 给出了「a simple convex optimization setting where Adam does not converge」, 并「describe the precise problems with the previous analysis of Adam algorithm」。
他们指出病根在那个指数滑动平均本身:
v 会忘掉很久以前那些大梯度,于是某些方向上的步子可以一直不收敛。
他们的补丁叫 AMSGrad —— 让 v 只增不减。
而最值得记的是后来发生的事:大家继续用 Adam。
AMSGrad 在实践里没比 Adam 好多少,于是那个「证明是错的」的算法 —— 被引用超过十万次,训出了今天所有的大模型。
这件事跟本讲的中心思想完全同频: 一个东西能用,和它被证明过,是两回事。 —— 而这一讲从头到尾在教的,就是别信结论,去看它的前提。
上面那张图基本讲完了。 这里只补图上没说的三句。
Ⓐ 那三列里,中间那一列值得单独想一下: Muon 作用在对角阵上会退化成逐元素取 sign —— 也就是说,「向量做法」本来就是「矩阵做法」的一个特例。 我们以前把它们当两种东西讲,那是把特例和一般情形讲反了。
梯度算完,到真正更新之间,还要过: 多卡 all-reduce 求平均 → 按全局范数裁剪一次(防止偶发大梯度炸掉) → 按 schedule 取当前学习率 → 权重衰减 → 才是那一步更新。
这一整条线可以用一句话收: 梯度只告诉你往哪走,优化器决定走多远。
而几十年的演化,全都在回答同一个问题 —— 这个「多远」该由谁说了算:
说到底就这么一条线索。
优化器的选择是一个显存决策,不只是收敛速度的决策。
Muon 那一份不是白省的 —— 两条限制都是作者自己写明的。
⚠️ 这一条里其实藏着两种不一样的排除,值得分开:
标量和向量是原理上不适用 —— 正交化是矩阵上的概念,
得有多个奇异方向才有得拉平;一个向量只有一个方向,「正交化」退化成单纯归一化,
没有信息可言。
可 embedding 和输出头是二维的,原理上完全做得了 ——
作者还是把它们留给了 AdamW,理由是实测效果更好。
这是实证排除,不是原理排除。
这跟图上 Ⓓ 那句「塞进了一段本来就空着的时间」不矛盾 —— 「更慢」说的是方向,「塞进空窗」说的是幅度(Muon 原作者在博客里按 FLOP 算是低于 1%)。 而幅度归你的配置管:那几轮是一串互相依赖的小矩阵乘, FLOP 少不代表墙钟短。真要用,在目标配置上自己量。
它的证据方式很硬:Muon 在 NanoGPT 那个刷速度的公开竞赛里把记录提了 35%, 此后(到作者写那篇博客时)十二次破纪录、七个不同的人全都还在用它。 —— 谁能把 AdamW 调到一样好,换回去就能破纪录。没人换。
顺带一句跟上一讲连起来:DeepSeek-V4 大部分模块就是用 Muon 训的 —— 论文(arXiv 2606.19348)摘要里列的三大升级之一。
这几个名字是一条线,不是几个并列选项: 每一代都在治上一代没治住的那种不稳。 —— 对照 6.0 那张失败模式表看,就不用背了。
所以「换优化器」从来不是换个名字 —— 是换一个你打算治的病。 而代价永远落在同一个地方:每个参数要额外记几个字节。
下面那一问说的是「衰减怎么加」。可衰减本身是什么,这一讲一直只是顺带提。 —— 三问,一次说清。
① 它是什么 —— 而答案跟教科书上那个不一样
一句话:每一步都把权重往零缩一点点。
教科书给的理由是正则化:不让模型靠几个特别大的权重去死记硬背 —— 岭回归那一脉传下来的。
⛔ 可这个理由在大模型预训练上站不住: 单遍过数据、数据量远超参数量,基本没有过拟合的机会。
但配置里它全都在,而且清一色 0.1 ——
DeepSeek 全系都是 weight_decay = 0.1(配 β₁ 0.9 / β₂ 0.95 / 裁剪 1.0)。
那它留着在干什么?
2017 年有人把这事说破了:在带归一化的网络里,L2 基本不当正则用了 —— 它影响的是权重的尺度,而尺度决定有效学习率。
机制一想就通:后面接着 Norm 的那些权重,你把整块放大两倍,输出一模一样 (Norm 会把这个放大归一化掉)。所以权重的长度不改变函数 —— 它只改变一件事:同样迈一步,方向能转多少角度。 权重越长,同样的一步转过的角度越小,也就是有效学习率越低。
而训练过程中权重是会慢慢变长的。 不管它,有效学习率就会自己一路往下漂。 —— 权重衰减把长度按住,让它别漂走。 所以它今天更像一个稳住有效学习率的旋钮,而不是一个防过拟合的正则项。
📌 van Laarhoven,arXiv 1706.05350 《L2 Regularization versus Batch and Weight Normalization》。 ⚠️ 那篇讲的是 BatchNorm 时代;搬到今天的 RMSNorm 上,起作用的是同一个尺度不变性 —— 但这是我们的迁移,不是原文的实验范围(2.6 那条判据)。
② 怎么衰减 —— 它是乘,不是减
θ ← θ − η·λ·θ = θ·(1 − η·λ)
—— 每一步乘一个略小于 1 的数。所以它是指数衰减: 要是没有梯度在推,权重会指数地趋向零。
算一下有多温和:V3 峰值 η = 2.2×10⁻⁴、λ = 0.1 → 每步缩 2.2×10⁻⁵;一万步累下来只剩 80% —— 很轻。
⚠️ 这里有个实践陷阱:那个收缩比例里带着学习率。 所以你一改 LR schedule,正则强度跟着一起变了 —— 你以为只动了一个旋钮,其实动了两个。 这也正是 3.3b 那条「一步的顺序」里, 衰减排在「按 schedule 取当前学习率」之后的原因。
顺带一句:实践上一般不对所有参数做衰减 —— bias 和归一化的增益系数通常排除在外。这是常见做法; 具体某个模型排了哪几类,得去看它自己的配置,别照抄。
③ 它为什么在优化器里 —— 答案是:它本来不在。
它原本是 loss 的一项:½·λ·‖θ‖²。
你把这一项写进目标函数,自动微分就会在梯度里自动产出 λθ
—— 所以它最初的身份,是「你想优化什么」的一部分。
那为什么搬家? 因为只要它还在 loss 里,它就必然跟梯度走同一条管道 —— 动量、二阶矩、除以分母,一样不落。而我们要的是均匀地拉。
而唯一能绕开分母的地方,就是更新那一步本身 —— 那一步归优化器管。
所以它从「你想优化什么」,变成了「你怎么走」。 —— 换的是归属,不是公式。
⚠️ 这次搬家是有代价的,值得记一句: 它不在 loss 里之后,你就不再能说「我在最小化 loss 加正则项」 —— 你实际优化的东西,和你写下来的那个 loss,不再是同一回事了。 这一点被批评过,但实践上它赢了。
❓ AdamW 那个「W」,用一个具体的画面再讲一遍
权重衰减本身很简单:每一步都把权重往零缩一点点,别让它越长越大。 问题只在于 —— 这个「往回缩」放在哪一步做。
老办法(原版 Adam):把它混进梯度。
算梯度的时候多加一项 λθ。听着很自然,反正都是要减的东西。
可一旦混进梯度,后面每一步都会一视同仁地作用到它头上 —— 包括除以 √v。
于是出来一个反着的结果。拿两个参数比一比就看出来了:
| 两个参数都已经长到 10 | √v(分母) | 那份衰减 | 实际收缩 |
|---|---|---|---|
| 常用特征,梯度天天很大 | 大 | 被除小了 | 几乎没被拉回来 |
| 冷门参数,梯度常年很小 | 小 | 被放大了 | 被往死里拉 |
它俩都长到 10,一样该被管住,可实际受到的约束正好反过来。 —— 我们要的是「所有权重都被均匀地往回拉一点」, 不是「按梯度大小分配惩罚」。这两件事被混在了一起。
AdamW 的修法就一句:衰减不走分母。
梯度那条路一个字不改;落地那一步单独再扣一次 η·λ·θ,
跟分母彻底分开。这就是 decoupled —— W 就是 weight decay 那个 W。
❓ Muon 把二阶矩整份扔了 —— 那「各参数尺度差太远」这个病,谁来治?
这是上面那张表欠着的一问:Adagrad 那一行刚说这是个要治的病, Muon 那一行就把药扔了。
答案是:正交化本身就在治同一个病,只是换了一层来治。
正交化把动量那块矩阵的奇异值全部拉到一样大。 奇异值就是「这块矩阵在各个方向上有多使劲」—— 全拉平,等于每个方向挪多少,跟那个方向原本梯度多大彻底脱钩。 尺度照样被抹掉了。
| Adam 的 v | Muon 的正交化 | |
|---|---|---|
| 在哪一层抹 | 逐元素,各除各的 | 整块矩阵,奇异值归一 |
| 抹掉的是 | 这个参数自己的梯度尺度 | 各奇异方向之间的尺度差 |
| 轴与轴之间的耦合 | 够不着(只沿坐标轴缩放,见 3.3b) | 够得着 —— 奇异方向本来就是跨轴的 |
代价也在这儿。Adam 那个分母还携带着一条信息 —— 这个参数「最近」反常不反常。v 一扔,这条就没了。 Muon 只剩动量:方向平滑还在,逐元素的自适应没了。
⚠️ 而且正交化只拉齐了各方向之间,它没说整体该迈多大。 —— 这正是下面 Moonlight 那篇要补「单独定整体更新幅度」的原因; 也是 Kimi K2 把 Muon 的 update RMS 校到 0.2(跟 Adam 那个常数对齐) 之后,Adam 那套超参就能整套搬过去的原因。
📌 这一格每一环都出自 Adam 原文(arXiv 1412.6980,已读原文):AdaGrad 的更新式原文逐字写作 θ_{t+1} = θ_t − α·g_t / √(Σ g²) —— 分母是累加的平方和,不除以 t,所以「单调衰减」这个病是从式子里长出来的;Adam 的定位原文写作「combine the advantages of AdaGrad(稀疏梯度)and RMSProp(在线与非平稳)」。
⭐ 偏差校正那一条,原文的说法是:滑动平均从 0 起步,于是估计 biased towards zero,especially during the initial timesteps,而且 β 越接近 1 越严重。而点名 RMSProp 的在 §5(跟 AdaGrad、RMSProp 的关系那一节):「RMSProp also lacks a bias-correction term」,以及 without bias correction, like in RMSProp —— Ⓒ 那条橙线画的就是这句话。
⚠️ 李宏毅课上那页写的 Adagrad 是「均方根」形式(分母里除了 t+1),跟这里画的原版不一样。⛔ 本讲按原版画,因为「有效学习率单调衰减」这个病只在原版(累加不除 t)上成立 —— 这个区别值得知道,不然两边对不上会以为自己算错了。
📌 三则出处,放在一起看很有意思(完整的故事在讲义里):AdaGrad 是正经的 JMLR 长文(Duchi / Hazan / Singer,12(61):2121–2159, 2011,整整 39 页),⭐ 而且题目是《Adaptive Subgradient Methods for Online Learning and Stochastic Optimization》—— 它根本不是为深度学习写的。
⭐⭐⭐ RMSProp 没有论文。它唯一的「出版物」是 Hinton 那门 Coursera 网课的一页 slide,标准引用写作 Tieleman & Hinton (2012), Lecture 6.5-rmsprop。⭐ 而那页 slide 的副标题本身就是算法的完整定义:「Divide the gradient by a running average of its recent magnitude」—— 把梯度除以它近期幅度的滑动平均。一句话,一页片子,成了这条链的中间一环。
⭐⭐ Adam 那篇(ICLR 2015)有两处特别好玩,都在论文里:首页脚注写着「Author ordering determined by coin flip over a Google Hangout」—— 作者顺序是在 Hangout 上掷硬币定的;致谢里写着「special thanks to Ivo Danihelka, and Tom Schaul for coining the name Adam」—— Adam 这个名字不是作者自己起的。
⭐ 图上的 4.1%、32 倍、6.6 倍三个数都是脚本算的,五条 assert 盯着:AdaGrad 必须单调衰减、跑到第 600 步必须掉到很小、不校正时第一步必须被放大很多倍、做了校正必须从第一步起恒为 1、以及「Adam 不校正的峰值必须低于 RMSProp 那条」(因为动量那一项的偏差会部分抵消)。
上面那条谱系是回头看整理出来的:每一代治什么病。 —— 可当年造它们的人,想的不是那件事。
📌 AdaGrad(2011)—— 动机是稀疏特征,不是稳定性。
原文的说法是:「不常出现的特征往往信息量很大、区分度很高」, 所以他们要「给高频特征很低的学习率,给低频特征很高的学习率」, 直觉是 —— 「每次见到一个罕见特征,学习器就该留意一下」。
想象文本里「的」出现几百万次,某个专业术语只出现三次。 同一个学习率下,那个术语这辈子也学不到东西。 AdaGrad 的办法:按这个参数历史上累计收到多少梯度来打折。
📌 Duchi、Hazan、Singer,JMLR 2011(预备版 COLT 2010)。 原文开篇就拿 TF-IDF 当动机(「我们把这个老想法当作出发点」)—— 就是搜索引擎里那条「越罕见的词越重要」。 出发点是信息检索里的老经验,不是曲率;优化理论是后面用来给它做保证的。
📌 Adam(2014)—— 「把每一步的幅度拉齐」这个解释,是它才提出来的。
论文 §2.1 原话:「在参数空间里每一步的有效幅度,大致被步长 α 这个设定卡住」 —— 而这「可以理解为在当前参数周围划出一个信赖域(trust region), 超出这个范围,当前的梯度估计就提供不了足够的信息了」。
换成大白话就是:不管这个参数的梯度是大是小, 它每一步挪动的幅度都被拉到差不多。 梯度小的被抬上来,梯度大的被压下去 —— 而这正是 3.3b 那个「0.2」的由来。
论文把 m̂/√v̂ 这个比值叫作信噪比:
梯度相对于它自己的噪声越小,这一步就越接近零。
📌 Kingma & Ba,arXiv 1412.6980(ICLR 2015)。
中间那代 RMSProp 出自 Hinton 的 Coursera 课件,没有正式论文。
⛔ 顺带收紧一句常见的说法:「SGD 不行」—— 太满。
SGD 加动量在视觉任务上至今能打。是在语言模型上 Adam 系统性占优。 —— 上面那条谱系说的是每一代治什么病, 不是「前一代没用」。
这一格真正的收获是那个错位: AdaGrad 当年为「罕见词要被听见」而造, 三年后它的机制被 Adam 用「把步子拉齐」重新解释了一遍 —— 而今天我们讲优化器,用的全是后一套说法。
判据:一个技术「为什么被发明」和「为什么留下来」,经常不是同一个理由。 只讲后者,会让人以为前人当初就想明白了 —— 而他们通常没有。
都是在动那 16 字节里的某一格,但动的格子不一样 —— 下面的字节数按 3.1 那套口径当场算:
| 做法 | 动了哪一格 | 每参数字节 | 代价 |
|---|---|---|---|
| AdamW(基准) | —— | 2+2+4+4+4 = 16 | —— |
| Muon | 把二阶矩整份拿掉 | 2+2+4+4 = 12 | 只管二维参数;改用正交化补回来 |
| Lion | 同样只留一份动量 | 2+2+4+4 = 12 | 更新只用梯度的符号 |
| Adafactor | 把二阶矩分解成一行 + 一列 | 那一份 ≈ 0;不带动量时总共 8 | 丢掉了 v 的逐元素信息 |
| 8-bit Adam | 两份状态各量化到 1 字节 | 2+2+4+1+1 = 10 | 算法不变,换的是存法 |
注意这三条走的是三个不同的思路: Muon 和 Lion 是「不要那一份」;Adafactor 是「换个更省的表示」; 8-bit 是「同一份东西存得更小」。 —— 所以 8-bit 可以跟前两者叠加,而前两者互斥。
📌 8-bit Adam 的做法:状态张量切成小块、逐块独立量化, 外加一种对大值小值都精确的非线性量化。 论文报告在一系列任务上保持 32 位效果,不改任何优化器超参 —— 两行代码的 drop-in 替换。
📌 Dettmers 等,arXiv 2110.02861(ICLR 2022 spotlight)。
但「不改算法只改存法」不完全成立,摘要里就写着: 达到 32 位效果靠的是三件事绑在一起 —— 分块量化、非线性量化, 加上一个「稳定 embedding 层」。
第三件是动网络结构,不是存法。 理由很具体:语言模型的输入 token 分布极不均匀,embedding 那层梯度方差特别大, 而量化最怕方差大。
判据:一个号称「drop-in 替换」的东西,先去摘要里数它到底改了几处。 「两行代码」说的是调用方改两行。
3.3b 讲的是 Muon 的想法,而想法好用不等于能直接上规模。 2025 年那篇专门做这件事的论文补了两处:加 weight decay(原版没有, 正是上面 AdamW 那一栏治的病),以及单独定整体更新幅度 —— 正交化只把各方向的尺度拉齐了,没说该迈多大。
补完才谈得上「开箱即用」。 论文的规模律实验报告:算力最优设定下,Muon 的计算效率约为 AdamW 的两倍。
📌 arXiv 2502.16982(Moonlight,3B/16B MoE,5.7T token)。 「两倍计算效率」是论文自己的规模律结论,不是我们的实测 —— 而且回想 2.6 那条判据:这类结论换规模要重验。 至今仍未核实的一条:Muon 下主权重是否仍需 fp32。
先给一把尺子:它不告诉你最优解,只告诉你有没有离谱。
📌 CS231n《Neural Networks Part 3》"Ratio of weights:updates":「A rough heuristic is that this ratio should be somewhere around 1e-3.」⭐ 原文还特意强调 "Note: updates, not the raw gradients"。
⚠️ 曲线是我们自己跑的:两层 tanh MLP(8→16→4),纯 numpy 手写前向反向,固定随机种子,跑 400 步。「刚好」那个学习率是扫出来的(让稳态比值最贴 1e−3),不是挑的;「再乘 2.1 就 NaN」是二分搜出来的。
这条曲线你只用做三个决定: 从哪升上来、升到多高、怎么降下去。
GPT-3:arXiv 2005.14165 附录 B —— 「头 3.75 亿 token 线性 warmup」「2,600 亿 token 内余弦降到 10%,之后继续以 10% 训练」;总量 3,000 亿 token
DeepSeek-V3:arXiv 2412.19437 §4.2 —— 2,000 步线性升到 2.2e-4 → 恒定到 10T → 4.3T 内余弦降到 2.2e-5 → 末 500B 里前 333B 保持、后 167B 换 7.3e-6;梯度裁剪范数 1.0
⭐ warmup 的真实机制(不是「样本太少估不准」):arXiv 2406.09405(NeurIPS 2024)—— 主要好处是让网络能承受更大的目标学习率。这个形状的系统分析:arXiv 2410.05192
⛔ 本图不含绝对学习率(两者峰值差 3.7 倍,叠在一起就看不出形状了)—— 八档规模的峰值对照表写在正文里
先看图上这两条形状根本不一样: GPT-3 升完就一路下滑;V3 中间多了一段又长又平的平台。 —— 「要不要那段平台」正是两派唯一的分歧,留到第三个决定再讲。 下面三个决定挨个拆,每一个都有公开配置可以抄,不用猜。
大部分教程说:Adam 一开始样本太少、二阶矩估不准,所以得慢慢来。
⛔ 2024 年有一篇专门做系统实验的论文,明确说这不是主因。
原文的判断是:warmup 压倒性的好处,在于 让网络能承受一个更大的目标学习率 —— 它把网络推到 loss 曲面上条件更好的区域去。 而「样本太少估不准」这个说法,他们直接反驳了: 真正的问题是预条件曲率一开始就很高,大 batch 也一样高。
所以 warmup 真正的价值是让你敢把峰值设高 —— 顺带让这个超参更好调(可选区间更宽)。
📌 出处:Why Warmup the Learning Rate? Underlying Mechanisms and Improvements,arXiv 2406.09405(NeurIPS 2024)。
「明确说这不是主因」说得太满。 那篇的 Limitations 自己写着实验规模偏小 —— Transformer 只有 4 层、上下文 64,另一组是 CIFAR-10 上的 WRN。 跟我们整讲谈的尺度差好几个数量级。
那它凭什么就能把峰值抬高? —— 这句得接回 1.4b 那个二阶导, 不然「条件更好的区域」只是一句同义反复。
一步能迈多大,不是你定的,是曲率定的
在一条抛物线上做梯度下降,步长只要超过 「2 ÷ 曲率」就发散 —— 不是走慢一点的问题, 是每一步都被放大,一步比一步远,直接翻出去。
所以「最大能用多大学习率」是当前这块曲面的曲率说了算的, 曲率越大,合法的步子越小。
而那篇论文实测到的是:训练一开始,预条件曲率就很高 —— 高到你想用的那个峰值根本不合法。 而且这跟 batch 大小无关,大 batch 一样高 —— 这条正是他们用来反驳「样本太少估不准」的证据: 要是估计噪声的问题,加大 batch 就该好转。
于是 warmup 做的事很具体:先用一段小到安全的学习率, 让网络自己走到曲率更低的地方去。 等曲率降下来,那个峰值才变成合法的。
关键是方向别搞反:不是网络学会了忍受大步子,是曲面本身变平缓了。 —— 这也解释了为什么拉长 warmup 基本没收益: 该走到的地方走到了就行,多磨几步曲率也不会再低多少。
❓ 「开局是 129,280 选一,那时候梯度一定很大吧?」
—— loss 的值大,不等于梯度大。
开局 loss 是 ln 129,280 = 11.77,确实是个大数;
可 1.2b 那张图上,logits 那一层的梯度是 p − y,
每一项都夹在 −1 到 1 之间,整条向量的长度撑死 √2。
它跟词表是 129,280 还是 1,000,没关系。
❓ 「梯度不是已经被 Adam 归一化过了吗?那还能大在哪?」
—— 这个问得对,而且它正好指着答案。 Adam 的分子是动量、分母是梯度的均方根,量纲互相抵消,那个分式是 O(1) —— 所以每一步迈多远,基本就等于学习率本身,跟这一步梯度多大几乎无关。
所以危险根本不来自「一开始梯度大」。 大的不是你迈的那一步,是你脚下那块地的弯度。
同样迈 η 这么大一步:地形平缓时你往前挪一点、坡度也就变一点,很安稳; 地形弯得急时,同一步会直接冲过底、冲到对面比原来还高的位置 —— 下一步被顶得更远,再下一步更远。这就是 2 ÷ 曲率那条线的现场版。
这正是 1.4b 那条的落点: Adam 除掉的是「陡」,它除不掉「弯」 —— 它手上那个二阶矩是统计量,而弯度是二阶导,是几何量,它从来没算过。 论文那个词「预条件曲率」的字面意思就是:在 Adam 处理完之后再量的曲率 —— 所以「都处理过了为什么还高」的答案是:量的就是处理之后那个数,它依然高。
❓ 「是不是一开始分母还没攒到值?」
—— 这条 Adam 自己防了:它有偏差修正,
一阶矩和二阶矩都要除以 1 − βt,专门补头几步累积不足
(β₁ = 0.9 时第 1 步只凑到 0.1,见 3.6 那张图 Ⓑ)。
所以不是「分母为零」。
而「早期估不准所以要慢慢来」正是上面那篇否掉的那一个 —— 他们的证据就是大 batch 曲率一样高:要真是估计噪声的问题, 加大 batch 就该好转。
最后提醒一条,别把这个故事推太远: 这不是说「越往后曲率越低、学习率就能一路涨」。 实际那条曲线升到峰值就不涨了,后面还要降下来(下面两个决定讲的就是这个)。 warmup 只负责把你送到峰值,不负责一直往上。
而还有第三个说法 —— 它自带一个前提,而那个前提把它挡在现代模型之外。 切入点跟上面两个都不同:Adam 让「梯度消失」换了个意思。
先看 Adam 的更新量长什么样(原文的写法):
Δθ = −η · E[g] ⁄ √E[g²]
分子分母同量纲,所以那个分式是 O(1),更新量就是 O(η)。 —— 这跟 SGD 完全不同:SGD 的更新量正比于梯度,梯度小,步子就小。
所以在 Adam 底下,梯度消失不再意味着「学不动」 —— 只要梯度还大于随机误差,参数照样拿到常数量级的更新。
⛔ 可「不再学不动」不是好消息 —— 它换成了一个更糟的东西。
梯度小到跟噪声一个量级的时候,分子分母就都是噪声, 而那个比值照样是常数量级。
⭐ 于是步子迈得满满的,只是方向是乱的。
拿 SGD 做个对照就清楚了:SGD 在这种时候是停着不动 —— 难看,但安全。而 Adam 是拿着满格的步长往随机方向冲。
可这恰恰是麻烦的开始。 原文的推理链是这样的(前提:模型确实有明显的梯度消失):
warmup 做的事,用原文的话说是 「抑制了后面的层的学习速度,并且给了前面的层更多的优化时间, 以促进每个层的同步优化」。
这一条唯一要带走的,是一个能拿去对日志的现象: Post-LN 不做 warmup,loss 先收敛到一个常数附近,再训一段开始发散,直至 NaN。
但这一段有一个必须一起记住的前提,原文自己写得很清楚:
「这里的讨论前提是梯度消失,如果是 Pre Norm 之类的结构, 没有明显的梯度消失现象,那么不加 Warmup 往往也可以成功训练。」
于是三个说法各就各位了 —— 它们不是在抢同一个位置。
| 说法 | 前提 | 现在怎么看它 |
|---|---|---|
| 二阶矩样本太少、估不准 | 没说前提 | 已被 2024 那篇系统实验驳掉 |
| 让网络能承受更大的峰值学习率 | 一般情况 | 成立 —— 但那篇的实验只到 4 层 |
| 压住后面的层,等前面的层跟上 | 有明显梯度消失 (也就是 Post-LN) |
成立,而且给了可观察的现象 |
所以该问的不是「哪个解释对」,是「在什么前提下」。 你的模型是 Pre-LN 还是 Post-LN,决定了哪一条在起作用 —— 现代 LLM 基本都是 Pre-LN(见 §6.5),所以第二条更相关; 但如果你在训 Post-LN 的东西、又看到「loss 先平后 NaN」,那就是第三条。
📌 出处:苏剑林《模型优化漫谈:BERT 的初始标准差为什么是 0.02?》, kexue.fm/archives/8747 —— 上面引号里的两句为原文原话。 这是作者本人的分析文章,不是同行评议论文; 我们按「一个有前提的解释」收下它,不当定论。
顺带自曝,而且很讽刺: 这一讲在 2.6 立过「跨规模要重验」那条判据, 结果我转述这篇论文时自己就没守,把「他们证伪了」写成了不带尺度的断言。 —— 判据写在纸上容易,用在自己引的那篇论文上才难。
实际用多长?GPT-3 头 3.75 亿 token(总量 3000 亿的 0.125%), V3 头 2000 步。—— 短到可以不当超参看。
GPT-3 论文的表 2.1 把八个规模的峰值学习率和 batch 一起列了出来 —— 这是一张免费的先验,不用自己扫:
📌 GPT-3 全系列(同一套数据、同一套训练流程,只有规模在变):
规律肉眼可见:模型越大,学习率越小、batch 越大。 而且幅度很温和 —— 1,400 倍的规模差,学习率只差 10 倍(125M 的 6.0e-4 → 175B 的 0.6e-4)。
论文自己的话是:「更大的模型通常能用更大的 batch, 但需要更小的学习率」。他们用梯度噪声尺度来定 batch。
注意这张表里 batch 和学习率是一起变的 (这条留到本节落点再收)。 GPT-3 还额外把 batch 从 32K token 线性爬到目标值(头 40–120 亿 token 内)。 📌 出处:arXiv 2005.14165 表 2.1 与附录 B; 「更大的模型要用更小的学习率」那句在 §2.3。
而「batch 越大、学习率就越能调大」这句,还有一层很多人不知道的天花板。
先把常见的那两条摆出来:
η* ≈ ηmax /(1 + Bnoise/B)
—— 注意这个形式是单调递增且有上界的:
batch 再大,学习率也只能逼近 ηmax,不会一直涨。所以「batch 翻倍学习率就该翻倍」是错的。
还有一层更反直觉的:在 Adam 底下,超过某个 batch 之后最优学习率可能不升反降(所谓 Surge 现象)。 —— 成因、前提,以及它本身仍在争议这件事,都在下面的折叠块里。主线要收的只有一句:别想当然地把任何缩放律往外推。
但在 Adam 底下,还可能更反直觉一点: 超过某个 batch 之后,最优学习率不升反降 —— 这就是所谓的 Surge 现象。
⛔ 为什么会这样? 直观的说法是:这本质上是「自适应学习率」本身次优的体现。
把 Adam 粗略看成 sign(g):batch 越大,估出来的
sign(g̃) 就越接近真的 sign(g)。
可 sign(g) 就是最好的更新方向吗?不一定,
尤其到了训练后期。
于是 batch 取中等的时候,那点噪声反而在替你修正这种次优;
batch 再大,噪声没了,修正的机会也没了,
所以只好更谨慎地把学习率降下来。
但这条有前提,而且原作者自己特意收了一格:
「(当然这里还有一个限制,β 是始终小于 1 的, 如果 βnoise ≥ 1,那么最优学习率与 Batch Size 的关系依旧是单调递增的。)」
苏剑林还顺手批评了那篇原论文: 原论文在一个较强的近似下得出「Surge 几乎总会出现」,他认为不大科学; 他自己换了个更合理的近似,结论是 「即使 Hessian 的非对角元不可忽略,Surge 现象也不一定会出现」。
📌 苏剑林《当 Batch Size 增大时,学习率该如何随之变化?》 kexue.fm/archives/10542; 所评论的原论文为《Surge Phenomenon in Optimal Learning Rate and Batch Size Scaling》。 引号里为原文原话。口径同上一处(作者本人的分析,不是同行评议) —— 我们收的是「别想当然地外推」这条警告,不是一个可以照抄的公式。
一个看着完全不合规律的现代参考值:DeepSeek-V3,671B 的 MoE, 峰值 2.2×10⁻⁴ —— 比 GPT-3 的 175B 大得多,学习率却高出近四倍。
⛔ 我先给过一个解释,被上面那张表当场推翻: 「V3 每个 token 只激活 37B,所以该按 37B 看」—— 可 13B 是 1.0×10⁻⁴、175B 是 0.6×10⁻⁴,37B 该在 0.8 上下,而 V3 是 2.2。 换口径没抹平差距,只是从 3.7 倍变成 2.8 倍。
真正的答案是:这两个数本来就不该放在一起比。
判据:一条趋势只在「产生它的那次受控实验」内部可用。
GPT-3 那张表能当先验,靠的是内部八档同一套配方、只有一个旋钮在动
—— 而这同一个理由也说明它出了那张表就不能当先验。
自曝:我原来拿「看激活规模不看总参数」去圆这个差距,
那是最危险的一类断言。听着像常识,还刚好能圆上场。
老派 · cosine(GPT-3 / Llama / Mistral): 2600 亿 token 内余弦降到峰值的 10%,之后一直保持不动。
新派 · warmup-stable-decay(DeepSeek-V3 就是这个形状)
V3 的完整曲线:2000 步线性升到 2.2×10⁻⁴ → 一直恒定,跑到 10T token 才开始降 → 用 4.3T token 余弦降到 2.2×10⁻⁵ → 最后 500B token 里,前 333B 恒定 2.2×10⁻⁵,后 167B 换成 7.3×10⁻⁶。
📌 arXiv 2412.19437 §4.2;梯度裁剪范数 1.0, batch 从 3072 爬到 15360(头 469B token)后保持。 这个形状的系统分析见 arXiv 2410.05192。
两派的差别不在「哪个收敛更好」, 而在它们各自要求你什么时候做决定。
⭐ 所以选哪派,问的不是「谁收敛好」,是 「我现在能不能说得准要训多少 token」。 说得准,余弦省心;说不准,平台那一段就是给你留的活口。
而两派的终点撞在同一个数上 —— 图里那条横贯全场的虚线。
梯度裁剪是安全带,不是调参手段。 V3 设的是 1.0。靠调裁剪阈值来压住一个太大的学习率, 是在掩盖问题不是在解决问题。
⛔ 最后一条,也是最容易被忽略的: 单报一个学习率数字,是没有意义的。
它必须连着 batch、schedule 形状、总 token 数 一起报 —— 换掉其中任何一个,这个数就不再适用。 上面那两套配置之所以能抄,正是因为它们四样都写全了。
上一小节收在「单报一个学习率没有意义,它必须连着 batch 一起报」。 —— 那 batch 自己凭什么定?
很多混乱来自「batch」被当成一个数在说。真跑起来,你手上是四个独立的旋钮:
| 旋钮 | 它是什么 | 拧大了,谁跟着变 |
|---|---|---|
| micro-batch m |
一张卡一次前向真正塞进去几条序列 | 激活直接跟着涨(1.7 那张表整体 ×m) |
| 梯度累积 K |
攒几次再更新一次(1.8 第 ④ 道) | 激活不变 —— 同时在场的永远只有一份 |
| DP 路数 d |
多少份模型副本各吃各的数据 | 激活按卡摊薄,但常驻那 16 字节每份都要一套 |
| 序列长度 S |
本讲基准 4,096 | 激活 ∝ token 总数(5.1) |
global batch(一次更新看了多少 token) = m × K × d × S
⛔ 而这里藏着一条最容易被忽略的连线:TP 开大,global batch 会变小。
卡的总数是定的,凡是切模型的那几维都在跟 DP 抢卡:
d = 总卡数 ÷ (TP × PP × CP)
所以你把 TP 从 8 开到 16,DP 路数当场减半 —— 别的都不动的话,global batch 也跟着减半。
式子里不该有 EP(我改过一次)。
Megatron-Core 有两个 data-parallel 尺寸:
data_parallel_size = world_size ÷ (TP × PP × CP) 和
expert_data_parallel_size = world_size ÷ (ETP × EP × PP)。
EP 只切后者 —— MoE 只是把同一批 token 在专家维上重分一次,
没让这一步看的 token 变少。CP 则确实在分母里(原来漏了)。
📌 megatron/core/parallel_state.py:
model_size = TP × PP × CP × gtp_remat。
而 batch 一变学习率就得跟着变 —— 并行策略那个旋钮的另一头,连着的是收敛。 它看起来只是「怎么把模型切到卡上」。
「代码没改数据没改,换套并行配置 loss 曲线就变了」—— 就是这么来的。
梯度跟 loss 一样,是一批样本各自意见的平均(1.0)。
那张「一屋子人取平均」的图(1.2), 现在可以再用一次。
屋里坐 8 个人,混进一个特别偏激的,平均值会被他拽走一大截。
屋里坐 800 个人,同一个人的影响被稀释到几乎看不见。
梯度的「抖动」大致按 1/√B 缩小 —— batch 翻 4 倍,噪声减半。
📐 这是样本平均的标准结论(独立样本的均值,标准误 ∝ 1/√n)。 前提是样本之间大致独立 —— 同一条序列里相邻的 token 显然不独立, 所以真实的有效样本数比 token 数少。当量级看,别当精确公式。
反过来说,小 batch 的每一步都在被噪声推着走。 loss 曲线会毛、grad norm 会跳 —— 而 6 那节讲的 spike,很多就是在这种时候被一小撮坏样本点着的。
既然大了更稳,为什么不把 batch 开到天上去? —— 下面这两条听起来是两回事,等会你会看到它们是同一条。
第一张脸 · 噪声降下去了,但「每个样本的收益」也降下去了。
梯度糙的时候,加样本实实在在让方向变准,加倍 batch 大致少走一半步数。 可一旦梯度够准,噪声不再是瓶颈 —— 再加样本方向也不会更对, 步数几乎不减,算力实打实翻倍。
转折点叫「临界 batch」—— 过了它, 你花的是算力,买不到等量的进步。
它不是一个固定的数:模型越大、训练越往后,它越大。 所以真实配置里 batch 是一路往上爬的 —— V3 就是从 3,072 条爬到 15,360 条(上一小节那张表)。 爬 batch 不是为了更快,是因为临界点在往上挪。
❓ batch 一路爬上去,是不是得一路加卡? —— 不用。它爬的不是卡,是梯度累积。
回到第一步那个乘法:
global batch = micro-batch × 梯度累积 K × DP 路数 × 序列长度。
要把它翻五倍,把 K 从 1 调到 5 就行 —— 卡一张不加。
⭐ 而且显存也不涨:梯度累积那一栏写着「激活不变 —— 同时在场的永远只有一份」。 攒梯度只是把更新往后推,不会让同时挂着的中间结果变多。
那代价是什么? 同样的卡、同样的吞吐,每秒处理的 token 数一点没变 —— 变的是「攒够多少 token 才更新一次」。更新次数变少了,总时间不变。
⭐ 所以爬 batch 花的既不是卡也不是时间,花的是更新频率。 而这正是它划算的地方:早期临界 batch 小,开大 batch 是浪费; 后期临界 batch 涨上来了,这时候少更新几次几乎不损失样本效率, 却能换到两样实在的东西 —— all-reduce 次数变稀(通信占比下降), 以及噪声更小、更稳。
📌 「batch 会随训练往上爬」三条出处,机制 / 实践 / 框架各一条。
--rampup-batch-size <起始> <每次加多少> <爬升用多少样本>。
帮助文本里的例子是:起始 16、目标 1024,中间分 126 段线性爬上去。
—— 注意它要你同时给 --global-batch-size(目标值),
从头到尾没问你要几张卡。⚠️ 口径:V3 那句是 v2 版正文(§4.2 附近)的直译;Megatron 那个开关
在 core_r0.9.0 的 arguments.py 里,
主干上已经演化成 --step-batch-size-schedule,做法还在,名字换了。
第二张脸 · batch 一大,学习率就得跟着抬 —— 而抬学习率是有上限的。
噪声小了就该迈更大的步,不然白拿了准度。 3.5 那八档看着相反(batch 越大学习率反而越小)—— 那是规模在同时往下压它,两股力量叠着。
但学习率不能无限抬:抬过头, loss 直接飞(6)。所以 batch 增大能换来的加速, 被「学习率能抬到多高」这条硬边界卡住了。
⛔ 现在把这两张脸合上 —— 它们不是两条约束。
回头看 3.5 给的那个式子:
η* ≈ ηmax ⁄ (1 + Bnoise/B)
第一张脸说的「临界 batch」,量化版本就是 Bnoise (3.5 那句「他们用梯度噪声尺度来定 batch」)。 而第二张脸那条上限,分母里写的是同一个 Bnoise。
所以两边的拐点是同一个点,而且能给出一个很好记的锚: 当 B = Bnoise 时,代进去得 η* = ηmax 的一半 —— 你手上那个学习率预算,到临界 batch 时正好用掉一半。 再往后 batch 翻多少倍,剩下那一半也只是慢慢逼近,永远到不了。
这一格原来写的是「两个各自独立的理由」,是错的。 说成「独立」会让人以为可以分头绕开其中一条 —— 比如「那我把学习率的天花板抬高一点不就行了」。抬不动:ηmax 是 发散门槛(3.3b 那条「2 ÷ 曲率」),不是你能调的旋钮。
所以那两句听起来矛盾的话,其实是同一条曲线的两段。
| batch 往大开 | |
|---|---|
| 稳定性 | ✅ 单调受益 —— 噪声 ∝ 1/√B,越大越稳,没有拐点 |
| 样本效率 | 有拐点 —— 过了临界 batch,多花的算力换不回等量的进步 |
两句都对,各说一行。 选 batch 就是在这两行之间,找那个刚好够稳、又还没开始浪费的位置。
上面两句是「大了才稳」和「大了就不行」。 还有第三句流传得最广:「batch 开大就更快」。
📌 「有平行运算时,大小 batch 跑一次的时间差别不大;而一个 epoch 反过来」出自李宏毅2021 年《类神经网络训练不起来怎么办(二):批次与动量》。⛔ 图是我们自己重画的。
⚠️ 图上不含任何实测数字 —— 只画两段的形状。拐点落在哪,取决于模型、卡、并行配置,得自己在目标配置上量。
这句话有前提,而且前提正好卡在你们这一档。
左半段成立:卡还没喂饱,batch 大了步数变少、每步没变贵 —— 那是真的快。
⛔ 右半段不成立:卡喂饱了,每步变贵的倍数,正好抵掉步数变少的倍数。
而几百亿参数、几百张卡的训练,基本都在右边这一段。 —— 所以在你们这儿,开大 batch 买到的是「稳」和「通信摊薄」,不是「快」。
「通信摊薄」那一条的账在 1.8: 那笔跨卡汇总的量跟 batch 完全无关,而计算量随 batch 线性涨 —— 所以 batch 越大,它被摊得越薄。
⛔ ① 梯度累积忘了除以 K —— 等于把学习率乘了 K。
1.8 那条结论成立的前提是你真的取了平均。
K 个 micro-batch 的梯度加起来之后,必须除以 K —— 忘了除,梯度整整大 K 倍,而这跟把学习率乘 K 是一回事。
症状很有迷惑性:代码跑得通、不报错、loss 一开始还在降, 然后突然飞掉 —— 而你会去怀疑数据、怀疑初始化。 它其实是个学习率问题,只是伪装成了别的样子。
② 「按 token 平均」还是「按序列平均」,在变长 batch 上不是同一件事。
一批里有的序列 4,096 个 token、有的只有 500 个(padding 掉的不算)。
两种算法给出不同的梯度, 而它们的代码差别只有一行。预训练几乎都用按 token 平均 —— 但重点不是选哪个,是知道自己选的是哪个。
现场提到一个念作「TPS」的量,说「TP 开得太大的时候,TPS 就会很大」。 但按第一步那个式子,TP 开大会让 DP 变少、global batch 变小 —— 三种读法(tokens per step / TP size / tokens per sequence) 都跟这句话对不上,所以没有替他猜,只写了骨架。 判据:听不清的缩写不要替人补全。补错了,读者学到的是一条不存在的关系。
落点:batch 的上限来自样本效率,不是显存。 —— 显存只决定你能不能塞下,塞不塞得对是另一回事。
Adam 还剩两个数:β₁ 和 β₂。 通常被当成「用默认值就行」,可它们的含义特别清楚。
一句话:β 决定「老的贡献能活多久」。
滑动平均每步乘一个 β 再掺新值,所以有效窗口大约是 1/(1−β) 步。
出处:Adam 原文给的默认值是 β₁ = 0.9、β₂ = 0.999(arXiv 1412.6980,Algorithm 1); 大模型预训练常把 β₂ 调到 0.95 —— GPT-3(arXiv 2005.14165 附录 B)和 Llama 2(arXiv 2307.09288 §2.2)原文都写的是 β₁ = 0.9、β₂ = 0.95。
所以 β₂ 调大 = 分母更平稳但反应更慢;调小 = 跟得紧但噪声大。 —— 这不是玄学,就是一个「记多久」的旋钮。
两笔账记性不一样长,有两个直接后果: 梯度一突变,步子会暂时走样;刚开局那一段,两笔账都凑不满。
Adam 原文(arXiv 1412.6980,已读原文)Algorithm 1:m̂ = m/(1−β₁ᵗ)、v̂ = v/(1−β₂ᵗ);默认 β₁=0.9、β₂=0.999。§3 说滑动平均从 0 起步,估计偏向 0,开头几步尤甚,β 越接近 1 越严重。
β₂=0.95:GPT-3(arXiv 2005.14165 附录 B)「Adam with β₁ = 0.9, β₂ = 0.95, ε = 10⁻⁸」;Llama 2(arXiv 2307.09288 §2.2)「AdamW … β₁ = 0.9, β₂ = 0.95, eps = 10⁻⁵」。均已读原文。
Ⓐ 是本课的数值实验:梯度先恒为 1(或 10)跑 3000 步到稳态,再突变;「回到 1±5%」按之后一直留在这个范围里算。真实训练的梯度不会这么整齐地跳,这一格只说明「分子分母反应速度不同」这一件事,不报任何真实模型的数。
Ⓑ 的数直接算 1−βᵗ:β₁=0.9 时 0.1、0.19、0.651、0.9948(第 1、2、10、50 步);β₂=0.999 时第 50 步 0.049、第 1000 步 0.632、第 3000 步 0.950。
它用的是 β₂ = 1 − k−0.8,k 是当前步数。
代几个数进去看看它在干嘛:
也就是说,窗口是跟着训练一起长的(大约按 k0.8)。
而固定的 β₂ = 0.99,意味着从头到尾都只记 100 步。
❓ 为什么要这么做?论文给的理由很具体,而且很好懂。
因为罕见的 embedding token —— 一个生僻字可能几千步才出现一次。在一个 100 步的窗口里, 它的二阶矩估计基本是垃圾:大部分时候是 0,偶尔来一个大值。
而窗口跟着训练一起长,这个问题就自己消失了。 论文原话:「我们发现这比标准的 β₂ = 0.99 更稳定」。
📌 arXiv 2204.02311 的超参段。同段还有:
β₁ = 0.9、学习率前 1 万步固定 10⁻²、之后按 1/√k 衰减。
⭐ 停一下 —— 这个理由你在这一讲里已经见过一次了。
AdaGrad(2011)被造出来,动机就是 3.3b 那条:罕见的特征学不到东西。
PaLM(2022)隔了十一年,从一个完全不同的入口 —— 调 β₂ 的记忆窗口 —— 撞上了同一个问题: 罕见 token 出现得太稀,在短窗口里它的统计量根本不可信。
一个给它更大的步子,一个给它更长的记忆 —— 同一件事的两个入口。
⛔ 顺带说清它俩不是同一个东西: AdaGrad 动的是分母的量级(让罕见参数步子大), PaLM 动的是分母的采样窗口(让罕见参数的分母别被噪声主导)。 —— 治的是同一个病,下的不是同一味药。
这里顺带推出一个结论,而它跟 3.2 那条判据打架。
3.2 说:动量和二阶矩是滑动平均,老的贡献会被衰减掉,所以 bf16 扛得住。
可如果 β₂ 一路涨到 0.9999,那个「衰减」就慢得快要不衰减了
—— v 越来越像一个真的累加器。
所以那条判据要带上前提:它成立的条件是「β 不随步数趋近 1」。 这一条是我们自己推的,不是论文说的 —— PaLM 用的是 Adafactor 系、也没报精度配置, 能不能真观察到这个影响,没有证据。当猜想看。
PaLM 用的其实是 Adafactor,但关掉了分解 —— 论文说这等价于「带参数缩放的 Adam」: 按参数矩阵的均方根去缩放学习率。
而论文自己点破了这跟 3.5 那张表的关系: 「这么做的效果,类似于 GPT-3 那样手工把学习率随规模调小」。
换句话说:3.5 那八档配置是手动解法,参数缩放是自动解法。 而且论文说自动那版还多一个好处 —— 尺度本来就不同的那些参数(embedding、layer norm 的缩放) 不会被按同一个比例一起压下去。
这一节能用 3.1 那张账单直接推出来, 不用查任何文档。
那 16 字节里,哪些必须进 checkpoint?一格一格问「丢了能不能重建」:
所以 checkpoint 的大小 = 那 12 字节 × 参数量。 对 671B:约 7.3 TiB 一份。
但别把这个数安到 V3 头上 —— 3.2 刚说过它的一二阶矩是 bf16,那就是 4+2+2 = 8 字节, 一份 4.9 TiB,比经典口径小三分之一。 省状态的那些做法,省的同时也在省 checkpoint。
这一下解释了两件工程上的事:
⛔ 但只存这 12 字节还不够 —— 还有三样,漏一样都会让「恢复」变成「重来」。
而 §6.2 那个「回滚 + 跳数据」的救火办法,前提正是 ①②。 —— 数据位置说不清,你连「跳掉哪几批」都没法讲。
顺带一个真实的省法:优化器那部分不一定要留在加速器上。 DeepSeek-V3 就把权重的指数滑动平均放在 CPU 内存里、每步异步更新 —— 既不占显存也不占训练时间,用途是提前估计「学习率衰减之后会有多好」。 📌 arXiv 2412.19437 §3.2.3。
前面整讲算的都是从零开始训。 —— 可绝大多数人这辈子跑的训练,是拿别人训好的模型接着调。
好消息是:这件事不需要任何新概念, 它就是上面那张 16 字节的账,换一个算法重算一遍。
起点是一个很具体的痛:你没法给每个客户存一个 175B 的副本。
论文摘要开门见山举的就是这个例子:拿 GPT-3 175B 做全量微调, 每一个下游任务都要部署一份独立的 1750 亿参数实例 —— 贵到不现实。
⭐ 注意这个痛点不在训练侧,在部署侧。 —— LoRA 首先是为了「一个底座配几百个小挂件」而生的, 省训练显存是它顺带的好处。
然后是那个让人敢动手的观察。
在它之前已经有人发现:大模型虽然参数极多,但它真正「有效活动」的 维度低得多 —— 换个说法,那么多参数其实挤在一个很薄的子空间里。
⭐ LoRA 作者把这个观察往前推了一步,而这一步是全篇的胆量所在: 既然模型本身是低维的,那「微调带来的改变量」会不会也是低维的?
—— 这是个假设,不是定理。但它一旦成立,做法就自己写出来了: 既然改变量是低秩的,那就别用一个满秩的大矩阵去装它, 用两个瘦矩阵相乘就够了。
⭐ 值得停一下的是这个推理的形状: 他们没有去证明「改变量一定低秩」,而是先按这个假设造出来、再回头量它 —— 论文里那一节「对语言模型适配中的 rank-deficiency 做实证考察」, 干的就是回头量这件事。先押注,再验证。
📌 Hu 等,LoRA: Low-Rank Adaptation of Large Language Models, arXiv 2106.09685。摘要里给的两个数:可训参数少 一万倍, GPU 显存少 三倍;并且「不像 adapter,推理时不增加任何额外延迟」 —— 最后这一条正是它压过前几代微调方法的地方。
📌 想通了上面那两步,做法就只剩一句话: 底座冻住不动,只在旁边挂一对很瘦的小矩阵。
原来那个 4096 × 4096 的大矩阵不训了;
旁边加一个 4096 × 16 和一个 16 × 4096,只训这两个。
关键在那个 16:两个瘦矩阵加起来
2 × 4096 × 16,只有原矩阵的 0.8%。
| 账 | 全量微调 | LoRA | 省了吗 |
|---|---|---|---|
| 常驻 权重 + 梯度 + 优化器状态 |
16 B × 全部参数 | 2 B × 全部(冻住,只读) + 16 B × 那 0.1% |
省得最狠 |
| 算力 | 3×(前向 1 + 反向 2) | 约 2× | 省了约三分之一 |
| 激活 | 整条链都要在场 | 整条链还是都要在场 | 基本不省 |
第一行拿 70 亿参数代进去,数字很夸张。
(Llama-2-7B 一档:32 层、隐藏维 4,096;
32 × 2 处(Q、V)× 2 块(A、B)× 4,096 × 16 = 8,388,608。)
相差 7.9 倍 —— 而 adapter 一共只有 839 万个参数,占全模型 0.124%。
为什么差这么多:那 16 字节里有 14 字节 (梯度 + 主权重 + m + v)是只有「要被更新的参数」才需要的。 冻住的参数只留 2 字节权重 —— 它退回成了推理的样子。
第二行那个「3× 变 2×」值得单独说,因为它直接来自 1.3。
1.3 说过反向要付两笔乘法,这里沿用它的编号(① 是前向): ② 算权重的梯度(给优化器用),③ 算输入的梯度(往下一层传)。
而冻住的那些层,第 ② 笔可以整个不算 —— 它的权重根本不更新,算出梯度也没人用。
于是:前向 1 + 只剩 ③ 那一笔 1 = 约 2×,而不是 3×。
反过来的情形别搞混:只微调最后一层时,省掉的是 ③(不用再往前传);而 LoRA 每层都挂 adapter,③ 一笔都省不掉,省的是 ②。
而第三行才是最容易被误解、也最值钱的一行。
很多人以为「只训 0.1% 的参数 = 训练变得很轻」。显存上不是。
因为 adapter 挂在每一层上。 —— 最前面那层的 adapter 也要梯度, 而梯度只能从 loss 一路传回去(1.5)。 所以整条链的激活,该在场的还得在场。
结论很具体:LoRA 之后,激活那一块往往成了新的大头 —— 所以 LoRA 还是要开重算(第二节)。 两件事不是替代关系,是叠加关系。
严格说激活会少一点,但少多少取决于你把 adapter 挂在哪 —— 这一条很少有人点破:
A 吃的是同一个输入,
而算 A 的梯度照样要它。推论很反直觉:adapter 挂得越全,激活省得越少。 上面那套「只挂 Q、V」激活还能省一点,正是因为 MLP 那三个大矩阵一个都没挂。 「多挂几处效果更好」的代价不在参数量,在激活。
非线性那些算子的输入照样要留, 所以总量只是少一点,不是少一个数量级。 这一段是按 1.3 那两笔账推的,我们没有实测。
⭐⭐⭐ 收口:LoRA 改的是「有多少参数带着那 16 字节」, 没有改变「反向要穿过整个网络」。 —— 参数那一块能按比例砍,链条本身砍不动: 它来自反向传播的数学,不来自你训多少参数。
这一节是通向专题五的桥。 把上面几项按大小排一遍,你会发现 —— ZeRO 那三级,正是照着这个顺序来的。
这一节是专题五的预习,不是本讲那三件事的一部分。 —— 三句话说完,细的都收在下面那个折叠块里。
训练要用的东西,按大小排下来是这个顺序:
优化器状态(12 字节/参数) > 权重 = 梯度(各 2 字节) > 激活(看 batch)
带走一句就够:并行策略不是凭空设计出来的, 是被这张账的大小顺序逼出来的。
把前面三节的东西摆在一起,按占多少排个序 —— 这个顺序本身就是这一节的全部内容。
| 这一项 | 每参数 | 671B 上 | 占常驻 | 它是什么 | 什么时候用得上 |
|---|---|---|---|---|---|
| 优化器状态 | 12 B | 7.32 TiB | 75% | fp32 主权重 4 + 一阶矩 m 4 + 二阶矩 v 4 | 只在更新那一瞬间用一次 |
| 权重 | 2 B | 1.22 TiB | 12.5% | bf16 那一份,前向反向都拿它算 | 每一层都要读 |
| 梯度 | 2 B | 1.22 TiB | 12.5% | bf16,跟权重同形 | 反向写、更新后就能扔 |
| 常驻小计 | 16 B | 9.76 TiB | 100% | ⭐ 跟 batch、跟序列长度都无关 —— 只要模型定了,这个数就定了。 | |
| 中间激活 | —— | 看 batch | —— | 反向要用的那一堆中间结果(1.6) | ⛔ 唯一一个你自己能调的 —— 也是唯一一个能反超上面三项的 |
前三行都是「每参数几字节 × 参数量」,所以它们的比例永远是 12 : 2 : 2 —— 换多大的模型都不变,换多少张卡也不变。
优化器状态一项就占常驻的 75%。 而它是三项里唯一一个前向反向都用不上的 —— 3.1 说过,它只在更新那一瞬间被读一次、写一次。
⛔ 但第四行不一样 —— 它是唯一一个你自己能调的。
前三项跟着参数量走,你没得选;激活跟着 「这一步同时在场多少 token」走 —— 而那是 micro-batch、梯度累积、 DP 路数、序列长度四个旋钮乘出来的。
所以「谁最大」不是模型的属性,是你这次训练配置的属性。 —— batch 开到某个程度,第四行就会翻到第一行上面去。 那个分水岭具体在哪,5.1 会算给你看。
记住这个顺序 —— 下一小节讲的 ZeRO, 三级分法就是照着它一级一级往下切的。
ZeRO 的分级不用背。 把上面那个顺序倒过来读一遍,你就把它推出来了。
📌 arXiv 1910.02054 §3(16 字节口径与 Figure 1 的四个数)、§7.2(通信量 2Ψ / 2Ψ / 3Ψ)。
⭐ 图上四个 GB 数由 75 亿参数 × 每参数字节数算出,脚本内 assert 与论文 Figure 1 对账(120 / 31.4 / 16.6 / 1.9 GB)。
切的顺序只有一条原则:谁最大、谁最少被用到,就先切谁。
所以顺序不是随意的,也不是历史巧合 —— 它是「大小」和「被用到的频率」这两个量排出来的。
📌 出处:Rajbhandari 等,ZeRO: Memory Optimizations Toward Training Trillion Parameter Models,arXiv 1910.02054。 上一节那个「每参数 16 字节」也出自它 —— 同一篇论文既给了账单,也给了切法。
把 ZeRO 之外那几个常听见的名词摆回这张账单上,它们各自的位置立刻就清楚了:
⭐⭐⭐ 所以这几个名词不是「几种优化技巧」, 是同一张账单上的四个不同栏目各自的对策。 —— 而专题五整讲要做的,就是把「切」这件事本身摊开算。
前面讲的都对,但全是 6,710 亿参数、TiB 级的数。 —— 它们没有分母。这一节把同一件事缩到一个你能自己算一遍的模型上。
把前向(专题一讲过)+ 反向 + 更新合成一张表。 而其中最有用的一问不是「总共多少」,是 「峰值出现在哪一个时刻」。
⭐ Ⓑ 三行都是当场算的:671e9 × 16 B ÷ 1024⁴ = 9.76 TiB;9.76 TiB × 1024 ÷ 162.14 GiB = 61.7 条 —— 脚本里有 assert,改数会自己报错
⚠️ 16 B/参数是 ZeRO 论文的经典口径(arXiv 1910.02054);DeepSeek-V3 实际把一二阶矩放成了 bf16,它的每参数账跟这个数不一样(见 3.2)
⚠️ 激活那 162.14 GiB 是自己按算子推的估算,没有第三方背书 —— 所以那个「62 条」也是量级,不是阈值
⛔ 全图算的是全局总量,没有任何并行切分 —— 怎么把它摊到多少张卡上,是专题五整讲的事
tools/manim/。)前面四节各算各的,现在把它们摆到一起。 这一节全部按全局总量算 —— 不分卡,怎么切是下一讲的事。
📌 常驻那一块的算式,短到可以口算:
671e9 参数 × 16 字节 ÷ 1024⁴ = 9.76 TiB。 拆开是:权重 1.22 + 梯度 1.22 + 优化器状态 7.32。
换算一下就知道这是个什么量级 —— 按每张卡 80 GiB 算,光这一块就要 125 张,还没算激活、没算任何冗余。 下面那个激活峰值按「全量重算」算。而 2.4 说过 V3 自己配的是选择性重算(RMSNorm + MLA 上投影)。 两个口径不是一回事:这里取全量是为了给一个干净的下界,真机上激活会比它高。 (80 GiB 是这里随手设的换算基准,不是在说某款具体的卡。 专题一按 v7 的 94.74 GiB/device 算同一笔账,得到的是约 105 张。TiB 那个数两边一致,差的只是除数。)
注意这三项里,只有优化器状态那 7.32 TiB 是纯开销 —— 它既不参与前向,也不参与反向, 只在每一步的最后那一瞬间被用一次。
顺着这个数往下问一句,会撞上一件反直觉的事。
常驻那 9.76 TiB 是定值 —— 跟你喂多长、喂多少条都无关。 那激活要涨到多大才追得上它?
答案是 约 808 万 token —— 按本讲的 4K 基准,就是 约 1973 条序列。 (一条 4K 序列开了全量重算之后峰值 5.07 GiB;换成扩训那一档, 一条 128K 是 162.14 GiB,约 62 条,token 总数一模一样。)
停一下 —— 这里有个数特别容易代错,我自己代错过一版。
3.5 说过,V3 的 global batch 从 3,072 条 4K 起步 (= 1,258 万 token),后期爬到 15,360 条。 看上去远远越过了 808 万 那道分水岭。
可 global batch 代不进来 —— 分水岭比的是同时在场。
global batch = DP 路数 × micro-batch × 梯度累积 K × 序列长度,
而那 K 份从来不同时存在(1.8 第 ④ 道已经立过这一条)。
显存里同时在场的只有前两项 —— 上面那张图的 Ⓑ 用的正是这个口径。
给个稳的上界:V3 用 2,048 张卡、PP16 × EP64,
就算把 DP 放到最宽松的 2048 ÷ 16 = 128 路、micro-batch 取 1,
同时在场也只有 128 条 = 52 万 token ——
不到那道分水岭的十四分之一。
所以「激活从第一步就反超优化器状态」这个结论不成立 —— 已撤回。 在 V3 自己的配置上,3.1 那句 「最大的一块是优化器状态」仍然成立。
这一处原来写的是「V3 从第一步起就越过分水岭 1.7 倍,训到后期 8.5 倍」(那是按旧的分水岭 737 万 token 算的,按现在的 808 万 token 是 1.56 倍和 7.8 倍), 还顺势说本讲第一个答案被自己的例子推翻了 —— 那是把 global batch 当成了同时在场。 而同一页的图一直是对的:Ⓑ 上印着「同时在场 = DP 路数 × micro-batch」。 判据:同一个量在图里和正文里各写一遍时,先确认两边用的是同一个定义。这一次图对文错,而图注和正文都能自圆其说,谁都不会报错。
还有个容易被跳过的前提:那 808 万 token 怎么凑出来的,显存不在乎。
⛔ 但算力不是这样。
同样 808 万 token,拆成长序列和拆成短序列, 要算的浮点数差很多 —— 因为 attention 那部分随 S² 涨, 而它不在显存账上、却在算力账上。
所以序列长度这个旋钮,在两本账上的行为不一样: 显存那本只看总量,算力那本还要看你怎么切。 —— 下一节那个「6ND 严重低估」,讲的就是这件事。
前提说清楚:以上都建立在用了 FlashAttention 这一条上。换成把分数矩阵写进显存的朴素实现, S² 就回到显存账里,上面整段都不成立。
6ND,在长上下文下严重低估估训练算力最常用的一条是 6ND:
每个参数、每个 token,大约 6 次浮点运算(前向 2、反向 4
—— 正好对上第一节那个 1+2)。
代进去(MoE 要用激活参数,不是总参数):
6 × 37e9 × 131,072 ≈ 29.1 PFLOP,一条 128K 序列。
⛔ 但这个数在 128K 上是错的 —— 而且错得很多。
6ND 数的是「跟权重相乘」那部分。
而 attention 里 QKᵀ 和 AV 这两步没有权重参与
—— 它们根本不在这个公式的账里。
而附录 7.2 那一行说:在 128K 上,
attention 占一层前向算力的 82.1%。
也就是说 6ND 数到的只是剩下那 17.9%。
反推一下:真实算力大约是 6ND 的
五到六倍 —— 29.1 PFLOP 实际接近 160 PFLOP。
这个倍数是由 82.1% 反推的(1 ÷ 0.179), 而 82.1% 本身是自己按算子推的 —— 当量级看。 要记的不是这个倍数,是那个公式什么时候会骗你:序列一长就会。
反过来说,6ND 在短序列上是很好用的
—— GPT-3 那个 2,048,attention 只占百分之一点几,
漏掉它完全无所谓。又是同一件事:不是公式错了,是前提变了。
第一节那张山形图给过一个答案:峰值在前向末尾。 那句话只在谈激活的时候成立。
把四项一起画到时间轴上(就是上面那张图), 会看到一件当时看不出来的事:不同的项,峰在不同的时刻。
推广出去,这是一条到处能用的判据:
把几条形状不同的曲线叠起来之后, 总和的峰,未必落在任何一条单独的峰上。 —— 所以「什么时候最挤」这个问题, 必须连着「挤的是哪一项」一起问。
📌 工程上的直接后果: 你去查 OOM,光知道「峰值 xx GiB」没用 —— 要知道是哪一项在那一刻最大,才知道该去动哪个开关。 激活大就开重算 / 上 CP;优化器状态大就上 ZeRO。这两条路走反了,一点用都没有。
先把这一讲那三件事,在这台机器上各落一句:
−ln p,取平均。
刚初始化时它是 ln(词表),跟 1.0 那把尺一模一样
—— 只是词表小一点,所以起点低一点。下面这张账把③变成一个你能验的数。
📌 设定:一个 1.25 亿参数的模型,一张卡,batch 8 × 序列 1,024。
12 层、宽度 768、MLP 宽 3,072 —— 这就是 GPT-3 论文表 2.1 的第一行(3.5 那张八档表最上面那档)。
照搬 3.1 那个 16 字节:
| 项 | 每参数 | 1.25 亿参数 |
|---|---|---|
| bf16 权重 | 2 B | 0.23 GiB |
| bf16 梯度 | 2 B | 0.23 GiB |
| 优化器状态(fp32 主权重 + m + v) | 12 B | 1.40 GiB |
| 小计 | 16 B | 1.86 GiB |
第一个可以自己验的结论: 这个模型的权重只有 0.23 GiB,而它要占掉 1.86 GiB —— 八倍。多出来的全是训练才要的。
一层里每个 token 留下的东西,一项一项数(宽度 768):
| 留下的张量 | 宽度 |
|---|---|
| 两个 norm 的输出 | 2 × 768 = 1,536 |
| Q / K / V | 3 × 768 = 2,304 |
| attention 输出 | 768 |
| MLP 第一层输出 | 3,072 |
| 激活函数的输出 | 3,072 |
| MLP 第二层输出 | 768 |
| 一层合计 | 11,520 个数 = 22.5 KiB(bf16) |
× 12 层 = 每个 token 270 KiB。 × 8,192 个 token = 2.11 GiB。
⛔ 停一下 —— 这里出了一件值得吃惊的事。
激活 2.11 GiB > 常驻 1.86 GiB。 一个只有 1.25 亿参数的小模型, 激活已经比权重、梯度、优化器状态加起来还大了。
而它不需要长上下文,序列才 1,024,光是 batch 开到 8 就够了。 —— 所以重算不是大模型的专利。
照 2.2 那一档:每层只留入口那一份(768 宽), 外加当前正在重算的那一层的完整一份。
0.32 GiB —— 2.11 掉到 0.32,省了 6.7 倍, 代价是总算力从 3× 变 4×。
这个 0.32 GiB 有一个故意的省略,照着验的人会撞上它。
它只算了 12 层里的激活 —— 没算最后那个 logits。 GPT-3 那一代沿用 GPT-2 的 BPE 词表,约 5.03 万:
8,192 token × 50,257 × 2 B = 0.77 GiB
—— 是那 0.32 GiB 的 2.4 倍。
一次性把整个 logits 算出来,这台机器上最大的一块 既不是权重也不是激活 —— 是那张「词表上的分数表」。 真实实现分块算 loss,所以它不进总账(1.7)。但那是口径选择,不是它不存在。
📌 5.03 万的来路是两跳:GPT-3 论文 §2.1 原话「我们使用与 GPT-2 相同的 模型与架构,包括其中描述的修改后的初始化、pre-normalization 和可逆分词」—— 沿用 GPT-2 那份 BPE,而那份是 50,257。 GPT-3 论文自己没印这个数。 换成 3 万或 6 万,结论不变。
| 不开重算 | 开了重算 | |
|---|---|---|
| 常驻 | 1.86 GiB | 1.86 GiB |
| 激活 | 2.11 GiB | 0.32 GiB |
| 合计 | 3.97 GiB | 2.18 GiB |
| 算力 | 3× | 4×(+33%) |
这张小表值得停一下 —— 它就是你笔记本上那个训练循环。
「多付 33%」跟 671B 那边一模一样 —— 但「省 6.7 倍」跟那边的 20.5 倍差了三倍。
这一处早先写的是「比例跟 671B 那笔几乎一样」。不一样,而且差得不小。 —— 不过它为什么不一样,本身比那句话值钱。
为什么同样是「全量重算」,一个省 6.7 倍、一个省 20.5 倍?
把账写成一个式子就看明白了。设 r = 一层激活 ÷ 入口那一份、L = 层数:
省多少倍 = r ÷ (1 + r/L)
分子 r 是「一层里挂了多少东西」—— 层越胖,扔掉能省越多。
分母那一项是当前正在重算的那一层摊到每层头上。层越多,它越不碍事。
| r = 一层激活 ÷ 入口 | L = 层数 | 省多少倍 | |
|---|---|---|---|
| 125M 小模型 | 15(11,520 ÷ 768) | 12 | 6.7 |
| 这两行的 r 口径略有不同:小模型那一行只数了两个 norm 的输出,V3 那一行(1.7 的表)把 norm 的输入(=残差入口)也数了进去。把入口补上,小模型的 r 是 16、省的倍数 6.9 —— 量级和结论都不变,但严格说这两个数不是同一把尺子量的。 这里原来手写的是「r 约 16、省的倍数约 7.1」。16 是对的,7.1 不是 —— 拿本节自己那个式子代进去得 6.9。而它错得很有代表性:这一格里别的数全是脚本算的,就它是手打的。 | |||
| V3 671B | 31.7(一层 MoE 块 ÷ 7,168) | 61 | 20.5 |
小模型两项都吃亏:r 小 2.1 倍,L 小 5 倍。 —— 所以它省得少是必然的,不是哪儿算错了。
而 r 大,根子在 MoE:1.7 那张表里 「专家输出」和 SwiGLU 中间结果各存九份 —— 一层里挂的东西多了,重算能省的自然也多。 MoE 在参数账上省,在激活账上贵,而在重算账上又因此格外划算。同一个设计,在三张账上是三个方向。
这个式子给 V3 算出来是 20.8,实测 20.5 —— 略小一点,差在那 3 层 dense 比 MoE 薄。当量级看,别当精确值。
那什么才是真的跟规模无关的?只有这三条。
而「省多少倍」不在这个名单里。 —— 它跟着 r 和 L 走,换个架构就得重算一遍。 这正好是第③条判据的又一个实例:会变的和不会变的,得分清楚。
三条边界,跟 1.7 那张表同一套: ① 数是按算子逐项推的,框架融合会让它小一些,当量级看; ② 没算注意力分数矩阵(假设 FlashAttention),也没算临时缓冲、碎片、通信缓冲; ③ 「0.32 GiB」假设每层都设存档点,而那不一定是最省的密度(2.2 Ⓒ)。
专题一算完前向,结论是「装不下」。 这一讲把账补全之后,那句话变得具体了 —— 不是「装不下」,是「四项各自装不下,而且各有各的治法」。
四项 + 四种对策,一一对上:
⭐⭐⭐ 你会注意到四条里有三条写着同一个字:切。 —— 那就是专题五整讲要做的事:切这件事本身,也是要算账的。
前面整整一讲都在算账。可账算得再清楚,也回答不了训练现场最常见的那一句: 「loss 突然飞上去了,怎么办?」
PaLM 540B 的 spike 与消融:arXiv 2204.02311 §5.1 —— 「大约 20 次」「回滚约 100 步」「跳 200–500 批」「不认为是数据本身坏」都是原文
router z-loss 与 Ⓒ 那张表:arXiv 2202.08906(ST-MoE)。⭐ 论文自己的小标题就是「很多方法能稳住稀疏模型,但代价是质量变差」
QK-norm:arXiv 2302.05442(ViT-22B)§2 —— 在约 80 亿参数处观察到训练发散,根因是注意力 logits 变得极大、注意力权重塌成几乎 one-hot(熵接近 0)
归一化的位置:arXiv 2002.04745(ICML 2020)—— 证明 Post-LN 在初始化时靠近输出层的梯度很大,所以必须靠 warmup 压住;换成 Pre-LN 则初始化时梯度就是良态的
⛔ 本图不含任何我们自己的实测 —— 四条全部来自公开论文,Ⓒ 那三个数是照抄 Table 4
这一讲从头到尾讲过五种不同的坏,可它们散在五个章节里, 各叫各的名字。先把它们并排摆一次 —— 训练现场真正难的不是治,是先认出这是哪一种。
| 叫什么 | 现场长什么样 | 根因 | 怎么确认是它 | 治法在哪一节 |
|---|---|---|---|---|
| 梯度爆炸 | loss 变 NaN/Inf,或梯度范数一步之内跳几个数量级 | 反向那条连乘里,一段的局部导数持续大于 1, 61 层复合下来指数放大(1.4) | 每步打印 global grad norm,看它是不是在某一步跳了几个数量级 | 裁剪(6.4)· 换 Pre-LN(6.5) |
| 梯度消失 | 靠近输入那几层几乎不动,训了很久还是初始化的样子 | 同一条连乘,只是局部导数持续小于 1 | 按层打印梯度范数,看是不是随深度单调塌下去 | Pre-LN 与初始化(6.5) |
| 更新被舍入吞掉 (「训不动」) |
loss 不降,可梯度明明不是 0;换上 fp32 主权重立刻就好 | 单步的相对挪动幅度,小于尾数能分辨的门槛
(bf16 约 1/256) |
算 update RMS ÷ 参数 RMS,跟 1/256 比 |
fp32 主权重(3.2) |
| 步长过大发散 | loss 一路上翘;或来回弹,每弹一次幅度更大 | η 超过 2 ÷ 陡方向的曲率,
沿那个方向冲过头并被放大 |
把 η 砍一半重跑 —— 立刻正常就是它 |
学习率上限与 warmup(3.3b · 3.5) |
| loss spike (不稳定) |
平稳训练里突然一根尖峰,之后可能自愈、也可能一路崩 | 不是数据坏 —— 这一条有消融(6.2) | 回滚重跑同一批数据,看它还飞不飞 | 本章 6.1–6.6 |
前两行值得单独看一眼:爆炸和消失不是两个问题,是同一条连乘 的两个方向。
1.4 说过,一个参数的梯度是 61 个局部导数乘起来。 这串乘积里每一项平均大于 1,结果就指数涨;平均小于 1,就指数塌。 所以它们的治法也是同一类 —— 让每一层的局部导数不偏离 1 太远, 这正是 6.5 那些结构手段在干的事。
中间那两行(舍入吞掉、步长发散)常被一起叫成「训不动」, 可它们的判据正好相反:前者要把步子放大或提精度,后者要把步子调小。 认错了会越治越糟。
📏 动手之前,先把 1.0 那把尺拿出来。
「飞了」是个感觉词,而这一节要讲的是判断。换成数就清楚了:
ln 129,280
—— 它把学过的东西全忘光了,退回到瞎猜。所以「飞多高」不是修辞,它直接告诉你还救不救得回来。 —— 跳到 6 通常回滚几十步就能过去;跳回 ln V 基本就是这一段白跑了。
⛔ PaLM 训 540B 的时候,loss 飞了大约 20 次。
而且 —— 梯度裁剪是开着的。 这些 spike 出现在极不规则的时刻,有时候训到很晚才来; 而更小的模型上根本没观察到。
📌 arXiv 2204.02311 §5.1。 「大约 20 次」「尽管梯度裁剪是开着的」都是论文原话。
📌 arXiv 2204.02311(PaLM)§5.1 —— 「大约 20 次」「尽管梯度裁剪是开着的」「更小的模型上没有观察到」均出自该节原文。
⚠️ 曲线为示意:尖峰的位置按「看不出规律」这一条挑出来,高度与宽度论文未给数,故纵轴不设刻度。没有刻度的曲线是示意,有刻度的曲线才是数据。
先记住这个规模效应:小模型上训得好好的,不代表大模型上不会飞。 —— 这跟 2.6 那条「不能跨规模照抄」是同一件事, 只不过这次翻车的不是收益,是训练本身。
第一反应都一样:肯定是那批数据有问题。 PaLM 团队去验了这件事,做法很干净:
把 spike 前后那几批数据单独拎出来,从另一个更早的 checkpoint 重新喂一遍 —— 结果不飞。
所以 spike 不是「坏数据」造成的, 是这批数据 和 当时那个参数状态 撞在一起才出的事。
换个时刻喂同样的数据,什么都不会发生。
这一下就解释了他们那个看起来很土的办法为什么管用: 回滚到 spike 之前约 100 步的 checkpoint,跳掉那 200–500 批数据,继续跑 —— 之后同一个点就不再飞了。
这不是「修好了」,是「绕过去了」。 论文原话:训练成本太高,他们没能找到一个有原则的缓解办法 —— 这一行至今是开放问题。
「让它别飞」有一堆办法 —— 学习率调到极小、裁剪收到极紧, 都能稳,代价是模型变差。
ST-MoE 那篇论文把这件事量出来了 —— 同一个配置换不同随机种子反复跑,看几次能跑完、以及跑完的质量:
| 做法 | 稳定性 | 质量(越大越好) | 结论 |
|---|---|---|---|
| 基线 | 4 / 6 | −1.755 | 六次里两次训崩 |
| 这一列是对数似然,不是 loss —— 所以它是负的,而且越大越好(−1.755 好过 −4.206)。 换成 1.0 那把尺就是:loss = 1.755 与 4.206, 困惑度 5.8 对 67。别把这两栏当成同一个量读。 | |||
| 收紧 update clipping(0.1) | 3 / 3 | −4.206 | 稳了,可质量被打穿了 |
| router z-loss | 3 / 3 | −1.741 | 稳了,质量还略好一点 |
中间那一行是这张表的全部价值: 「稳定 3/3」看着完美,可它是拿质量换来的。 —— 评价一个稳定性手段,必须同时看这两栏。
两个口径要说清楚,不然这张表会被读得太重。
这不是黑点,是好的实验设计 —— 研究一个罕见故障,你必须先把它变得不罕见。 但读数的时候要记住:这个概率是被调高过的。
📌 arXiv 2202.08906(ST-MoE)Table 4。 论文自己的小标题就是「很多方法能稳住稀疏模型,但代价是质量变差」。
做法出人意料地简单:在总 loss 上加一项,惩罚 softmax 归一化因子的对数的平方。
—— 它逼着那个 log Z 待在 0 附近,也就是不让 logits 长得太大。
两个地方都能加,而且都有人用:
10⁻⁴ · log²Z,
论文说它提高了训练稳定性。为什么 z-loss 特别划算:ST-MoE 的解释是 —— logits 后面接的是指数函数,而指数对输入误差极度敏感。 把输入范围压小,等于直接降低了这一步的数值风险, 而模型并不真的需要那么大的动态范围。
按全局范数裁:把所有参数的梯度当成一个大向量, 范数超过阈值就整体等比例缩回去。常见设 1.0(PaLM、DeepSeek-V3 都是 1.0)。
但 6.1 那句话要记住:PaLM 开着裁剪,照样飞了 20 次。 —— 裁剪拦得住单步的爆炸,拦不住「参数状态已经走到了一个坏地方」。
先把一层拆成三个零件,不然下面那个差别看不出来。 一层不是一条直线,是两条路并在一起:主干是 x 原样往前走、 什么都不做;分支是 x 进注意力或 MLP、算出一个修正量 F(x)。 层尾两条合流成 x + F(x) —— 这就是 1.4 那条残差。
归一化是第三个零件,它总得插在这两条路的某个位置上。 而 Post-LN 与 Pre-LN 的全部差别就是它插在哪儿 —— 别的一个字都没改。
两种放法,只差一个位置
Post-LN xt+1 = Norm( xt + F(xt) )
—— 先合流,再拿 Norm 去洗整条主干。主干每过一层都被动一次手。
Pre-LN xt+1 = xt + F( Norm(xt) )
—— Norm 被塞进分支里面了。主干那条路从头到尾没人碰,一路直通到顶。
到这儿还看不出谁好谁坏 —— 但这绝不是风格问题。下面才是。
2020 年有一篇论文用理论证明了这件事, 而它的结论直接接上了3.5:
Post-LN 在初始化的那一刻,靠近输出层的梯度就很大 ——
这时候用大学习率必然不稳。而 warmup 正是在实践中压住这个问题的办法。
反过来,Pre-LN 在初始化时梯度就是良态的。所以论文说:Pre-LN 可以把 warmup 那一段去掉。
这就把 3.5 那张表的第三行接上了。
那一行的「前提」栏写着「有明显梯度消失(也就是 Post-LN)」
—— 那个前提就是这里这条指数衰减。
所以别把它读成「warmup 有好几种互相竞争的解释」:
2020 年这篇说的是「当年为什么非要不可」,3.5 那篇说的是「今天为什么还留着」。问的根本不是同一个问题。
📌 arXiv 2002.04745(ICML 2020),用平均场理论证的。
不过上面那段只说了「Post-LN 的梯度不好」,没说为什么。 而机制其实一句话就能讲完,讲完之后还能顺手回答一个更扎人的问题: 既然它不好,那为什么不干脆去掉?
⛔ Post-LN 是
xt+1 = Norm(xt + Ft(xt))。
初始化那一刻,x 和 F(x) 可以看成两个独立随机向量, 各自方差是 1,加起来方差就是 2 —— 而 Norm 要把方差拉回 1, 所以它在这一刻相当于「除以 √2」。
一层一层递归下去:
最初那个输入 x₀,在第 l 层输出里的系数就是 2−l/2。
—— 残差那条「直通路」被指数地削掉了,越靠近输入削得越狠。
所以苏剑林那句话说得很重,但它有依据: 「在 Post Norm 的 BERT 模型中,LN 不仅不能缓解梯度消失, 它还是梯度消失的『元凶』之一。」
📌 苏剑林《模型优化漫谈:BERT 的初始标准差为什么是 0.02?》kexue.fm/archives/8747 —— 「在 Post Norm 的 BERT 模型中,LN 不仅不能缓解梯度消失,它还是梯度消失的『元凶』之一」为原文原话,2^(−l/2) 出自该文公式的递归展开。
⚠️ 这是作者本人的分析文章,不是同行评议论文。⛔ 图上画的是前向的残差直通项,不是梯度倍率 —— 两者相关,但不是一回事。
那为什么不去掉它?
—— 因为去掉之后 x + F(x) 的方差就是 2,残差越多方差越大。
问题从来不是「加不加 Norm」,是「加在哪儿」:
Pre-LN 改成 x + F(Norm(x))、最后总输出再加一个 Norm,
这样每个残差分支是平权的,就没有那条指数衰减了。
而最反直觉的一条是: 这个「毛病」,换个场合就变成了功能。
Finetune 的时候,我们本来就希望优先调靠近输出的参数, 不要过度动靠近输入的 —— 免得把预训练学到的东西破坏掉。 而梯度消失的意思恰恰是「越靠近输入,它对最终输出的影响越弱」, 这正好是 finetune 想要的。
所以预训练好的 Post-LN 模型, 往往比 Pre-LN 有更好的 finetune 效果。 同一条曲线,预训练时是毛病,微调时是功能 —— 这就是上面那张图左右两半在说的事。
📌 出处与免责同 3.5 (苏剑林,kexue.fm/archives/8747)。 那里原来写的是「见 3.4 的脚注」—— 引错了:3.4 那条脚注是 同一位作者的另一篇(archives/11267,讲 update RMS 0.2 的)。
顺带把 3.5 那三个 warmup 解释的前提坐实了: 第三条说「压住后面的层、等前面的层跟上」, 它要的正是这里这条指数衰减 —— Pre-LN 没有这条线,所以那一条对它也就不适用。
ViT 往上做到约 80 亿参数的时候,训了几千步就发散。 根因查出来很具体:注意力 logits 变得极大, 于是 softmax 之后的注意力权重塌成几乎 one-hot(熵接近 0)。
治法也很直接:在做点积之前,给 Q 和 K 各做一次 LayerNorm。 —— 这就是今天很多大模型标配的 QK-norm 的来历。
📌 arXiv 2302.05442(ViT-22B)§2。 出处要说准:QK-norm 不是 ViT-22B 发明的。 它的原文写的是「我们采用 Gilmer 等(2023)的做法」 —— ViT-22B 是把它用到 220 亿参数上并留下那张对照图的地方, 这才是它值得引的原因。 注意这又是一次「只在大规模上才出现」的故障。跟 6.1 那条是同一个模式。
深网络里,如果每一层的残差分支都按同样的尺度初始化, 信号会随层数累积放大。常规做法是按深度把残差分支的初始化缩一下 —— 它不解决 spike,但它决定了你从一个多好的起点出发。
❓ 「bf16 是不是也要 loss scaling?」—— 不用。
一句话版本:同样是 16 个格子,两边的分法不一样。 fp16 把更多格子分给了「分得细」,bf16 把更多格子分给了「够得着多小」。 —— 所以 fp16 的毛病不是不够细,是下不去:梯度一小到某个程度直接变成 0, 那个参数这一步等于没收到任何消息。而 loss scaling 做的事很朴素 —— 搬个位置躲开地板。
loss scaling 是 fp16 时代的必需品:fp16 的指数位只有 5 位,
小梯度会直接下溢成 0,所以要先把 loss 放大若干倍再算、更新前再缩回去。
而 bf16 的指数位跟 fp32 一样是 8 位 ——
动态范围没缩,缩的是尾数精度。所以它不下溢,也就不需要 loss scaling。
numpy.float16 的位模式当场算的,「归零」也是真舍了一遍验的;没有直方图—— 那份数据我们没有,不编。📌 图上每个边界都是从 numpy.float16 的位模式当场算的:最小正规数 0x0400 = 2⁻¹⁴,最小次正规数 0x0001 = 2⁻²⁴;bf16 与 fp32 同为 8 位指数,下界 2⁻¹²⁶。「低于红线会被舍成 0」是真舍了一遍验出来的。
⭐ 这张图的讲法取自混合精度那篇经典图(梯度直方图 + 一条 FP16 下界竖线,见 Micikevicius, Narang et al., ICLR 2018) —— ⛔ 但我们没有那份直方图数据,所以这里不画直方图,只画真边界。
这跟 3.2 那条判据是配套的: bf16 换来的是「范围够、精度差」,所以怕的是累加,不是下溢。
❓ 「训练是不是应该做到可复现?」—— 能做到,而且很值。
PaLM 做到了逐比特可复现:从任何一个 checkpoint 重启, 后续每一步的结果跟原来那次一模一样。
靠的是两件事:确定性的计算框架, 以及确定性的数据管线 —— 后者的关键是「第几批数据」只由步数决定,跟进程数、恢复次数都无关。
而 6.2 那个「回滚 + 跳数据」的办法,前提就是这个。 —— 数据管线不确定,你连「跳掉哪几批」都说不清。
📌 同样出自 arXiv 2204.02311。
先回到开头那句话。
第零节我说:训练这件事,就是拿一个数,去决定6,710 亿个参数各自该往哪边挪。
现在这句话的每一个字都有着落了:
−ln p,模型对正确答案有多意外。
刚开始是 11.77(在整个词表里瞎猜),训到后来落在 2 附近。
(1.0)而中间所有那些账 —— 三倍算力、扔不掉的中间结果、 每参数 16 字节。都只是为了把那一个数,从 11.8 挪到 2。
到了 2 附近之后,每往下 0.01 都很贵 —— 而那时候你付的,就是你刚才算过的那整张账。
这一讲还报了几十个数字。但真正想留下的不是那些数。
⭐⭐⭐ 数字会过期,这四条不会。
这一节刻意一个我们自己的实测都没有 —— 四条全部来自公开论文并逐条核过原文。 理由写在 §七:这一讲已经有太多「自己推的」数了, 稳定性这一块不该再加。
这一讲报了几十个数字。它们不是同一种东西。 有的能查到论文原文,有的是我们自己按算子推的 —— 后者可能差一倍,前者不会。
回去打开框架,该搜哪个词?
| 这一讲里的说法 | 在框架里叫什么 | 核的地方 |
|---|---|---|
| 全量重算(2.2) | --recompute-granularity full |
Megatron-LMtraining/arguments.pycore/transformer/transformer_config.py |
| 选择性重算(2.3) | --recompute-granularity selective +
--recompute-modules候选项: core_attn(selective 打开后的默认选项)/ layernorm /
moe_act / mla_up_proj / mlp … | |
| 梯度裁剪(1.8) | --clip-grad(默认 1.0,正好是 V3 用的那个值) | |
| 重算,手写的那种 | torch.utils.checkpoint.checkpoint(...) |
PyTorchtorch/utils/checkpoint.py |
| 选择性重算,按张量挑 | create_selective_checkpoint_contexts + CheckpointPolicy这就是 2.3 那条判据在 PyTorch 里的落点: 你自己写规则决定哪个算子存、哪个重算 | |
| 重算(JAX 那边) | jax.checkpoint(别名 jax.remat) |
JAXjax/_src/ad_checkpoint.py |
| 选择性重算的现成策略 | jax.checkpoint_policies.dots_with_no_batch_dims_saveable名字直接说出了判据:「矩阵乘的结果留着」 —— 正是 2.3 那张表最贵的那几行 | |
| 梯度累积(1.8 第 ④ 道) | ddp.no_sync() —— 上下文管理器进去之后梯度只在本地累加、不跨卡同步; 退出后的第一次 forward-backward 才同步一次(原文档语) |
PyTorchtorch/nn/parallel/distributed.py |
| 「跨卡汇总能藏进计算里」(1.8 第 ② 道) | bucket_cap_mb(默认 25 MiB)梯度攒够一桶就发一次 —— 所以前面的层还在算,后面的桶已经在路上了。 那一道「✅ 能藏」,藏在这个桶里 | |
| ZeRO 的三级(4.2) | 配置里的 zero_optimization.stage = 1 / 2 / 3 |
DeepSpeedruntime/zero/config.py |
| 8-bit 优化器(3.4) | bitsandbytes.optim.Adam8bit / AdamW8bit |
bitsandbytesoptim/__init__.py |
这两行,是这一讲的判据被写进了 API 的名字里。
dots_with_no_batch_dims_saveable ——
「矩阵乘的结果存下来」。为什么是矩阵乘?
因为它每省一字节要付的 FLOPs 最多 —— 正是 2.3 那条闭式解。ddp.no_sync() ——
把这两行放一起看就清楚了:no_sync() 干的事,
正是把第 ② 道整个关掉。
累积期间一次不通信,攒完再一次性同步 ——
所以「梯度累积顺带省通信」不是副作用,它就是这个 API 的用途。core_attn 是 Megatron 打开 selective 之后的默认选项
(不是「默认开着」—— recompute_granularity 默认是 None),
而且源码里就带着一条「融合 attention 下你不需要设它」的警告 ——
而按 2.4,长上下文下它恰恰是最不该重算的那一个。
默认值是有年代的,这条在 2.5 展开过。
顺带消一个看起来矛盾的地方:2.2 说「大模型训练里重算默认就开着」讲的是业界实践,
这里说 recompute_granularity 默认 None 讲的是框架出厂值 —— 两句都对,但不是同一个「默认」。这一讲少讲了一档:PyTorch 的 CheckpointPolicy
有六个枚举值不是两个 —— {MUST,PREFER}_SAVE、
{MUST,PREFER}_RECOMPUTE、{MUST,PREFER}_CPU_OFFLOAD。
也就是说,框架眼里「这块激活怎么办」是三选一:
存在显存里 / 扔了重算 / 卸到 CPU 再搬回来。而本讲只讲了前两个。第三条是拿 PCIe 带宽换显存,
跟本讲那条「拿算力换显存」是同一个形状、不同的货币。
至于 MUST 和 PREFER 的区别,文档写得很直接:
MUST_* 表示这条不许被 torch.compile 那类子系统覆盖。
所以这张表是个反向检查: 你理解的判据跟框架给的选项对不上时, 多半是你的判据错了,或者那个默认过期了。
这张表最容易过期,所以用法要说清楚。
上面每一个名字都是 2026 年 9 月在各自主干上当场 grep 到的, 不是凭印象写的 —— 而框架改名是常事。
判据:给了名字,就得给「在哪个文件里能查到」。 —— 否则名字一改,这张表就从「帮忙」变成「误导」,而且不会有任何东西报错。
| 数字 / 说法 | 出处 |
|---|---|
| 每参数 16 字节(2+2+12)的经典口径;ZeRO 三级的切法 | Rajbhandari 等,arXiv 1910.02054 |
| GPT-3 八档峰值学习率与 batch;375M token 线性 warmup; 2,600 亿 token 内余弦降到 10%;weight decay 0.1;上下文 2,048 | arXiv 2005.14165 表 2.1 与附录 B(§2.3 只写「细节见附录 B」) |
| DeepSeek-V3 的 完整 LR schedule(2K 步 → 10T 恒定 → 4.3T 余弦 → 末段两级);梯度裁剪 1.0;batch 3072→15360; bf16 的一/二阶矩 + fp32 主权重和梯度;重算 RMSNorm 与 MLA 上投影 | arXiv 2412.19437 §3.2.3(重算)/ §3.3.3(低精度)/ §4.2(超参) |
| 选择性重算的判据原文;GPT-3 省 70% 付 2.7%;MT-NLG 省 65% 付 1.6% | Korthikanti 等,arXiv 2205.05198 |
| warmup 的真实机制(让网络能承受更大的目标学习率; 「样本太少估不准」不是主因;warmup 拉长收益边际) | arXiv 2406.09405(NeurIPS 2024) |
| Adam / AdamW / Adafactor / Lion 的原始定义 | 1412.6980 / 1711.05101 / 1804.04235 / 2302.06675 |
| Muon 只作用于二维参数、embedding 与输出头仍用 AdamW、 per-step 墙钟比 AdamW 慢 | 作者 writeup(三条都是原文) |
| 数字 | 推导链 | 它可能错在哪 |
|---|---|---|
| 激活 104.11 GiB → 重算后峰值 5.07 GiB(4K) | 按算子逐项推(1.7 那两张表)。输入只有 V3 的 config + 官方参考实现的 MLA 前向 | 框架的算子融合程度、MoE 派发是否真的物化九份 |
| attention 占一层算力 82.1% | 按 causal 折半口径算。这里早先写「专题一用完全独立的另一套算法算出
81.8%,两边对上了」—— 那句话是错的,已撤回。
两边分子是同一条公式(S²·H·(dqk+dv)、同一份 config、
同样 causal 折半),只有分母不同:专题一除整模型(含 lm_head),
这里除一层的激活参数。差的那 0.463% 正是 lm_head 的稀释
—— 81.8 ÷ (1−0.00463) = 82.18。 |
口径(折没折半);换头维度就变。 它是一次算术自检,不是外部锚点 —— 两个数同源,对上是必然的。 这个量目前没有第三方实测可验 |
| 交叉点 S ≈ 13,107 | 1.25·S = 16,384(o_proj 的输入宽 = 128 头 × 128)。
1.25 来自 V3 头维度 192/128、causal 折半。
早先这里分母写的是 d_model 7,168、交点报 5,734 ——
「最宽线性层 = d_model」在 MLA 上不成立 |
换一条线性层做对照,交点就不同 —— 它不是工程阈值 |
| 6ND 低估五到六倍 | 由上面那个 82.1% 反推(1 ÷ 0.179) | 它继承了 82.1% 的全部不确定性;目前没有第三方实测佐证 |
| 9.76 TiB 常驻块 · 约 1973 条 4K 序列的分水岭 | 671e9 × 16 B ÷ 1024⁴;再除以重算后峰值 5.07 GiB。 那个峰值必须含「正在重算的那一层」 —— 只算存档点会把分水岭报成 2997 条,偏高 52%。构建时带 assert | 16 B 是经典口径 —— V3 自己就不是这么配的(见 3.2) |
| 「按每张卡 80 GiB 算要 125 张」 | 9.76 TiB ÷ 80 GiB | 80 GiB 是随手设的换算基准,不是某款具体的卡; 真实部署还要算冗余、通信缓冲、碎片 |
为什么要专门写这一节。
因为这两类数字长得一模一样 —— 都是几位有效数字加一个单位。 而读者会把它们一起抄走。
⭐⭐⭐ 判据:一个自己推出来的数,必须连着推导一起给; 否则它冒充的是事实。
📌 一条方法,而这一页正好有它的反例:孤立的估算没法验证, 能对上一个「外部」锚点的估算,一次就把整套公式验了。 82.1% 那一行没有这样的锚点 —— 上面那条撤回说得很清楚, 它跟专题一的 81.8% 同源,对上是必然的。 「两个数对上了」只有在两条路真的独立时才算数。
← 回 课程总纲 ·
前向那半张账在 专题一 · 一个 Token 的一生 ·
想自己讲一遍?看 本讲讲义(授课稿) ·
这张账怎么切,在 专题五 · 并行策略
本页由 Courses/tools/topic04-build.py 生成 ——
正文写在那个脚本里。