现代 AI 加速器 GPU / TPU 系统课程 / 主线 / 专题四 / 反向与优化器 🌐 English

反向与优化器

模型读完一句话,猜错了下一个字。这份「错得有多离谱」是一个数。
—— 而训练要做的,是拿这一个数, 去决定6,710 亿个参数各自该往哪边挪多少。

这一讲只讲三件事:这个数怎么算出来(loss)、 一个数怎么变成 6,710 亿个导数(反向传播)、 拿到导数之后那一步该迈多大(梯度下降与优化器)。 —— 一条链,从一个数走到一次更新。

前置 专题一 部分小节需要 专题三 后续 专题五 · 并行策略 读法 顺着一个 loss 值走一遍

课程作者 Chris Yang·Google Cloud AI Infra 架构师

这一讲另有一份讲义(授课稿)。

讲义写的是怎么讲:每一段的目的、讲到哪里该停、常见的误解、 被问到了怎么答。内容本身在你现在看的这份正文里。

两个用法。自己上台讲:照着讲义讲,台词、切图、时间都写着。 自学:把讲义整份丢给 AI,你会得到一个既有这一讲全部背景、 也知道该怎么讲的助教,让它带你走一遍。

第 零 节

一个数,和 6,710 亿个参数

🎯 开场热身:上一讲那四个模型,各自走的是哪条路? —— 连线题,四条全对才公布答案。不做也不影响这一讲

左边是四个模型,右边是四条注意力构成(一格=一层,这是 专题三那张编年史表里同一套配色)。 先点左边一个,再点右边一个就连上;再点一次左边可以拆掉。

Kimi K3 2.8T/104B · 93 层
DeepSeek-V4-Pro 1.6T/49B · 61 层
Qwen3.5 397B/17B · 60 层
小米 MiMo-V2.5-Pro 1.02T/42B · 70 层
SWASWASWASWASWASWAFULL
KDAKDAKDAgMLA
HCAHCACSAHCACSA
GDNGDNGDNgAT

专题一跟着一个 token 走完了前向 —— 模型吐出了它的猜测。 这一讲从那一刻接着往下走:猜错了,然后呢?

「猜得多离谱」会被压成一个数。不是一张表,不是一个向量 ——  一个数。

而训练这件事,从头到尾就是在做一件事: 拿这一个数,去决定6,710 亿个参数各自该往哪边挪、挪多少。

✋ 这里台下一定会有人举手:一个数怎么可能决定 6,710 亿个东西?信息量根本不够。

问得对,而这一问的答案就是整讲的主线: 那 6,710 亿个方向不是从这个数里读出来的,是从它算出来的。

信息不在这个数里 —— 它在网络的结构里, 在那一次前向留下的每一个中间值里。 loss 只是个起点,链式法则负责把它展开成 6,710 亿份。 记住这句话,第二节那笔「激活为什么扔不掉」的账 就不用解释了。要展开,就得留着展开时要用的东西。

所以这一讲就三件事,顺着这条链走一遍:

  • ① 这个数怎么来的 —— loss 到底怎么算(1.0)。
  • ② 一个数怎么变成 6,710 亿个导数 —— 反向传播的原理(第一节)。 这一段是全讲最该讲透的:笨办法要算 两万年,而实际只多花两倍前向的时间。
  • ③ 有了导数,那一步该迈多大 —— 梯度下降与优化器(第三节)。

三件事,一条链。 —— 链的一头是一个数,另一头是 6,710 亿次「挪一点点」。

⛔ 这一讲不讲什么 —— 先说清楚,免得你等一个不会来的答案。

  • 装不装得下。显存够不够、哪一块最大、怎么省 ——  这一讲会顺手报几个数字让你有量级感,但不展开。
  • 怎么切到多少张卡上。张量并行、流水线、ZeRO 的三级分法 ——  整个是专题五的事。

⭐⭐⭐ 具体说:第二、四、五节里那些细账, 以及全讲所有点得开的折叠块 —— 都属于上面这两类。 它们是专题五的预习,跳过去不影响这一讲的三件事。

为什么这条线要划在这儿 —— 一句话的方法论,跟这一讲的三件事无关,可以直接跳过

反向传播和梯度下降是原理,它们几十年不变; 而「放不放得下」是当下这一代硬件的处境,换一代机器就变。 把两者混在一起讲,读者会以为原理也是会过期的。

📐 先把场景钉住,不然后面每个数你都不知道它在说哪一档。

这一讲所有的账,默认都按 DeepSeek-V3 预训练的真实配置算: 序列长度 4,096,global batch 从 3,072 条爬到 15,360 条。

V3 对外说的是 128K 上下文,但那是预训练之后 两段各一千步的扩展;真正跑掉 14.8T token 的那一段,是在 4K 上。 本讲凡是出现 128K 的地方,都会明说那是扩训场景, 并给出跟 4K 的换算 —— 不标场景的数字没有意义,这也是全讲第③条判据。

第 一 节

一个数怎么变成 6,710 亿个导数 —— 反向传播的原理

反向传播不是「再跑一遍」。它要付两样东西: 大约两倍于前向的算力,以及 —— 更要命的。一路累加、不能提前扔掉的中间激活。

📌 先把「激活」这个词钉死 —— 它在这一讲出现六十多次, 而它有三个都很常见的意思。

  • 本讲一律指第一个:前向算出来、还没被扔掉的 中间结果(每层的输入、norm 的输出、注意力的分数……)。 整个第二节都在算它占多少显存。
  • 不是「激活参数」。上一讲说 V3「每 token 激活 37B」——  那是 MoE 里这一步被选中参与计算的那部分权重, 跟这里说的中间结果完全是两样东西。 本讲只在讲 MoE 派发时用到那个意思,用到时会写成 「被激活的专家」。
  • 也不是「激活函数」。SwiGLU、GELU 那一类算子, 本讲一律写全「激活函数」,不简称。

一句话:本讲看到「激活」两个字单独出现,指的就是 前向留下来、反向还要用的那堆中间结果。

不过在算这笔账之前,得先把起点说清楚 ——  整条链是从一个叫 loss 的数开始往回走的, 而那个数本身,值得先花两分钟。

1.0 先说清楚:loss 到底是一个什么数

这一讲后面所有的账,都是为了让一个数变小。 —— 先把这个数说清楚。

第一步 · loss 就是「模型有多意外」

模型读完前面的字,要猜下一个字。它不是只报一个答案,而是给词表里每一个词打一个概率。 —— 然后我们翻开正确答案,只看它给对的那个词打了多少分。

📌 分数变概率靠 softmax:取指数(保证为正), 再除以总和(保证和为 1)。本讲后面它出现十几次,都是这一个动作; 专题三注意力那张图的「权重加起来等于 1」也是它。

loss = −ln p  (p = 模型给正确那个词的概率)

第一步之二 · logits 怎么变成 loss —— 以及「猜错的那些」去哪了

先说清 logits 是从哪儿来的,不然下面那张图一上来就是「一排分数」, 没人知道这排数为什么正好是 129,280 个。

那排 logits 是从哪儿来的 一句话:前向走完 → 一个 7,168 维的向量 → 乘 LM head → 129,280 个分数 前向 LM head logits Ⓐ 一个位置,走完前向之后手里有什么 只画这一条线 —— 层里面长什么样是专题一的事 前向走完 (61 层) 这个位置的向量 7,168 个数 × LM head 7,168 × 129,280 这一块权重有 9.27 亿 个数 logits 129,280 个数 (词表每个词一个) 画不成比例:真实是长 18 倍 这排数就叫 logits 可正可负、没有范围 它还不是概率。 所有位置一起算就是一次矩阵乘:[4,095 × 7,168]× [7,168 × 129,280]=[4,095 × 129,280] 那块结果不小:bf16 存下来约 0.99 GiB —— 它比 1.7 那张表里任何一个单独的张量都大。 下一格才是 softmax —— 它把这 129,280 个分数变成 129,280 个概率。
一句话:前向走完 → 一个 7,168 维的向量 → 乘 LM head → 129,280 个分数。那块 LM head 的形状是 7,168 × 129,280,光它自己就有 9.27 亿个数;乘完之后,词表上每个词各拿到一个分数 —— 这排数就叫 logits,可正可负、没有范围,还不是概率。
⭐ 所有位置一起算是一次矩阵乘,结果那块约 0.99 GiB(bf16)—— 比 1.7 那张表里任何一个单独的张量都大。
出处与口径

词表 129,280、残差流宽度 7,168 取自 DeepSeek-V3 配置;LM head 的参数量与那 0.99 GiB 都是本脚本现算并 assert 住的。

⚠️ 图里两个方块不成比例(真实差 18 倍,画不下);层内部结构不在这一格,见专题一。

好,那上面那句 −ln p 里的 p 是怎么来的?中间隔着两步。

模型最后一层吐出来的,是一排原始分数 ——  这排数就叫 logits。 它可正可负、没有范围,还不是概率。

logits 怎么变成 loss —— 以及「猜错的那些」去哪了 三步:取指数 → 除以总和 → 翻开答案取负对数 Ⓐ 三步 Ⓑ 两个性质 Ⓒ 错的那些去哪了 Ⓐ 从一排分数,到一个数 词表这里缩成 5 个词;真实是 129,280 个 —— 动作一模一样,但算出来的那个数也跟着缩了(下面那条专说这件事) ① logits(原始分数) 2.00 的 1.00 了 1.00 在 0.00 和 0.00 有 可正可负,没有范围 ② 减掉最大值,再取指数 1.00 的 0.37 了 0.37 在 0.14 和 0.14 有 全变正数,最高那格正好是 1 各减 2.00: 0 / −1 / −1 / −2 / −2 ③ 除以总和 = 概率 0.50 的 0.18 了 0.18 在 0.07 和 0.07 有 加起来正好是 1 这一排的总和不用管 整排同时加减一个数,概率一模一样 → 所以下一格敢减 分母 = 2.01 = 1 ÷ 最高那格的概率 (这里也就是困惑度) 总和 = 1.00 这一条才是有意义的 ④ 翻开正确答案 正确的是「的」,它的概率 0.4984 (就是 ③ 里那一格 —— 那边四舍五入成了 0.50) 这一个位置的 loss = −ln 0.4984 = 0.6964 其余四个的概率,式子里一个都没出现 —— 那它们去哪了?看 Ⓒ。 顺带记住这个词:logits = 最后一层吐出来的那排原始分数 —— 它还不是概率,中间隔着 softmax 这两步。 这个 0.6964,不是你在训练曲线上看到的那个 loss 式子是同一个 −ln p,但这张图为了画得下,把口径缩了两层:词表只有 5 个词,而且只看一个位置。5 个词瞎猜就是 −ln(1/5) = 1.61 —— 所以 0.6964 的全部含义是「比瞎 猜好一点」,不是「已经训得很好了」。 训练日志里那个 loss = 真词表 129,280 个词 + 一整个 batch 所有位置取平均,它瞎猜的起点是 11.77(1.0 那把尺的顶端,也是训练曲线的第 0 步)。 所以 loss 的 数值一半是词表定的 —— 词表不一样的两个模型,loss 不能直接比。 Ⓑ 两个性质,一个漂亮、一个救命 ① 加同一个数,概率完全不变 把那一排 logits 全部 +100 —— 算出来还是 0.4984。 所以 logits 的绝对大小不重要,只有「差」重要。 指数干的事,就是把「差」变成「比」。 ② 可别真直接取指数 —— 会炸 真实 logit 可能几十上百:e¹⁰² ≈ 2e+44, 而 fp32 的上限只有 3.4e+38。 所以实现里先减去这排里的最大值再取指数 —— Ⓐ 第 ② 格画的就是这一步 —— 敢减,靠的正是左边那条平移不变。数学等价,数值不炸。 Ⓒ 那猜错的那些去哪了? —— 它们全在分母里 正确答案的概率 = 它自己的指数 ÷ 所有格子的指数之和 —— 那个和里装着每一个词 原来 正确那格的概率 0.4984 loss = 0.6964 只把一个「错」的抬高一格 抬高 正确那格的概率 0.3790 loss = 0.9702 正确那一格的分数,一个字都没改 —— 可 loss 涨了 0.2739。 所以它们参与了,只是不以自己的名义。 而求导之后,它们全部显形 的(正确) -0.5016 了 +0.1834 在 +0.1834 和 +0.0675 有 +0.0675 加起来 = 0 —— 一次再分配 错的那些,梯度正好等于它现在占的概率。 这一格的两句话 logits = 最后一层的原始分数(可正可负);取指数 → 除以总和 变成概率,再翻开答案取负对数,就是 loss。 猜错的那些没有从式子里消失,它们在分母里 —— 而且求导之后每一个都显形。 一句话:loss 的式子里看不见它们,梯度里看得见;而训练只用梯度。
logits → 概率 → loss,三步走完。Ⓐ 取指数(全变正、差距拉开)→ 除以总和(加起来是 1)→ 翻开答案取负对数。「logits」= 最后一层的原始分数,它还不是概率。
Ⓑ 两个性质:全部加同一个数,概率完全不变(所以只有「差」重要);而直接取指数会炸,所以实现里先减最大值。
⛔ Ⓒ 回答现场那一问:猜错的那些全在分母里 —— 只抬高一个错的分数、正确那格一动不动,loss 照样涨;而求导之后它们全部显形。
出处与口径

⭐ 完整的交叉熵其实是对整个词表求和;只因为标签是 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 里。

为什么是这个式子 —— 它其实很讲道理。

  • 模型很确信而且猜对了(p → 1):−ln 1 = 0,不罚。
  • 模型给对的那个词几乎没打分(p → 0):−ln p → ∞,罚到天上去。
  • 关键是取了对数:这让「从 1% 提到 2%」和「从 50% 提到 100%」 得到一样的奖励 —— 都是概率翻倍,都降 ln 2。
  • 而对数真正带来的是另一样东西: d(−ln p)/dp = −1/p —— 概率越低的位置,梯度越大, 所以模型先去救它错得最离谱的那些。 这里原来写的是「不然模型会只顾着把已经很有把握的地方 再推高一点点」—— 那句推不出来:换成线性的 1−p, 导数恒为 −1,模型对「已经有把握的」和「完全没把握的」是无差别的, 并不会偏向前者。方向正好说反了。

📌 这个东西的正式名字叫交叉熵,也叫负对数似然。 —— 三个名字,同一个式子。

第二步 · 先有困惑度,loss 是它的对数

先扔掉对数。就问一件事:模型给正确答案打了 0.4 分, 我们要给它一个惩罚分,怎么定?

最自然的办法:取倒数。 1 ÷ 0.4 = 2.5

这个 2.5 的意思是 —— 它跟「在 2.5 个词里闭着眼睛瞎猜」是一个水平。 (真有 2.5 个等可能的选项时,每个正好就是 0.4。)

这个倒数就是困惑度。 它一点都不神秘 —— 就是「1 除以你给正确答案打的那个分」。

给正确答案打的 p困惑度 = 1/p读作
0.81.25几乎不用挑了
0.42.5相当于在 2~3 个词里瞎猜
0.110相当于在 10 个词里瞎猜
0.01100很糊涂

⛔ 那 −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 自动给的。
  • 模型错到万分之一 → 困惑度 10,000 → loss = 9.21。 越错惩罚越大,而且没有上限。

注意那个节奏:困惑度从 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
猫(正确)10.400.9163
狗00.350 —— 乘 0,整项消失
桌子00.150 —— 乘 0,整项消失
的00.100 —— 乘 0,整项消失
合计0.9163 = −ln 0.4

所以不是「我们只看一个」——  是那 129,279 项各自乘了一个 0,自己消失了。

这也是「交叉熵」那两个字的来历: 交叉 = 两个分布在比。而熵是一个分布跟自己比 —— 这正是后面那条自曝里被我讲混的两个量,根子在这儿。

📌 顺带一扇门:既然标准答案是「人写上去的」,它就可以不是 100%。

  • label smoothing —— 正确的给 91%,剩下 9% 摊给别人。 同一个模型预测,交叉熵从 0.9163 变成 0.9913 —— 其余几项真的参与进来了。
  • 蒸馏 —— 标准答案直接换成大模型吐出来的那一整列概率。 这时候所有词全都参与:小模型学的不只是「答案是猫」, 还有「狗也挺像,桌子完全不沾边」。

但预训练几乎都用硬的 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.98129,280刚初始化,还没学任何东西在整个词表里均匀瞎猜 —— 这就是 loss 的上限
6.0 量级8.66403学会了最基本的字频相当于在几百个词里犹豫
4.0 量级5.7755语法大致对了几十个词
3.0 量级4.3320像模像样的文本二十个词上下
2.0 量级2.897现代大模型预训练末期大致落在这一档七八个词
1.0 量级1.443几乎能背出来了两三个词 —— 正常预训练到不了这里

⛔ 看最上面那一行 —— 它不是随手填的。

一个刚初始化、什么都没学的模型,对每个词的概率都一样, 也就是 p = 1 / 129,280。代进去:

loss = −ln(1 / 129,280) = ln 129,280 = 11.77

而它的困惑度正好就是 129,280 —— 整个词表。 「在 129,280 个词之间瞎猜」,这不就是瞎猜的定义吗。

所以这把尺的上端不是估的,是算出来的 —— 你换个词表大小,上端就跟着换(词表 129,280 这个数在专题一核过)。 而下端我没有 V3 的官方数字:表里「2.0 上下」是公开模型的大致量级, 当参照看,别当某个具体模型的实测值。

那一列 bit 在说什么 —— 把它「选出来」要问几个是非问题

第二列是把 nat 换成 bit(除以 ln 2)。 换算本身没什么,值钱的是 bit 这个数怎么读。

bit 回答的是这个问题:把这个词从候选里挑出来,要问几个「是 / 不是」。 每问一次,候选减半 —— 所以要问几次,就是候选个数取以 2 为底的对数。

刚初始化时候选是整个词表,要问 16.98 次;训练到后期只要 2.89 次。

而候选变少,不是这个词自己变简单了 —— 是它前面那段上下文。 把 129,280 个候选压成等效 7 个,这就是模型前向干的活 —— 省下来的 14.09 个 bit,就是那 17,500 倍。

⛔ 说准一点:「等效 7 个」不是说真的只剩 7 个候选 —— 词表一直是 129,280 个,变的只是概率有多集中。 它的意思是「这份不均匀的分布,跟在 7 个等概率候选里挑,一样难」。

那一列 bit 在说什么 —— 把它「选出来」要问几个是非问题 不是「存下来要几个字节」—— 是从候选里把它挑出来,要问几次「是 / 不是」 每问一次,候选减半 Ⓐ 一个 bit = 一个是非问题 —— 每问一次,候选减半 所以「要问几次」= 候选个数取以 2 为底的对数 ① 刚初始化:候选是整个词表 还剩 129,280 个 开局 还剩 64,640 个 问 1 次 还剩 32,320 个 问 2 次 还剩 16,160 个 问 3 次 …… 这样一直问下去,第 17 次才剩 1 个 ⇒ 要问 16.98 次 (log₂ 129,280) ② 训练到后期:候选只剩等效 7 个 还剩 7 个 开局 还剩 4 个 问 1 次 还剩 2 个 问 2 次 还剩 1 个 问 3 次 三次就到头了 ⇒ 要问 2.89 次 (log₂ 7.39) bit 数量的是「挑出来有多难」,不是「存起来有多大」。 —— 一个 token 的 id 拿 4 个字节就存下了,跟这一列没有关系。 一句话记住这张图 bit = 把它从候选里选出来要问几个是非问题 —— 候选越少,问得越少。 而候选是上下文缩小的,不是这个词自己变简单了 —— 16.98 降到 2.89,那 14.09 个 bit 就是模型前向干的活。
bit = 把这个词从候选里「选出来」要问几个是非问题,不是「存下来要几个字节」。每问一次候选减半,所以问的次数= 候选个数取 log₂。
Ⓐ 开局候选是整个词表,要问 16.98 次;后期只要 2.89 次。
⭐ 重点是下一句:候选是上下文缩小的,不是这个词自己变简单了 —— 模型前向把 129,280 压成等效 7,省下的 14.09 个 bit 就是它干的全部活(2 的 14.09 次方 ≈ 那 17,500 倍)。
⛔ 再把「等效」说准:词表没有变小,变的只是概率有多集中。(这两句的画面版折在下面那张图里。)
出处与口径

换算里不含任何实测值:困惑度 = e^loss,bit = log₂(困惑度) = loss ÷ ln2;词表 129,280 取自 DeepSeek-V3 配置。

⚠️ 「后期 loss 2.0 上下」是公开模型的大致量级,当参照看,别当某个具体模型的实测值。

展开:候选是谁缩小的,以及「等效 7 个」的画面版 —— 上面三段字已经说完了。这是它的画面版: 没有上下文时整个词表都有份,有了上下文只剩一小撮; 右边那格把「等效」摆给你看。想看图的展开
接着上一张:候选是谁缩小的,以及「等效」是什么意思 这两格的话,课件在图上面已经写过一遍 —— 这里是它的画面版 Ⓐ 谁把候选缩小的 Ⓑ 「等效」的意思 Ⓐ 候选是上下文缩小的 —— 不是这个词自己变简单了 这是全图最要紧的一格:那 14 个 bit 是模型省下来的 没有上下文 (刚初始化) 整个词表都有份 —— 谁都可能 候选 129,280 个 ⇒ 16.98 bit 有上下文 「…… 今天天气真」 绝大多数词的概率被压到几乎为 0 —— 只剩一小撮还在场 等效候选 7 个 ⇒ 2.89 bit 中间那一步,就是大模型的前向。 它把 129,280 个候选压成等效 7.4 个 —— 缩小了约 17,496 倍。 16.98 − 2.89 = 14.09 个 bit —— 这 14 个 bit 就是模型干的全部活。(而 2 的 14.09 次方,约等于那 17,496 倍。) Ⓑ 「等效 7 个」是什么意思 —— 词表并没有变小 不是「真的只剩 7 个候选」—— 是「跟 7 个等概率候选一样难猜」 真实分布 (129,280 根柱子) 高低极不均匀 …… 其余 129,275 个的概率几乎是 0 一样难猜 等概率的 7 个 每个都是 1/7 这就是「困惑度 = 7」那句话的全部含义 所以困惑度不是候选的个数,是「相当于在几个词之间犹豫」。词表一直是 129,280 个,变的只是概率有多集中。
上面那三段字的画面版。Ⓐ 没有上下文时整个词表都有份;有了「…… 今天天气真」这么一句在前面,绝大多数词的概率被压到几乎为 0,只剩一小撮还在场。16.98 − 2.89 = 14.09 个 bit,而 2 的 14.09 次方约等于那 17,496 倍(不取整的 14.0947 才严丝合缝)—— 这就是模型干的全部活。
⛔ Ⓑ 把「等效」说准:词表并没有变小,变的只是概率有多集中。
出处与口径

⭐ 这两格原本是上一张图的 Ⓑ Ⓒ,2026-09-23 拆出来—— 为的是让课件那边能把它折叠起来。

换算里不含任何实测值:困惑度 = e^loss,bit = log₂(困惑度);词表 129,280 取自 DeepSeek-V3 配置。

一条现场能用的心算法:只要背两个数。

ln 2 ≈ 0.693 (记成 0.7) · ln 10 ≈ 2.303 (记成 2.3)

  • loss 每降 0.7,困惑度砍一半。
  • loss 每降 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.77129,314 → 47,57281,742 个
6 → 5403 → 148255 个
3 → 220.1 → 7.412.7 个
2 → 17.4 → 2.74.7 个

① 绝对收益越来越小。同样是「降 1」,早期划掉八万多个候选, 到 2 附近只划掉不到 5 个 —— 因为剩下的本来就没几个了。

② 而这一条才是根子:剩下的那点不确定性,有一部分是语言本身固有的。 「下一个字」真的可以是好几个,谁都猜不准,包括人。
—— 所以到了后面,你不再是在学习,你是在撞天花板。 那部分熵是不可约的,模型再好也降不到 0。

📌 这也是为什么比较两个模型的 loss 只在同一个数据集、同一个 tokenizer 下才有意义 —— 换一份数据,那个天花板本身就换了。

这把尺后面要用三次: 3.5 判断「loss 下得够不够快」、 6.1 判断「飞了多少算飞」、 6.3 读那张表里的数。 —— 没有尺,那三处都只能靠感觉。

插一格 · nat、bit、困惑度 —— 同一件事的三副面孔

上面那把尺用了两个词:nat 和困惑度。 它们听起来是两个概念,其实连同 bit 在内,是同一个量的三种读法。

展开:nat / bit / 困惑度 —— 同一个量的三种读法(一把双面尺) —— 换算下面这段字已经说清了(1 nat = 1.4427 bit)。 这张图只是把它画成一把尺,想看刻度的展开
Ⓐ 一把双面尺 —— 上沿 nat,下沿 bit,同一个位置是同一件事 就像厘米和英寸印在同一把直尺上:刻度疏密不同,量的是同一段长度 0 2 4 6 8 10 12 nat loss 本身 0 2 4 6 8 10 12 14 16 18 bit × 1.4427 刚初始化 · 瞎猜 11.77 nat = 16.98 bit 训练早中期 7.00 nat = 10.10 bit 收敛附近 2.00 nat = 2.89 bit Ⓑ 一个格子 = 一个 bit —— 长度是量出来的,不是写上去的 「模型平均要花多少个 bit,才能把下一个 token 记下来」 刚初始化 · 瞎猜 16.98 bit 收敛附近 2.89 bit 两条一比就完了:5.9 倍 —— 这就是模型学到的全部东西,换算成压缩的样子。 Ⓒ 困惑度 = e^loss —— 「这一步在几个词之间犹豫」 同一个量的第三种读法,换算里同样不含任何实测值 收敛附近 = 困惑度 7.4 —— 七个多词之间犹豫 刚初始化 · 瞎猜 …… 一共 129,280 个 瞎猜那一档画不下 —— 而它的困惑度正好就是整个词表,「在十二万九千个词之间挑一个」就是瞎猜的定义。 nat 和 bit 不是两种东西 —— 是同一把尺换了个底 bit 是「一次二选一」的信息量,以 2 为底;nat 以 e 为底 —— 差一个固定常数 1.4427。我们这儿是 nat,纯粹因为 loss 的定义里写的是 ln。 per token 那半截来自「一条序列几千个位置、每个位置一个 loss、最后取平均」—— 读作「平均每个 token 多少 nat」。
一个量,三把尺 —— loss(nat)/压缩(bit)/困惑度,挂在同一根轴上。
它们不是三个概念,是三种读法:bit = nat × 1.4427(只是底数从 e 换成 2)、困惑度 = e^loss。换算里不含任何实测值。
「刚初始化 · 瞎猜」那一档(Ⓐ 最右)是自检:瞎猜时困惑度必须正好回到词表大小 129,280、bit 必须正好等于 log₂(词表)。对不上就是公式写错了。
⛔ 落点是那个压缩比:17 bit → 2.9 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 ——  这就是这个模型学到的全部东西,换算成压缩的样子。

📌 所以同一件事有三副面孔,按场合挑:

  • nat/token —— 定义直接给的,训练日志里打的就是它。
  • bit/token —— 换算成压缩,直觉最强。
  • 困惑度 —— 换算成「在几个词之间犹豫」,最好向外行解释。

它们之间是恒等式,不是三套测量 —— 任何一个变了,另外两个必然跟着变。所以别把它们并排列出来当成三条证据。

第三步 · 一个 token 一个 loss,一个 batch 取平均

上面算的是一个位置的 loss。而一条 4K 的序列里, 每个位置都在猜它的下一个字 —— 所以一条序列有 4,095 个 loss。

⛔ 是 4,095 不是 4,096 ——  最后那个字没有「下一个」可预测。这个 1 在别处不重要, 但它正是 1.2 那批账的分母,所以这里说准。

把它们全部取平均,就得到这一批的 loss。

一个 token 一个 loss —— 62,899,200 个数,取一个平均 这一讲开篇那句「错得有多离谱是一个数」—— 就是在这一步变成「一个」的 Ⓐ 那张网格 Ⓑ 除的是格子数 Ⓐ 横着是位置,竖着是这一批里的每一条序列 —— 每一格一个 loss 画出来的是 8 × 10 示意;真实是 15,360 × 4,095 位置 1 → 位置 4,095 (一条序列有 4,095 个「下一个字」) 0.31 5.62 3.28 0.15 0.57 1.91 2.88 2.14 0.31 5.62 … 序列 1 0.44 7.81 1.38 0.23 0.36 0.31 5.62 3.28 0.44 7.81 … 序列 2 2.63 4.05 6.74 1.12 0.08 0.44 7.81 1.38 — — … 序列 3 1.91 2.88 2.14 1.07 0.92 — 4.05 6.74 1.91 2.88 … 序列 4 0.31 5.62 3.28 0.15 0.57 1.91 2.88 2.14 0.31 5.62 … 序列 5 0.44 7.81 1.38 0.23 0.36 0.31 5.62 3.28 0.44 — … 序列 6 2.63 4.05 6.74 1.12 0.08 0.44 7.81 1.38 2.63 4.05 … 序列 7 1.91 2.88 2.14 1.07 0.92 2.63 4.05 6.74 1.91 2.88 … 序列 8 …… …… 一直到第 15,360 条 灰格 = 不算分的位置 —— 它们不进分母,有两种: ① 行尾补的空位(padding) —— 这条文章不够长,后面拿空位填满好摞成一个整齐的方块。那儿根本没有字,猜什么都没意义。 ② 两篇文章的接缝 —— 为了不浪费,短文章会几篇拼进同一条里。拿上一篇的结尾去猜下一篇的开头,也没意义。 全部加起来 再除以格子数 一个数 这一批的 loss 62,899,200 个格子(15,360 × 4,095) —— 每一格都是一个 −ln p,都在 0 到 11.77 之间。 这 62,899,200 个数,最后只剩一个。 整条链后面所有的事,都是从这一个数出发的。 Ⓑ 那个「除一次」,除的是格子数 —— 不是序列数 分母数的是格子,不是行 不是「每条序列先平均成一个数,再把这些数平均」。 是所有格子一视同仁,加起来除一次。 序列长短不一的时候,这两种算法结果不一样 —— 按行平均会把短序列里的每个字看得更重 一句话记住这张图 一个位置一个 loss —— 一批就是一张 15,360 × 4,095 的网格,62,899,200 个数。 全部加起来,除以真正算了的那些格子的个数,得到一个数 —— 后面整条链,都是从这一个数出发的。
横着是位置,竖着是这一批里的每一条序列 —— 每一格一个 loss。按 V3 的口径这张网格有 62,899,200 个格子(15,360 × 4,095),每一格都是一个 −ln p。全部加起来再除一次,就剩一个数 —— 开篇那句「错得有多离谱是一个数」,就是在这一步变成「一个」的。
⭐ 网格上有灰格:那些位置不算分、不进分母 —— 一种是行尾补的空位(那儿根本没有字),一种是两篇文章的接缝(拿上一篇的结尾去猜下一篇的开头没意义)。
⛔ Ⓑ 一句话:除的是格子数,不是序列数 —— 不是「每条序列先平均成一个数再平均」。序列长短不一时这两种算法结果不同:按行平均会把短序列里的每个字看得更重。
出处与口径

口径来自 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
↓ 第一次压缩:只取正确答案那一格,取负对数
一个位置的 loss1−ln p
一条序列4,095每个位置一个
一步(按 V3 的 global batch 算)62,899,200(= 4,095 × 15,360 条)还是每个位置一个
↓ 第二次压缩:全部加起来,除以有效 token 数
最终 loss1你在 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 亿个导数,怎么算得过来?

1.1 先把难点问对 —— 难的不是求导,是求 6,710 亿个导数

求导是高中的事。 这里难的是:要求快 6,710 亿个导数,而且每一步都要重求一遍。

不过「求导是高中的事」这句话会劝退一批人 ——  所以先花一格,把这一讲要用到的三个词说完。 没有极限、没有公式,三句话,一张图。

导数、偏导数、链式法则 —— 其实是同一个词:兑换率 这一格不讲极限、不讲公式 —— 只讲这三个词到底在说什么事 导数:动一格,变几格 偏导数:其余按住 链式法则:一路乘 Ⓐ 导数问的不是「现在是多少」,是「你动一格,它动几格」 把参数想成一个旋钮,loss 是它右边那个读数 一个参数 (6,710 亿个之一) 往上推一点点 +0.01 → 这个参数 1 格 loss 3 格 两把尺一格都是 0.01 那这个旋钮的导数就是 loss 读数 4.00 → 4.03 (动了 0.03) 0.03 ÷ 0.01 = 3 读作:你动一格,它动三格 它不是「读数是 4.00」 —— 那是值,这是兑换率 顺带记住它的单位:loss 每参数 —— 后面讲「那一步该迈多大」那一节,整节都是被这个单位逼出来的。 Ⓑ 那「偏」字是什么意思 —— 就三个字:按住不动 一个 6,710 亿个旋钮的淋浴,一次只拧一个,其余全按住 按住 按住 按住 按住 只动这一个 按住 按住 按住 按住 …… 其余 6,710 亿个,全按住 偏导数 = 其余全按住时,这一个旋钮的兑换率。 而把 6,710 亿个旋钮各自的那个数排成一列 —— 那一列就叫「梯度」。 Ⓒ 可旋钮不直接连到读数 —— 中间隔着好几级 每一级有自己的兑换率,总兑换率就是一路乘起来 旋钮 × 权重 过激活 斜率 2.0 中间量甲 × 权重 过激活 斜率 0.5 中间量乙 × 权重 过激活 斜率 3.0 离目标差几度 橙色那个小方块才是装置;上面那个数是装置的斜率,不是装置本身 —— 它 = 权重 × 激活函数在当前这一点的斜率。 总兑换率 = 一路乘起来 2.0 × 0.5 × 3.0 = 3 这就是换汇 人民币 → 港币 → 美元,每步一个汇率 总汇率当然是乘出来的 —— 链式法则就这一件事 而「这一串数从哪一头开始乘」 —— 结果完全一样,代价差两万年。那是紧接着后面那张「正向 vs 反向」图的事。 所以这一讲后面所有的东西,都只用到这三句话 ① 导数 = 你动一格,它动几格(兑换率)。② 偏导数 = 其余全按住时的那个兑换率。③ 链式法则 = 中间每一级的兑换率,一路乘起来。—— 没有极限,没有 ε,没有要背的公 式。 唯一一个真的要小心的点:兑换率不是「值」。读数是 4.00 跟「动一格变三格」是两件完全不同的事 —— 本讲后面每次说「梯度大」,说的都是后者。
整讲的入口那一格 —— 导数、偏导数、链式法则,其实是同一个词:兑换率。
Ⓐ 导数问的不是「现在是多少」,是「你动一格,它动几格」。Ⓑ「偏」字的全部含义就三个字 —— 按住不动;而 6,710 亿个旋钮各自那个数排成一列,那一列就叫梯度。
Ⓒ 链式法则就是换汇:人民币→港币→美元,每步一个汇率,总汇率当然是乘出来的。—— 而「从哪一头开始乘」代价差 两万年,那是 1.5 的事。
出处与口径

⚠️ Ⓐ 的 4.00 → 4.03、Ⓒ 的 ×2 / ×0.5 / ×3 都是编出来的示意数,唯一的作用是让「相除」和「相乘」这两件事看得见。⭐ 脚本里 assert 了两条:总兑换率必须真的是三个乘积,而且链条里要有一级是缩小的 —— 不然「乘起来」会被读成「越乘越大」,而那正是梯度消失/爆炸那一节要讲的反面。

⭐ 这一格刻意不碰极限:严格地说导数是「动的那一点点趋于 0 时的极限」,而这张图画的是差商。⛔ 对本讲够用 —— 而且 §1.1 那个「笨办法」用的正是差商,所以这里不严格反而接得更顺。

⭐⭐ 「兑换率」这个说法不是为了好听,它自带两个钩子,两个都是本讲自己的:一串数相乘,从哪头开始乘代价差两万年(§1.5);而单位对不上所以必须再乘一个折算系数(§3.3)。

展开:可真实的一级不是一个标量 —— 上面那三格是一维玩具(一个旋钮、一个读数)。 真实的一级是七千多维进、七千多维出,它的「斜率」是一整张表。 结论只有一句:那张表我们从来不算出来 —— 想看细节的展开
补一格:真实的一级不是一个标量 前面那张图是一维玩具;这一格说清它跟真实的一级差在哪 —— 结论只有一句:那张表我们从来不算出来 斜率是一整张表 可真实的一级不是一个标量 —— 它的「斜率」是一整张表 上面三格是一维玩具:一个旋钮、一个读数。真实的一级是7,168 维进、7,168 维出 进来 7,168 个数 装置 几块权重 + 激活 (7,168→2,048 这种,都不是方阵) 出去 7,168 个数 那这一级的「斜率」是多少? —— 不是一个数:出去的每一维, 对进来的每一维,都各有一个兑换率。 但注意:机器里并没有这样一张方阵。 真实的权重没有一块是方阵,那张表只是概念上的。 但好消息是: 我们从来不把那张表算出来。 反向只做一件事:拿责任去乘它, 直接得到上一级该收到的责任。 —— 那正是「反向那两笔乘法」里的第二笔。 所以「一路乘起来」这句话是真的,只是乘的是表。
上面那三格是一维玩具,这一格说清它跟真实的一级差在哪。真实的一级是 7,168 维进、7,168 维出 —— 它的「斜率」不是一个数,是出去的每一维对进来的每一维各有一个兑换率,概念上是一整张表。⛔ 但机器里并没有这样一张方阵,真实的权重没有一块两边一样宽。
⭐ 而这一格真正要留下的只有一句:那张表我们从来不算出来 —— 反向只做「拿责任去乘它」这一件事,那正是反向那两笔乘法里的第二笔。
出处与口径

⭐ 这一格原本是上一张图的第四格,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.2 种子:第一个梯度长什么样

起点就是 1.0 那个数 —— loss。 (它只有一个,这一点后面是全部关键。)

那第一个梯度是什么?拿最常见的交叉熵来说:网络最后吐出一个概率分布 —— 下一个字是「的」的概率 0.3、是「了」的概率 0.2…… 而正确答案是一个只有一格是 1、其余全是 0 的东西。

第一个梯度 = 你猜的,减去正确答案。

猜高了的地方是正数,该高没高的地方是负数。 就这么简单。这个差,就是整条反向链的种子。

而它不是凑巧长这样 —— 它是 1.0 那个 −ln p 求一次导的结果。

对 logits 求导(不是对概率求导), −ln p 那一串恰好约化成 p − y —— 模型给的概率,减去那个只有一格是 1 的正确答案。

跟 1.0 那一段接上: 同一个 −ln p,换个求导对象,给出两件不同的东西。

  • 对概率 p 求导 —— −1/p, 概率越低梯度越大。这解释的是动机:模型为什么会先去救错得最离谱的。
  • 对 logits 求导 —— 整串约化成 p − y。 这给出的是实现:反向那条链的种子,一个减法就完事。

一个解释「为什么想动」,一个给出「怎么动」——  同一个 loss 的两张脸。

也正因为约化得这么干净,框架里它俩总是 融合成一个算子:分开算要先出概率再求导,合起来一步就到。 不是所有 loss 都这么好看,但这一对是今天的默认组合。

一个说准了才不会误导的细节: 那个「减」不是对概率求导,是对 logits 求导 —— 也就是 softmax 之前那一层的输出。
这个区别有实际后果:正因为约掉的是 softmax 那一步, 这个梯度才不会在 softmax 饱和的地方消失。softmax 和交叉熵总是成对出现,一半的原因就在这儿。

梯度是什么 —— 一屋子人各提各的要求,最后取个平均 这一格不讲公式,只讲这件事在干嘛 ① 一条样本的诉求 ② 众口难调,取平均 Ⓐ 一条样本看完输出,只会提一个要求 正确答案是「的」,而网络给「的」只打了 0.3 差 0.70 的 现在 0.30 差 0.20 了 现在 0.20 差 0.15 在 现在 0.15 差 0.10 和 现在 0.10 灰柱 = 网络现在给的 | 虚线 = 正确答案 | 箭头长度 = 要推多少 它的要求就一句话 「的」推上去,其他推下去 而且推多少,看差多远 这就是本讲说的那颗种子 「预测 − 真值」 —— 换成人话就是这一句 注意它只是「希望」—— 没人能直接改输出 Ⓑ 每一个位置都提自己的一份 —— 几千股力,加成一股 注意这一格一格 = 一个位置,不是一个字 —— 字那一层在 Ⓐ,这一层是位置与位置之间 序列 1 位置 1 位置 2 …… 共 4,095 个位置 序列 2 …… 共 4,095 个位置 每一支箭头 = 一个位置对这块权重的诉求(往哪改、改多少) 它们方向各不相同 —— 这才是「众口难调」四个字的实际样子。 ⊕ 全部加起来 (batch=2 就是 8,190 支) 合力 各自加起来 6.8, 合力只有 2.06 大部分互相抵消了 剩下的那一点,才是真信号 这股合力,就是这块权重这一步要挪的方向。 而「抵消得多、剩得少」正是batch 越大越稳的全部原因 —— 人越多,偏激的那几支越淹得住。 多卡训练里那道「跨卡汇总」,干的就是这个加法:每张卡先加自己那批,再凑到一起。 整个反向传播,用人话讲完就是这三步 一条样本提要求 → 要求往回递一层又一层 → 所有样本的要求取平均。后面那些张量、链式法则、矩阵乘,都是这三句话的算法实现,不是另外一件事。 而这一讲真正关心的账,全挂在第二步上:要求往回递的时候,必须回头看前向留下的东西 —— 这就是激活扔不掉、显存下不来的全部原因。
全讲最口语的一张 —— 「梯度」这个词唬人,本意却只是一屋子人各提各的要求,最后取个平均。
Ⓐ 一条样本看完输出只会提一个要求:对的推上去、别的推下去,推多少看差多远 —— 那就是「预测 − 真值」换成人话。
Ⓑ 只听一条样本的,网络会学会把什么都答成同一个字。所以要平均 —— 而多卡训练里那道「跨卡汇总」,干的就是这个平均。
出处与口径

📌 「推一下(nudge),推多少跟差多远成正比」「想让一个神经元更亮有三条路」「改权重要按上游亮度成比例,回报最大」「众口难调,只能取平均;只听那张 2 的,网络会把所有图都判成 2」四个装置,取自 3Blue1Brown《What is backpropagation really doing?》官方讲义 —— 已逐条核过原文,图是我们自己重画的,例子换成了本讲一直在用的「下一个字」。

⚠️ 他在「按上游亮度成比例」那里顺带提了赫布理论(neurons that fire together wire together),但原文自己就说这个类比并不严格(未训练的网络并没有在「想」那个答案),所以只记在这儿,不画上图。

⭐ Ⓑ 与 §1.8 的那处接头(以及折起来那张与 §1.6 的那处),原文都没有,是本讲自己的合题 —— 3B1B 讲的是「反向传播在干嘛」,本讲要的是「它为什么这么费显存」。

展开:一根权重的梯度,正比于上游有多亮 —— 它回答的是另一个问题:「改哪根线最划算」。 结论一句话:答案不在反向里,在前向里 —— 而这正是 1.6「激活扔不掉」的根子, 想先看的展开
一根权重的梯度,正比于上游有多亮 两根线加粗同样多,回报差二十倍 —— 而「回报有多大」就是「这根权重的梯度有多大」 上游亮 上游暗 回报之比 = 亮度之比 同样加粗 0.1,接在亮的那根上回报大 20 倍 这一格另开一根轴:哪根线改起来最划算 4.0 上游很亮 +0.1 粗 0.2 上游很暗 +0.1 粗 输出 输出涨 +0.40 输出涨 +0.02 同样的力气 回报差 20 倍 —— 正好是亮度之比 说的就是梯度:一根权重的梯度 = 上游那一刻的亮度 × 下游传来的责任。 这一格画的是前面那个乘数。 所以「改哪根线最划算」这个问题,答案不在反向里,在前向里 —— 它由那一刻的亮度决定。 而那个亮度,是前向算出来、必须被存下来的。整本显存账的根子,就在这一句上。
一根权重的梯度 = 上游那一刻的亮度 × 下游传来的责任 —— 这一格画的是前面那个乘数:两根线加粗同样多(+0.1),上游亮 20 倍,回报就大 20 倍。
落点不在「怎么改权重」,在「改哪根线最划算」这个问题的答案不在反向里,在前向里 —— 它由那一刻的亮度决定,而那个亮度是前向算出来、必须被存下来的。「激活扔不掉」的根子就在这儿(1.6)。
出处与口径

📌 「改权重要按上游亮度成比例,回报最大」取自 3Blue1Brown《What is backpropagation really doing?》官方讲义("adjust the weights in proportion to their associated activations")—— 图是我们自己重画的。

⚠️ 他在这里顺带提了赫布理论(neurons that fire together wire together),但原文自己就说这个类比并不严格,所以只记在这儿,不画上图。

⭐ 「所以激活扔不掉」那一步是本讲自己的合题,3B1B 讲的是「反向传播在干嘛」,本讲要的是「它为什么这么费显存」。

1.2b 对的推上去、错的也压下去 —— 那是同一个动作

✋ 这里现场问过一个很要紧的问题,而它照出一个洞: 反向的时候,是「把对的推上去、错的也各自推下去」,还是「只推对的那个, 其余是副作用」?

答案:都做 —— 而且是同一个动作。

那颗种子是「你猜的 − 正确答案」,它是一整排数, 词表上每一个字都占一格:
正确那格是 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)。

一整批 6,300 万个 loss(15,360 条 × 4,095 个位置),怎么变成一份梯度 现场问:「错的那几个要不要推向 0,还是只推对的那个、其余算副作用?」—— 答案是:都做,而且是同一个动作 Ⓐ 一个位置 Ⓑ batch=1 Ⓒ batch=2 Ⓐ 先只看一个位置 —— 这一格里,词表上的每一个字都拿到了自己的那一份 正确答案是「的」,网络给它打了 0.40;剩下 0.60 分散在别的字上 0.40 的 -0.60 0.20 了 +0.20 0.20 在 +0.20 0.10 和 +0.10 0.10 有 +0.10 灰柱 = 网络现在给的概率 | 下面那个数 = 这一格的梯度 = 你猜的 − 正确答案 负号 = 把这一格推高 · 正号 = 把这一格推低 所以那一问的答案是: 都做,而且是同一个动作 错的那几个不是副作用 —— 每一个都有自己那一份, 而且力度正好等于它现在占了多少:0.20 那个被推的劲, 是 0.10 那个的两倍。 而这一排数加起来正好是 0(−0.60 + 0.20 + 0.20 + 0.10 + 0.10) 概率总量是守恒的 —— 所以这不是一次加分, 是一次再分配。 剩下那 129,275 个字概率≈0,梯度也≈0 —— 它们本来就没占地方 Ⓑ 再放大到一整条序列(batch = 1) —— 上面那一整套,每个位置都来一遍 一条长 4,096 的序列只有 4,095 个预测 —— 最后那个字没有「下一个」;而下面每个位置底下那支箭,是一束,不是一根 …… 4,095 个位置,每个位置都有一份整个词表那么长的意见(129,280 个数) 那支箭不是「这个位置往哪边推」 —— 到了这一层,已经没有单一的方向了 一个位置的那份意见 词表 129,280 行,每一行都往自己那边拉一把 叠起来 一支合力:7,168 维 所以「一个方向」这个说法是错的: 词表上每一行都拽着一个 7,168 维的向量, 129,280 行全部叠加,才得到这一支箭。 它到底怎么叠出来的 —— 下一节专讲。 batch = 1 一共 529,401,600 个数当种子 每一份都÷ 4,095 Ⓒ batch = 2 —— 唯一的变化是分母,从 4,095 变成 8,190 「平均」发生的全部地方就在这个除法上,而且它在种子那一步就做掉了 序列 1 …… 共 4,095 个位置 序列 2 …… 共 4,095 个位置 8,190 份意见,每一份先 ÷ 8,190,再全部累加进同一套 671B 的参数梯度 所以「每个 token 各跑一遍反向、再把 671B 个梯度平均」和「先把 loss 平均、只跑一次反向」—— 算出来完全一样(求导是线性的),只是后者便宜 8,190 倍。 一句话记住这张图 「把对的推上去」和「把错的压下去」是同一个动作 —— 那一排数加起来正好是 0,它是一次再分配,错的那些不是副作用。 loss 按 token 平均(不是按序列),但反向并不从那个标量出发 —— 它从一个「每个位置 × 整个词表」的张量出发,每个数都是「你猜的 − 正确答案」÷ 总数;而一个位置往 回传的是一支合力(129,280 行各拽一个 7,168 维向量叠出来的),不是一个方向。
专答现场那一问:错的那几个要不要也推下去?—— 要,而且跟「把对的推上去」是同一个动作。
Ⓐ 一个位置上,词表每一格都拿到自己那一份「你猜的 − 正确答案」;负号推高、正号推低,力度 = 它现在占了多少,而这一排数加起来正好是 0 —— 它是一次再分配,不是一次加分。
Ⓑ 一条序列有 4,095 个这样的位置(不是 4,096);Ⓒ batch 从 1 变 2,唯一的变化是那个分母 —— 「平均」发生的全部地方就在这个除法上。
出处与口径

口径来自 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 那一步被抹掉 ——  它们是在后面一层层的矩阵乘里才被累加起来的。

1.2c 一个位置的诉求,怎么一路变成 6,710 亿个数

⛔ 这里有一处特别自然、但会把整条链理解反的误解, 必须单独说:不同位置的那个 7,168,不能先加起来。

很容易这么想:一条序列 4,095 个位置、每个位置一个 7,168 长的向量, 那就把它们加起来求个平均,再拿这个平均往前传。 —— 这一步做了,整份梯度就错了。

因为第 i 个位置的责任,只能配第 i 个位置的输入。 权重梯度是「每一行各乘各的,乘完再加」;先把 δ 加起来再乘, 等于把第 3 个位置的责任配到了第 900 个位置的输入上 —— 那是另一个量。

所以「求和」这件事确实发生,只是不发生在 δ 上, 发生在权重梯度上,而且每一层各结一次账。 δ 从头到尾是一张「位置 × 宽度」的表, 位置那一维一路保留到最后。

一个位置的诉求,怎么一路变成 6,710 亿个数 现场自己把这条链复述了一遍,前四步全对; 第五步「把那些 7,168 加起来」—— 那一步不能加,而它恰好最要紧 Ⓐ 折成一股力 Ⓑ 位置维要保留 Ⓒ 加错了会怎样 Ⓓ 真正相加的地方 Ⓐ 第一步:词表那么长的诉求,折成一个方向 词表里每一个字,在模型内部都占一个方向;按各自那个数加权,合成一股力 129,280 个数 每个字一格 =「你猜的 − 正确答案」 概率≈0 的那些也在里面,只是它们那一格≈0 经过 输出那张大表 (129,280 × 7,168) 7,168 个数 这个位置的责任(δ) 它是一个方向,不是一个目标值 这一步在干什么?合力。 像五个人拉同一个铁环:「的」往这边拽 0.60, 「了」「在」各往外推 0.20,「和」「有」各 0.10。 环最后只朝一个方向动 —— 那个合力,就是 δ。 所以「只管那个 −0.60」是不行的: 只说「往北走」,和说「往北走、同时离那三个人远点」—— 走出来的路线不一样。 Ⓑ 一条序列:4,095 个这样的向量,排成一张表 是 4,095 不是 4,096 —— 最后那个字没有「下一个」。 而这张表的「位置」那一维,要一路保留到最后 位置 1 位置 2 位置 4,095 宽 7,168(每个位置的 δ) 高 4,095 一行 = 一个位置的那股合力 batch = 2 就是两张这样的表叠起来 8,190 行 × 7,168 列 每一行在生出来的那一刻就已经除过 8,190 了 —— 「平均」那个除法,早在种子那一步就做掉了。 Ⓒ 现场那第五步:把这些 7,168 加起来 —— 这一步不能做 因为每一行的责任,必须配它自己那一行的输入 ❌ 先把 4,095 行加成一行,再往回传 (所有 δ 加起来)⊗(所有输入加起来) 这样一加,「第 3 个位置的责任」就被配到了 「第 900 个位置的输入」上。 而「谁在什么上下文里提的要求」 正是这份梯度全部的信息 —— 加掉就没了。 它是另一个量,跟正确答案不相等。 一行配一行,乘完之后才加 Σ(第 i 行的责任 ⊗ 第 i 行的输入) 每个位置各乘各的,得到各自那一份 对权重的贡献 —— 这些贡献才相加。 所以「相加」这件事确实发生, 只是它不发生在 δ 上,发生在权重梯度上。 而且每一层各自发生一次。 Ⓓ 于是整条链是这样的 —— 位置维一路走到底,每层顺手结一次账 一个位置 129,280 个数 词表那么长的诉求 折一次 7,168 个数 合力 = 这个位置的 δ 一条序列 4,095 行 排成一张表,行不相加 穿 61 层 每层一次 δ 配本行输入 → 权重贡献 结账 6,710 亿个数 各层各权重,贡献求和 所以现场说的「无数个 7,168 加起来变成一个平均的期望」—— 「加起来」对,「在 7,168 这一层加」不对。 加法要等到最后一格才发生,而且加的是对权重的贡献,不是 δ 本身。 两句话记住这张图 δ 从头到尾是一张「位置 × 宽度」的表 —— 位置那一维一路保留,因为第 i 个位置的责任只能配第 i 个位置的输入。 求和发生在权重梯度上,每一层各结一次账 —— 所有位置、所有样本对同一个权重的贡献加起来,才是这一步要挪它的那个数。
整条链,从一个位置一直走到 6,710 亿个数。—— Ⓐ 词表那么长的诉求先折成一股合力(每个字占一个方向,按各自那个数加权);Ⓑ 一条序列就是 4,095 行这样的合力,排成一张表。
⛔ Ⓒ 是这张图的机关:那些行不能先加起来 —— 第 i 行的责任只能配第 i 行的输入,先加就错配了。
Ⓓ 所以求和确实发生,但发生在权重梯度上,而且每层各结一次账;位置那一维一路保留到最后。
出处与口径

线性层:权重梯度 = Σ_i(δ_i ⊗ x_i),沿位置维收缩;而对输入的梯度是逐位置的,不收缩。⚠️ 一个诚实的例外:attention 会让不同位置的 δ 互相混合 —— 因为前向时位置之间本来就互相看;

但那是 attention 的结构造成的,不是「求平均」,线性层那一路位置维严格独立。词表 129,280、宽度 7,168、层数 61 取自 DeepSeek-V3 配置。

1.2d 「结账」—— 权重梯度是在哪一步相加的

⭐ 再往下一层:「结账」到底发生在哪一步? —— 现场问得很准:「是每个函数各做一次,还是把这一层算完再做?」

是前者:每一个带权重的算子各结一次账, 而且结账和往前传互不等待。

一个带权重的算子收到 δ 之后,做的是两件事:
① 结账 —— 把 δ 和这一层的输入相乘、沿位置求和, 得到这块权重的改动。位置那一维在这一笔里被吃掉了,这笔账不往下传。
② 往前传 —— 把 δ 乘上权重本身,得到上游该收到的责任。 位置那一维在这一笔里完整保留。

⭐⭐ 而这两笔,正是 1.6 那句 「反向要付两笔乘法,所以训练比推理贵三倍」里的那两笔。 —— 同一张 δ 表,两种收缩方式:一笔把位置维吃掉,一笔把位置维留着。

⛔ 两个特别容易错的地方: ① 权重梯度的桶是固定大小的,不随 token 数变大 ——  四千个位置只是往同一个桶里加了四千笔;这就是为什么整份梯度是 「每个参数一个数」,而不是「每个 token 一套参数」。
② 每层只加,不除。那个「÷ 总数」在最开头的种子里就做过一次了 —— 每层再除一遍的话,61 层就除了 61 次。 所以严格说这一步叫「求和」,不叫「求平均」:平均早就摊进每一笔里了。

顺带确认现场推到的那一步: 线性层的权重梯度只用本位置的输入 ——  而前面那些 token,是在前向的 attention 里就已经被搅进这个输入了, 不是反向的时候才被拉进来的。

「结账」—— 权重梯度是在哪一步相加的 现场问:「每一个函数都做一次,还是把这一层算完再做?」—— 每一个带权重的算子各结一次,而且不等待 Ⓐ 两笔乘法 Ⓑ 一层里谁结账 Ⓒ 桶是固定大小的 Ⓐ 一个带权重的算子,反向时做两件事 —— 这就是第一节说的那两笔乘法 同一张 δ 表,两种收缩方式:一笔吃掉位置维,一笔留着它 | 例子是真实的算子:专家 up 投影,7,168 进 → 2,048 出 δ (出口那一侧的责任) 4,095 行 × 2,048 列 2,048 = 这块权重的出口宽 —— 专家的「腰」 x (入口那一侧的输入) 4,095 行 × 7,168 列 7,168 = 残差流的宽度 而两张表共有的 4,095 = 位置数 (4,096 长的序列有 4,095 个「下一个字」) ① 结账 —— 位置维被吃掉 δ 与 x 相乘,沿着「位置」求和 得到一张 2,048 × 7,168 的改动表 —— 跟这块权重一样大 4,095 这个数,在这一笔里消失了 —— 所有位置对这块权重的意见, 在这里合成了一个数。 这一笔不往下传 —— 它就留在这块权重的账上,等更新那一刻。 ② 往前传 —— 位置维留着 δ 乘上权重本身 得到一张还是 4,095 行的新表 每个位置仍然各是各的 —— 它就是上一层要收到的那份责任。 位置这一维,一路留到最前面。 所以第一节那句「反向要付两笔乘法,所以训练比推理贵三倍」—— 那两笔,就是这两笔。 Ⓑ 一层里有十几个算子 —— 带权重的各结各的账,不带权重的只是路过 回答现场那个二选一:是「每个算子一次」,不是「一层算完再一次」 归一化 结账 Q/K/V 投影 结账 注意力打分 只路过 softmax 只路过 加权求和 只路过 输出投影 结账 残差相加 只路过 归一化 结账 路由打分 结账 专家 gate/up 结账 SwiGLU 相乘 只路过 专家 down 结账 残差相加 只路过 δ 从右往左走,每碰到一个橙色的就顺手结一次账 橙色的:自己有参数,所以有账要结。 灰色的:自己没有参数(打分、softmax、逐元素相乘、加法),只把责任改个形状递过去。 所以「一层算完再平均」是没有的 —— 根本没有任何东西需要等一层走完。 MoE 那几格还有一条:一个 token 只往它选中的那几个专家的账上加,没被选中的专家这一步收不到任何东西。 上面这一排是示意:真实的 MLA + MoE 一层比这还多几格,但「谁结账」这件事一模一样。 Ⓒ 每块权重有一个固定大小的桶 —— 所有位置往同一个桶里加 这就是为什么整份梯度是「每个参数一个数」,而不是「每个 token 一套参数」 位置 1 的那一笔 位置 2 的那一笔 位置 3 的那一笔 位置 4 的那一笔 位置 5 的那一笔 位置 6 的那一笔 位置 7 的那一笔 …… 共 4,095 笔(batch=2 就是 8,190 笔) 这块权重的桶 2,048 × 7,168 个数 大小固定,永远不变 两条最容易搞错的: ① 桶不会因为 token 多就变大 —— 四千个位置只是 往同一个桶里加了四千笔,桶还是那么大。 ② 每层只加,不除。那个「÷ 总数」在最开头的种子里 就做过一次了 —— 每层再除一遍的话,61 层就除了 61 次。 所以严格说这一步叫求和,不叫求平均 —— 平均早就摊进每一笔里了。 这张图的两句话 一个带权重的算子,反向时做两件事 —— 「δ 配本位置的输入、沿位置求和」结出权重梯度(位置维被吃掉);「δ 乘权重」结出传给上游的责任(位置维留着)。那就是第一节那 两笔乘法。 所以结账是「每个带权重的算子各一次」,不是「一层算完再一次」 —— 而且桶的大小固定、每层只加不除。
这一讲被追问得最深的一处,也是整节的枢纽。—— Ⓐ 一个带权重的算子反向时做两件事:一笔沿位置求和(结出权重梯度,位置维被吃掉)、一笔逐位置保留(结出传给上游的责任)。那就是 1.6 说的那两笔乘法。
Ⓑ 一层里带权重的各结各的账,不带权重的只是路过 —— 没有「一层算完再平均」这回事。
Ⓒ 桶的大小固定、每层只加不除。另外,结账谁也不用等谁 —— 这正是多卡训练能把通信藏进计算里的原因(那一格折在下面)。
出处与口径

⭐ 现场自己推到的那一步是对的:「我当前这个 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 层。

展开:结账不用排队 —— 谁也不用等谁 —— 这一格在这一讲里不承重,它真正派上用场是在 专题五 · 并行策略:最后几层的账早结完了、前面几层还在算, 那段时间正好拿来把已经结完的那部分传出去 ——  这就是「把通信藏进计算里」。想先看的展开
补一格:结账不用排队 这一格在这一讲里不承重;它真正派上用场是在专题五 · 并行策略 顺序:谁也不用等谁 顺序:一收到责任就能结账,谁也不用等谁 loss 那头 输入那头 算子 1 结账 算子 2 结账 算子 3 结账 算子 4 结账 算子 5 结账 算子 6 结账 而这正是多卡训练能把通信藏进计算里的原因:最后几层的账早就结完了,前面几层还在算 —— 那段时间正好拿来把已经结完的那部分传出去。
结账不用排队:哪一层收到上游传来的责任,哪一层就能立刻把自己那笔权重梯度算掉,谁也不用等谁。⭐ 这一格在这一讲里不承重 —— 它真正派上用场是在专题五 · 并行策略:最后几层的账早就结完了、前面几层还在算,那段时间正好拿来把已经结完的那部分传出去,这就是「把通信藏进计算里」。
出处与口径

⭐ 这一格原本是上一张图的第四格,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。

1.2e 那个「平均」,到底分几层

还有一层要说清:那个「平均」分几层? —— 现场的猜测是:序列内平均一次、本卡跨序列再平均一次、 micro-batch 之间再平均一次、跨卡再平均一次。

「分层次」这个直觉是对的,但实际是 ——  三层加法 + 一次除法。

  • ① 序列内 + 本卡多条序列 —— 这两层其实是同一层。 δ 表的形状是「(本卡条数 × 序列长度) × 宽」, 权重梯度那一次矩阵乘一次就把这一整维收缩掉。
  • ② micro-batch 之间 —— 梯度累积,累加到同一个桶,只加不除。
  • ③ 跨卡(DP) —— all-reduce 求和。
  • ④ 除法 —— 全程只有一次,除以「全局有效 token 总数」。

⛔ 为什么不能每层各除一次?那就成了「平均的平均」。 各层的有效 token 数并不相等(padding、拼接边界、最后一批)——  一旦各自先除,token 少的那一批就被当成跟多的那批一样重。 而它不报错、不发散、曲线看着完全正常。
正确做法:一路只传两个数 —— 「loss 的和」和「token 的个数」, 最后拿前者除后者。

那个「平均」,到底分几层 「分层次」这个直觉对了,但实际是 —— 三层加法 + 一次除法 Ⓐ 以为的 Ⓑ 实际的 Ⓒ 为什么不能各除各的 Ⓐ 很自然会这么想:一层一层各平均一次 序列内 平均一次 本卡多条序列 再平均一次 micro-batch 之间 再平均一次 跨卡 再平均一次 四次除法。而实际上除法只有一次 —— 而且其中有一层,根本不存在。 Ⓑ 实际是这样:加法分三层,除法只有一次 ① 序列内 + 本卡多条 这两层是同一层 δ 表的形状是「(本卡条数 × 序列长度) × 宽」, 权重梯度那一次矩阵乘一次收缩掉整维 ② micro-batch 之间 累加到同一个桶 梯度累积:算一批加一批, 只加不除 ③ 跨卡(DP) all-reduce 求和 每张卡把自己那个桶交出来, 加到一起 ④ 除一次 ÷ 全局有效 token 总数 全程就这一次 所以「加起来」这件事确实分层,只不过每一层做的都是加 —— 除,从头到尾只有一下。 而 ① 那一层要特别说一句:你以为的「序列内平均」和「本卡跨序列平均」不是两步,是同一次矩阵乘 —— 那两维早就拼成一维了。 Ⓒ 那为什么不能每层各除各的? —— 因为那是「平均的平均」 前提:各层的有效 token 数并不相等(padding、拼接边界、最后一批) micro-batch 1 有效 token 100 个 · 这一批的 loss 加起来 200 → 自己平均 2.0 micro-batch 2 有效 token 20 个 · 这一批的 loss 加起来 60 → 自己平均 3.0 ❌ 各除各的 (2.0 + 3.0) ÷ 2 = 2.50 先全加,最后除一次 (200 + 60) ÷ (100 + 20) = 2.17 差 15%。而错的那一边不报错、不发散、曲线看着完全正常 —— 它只是悄悄给每一批换了权重。 病根一句话:先除,就等于宣布「每一批一样重」 —— 可它们的 token 数明明不一样。 所以正确的做法是:一路只传两个数 —— 「loss 的和」和「token 的个数」,最后拿前者除后者。 一句话记住 加法分三层(本卡一次矩阵乘 → 梯度累积 → 跨卡求和),除法只有一次 —— 除以全局有效 token 总数。 一路只传两个数:loss 的和、token 的个数。 任何一层提前做除法,都是「平均的平均」 —— 它不报错,只是悄悄给每一批换了权重。
「那个平均分几层?」—— 三层加法 + 一次除法。Ⓐ 很自然会数成「四层各平均一次」;Ⓑ 实际上「序列内」和「本卡跨序列」是同一次矩阵乘,后面两层(梯度累积、跨卡)都只是加,除法全程只有一次。
Ⓒ 是这张图的机关:每层各除一次就是「平均的平均」 —— 两个 token 数不等的批,错的算法差 15%,而且不报错、曲线看着完全正常。
源码逐行对照折在下面:一路只传「loss 的和」和「token 的个数」,最后除一次。
出处与口径

出处:MaxText 的梯度累积实现 —— 循环里 acc["loss"] += xent_sum、acc["total_weights"] += total_weights,循环外 grads ÷ acc["total_weights"]。

⚠️ 一个例外要说清:辅助损失(MoE 负载均衡这类)反而是除以 micro-batch 个数的 —— 因为它们本来就是「每个 micro-batch 一个平均值」。两套口径,别混。

展开:源码对照 —— 上面那套不是我推的 —— MaxText 梯度累积那段逐行就是这样: 累加的是和不是平均、token 个数另外单独累加、 最后只除一次,而且除的是累加起来的 token 总数(不是 micro-batch 的个数)。 想自己核一遍的展开
补一格:源码对照 —— 上面那套不是我推的 这一格是证据,不是内容 —— 想自己核一遍的看它,讲课时用不上 MaxText 梯度累积 这不是我推的 —— 梯度累积那段源码逐行就是这样 累加的是和,不是平均 acc["loss"] += 这一批的 loss 之和 token 个数另外单独累加 acc["total_weights"] += 这一批的有效 token 数 最后除一次,而且除的是累加起来的 token 总数 梯度 ÷ acc["total_weights"] 注意它除的不是「micro-batch 的个数」,是累加起来的 token 总数 —— 这一手就是用来躲开上面那个坑的。
上面那套「三层加法、一次除法」不是推出来的 —— MaxText 梯度累积那段源码逐行就是这样。累加的是和不是平均;token 个数另外单独累加;最后只除一次,而且除的是累加起来的 token 总数,不是「micro-batch 的个数」—— 这一手就是用来躲开那个坑的。
出处与口径

⭐ 这一格原本是上一张图的第四格,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。

1.3 往回传的不是一个数 —— 这里是最多人卡住的地方

很多人脑子里的画面是「一个梯度值一层一层传下去」。不是这样。

往回传的是一整个张量,形状跟这一层的输出一模一样。 它的含义是:「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×」这个数的人,这两问都答不了。

三倍算力是数出来的 —— 前向一次矩阵乘,反向两次 这一格不讲链式法则,只数乘法做了几次 前向 1 次 反向 2 次 合计 3 次 Ⓐ 把一层摊开 —— 总共只有三次矩阵乘,一次向前、两次向后 只数矩阵乘:norm / 激活函数 / 偏置在这笔账里可以忽略 每个小方格都一样大 —— 形状不同是因为格子的个数不同(示意:位置 T = 6 格 · 进来 d_in = 4 格 · 出去 d_out = 3 格)。转置 = 同一批方格换个排法。 ① 前向 算这一层的输出 输入 X 6 × 4 × 权重 W 4 × 3 = 输出 Y 6 × 3 → 交给下一层 ② 反向 · 权重梯度 算「我这块权重该怎么改」 输入 Xᵀ 4 × 6 × 上游责任 dY 6 × 3 = 权重梯度 dW 4 × 3 → 交给优化器 这一块不是新算的 —— 是 ① 里那个输入被存下来了 ③ 反向 · 传给下游 算「前一层该收到什么」 上游责任 dY 6 × 3 × 权重 Wᵀ 3 × 4 = 新的责任 dX 6 × 4 → 交给前一层 三次乘法的乘加次数一模一样(都是「位置数 × 进来的宽度 × 出去的宽度」) —— 所以 1 + 2 = 3 不是个比喻,是数出来的。 ② 那块虚线的,就是激活扔不掉的全部原因。 · 那两个 ᵀ 是怎么回事?另配了一格专讲它,在下面折叠着。 Ⓑ 全图的钥匙:一条线进来,分成两支 不是「反向比较慢」这种含糊说法 —— 是两支,而且一支都省不掉 上游传来的责任 δ (就这一个东西) × 前向存下来的输入 一次矩阵乘 这块权重的梯度 交给优化器 到此为止 这是这一步真正要的东西 · 到这儿这一支就不往前了 × 这一层的权重 一次矩阵乘 新的责任 δ 喂给前一层 接着往左走 链条靠它 · 少了它,再往前就断了 两支乘的东西不一样(一支乘输入、一支乘权重)—— 所以合并不了;一支断了链条就断,一支没了这一层就白算。一个都省不掉,这就是那个 2。 Ⓒ 于是这笔账就封口了 推理 只有前向 一遍 = 1× 训练 前向 + 反向 一遍 一遍 一遍 = 3× 训练 + 全量重算 一遍 一遍 一遍 一遍 = 4× 「一遍」= 一次走完整个网络的矩阵乘量。推理只买一遍,训练要买三遍 这张图顺带回答了另外两个常见疑问 「为什么训练比推理贵这么多」 —— 算力上就是这个 3 倍; 但真正拉开差距的不是它,而是显存里那一整条从头挂到尾的激活(下一张图)。 「反向能不能只算一次」 —— 能,如果你不打算继续往前传(比如只微调最后一层)。 那种情况下第 ③ 次确实可以省掉。 但别把它安到冻结层头上 —— LoRA 那种每层都挂 adapter 的,第 ③ 笔一笔都省不掉;它省的是第 ② 笔(权重梯度)。见 3.8。
Ⓑ 是这张图的钥匙 —— 反向不是「比较慢」,是它要回答两个不同的问题:我这块权重该怎么改、上游该收到什么。两个问题,两次乘法。
⛔ Ⓐ 第②步那句「用前向存下来的输入」是整个专题的枢纽 —— 激活扔不掉、以及下一节那笔交易,全挂在这一句上。
出处与口径

⚠️ 「3 倍」是矩阵乘口径的常用近似:只数 matmul,忽略 norm / 激活函数 / 偏置 / 通信。真实 step 里这些占比不大,但不是零

⛔ 图上第 ② 步那句「用前向存下来的输入」是整个专题的枢纽 —— 激活扔不掉、以及下一节那笔重算交易,全都挂在这一句上

展开:那两个「ᵀ」是怎么回事 —— 结论两句:转置不花算力(行变列、列变行,一个数都没动, 真实实现里常常连搬都不搬);而非它不可是形状逼出来的 ——  dW 得跟 W 同形、dX 得跟 X 同形,转置就是唯一摆得上的方式。想看推演的展开

上面那张图里立着两个 ᵀ: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 说的那笔「结账」: 位置维在这里消失,所以这一笔不往前传。

补一格:转置 结论两句:转置不花算力(行列对调,一个数没动);而非它不可是形状逼出来的 先说是什么,再说为什么非它不可 那两个「ᵀ」是怎么回事 —— 转置不是多算了一步,是同一张表换个方向读 分两层:先说它是什么,再说为什么非它不可 ① 它是什么 行变列、列变行 —— 一个数都没动 1 2 3 4 5 6 A (2 行 3 列) 转置 1 4 2 5 3 6 Aᵀ (3 行 2 列) 黄色那一行,转完变成了黄色那一列。 数一个没少、值一个没变 —— 变的只是「从哪个方向读」。 所以它不花算力,真实实现里常常连搬都不搬。 ② 为什么非它不可 矩阵乘有一条死规矩:左边那个的列数,必须等于右边那个的行数 ① 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(位置) —— 乘完它就被吃掉了 要得到一块跟 W 同形的结果 —— 只有这一种摆法 ③ dY [T × d_out] × Wᵀ [d_out × d_in] = dX [T × d_in] 中间对上的那一维是 d_out —— 乘完它就被吃掉了 要得到一块跟 X 同形的结果 —— 只有这一种摆法 所以转置不是一步额外的运算:你要的结果形状一旦定死 —— dW 得跟 W 同形、dX 得跟 X 同形 —— 转置就是唯一摆得上的方式。 换成人话:前向问的是「输入怎么混成输出」;③ 问的是反过来那个问题 —— 「输出的责任怎么分回输入」。 同一张 W,换个方向读,写出来就是 Wᵀ。 · 而 ② 里 Xᵀ 的作用是把「位置」摆到中间去让它被吃掉 —— 这就是 1.2d 说的那笔「结账」。
结论两句。① 转置不花算力:行变列、列变行,一个数都没动(真实实现里常常连搬都不搬)。② 而非它不可是形状逼出来的:矩阵乘要求「左边的列数 = 右边的行数」,而反向要的两块结果形状是定死的 —— dW 得跟 W 同形、dX 得跟 X 同形,于是转置是唯一摆得上的方式。
出处与口径

⭐ 这一格原本是上一张图的 Ⓑ,2026-09-23 拆成独立一张—— 为的是让课件那边能把它折叠起来。

⭐ 顺带说清图上那根橙色的线(现场也问了): 它表示 ② 里用的那块 Xᵀ 不是新算出来的 ——  就是 ① 前向时那个输入,被存下来了。 这根线就是「激活为什么扔不掉」的全部答案: 前向做完不能把 X 丢掉,因为反向算 dW 还要拿它当来料。 箭头顺着流向画:① 存下来 → ② 取用。

跟着数走一遍 —— 三个节点,前向一遍,反向一遍 前面讲的全是道理。道理点头很容易,跟着数走一遍才知道自己卡在哪 黑字:前向的值 红字:反向的梯度 Ⓐ 式子是 f = (a + b) × c 同一条线上两个数:上面黑的是前向算出来的,下面红的是反向传回来的 a = 2 梯度 4 b = -3 梯度 4 c = 4 梯度 -1 + × f = -4 梯度 1 q = a + b -1 ↤ 4 前向从左往右走一遍,反向沿同一批线从右往左走一遍 —— 红字就是「这个东西变一点,f 变多少」 Ⓑ 常见的门只有三种脾气 —— 而这三种脾气就是三种连线的形状 不用背公式 —— 线越粗梯度越大,虚线表示负的,三张图的骨架完全一样,只看红线怎么走 + 加法门 像一个分发器 a b + 上游 4 4 4 两条一样粗 —— 原样各拿一份 × 乘法门 像一个交换器 a b × 上游 1 4 -1 换 两条交叉 —— 各自拿对方的前向值 max 门 像一个路由器 a b max 上游 4 4 ✕ 0 一条断了 —— 全给赢的那个 Ⓒ 而中间那个门,正是这一整讲的账单的源头 别跳过这一格 —— 后面所有关于「激活」的话都从这儿来 × 反向要乘它 所以扔不掉 就这一个门 每一层 每一步 ……于是变成这么一片 每一个小方块都是同样一件事 —— 某一层某一步存下来的那个前向值 所以激活不是「框架顺手缓存的东西」 —— 是反向的数学要求它在场 所以「重算」那个决定,在这张小电路上也说得通 把 q 扔掉,反向要用的时候临时把 a + b 再加一遍 —— 一次加法,换一个数的存储空间。这就是重算,整套逻辑一个字都不用改。 而这也解释了为什么加法便宜、矩阵乘贵:重算一个加法门几乎不要钱,重算一个矩阵乘要把那一大坨乘法再做一遍。
这是整讲唯一一处「小到能用眼睛跟着数走」的地方 —— 同一条线上两个数:黑的是前向,红的是反向。
Ⓑ 那三个门不用背:加法是分发器、乘法是交换器、max 是路由器。记住脾气就能手推任何一张电路。
⛔ Ⓒ 别跳过 —— 乘法门反向要用前向的值,而这就是整讲那张激活账单的源头:激活不是框架顺手缓存的东西,是反向的数学要求它在场。
出处与口径

📌 「电路图 + 三个门(分发 / 交换 / 路由)」这个讲法取自 CS231n 的反向传播讲义 —— 图是我们自己重画的,数也是自己挑的。

⭐ 图上每个数都可以自己验:脚本里带 assert —— a 和 b 的梯度都是 4、c 的梯度是 −1,对不上就不让构建。

1.3b 前面猜错了,会不会影响后面 —— 训练时不会

这一问是现场推出来的,而且推对了: 训练的时候,前面那些 token 猜没猜对,完全不影响这个位置。

因为每个位置的输入永远是真值,不是模型自己刚猜出来的那个字。 这件事有名字:teacher forcing。

⛔ 但有一处要说准:这不是「一个 token 一个 token 地去查」。

训练里 Q / K / V 一把算完、注意力一把做完, 所有位置同时。
—— 而这正是训练和推理最大的形态差别: 推理才是真的一个一个来,因为下一个字得等上一个字生成出来。

顺带一个小口径:「查前面的 K 和 V」严格说是 「前面和自己」—— 因果掩码允许看到自己这个位置,只是不能看后面。

前面猜错了,会不会影响后面 —— 训练时不会 这件事有名字:teacher forcing —— 每个位置的输入永远是真值,不是模型自己刚猜的那个字 Ⓐ 训练 Ⓑ 推理 Ⓒ 代价与取舍 Ⓐ 训练:输入那一排,从头到尾都是真值 而且所有位置同时算完 —— 一次矩阵乘,不是一个一个来 真值 今 天 天 气 很 好 猜下一个字 天 天 空 ✘ 猜错了 很 好 。 ✘ 这条路不存在 所以「错误不会向后传」 下一个位置拿到的输入,来自上面那一排真值, 不是来自刚才那个错的预测。 每个位置各算各的,互不污染 —— 所以 4,095 个位置可以一次全算完。 Ⓑ 推理:前文全是它自己生成的 而且必须一个一个来 —— 下一个字得等上一个字出来 今 天 天 空 很 蓝 ✘ 从这儿错 后面每一个,都建立在那个错的上面 训练和推理,喂的东西不一样 训练:真值 · 推理:它自己的输出 训练:一次算完 · 推理:串行 4,095 次 这是训练和推理最大的形态差别。 Ⓒ 代价有个名字:曝光偏差(exposure bias) 训练时它从来没见过自己的错误 它一直活在一个「前文永远是对的」世界里 可推理时前文全是它自己生成的。 一旦错一个,它就走进了一个 训练时从没见过的分布 —— 而在那儿它没有任何经验。 这就解释了:长文本生成为什么会越跑越偏。 不是它突然变笨了,是它走进了自己没被训练过的地方。 那为什么还这么干? ① 并行 —— 用自己的预测喂自己的话,第 t 个位置 得等第 t−1 个算完,4,095 个位置就得串行 4,095 次。 ② 早期不发散 —— 刚开始模型猜得一塌糊涂, 拿它自己的输出喂自己,一步就飞了。 所以这是一笔明知有代价、仍然划算的交易。 两句话记住 训练喂真值、推理喂自己 —— 所以训练时「前面猜错了」污染不到后面,而且 4,095 个位置能一次算完;推理只能一个一个来。 代价是曝光偏差:它训练时没见过自己的错误,所以推理时一旦错一个,就进了没被训练过的分布 —— 长文本越跑越偏,根子在这儿。
训练喂真值、推理喂自己 —— Ⓐ 训练时那条"预测 → 下一格输入"的路根本不存在,所以「前面猜错了」污染不到后面,而且所有位置能一次算完;Ⓑ 推理时前文全是它自己生成的,错一个,后面每一个都建立在那个错的上面。
Ⓒ 代价叫曝光偏差:它训练时没见过自己的错误 —— 长文本越跑越偏,根子在这儿。那为什么还用?因为并行那个好处太大。
出处与口径

出处(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。

1.4 为什么偏导数一出现,这件事就变容易了

因为偏导数是局部的。

⛔ ❓ 可这句话第一遍听完,通常会立刻冒出一个反对意见 —— 而且那个反对意见是对的。

「一个权重要影响到 loss,中间穿过的不是一个整数的乘,是一整个矩阵; 而且它的影响还取决于同一层里横着的那些参数 —— 它们彼此之间还有影响。 这么牵一发动全身,凭什么算得出来?」

这两条都成立,而且比听起来还要严重一点:

  • 横向是「加」在一起的。同一层里喂给同一个出口的那些权重, 它们的影响先加进同一个数。
  • 而那个出口往下走,分量又取决于别的出口。因为下一层要把它们 混在一起 —— 所以「牵一发动全身」不是修辞,是字面意思。
Ⓐ 「导」就是引流 —— dērīvāre = de(从…)+ rivus(河流) 左边那条切线的斜率,就是右边那条曲线在同一横坐标上的高度 输入 原来这条河 输入 → 输出 输入 引出来这条 动一格 → 动几格 切线斜率 1.2 高度 1.2 同一个数 左边是斜率,右边是高度 Ⓑ 「偏」不是偏差 —— 是只松开一个,其余全部夹住 partial = 求导这件事只做了一部分:一次一个变量 w1 w2 w3 w4 w5 w6 w7 w8 w9 9 个旋钮 其中 8 个被夹住 9 维的问题当场塌成一维 —— 偏导数又变回了普通导数 Ⓒ 那把扇子,折进了一个数 —— 这才是 partial derivative 的神奇之处 左边是「复杂是真的」,右边是「而它只要两个数」 w 要算它的梯度 同层横向的那些 在这儿是「加」进来 第 2 层 第 3 层 第 4 层 才走 3 跳,已经 216 条路 真模型 60 层 × 7,168 宽 —— 路径数是个 232 位数 全部折进去 来料 x 前向那一刻存下的 × 责任 δ 反向传回来的 = w 的梯度 那把扇子没有被忽略 —— 它已经在 δ 里面了 反向那一趟是按层一次算完的,不是按参数两两去算的 复杂没有消失 —— 它被「只付一次」了 一个权重影响 loss 的路径多到写不下,可算它的梯度只要两个数:前向存下的那个输入、反向传来的那个责任。—— 中间所有的横向混合与下游分叉,都已经在算 δ 的时候按层 一次做掉了。 代价也很清楚:参数两两之间的相互作用(二阶导)故意没算 —— 每两个参数就有一个数,存不下。而「故意不算」的代价,就是必须小步走—— 这就是学习率存在的理由。
Ⓒ 是这张图的主菜 —— 它回答的是那个「听起来无解」的问题:一个权重影响 loss 的路径多到写不下,那它的梯度凭什么算得出来?
左边先让你看见复杂是真的:同层别的权重先「加」进同一个出口,再往下一层层散开,才 3 跳就 216 条路。右边是同一件事的另一种画法 —— 两个格子相乘。中间那根箭头就是全部答案:那把扇子已经折进 δ 里面了。
Ⓐ 顺带把名字讲清楚:derivative 来自拉丁语「从一条河里引一股水出来」—— 图上那根虚线是可验证的:左边的切线斜率 = 右边的曲线高度。Ⓑ 的「偏」是夹子不是偏差:松开一个、夹住其余,N 维当场塌成一维。
出处与口径

📌 词源: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 传的是前者。

❓ —— 那「乘起来」之后会怎样? 这一问有一个非常出名的答案,而它是链式法则最直接的后果。

一路乘下去会怎样 —— 梯度消失,和梯度爆炸 上一格说「把 61 个小导数按顺序乘起来」—— 这一格说乘起来之后发生了什么 每层 ×0.8:消失 ×1.0:刚好 ×1.2:爆炸 Ⓐ 同一个 60 层的网络,只改「每层的兑换率」—— 三条线都是真乘出来的 横轴左边是靠输入的层,右边是靠输出的层;纵轴是那一层拿到的梯度有多大 1 0 第 1 层(最靠输入) 第 60 层(最靠输出) 冲出画面 这条贴在轴上 —— 不是画漏了,是真的小到画不出来 Ⓑ 换一根对数轴才装得下 —— 两头差了 10 个数量级 而那两个兑换率只差两成 10^-6 10^-4 10^-2 10^0 10^2 10^4 每层 ×0.8 ≈ 1.9 × 10⁻⁶ 每层 ×1.0 = 1 每层 ×1.2 ≈ 4.7 万 相差 10 个数量级 所以被指数放大的不是梯度,是「每层偏离 1 多少」那个微小的偏差 —— 偏一点点,乘六十次就回不来了。 Ⓒ 那「每层的兑换率」从哪来 —— 其中一截是激活函数的导数 这两条是真画的函数曲线,不是示意 导数 输入 → 1.0 0.25 ReLU 的导数 正半轴恒等于 1 sigmoid 的导数,峰值就这么高 sigmoid 的导数最大是多少 σ(1 − σ) 在 σ = ½ 处最大 = 0.25 光这一下,每层就先乘了个 ≤ ¼ 的数 权重那一乘还在外面 —— 所以不能说 「一定衰减四倍」,只能说它先天往下压 这就是为什么 ReLU 一换上来,深网络忽然就训得动了 —— 它把每层那个「先天往下压」的系数,从 ¼ 变回了 1。 这一格只回答「会怎样」和「为什么」—— 治法在本讲后面,各有各的位置 要记的只有一句:链式法则是连乘,而连乘是指数的。所以真正要盯的不是「梯度大不大」,是「每层那个兑换率离 1 有多远」 —— 离一点点,乘几十层就回不来了。 而两头的症状完全不同:消失是静悄悄的(loss 就是不降,前面几层跟没训一样,没有任何报错);爆炸是吵闹的(loss 直接飞掉或者变 NaN)。 所以爆炸好查,消失难查。
链式法则是连乘,而连乘是指数的。同一个 60 层网络,每层兑换率 0.8 还是 1.2 —— 只差两成,最靠输入那层拿到的梯度差了 10 个数量级。
Ⓐ 那条贴在轴上的红线不是画漏了,是真的小到画不出来;Ⓑ 得换一根对数轴才装得下这两头。
Ⓒ 是这一格唯一能当场算清楚的那截原因:sigmoid 的导数最大只有 0.25(σ(1−σ) 的闭式最大值),光这一下每层就先乘了个 ≤ ¼ 的数 —— 而 ReLU 正半轴恒为 1。深网络忽然训得动,就是这么来的。
出处与口径

⭐ Ⓐ 三条曲线、Ⓑ 那两个端点值、Ⓒ 那个 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 步,换算过来就是一千层。

那深层网络凭什么还能训得动 —— 残差的全部秘密就一个加号

那深层网络凭什么还能训得动 —— 残差的全部秘密就一个加号 上一格提出了问题(连乘不是指数塌就是指数涨);这一格是答案 没有残差:连乘 有残差:连加 把一层的出口改一个字 —— 局部导数就从「某个数」变成「1 + 某个数」 只讲这一句;归一化放哪儿、初始化怎么缩,是 6.5 的事 ❌ 没有残差 y = F(x) 每层的局部导数 = 某个数 每层 0.9,61 层连乘 0.0016 (消失) 每层 1.1,61 层连乘 335 (爆炸) 离 1 只差一成,照样塌得彻底 有残差 y = x + F(x) 每层的局部导数 = 1 + 某个数 所有括号都取 1,61 层连乘 1 (不塌不涨) 初始化时 F 很小,所以本来就是 1 + 很小 梯度总有一条不衰减的路,直达任何一层 一句话记住这张图 残差把「乘」换成了「加」。 —— 没有残差时,第 3 层收不收得到梯度,取决于第 4 到 61 层那一整串乘积;有残差之后,各层的贡献是加起来的,某一层学坏了只是少加一项, 不会把整条路乘没。 所以「残差让模型能做深」不神秘:它把每一层的局部导数从「某个数」钉到了 1 附近 —— 而 6.0 那张表里,爆炸和消失的根因正是局部导数偏离 1。
上一张图提出了问题,这张是答案。没有残差:每层局部导数是「某个数」,离 1 只差一成,61 层连乘要么 0.0016(消失)、要么 335(爆炸)。
有残差: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。

这就是全部,剩下的都是它的推论。

  • 连乘里多了一条恒等通路。把 61 层的 ∏ (1 + ∂Fi/∂x) 展开,里面有一项是 所有括号都取 1 —— 而 161 = 1。 不管中间那些权重是大是小,梯度总有一条不衰减的路直达任何一层。
  • 它把「乘」换成了「加」。没有残差时,第 3 层收不收得到梯度, 取决于第 4 到 61 层那一整串乘积;有残差之后,各层的贡献是加起来的 —— 某一层学坏了只是少加一项,不会把整条路乘没。
  • 初始化时它天生就是 1。F 那一支初始化很小(不少实现直接把 最后一个投影置零),所以刚开始每层的局部导数就是 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」已经是它的全部内容。

对数轴让你看得见十个数量级,也让你感觉不到十个数量级有多大。 两条轨共用一根横轴、一根扫描线 —— 所以它们永远在说同一层。
上轨是对数刻度:三条线才刚刚张开,看着「还差不多」。
⭐ 下轨是线性刻度,也就是这些数真实的样子: 第 8 层蓝线就顶出了画框,第 18 层红线已经贴在地上看不见了 —— 而同一层,上轨那把扇子才张开三成。
⛔ 每层只差两成的兑换率,十几层就已经没法放进同一张图里了。 (14 秒无声循环,Manim 渲染,脚本在 tools/manim/。 出框层与消失层都是脚本当场算的,并有断言钉住。)

1.4b 插一节:二阶导到底是什么 —— 以及它跟 Adam 那个「二阶矩」没有关系

展开:二阶导是什么,以及它跟 Adam 的「二阶矩」为什么没关系 —— 这一节是被现场追问撞出来的,不在主线上。 三句结论:二阶导是坡度自己的变化率(一阶导说往哪走,二阶导说这个坡还能保持多久); 最优步长 = 梯度 ÷ 二阶导,那就是牛顿法; 可它是 N² 个数,V3 要十万亿块卡,所以「故意不算」不是偷懒。 ⛔ 而 Adam 那个「二阶矩」跟它没有关系 —— 一个是几何,一个是统计, 中文都带「二阶」纯属巧合。想看细节的展开

上面刚说「我们故意不算二阶导」。可它到底是个什么东西?

一句话:二阶导是坡度自己的变化率。

一阶导(梯度)说的是「你动一格,loss 动几格」—— 坡度。
二阶导说的是「你动一格,坡度变几格」—— 翻译成画面就是 这个地方弯得有多急。

一阶导告诉你往哪走;二阶导告诉你这个坡还能保持多久。 —— 同样是陡坡,一个马上变平、一个一直陡下去, 该迈的步子完全不同;可一阶导看它俩是一样的。

二阶导到底是什么 —— 以及它跟 Adam 那个「二阶矩」没有关系 一阶导告诉你往哪走;二阶导告诉你这个坡还能保持多久 Ⓐ 它是什么 Ⓑ 能干嘛 Ⓒ 为什么不用 Ⓓ 跟二阶矩的区别 Ⓐ 两个参数,梯度一模一样 —— 可它们的处境完全不同 一阶导看它俩没有任何区别;分得开它俩的,只有二阶导 坡度 2 离底 2.00 ① 弯得缓 二阶导 = 1 坡度 2 离底 0.25 ② 弯得急 二阶导 = 8 两个点的坡度完全一样,可一个离底 2.00、另一个离底 0.25 —— 差 8 倍。只看梯度,你分不出这两种处境。 Ⓑ 所以它的用处很硬:最优步长可以算出来 最优步长 = 梯度 ÷ 二阶导 在一条抛物线上,一步到底 —— 不用试,不用调。 上面那两个点:2 ÷ 1 = 2.00 · 2 ÷ 8 = 0.25 而且它正好治那个「拧反了」 灵的旋钮该少拧、钝的该多拧 —— 除以二阶导之后,不同参数才可比。 Ⓒ 那为什么不用? —— 因为它的大小是参数量的平方 多参数时它不是一个数,是一张表:每两个参数之间一个数 存不下 权重本身 1.22 TiB —— 16 块 80 GiB 的卡 这张表 —— 10 万亿块 不是十万块。是十万亿块。 (4.5e+23 个数,按 bf16 算) 也算不动 真要拿它去解,朴素做法是参数量的三次方 拿一台每秒百亿亿次的机器跑 —— 96 亿年 宇宙到现在才 138 亿年。 那台机器是随手设的换算基准,只给量级 所以「我们故意不算二阶导」不是偷懒 —— 它压根不在可能性范围内。 Ⓓ 最后一件事:Adam 里那个「二阶矩」不是「二阶导」 它们中文都带「二阶」,纯属巧合 —— 这是这一讲最容易被中文坑到的一处 二阶导(Hessian) 二阶矩(Adam 的分母) 对谁做 对参数求两次导 对梯度取平方再求平均 得到什么 曲率 —— 这儿弯得多急 这个参数的梯度平常多大 属于哪一路 几何 统计 多少个数 N 的平方 N 同样,「一阶动量」也不是一阶导 —— 它是梯度的滑动平均,那个「一阶」指的是统计上的一阶矩(期望)。 所以 Adam 不是「近似了 Hessian」 —— 它用 2 个 N 个数,换了一条路,而不是去逼近那张 N² 的表。 两句话记住 二阶导 = 坡度自己的变化率 = 这儿弯得多急。一阶导告诉你往哪走,它告诉你这个坡还能保持多久 —— 最优步长 = 梯度 ÷ 二阶导,一步到底。 可它是 N² 个数,存不下也 算不动,所以我们故意不算。 而 Adam 的「二阶矩」跟它没有关系 —— 一个对参数求两次导(几何),一个对梯度取平方求平均(统计)。中文都带「二阶」,纯属巧合。
「二阶导」在这一讲里承重了好几处,却从来没被正面定义过。Ⓐ 两个参数梯度一模一样,可一个离底 2.00、另一个离底 0.25 —— 只看梯度分不出这两种处境;Ⓑ 最优步长 = 梯度 ÷ 二阶导,一步到底。
Ⓒ 可它是 N² 个数:权重 16 块卡,这张表要十万亿块;解它要九十多亿年。所以「故意不算」不是偷懒。
⛔ Ⓓ 是这张图真正的机关:Adam 的「二阶矩」跟「二阶导」没有关系 —— 一个对参数求两次导(几何),一个对梯度取平方求平均(统计)。中文都带「二阶」,纯属巧合。
出处与口径

数都是本脚本现算的: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 本身就是一条抛物线,一步就到底了 —— 这就是「一步到底」这句话的来历。

那深度学习为什么不用?两条,第一条上面已经算过:

  • 存不下也解不动。多参数时那个「二阶导」是 N 的平方个数, 而且你还得求它的逆 —— 那是 N 的三次方。
  • 而且 loss 曲面不是碗形的。在鞍点附近,那张表可能是 「有的方向朝上、有的朝下」—— 这时候牛顿法会朝着鞍点走,甚至朝山顶走。 因为它只管「找导数为零的点」,它不挑那个点是谷底还是山顶。

中间还有一条路叫拟牛顿(L-BFGS 这一类): 不显式造那张表,用最近几步的梯度去近似它的作用。 在传统优化里很好用,但在超大规模 + mini-batch 噪声这种场景下一直没做起来。

📌 出处(现查):牛顿十七世纪先有了类似的做法, 但把它写成今天这个迭代式子的是 Raphson,1690 年 (Analysis aequationum universalis); ⚠️ 两个人当时都只把它用在多项式上。

⛔ 那为什么不用?—— 因为它的大小是参数量的平方。

多参数的时候二阶导不是一个数,是一张表:每两个参数之间一个数。 这张表叫 Hessian。

  • 存不下。权重本身 1.22 TiB,16块 80 GiB 的卡就装下了; 这张表要 10 万亿块。不是十万块,是十万亿块。
  • 也算不动。真要拿它去解,朴素做法是参数量的三次方 —— 拿一台每秒百亿亿次的机器跑,要 96 亿年。 宇宙到现在才 138 亿年。

所以「我们故意不算二阶导」不是偷懒 ——  它压根不在可能性范围内。

⚠️ 那台「每秒百亿亿次」的机器是随手设的换算基准, 只用来给量级,不是在说某台具体的机器。数都在 topic04-fig-second.py 里现算并 assert 住。

✋ 最后一件事,而且这是这一讲最容易被中文坑到的一处:
Adam 里那个「二阶矩」不是「二阶导」。

二阶导(Hessian)二阶矩(Adam 的分母)
对谁做对参数求两次导 对梯度取平方再求平均
得到什么曲率 —— 这儿弯得多急 这个参数的梯度平常多大
属于哪一路几何统计
多少个数N 的平方N

它们中文都带「二阶」,纯属巧合。

这个区别不是学究气 —— 它有一个很硬的后果, 3.5 那个 warmup 就卡在这儿:

Adam 除掉的是「陡」,它除不掉「弯」。

分母是梯度的均方根,所以不管这一步梯度多大,更新量都被拉回 η 的量级 —— 「坡有多陡」这件事,被它归一化没了。 可「坡弯得多急」它从头到尾没算过:手上那 N 个数里,没有这个信息。

所以以后碰到「梯度都被 Adam 处理过了,怎么还会不稳」——  答案就在这一行:不稳不是「陡」造成的,是「弯」造成的,而弯不在 Adam 的账本里。

同样,「一阶动量」也不是一阶导 ——  它是梯度的滑动平均,那个「一阶」指的是统计上的一阶矩(期望)。

那为什么老有人说「Adam 的分母在估二阶导」? 因为效果上确实有某种事后可以建立的联系。 但那是后人回头加的解释,不是发明它的人的思路 ——  详见 3.3b,那一节从三代人各自要治的病讲起。
⭐ 而最能说明问题的是尺寸:Adam 用 2 个 N 个数,换了一条路, 它压根没打算去逼近那张 N² 的表。 这也是为什么它叫「自适应学习率」,而不叫「近似牛顿法」。

1.5 最深的一条:为什么是从后往前

展开:为什么是从后往前算 —— 而不是从前往后 —— 这一节不在主线上:今天没人会问「能不能用前向算梯度」。 一句话结论:右边只有一个数、左边有几千亿个,所以从右边插种子只插一次, 从左边要插几千亿次 —— 按一次前向 1 秒算,代价差约 两万年(1.1 算过)。 想看「为什么插在右边一次就够」再展开

数学上两个方向都成立,算出来的结果一模一样。 区别只有一个 —— 你得把整条链走多少遍。

为什么是从后往前 —— 因为那一头只有一个数 这里的关键不是链式法则怎么乘(乘法从哪头开始都一样)—— 是你得重复几遍 正向:插在输入端 反向:插在输出端 Ⓐ 正向模式 —— 种子插在左边,有几个参数就要插几次 每插一次,就要把整条链从头走到尾一遍 嵌入 第 1 层 第 2 层 … 最后一层 loss 第 1 遍 第 2 遍 第 3 遍 ⋮ 共 6,710 亿 遍 每一遍走完,只拿到一个参数的梯度 —— 因为你这一遍只扰动了它一个 所以它的代价跟参数个数成正比。 6,710 亿个参数,就是 6,710 亿遍整条链。 画成从最左边插只是为了整齐 —— 参数分布在每一层,种子就插在它所在的那一层。不变的是「一个参数一遍」。 Ⓑ 反向模式 —— 种子插在右边,而右边只有一个数 所以只插一次,而且回来的路上每个参数的梯度顺手就到手了 嵌入 第 1 层 第 2 层 … 最后一层 loss 种子 = 1 只有这一个 ✓ 梯度到手 ✓ 梯度到手 ✓ 梯度到手 ✓ 梯度到手 ✓ 梯度到手 走到最左边的时候,6,710 亿个梯度已经全部在手里了 —— 而你只走了一遍。 一路上传的始终是一个东西(那个种子沿途被改写),所以那些巨大的中间雅可比从来不用真的算出来。 Ⓒ 换个看法:反向那一遍,其实就是同一张网倒着走 不是「另一套算法」—— 同样的形状,只有三处换了 W W Wᵀ Wᵀ 前向 反向 同一张网 只有三处换了 这个常数是 σ′(z) 前向那一遍算好的 ① 每条边的箭头掉了个头 ② 同一个 W,转置过来 —— 没有新参数 ③ 节点从「套非线性」换成「乘一个常数」 落点在第 ③ 处:那个常数在前向就定下来了 —— 所以前向算出来的东西必须留在场上,反向才有东西可乘。 Ⓓ 所以规则只有一条,而且它跟神经网络没关系 别把它记成「反向传播永远更好」—— 换个形状它就反过来 从窄的那一头起步。 6,710 亿个参数 → 1 个 loss 输入多、输出少 → 从后往前(就是反向传播) 这就是我们的情况 10 个参数 → 100 万维输出 输入少、输出多 → 从前往后 这时候反向传播反而亏 判据:看到任何一个「要求一大堆偏导」的问题,先数输入多还是输出多 它决定的不是「算得对不对」—— 两个方向算出来的结果一模一样,决定的是你要把整条链走多少遍。 而这正是推理里没有的那一半:推理只有一遍前向,压根不存在「往回走」这个动作,也就不存在「沿途把梯度收下来」这件事。
两排只差一件事:种子插在哪一头 —— 而这一件事,就把代价从「 6,710 亿遍」压到「一遍」。
Ⓑ 里每个算子底下那个 ✓ 是关键:回来的路上顺手就收下了 —— 不是走完再统一算。
Ⓒ 是另一个看法:反向那一遍就是同一张网倒着走 —— 同样的形状,只有三处换了。第三处最要紧:每个节点从「套一个非线性」换成「乘一个常数」,而那个常数在前向就定死了。
⛔ Ⓓ 的反例一定要看:「反向传播更好」是条件成立的,条件就是输入多输出少。
出处与口径

⭐ 这一格是结构,不是数据 —— 图上唯一的量是「 6,710 亿」,那是模型规模,前面已经立过。

📌 「正向模式 / 反向模式」是自动微分的标准术语;反向传播是反向模式用在神经网络上的那个特例。

两条链同时开跑 —— 看谁先跑完。 上面是正向模式:小球一次只能为一个参数跑一趟,跑完才点亮那一个, 于是八个参数就得跑八趟(右边堆了八块)。
下面是反向模式:小球从 loss 出发往回走一趟,沿途所有参数一起点亮 —— 一趟就完事,右边永远只有一块。
⭐ 注意它早早就停在那儿了,而上面那条还在吭哧 —— 那份等待就是 6,710 亿倍代价的样子。 (9 秒无声循环,Manim 渲染,脚本在 tools/manim/。)

所以反向传播成立的全部理由就一句话: 参数有几千亿个,而 loss 只有一个。

多输入、单输出。 如果 loss 不是一个数、而是一百万维的输出,这套就不划算了 —— 那时候反倒该用从前往后。

所以 1.1 那个问题的答案是:那 6,710 亿次前向, 压成的是一次反向。

这条判据可以直接迁移: 看到任何一个「求一大堆偏导」的问题,先数一下输入多、还是输出多 —— 它决定了你该从哪头开始。

🕰️ 而这件事第一次被写下来,据公开资料是 一篇没人读的硕士论文。

1970 年,赫尔辛基大学,一个叫 Seppo Linnainmaa 的学生在硕士论文里 提出了反向模式的自动微分 —— 也就是上面这整套「从输出往回推」的做法。

而那篇论文里一次都没提神经网络。 —— 他解决的是「一个复合函数怎么高效求导」这个纯数学问题。

神经网络那边要再等十六年,才有人把它接上去(1986 年那篇 Nature)。

这个形状前面其实已经出现过一次 ——  1.4 那个「梯度消失」,第一次被说清楚也是在 一篇硕士论文里(1991 年,慕尼黑,德文,从没在英文期刊发表)。
两次改变一切的东西,第一次出现时都是没人读的硕士论文。

这两条史料各查到什么程度

1970 那条我核的是公开的传记与综述资料, 没有读到论文原件(芬兰语,未数字化)—— 当量级可靠的二手事实看, 所以正文写的是「据公开资料」而不是断言。
1991 那条(Hochreiter 的德文硕士论文)同样没读原件, 但它有 2001 年那篇四人合写的综述作为一手转述,可信度高一档。
两条都不要当成「我读过」来引用。

1.6 闭环:反向必须用到前向的值 —— 这就是激活扔不掉的根本原因

回头看 1.2d 那两笔里的第 ② 笔: 算自己权重的梯度,要用「前向时存下来的输入」—— 而那个输入,就是激活。

⛔ 这就是激活必须留着的根本原因 ——  不是谁设计得不好,是反向的数学本身要求它在场。

前向每算出一个中间结果,都得一直挂在那儿, 等反向走回来的时候用。整条网络走完,它们全都还在。

这一节的两笔账到此都立住了: 算力 3×(前向 1 + 反向 2); 显存里多出一整条从头挂到尾的激活。 而下一节要做的,就是拿第一样去换第二样。

激活是一座山 —— 前向一路堆,山顶在 loss 那一刻 横轴是时间,不是层号 · 权重和优化器状态没画 —— 它们是水平的,会把山形压扁 前向 · 堆 峰值 反向 · 拆 开了全量重算 Ⓐ 每前进一层,就多挂一份中间结果 —— 而且一份都不能提前扔 为什么不能扔:反向算权重梯度时要用前向那一刻的输入 显存里的激活(GiB) 0 25 50 75 100 前向:第 1 层 → 第 61 层 反向:第 61 层 → 第 1 层 曲线是按 V3 真实层构成算的:前 3 层 dense(每层 1.24 GiB)+ 58 层 MoE(每层 1.73 GiB) 峰值 104.1 GiB 前向刚算完、反向还没开始 🔍 橙色那条 = 开了全量重算之后的同一笔账 · 单独放大,纵轴换了一把尺 同一条序列、同一个模型,只是中间结果不留,反向要用时现算一遍 loss 峰值 5.07 GiB —— 在反向途中 台阶是每释放一个存档点掉一小格;那一跳是「当前正在重算的那一层」被物化出来 ↓ 开了全量重算,整条压到这儿 —— 峰值 5.07 GiB,省 21 倍 Ⓑ 这座山有多高 —— 一条 4K 序列(batch = 1),V3 那个规模 跟上面那座山同一个口径 · 自己按算子推的估算,当量级看,别当准数 不开重算 104.1 GiB 一整条全挂着 一块 80 GiB 的卡,一条都放不下 开了全量重算 5.07 GiB 每层只留入口那一份 同一块卡能放 15 条(只算激活) 两个框的高度是按真实比例画的 —— 右边那条薄片就是重算之后剩下的厚度 再往上就是乘 batch,线性的:per-device batch = 8,两边就各是 833 GiB 和 40.6 GiB。 这里全程按 4K 算 —— 训练用的就是 4K,长上下文扩展是预训练之后另加的一段(在后训练之前),不该拿来充这一节的门面。 这张图顺带把两件事一起讲了 「为什么训练比推理贵」:算力只贵 3 倍,可推理根本没有这座山 —— 它算完一层就把中间结果扔了,只留 KV cache。真正拉开差距的是显存,不是算力。 「峰值出现在哪一刻」:就是山顶那一竖 —— 前向刚结束、反向还没开始。 到第五节会把权重和优化器状态那两条水平带叠上来,山形不变,只是整体抬高。
横轴是时间,不是层号 —— 换成层号,「什么时候最挤」这个问题就提不出来了。
山顶那一竖同时回答了第五节要问的「峰值在哪一刻」:前向刚算完、反向还没开始。
出处与口径

真实是 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 的「九份复制」。

  • 专家输出 28% + SwiGLU 乘积 8% —— 两项是同一件事的后果:每个 token 要发给 9 个专家 (8 个路由 + 1 个共享),每个专家各产出一份自己的中间结果, 于是这几个张量各存九份。合起来 37%,一层里最大的一块。
  • ⚠️ 进去那一份不算在内:九个专家读的是 同一块内存(上游 norm 的输出),不需要复制九遍。 常见实现会为了做分组矩阵乘而物化一份重排后的副本(那才是九份, 4K 上 504 MiB),但也有实现在反向里重做一遍重排而不存它 —— 那是实现选择,不是数学上的必需,所以不进这张账。
  • 而 attention 输出只占 7% —— 比多数人猜的小一个档。

这一条直接决定了下一节的名单: 要省激活,先看的不是 attention,是那几份复制。 它也解释了一件反直觉的事 —— MoE 在参数账上很省 (每 token 只选中一小部分权重),在激活账上却要付九份的复制费。

逐项怎么数的、换到 128K 是多少 —— 都在下面这个折叠块里。属于「装不装得下」,本讲不要求。

把那张激活账单逐项摊开:一层里到底挂了哪些张量 作者自己写着「这一小节可以整段跳过」—— 给要自己算的人看的,属于「装不装得下」

1.7 把那张原始账单摊开 —— 一层里到底挂了些什么

这一小节可以整段跳过。 它是给要自己动手算的人看的 —— 上面那两个数从哪来,全在这儿。

基准单位先立住:一份 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。见下面第二条边界。

MLA 子层留什么

留下的张量宽度大小
norm 的输入(= 残差入口,重算模式下唯一留的那份)7,16856 MiB
norm 的输出7,16856 MiB
Q 降维结果(layernorm 前后各一份)2 × 1,53624 MiB
KV 降维结果(含 RoPE 那 64 维)576 + 5128.5 MiB
Q 展开后128 头 × 192 = 24,576192 MiB
K、V 解压后128 头 × 256 = 32,768256 MiB
attention 输出128 头 × 128 = 16,384128 MiB
logsumexp(fp32)1282 MiB
小计约 722 MiB

MoE 子层留什么

留下的张量份数 × 宽度大小
norm 的输入 / 输出2 × 7,168112 MiB
路由分数2562 MiB
派发给专家的那份= 上一行本身,九个专家共用0 MiB
gate / up / SwiGLU 乘积3 × 9 份 × 2,048432 MiB
专家输出(合并前)9 份 × 7,168504 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。

⛔ 这张表的三条边界,讲的时候必须说清楚。

  • 它是按算子逐项推的,不是从哪份报告抄的。 不同框架的算子融合程度、是否顺手重算便宜算子、 MoE 派发是否真的物化九份副本,差别都很大 —— 当量级看,别当准数。
  • 注意力分数矩阵没算在里面。 它带 S² —— 全表唯一一个不跟着 token 总数走的量。 4K 上是 4.00 GiB/层(128 头 × 4,096² × 2 B), 128K 上是 4 TiB/层(×1024,不是 ×32)。 FlashAttention 压根不把它写进显存,所以它不出现在这张表上 —— 换成不带 flash 的朴素实现,这张表整个作废。

    别因为「才 4 GiB」就放过它:上面整整一层 MoE 块的全部激活 加起来才 1.73 GiB —— 这一项自己就比那一整层还大。 在 128K 上它是压倒性的,在 4K 上它依然是单个最大的张量。 这条论点没有因为换基准而失效,只是从「吓人」变成「仍然第一」。

  • 那个 5.07 GiB 的峰值是「已经做过一次交易之后」的账。 它假设每层只留入口那一份,再加上当前正在重算的那一层的完整激活 (3.34 GiB + 1.73 GiB)—— 而那恰恰就是开了重算之后的样子。 后面那一项很容易漏:漏掉它,峰值会低估 34%, 照着配显存会少配约三分之一。 它还压着两个前提:一是存档点正好切在层边界上; 二是同一时刻只有一层在重算 —— 流水线并行的气泡里可能不止一层, 那时峰值要按同时在算的层数乘上去。两条都成立时这个数才是对的。 所以先看原始账单、再看下一节,顺序不能颠倒。

还有一项,它不在上面两张表里 —— 因为它不属于任何一层。

最后那个投影把 hidden 变成词表上的分数(logits),形状是 [序列长度, 词表]。V3 的词表是 129,280:

4,096 × 129,280 × 2 B = 1010 MiB  (一条 4K 序列)

把它跟上面那两张表放一起比一下:

  • 表里最大的单个张量是「K/V 解压后」,256 MiB。
  • logits 是 1010 MiB —— 差不多是它的四倍。
  • 而整整一层 MLA 子层加起来才 722.5 MiB —— logits 一项就比一个完整的 MLA 子层还大。

它是整个模型里最大的单个张量, 而且 softmax 通常还要升到 fp32 去做 —— 那就再翻一倍。

所以真实实现几乎都不会把它整个物化出来: 把序列切成若干块,算一块的 loss、回一块的梯度,再算下一块。 —— 这跟 2 那节的重算是同一个思路, 只是换到了词表这一维上。

正因为主流实现都分块,它没有被算进上面的总账 —— 这是个口径选择,不是忘了。但你要是自己写训练循环、 又老老实实一次性算完整个 logits,这一块会突然出现在你的显存里。 扩训到 128K 那一档它是 31.6 GiB,届时它不分块就根本跑不动。

1.8 梯度算出来之后,还没完

1.3 只讲到梯度算出来那一刻就停了。 可它离「被用掉」还隔着好几道 ——  而这几道每一道都是推理里不存在的。

梯度的一生 —— 从算出来到被扔掉,中间要过五道 看三条泳道:做什么、能不能藏、推理里有没有 能藏进计算里 藏不了 推理里都没有 Ⓐ 五道依次走完,而其中只有一道能跟计算叠在一起 也只有一道会把所有卡钉在一起等 ① 算出来 反向走到哪层, 哪层的梯度就出来 → — 从后往前陆续出来,不是最后一起出 推理里:没有 ② 跨卡汇总 每张卡看的数据不同, 得取平均 → 能藏 前面几层还在算,后面的梯度 已经能传了 推理里:没有 ③ 裁剪 按全局范数,超了整体缩回去 → 藏不了 要等所有卡所有层都到齐,强制一次同步 推理里:没有 ④ 累积 几个 micro-batch 先加起来(可选) → — 它改的是时间线,不是总量 推理里:没有 ⑤ 用掉就扔 交给优化器,这一份就没用了 — 正因为用完就扔,它才敢用 bf16 存 推理里:没有 第三条泳道是这张图的落点:这五道,推理里一道都没有 —— 它们整条都是训练才有的东西。 而这也是为什么「训练比推理贵」不只是「多跑一遍」 —— 多出来的是一整条流水线。 只有第 ③ 道会把所有卡钉在一起等 —— 而它传的其实只是一个数 「全局范数」是跨全部参数的一个标量:得先把每一块的平方和都算出来、汇总成一个数、开根号,才知道要不要缩、缩多少。通信量可以忽略,代价是那一次同步。 所以按全局范数裁剪天然是「一步一次」。 但别读成「逐层裁剪不存在」—— 它存在,只是保的不是同一个量:逐层保的是每层各自的范数,全局保的是这一步总共迈多大。
看三条泳道,别只看第一条 —— 第一条是「做什么」,第二条是「能不能跟计算叠在一起」,第三条才是落点。
第三条泳道全是紫的 —— 这一格是现场那条界(推理里没有的那些东西)最直观的一次落地。
⛔ 而五道里只有裁剪那一道会把所有卡钉在一起等,偏偏它传的只是一个数。
出处与口径

⚠️ 图上不含任何量 —— 通信到底多大、能藏掉多少,是那张 batch 图和专题五的事。

⭐ 第 ⑤ 道那句「用完就扔」是本讲另一处的伏笔:正因为它一次性,它才敢用 bf16 存 —— 而一旦要做累积,它就变成累加量,得升回 fp32。

那笔通信有多大、为什么跟 batch 无关 通信是并行的事 —— 专题五整讲在算它

第 ② 步那笔通信,有个很反直觉的性质

纯数据并行下,每一步要把整份梯度在所有卡之间汇总一遍。 量级很好算:参数量 × 每参数字节数。

关键在这儿:这笔通信量跟 batch 完全无关。 —— 参数有多少就传多少,你喂一条序列和喂一千条,传的是同样多的字节。

而计算量是随 batch 线性涨的。所以:

batch 越大,这笔通信被摊得越薄。

这一下就解释了两件原本看着不相干的事:

  • 为什么大模型都在爬 batch。 GPT-3 从 32K token 一路爬到 3.2M,PaLM 从 1M 翻到 4M, V3 从 3072 条序列爬到 15360 条(4K 上下文,折合 12.6M → 62.9M token) —— 它们全都在往上爬,而且都写着「越到后面越大」。
  • 为什么梯度累积除了省显存还顺带便宜。 累积 K 个 micro-batch 才更新一次,就是把通信次数除以了 K —— 它省的不只是激活。

✋ 这里必须补一句,否则上面那段会被读歪: 爬 batch 买到的不是吞吐。

「batch 开大就更快」这句话有前提,而且前提正好卡在大规模训练这一档 —— 并行度一旦吃满,每步变贵的倍数正好抵掉步数变少的倍数。

所以在这个规模上,开大 batch 买到的是 通信被摊薄和梯度更稳 —— 不是「跑得快」。

那条曲线连同「该开多大」的完整取舍,在 3.5b —— 那一节里它跟另外两句民间话 (「大了才稳」「大了就不行」)摆在一起讲,三句凑成一组才完整。

那条「能藏」的泳道,值得单独说一句

「算」和「传」能叠在一起,是训练里最重要的一类优化 —— 而推理侧没有对应物:它没有反向, 也就没有这条可以边算边传的长尾巴。

裁剪那一道为什么藏不了、「逐层裁剪」为什么是另一件事 —— 图下面的落点写了。这里只留一句: 「这一步总共迈多大」才是跟 3.3 对话的那个量。

顺带把 ④ 说清楚:梯度累积到底省什么

⭐⭐⭐ 一句话:梯度累积改的是时间线,不是总量。

边界:这一节只讲了「这一步存在、有多大、能不能藏起来」。 换个切法它是 all-reduce 还是别的形态、量各差多少 —— 专题五整讲的事。

通信量那个「参数量 × 每参数字节」是量级口径: 真实的环形汇总要来回搬,实际搬运量大约是它的两倍; 而 MoE 的专家部分走的又是另一套。当量级看。

第 二 节

代价:那些中间结果扔不掉 —— 以及第一个真正的取舍

这是全课第一次出现真正的取舍: 不是「有没有更好的办法」,而是两样东西只能选一样,你选哪个。

这一节留在主线上,是因为它接着 1.6 那个结论(反向要用中间结果,所以扔不掉)——  「扔了再算回来」是这条因果链的下一步,而那条判据很值钱。 但具体省多少 GiB、哪一档划算属于「装不装得下」,那是 专题五 的事。本节相关的细账都收进折叠块了。

2.1 重算是什么 —— 一句话:不存过程,只存存档点

前向每算出一个中间结果就留着,是因为上一节那条 —— 反向要用。重算说:我不留了。

反向要用的时候,我从这一层的入口再往前跑一遍,现算出来。 就像游戏存档 —— 不存整个过程,只存一个存档点, 要用的时候从那儿重打一遍。

2.2 全量重算:这笔交易到底划不划算

先把量级说清楚 —— 这才是要记住的东西。

这个兑换比例,夸张到不像是个「权衡」。

所以在大模型训练里,它默认就是开着的 ——  值得讨论的从来不是开不开,而是开到哪一档(图 Ⓑ 那三档)。

全量重算 —— 用三分之一的算力,换掉二十分之十九的显存 两边都归一到「原来 = 100%」 · 否则一边 TiB 一边 TFLOPs,两根条没法比 付出:算力 省下:显存 Ⓐ 这笔交易的两边 —— 形状不对称到不像是个权衡 条长代表「相对原来剩多少 / 涨多少」 付出 算力 原来:3×(前向 1 + 反向 2) 现在:4×(多跑一遍前向) +33% 多出来的那一小截,就是「再跑一遍前向」 省下 显存 原来:104.1 GiB 激活 现在:5.07 GiB —— 只剩 4.9% 这根条短到几乎看不见 —— 那正是这张图要说的事 Ⓑ 所以值得讨论的从来不是「开不开」 而是开到哪一档 不开 全留 只在显存宽裕时才合理 选择性 按比值挑着扔 128K:约 1.9% 算力换约 71% 显存(4K 是 9.3%)—— 性价比最高 全量 每层只留入口那一份 33% 算力换 95% —— 显存实在不够时 显存本来就宽裕的时候(小模型、短序列),重算就是纯亏 Ⓒ 换一个轴:隔几层留一个存档点 注意这跟 Ⓑ 不是同一件事 —— Ⓑ 是一层之内留哪些,这里是隔几层留一个 全存 每一层都留 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 💾 存 16 份 + 段内 1 层 = 17 隔 4 层留一个 L = 16,而 √16 = 4 💾 💾 💾 💾 存 4 份 + 段内 4 层 = 8 只存开头那一个 重算时整条 16 层都得在场 💾 存 1 份 + 段内 16 层 = 17 同时在场 一个方块 = 一层。💾 就是留下来的存档点 两头一样高 —— 存得越少,并不是越省。少存一个存档点,就要多扛一段重算时的中间结果。
要看的是两根条的不对称 —— 付出那边只多出一小截,省下那边短到几乎看不见。
⚠️ 两根条都归一化了,所以可以直接并排看 —— 单位不同的量并排放,读者第一反应是去比长度,而那个比较没有意义。
Ⓒ 换了另一个轴:Ⓑ 问的是「一层之内留哪些」,Ⓒ 问的是「隔几层留一个」。看那三个「同时在场」—— 17 / 8 / 17,两头一样高。
⛔ 所以最优点在中间,而它落在 √L 上 —— 这个结果的出处是 Chen et al. 2016(arXiv 1604.06174,标题就是结论:Training Deep Nets with Sublinear Memory Cost):「an algorithm that costs O(sqrt(n)) memory to train a n layer network, with only the computational cost of an extra forward pass」。⚠️ ZeRO 论文(1910.02054 §3.2)也说过「降到大约总量的平方根、代价 33% 重算」,但它是在转述这个结果,不是它的出处。
出处与口径

⚠️ 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 上投影 —— 正是那一档

2.3 选择性重算:判据只有一个数

对每一个中间张量问同一个问题: 把它扔掉、反向时重算回来,每省一个字节要付多少次浮点运算?

比值越小越该扔。就这一个数,整张排序表自己就出来了。

对线性层,这个数有闭式解,而且漂亮得出乎意料:

一个 [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 里最占地方的那两项,正好都在最便宜的那一批。

  • SwiGLU 乘积(占 8%)—— 逐元素,每字节代价 ≈ 0
  • 专家输出(占 28%)—— 输入宽 2,048, 每 GiB 付 2.20,仍在「小于 3 全收下」那条线之下

这是运气,不是规律 ——  反例就在同一张表上:最贵的那一项(o_proj 的输出,每 GiB 付 17.59) 只占一层的 2.5%,扔它既不省地方又很贵。 所以下次换个模型,两个排序完全可能打架。真打架的时候,按比值挑,不按大小挑:判据是「每省一字节付多少」, 从来不是「谁最胖」。

2.4 但 attention 不服从这条 —— 而且它必然会跟线性层交叉

attention 不是线性层:代价随 S² 涨,产出只随 S 涨。 一除,每字节代价随序列长度线性上升。

为什么同一条判据会给出相反的答案 —— 两条斜率不同的线,必然相交 纵轴:扔掉它、再算回来 —— 一个字节的代价 · 双对数坐标 —— 常数在这里是水平线,正比于 S 的是直线 便宜 → 该扔 贵 → 该留 attention Ⓐ 横轴是序列长度 —— 整张图只有这一个变量在动 线性层那几条是水平的:它们的代价跟序列长度无关 1K 4K 16K 64K 256K 序列长度(token) 1K 10K 100K FLOPs/字节 K/V 解压(输入宽 512) Q 展开(输入宽 1,536) 专家输出(输入宽 2,048) gate / up / 路由(输入宽 7,168) o_proj(输入宽 16,384)—— 最宽 V3 的 attention(紫线) = 1.25 × 序列长度 GPT-3 的 attention = 1.00 × 序列长度 GPT-3 最宽的线性层(49,152 = 4h) GPT-3 自己的交点 49,152 交点 S ≈ 13,107 左边 attention 还不是最贵的,右边它就是最贵的 GPT-3 2,048 → 2,048 FLOPs/字节 V3 预训练 4,096 → 5,120 FLOPs/字节 V3 扩训 131,072 → 163,840 FLOPs/字节 长上下文扩训:同一个模型,往右走 32 倍 同一条判据,结论翻转 —— 而两个模型的线都不一样 2022 年那篇(arXiv 2205.05198)说:挑「占显存不少、但重算起来不贵」的扔,它选中了 attention。 看橙色那一组:GPT-3 在 2,048 处只要 2,048,而它自己的交点在 49,152 —— 远在左边,attention 确实最便宜。论文没错。 而真正值得记的是红色那一组自己走的这段路:V3 预训练在 4,096,每字节 5,120 —— 比 gate/up 那条线还低,attention 只是个普通候选。扩训把它推到 131,072,同一 个 attention 变成 163,840,越过交点 13,107 很远,成了最该留的那一个。同一个模型、同一条判据、只有一个旋钮在动 —— 结论换了边。 判据一个字没改 —— 而且注意: 两个模型的斜率和对照宽度都不一样,翻转靠的是「斜率不同必然相交」这件事本身,不靠任何一组具体数值。
全专题最值钱的一张 —— 「两条斜率不同的线必然相交」这句话,图讲一秒,字讲一段。
双对数不是为了好看:只有在这个坐标上,「常数」才是水平线、「正比于 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。

  • 短于 ~13K —— attention 还没爬到最贵那一档, 扔掉它不是这一层里最亏的选择。
  • 长于 ~13K —— 它越过最宽的线性层,从此一路最贵, 而且线性地越来越贵。

13,107 是个粗略交叉点,不是工程阈值。 它依赖 causal 折半的口径、依赖 V3 的头维度、依赖你拿哪个线性层做对照。 要记的是那句「两条线斜率不同所以必然相交」,不是这个数。

把一层里每个张量按这条判据排一遍 —— 9 行名次表、该切在哪、省多少付多少 判据本身上面已讲完;这里是跑一遍的细账,属于「装不装得下」

把 V3 在基准的 4K 上排一遍 —— 一层 MoE 块,按「每 GiB 要付多少 TFLOP」升序:

张量省显存重算代价每 GiB 付结论
logsumexp(attention 副产物,fp32)0.002 GiB~00白捡
RMSNorm 输出(3 份,逐元素)0.121 GiB~0~0白捡
SwiGLU 乘积 9 份(逐元素)0.141 GiB~0~0白捡
K/V 解压(输入宽 512)0.250 GiB0.14 TFLOP0.55划算
Q 展开(输入宽 1,536)0.188 GiB0.31 TFLOP1.65划算
专家输出 9 份(输入宽 2,048)0.492 GiB1.08 TFLOP2.20划算
attention 输出0.125 GiB0.69 TFLOP5.50边际
gate / up / 路由 / 降维(输入宽 7,168)0.303 GiB2.33 TFLOP7.70边际
MLA 后的残差流(= o_proj 输出,输入宽 16,384)0.055 GiB0.96 TFLOP17.59边际

这张表不用背,它是上面那条闭式解直接排出来的 ——  除了逐元素那几行(代价≈0)和 attention 那一行(随 S 动), 其余每一行的「每 GiB 付」就是各自的输入宽度换了个单位, 你拿 config 自己也能排一遍。 顺带自曝:这张表早先有一行是手填的, 「省显存 9.14 × 每 GiB 7.70」算出来是 70 TFLOP,那一栏却写着 39.08。 而这张表的卖点正是「你自己也能排一遍」。照着排的人会正好撞上它。现在整张表由闭式解生成,手改不了。

⛔ 回答那个直觉问题:「有没有占显存很小、算力却很大的东西?」 —— 有,就是 attention。但「有多极端」完全取决于你在哪个序列长度上问。

判据只有一条比值 —— 比值高的留,比值低的扔。 而这张表里只有 attention 这一行会随序列长度动,其余各行是输入宽度,跟 S 无关。

attention 每 GiB 付4K(本讲基准) 128K(扩训)
绝对值5.50175.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 一点关系都没有。

口径收紧:FlashAttention 下 attention 的反向是 2.5 倍不是 2 倍 精确口径,不改变任何结论的方向

⛔ 顺带收紧一个口径: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。

2.5 同一条判据,2022 年给出的是相反的答案

「选择性重算」这个概念出自 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 天生就不把分数矩阵写进显存、反向时现算 —— 等于把论文那条建议内建成了默认行为。

去翻 Megatron 源码:那个默认值今天还在,而维护者在旁边钉了一条警告 很好玩,但属于框架实现细节

⛔ 这里我原来写「所以现代框架的候选名单里 attention 根本不出现」——  去翻了源码,完全说反了。

Megatron-LM 的选择性重算开关 --recompute-modules, 候选项里第一个就是 core_attn, 而且它是默认值(recompute_modules = ["core_attn"])。

先把话说准 —— 这里有三层,我原来只讲了一层。

  • ① 「默认」不等于「默认开着」。recompute_granularity 的默认值是 None,也就是什么都不重算。 core_attn 是你主动打开 selective 之后,默认选中的那个模块。
  • ② 而在 FlashAttention / 融合 attention 下,重算它基本没用。 FlashAttention 压根不把注意力分数写进显存 ——  没有物化的东西,谈不上「扔掉再算回来」。
  • ③ 最有意思的是:Megatron 自己知道这件事,而且把警告写进了源码。

「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 那套口径)。

重算的两笔「不在账上」的代价:结果可能不一样、收益不能照抄 工程上很重要,但属于「怎么把它跑起来」,不是反向/梯度下降/loss 的原理

2.5b 重算还有一笔不在账上的代价:它可能算出不一样的东西

前面算的是两本能算的账。可重算还有第三样代价, 它不在任何一本账上 —— 而且它不报错。

重算的前提是:把同一段前向再跑一遍,跑出来的要一模一样。 —— 有三种情况会让它不一样。

① 随机数 —— 这一条框架替你挡住了。

前向里有 dropout。如果重算时抽到的是另一套掩码, 那反向用的就不是前向那张网络了 —— 梯度直接是错的,而且没有任何报错。

PyTorch 的做法很干脆:把前向那一刻的随机数状态存下来, 重算前先恢复。 —— torch.utils.checkpoint 的 preserve_rng_state,默认就是 True。

而这一条正好解释了 3.7 那个清单里的第三项: checkpoint 里除了权重和优化器状态,还得存随机数状态 ——  原因是同一个:随机数是训练结果的一部分,不是「运行时的临时东西」。

② 副作用 —— 这一条没人替你挡。

如果那段前向除了返回结果,还顺手改了别的东西 —— 更新了一个滑动统计量、累加了一个计数器、写了一行日志。重算会把它再改一遍。

框架不会替你回滚这些,因为它根本不知道你改了什么。 —— 判据很简单:被重算的那一段,最好是个纯函数。

③ 逐比特不一致 —— 通常无害,但它有个具体的受害者。

同一段计算跑两遍,结果可能差在最后几位 —— 归约的顺序不同、挑的 kernel 不同,都会这样。

对训练本身,这个量级的差别基本没影响。 但它让「逐比特可复现」变难 ——  而那正是 6.6 里 PaLM 做到的那件事, 也是 6.2 那个「回滚 + 跳数据」的救火办法所依赖的前提。

一句话:重算把「算力 ↔ 显存」这笔交易谈成了, 但它同时悄悄引入了一个「结果要可重现」的要求。 —— 前两本账会告诉你划不划算,这一条不会:它只在出事的时候现身。

2.6 本章落点:收益不能照抄别人的

⛔ 同一个模型、同一个开关,换一个规模, 收益可能从正的变成负的。

原因不神秘:重算改变的是计算与访存的配比, 而这个配比在不同并行配置、不同芯片数下本来就不同。

由此推出一条通用规则(它不只对 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 看起来那么低: 分子里那一大块重算做了功,但按定义不算进「有效算力」。

说准一点:这里有两个指标,差的正好就是重算。

  • MFU(Model FLOPs Utilization):分子用 不含重算的模型 FLOPs(也就是 6ND 那一套)。
  • HFU(Hardware FLOPs Utilization):分子用 机器真的算了的 FLOPs,含重算。

全量重算时 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 口径对齐。

第 三 节

有了导数,那一步该迈多大 —— 梯度下降与优化器

前面两节都在跟激活较劲。可把账摊开一看 ——  那个从头到尾一言不发的角色,才是最大的一块。

3.1 一个参数到底要占多少字节

❓ 先花两句话把前提说清楚,不然下面那张账单看不懂。

训练的时候,同一个参数在显存里同时存着两份:
① 一份省地方的(bf16,2 字节)—— 前向和反向都拿它算;
② 一份精确的(fp32,4 字节)。专门用来记账,每一步的更新加在它身上。

这套做法就叫「混合精度」。 —— 为什么非得存两份,下一小节(3.2)整节都在回答。

混合精度训练下,每一个参数身上挂着五样东西 ——  而其中只有第一样是「模型本身」。

优化器谱系 —— 每一代往每个参数身上挂了几份状态 这张图不按算法怎么算排,按账单排 · 横轴只表示先后,不是线性年份 0 份 1 份 2 份 往回走 Ⓐ 六十年只在加同一样东西 —— 直到 2024 年有人把它拿掉一份 「份数」指的是每个参数要额外存几个跟它一样大的张量 0 份 1 份 2 份 SGD 只按梯度走一步 + 动量 1964 记住上一步往哪走 AdaGrad 2011 每个参数一个学习率 RMSProp 2012 把累加换成滑动平均 Adam 2014 动量 + 自适应,两份都要 AdamW 2017 修 weight decay 那个 bug Muon 2024 去掉 v,改为正交化 横轴只表示先后,不是线性年份 Muon 是往回走的那一步 六十年一路加,2024 年 有人把二阶矩那一份整个拿掉了 AdamW 不是新算法 —— 它是在修一个 bug 论文摘要开头就说:L2 正则和 weight decay 对普通 SGD 是等价的,但对 Adam 这种自适应方法不等价。 因为 L2 那一项是混在梯度里进去的,再被二阶矩的分母一除 ——  梯度大的参数,它的 weight decay 被稀释掉了。 所以 AdamW 的修法是把 weight decay 从梯度里解耦出来,更新参数时单独减一下。那个 W 就是 decoupled 的意思。 Ⓑ 所以「每参数 16 字节」是哪五样 —— 其中 12 字节是 fp32 的那三份 混合精度训练的常规配置 bf16 权重 2 B 前向反向都用它 bf16 梯度 2 B 反向算出来的 fp32 主权重 4 B 真身,用来累加 fp32 动量 m 4 B Adam 的第一份 fp32 二阶矩 v 4 B Muon 去掉的就是它 = 16 B 2 B 推理也要 就是你下载到的那份权重 14 B 训练才要 这一讲讲的,全是这一段 而这一讲那句「最大的一块是优化器状态」,落到数上就是这么来的: 权重只占 2 B,优化器那边(主权重 + m + v)占 12 B —— 六倍。 而换成 Muon:二阶矩那一份没了 —— 16 B 变成 12 B,少四分之一。 但它只管二维参数 —— embedding 和输出头仍然走 AdamW,所以整模型省不到四分之一。
Ⓐ 的形状是这张图的全部 —— 六十年一路往上加,2024 年有人往回走了一步。
而 Ⓑ 把「最大的一块是优化器状态」翻译成了一根尺子:权重只占 2 B,优化器那边占 12 B。
出处与口径

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 字节摊开:混合精度到底省没省常驻显存 结论「一个字节都没省」很反直觉,但它是显存账 —— 本讲只要记住「Adam 每个参数要记两个矩」

⛔ 顺手拆掉一个最顽固的误解:「用了混合精度,显存不就省一半吗?」

常驻这一块,它一个字节都没省。 —— 两边算一遍,答案都是 16。

权重梯度动量 m二阶矩 v主权重合计
纯 fp324444—16 B
混合精度2244416 B

看那一列:权重和梯度各省了 2 字节, 可换来的是多出一份 4 字节的主权重 —— 2 + 2 正好被 4 吃掉。

那混合精度到底换来了什么?两样,都不是常驻显存。

  • 速度。矩阵乘走 bf16,用的是芯片上那套专门的单元 —— 这才是它的主要目的。
  • 激活。激活那一大块是 bf16 存的,这里确实省了一半 —— 而按 5.4 那个小例子,激活经常比常驻还大。

判据:说「省显存」之前,先问省的是哪一块。 常驻和激活是两本账,一句「省一半」把它们混在一起, 结论就会在你最需要它的时候是错的(比如估一张卡装不装得下)。

3.2 哪些量必须高精度 —— 判据只有一句:看它累不累加

图上那五格,为什么有三格是 fp32、两格是 bf16? 不用一格一格记 —— 根子上只有一个画面。

精度问题,根子上只有一个画面 —— 大数吃小数 这一格里每一个数都是脚本当场算的 —— 你也可以自己跑一遍 bf16:范围够,精细不够 fp16:精细够,范围不够 fp32:都够,但占两倍字节 Ⓐ 一个小数在机器里分成两段存 —— 指数管「能多大」,尾数管「能多细」 看清楚:bf16 和 fp32 的指数段一样长 fp32 32 位 指数 8 位 尾数 23 位 bf16 16 位 指数 8 位 尾数 7 位 指数跟 fp32 一样长 → 范围一样,只是变粗 fp16 16 位 指数 5 位 尾数 10 位 指数短了 3 位 → 小的梯度直接掉到 0 bf16 和 fp16 都是 16 位,只是分法不同 —— 所以 fp16 要 loss scaling,不是因为「16 位不够用」,是因为它把位数分给了尾数。 Ⓑ 于是「加了等于没加」 —— 这不是比喻,是真的一动不动 权重 1.0,每步加 0.0003(训练后期的典型量级) 1.0000000 1.0078125 1.0156250 1.0234375 这中间什么都没有 一格 = 0.0078125 要加的量 0.0003 只有一格的 3.8% —— 四舍五入直接舍回原地 要连加 26 次 才够跨过一格 可它跨不过去 bf16 里连加 1,000 次 1.0 → 1.0 一步都没动 —— 每次都被舍回去了 同样 1,000 次,改用 fp32 1.0 → 1.3 该加的都加上了 所以「主权重留一份 fp32」不是保险起见 —— 不留,训练到后期就真的停在原地了。 Ⓒ 那谁必须 fp32?判据一句话:老的贡献会不会永远不走 不是「累不累加」—— 那个说法太粗,被 DeepSeek-V3 一条实测打中过 10⁰ 10¹ 10² 10³ 10⁴ 10⁵ 步 这一步的贡献,到现在还剩多少 一半 主权重 必须 fp32 v(β₂=0.999,Adam 默认值):半衰期 693 步 m(β₁=0.9):6.6 步 梯度/激活:下一步就没了 只有那条一直平着的必须 fp32 —— 它装的是十万步前那一点点增量,而那一点现在还在里面。其余三条都会被忘掉,忘得掉的就存得粗。 所以 12 个 fp32 字节装的正好是「不走的」,2 个 bf16 字节装的正好是「会走的」 —— 这条线不是拍出来的,是这条曲线画出来的。 梯度一做累积就又变成「要留一阵子」,于是升回 fp32。 而这条规则可以被打破 —— 只要把「每次都朝同一边抹零」去掉 真正致命的不是「加的量小」,是「每次都朝同一个方向抹零」。换成随机舍入(按余数大小决定进位概率),那么每步的期望增量正好等于真实增量 —— 丢掉的那部分,多步之 后会被找回来。(这个恒等式脚本里验了。) 但这不是推荐做法:它要额外的硬件/框架支持,而 fp32 主权重便宜又省心。放在这儿只是因为 —— 知道一条规则「为什么成立」,才知道它什么时候可以不成立。
Ⓑ 是这一节的全部 —— 权重 1.0、每步加 0.0003,在 bf16 里连加一千次还是 1.0。不是慢,是一步都没动。换 fp32 同样一千次:1.0 → 1.3。
这些数不是引来的,是脚本当场算的 —— 里面有一个真的 bf16 舍入函数,三条 assert 盯着。你可以自己跑一遍。
Ⓐ 顺带解掉一个常见误解:fp16 要 loss scaling 跟「16 位不够」无关—— 它跟 bf16 一样是 16 位,只是把 3 位从指数挪给了尾数,于是范围小了,小梯度直接掉到 0。
出处与口径

📌 Ⓑ 里每一个数都是脚本用一个真的 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。
  • 动量 m / 二阶矩 v —— 它们是滑动平均, 每步都乘一个小于 1 的系数再掺新值 —— 老的贡献会被衰减掉。 滑动平均不是累加,所以 bf16 扛得住。(前提是 β₂ 不太接近 1:β₂ 越接近 1,每步掺进的新值越少,改动可能小到被 bf16 舍掉。V3 用 β₂ = 0.95;§3.6 讲 PaLM 让 β₂ 随步数变那一段专门说了这个前提。2026-09-25 更正:这句原来没写前提)
  • 梯度 —— 本来是一次性的;一旦要做梯度累积,它就变成累加量, 于是又得升回 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 训练为什么难, 问的就是同一句 —— 精度往下压的时候,哪些量能压、哪些必须留住, 看的还是它累不累加。那是另一课的事。

3.3 为什么顺着梯度走,loss 就会变小

先说一句这个想法是谁的 —— 1847 年,柯西

⭐ 梯度下降比神经网络早了一百多年。 它出自 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 整节,都在跟它较劲。

梯度下降为什么可以 —— 一切的本源,先把它讲透 前面讲了梯度怎么算出来,这一格讲为什么顺着它走就能变好 一维:一条线 二维:一片山地 6,710 亿维:不画了 Ⓐ 先看一维 —— 脑子里放一个球,从山上滚下来 规则只有一句:斜率为正就往左挪,为负就往右挪 某个参数 → loss 起点 A 起点 B 落在这儿 落在这儿 球一步比一步挪得少 没人让它慢下来 —— 是坡自己变平了 A 落进了更浅的那个谷 只因为它从左边出发 —— 跟谁更优无关 自动刹车 步长 ∝ 斜率 越接近谷底,坡越平 坡越平,步子越小 所以它不会在谷底 来回冲过头 —— 只要步子够小,这一条是免费送的 Ⓑ 加到两个参数 —— 「斜率」这个词就不够用了 一个数说不清方向,得用一个向量 一维:问「斜率是正是负」 一个数就够了 二维:问「往哪个方向走,降得最快」 一个数说不清 —— 它得是个方向 → 这个方向就叫梯度 梯度指的是上坡最快的方向 所以下坡就取它的相反数 而它的长度还顺带告诉你:这个坡有多陡 顺带记一句,后面会兑现:「最快」是相对于你怎么量「这一步迈了多大」说的 —— 换一把尺,最快的方向就跟着变(后面那张 Muon 图的 Ⓒ)。 Ⓒ 到了 6,710 亿个参数 —— 别再想「山」了,换个读法 6,710 亿维的山画不出来,但那一列数是看得懂的 所有参数 排成一列 0.31 −1.24 0.07 ⋮ 6,710 亿个数 + 负梯度 也排成一列 +0.002 −0.910 +0.004 ⋮ 一一对应 → 每一项告诉你两件事 ① 正负:这个参数该往上推还是往下推 ② 相对大小:哪一项改起来更要紧 第二件才是这一格的重点 —— 它不只说往哪走,还说该先动谁 所以「为什么可以」这个问题,答案分成能保证的和不能保证的两半 能保证的:每一步都沿着局部下降最快的方向走,而且步长跟坡度成正比 —— 只要步子别迈得太离谱,loss 就一路在降。 不能保证的:你落在哪个谷取决于从哪儿出发,它不保证那是最低的一个。—— 梯度下降从来没承诺过最优,它只承诺每一步都在变好。
这是全讲的本源那一格 —— 前面讲了梯度怎么算出来,这里讲为什么顺着它走就能变好。
Ⓐ 那两串球是真跑了一遍梯度下降算出来的,不是摆上去的:步子一步比一步小 —— 没人让它慢,是坡自己变平了。
⛔ 而 A 那一串落进了更浅的谷 —— 只因为它从左边出发。看图时先比两个落点的高低,再回头看起点。
出处与口径

📌 Ⓑ 末尾那句「最快是相对于你怎么量一步」取自苏剑林《为什么我们偏爱各向同性?基于最速下降的理解》—— 原话是「梯度反方向是损失下降最快的方向,但这结论是有前提的,最关键的前提是它选取的度量是欧氏范数,如果换一个范数,那么最速方向也就变了」。⭐ 这句前提几乎所有教程都略过,而略过它,Muon 就只能被当成「又一个新优化器」。

📌 「球滚下山」「步长 ∝ 斜率所以不会冲过头」「落在哪个谷取决于起点」「高维时看那一列数的正负与相对大小」四个讲法,取自 3Blue1Brown《Gradient descent, how neural networks learn》官方讲义 —— 已逐条核过原文,图是我们自己重画的。

⭐ Ⓒ 那一整列负梯度,正是反向传播一遍算出来的那一份 —— 所以这一讲的第一节和第三节,接头就在这儿。

一维 → 二维 → 不再画空间。 第一幕:同一条曲线、同一个规则,两个球落进了不同的谷。
第二幕:升到二维,换成等高线俯视 —— 形状还看得见。
⭐ 第三幕是关键:6,710 亿维想象不出来,所以干脆不画空间了 —— 把参数画成一列条,颜色是符号、长度是大小, 它们一根根缩短,就是在下降。
(15 秒无声循环,Manim 渲染。骨架取自 3Blue1Brown 神经网络系列的 叙事结构(源码, CC BY-NC-SA 4.0)—— 只借思路,画面与数据全部自算。 脚本在 tools/manim/。)

那张图留了句不好听的:落在哪个谷,取决于你从哪儿出发。 —— 一维图上这件事很吓人。下面这张是来拆它的。

导数为零 ≠ 走不动了 —— 上一格那个「掉进坑里出不来」,是一维骗你的 这一格回答:为什么参数越多,梯度下降反而越走得通 真谷底:走不了 鞍点:还能走 实测:没遇到过真谷底 Ⓐ 坡度为零的地方不止一种 —— 看两个方向就能分开 每一格画的是同一个点,只是沿两个不同方向切一刀看剖面 真谷底(局部最小) 方向 1 往上 ↑ 方向 2 往上 ↑ 两个方向都往上 往哪走都变差 —— 真的卡住了 山顶(局部最大) 方向 1 往下 ↓ 方向 2 往下 ↓ 两个方向都往下 一推就走 —— 训练里基本遇不到 鞍点(垭口) 方向 1 往上 ↑ 方向 2 往下 ↓ 一个往上,一个往下 顺着往下那个方向,接着走 「垭口」就是鞍点:沿着翻山的那条路,它是整条路的最高点;横过来沿山脊走,它又是最低点。 中文管这种地形叫鞍部。 Ⓑ 要当真谷底,得所有方向都朝上 —— 而只要有一个朝下,就还能走 一维图上只有两个方向可选 一维图上 2 个方向 (图上画了 2 个) 两个都朝上很容易凑齐 —— 所以那种图上坑一个接一个 一个小模型 几万个方向 (图上画了 40 个) 四十个全朝上已经很苛刻了 —— 何况几万个 我们在谈的规模 几千亿个方向 … 画到这儿就到头了 —— 真实的数再乘十亿倍,这一行根本画不下 只要有这一个 只要漏掉一个,它就只是个垭口 —— 接着走 这是定义层面的话,不是概率论证 —— 各个方向的弯曲方向并不彼此独立,所以这里不给「罕见到什么程度」配任何数字。 Ⓒ 而这不只是推理 —— 量过 把训练跑到梯度为零,再看这个点有多少方向是朝上的 0 1 横轴:朝上的方向占比(minimum ratio) 实际训练收敛到的点,都落在这一段 = 1 所有方向都朝上 = 真正的局部最小值 实测一次都没到过 换句话说:训练停下来的那些地方,总还剩一批方向是朝下的 —— 没走,不是因为没路,是因为坡太平了 这根轴是示意,不是实测散点 —— 只画「观测都停在 1 之前」这一个事实,原图见李宏毅投影片。 所以「梯度下降为什么可以」,最深的那半个答案是:参数越多,它越不容易真卡住 好消息:上一格那个「掉进浅坑出不来」的画面,是一维特有的。维度一多,坡度为零的地方绝大多数只是垭口 —— 总还剩一个朝下的方向。 坏消息:卡不住,不等于走得快。垭口附近坡极平、梯度极小,朴素梯度下降(步长 ∝ 斜率)会在那儿磨很久 —— 后面几格讲的那些优化器,一多半是在治这个。
这张图拆掉上一张留下的那个阴影 —— 「掉进浅坑出不来」是一维特有的画面。
Ⓐ 记住垭口这一个词就够了:沿着翻山的路它是最高点,横过来沿山脊走它又是最低点 —— 坡度为零,却照样有路可走。
Ⓑ 要当真谷底,所有方向都得朝上;几千亿个参数就是几千亿个方向,漏一个它就只是垭口。Ⓒ 实测也是这样:训练停下来的那些点,一个真谷底都没遇到过。
⛔ 但别读成「所以随便训」—— 卡不住不等于走得快,垭口附近坡太平,后面那些优化器一多半是在治这个。
出处与口径

📌 「critical point 分 local minima 与 saddle point」「判据是 Hessian 特征值全正与否」「沿负特征值方向可继续下降,但实践中很少这么做」「实测 never reach a real local minima」四条,取自李宏毅2021《类神经网络训练不起来怎么办(一):局部最小值与鞍点》投影片 —— 已逐条核过原文,图是我们自己重画的。

⭐ 他课上还引了《三体Ⅲ·死神永生》里那个能在高维取物的魔法师作比,投影片原话是「从三维空间看它是封死的,在更高维度里并不是」。⛔ 小说情节我们没核,所以只转述这一句,不展开 —— 图上的主比喻用我们自己的垭口。

⚠️ Ⓑ 刻意不给概率:「每个方向朝上朝下各半,所以 d 维全朝上的概率是 2 的 −d 次方」这句话听起来很顺,但特征值的符号并不独立,那个数是编的。只讲定义层面必然成立的部分。

⭐ 原片收尾那句也在本讲别处出现:更小的 batch 和动量都有助于逃离临界点 —— 噪声和惯性,正好是那张 batch 图与 Adam 那两格在讲的东西。

这张图切了两刀给你看剖面,而那个形状本来是三维的。 下面让它转起来。

同一个鞍点,转起来看。 上面那张图只能切两刀给你看剖面;而它真正的形状是这样的。 红线沿一个方向往上翘(走过去 loss 变大), 绿线沿另一个方向往下沉 —— 两条在中间那个点交叉。
⭐ 站在那个黑点上,脚下确实是平的 —— 可绿色那条路一直都在。 (8 秒无声循环,用 Manim 渲染 ——  就是 3Blue1Brown 那套工具的社区版。脚本在 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、同一个起点 —— 两条轨迹都是真滚出来的 唯一的差别:右边那条记得上一步怎么动的 浅坑 深谷 停在这儿 滚到这儿 同一个起点 灰:没有动量 滚进浅坑就停了 —— 而且是真停: 那一点的梯度已经归零 绿:加了动量 带着上一步的速度冲了过去 还冲过了头,再荡回来 但说准一点:它冲得过去,是因为那个坑够浅。动量让你更不容易被小坑绊住,它没承诺过能找到最低的那个谷。 Ⓑ 它凭什么冲得过去 —— 看它刚越过坑底那一刻,两股力在对着干 箭头的长度和方向都按真实数值画 —— 取自上面那条绿轨迹刚越过浅坑的那一步 从这一点出发 ← 往深谷那边 往回退 → 梯度这一项 − 学习率 × 梯度 0.092 它在把它往回拉 惯性这一项 β × 上一步的移动 1.304 它要继续往前 净移动 两项加起来 1.213 惯性赢了 14 倍 看清楚这一刻在发生什么:梯度是反对它继续走的 —— 它刚越过坑底,坡正拽着它回去。是惯性把它带出去的。 Ⓒ 那 β 是什么 —— 「上一步」其实是「过去所有步」,只是越老越轻 每往前追一步就再乘一个 β,所以它是一排按 β 衰减的柱子 这一步 1 步前 9 步前 17 步前 有效窗口 ≈ 10 步 窗口 = 1 ÷ (1 − β) —— β = 0.9 就是 10 步左右。β 不是玄学,它是一个「记多久」的旋钮。 Ⓓ 最后一件容易漏的:你降学习率的时候,其实顺手把摩擦力拧大了 条的长度 = 摩擦系数 λ —— 那才是物理量,β 只是它和步长凑出来的一个数 原来 η = 0.9 β = 0.85 λ = 0.158 记忆窗口 7 步 只把 η 降到 1/10 η = 0.09 β = 0.85(没动) λ = 0.500 摩擦悄悄涨了 3.16 倍 记忆窗口 7 步 同时把 β 提到 0.953 β ← 1−(1−β)√r λ = 0.158 摩擦纹丝不动 记忆窗口 21 步 摩擦系数本该是个常数 —— 可 β 不动、只动 η,它就跟着变了。调完之后记忆窗口从 7 步拉到 21 步(正好 1/√r 倍)。 动量补上了上一格欠的那半句 —— 但它补的是「慢」,不是「最优」 上一格说「卡不住,但走得慢」,动量正是治那个「慢」的第一招:在坡平的地方,梯度这一项快没了,可上一步的移动还在 —— 于是它继续滑。 但别把它讲成「能找到全局最优」。图上那条能出来,是因为那个坑够浅;换个更深的坑它一样出不来。它降低的是「起点决定一切」的程度,不是消除它。
同一条 loss、同一个起点,只多给它一点惯性。灰的那条滚进半路那个浅坑就停了(梯度真的归零,动不了);绿的那条冲过去,落进了后面更深的谷。两条都是真滚出来的。
Ⓑ 是机关所在,而且比预想的更狠:在它刚越过坑底那一刻,梯度其实是在把它往回拉 —— 是惯性以十几倍的优势把它带出去的。箭头长度和方向都按真实数值画。
⛔ 但别读成「能找到全局最优」—— 它冲得过去是因为那个坑够浅。它降低的是「起点决定一切」的程度,不是消除它。
出处与口径

⭐ Ⓐ 两条轨迹、Ⓑ 三个箭头的长度、Ⓒ 那排柱子,全是脚本算的。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.805 倍约 5 步
0.90(最常用)10 倍约 10 步
0.99100 倍约 100 步

⭐ 这就是它全部的本钱。 β = 0.9 的时候,动量最多把有效步长放大到 十倍 —— 坑壁比这个高,它就是冲不出去。

所以「有时候不管用」不神秘,也不是调参没调好: 它带的动能是有限的,而且这个上限你现在就能算。 —— 上面那张图里它冲得过去,就是因为那个坑的深度正好在十倍以内。

⛔ 还有反面:它会冲过头。 越接近谷底,惯性越会把它带过去,于是在底部来回荡几次才停。 动量不是纯赚 —— 它拿「终点附近多晃几下」换「路上不停下来」。

⚠️ 两个都叫「动量」,但 Adam 里那个不放大幅度 —— 这一处很容易混。

  • 经典动量:速度 ← β×速度 + 梯度 —— 恒定梯度下累到 1/(1−β) 倍。它买的是速度。
  • Adam 的一阶矩:m ← β×m + (1−β)×梯度 —— 这是个归一化的滑动平均,恒定梯度下稳态就等于梯度本身, 一点不放大。它买的是方向的稳定,不是速度。

⭐ 同一个名字,两件事:一个攒动能,一个去抖动。 Adam 的步长由 3.3b 那个 0.2 定,跟 β₁ 攒不攒速度无关。

⭐ 所以把动量介绍成「帮你逃出局部最小」,其实是抓了最不常用的那一面。 它每天真正在干的两件事是:在平台上不停下来,和在狭长谷里不横着撞。

同一条曲线、同一个起点,差别只在「上一步的速度留不留」。 灰球没有动量,滚进第一个浅坑就停住了; 蓝球带着攒下来的速度直接冲过去,落进了更深的谷。
⭐ 注意它冲过了头才荡回来 —— 那不是 bug,是动量真实的副作用, 也正是下一段要治的东西。
⛔ 两颗球跑的是同一份代码,唯一的差别是 β 从 0 变成 0.9。 (24.6 秒无声循环,Manim 渲染。 地形与这两条轨迹是脚本当场跑出来的:「先遇到的坑更浅」「灰球停在浅坑」 「蓝球落进深谷」「速度峰值高出近三倍」各有一条断言钉住。 脚本在 tools/manim/。)

这三张图把方向说完了 —— 顺着负梯度走 loss 就在降,维度一多基本卡不死,平地上还能靠惯性滑过去。 这一节只剩一个问题:那一步,到底该迈多大?

3.3b 那一步该迈多大 —— 从一个量纲问题说起

上一小节说清了「往哪边走」。这一小节只回答一个问题: 迈多大一步。

先看一行几乎所有人都写过的代码: 参数 ← 参数 − 学习率 × 梯度

先不谈量纲 —— 两个旋钮就能看出这一行拧反了

📐 先把这一节接回 3.3 那位 1847 年的柯西。

他那篇文章末尾留了一句:用这个方法拿到已经比较接近的值之后, 「可以再用线性的、或者说牛顿的方法」快速逼近。

那句话把整件事切成了两半:一阶负责从远处走过来,二阶负责最后收口。

—— 而这一整节讲的就是「二阶收不起口,怎么办」。

量纲那套是严的,但它不是最快看见问题的那条路。 先用两个旋钮把结论看出来 —— 只用小学算术。

一台机器上只有两个旋钮,此刻误差是 1,000。

  • 甲很灵:拧一格,误差变 100。
  • 乙很钝:拧一格,误差才变 1。

❓ 要把这 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,它就得重调。

这个量纲问题一暴露,SGD 的根本毛病也就出来了

全网络共用一个学习率,而不同参数的梯度尺度能差好几个数量级。 —— 下面两条轨迹同一个谷、同一套规则,只改了学习率。

一个学习率伺候不了所有参数 —— 而中间那个「折中」也不存在 同一个谷、同一套规则,只改学习率 —— 两条轨迹都是真跑出来的 大 5%:炸 小 5%:慢 中间:也不行 Ⓐ 这个谷一个方向陡、一个方向平 —— 陡峭程度差 25 倍 竖着弹的是陡的那个参数,横着爬的是平的那个 谷底 出画面了 起点 红:学习率只大 5% 每弹一次幅度更大 —— 收不住 ↑ 竖直 = 陡的那个参数 → 横向 = 平的那个参数 蓝:学习率只小 5% 不炸了 —— 可你看那串锯齿: 每一步大半的力气花在左右横跳上 真正朝谷底去的只有那一丁点横向位移 两条轨迹的学习率只差一成 —— 一条炸了,一条慢得让人着急。你能下手的区间就这么窄。 Ⓑ 那取中间那个值呢 —— 问题就在这儿:中间也没有好的 下面三行不是估的,是算出来的 再大 5% 陡的方向直接发散 门槛卡死在 2 ÷ 陡峭程度 —— 跟你想不想快无关 就取最大的安全值 平的方向走完一半 要 0.37 × 陡峭比 步 —— 图上这个谷(比 25)= 9 步 而真实模型呢 梯度尺度差几个数量级 比值按 1000 算,同一条公式给出 364 步 —— 而这已经是最快的了 所以这不是「参数没调好」 —— 是这个谷的形状决定的,而形状是模型给你的,不是你能选的。 出路只有一条:别再找那个「最好的全局学习率」了,它不存在 给每个参数配它自己的那一个。—— 而「它自己的」该是多少?下一格给标准答案(一阶导 ÷ 二阶导),再往后讲为什么真实训练里只能估它。 代价也在这儿:「每个参数一个」意味着要为每个参数存东西 —— 这一讲开头那笔 12 字节的优化器状态,根子就是这张图逼出来的。
这张图替掉的是一句纯文字的断言 —— 「梯度尺度差好几个数量级」听着像句套话,画出来就是红色那条弹着弹着飞出了画面。
Ⓑ 才是重点:中间那个「折中」根本不存在。在不发散的前提下能用的最大学习率,让平的那个方向走完一半也要几百步 —— 这不是调参没调好,是谷的形状决定的。
两条轨迹都是真跑出来的,三个数都有 assert 盯着。
出处与口径

📌 「同一个学习率,大了第二次更新就飞出地图之外、小了更新一百次还走不到谷底,所以不同参数应该有不同的 learning rate」这个两难取自 李宏毅《Training Tip》投影片(2025 秋 GenAI-ML 课程)。

⛔ 但他那两个具体数字我们没照抄 —— 抄一个别人挑出来的学习率,等于把别人的地形当成自己的。这里自己搭了谷、自己跑了两遍,每条轨迹都有 assert 盯着。

⚠️ 画面用的陡峭比是 25,不是正文说的「几个数量级」。第一版按 1,000 画,物理没错但画面废了:平方向几十步只挪几十像素,锯齿退化成一根竖线。⭐ 判据:要让人「看见」某个动态,参数按「看得见」选,真实量级交给公式外推。Ⓑ 第三行就是那条外推。

⭐ Ⓑ 那两个步数是闭式算的:平方向每步收缩 (1 − 1.9 ÷ 陡峭比),走到一半就是 log½ ÷ log(那个收缩率)。脚本里拿真跑一遍的结果对过账,差不超过 1 步。

把学习率本身做成一根能走的轴。 滑块从左往右 = η 从小调到大,上面那条轨迹跟着连续变形:
贴着谷底慢慢蹭 → 走得刚好 → 开始左右横跳 → 炸出画面。
⭐ 注意标尺上那三条挨在一起的线:中间红的是发散门槛 (闭式的,2 ÷ 陡方向曲率),两侧细线是它的 ±5% ——  只隔标尺的一成,而跨过去就从收敛翻成发散。
⛔ 而左边那头也不是好消息:η 小到不横跳时, 平缓方向二十六步只走掉三分之一。两头都不满意,这才是「一个学习率」的困境。 (15 秒无声循环,Manim 渲染,脚本在 tools/manim/。 门槛、±5% 的收敛/发散、以及左端那「三分之一」都是脚本当场跑出来并有断言钉住的。)

自适应那条线,核心想法只有一句

别用梯度的大小,只用梯度的方向 ——  把每个参数自己的尺度先除掉。

❓ 可凭什么是「除」?—— 有标准答案,而且小到能当场验。

那一步该迈多大 —— 它其实是有标准答案的 前面只讲了「除完之后是多少」—— 这一格回答「为什么要除」 最优步长 = |一阶导| ÷ 二阶导 Ⓐ 在一条抛物线上,「一阶导 ÷ 二阶导」正好就是「离底还有多远」 所以理论上一步就能到底 —— 不用试、不用调 你在这儿 还差 0.5 最低点 陡 谷 一阶导 2 · 二阶导 4 2 ÷ 4 = 0.5 跟「还差 0.5」一模一样 你在这儿 还差 2 最低点 平 谷 一阶导 1 · 二阶导 0.5 1 ÷ 0.5 = 2 跟「还差 2」一模一样 Ⓑ 而这就解释了一件反直觉的事:梯度大,不代表离得远 所以只看梯度大小,跨参数就会比错 只看一阶导(梯度) 陡谷 2.0 > 平谷 1.0 → 「陡谷那个离得更远,该迈大步」 错了。它其实离底更近(0.5 对 2.0) → 除以二阶导之后 0.5 和 2.0 → 两个都正好对 除完之后,两个参数才可比 Ⓒ 那为什么没人真去算二阶导?因为算不起 这一格把上面那条漂亮的式子,接回我们这一讲的现实 二阶导 每两个参数之间都有一个 几千亿参数 → 根本存不下,更别说算 那就估它 用一阶导的历史 梯度一直很大 → 多半在陡的地方 → 落到实现 Adagrad:累加平方和 Adam:滑动平均 分母上那一坨,就是这么来的 → 所以自适应优化器分母上那一项,不是「一个技巧」—— 它在替二阶导占那个位置 但要说准:它不是二阶导,连量纲都不是。二阶导是 loss ÷ 参数²,而 √v 大致是梯度的均方根,量纲是 loss ÷ 参数 —— 差一个「参数」。所以严格的牛顿步 g ÷ H 本身就 已经是「参数」量纲、不用再乘学习率;而 Adam 的 m ÷ √v 是无量纲的。 而这个差别正好解释了本讲 3.3 那个结论:Adam 把梯度的尺度除干净了,每步大约挪 0.2 × 学习率 —— 既然 m ÷ √v 无量纲,Adam 的学习率量纲就是「参数」本身,跟 S GD 那个「参数² ÷ loss」不是同一个东西。这才是 Adam 的学习率好调、好迁移的真正原因。
这张图回答的是「为什么要除」 —— Ⓐ 在抛物线上,一阶导 ÷ 二阶导正好等于「离底还有多远」,所以最优的一步是算得出来的。
Ⓑ 最反直觉的一格:梯度大不代表离得远 —— 陡谷那个点梯度是 2.0,却只差 0.5。不除以二阶导,两个参数根本不可比。
Ⓒ 收回现实:二阶导在几千亿参数上算不起,所以自适应优化器拿一阶导的历史去估它 —— Adam 分母上那一坨就是这么来的。
出处与口径

📌 「最优步长 = |一阶导| ÷ 二阶导」与「用一阶导去估二阶导」取自李宏毅(台大)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 已经有尺子了(分母),可分子还是当前这一步的原始梯度,它会抖。 所以给分子也做一个滑动平均 —— 那就是动量。

⭐ 于是分子分母对齐了:都是「最近这段时间」的统计量。 分子管方向,分母管尺度。

而这一对齐,它顺手买到了一样没打算买的东西。 论文自己管这个比值叫信噪比:

  • 梯度一直朝一个方向、很稳 —— 分子累得大、分母也稳, 比值接近 1,走满步;
  • 梯度忽大忽小、正负乱跳 —— 分子正负相消变小了, 可分母是平方,不管正负都在涨。比值变小,自动缩步。

⭐ 所以它同时干了两件事:把灵钝差异拉平,外加对拿不准的方向变谨慎。 —— 后面这件事没人设计,是那个形状白送的。

上面这几句,拿几个数当场算一遍就全清楚了。 Adam 只记两笔账:m 记方向,v 记大小。

Adam 的两笔账 —— 拿几个数当场算一遍 m = 梯度的滑动平均(记方向) · v = 梯度平方的滑动平均(记大小) · 每步走 = 学习率 × m ÷ √v(m、v 都已做偏差修正;ε 只防除零,下面忽略) 梯度 m ÷ √v = 走几个学习率 Ⓐ 梯度差一万倍,步子一样大 左边梯度画在对数轴上;右边箭头长度 = 这一步走几个学习率 梯度(对数轴) m v √v 这一步走多远 恒为 0.02 0.02 0.0004 0.02 → 0.02÷0.02 = 1 1 个学习率 恒为 2 2 4 2 → 2÷2 = 1 1 个学习率 恒为 200 200 40000 200 → 200÷200 = 1 1 个学习率 0.01 0.1 1 10 100 1000 大小被 √v 除掉了 —— 一个学习率,就能同时管住这三个参数 Ⓑ 大小没了,剩下的是方向有多一致 每条画前 40 步的梯度(柱);右边是稳态下每步净走几个学习率 一直是 +10 净走 1.00 均值 +2,噪声 ±10 净走 0.19 +10、−10 交替 净走 0 0 1 个学习率 m 正负相消 ≈ ±0.53,√v = 10 → 每步 ±0.05,一来一回 走多远 ≈ 学习率 × 方向有多确定 —— 梯度一致就走满,拿不准就自动缩步 Ⓒ 每步都走一个学习率,到了谷底不会来回蹦吗? 一维的谷:梯度 = 位置 + 噪声。左:位置随步数;右:每步走几个学习率 谷底 +10 远处:每步约 1 个学习率,直着走过去 谷底放大(第 200 步以后,纵轴放大约 4 倍) 谷底 第 600 步 第 200 步 学习率不变: 一直小幅晃 学习率按余弦 降下来:停稳 1 0.2 0 第 600 步 信号压过噪声 ≈ 0.92 谷底只剩噪声,m 自己缩小 ≈ 0.19 Adam 自己会在谷底缩步,但总步长归学习率管 —— 最后停稳,靠的是学习率调度 Adam 故意不看梯度有多大,只看方向有多稳 不同参数的梯度能差几个数量级,「步长 = 学习率 × 梯度」一个学习率顾不过来;除以 √v 等于给每个参数单独归一化,于是一个学习率管得住所有参数。 代价是梯度的大小这条信息被扔了,剩下方向和一致程度 —— 真实训练的梯度大半是噪声,所以典型的一步是零点几个学习率,不是 1。
先看 Ⓐ 右边三支一样长的箭头 —— 梯度差一万倍,每步都正好走一个学习率。
Ⓑ 是剩下的那条信息:方向越一致,走得越满;正负来回跳的,m 自己相消,几乎不动。Ⓒ 回答「到了谷底会不会来回蹦」:谷底的梯度只剩噪声,m 缩到约 0.2,最后停稳靠学习率调度。数全是真跑 Adam 跑出来的,有 assert 盯着。
出处与口径

更新式逐行照 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 的尺度、 跟梯度的大小都脱钩了,只剩一个由 β₁ 定死的系数。

而 0.2 这个常数,顺手解决了「换优化器要不要重调学习率」

别的优化器只要把自己的 update 也对齐到 0.2, Adam 那套调好的学习率和权重衰减就能整套搬过去。 —— Kimi K2 从 Adam 迁到 Muon 用的就是这一招: update RMS 统一成 0.2,其余超参照抄。

📌 同一篇(苏剑林,科学空间)。 这是「量纲」这条线最实用的一个落点: 先把某个量做成常数,常数就能当接口用。

Muon 从零讲一遍:从「正交」到「大锅饭」

Adam 是每个数各除各的;Muon 把整块矩阵当一个东西来处理。 先认识它脚下那个词。

先认识「正交」 —— 垂直的箭头,和只转不拉的矩阵 Muon 后面每一步都踩在这个词上。三格各回答一个问题,箭头都按真实坐标画 原来的箭头 正交:垂直/只转不拉 反例:被拉长了 三个问题 Ⓐ 正交 = 垂直 (3, 4) (−4, 3) 对应位置相乘再相加(内积): 3×(−4) + 4×3 = 0 → 垂直 Ⓑ 正交矩阵:只转不拉 (3, 4) 长度 5 转 30°:长度还是 5 反例:6.28 转 30° 0.866 −0.5 0.5 0.866 两列垂直 反例 1 0.6 0 0.8 两列不垂直 两个矩阵每列长度都是 1,差别只在垂不垂直 Ⓒ 维数上限:平面最多两根 第三根? ① ② 跟 ① 垂直就跟 ② 平行 6 × 2 2 列:6 维里 两根,能垂直 6 行:平面里 六根,不可能 长方形只有短边那一侧能正交 这叫半正交 带走一句:正交矩阵乘上去,只改方向不改长短 Muon 想要的「更新」就是这样一块矩阵:每个方向一样使劲,没有哪个方向被拉得特别长。 可正交的箭头个数有上限:最多等于维数。一块长方形矩阵,最多短边那么多个方向。
先看 Ⓑ 那两根红绿箭头 —— 两个矩阵每列长度都是 1,只差在两列垂不垂直:垂直的只转不拉,不垂直的把 5 拉到 6.28。
Ⓒ 是后面「频率最多几个」的伏笔:个数有上限,等于短边的维数。
出处与口径

本课推导:转 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×2 的小矩阵 [[2,1],[1,2]] 把三件事算一遍 频率 ①:强度 3 频率 ②:强度 1 合起来 Ⓐ 一块矩阵 = 几个分量叠起来 每块格子的颜色深浅 = 那个数的大小(蓝正红负) 2 1 1 2 原矩阵 = 1.5 1.5 1.5 1.5 3 × 频率 ① + 0.5 −0.5 −0.5 0.5 1 × 频率 ② 均衡器上看:两根推子 3 ① 1 ② 能量账(平方和): 元素:4 + 1 + 1 + 4 = 10 强度:3² + 1² = 9 + 1 = 10 一分不差:能量全在这几根推子上 Ⓑ 每个频率能单独拎出来:拆开、各乘强度、再合起来 输入 (1, 0),矩阵直接乘出来是 (2, 1) ① 拆:(1, 0) 在两个频率上各 0.707 (1, 0) 频率 ① 的方向 频率 ② 的方向 0.707 0.707 → ① × 3 ② × 1 ② 各乘强度,再首尾相接 (1.5, 1.5) (2, 1) 跟直接乘一样 拿频率 ① 的方向去乘: [[2,1],[1,2]] × (0.707, 0.707) = (2.12, 2.12) = 3 × (0.707, 0.707) 只出来频率 ①,一点 ② 都不沾 (频率 ② 那个方向乘出来是 1 倍) 这就是「互不干扰」 Ⓒ 频率不住在某一列里:一个频率铺满每一格 左边是随手取的一块 6×4 小矩阵,只画它最强的那一个分量 一个分量:每一格都有份 没有哪一列 「是」这个频率 每一行每一列 都是所有频率的混合 2048 6144 比如 6144×2048 这样的门控矩阵: 频率最多 2048 个 —— 个数来自短边的维数 (上一张图:平面里最多两根互相垂直的箭头,同一个道理) 每个频率的「输出模式」= 全体 6144 个神经元的一种配比: …… 一直到第 6144 个 不是某一个神经元,是所有神经元一起按这个比例动 带走一句:矩阵 = 几个频率各自的强度;能量就是强度的平方和 后面 Muon 动的只有「强度」那一排推子;每个频率的方向,它一根都不碰。
先看 Ⓑ:拆开、各乘强度、再合起来,跟直接乘一模一样 —— 这就是「互不干扰」:每个频率各算各的。
Ⓐ 的能量账(元素平方和 = 强度平方和)后面要用;Ⓒ 防一个常见误会:频率不是某一列,也不是某一个神经元。
出处与口径

本课推导:[[2,1],[1,2]] 的奇异值分解 —— 两个频率的输入模式 (0.707, 0.707)、(0.707, −0.707),强度 3 和 1;numpy.linalg.svd 现算并断言,拆开再合 = 直接相乘也有断言。

注:「频率/振幅/能量」是类比,不是傅里叶变换本身:傅里叶的频率是固定的正弦波,这里的「频率」(奇异方向)由每块矩阵自己决定。共同点只在三条:互不干扰、各有强度、能量是强度平方和。

注:Ⓒ 右下那排配比条是随机数示意,不是任何模型的真实输出模式;6144×2048 只是举一个常见的门控矩阵形状。

有了「频率」这个词,Muon 的一步就说得清了。

Muon 的一步 —— 前面是普通的动量,后面多了一道「把强度拉平」 每一站下面的三根条:同一个更新矩阵里三个频率的强度(例子:10 / 1 / 0.01) 频率 ① 频率 ② 频率 ③(很弱) Ⓐ 一步六站 左边三站就是带动量的 SGD;Muon 自己的东西只在右边三站 ① 这一步的梯度 G 反向算出来的 ② 动量:记性 M ← 0.95·M + 0.05·G 旧的占九成五 ③ 再掺一点当前 U = 0.95·M + 0.05·G Nesterov:往前看一眼 ④ 除以总大小 U ÷ ‖U‖ 所有强度都 ≤ 1 ⑤ 五轮迭代 Newton–Schulz × 5 强度都推到 1 附近 ⑥ 减到权重上 W ← W − 学习率 × k × O k = √max(1, 行/列) 10 1 0.01 0.995 0.0995 0.001 0.70 0.71 0.47 进来的更新:强度差一千倍 比例没变,整体缩到 ≤ 1 差一千倍 → 差不到两倍 比如 6144×2048: k = √3 ≈ 1.73 整体多大,学习率说了算 注:③ 底下的条按满刻度 10 画,频率 ③ 只有 0.01,细到看不见 —— 这正是问题所在 Ⓑ 不是所有参数都走 Muon 只管隐藏层里的二维矩阵;其余仍走 Adam 嵌入表 走 Adam 注意力 Q/K/V/O 走 Muon MLP 三块矩阵 走 Muon norm 的增益 走 Adam 偏置 走 Adam 输出头 走 Adam 一个数、一排数(增益、偏置):只有一个方向,没有「强度」可拉平 —— 原理上用不了 嵌入表和输出头也是矩阵:原理上能用,作者实测交给 Adam 效果更好 —— 这是实测排除 带走一句:Muon = 动量 + 一道「把每个频率的强度拉到差不多」 前面三站跟带动量的 SGD 一模一样;它只比 Adam 少记一份东西(没有二阶矩),多做五轮矩阵乘。
先看 ③ 到 ⑤ 底下那三组条 —— 差一千倍的三个强度,五轮之后差不到两倍。
左边三站跟普通动量一样,所以显存账上它只挂一份动量,比 Adam 少一份。
出处与口径

出处:每一站都对着公开实现 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),这里画的是公开实现的写法。

中间那五轮矩阵乘,只是把每根推子各推一遍。

那五轮在干什么 —— 每个强度各过五遍同一个多项式,方向一根不动 矩阵乘出来的奇数次多项式,只作用在强度上:XXᵀX = U Σ³ Vᵀ(U、V 原样,强度 σ 变成 σ³)。所以只要看「一个数过五遍,变成多少」 经典 1.5x − 0.5x³ Muon 的系数 (3.4445, −4.7750, 2.0315) 频率 ① 频率 ② 频率 ③ Ⓐ 进来多大,五轮后多大 横轴是对数:每一格差十倍 两条虚线之间(0.68 ~ 1.2):「差不多是 1」 超过 1.26:越推越大 0.001 0.01 0.1 1 0.5 1 进来的强度(已除以总大小) 五轮后的强度 0.001 → 0.47 经典的:0.001 → 0.0076 ① 小数每轮放大 3.44 倍 (0 附近的斜率就是第一个系数) ② 大的不会冲出去:落在 0.68~1.2 不追求正好等于 1,「差不多」就够用 ③ 先除以总大小,才能保证 ≤ 1 总大小 = 所有强度平方和开根号, 比哪一个强度都大,一除全部 ≤ 1 经典的 1.5x − 0.5x³ 稳,但太慢: 0.001 五轮后还不到 0.01 Ⓑ 三个频率,一轮一轮看 进来时强度 10 / 1 / 0.01,先除以总大小 10.05 缩放后 第 1 轮 第 2 轮 第 3 轮 第 4 轮 第 5 轮 0.5 1 0.70 0.71 0.47 进来:0.995 / 0.0995 / 0.001 五轮:0.70 / 0.71 / 0.47 大的那个:在 0.7 和 1.1 之间来回晃 小的那两个:每轮放大三倍多,追上来 差一千倍 → 差不到两倍 Ⓒ 能量(强度²)怎么分 一根条 = 100%,三段 = 三个频率各占多少 五轮之前 99% ② 1% ③ 0% 五轮之后 41% 41% 18% 带走一句:五轮迭代 = 把每根推子都推到「差不多一样高」 推的是强度,方向一根没碰;之所以是迭代而不是直接拆开算,是因为几次矩阵乘在显卡上快,还能用 BF16 算。
先看 Ⓐ 两条曲线在最左边的高度 —— 同样从 0.001 出发,经典的五轮后不到 0.01,Muon 的系数到 0.47。
Ⓑ 是三个频率一轮一轮的样子:大的在 0.7 和 1.1 之间晃,小的每轮放大三倍多追上来。Ⓒ:能量占比 99/1/0 变成 41/41/18。
出处与口径

出处:系数 (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」,比这里的单个多项式现算宽一些;我们只报自己算出来的数。

元素全变了,可它没有乱改。

拉平之后 —— 频率方向一根不动,强弱比例故意扔掉 绿的是保住的,红的是丢掉的;最下面一格回答「元素全变了,方向怎么会没变」 保住 丢掉 频率方向 Ⓐ 保住的三样 三样都是数学上严格成立的,不是「大致」 ① 频率方向一根不动 之前 之后 = ② 不会反向:一定是下坡 0 进来 (0,1] → 出去 > 0 不会落到这边 更新 · 动量 = Σ 强度 × 新强度 = 0.995×0.70 + 0.0995×0.71 + 0.001×0.47 ≈ 0.77 > 0 跟动量夹角小于 90°:沿着它走,loss 往下 ③ 零还是零:不凭空造方向 进来 0.30 一轮后 0.91 有一点 进来 0.00 一轮后 0.00 完全没有 Ⓑ 丢掉的:强弱比例 —— 故意的 三个频率,左边是进来的强度(满刻度 10),右边是五轮之后(满刻度 1) 10 1 0.01 进来:差一千倍 0.70 0.71 0.47 五轮后:差不到两倍 → 强的不再更强,弱的被抬起来 排名还会被轻微打乱: 原来最强的 ①(0.70)现在比 ②(0.71)还小一点 这一步本来就是要它这样: 单步里不分大小,大家迈差不多的步子 Ⓒ 「元素全变了」和「方向没变」不矛盾 变的是行箭头和元素的样子;不变的是频率方向 第 1 行 第 2 行 [[2,1],[1,2]] 第 1 行 第 2 行 拉平后:[[1,0],[0,1]] 两行夹角 37°、长度 √5 两行垂直、长度都是 1 蓝虚线 = 频率 ① 的方向:两边一模一样(频率 ② 与它垂直,也一样) 一块动量(示意) 拉平之后 逐元素看,很不像: 余弦相似度只有 0.56 约 31% 的格子连正负号都不同 可频率方向一根没变 变的只是每根推子的高低 带走一句:方向原样、坡照样下,只是不再「谁大听谁的」 行变得两两垂直、等长,是强度拉平顺带出来的;看元素会觉得改得面目全非,看频率会发现一根没动。
绿的三样是严格成立的,红的那样是故意扔的 —— 方向不动、不会反向、零还是零;扔掉的只是强弱比例。
Ⓒ 回答「元素全变了」:行变得垂直等长,是强度拉平的副产品;频率方向一根没动。
出处与口径

本课推导:五轮多项式 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 是矩阵版的「只留正负号」。 再打个比方,就是一锅大锅饭。

一个比方:大锅饭 —— 单步人人约一碗,长期看谁一直被同向推 碗里盛多少 = 这一步在这个方向上迈多大(拉平之后的强度) 有编制 临时工(极弱的方向) 没编制 Ⓐ 这一步怎么分饭 编制(谁有份)每一步都按这一步的数据重新发 动量里强度 10 0.70 碗 有编制:约一碗 动量里强度 1 0.71 碗 有编制:约一碗 动量里强度 0.01 0.47 碗 临时工:半碗 动量里强度 0 0 没编制:没有 强度差一千倍,饭量差不到两倍 完全没有的方向,一粒米也不给 (不凭空造方向) 一锅总共多少饭: 随人数(频率个数)变,最后再乘学习率 Ⓑ 五十步之后:论功行赏 两个方向每一步都分到 0.7 碗;差别只在方向一致不一致 起点 第 50 步 每步同向:走了 35 今天东明天西:原地打转 (平均离起点约 4.0) 单步里人人平等;拉开差距的,是「一直被同一个方向推」 带走一句:强弱没有消失,是从「单步多大」搬到了「多步多一致」 Adam 是每个参数自己按历史定步子;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)。

强弱比例都扔了,凭什么还更好?答案有两条,外加一份家谱。

为什么有用,以及它从哪儿来 —— 一个观察、一个推导、两条支的家谱 Ⓐ 两条理由互相独立:一条是看出来的,一条是算出来的。Ⓑ 每个节点都核过原文 看出来的 算出来的 逐元素支 矩阵支 Ⓐ 为什么拉平强度反而更好 观察:普通更新被少数几个方向霸占 SGD 动量 / Adam 的更新(示意) 正交化之后 → 矮的那一长串:幅度小,可对学习可能很重要 —— 「稀有方向」被抬起来了 (作者原话是推测:based on manual inspection … we speculate) 推导:给「这一步」立一条规矩 规矩:不管输入是什么,这一层的输出变化都不超过一个上限 (输出别一下子变太多,网络才稳) 问:守着这条规矩,loss 降得最多的那一步长什么样? 答:方向照搬梯度的频率方向,强度全部一样 —— 也就是正交化的梯度 同一件事的几何画法:紧接着那张 Muon 总图 Ⓒ 里「方形的那个角」 Ⓑ 家谱:一条「只留正负」,一条「只留方向」 横轴只表示先后,不是等距年份 1993 Rprop Riedmiller、Braun 只用梯度的正负号 2012 / 2014 RMSProp / Adam Hinton 课件 / Kingma、Ba 除以「典型大小」 2018 signSGD Bernstein 等 只用正负号 2015 随机谱下降(SSD) Carlson、Cevher、Carin SVD 正交化,无动量 2018 Shampoo Gupta、Koren、Singer 去掉累积 = 正交化梯度 2022 Orthogonal-SGDM Tuddenham 等 先正交化再动量(SVD) 2024 Muon Keller Jordan 等 动量在前、NS 迭代、BF16 2025 Moonlight / Kimi K2 月之暗面:上规模 加衰减、对齐幅度、QK-Clip 两支之间的桥 —— 苏剑林:Muon = sign 的矩阵版(msign) 对角阵时它就退化成带动量的 signSGD 逐元素:每个数各管各的 大小扔掉,只留正负(或除以典型大小) 带走一句:Muon 不是凭空冒出来的,是「只留正负」那条老思路搬到了整块矩阵上 它自己新的只有两处:动量放在正交化之前,和用几次矩阵乘(Newton–Schulz)把正交化做得又快又能用 BF16。
Ⓐ 两条理由互相独立 —— 一条是作者看出来的(普通更新被少数方向霸占),一条是算出来的(守住「输出别变太多」,最好的一步就是正交化)。
Ⓑ 看箭头:「只留正负」先在逐元素那一支成熟,约三十年后(1993 → 2024)才搬到整块矩阵上。
出处与口径

出处: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。

顺带分清一件容易混的事:「几乎垂直」的叠加,和 Muon 的「严格垂直」(选读,一分钟)

平面里最多两根互相垂直的箭头 —— 那模型里几千个维度,怎么装下更多的概念?

Anthropic 2022 年的《Toy Models of Superposition》研究的就是这件事: 概念个数超过维数时,模型让它们「几乎垂直」挤在一起,互相干扰一点点。这叫叠加。

它跟 Muon 是两件事:叠加说的是权重里装了什么,「几乎垂直」、个数可以超过维数; Muon 说的是每一步的更新长什么样,严格垂直、个数不超过短边维数。 别把一个当成另一个的解释。

下面这张总图,是高手看 Muon 的四个角度: Ⓐ「矩阵版取符号」、Ⓒ 那个方角,就是上面「大锅饭」和「推导」的另一种画法。

Muon —— 同一个动作「扔掉大小,只留方向」,在三种形状上的三个版本 三列并排看,就会发现它们是一件事 · 分开讲就变成三个知识点 标量 对角阵 一般矩阵 Ⓐ 为什么它配叫「矩阵版的符号函数」 每一列都是:左边原样,右边只剩方向 标量 −1 0 +1 0.42 不管它原来是 0.42 还是 42 出来都是 +1 对角阵 +0.8 +1 -0.3 -1 +0.5 +1 对角线上 各管各的 = 拍平成向量 也没差 这一格是「向量做法」的极限 一般矩阵 原来的奇异值 全部拉到 1 方向全留下,大小全扔掉 Ⓑ 「矩阵和向量不都是一堆数字吗」—— 一个例子就能说清 拍平成向量,抹掉的正是这件事 一个矩阵 对角线那几个是特殊的 —— 迹就是它们的和, 而迹在相似变换下不变,还等于所有特征值之和。 拍平 拍平成一个大向量之后 所有位置长得一模一样 —— 淡紫小竖线标的是原来在对角线上的那六个,优化器已经看不出来了。 SGD / Adam 都是这么干的(逐元素) —— 而 Muon 拒绝拍平。 Ⓒ 换一把尺子,就换一个优化器 —— 而尺子的差别就是这两个形状 同一个问题:在「这一步不许迈太大」的区域里,沿梯度方向走最远 σ₁ σ₂ 梯度方向 这一步落在这儿 圆 F 范数 = √(σ₁² + σ₂²) (把矩阵拍平,算欧氏长度) 最远点在梯度方向的延长线上 → 比例原封不动:大的还是大,小的还是小 得到的就是 SGD σ₁ σ₂ 梯度方向 这一步落在这儿 1 1 方 谱范数 = max(σ₁, σ₂) (由「矩阵乘向量」这个动作诱导出来) 最远点是那个角 → 两个奇异值都变成 1 —— 这就是 msign 得到的正是 Muon 同一个梯度 同一个问题 ⬇ 只换了区域的形状 Ⓓ 「每步多做十几次矩阵乘,不会很慢吗」—— 它塞进了一段本来就空着的时间 Muon 原作者在博客里算过这笔账:FLOP 开销低于 1% —— 但那是 FLOP 口径,不是墙钟口径 算这一步的梯度 算力满载 空窗 算力几乎闲着 算下一步的梯度 算力满载 msign 就干在这儿 而且这些矩阵乘尺寸固定、可以并行 —— 不是那种会卡住流水线的活 所以它花的是本来就闲着的算力,换来的是每参数少 4 字节(16 → 12)
Ⓐ 的三列要并排看 —— 分开讲是三个知识点,并排放你自己就看出来了:它们是同一个动作。
Ⓑ 用「迹」回答了「矩阵和向量到底差在哪」;Ⓒ 说明换一把量尺就换一个优化器;Ⓓ 解释了那十几次矩阵乘为什么几乎不要钱。
📌 四条讲法都取自苏剑林《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。一个东西能用,和它被证明过,是两回事。细节见下面的折叠块。

那次翻车的细节:证明错在哪、AMSGrad 是什么、以及为什么大家没换

⛔ 🕰️ 这条「一路往上加」的线上,有一次很少被提的翻车。

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 更激进一层

上面那张图基本讲完了。 这里只补图上没说的三句。

Ⓐ 那三列里,中间那一列值得单独想一下: Muon 作用在对角阵上会退化成逐元素取 sign —— 也就是说,「向量做法」本来就是「矩阵做法」的一个特例。 我们以前把它们当两种东西讲,那是把特例和一般情形讲反了。

公式里不写、但真实存在的那几道

梯度算完,到真正更新之间,还要过: 多卡 all-reduce 求平均 → 按全局范数裁剪一次(防止偶发大梯度炸掉) → 按 schedule 取当前学习率 → 权重衰减 → 才是那一步更新。

这一整条线可以用一句话收: 梯度只告诉你往哪走,优化器决定走多远。

而几十年的演化,全都在回答同一个问题 ——  这个「多远」该由谁说了算:

  • SGD 说 —— 由你说了算,你去调。
  • AdaGrad / Adam 说 —— 由梯度自己的历史尺度说了算。
  • Muon 说 —— 由矩阵的几何说了算。

说到底就这么一条线索。

3.4 换个优化器,账单就跟着变

优化器的选择是一个显存决策,不只是收敛速度的决策。

Muon 那一份不是白省的 —— 两条限制都是作者自己写明的。

  • 只管二维参数。标量、向量,以及 embedding 和最后那个输出头,仍然走 AdamW ——  作者明说输入输出层用 AdamW 效果才最好。 所以整模型省不到那四分之一。

    ⚠️ 这一条里其实藏着两种不一样的排除,值得分开: 标量和向量是原理上不适用 —— 正交化是矩阵上的概念, 得有多个奇异方向才有得拉平;一个向量只有一个方向,「正交化」退化成单纯归一化, 没有信息可言。
    可 embedding 和输出头是二维的,原理上完全做得了 ——  作者还是把它们留给了 AdamW,理由是实测效果更好。 这是实证排除,不是原理排除。

  • 每一步更慢(原文写明)。所以它不是「又快又省」 ——  它把一笔账挪到了另一笔账上:显存那栏减了,单步时间那栏加了。

这跟图上 Ⓓ 那句「塞进了一段本来就空着的时间」不矛盾 ——  「更慢」说的是方向,「塞进空窗」说的是幅度(Muon 原作者在博客里按 FLOP 算是低于 1%)。 而幅度归你的配置管:那几轮是一串互相依赖的小矩阵乘, FLOP 少不代表墙钟短。真要用,在目标配置上自己量。

它的证据方式很硬:Muon 在 NanoGPT 那个刷速度的公开竞赛里把记录提了 35%, 此后(到作者写那篇博客时)十二次破纪录、七个不同的人全都还在用它。 —— 谁能把 AdamW 调到一样好,换回去就能破纪录。没人换。

顺带一句跟上一讲连起来:DeepSeek-V4 大部分模块就是用 Muon 训的 —— 论文(arXiv 2606.19348)摘要里列的三大升级之一。

这几个名字是一条线,不是几个并列选项: 每一代都在治上一代没治住的那种不稳。 —— 对照 6.0 那张失败模式表看,就不用背了。

  • SGD —— 只有方向,没有记忆。 沿陡方向来回弹,沿平方向几乎不动。
  • + 动量 —— 治的是来回弹:把历史梯度做滑动平均, 相反的分量互相抵消,同向的累加起来。
  • Adagrad / RMSProp —— 治的是各参数尺度差太远: 全网共用一个学习率,可不同参数的梯度能差几个数量级 (3.3b 那两条轨迹就是这件事)。 办法是给每个参数各除以自己梯度的均方根。
  • Adam —— 把上面两样合体:一阶矩管方向、二阶矩管尺度。 代价就是那多出来的 8 字节(3.1)。
  • AdamW —— 治的是一个副作用: 权重衰减被二阶矩缩放了 —— 梯度大的参数反而被正则得更弱。 办法是把衰减从梯度里摘出来,直接作用在权重上 —— 论文标题里那个 decoupled 说的就是这件事, 整篇论文主要就干了这一件。
  • Muon —— 治的是更新的方向本身: Adam 逐元素地定每一步,整块矩阵的更新可能被少数几个方向主导。 Muon 对更新矩阵做正交化,让各方向的步子更均匀。

所以「换优化器」从来不是换个名字 ——  是换一个你打算治的病。 而代价永远落在同一个地方:每个参数要额外记几个字节。

插一节:权重衰减本身是什么 —— 以及它为什么会待在优化器里

下面那一问说的是「衰减怎么加」。可衰减本身是什么,这一讲一直只是顺带提。 —— 三问,一次说清。

① 它是什么 —— 而答案跟教科书上那个不一样

一句话:每一步都把权重往零缩一点点。

教科书给的理由是正则化:不让模型靠几个特别大的权重去死记硬背 —— 岭回归那一脉传下来的。

⛔ 可这个理由在大模型预训练上站不住: 单遍过数据、数据量远超参数量,基本没有过拟合的机会。

但配置里它全都在,而且清一色 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 的 vMuon 的正交化
在哪一层抹逐元素,各除各的 整块矩阵,奇异值归一
抹掉的是这个参数自己的梯度尺度 各奇异方向之间的尺度差
轴与轴之间的耦合 够不着(只沿坐标轴缩放,见 3.3b) 够得着 —— 奇异方向本来就是跨轴的

代价也在这儿。Adam 那个分母还携带着一条信息 ——  这个参数「最近」反常不反常。v 一扔,这条就没了。 Muon 只剩动量:方向平滑还在,逐元素的自适应没了。

⚠️ 而且正交化只拉齐了各方向之间,它没说整体该迈多大。 —— 这正是下面 Moonlight 那篇要补「单独定整体更新幅度」的原因; 也是 Kimi K2 把 Muon 的 update RMS 校到 0.2(跟 Adam 那个常数对齐) 之后,Adam 那套超参就能整套搬过去的原因。

从 AdaGrad 到 Adam —— 这不是四个选项,是一条因果链 喂同一串恒定梯度,看各自给出的「有效学习率」—— 健康的应该是一条平线 AdaGrad:掉到 0 RMSProp:开头冲太高 Adam:平 Ⓐ 每一环补上一环的洞,同时留下一个新的 每个节点里那条小曲线,就是它给出的有效学习率(真跑的) SGD 全局一个学习率 尺度差大的参数伺候不了 除以「它自己历史梯度的均方根」 → 每个参数一个尺度 AdaGrad 2011 分母只增不减 → 有效学习率单调掉到 0 累加换成滑动平均 → 分母会遗忘,不再单调掉 RMSProp 2012 没动量,也没偏差校正 → 头几步冲得极高 +动量 +偏差校正 → 方向也平滑了,开头也稳了 Adam 2014 恒定梯度下从第一步起就是平的 Ⓑ AdaGrad 的病在后期 —— 分母只增不减,学习率自己走向 0 横轴是步数,纵轴是有效学习率(稳态 = 1) 1 0 第 600 步 SGD(对照) AdaGrad 跑到第 600 步只剩稳态的 4.1% 注意这跟数据无关 —— 喂进去的梯度自始至终是同一个数,是那个只增不减的分母把它自己压死的。 Ⓒ 而 RMSProp 的病在初期 —— 滑动平均从 0 起步,头几步严重低估 分母被低估 → 更新被放大。Adam 的偏差校正就是来修这一下的 1× 4× 8× 第 400 步 RMSProp(无校正) Adam 若不校正 Adam(有校正) 第一步被放大 32 倍(冲出画面) 而 Adam 若不校正,峰值只有 6.6 倍 —— 因为动量那一项的偏差部分抵消了它 绿线从第一步起就是平的 —— 偏差校正不是小修小补,它把开头那几十步从「不可用」变成了「可用」。 这条链最强的一个证据:后面那个能把前面那个当成特例含进去 Adam 原文自己证了一件事:AdaGrad 就是 Adam 的一个特例(β₁ 取 0、(1−β₂) 取无穷小、学习率按 t 的负二分之一次方退火)。—— 所以这真的是一条链,不是四个并列 的选项。 而每一环都还欠着下一环:Adam 留下的那个洞是权重衰减被卷进了自适应的分母里(AdamW 来修),以及每个参数要挂两份状态(Muon 来省)。这两环本讲后面都有。
上面那条谱系是「每一代治什么病」,这张图是它的示波器—— 每一种病,在这里都有自己的形状。
这不是四个并列的选项,是一条因果链 —— 每一环补上一环的洞,同时留下一个新的。
喂同一串恒定的梯度进去,健康的优化器应当给出一条平线;不平的就是它自己的毛病。AdaGrad 的病在后期(分母只增不减,有效学习率自己掉到稳态的 4%);RMSProp 的病在初期(滑动平均从 0 起步,头一步被放大 32 倍);Adam 从第一步起就是平的。
这条链最强的证据来自 Adam 原文自己:AdaGrad 就是 Adam 的一个特例(β₁ 取 0、(1−β₂) 取无穷小、学习率按 t 的负二分之一次方退火)。
出处与口径

📌 这一格每一环都出自 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 字节里的不同部分

都是在动那 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 替换」的东西,先去摘要里数它到底改了几处。 「两行代码」说的是调用方改两行。

Muon 上规模还得补两样

3.3b 讲的是 Muon 的想法,而想法好用不等于能直接上规模。 2025 年那篇专门做这件事的论文补了两处:加 weight decay(原版没有, 正是上面 AdamW 那一栏治的病),以及单独定整体更新幅度 —— 正交化只把各方向的尺度拉齐了,没说该迈多大。

补完才谈得上「开箱即用」。 论文的规模律实验报告:算力最优设定下,Muon 的计算效率约为 AdamW 的两倍。

📌 arXiv 2502.16982(Moonlight,3B/16B MoE,5.7T token)。 「两倍计算效率」是论文自己的规模律结论,不是我们的实测 ——  而且回想 2.6 那条判据:这类结论换规模要重验。 至今仍未核实的一条:Muon 下主权重是否仍需 fp32。

3.5 学习率:那条曲线到底怎么画

先给一把尺子:它不告诉你最优解,只告诉你有没有离谱。

「学习率设对了吗」 —— 有一条能用眼睛对齐的线 量的是更新量 ÷ 参数本身 —— 是更新量,不是梯度(原文特意强调的) 太小 刚好 太大 黑线 = 1e−3 Ⓐ 三个学习率,同一个网络 —— 看它们各自落在黑线的哪一侧 纵轴对数;黑线是 CS231n 给的经验值 1e−3 —— 一条粗略的经验线,不是定律 10⁻5 10⁻4 10⁻3 10⁻2 10⁻1 10⁰ 步数 → 1e−3 CS231n 的经验线 太小 η=0.000961 刚好 η=0.0288 太大 η=0.865 原文的读法就三句:贴着线 = 大致合适;低太多 = 学习率可能偏小;高太多 = 学习率可能偏大。 它的好处是跟模型大小无关 —— 分子分母同量纲,约掉了。换个模型这条线还在原地。 Ⓑ 可「太大」那条的 loss 反而更低 —— 代价在别处 跑出来就是这样,不藏 —— 所以这条比值不是「让 loss 最低」的指标 0 5 10 15 第一层权重的范数 ‖W‖ 刚好/太小 两条几乎重合 太大 太大那条把权重撑到 4.2 倍,loss 的逐步抖动大了约 9 倍 —— 而学习率再乘 2.1 就直接 NaN。 判据:这个比值不是「loss 最低」的指标,是「你离悬崖多远」的指标。 —— 诊断指标不是优化目标。 这是个玩具问题 —— 所以「loss 更低」在这儿本来就不算数 数据是随机 X → 随机 Y,没有验证集 —— 网络在记忆噪声,谁记得快谁 loss 低。 真实训练里,撑大权重 + 抖动加剧通常换来的是更差的泛化。 但这一格想讲的那条不依赖这个问题的好坏:那条比值线只回答「你的步子相对参数本身是不是一个合理的量级」,它是个体温计,不是治疗方案。
「学习率设对了吗」有一条能用眼睛对齐的线。量的是更新量 ÷ 参数本身(是更新量,不是梯度 —— 原文特意强调),CS231n 给的经验值是 1e−3。
Ⓐ 三个学习率跑同一个网络:太小那条贴在黑线下、「刚好」那条骑在黑线上、太大那条远在黑线上方。
⛔ Ⓑ 是这张图最该看的一格:太大那条的 loss 反而更低 —— 可它把权重撑到 4.2 倍、抖动大了约 9 倍,而学习率再乘 2.1 就 NaN。
所以这条比值不是「loss 最低」的指标,是「你离悬崖多远」的指标—— 诊断指标不是优化目标。
出处与口径

📌 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」是二分搜出来的。

这条曲线你只用做三个决定: 从哪升上来、升到多高、怎么降下去。

两种学习率曲线 —— 形状差很多,落点却撞在同一个数上 纵轴是占峰值的百分比,不是绝对学习率 · warmup 那一小段按真实比例画就是一条竖线,图上放宽了 GPT-3 · 余弦 V3 · 平台+衰减 峰值的 10% Ⓐ 横轴是训练进度(占总 token 数的比例) 两条都归一化了,所以可以直接叠在一起比 0% 25% 50% 75% 100% 训练进度(已消耗的 token 占总量的比例) 100% 50% 10% 占峰值 峰值的 10% GPT-3 余弦 2,600 亿 token 处降到 10% DeepSeek-V3 长平台 10T token 才开始降 warmup 画宽了 GPT-3 真实只占 0.125% Ⓑ WSD 这两年流行起来的理由特别实在 不是「它收敛更好」—— 是它把一个决定往后推了 余弦的硬约束 曲线形状依赖终点 所以你必须一开始就知道总共训多少步 中途想多训一段,整条曲线都得重来 平台段的自由 恒定段可以随时截断 接一小段快速衰减,就能出一个能用的 checkpoint 想加数据接着训,从平台段续上就行 一句话:它把「训多久」这个决定,从开局推迟到了随时 两个落点,一个巧合 warmup 的量级是「总量的千分之几」,不是需要精调的东西 —— GPT-3 占 0.125%,V3 是头 2,000 步。 而且有论文实测:目标学习率固定的话,warmup 拉长基本没收益, 决定效果的是峰值本身。 两条曲线的落点都在峰值的十分之一附近 —— GPT-3 明写「降到 10%」;V3 是 2.2e-4 → 2.2e-5,也正好十分之一(最后一小段再往下到 7.3e-6,约 3.3%)。 两个样 本不构成定律,但足以说明「降到零」不是默认做法。
这张图比的是形状,不是高度 —— 两个模型的峰值差 3.7 倍,不归一化根本叠不到一起。峰值的绝对值另有一份八档对照,在正文里。
看两件事:V3 那条长平台,以及两条曲线都落在同一根「10%」虚线上。
出处与口径

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 中间多了一段又长又平的平台。 —— 「要不要那段平台」正是两派唯一的分歧,留到第三个决定再讲。 下面三个决定挨个拆,每一个都有公开配置可以抄,不用猜。

第一段 · warmup —— 流行的那个解释是错的

大部分教程说: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 让「梯度消失」换了个意思。

这第三条的完整推理链 —— 前提是 Post-LN(6.5 讲为什么)。 你训的要是 Pre-LN,这一条对你不适用,可以直接跳到下面那张表

先看 Adam 的更新量长什么样(原文的写法):

Δθ = −η · E[g] ⁄ √E[g²]

分子分母同量纲,所以那个分式是 O(1),更新量就是 O(η)。 —— 这跟 SGD 完全不同:SGD 的更新量正比于梯度,梯度小,步子就小。

所以在 Adam 底下,梯度消失不再意味着「学不动」 —— 只要梯度还大于随机误差,参数照样拿到常数量级的更新。

⛔ 可「不再学不动」不是好消息 ——  它换成了一个更糟的东西。

梯度小到跟噪声一个量级的时候,分子分母就都是噪声, 而那个比值照样是常数量级。

⭐ 于是步子迈得满满的,只是方向是乱的。

拿 SGD 做个对照就清楚了:SGD 在这种时候是停着不动 —— 难看,但安全。而 Adam 是拿着满格的步长往随机方向冲。

可这恰恰是麻烦的开始。 原文的推理链是这样的(前提:模型确实有明显的梯度消失):

  1. 不做 warmup,一上来就快学。越靠后的层越敏感,学得越快。
  2. 可后面的层是拿前面的层的输出当输入的,而前面的层还没学好 —— 它是在糟糕的输入上快速前进。
  3. 很快它到达一个糟糕的局部最优,学习放缓, 反传回前面的梯度进一步变弱。
  4. 梯度不准了,可 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 全系列(同一套数据、同一套训练流程,只有规模在变):

  • 125M → 6.0×10⁻⁴,batch 0.5M token | 350M → 3.0×10⁻⁴,batch 0.5M | 760M → 2.5×10⁻⁴,batch 0.5M
  • 1.3B → 2.0×10⁻⁴,batch 1M | 2.7B → 1.6×10⁻⁴,batch 1M
  • 6.7B → 1.2×10⁻⁴,batch 2M | 13B → 1.0×10⁻⁴,batch 2M
  • 175B → 0.6×10⁻⁴,batch 3.2M

规律肉眼可见:模型越大,学习率越小、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 越大、学习率就越能调大」这句,还有一层很多人不知道的天花板。

先把常见的那两条摆出来:

  • 平方根缩放:batch 扩大 n 倍、学习率扩大 √n 倍。 —— 推导的出发点是让更新量的噪声强度保持不变 (增量协方差 ∝ η²/B,要它不变就得 η ∝ √B)。
  • OpenAI 用梯度噪声尺度 Bnoise 给出 η* ≈ ηmax /(1 + Bnoise/B) —— 注意这个形式是单调递增且有上界的: batch 再大,学习率也只能逼近 ηmax,不会一直涨。

所以「batch 翻倍学习率就该翻倍」是错的。

还有一层更反直觉的:在 Adam 底下,超过某个 batch 之后最优学习率可能不升反降(所谓 Surge 现象)。 —— 成因、前提,以及它本身仍在争议这件事,都在下面的折叠块里。主线要收的只有一句:别想当然地把任何缩放律往外推。

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 倍。

真正的答案是:这两个数本来就不该放在一起比。

  • batch 完全不是一个量级。GPT-3 175B 是 3.2M token, V3 是 12.6M 起、爬到 62.9M —— 差二十倍。 而这一节反复说:学习率和 batch 是绑着动的。
  • 形状不一样。GPT-3 走余弦、早早就开始降; V3 是 WSD,峰值那个数要一路恒定扛过 10T token。 —— 「峰值」在两条曲线上不是同一个身份的东西。
  • 连参数都不是同一批。MoE 里绝大多数参数每一步只被一小部分 token 碰到。它挨的更新次数和稠密模型不是一个数量级。

判据:一条趋势只在「产生它的那次受控实验」内部可用。 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 的报告都是公开的,这是免费的先验。
  • ② 跨规模不能直接照抄。回到 3.3b 那条: 学习率带量纲。小规模上扫出来的值,要么用可迁移的参数化, 要么在目标规模上小步重验。
  • ③ 判据看两条曲线。loss 炸了、或者 grad norm 出突刺 —— 太大; loss 下得慢、grad norm 一直贴着地板 —— 太小。
    「慢」有绝对刻度可参照(1.0 那把尺): 从 11.8 一路往下掉是正常开局; 掉到 2 附近之后,每 0.01 都很贵。

梯度裁剪是安全带,不是调参手段。 V3 设的是 1.0。靠调裁剪阈值来压住一个太大的学习率, 是在掩盖问题不是在解决问题。

⛔ 最后一条,也是最容易被忽略的: 单报一个学习率数字,是没有意义的。

它必须连着 batch、schedule 形状、总 token 数 一起报 —— 换掉其中任何一个,这个数就不再适用。 上面那两套配置之所以能抄,正是因为它们四样都写全了。

3.5b 那 batch 本身该开多大 —— 为什么大了稳,大过头又不行

上一小节收在「单报一个学习率没有意义,它必须连着 batch 一起报」。 —— 那 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 曲线就变了」—— 就是这么来的。

第二步 · 为什么 batch 开大了会稳

梯度跟 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 会随训练往上爬」三条出处,机制 / 实践 / 框架各一条。

  • 机制:McCandlish 等,An Empirical Model of Large-Batch Training, arXiv 1812.06162(OpenAI,2018)。摘要原话: 「我们发现,随着一次训练中 loss 的下降,噪声尺度会上升」, 并明说这套理论「给出了自适应 batch 训练好处的一个粗略模型」。 —— 临界 batch 会长大,这是它的出处。
  • 实践:DeepSeek-V3 技术报告(arXiv 2412.19437)正文原话: 「我们采用一种 batch 调度策略:在最初 469B token 的训练中, batch 从 3072 逐步增加到 15360,之后保持 15360 不变。」 —— 而 V3 全程用的是 2,048 张卡,没有中途加机器。
  • 框架:Megatron-LM 有一个一等公民的命令行开关 --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 开大就更快」 —— 这句话有个前提,而它通常不写 这一格画的不是结论,是结论的适用区间 左段:没吃满 右段:吃满了 通信:两段都无关 Ⓐ 横轴 batch、纵轴一次更新要多久 —— 这条线是折的,不是直的 大多数讲法只画了左半段 batch → 一次更新的时间 并行度在这儿吃满 几乎是平的 batch 翻倍,时间几乎不变 正比于 batch batch 翻倍,时间也翻倍 卡还没喂饱 卡已经满了 左段 batch 开大是白赚的(步数变少,每步没变贵);右段就不白赚了(步数变少,每步同比变贵)。 Ⓑ 同一句话,在两段里一句成立、一句不成立 而教程里那句「大 batch 更快」,说的几乎都是左段 左段 并行度没吃满 「跑完固定的数据量,大 batch 更快」 成立 —— 步数少了,而每步没变贵 小模型、单卡、教学例子,多半在这儿 右段 并行度吃满了 同一句话 不成立 —— 每步变贵的倍数,正好抵掉步数少的倍数 几百亿参数、几百张卡的训练,基本在这儿 Ⓒ 但通信那一笔不分左右段 —— 它跟 batch 完全无关 所以「batch 越大摊得越薄」这句话,对通信永远成立 每步要汇总的梯度 = 参数量 × 每参数字节数 喂一条序列和喂一千条,传的一样多 → 所以它只会被摊薄 batch 翻倍 → 每 token 分摊的通信减半 这一条在左段右段都成立 这一格真正要留下的,不是「大 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 平均:所有有效 token 一视同仁 ——  长序列因为 token 多,在这一步里说话更响。
  • 按序列平均:每条序列先各自平均,再对序列取平均 ——  长短序列话语权相同,于是短序列里每个 token 的权重更高。

两种算法给出不同的梯度, 而它们的代码差别只有一行。预训练几乎都用按 token 平均 —— 但重点不是选哪个,是知道自己选的是哪个。

这一节有一个没写的点:一个听不清的缩写 —— 作者的备案,读者可以直接跳过

现场提到一个念作「TPS」的量,说「TP 开得太大的时候,TPS 就会很大」。 但按第一步那个式子,TP 开大会让 DP 变少、global batch 变小 —— 三种读法(tokens per step / TP size / tokens per sequence) 都跟这句话对不上,所以没有替他猜,只写了骨架。 判据:听不清的缩写不要替人补全。补错了,读者学到的是一条不存在的关系。

落点:batch 的上限来自样本效率,不是显存。 —— 显存只决定你能不能塞下,塞不塞得对是另一回事。

3.6 另外那两个超参:β₁ 和 β₂ 到底在干什么

Adam 还剩两个数:β₁ 和 β₂。 通常被当成「用默认值就行」,可它们的含义特别清楚。

一句话:β 决定「老的贡献能活多久」。

滑动平均每步乘一个 β 再掺新值,所以有效窗口大约是 1/(1−β) 步。

  • β₁ = 0.9 → 动量的窗口约 10 步。它只负责把方向抖动抹平。
  • β₂ = 0.95 → 约 20 步;β₂ = 0.99 → 约 100 步;β₂ = 0.999 → 约 1000 步。

出处: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。

所以 β₂ 调大 = 分母更平稳但反应更慢;调小 = 跟得紧但噪声大。 —— 这不是玄学,就是一个「记多久」的旋钮。

两笔账记性不一样长,有两个直接后果: 梯度一突变,步子会暂时走样;刚开局那一段,两笔账都凑不满。

两笔账,记性不一样长 —— m 记十来步,v 记得久得多 β 越接近 1 记得越久(窗口约 1 ÷ (1−β) 步):β₁=0.9 约 10 步;β₂=0.95 约 20 步,0.999 约 1000 步 β₂=0.999(原文默认) β₂=0.95(大模型常用) β₁=0.9 Ⓐ 梯度突然变了:m 先跟上,v 慢半拍 → 步子暂时走样 纵轴:每步走几个学习率(m ÷ √v);横轴:变化之后第几步(对数轴) 梯度从 1 跳到 10:步子暂时变大 1 3 5 1 10 100 1000 10000 最多 5.1 倍,2319 步后才回到 1±5% 最多 1.11 倍,43 步就回来 梯度从 10 掉到 1:步子暂时变小 0.5 1 1 10 100 1000 10000 最低 0.10,6767 步后才回到 1±5% 最低 0.29,133 步回来 β₁ < β₂,所以分子比分母反应快 —— β₂ 越大,这段走样越长、越猛 Ⓑ 偏差修正:从 0 起步,开头那几步权重凑不满 1 纵轴:第 t 步,所有历史梯度的权重加起来是多少(= 1 − βᵗ);横轴:步数(对数轴) 0.5 1 0 1 10 100 1000 β₁=0.9:约 50 步就凑满 β₂=0.999:要几千步 β₂=0.95 第 1 步 0.10 第 2 步 0.19 第 10 步 0.65 第 50 步 0.995 第 1 步,梯度是 g: m = 0.1 × g(偏小 10 倍) 修正:m ÷ (1−0.9) = g 第 2 步:m 不是 0 了, 可权重只凑到 0.19, 仍偏小 → 除以 0.19 凑满之后:除以 ≈1 = 修正自己消失 偏差修正只管开头:m 管几十步,v 的要管到它那根曲线凑满为止 β 就是「记多久」,而 Adam 的两笔账记性故意不一样长 m 要跟得紧(方向一变就该知道),v 要看得稳(「平常多大」得多看一阵);代价是梯度突变时,两笔账有一段对不上,步子暂时走样。 偏差修正补的是「从 0 起步」那一下:没有它,开头几步的 m、v 都偏小,两者偏得还不一样多,步子就失真。
先看 Ⓐ 紫色那条冲到五倍的峰 —— 梯度一变大,m 十来步就跟上,v 还在按老的「平常多大」除,步子暂时偏大;β₂ 取 0.95 时这段只多一成、几十步就回来。
Ⓑ 是偏差修正的全部道理:从 0 起步,第 1 步的 m 只有梯度的 0.1,除以 1−β₁ᵗ 正好补回;约 50 步后这个数≈1,修正自己消失。v 那条(β₂ = 0.999)要几千步才凑满,别把 m 的结论套到 v 上。
出处与口径

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。

而 PaLM 在这里做了一件反常的事:让 β₂ 随步数变

它用的是 β₂ = 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 把 GPT-3 手调的那张表自动化了

PaLM 用的其实是 Adafactor,但关掉了分解 —— 论文说这等价于「带参数缩放的 Adam」: 按参数矩阵的均方根去缩放学习率。

而论文自己点破了这跟 3.5 那张表的关系: 「这么做的效果,类似于 GPT-3 那样手工把学习率随规模调小」。

换句话说:3.5 那八档配置是手动解法,参数缩放是自动解法。 而且论文说自动那版还多一个好处 ——  尺度本来就不同的那些参数(embedding、layer norm 的缩放) 不会被按同一个比例一起压下去。

checkpoint 要存什么、为什么正好是那 12 字节 存储的事,不是这三件事

3.7 checkpoint 要存的,正好就是那 12 字节

这一节能用 3.1 那张账单直接推出来, 不用查任何文档。

那 16 字节里,哪些必须进 checkpoint?一格一格问「丢了能不能重建」:

  • bf16 权重(2 B) —— 不用存:它是 fp32 主权重的投影,转一下就有。
  • bf16 梯度(2 B) —— 不用存:下一步重新算一份。
  • fp32 主权重(4 B) —— 必须存,而且不能只存 bf16 版 —— 存成 bf16 再读回来,等于把训练到现在累出来的低位全扔了。
  • 动量 m、二阶矩 v(各 4 B) —— 必须存: 它们是历史,丢了就只能从零重新积累。

所以 checkpoint 的大小 = 那 12 字节 × 参数量。 对 671B:约 7.3 TiB 一份。

但别把这个数安到 V3 头上 ——  3.2 刚说过它的一二阶矩是 bf16,那就是 4+2+2 = 8 字节, 一份 4.9 TiB,比经典口径小三分之一。 省状态的那些做法,省的同时也在省 checkpoint。

这一下解释了两件工程上的事:

  • 为什么 checkpoint 这么大、存这么慢。 —— 它存的不是模型,是优化器。模型本身只占其中的三分之一。
  • 为什么「发布的模型权重」比 checkpoint 小得多。 —— 发布只要那 2 字节的推理权重,而 checkpoint 里那 12 字节全是训练用的 —— 一比六。

⛔ 但只存这 12 字节还不够 —— 还有三样,漏一样都会让「恢复」变成「重来」。

  • ① 步数 —— 因为学习率、β₂、weight decay 都可能是步数的函数(见 3.5、3.6)。
  • ② 数据读到哪儿了 —— 这一条最容易漏,而且漏了最隐蔽: 恢复之后又把同一批数据重训一遍,loss 曲线看着完全正常。
  • ③ 随机数状态 —— dropout、数据打散都要用。

而 §6.2 那个「回滚 + 跳数据」的救火办法,前提正是 ①②。 —— 数据位置说不清,你连「跳掉哪几批」都没法讲。

顺带一个真实的省法:优化器那部分不一定要留在加速器上。 DeepSeek-V3 就把权重的指数滑动平均放在 CPU 内存里、每步异步更新 —— 既不占显存也不占训练时间,用途是提前估计「学习率衰减之后会有多好」。 📌 arXiv 2412.19437 §3.2.3。

3.8 LoRA:大多数人真正会碰到的那种训练

前面整讲算的都是从零开始训。 —— 可绝大多数人这辈子跑的训练,是拿别人训好的模型接着调。

好消息是:这件事不需要任何新概念, 它就是上面那张 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。)

  • 全量微调:6.74e9 × 16 B = 100.4 GiB。
  • LoRA(每层给 Q 和 V 各挂一对,秩 16): 冻结底座 12.55 GiB + adapter 0.125 GiB = 12.68 GiB。

相差 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 挂在哪 —— 这一条很少有人点破:

  • 完全冻住的线性层:它的输入可以不留了 ——  1.3 那第 ② 笔(权重梯度)要用输入,而这一笔已经不算了。
  • 挂了 adapter 的那一层,输入又被钉回去了: 因为 A 吃的是同一个输入, 而算 A 的梯度照样要它。

推论很反直觉:adapter 挂得越全,激活省得越少。 上面那套「只挂 Q、V」激活还能省一点,正是因为 MLP 那三个大矩阵一个都没挂。 「多挂几处效果更好」的代价不在参数量,在激活。

非线性那些算子的输入照样要留, 所以总量只是少一点,不是少一个数量级。 这一段是按 1.3 那两笔账推的,我们没有实测。

⭐⭐⭐ 收口:LoRA 改的是「有多少参数带着那 16 字节」, 没有改变「反向要穿过整个网络」。 —— 参数那一块能按比例砍,链条本身砍不动: 它来自反向传播的数学,不来自你训多少参数。

第 四 节

这张账交给专题五(本讲不展开)

这一节是通向专题五的桥。 把上面几项按大小排一遍,你会发现 ——  ZeRO 那三级,正是照着这个顺序来的。

这一节是专题五的预习,不是本讲那三件事的一部分。 —— 三句话说完,细的都收在下面那个折叠块里。

训练要用的东西,按大小排下来是这个顺序:

优化器状态(12 字节/参数) > 权重 = 梯度(各 2 字节) > 激活(看 batch)

  • 卡装不下的时候,就按这个顺序往外切 —— 先切最大的、而且最少被用到的。
  • 这正好就是 ZeRO 那三级的顺序:先优化器状态,再梯度,最后权重。
  • 但「怎么切、切给谁、切完通信涨多少」整个是 专题五 的事。

带走一句就够:并行策略不是凭空设计出来的, 是被这张账的大小顺序逼出来的。

这张账本身:四项各多大、ZeRO 三级怎么从它推出来、其它几招各在切哪一项 专题五的预习 —— 本讲不要求

4.1 先把账按大小排一遍

把前面三节的东西摆在一起,按占多少排个序 ——  这个顺序本身就是这一节的全部内容。

这一项每参数671B 上占常驻它是什么什么时候用得上
优化器状态12 B7.32 TiB75%fp32 主权重 4 + 一阶矩 m 4 + 二阶矩 v 4只在更新那一瞬间用一次
权重2 B1.22 TiB12.5%bf16 那一份,前向反向都拿它算每一层都要读
梯度2 B1.22 TiB12.5%bf16,跟权重同形反向写、更新后就能扔
常驻小计16 B9.76 TiB100%⭐ 跟 batch、跟序列长度都无关 —— 只要模型定了,这个数就定了。
中间激活——看 batch——反向要用的那一堆中间结果(1.6)⛔ 唯一一个你自己能调的 —— 也是唯一一个能反超上面三项的

前三行都是「每参数几字节 × 参数量」,所以它们的比例永远是 12 : 2 : 2 —— 换多大的模型都不变,换多少张卡也不变。

优化器状态一项就占常驻的 75%。 而它是三项里唯一一个前向反向都用不上的 —— 3.1 说过,它只在更新那一瞬间被读一次、写一次。

⛔ 但第四行不一样 —— 它是唯一一个你自己能调的。

前三项跟着参数量走,你没得选;激活跟着 「这一步同时在场多少 token」走 —— 而那是 micro-batch、梯度累积、 DP 路数、序列长度四个旋钮乘出来的。

所以「谁最大」不是模型的属性,是你这次训练配置的属性。 —— batch 开到某个程度,第四行就会翻到第一行上面去。 那个分水岭具体在哪,5.1 会算给你看。

记住这个顺序 —— 下一小节讲的 ZeRO, 三级分法就是照着它一级一级往下切的。

4.2 ZeRO 的三级,正是照着这个顺序来的

ZeRO 的分级不用背。 把上面那个顺序倒过来读一遍,你就把它推出来了。

ZeRO 的三级 —— 同一根条,被削掉三次 顺序不用背:谁最大、谁最少被用到,就先切谁 权重 梯度 优化器状态 Ⓐ 横条的长度 = 每张卡真正要装下的量 按 75 亿参数、64 路数据并行算 —— 论文 Figure 1 用的就是这组 基线 纯数据并行 每张卡都存一整份 权重 梯度 优化器状态 120.0 GB 每张卡 2Ψ — ZeRO-1 切优化器状态 Pos 权重 梯度 切走了 31.4 GB 每张卡 2Ψ 跟基线一样 ZeRO-2 再切梯度 Pos+g 权重 切走了 16.6 GB 每张卡 2Ψ 跟基线一样 ZeRO-3 最后才切权重 Pos+g+p ≈ FSDP 切走了 1.9 GB 每张卡 3Ψ 1.5 倍 还要装多少 通信量 三段的长度按同一个换算常数画,所以长短可以直接比 这四个数不是抄的,是算的 —— 脚本里带 assert 跟论文 Figure 1 对账,对不上就不让构建。能算的就别抄。 Ⓑ 顺序不是历史巧合 —— 是「多大」和「多久用一次」排出来的 所以这三级不能换顺序,也不用背 每步用几次 → ↑ 每参数几字节 1 次 10 100 2 B 12 B 1|优化器状态 每步只用一次 通信不变 2|梯度 反向结束汇总一次 通信不变 3|权重 每层前向都要 通信 ×1.5 这一角是空的:又大又忙的东西 顺序不用背 —— 沿着「先大后忙」这条线走一遍,排出来的就是 ZeRO 的三级。 而这条判据出了 ZeRO 还能用:先动又大又闲的那一项,最后才碰又小又忙的。 顺带把「基线的 2Ψ」拆开看 —— 它解释了为什么切优化器状态是白捡的 纯数据并行每步那笔 all-reduce,其实是两步:先 reduce-scatter(Ψ)把梯度归约并散开,再 all-gather(Ψ)把结果收回来 —— 合起来 2Ψ。 而 ZeRO-1 要的正好是「散开」那个中间状态:每张卡只更新自己那一份优化器状态。它没有多要一次通信,它只是没把中间结果扔掉。
Ⓐ 是同一根条被削掉三次 —— 虚线框就是切走的部分,右边那个 GB 是每张卡真正还要装下的量。
Ⓑ 解释了顺序:「多大」乘以「多久用一次」。优化器状态最大、又只在更新那一瞬间用 —— 所以它先被切。
能算的就别抄 —— 抄来的数对不上时,你不知道是自己抄错了还是人家印错了;算出来的对不上,当场就报错。
出处与口径

📌 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)。

切的顺序只有一条原则:谁最大、谁最少被用到,就先切谁。

  • ZeRO-1 切优化器状态。它最大,而且只在更新时用一次 —— 切了几乎不增加通信。先切它,性价比最高。
  • ZeRO-2 再切梯度。它跟权重一样大,但反向结束前它可以是散着的 —— 在那之前它可以是散着的。
  • ZeRO-3(≈ FSDP)最后才切参数。因为每一层前向都要用它 —— 一切开,每层都得先 all-gather 把它拼回来。 通信代价是三级里最高的。

所以顺序不是随意的,也不是历史巧合 ——  它是「大小」和「被用到的频率」这两个量排出来的。

📌 出处:Rajbhandari 等,ZeRO: Memory Optimizations Toward Training Trillion Parameter Models,arXiv 1910.02054。 上一节那个「每参数 16 字节」也出自它 ——  同一篇论文既给了账单,也给了切法。

4.3 同一张账单,其它几招各在切哪一项

把 ZeRO 之外那几个常听见的名词摆回这张账单上,它们各自的位置立刻就清楚了:

  • 重算(第二节那个决策)—— 针对激活那一项。
  • offload —— 针对「暂时用不到」的那些项 —— 注意它切的不是「哪一类」,是「哪一段时间」。
  • CP(上下文并行)—— 针对激活里随序列长度涨的那一部分 —— 也就是长上下文下反超优化器状态的那一块。

⭐⭐⭐ 所以这几个名词不是「几种优化技巧」, 是同一张账单上的四个不同栏目各自的对策。 —— 而专题五整讲要做的,就是把「切」这件事本身摊开算。

第 五 节

把这三件事,放到一台你摸得到的机器上

前面讲的都对,但全是 6,710 亿参数、TiB 级的数。 —— 它们没有分母。这一节把同一件事缩到一个你能自己算一遍的模型上。

把前向(专题一讲过)+ 反向 + 更新合成一张表。 而其中最有用的一问不是「总共多少」,是 「峰值出现在哪一个时刻」。

一个 step 的总账 —— 「峰值在哪一刻」要先问「哪一项的峰」 这里算的是全局总量,不是单卡 · 横轴只标阶段,不是真实时长比例 权重 · 不动 优化器 · 不动 激活 · 前向堆 梯度 · 反向堆 Ⓐ 两条不动的,加两条形状正好相反的 下面那四层按真实比例画(global batch = 1 条)—— 所以优化器那一块最厚 开始 前向结束 反向结束 更新完 一个 step 的时间轴 权重 1.22 TiB 优化器状态 7.32 TiB 全程不动,而且是四项里最大的一块 —— 却只在最后那一瞬间被用一次 梯度 1.22 TiB + 激活 162.14 GiB —— 薄成这样是真的 ↑ 上面那两层放大 20 倍 —— 真实比例下它们太薄,两个峰看不出来 激活的峰 前向刚结束,反向还没开始 梯度的峰 反向刚结束,还没更新 两个峰不在同一时刻 先问「哪一项的峰」,再问「在哪一刻」 Ⓑ 「激活大还是优化器状态大」—— 这个问题没有固定答案 因为常驻那块不随 batch 变,而激活线性地随 batch 涨 常驻那一块(不随 batch 变) 9.76 TiB 权重 2 + 梯度 2 + 优化器 12 = 16 B/参数,× 671B 激活 · 同时在场 = 1 条 0.16 TiB 开了全量重算的 128K 序列 激活 · 同时在场 = 62 条 9.76 TiB 到这里才追平 —— 同时在场 = DP 路数 × micro-batch 所以 「谁最大」不是模型的属性,是这次训练配置的属性 —— 换个 global batch,答案就换了。
全专题的收口图 —— 前面四节各自那一块,第一次摆到同一条时间轴上。
Ⓐ 要看的是两条形状相反的带子:蓝的前向堆、橙的反向堆 —— 它们的高点差了大半个 step。
Ⓑ 三根条全是当场算的,脚本里带 assert —— 改任何一个输入,对不上会自己报错。
📌 梯度累积到底省什么、不省什么,在 1.8 有完整的五条。
出处与口径

⭐ Ⓑ 三行都是当场算的: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 条」也是量级,不是阈值

⛔ 全图算的是全局总量,没有任何并行切分 —— 怎么把它摊到多少张卡上,是专题五整讲的事

同一笔账,让它跑一遍。 上面那张图画的是这座山的形状;这段画的是它怎么被堆起来、又怎么塌下去。
■ 常驻(权重 + 优化器状态,14 B/参数)—— 始终不动 |  ■ 激活 —— 前向堆高,反向释放 |  ■ 梯度(2 B/参数)—— 反向才出现,反向结束时最全 |  最下面那排小格 = 61 层,走到哪一层就点到哪一格
⭐⭐ 盯住那根竖线:不开重算时,最高点出现在前向刚走完、反向还没开始的那一刻 (开了重算就不是了 —— 那时峰值挪到反向的第一个瞬间:61 份入口 + 正在重算的那一层,见「激活是一座山」那张图的放大格) —— 不是训练的某个阶段,是一个瞬间。 (三条带的高度按真实字节数算,跟上面那张图同一套口径。 14.6 秒无声循环,Manim 渲染,脚本在 tools/manim/。)
完整的一步总账:四项加起来多少、6ND 为什么低估、峰值出现在哪一刻 全是「装不装得下」—— 专题五的预习,本讲不要求

5.1 显存:四项加起来是多少

前面四节各算各的,现在把它们摆到一起。 这一节全部按全局总量算 —— 不分卡,怎么切是下一讲的事。

📌 常驻那一块的算式,短到可以口算:

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 怎么凑出来的,显存不在乎。

  • 约 1973 条 4K,还是 约 62 条 128K ——  对显存是同一件事。
  • 为什么:激活账里没有随 S² 涨的项 —— 注意力分数矩阵根本不落显存(1.7 那三条边界的第二条)。 剩下的每一项都是「每个 token 一份」,所以它只认 token 总数。

⛔ 但算力不是这样。

同样 808 万 token,拆成长序列和拆成短序列, 要算的浮点数差很多 —— 因为 attention 那部分随 S² 涨, 而它不在显存账上、却在算力账上。

所以序列长度这个旋钮,在两本账上的行为不一样: 显存那本只看总量,算力那本还要看你怎么切。 —— 下一节那个「6ND 严重低估」,讲的就是这件事。

前提说清楚:以上都建立在用了 FlashAttention 这一条上。换成把分数矩阵写进显存的朴素实现, S² 就回到显存账里,上面整段都不成立。

5.2 算力:那个人人都在用的 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 只占百分之一点几, 漏掉它完全无所谓。又是同一件事:不是公式错了,是前提变了。

5.3 峰值:先问「哪一项的峰」

第一节那张山形图给过一个答案:峰值在前向末尾。 那句话只在谈激活的时候成立。

把四项一起画到时间轴上(就是上面那张图), 会看到一件当时看不出来的事:不同的项,峰在不同的时刻。

推广出去,这是一条到处能用的判据:

把几条形状不同的曲线叠起来之后, 总和的峰,未必落在任何一条单独的峰上。 —— 所以「什么时候最挤」这个问题, 必须连着「挤的是哪一项」一起问。

📌 工程上的直接后果: 你去查 OOM,光知道「峰值 xx GiB」没用 ——  要知道是哪一项在那一刻最大,才知道该去动哪个开关。 激活大就开重算 / 上 CP;优化器状态大就上 ZeRO。这两条路走反了,一点用都没有。

5.4 一个 1.25 亿参数的模型,一步里发生了什么

先把这一讲那三件事,在这台机器上各落一句:

  • ① loss 怎么算:8,192 个位置,每个位置一个 −ln p,取平均。 刚初始化时它是 ln(词表),跟 1.0 那把尺一模一样 —— 只是词表小一点,所以起点低一点。
  • ② 一个数变成多少个导数:1.25 亿个。 而代价是「多跑两遍前向」,不是 1.25 亿遍(1.1)。
  • ③ 那一步该迈多大:Adam 要为每一个参数记两个滑动平均 —— 那是 12 字节里的 8 字节;剩下 4 字节是 fp32 主权重, 来自混合精度,跟 Adam 无关(3.1)。

下面这张账把③变成一个你能验的数。

📌 设定:一个 1.25 亿参数的模型,一张卡,batch 8 × 序列 1,024。

12 层、宽度 768、MLP 宽 3,072 ——  这就是 GPT-3 论文表 2.1 的第一行(3.5 那张八档表最上面那档)。

第一步 · 常驻那一块

照搬 3.1 那个 16 字节:

项每参数1.25 亿参数
bf16 权重2 B0.23 GiB
bf16 梯度2 B0.23 GiB
优化器状态(fp32 主权重 + m + v)12 B1.40 GiB
小计16 B1.86 GiB

第一个可以自己验的结论: 这个模型的权重只有 0.23 GiB,而它要占掉 1.86 GiB ——  八倍。多出来的全是训练才要的。

第二步 · 激活那一块

一层里每个 token 留下的东西,一项一项数(宽度 768):

留下的张量宽度
两个 norm 的输出2 × 768 = 1,536
Q / K / V3 × 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 GiB1.86 GiB
激活2.11 GiB0.32 GiB
合计3.97 GiB2.18 GiB
算力3×4×(+33%)

这张小表值得停一下 —— 它就是你笔记本上那个训练循环。

  • 16 字节那张账(3.1)—— 1.86 GiB 是这么来的。
  • 激活随 token 总数长(5.1,就在本节)——  2.11 GiB 里唯一的变量就是那 8,192 个 token。
  • 拿算力换显存(2.2)——  多付 33%,省 6.7 倍。

「多付 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)126.7
这两行的 r 口径略有不同:小模型那一行只数了两个 norm 的输出,V3 那一行(1.7 的表)把 norm 的输入(=残差入口)也数了进去。把入口补上,小模型的 r 是 16、省的倍数 6.9 —— 量级和结论都不变,但严格说这两个数不是同一把尺子量的。
这里原来手写的是「r 约 16、省的倍数约 7.1」。16 是对的,7.1 不是 —— 拿本节自己那个式子代进去得 6.9。而它错得很有代表性:这一格里别的数全是脚本算的,就它是手打的。
V3 671B31.7(一层 MoE 块 ÷ 7,168)6120.5

小模型两项都吃亏:r 小 2.1 倍,L 小 5 倍。 —— 所以它省得少是必然的,不是哪儿算错了。

而 r 大,根子在 MoE:1.7 那张表里 「专家输出」和 SwiGLU 中间结果各存九份 ——  一层里挂的东西多了,重算能省的自然也多。 MoE 在参数账上省,在激活账上贵,而在重算账上又因此格外划算。同一个设计,在三张账上是三个方向。

这个式子给 V3 算出来是 20.8,实测 20.5 —— 略小一点,差在那 3 层 dense 比 MoE 薄。当量级看,别当精确值。

那什么才是真的跟规模无关的?只有这三条。

  • 多付 33%。它只取决于「前向跑两遍而不是一遍」,跟模型多大、序列多长都无关。
  • 每参数 16 字节。1.25 亿和 6,710 亿,拆法一字不差(3.1)。
  • 激活只认 token 总数。8,192 个 token 和 808 万个 token,规律是同一条。

而「省多少倍」不在这个名单里。 —— 它跟着 r 和 L 走,换个架构就得重算一遍。 这正好是第③条判据的又一个实例:会变的和不会变的,得分清楚。

三条边界,跟 1.7 那张表同一套: ① 数是按算子逐项推的,框架融合会让它小一些,当量级看; ② 没算注意力分数矩阵(假设 FlashAttention),也没算临时缓冲、碎片、通信缓冲; ③ 「0.32 GiB」假设每层都设存档点,而那不一定是最省的密度(2.2 Ⓒ)。

这张账交给专题五的是什么 交棒段,属于并行

5.5 这张账单交给下一讲的是什么

专题一算完前向,结论是「装不下」。 这一讲把账补全之后,那句话变得具体了 ——  不是「装不下」,是「四项各自装不下,而且各有各的治法」。

四项 + 四种对策,一一对上:

  • 优化器状态(最大,最少被用到)→ 切(ZeRO-1)
  • 梯度(跟权重一样大,但反向结束前可以散着)→ 切(ZeRO-2)
  • 权重(每层都要用)→ 最后才切(ZeRO-3/FSDP),因为通信最贵
  • 激活(随 batch × 序列长度涨)→ 重算,或者按序列切(CP)

⭐⭐⭐ 你会注意到四条里有三条写着同一个字:切。 —— 那就是专题五整讲要做的事:切这件事本身,也是要算账的。

第 六 节

训不崩 —— loss 飞了怎么办,以及怎么让它别飞

前面整整一讲都在算账。可账算得再清楚,也回答不了训练现场最常见的那一句: 「loss 突然飞上去了,怎么办?」

训不崩 —— 把它当成一条河,三段各治各的 这一节最容易写成一张技巧清单 —— 列完了还是不知道该先动哪个 上游 · 改河道 中游 · 装闸门 下游 · 捞船 Ⓐ 把它想成一条河 —— 同一场水患,三个位置都能下手 从上游到下游:越靠上越治本,越靠下越应急 上游 改河道 把河挖宽、挖直 —— 水本来就不容易漫出来 · 归一化放进残差块里(Pre-LN) · QK-norm —— 别让注意力分数长疯 · 初始化按深度缩一下 一次性:开工前做完,之后不用管 中游 装闸门 水位一高就关闸 —— 不让它冲下去 · z-loss —— 摁住 softmax 前的 logits · 梯度裁剪 —— 按全局范数,常设 1.0 · 关键处用高精度算 常驻:一直开着,便宜,多数不伤质量 下游 捞船 已经翻了 —— 把船捞回来重新开 · 回滚到 spike 之前的 checkpoint · 跳掉那一段数据,再往下跑 · 把出事的时间点和数据位置记下来 每出一次事就得干一次 —— 而且没修好 水往这边流 → loss 飞了 越往下游,越是在救火 —— 而上游那几样开工前做一次就完了,下游那几样每出一次事就得再干一次。 Ⓑ PaLM 做过一个消融,结论跟所有人的第一反应相反 这个消融只花了一次重训,却把一整类猜测排除掉了 拿「坏数据」这个假设验一验 同一批数据 + 换一个时刻 ↓ 结果:不飞。 所以不是数据坏 两个条件同时满足才出事 缺一样都不会飞 这解释了为什么回滚 + 跳数据管用 Ⓒ 这一节真正的难点:让它稳住很容易,难的是稳住而不牺牲质量 ST-MoE 论文 Table 4 的原数 —— 三种做法:基线跑 6 个种子,另两种各跑 3 个 基线 -1.755 稳定 4/6 六次跑崩两次 收紧 update clipping -4.206 稳定 3/3 条短了一大截 —— 看这里 router z-loss -1.741 稳定 3/3 条最长,而且一次没崩 横条越长质量越好(这是个越大越好的指标)。中间那根「稳定 3/3」看着完美,可它把质量打穿了。
Ⓐ 按「治在链条的哪一步」排,不按「有哪些技巧」排 —— 技巧清单列完了,读者还是不知道该先动哪个。
Ⓑ 是 PaLM 那个消融:同一批数据换个时刻喂就不飞,所以 spike 是数据和参数状态撞出来的,不是数据本身坏。
⛔ Ⓒ 中间那根条看着完美(稳定 3/3),可它把质量打穿了。
出处与口径

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

6.0 先给这几种「坏」起个名字 —— 一张对照表

这一讲从头到尾讲过五种不同的坏,可它们散在五个章节里, 各叫各的名字。先把它们并排摆一次 ——  训练现场真正难的不是治,是先认出这是哪一种。

叫什么现场长什么样根因 怎么确认是它治法在哪一节
梯度爆炸 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 那些结构手段在干的事。

中间那两行(舍入吞掉、步长发散)常被一起叫成「训不动」, 可它们的判据正好相反:前者要把步子放大或提精度,后者要把步子调小。 认错了会越治越糟。

6.1 先看一个真实的画面

📏 动手之前,先把 1.0 那把尺拿出来。

「飞了」是个感觉词,而这一节要讲的是判断。换成数就清楚了:

  • 预训练中后期 loss 在 2 上下晃 —— 正常。
  • 突然跳到 6:困惑度从 7 变成 400 —— 模型退回到「只会字频」那一档,但还认得字。
  • 跳回 11.8:那是 ln 129,280 —— 它把学过的东西全忘光了,退回到瞎猜。

所以「飞多高」不是修辞,它直接告诉你还救不救得回来。 —— 跳到 6 通常回滚几十步就能过去;跳回 ln V 基本就是这一段白跑了。

⛔ PaLM 训 540B 的时候,loss 飞了大约 20 次。

而且 —— 梯度裁剪是开着的。 这些 spike 出现在极不规则的时刻,有时候训到很晚才来; 而更小的模型上根本没观察到。

📌 arXiv 2204.02311 §5.1。 「大约 20 次」「尽管梯度裁剪是开着的」都是论文原话。

loss spike —— 它长这样,而且没人能说清为什么 曲线是按论文文字描述画的示意图,不是实测数据 —— 所以纵轴故意不给刻度 540B:约 20 次 更小的模型:没观察到 裁剪开着 Ⓐ 同一张纸上放两条曲线,差别一眼就看出来 横轴是训练步数,纵轴是 loss —— 越低越好,所以主干是往下走的 loss 步数 → 540B 约 20 次 更小的模型 一次都没有 下面这条另起一根纵轴 —— 这里比的是形状,不是谁低 图上只有三件事,而这三件都是论文明写的: ① 时刻毫无规律 —— 挤在一起的有,隔很久才来一个的也有 ② 很晚了还会来 —— 不是「开头不稳,稳了就没事」 ③ 小模型是平的 —— 所以小规模验过不代表大规模安全 Ⓑ 「保险开着还是飞了」听着像悖论 —— 其实是两个量 把上面那段放大来看:裁剪摁住的那条被削平了,飞掉的那条照样飞 ① 裁剪管的是这个量:梯度范数 (纵轴为对数,跨了一个量级) 裁剪阈值 这一截被砍掉 原本要迈这么大 削平的顶 红线每一处都贴着阈值、没有一处越过去 —— 保险 100% 生效了,一次都没漏 ② 可是飞掉的是另一个量:loss (同一段时间、同一批时刻; 纵轴也按这一段放大了) 六个时刻,一次不落 —— 摁住了「迈多大」,没摁住 loss 所以这不矛盾 保险装在 「这一步迈多大」上 事故发生在 「loss」上 它不是失效了, 是保的不是这件事 那到底为什么会飞? 论文说:没找到 所以 §6 后面讲的全部是「绕过去」和「降低概率」,没有一条是「根治」 知道一件事至今无解,跟知道它的三种治法一样重要 —— 否则你会以为是自己配错了参数。 判据:把「这是开放问题」写出来,比把它糊过去更有用。 糊过去的代价,是学员在自己的训练里反复找一个不存在的配置错误。
Ⓐ 只要看两条线的形状差别 —— 上面那条扎满了尖,下面那条是平的。而下面那条是同一套配方的小模型。
Ⓑ 是这一节存在的理由:保险是开着的,事故照样发生。—— 所以后面那些办法全是「绕过去」,没有一条是「根治」。
⚠️ Ⓐ 那条曲线纵轴上一个刻度都没有,这是故意的 —— 没有刻度的曲线是示意,有刻度的才是数据。论文给了前者的描述,没给后者的数。
出处与口径

📌 arXiv 2204.02311(PaLM)§5.1 —— 「大约 20 次」「尽管梯度裁剪是开着的」「更小的模型上没有观察到」均出自该节原文。

⚠️ 曲线为示意:尖峰的位置按「看不出规律」这一条挑出来,高度与宽度论文未给数,故纵轴不设刻度。没有刻度的曲线是示意,有刻度的曲线才是数据。

先记住这个规模效应:小模型上训得好好的,不代表大模型上不会飞。 —— 这跟 2.6 那条「不能跨规模照抄」是同一件事, 只不过这次翻车的不是收益,是训练本身。

6.2 那个最反直觉的消融:不是数据坏

第一反应都一样:肯定是那批数据有问题。 PaLM 团队去验了这件事,做法很干净:

把 spike 前后那几批数据单独拎出来,从另一个更早的 checkpoint 重新喂一遍 —— 结果不飞。

所以 spike 不是「坏数据」造成的, 是这批数据 和 当时那个参数状态 撞在一起才出的事。

换个时刻喂同样的数据,什么都不会发生。

这一下就解释了他们那个看起来很土的办法为什么管用: 回滚到 spike 之前约 100 步的 checkpoint,跳掉那 200–500 批数据,继续跑 —— 之后同一个点就不再飞了。

这不是「修好了」,是「绕过去了」。 论文原话:训练成本太高,他们没能找到一个有原则的缓解办法 —— 这一行至今是开放问题。

6.3 这一节真正的难点:稳住很容易,难的是稳住而不掉质量

「让它别飞」有一堆办法 —— 学习率调到极小、裁剪收到极紧, 都能稳,代价是模型变差。

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-loss3 / 3−1.741 稳了,质量还略好一点

中间那一行是这张表的全部价值: 「稳定 3/3」看着完美,可它是拿质量换来的。 —— 评价一个稳定性手段,必须同时看这两栏。

两个口径要说清楚,不然这张表会被读得太重。

  • 分母不一样。基线跑的是 6 个种子,每个稳定性手段各跑 3 个种子 —— 所以「4/6」和「3/3」不是同一个分母下的比较。 3/3 也就是三次,样本小到不该当成「保证稳定」。
  • 这个实验是刻意挑出来的。作者写得很直白:小模型很少不稳定, 大模型又贵到跑不起足够的种子。于是他们特意选了一个约三分之一概率会崩的配置, 还特意换到多语种数据上 —— 他们发现多语种数据会加剧不稳定, 这样用稍小一点的模型就能做实验。

这不是黑点,是好的实验设计 ——  研究一个罕见故障,你必须先把它变得不罕见。 但读数的时候要记住:这个概率是被调高过的。

📌 arXiv 2202.08906(ST-MoE)Table 4。 论文自己的小标题就是「很多方法能稳住稀疏模型,但代价是质量变差」。

6.4 治法一 · 治数值:不让某些量长太大

z-loss —— 摁住 softmax 前面那个 logits

做法出人意料地简单:在总 loss 上加一项,惩罚 softmax 归一化因子的对数的平方。 —— 它逼着那个 log Z 待在 0 附近,也就是不让 logits 长得太大。

两个地方都能加,而且都有人用:

为什么 z-loss 特别划算:ST-MoE 的解释是 ——  logits 后面接的是指数函数,而指数对输入误差极度敏感。 把输入范围压小,等于直接降低了这一步的数值风险, 而模型并不真的需要那么大的动态范围。

梯度裁剪 —— 它是安全带,不是调参手段

按全局范数裁:把所有参数的梯度当成一个大向量, 范数超过阈值就整体等比例缩回去。常见设 1.0(PaLM、DeepSeek-V3 都是 1.0)。

但 6.1 那句话要记住:PaLM 开着裁剪,照样飞了 20 次。 —— 裁剪拦得住单步的爆炸,拦不住「参数状态已经走到了一个坏地方」。

6.5 治法二 · 治结构:让它天生不容易飞

归一化放在哪儿 —— 这件事顺带回答了 3.5 那个悬案

先把一层拆成三个零件,不然下面那个差别看不出来。 一层不是一条直线,是两条路并在一起:主干是 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 不仅不能缓解梯度消失, 它还是梯度消失的『元凶』之一。」

Post-LN 里,归一化本身就是梯度消失的元凶之一 —— 可它还留着,而且有道理 下面画的是前向的残差直通项 —— 「所以梯度也消失」那一步由正文交代,图上不冒充 Pre-LN:平权 Post-LN:2^(−l/2) 同一条曲线,两种价值 左右两边是同一张图 —— 变的只有底下那个结论 横轴层号,纵轴(对数)= 最初那个输入,在这一层的输出里还剩多少 还剩多少 层 → 1 10⁻¹ 10⁻² 10⁻³ 10⁻⁴ Pre-LN Post-LN Ⓐ 预训练的时候 残差「名存实亡」 越靠近输入,信号被削得越狠 前面的层几乎学不到东西 还剩多少 层 → 1 10⁻¹ 10⁻² 10⁻³ 10⁻⁴ Pre-LN Post-LN Ⓑ 而拿去微调的时候 这正好是你要的 微调只想动靠近输出的那几层 它替你把前面的层按住了 曲线一模一样,连坐标都没动 —— 换的只是「你拿它来干什么」。到第 24 层,Post-LN 的直通项只剩 Pre-LN 的 1/4096。 那为什么不干脆把 LN 去掉? —— 因为方差会一路涨上去 去掉之后 x + F(x) 的方差就是 2,残差越多方差越大,所以还是得加一个 Norm —— 问题从来不是「加不加」,是加在哪儿。 Pre-LN 的加法是 x + F(Norm(x)),最后总输出再加一个 Norm —— 这样每个残差分支是平权的,就没有上面那条指数衰减了。
左右两边是同一张图 —— 连坐标都没动。变的只有底下那个结论框。
红线是 Post-LN:最初那个输入在第 l 层输出里只剩 2−l/2,到第 24 层是 1/4096;绿线是 Pre-LN,一直是 1。
Ⓐ 说这叫「残差名存实亡」,Ⓑ 说这正好替你按住了前面的层—— 同一条曲线,预训练时是毛病,微调时是功能。
⛔ 画的是前向的残差直通项,不是梯度倍率—— 两者相关,但不是一回事。
出处与口径

📌 苏剑林《模型优化漫谈: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 没有这条线,所以那一条对它也就不适用。

QK-norm —— 注意力分数长疯了

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,但它决定了你从一个多好的起点出发。

6.6 顺带清掉两个常见误解

❓ 「bf16 是不是也要 loss scaling?」—— 不用。

一句话版本:同样是 16 个格子,两边的分法不一样。 fp16 把更多格子分给了「分得细」,bf16 把更多格子分给了「够得着多小」。 —— 所以 fp16 的毛病不是不够细,是下不去:梯度一小到某个程度直接变成 0, 那个参数这一步等于没收到任何消息。而 loss scaling 做的事很朴素 ——  搬个位置躲开地板。

loss scaling 是 fp16 时代的必需品:fp16 的指数位只有 5 位, 小梯度会直接下溢成 0,所以要先把 loss 放大若干倍再算、更新前再缩回去。
而 bf16 的指数位跟 fp32 一样是 8 位 ——  动态范围没缩,缩的是尾数精度。所以它不下溢,也就不需要 loss scaling。

fp16 的毛病不是「不够细」,是「下不去」 这一格只有一根真数轴和几条真边界 —— 每个数都是从 IEEE 754 的位模式当场算的 fp16 正规数下界 fp16 归零线 bf16 下界 Ⓐ 同一根对数轴上,两种 16 位格式的下界差了 30 个数量级 轴上越往左数越小;过了红线,那个数在 fp16 里就是 0 这一整段:bf16 存得下,fp16 存不下 30 个数量级 10⁻⁴⁰ 10⁻³⁵ 10⁻³⁰ 10⁻²⁵ 10⁻²⁰ 10⁻¹⁵ 10⁻¹⁰ 10⁻⁵ 10⁰ 大 → bf16 1.18e-38 fp16 归零线 5.96e-08 fp16 正规数下界 6.10e-05 所以 fp16 的问题从来不是「16 位不够细」 —— bf16 也是 16 位,而且尾数比它还少。问题是它的指数位只有 5 位,下界抬得太高。 Ⓑ 那 loss scaling 在干什么 —— 就是把整条分布在这根轴上往右推 乘 1024 = 在对数轴上平移 3.01 格 —— 够不够,看它跨没跨过红线 一个梯度 2e-08 fp16 存 → 0 × 1024 变成 2.05e-05 活下来了 诚实一句:放大之后它落在 fp16 的次正规区(红线右、橙线左)—— 存得下了,但精度打折。要进正规区得用更大的 scale。 而 bf16 根本不用做这件事 —— 它的下界在左边 30 个数量级之外,那些梯度本来就在范围内。 所以「bf16 要不要 loss scaling」这个问题,答案在指数位上,不在位数上 bf16 和 fp16 都是 16 位,可 bf16 把位数分给了指数(8 位,跟 fp32 一样),fp16 分给了尾数(10 位)。 于是 bf16 更粗但更宽。 判据:「精度不够」是个形容词,「这条线左边全没了」是可数的损失。 —— 把一个笼统的担心换成一根能指的线,误解自己就散了。
fp16 的毛病不是「不够细」,是「下不去」。
Ⓐ 一根对数轴上三条真边界:fp16 正规数下界 6.10e−5、fp16 归零线 5.96e−8(再往左就真是 0)、bf16 下界 1.18e−38。中间那一大片绿 —— 30 个数量级,全是 bf16 存得下、fp16 存不下的。
Ⓑ loss scaling 就是在这根轴上整体右移:×1024 = 平移 3.01 格,一个本来归零的梯度就跨过红线活了。
⛔ 每个边界都是从 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.7 全课落点:四条判据

先回到开头那句话。

第零节我说:训练这件事,就是拿一个数,去决定6,710 亿个参数各自该往哪边挪。

现在这句话的每一个字都有着落了:

  • 那个数 —— −ln p,模型对正确答案有多意外。 刚开始是 11.77(在整个词表里瞎猜),训到后来落在 2 附近。 (1.0)
  • 一个数怎么变成 6,710 亿个导数 —— 因为进去的多、出来的少, 所以从输出往回推最划算。6,710 亿次前向,压成了一次反向。 (1.5)
  • 那一步该迈多大 —— 方向是算出来的,步长不是。 半个世纪的优化器史,都在跟这一个没有答案的问题较劲。 (3.3b)

而中间所有那些账 —— 三倍算力、扔不掉的中间结果、 每参数 16 字节。都只是为了把那一个数,从 11.8 挪到 2。

到了 2 附近之后,每往下 0.01 都很贵 —— 而那时候你付的,就是你刚才算过的那整张账。

这一讲还报了几十个数字。但真正想留下的不是那些数。

  • ① 要不要高精度,比的是两个数: 「这一项每一步挪动的相对幅度」,对上「尾数能分辨的最小格」 —— bf16 相邻两个数差 1/128(尾数 7 位,2⁻⁷), 所以「加上去还是被舍掉」的门槛是它的一半,约 1/256。
    这两个数都对,但不是同一个量: 1/128 是格宽(3.2 那张精度图的 Ⓑ 画的 0.0078125 就是它), 1/256 是舍入门槛(差得比半格还小就原地不动)。当判据用的时候看后者。
    滑动平均每步都在遗忘,挪得动;主权重跨十万步累加、单步只挪千分之几,挪不动。 (3.2)
  • ② 该不该重算,看「每省一字节要付多少 FLOPs」。 线性层的这个数恰好等于输入宽度;attention 的随序列长度线性上升 —— 两条斜率不同,必然相交。(2.3)
  • ③ 两个量如果对同一个变量的增长速度不同, 而且长得快的那个起点更低,那它们的排序必然在某一点翻转。 —— 所以任何「A 比 B 划算」的结论,都得带上它成立的那一段区间; 脱离区间的排序是没有意义的。
    那个下划线的前提是 2026-09-20 补的,原来没有 —— 而少了它这条判据就是错的。 长得快的那个要是起点也高,两条线在正半轴上永不相交, 排序从头到尾不变。本讲那个例子(2.4,交点在 S ≈ 13,107)恰好是「慢的起点高」那一种,所以一路都对 —— 一条判据在它自己的例子上永远成立,这正是它最难被证伪的时候。
    补上之后它反而更好用了:要判断会不会翻转,你要查的是两件事 —— 谁长得快,以及谁的起点低。

    本讲里它翻转过好几处,而且每处的那个变量都不一样: 序列长度(2.4)、模型规模(6.1,就在本节)、 以及同一个开关换规模连收益的正负号都变(2.6)。
  • ④ 评价任何一个稳定性手段,要同时看「稳没稳」和「质量掉没掉」。 只看前者的话,把学习率设成零是最优解。(本节 6.3)

⭐⭐⭐ 数字会过期,这四条不会。

这一节刻意一个我们自己的实测都没有 ——  四条全部来自公开论文并逐条核过原文。 理由写在 §七:这一讲已经有太多「自己推的」数了, 稳定性这一块不该再加。

附 录

这一讲的数是怎么核的

这一讲报了几十个数字。它们不是同一种东西。 有的能查到论文原文,有的是我们自己按算子推的 —— 后者可能差一倍,前者不会。

7.0 这些东西在框架里叫什么

回去打开框架,该搜哪个词?

这一讲里的说法在框架里叫什么核的地方
全量重算(2.2) --recompute-granularity full Megatron-LM
training/arguments.py
core/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(...) PyTorch
torch/utils/checkpoint.py
选择性重算,按张量挑 create_selective_checkpoint_contexts + CheckpointPolicy
这就是 2.3 那条判据在 PyTorch 里的落点: 你自己写规则决定哪个算子存、哪个重算
重算(JAX 那边) jax.checkpoint(别名 jax.remat) JAX
jax/_src/ad_checkpoint.py
选择性重算的现成策略 jax.checkpoint_policies.dots_with_no_batch_dims_saveable
名字直接说出了判据:「矩阵乘的结果留着」 —— 正是 2.3 那张表最贵的那几行
梯度累积(1.8 第 ④ 道) ddp.no_sync() —— 上下文管理器
进去之后梯度只在本地累加、不跨卡同步; 退出后的第一次 forward-backward 才同步一次(原文档语)
PyTorch
torch/nn/parallel/distributed.py
「跨卡汇总能藏进计算里」(1.8 第 ② 道) bucket_cap_mb(默认 25 MiB)
梯度攒够一桶就发一次 ——  所以前面的层还在算,后面的桶已经在路上了。 那一道「✅ 能藏」,藏在这个桶里
ZeRO 的三级(4.2) 配置里的 zero_optimization.stage = 1 / 2 / 3 DeepSpeed
runtime/zero/config.py
8-bit 优化器(3.4) bitsandbytes.optim.Adam8bit / AdamW8bit bitsandbytes
optim/__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 到的, 不是凭印象写的 —— 而框架改名是常事。

判据:给了名字,就得给「在哪个文件里能查到」。 —— 否则名字一改,这张表就从「帮忙」变成「误导」,而且不会有任何东西报错。

7.1 查得到出处的(放心抄)

数字 / 说法出处
每参数 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(三条都是原文)

7.2 自己推的(当量级看,别当阈值)

数字推导链它可能错在哪
激活 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 生成 ——  正文写在那个脚本里。