这份讲义怎么用
两个用法。
① 上台讲:照着念,台词、切图、每段几分钟都写着。
② 自学:把这一整份丢给 AI,你会得到一个既有全部背景、
也知道该怎么讲的助教,让它带你走一遍。
内容本身在课件那边,这一份只管「怎么讲」。
课程作者 Chris Yang · Google Cloud AI Infra 架构师。
| 🎯 | 这一节要留下什么 讲完之后台下脑子里该剩的那一句。 |
| 🗣 | 讲稿 黄底的可以照着念。 |
| 🖥 | 屏幕 该滚到课件的哪张图、放大哪一格。
⭐ 这些提示挂了 class="board",构建时逐条对账 ——
指了不存在的图或小节号会当场报出来。 |
| ⚠️ | 别讲什么 这一节最容易跑偏的方向。 |
⏱ 时间:主线 77′
⛔⛔ 2026-09-19 改口径 —— 这一讲不再是一张可以跳着讲的账单。 现场把范围定死成三件事:① 反向传播的原理 ② 梯度下降的原理 ③ loss 怎么算; 而「装不装得下、怎么切到多少张卡上」整个归专题五。
⭐⭐ 所以它现在跟专题三一样,是一条不能跳的链: 一个数(§1.0)→ 这一个数怎么变成6,710 亿个导数(§1)→ 有了导数那一步该迈多大(§3)。
⛔ 第二、四、五节在课件里已经大幅折叠(点得开的那种灰框)—— 台上照着展开着的部分讲就对了; 折叠块里的东西不要现场展开,它们是专题五的预习。
| 段落 | 分钟 | 能不能砍 | 说明 |
|---|---|---|---|
| 零 开场 | 3 | 不能 | ⭐ 新钩子:「模型猜错了,这份『错得多离谱』是一个数」 —— 停两秒,让台下先想「那怎么拿一个数去改6,710 亿个参数」 |
| 一 loss 是什么 + 反向在干什么 | 22 | 不能 | ⭐⭐⭐ 全讲的主菜(原来 §0 的 3 分 + §1 的 15 分,现在合并加长)。 §1.0 新增约 5 分钟:loss = −ln p、那把 11.77 → 2 的尺。 ⛔ §1.7 已折叠,不讲 |
| 二 扔了再算回来 | 7 | 可压到 4 | ⭐ 只讲因果链 + 那条判据(每字节代价 = 输入宽度), 交叉点那张图还是要放。 ⛔ 名次表、两档对照、Megatron 源码那段全在折叠块里,别展开 |
| 三 梯度下降与优化器 | 28 | 可独立成课 | ⭐⭐⭐ 最长,而且这一轮又拆细了: 3.3 为什么顺着梯度走 loss 就会变小(一阶原理 + 鞍点 + 动量)、 3.3b 那一步该迈多大(量纲 → 0.2294 → Kimi K2 拿它当接口)、 3.5 学习率、3.5b batch 开多大(新增约 4 分钟)、3.8 LoRA |
| 四 这张账交给专题五 | 2 | 可砍 | ⛔ 已压成三句话:按大小排 → 就按这个顺序往外切 → 那就是 ZeRO 三级。 说完就走 |
| 五 一台你摸得到的机器 | 6 | 可压到 4 | ⭐ 只剩 125M 那个例子(总账 / 6ND / 峰值都折了)—— 它是全讲唯一能手算的一格,最好别砍 |
| 六 训不崩 + 收尾 | 9 | 收尾不能砍 | ⭐ 那四条判据就在这一节的最末尾(2026-09-22 从第五节搬过来的 —— 原来它在第五节收尾,后面却还有一整节,等于谢了两次幕)。 念完就停,别再补话。 ⭐ 收尾前先回到开头那句「拿一个数改6,710 亿个参数」,把三件事各回收一句 |
| 合计 | 77 | ⚠️ 附录(§7)不进课堂,它是给会后自己查的 |
⛔⛔ 上面那张表是愿望,下面这张是地板。 「地板」= 把这一节的讲稿一个字不落地念完、再加切图滚动的时间, 一句现场发挥都没有。每次 build 现数,不是估的。
| 节 | 台词汉字 | 切图 | 地板 | 计划给的 |
|---|---|---|---|---|
| 第零节 一个数,和 6,710 亿个参数 | 475 | 1 | 2.6′ | 3′ |
| 第一节 一个数怎么变成 6,710 亿个导数 —— 反向传播的原理 | 10,594 | 41 | 63.2′ | 22′ |
| 第二节 代价:那些中间结果扔不掉 —— 以及第一个真正的取舍 | 1,301 | 3 | 7.3′ | 7′ |
| 第三节 有了导数,那一步该迈多大 —— 梯度下降与优化器 | 12,459 | 30 | 69.8′ | 28′ |
| 第四节 这张账交给专题五 | 172 | 1 | 1.1′ | 2′ |
| 第五节 把这三件事,放到一台你摸得到的机器上 | 730 | 3 | 4.4′ | 6′ |
| 第六节 训不崩 —— loss 飞了怎么办,以及怎么让它别飞 | 3,312 | 7 | 18.3′ | 9′ |
| 七节合计 | 167′ | 77′ | ||
⛔⛔ 时间账(每次 build 现数)
讲稿台词 29,043 汉字(按 200 字/分 = 145 分钟) + 86 次切图(每次滚动定位按 15 秒 = 21.5 分钟) —— 合计 167 分钟,而这里面还没算任何讲图、互动、答问的时间。
⭐ 77′ 版:照稿念完就要超 90 分钟 —— 讲稿是给准备用的全量,台上只讲每节「🎯 只留一句」和标 ⭐ 的段落,其余按「别讲什么」砍。
🧵 上台之前:把三条暗线记在心里
⭐ 这一讲会报出几十个数字,但只有三条线。 讲的时候每碰到一次就点一次名 —— 台下记住的会是这三条。
① 每一节都挂在同一条链上:一个数 → 6,710 亿个导数 → 那一步迈多大。 §2 的重算,是第零节那句「要展开,就得留着展开时要用的东西」的直接后果; §3 的优化器,是因为梯度只给了方向、没给步长 —— ⛔ 这一讲从不介绍工具,只推结论。一旦讲成「接下来介绍某某方法」,这条线就断了。
② 同一条判据,换个前提就翻转。 §2 那篇 2022 年的论文(序列长度从 2K 到 128K,结论反过来)、 §5 那个 1.25 亿参数的小模型(同样全量重算,它省 6.7 倍、V3 省 20.5 倍)—— 两次都是「公式没错,前提变了」。
③ 查来的 vs 推来的,每次都要说清楚。
GPT-3 的学习率表、V3 的 schedule、ZeRO 的 16 字节 —— 都是查来的;
104 GiB 那座山、82.1%、62 条序列、六倍反推 —— 都是自己推的。
⛔ 台上把这两类混着报,是这一讲最容易掉的坑。
⭐ 课件最后新加了一节附录,把这两类逐条列了出来
—— 台上不用念,但上台前自己扫一遍;
被追问某个数从哪来的时候,直接翻到那一页。
🖥 投屏怎么放
⭐⭐ 这一讲的图大多是「一格一格讲」的, 整张投到 1280×720 上,最小字会掉到个位数 px。 正确的放法:点开单独一张,用 Ctrl/⌘ + 滚轮放到只剩一格,讲完横向平移。
⭐ 需要整张投的三个时刻(其余一律放大到只剩一格): 第一节的fig-act-bill(那座山要一眼看完)、
第二节那张交叉点图(fig-per-byte ——
它的全部意义就在两个模型的交点不在同一处这个画面上,拆开看就没有了)、
以及第五节开头的总账图(fig-step ——
先整张停三秒,让「四项摆在同一条时间轴上」这个画面落地,再放大)。
⭐ 另外记得课件右下角有个「折叠讲解」按钮(或按 T)。 投屏之前打开它。⚠️ 它收的是正文、列表和图注 —— 小节导语和落点带是刻意留着的(那是骨架)。 ⛔ 不开的话,台下会低头读字,不听你讲。
第零节 一个数,和 6,710 亿个参数(3′)
🎯 这一节只留一句:那 6,710 亿个方向不是从一个数里读出来的,是从它算出来的。
「专题一那一讲,我们跟着一个 token 走完了前向,
模型最后吐出了它的猜测。
今天就从那一刻接着往下走:猜错了,然后呢?」
「这份「错得多离谱」,会被压成一个数。
不是一张表,也不是一个向量 —— 就是一个数。
而训练这件事,从头到尾只在做一件事:
拿这一个数,去决定 6,710 亿个参数各自该往哪边挪、挪多少。
—— 各位先想一想:一个数,怎么可能决定 6,710 亿个东西?」
⭐ 停两秒,让台下真的想。 一定会有人说「信息量根本不够」—— 问得对,这一问就是整讲的主线。
「答案是:那 6,710 亿个方向,不是从这个数里读出来的,是从它算出来的。
信息不在这个数里 —— 它在网络的结构里,
在那一次前向留下的每一个中间值里。
⭐ 这个数只是起点,链式法则负责把它展开成 6,710 亿份。」
⭐⭐ 下面这句是给第二节埋的伏笔,必须说。
「记住这句话,它有一个直接的推论:
要展开,就得留着展开时要用的东西。
后面讲到中间结果为什么扔不掉,根子就在这儿。」
⭐⭐ 然后交代这一讲的排法,这句话必须说。
「所以今天就三件事,一条链:
一,这个数怎么来的 —— loss 到底怎么算。
二,一个数怎么变成 6,710 亿个导数 —— 反向传播。
这一段全讲最该讲透:笨办法要算两万年,而实际只比前向多花两倍的时间。
三,有了导数,那一步该迈多大 —— 梯度下降和优化器。
⭐ 链的一头是一个数,另一头是 6,710 亿次「挪一点点」。」
⭐ 再花半分钟,说清不讲什么、场景是哪一档。
「也先说清楚今天不讲什么:装不装得下,
和怎么切到多少张卡上 —— 那是专题五的事。
今天会顺手报几个数让大家有量级感,但不展开。
最后把场景钉住:今天所有的账,都按 DeepSeek-V3 预训练的真实配置算,
序列长度四千零九十六。凡是出现 128K 的地方,我都会明说那是扩训场景。」
🖥 屏幕:课件 s零 那一屏就够,
不要提前翻到任何一张图。开场热身那道连线题在折叠块里,台上不做。这三分钟全靠嘴。
⚠️ 也不要回答「装不装得下」,不要报优化器状态多大 —— 课件开头就把它划给了专题五。这里只给那条链。
🖥 本节主屏:课件 第零节 一个数,和 6,710 亿个参数 · 本节无图(故意的)
第一节 一个数怎么变成 6,710 亿个导数 —— 反向传播的原理(22′)
🎯 这一节留两样:三倍算力的出处,以及「反向必须用前向的值」这个枢纽。
⛔⛔ 这一节是全讲唯一一处「讲原理」的地方,而它极容易讲砸。 砸法是固定的:一上来写链式法则。⭐ 别那么开始 —— 先让台下感受到笨办法有多笨。
「先问一个笨问题:我怎么知道某一个参数该往哪边调?
最直接的办法 —— 把它动一丁点,整个网络重跑一遍,看 loss 变了多少。
……那6,710 亿个参数,就是6,710 亿次前向。
一次前向按一秒算,跑完要将近两万年。而这还只是一步。」
⭐⭐⭐ 这句是这一节的地基,念完停一下:
「所以反向传播真正解决的问题,不是「怎么求导」 ——
求导是高中的事。
它解决的是:怎么把6,710 亿次前向,压成一次。」
⭐⭐⭐ 但在讲笨办法之前,先补一格 —— 这一格决定了后面有多少人跟得上。 ⛔ 「求导是高中的事」这句话说完,台下会分成两半: 一半点头,一半心里想「我高中就没学明白」。⭐ 而这一讲后面**全部**建立在 三个词上:导数、偏导数、链式法则。花三分钟把它们说完,后面一路顺。 —— 不讲极限,不写公式,就一个词:兑换率。
🖥 屏幕:fig-slider,先只放 Ⓐ。
「把一个参数想象成淋浴的那个旋钮。
右边那个读数就是 loss —— 水温离你想要的那个度数,还差几度。
现在我把这个旋钮往热的方向转一点点,转了零点零一。
读数从 4.00 变成了 4.03,变了零点零三。
⭐ 那这个旋钮的导数就是 0.03 除以 0.01,等于 3。
读作:你动一格,它动三格。」
⛔⛔ 这里要专门停一下强调,这是最容易混的一点。
「注意 —— 导数不是「读数是 4.00」。
4.00 是值。3 是兑换率。这是两件完全不同的事。
⭐ 本讲后面每次说「这个梯度大」,说的都是兑换率大,
不是说这个参数本身大。」
⭐⭐ 趁「兑换率」刚说完,插半分钟讲一下这个词的来历。 ⛔ 现场问过:「导数英文不是 deviation 吗?」—— 这是记混了,要当场纠: deviation 是「偏差」(standard deviation 那个),跟这里不是一个词。 ⭐ 但这一问值得认真答,因为这个词的名字本身就是解释。
「顺带说一句这个词。导数的英文是 derivative ——
不是 deviation,deviation 是「偏差」,另一个词。
⭐ 而 derive 来自拉丁语 dērīvāre:de 是「从…」,rivus 是「河流」。
字面意思是 —— 从一条河里,引一股水出来。」
「所以中文那个『导』字其实翻得很准 —— 导就是引导、引出。
只是今天大家一看『导』就想到『指导』,那个引水的画面丢了。
⭐⭐ 回到刚才那个旋钮:你没有换一条河,你是从这条河里引出了第二条。
原来那条给的是『输入对应多少输出』;
引出来这条给的是『动一格,动几格』。—— 同一个源头,两股水。」
🖥 屏幕:平移到 Ⓑ。 ⭐ 指着那排旋钮讲,手真的按在屏幕上效果最好。
「那「偏导数」的「偏」是什么意思?就三个字:按住不动。
—— 英文是 partial,「部分的」:
求导这件事只做了一部分,一次一个变量。
你看这一排旋钮 —— 我只动中间这一个,其余全按住。
在这个前提下量出来的兑换率,就叫偏导数。
⭐⭐⭐ 而这个淋浴有6,710 亿个旋钮。
把它们各自的那个数排成一列 —— 那一列,就叫「梯度」。
⛔ 所以记住:梯度不是一个数,是6,710 亿个数。」
🖥 屏幕:平移到 Ⓒ。
「最后一个词:链式法则。
问题在于,旋钮不直接连到水温,中间隔着好几级。
第一级:旋钮动一格,中间量甲动两格 —— 兑换率 2。
第二级:甲动一格,乙只动半格 —— 兑换率 0.5。
第三级:乙动一格,离目标差几度动三格 —— 兑换率 3。
⭐ 那从旋钮到那个差值,总兑换率是多少?二乘零点五乘三,等于三。」
⭐⭐ 紧接着补两句 —— 不补,那三个数听着像凭空写上去的。 ⛔ 现场就是在这儿卡住的。
「⭐ 注意每两个框之间那个橙色的小方块 —— 那个才是装置:
一块权重,加一个激活函数。
上面标的那个数不是装置本身,是装置的斜率:
它等于权重,乘上激活函数在当前这一点的斜率。
⛔ 所以那三个数不是我随手写的 —— 每一个都是那个装置算出来的。」
⭐⭐⭐ 然后这一句一定要说,它防止台下把这张图当真。
「⛔ 还有一句得说清楚:这是一维玩具 —— 一个旋钮、一个读数。
真实的一级是七千多维进、七千多维出。
⭐⭐ 那它的「斜率」是多少?不是一个数,是一整张表 ——
出去的每一维,对进来的每一维,都各有一个兑换率。
⛔ 但这里要说准一句:机器里并没有这样一张方阵 ——
一层里那些权重没有一块两边都是七千一百六十八,
那张表只是概念上的。
⭐ 但好消息是:我们从来不把那张表算出来。
反向只做一件事 —— 拿责任去乘它,直接得到上一级的责任。
—— 所以「一路乘起来」这句话是真的,只是乘的是表。」
⭐⭐⭐ 然后给那个比喻 —— 这一句讲完,链式法则这个词就再也不吓人了。
「这件事你其实天天在做:换汇。
人民币换港币一个汇率,港币换美元一个汇率 ——
人民币到美元的总汇率是多少?当然是乘起来。
⭐⭐ 链式法则就这一件事,没有别的。
⛔ 而有意思的是下一句:这一串数,从哪一头开始乘?
结果完全一样,可代价 —— 差两万年。
这就是我们接下来要讲的东西。」
⭐ 收这一格,只要一句:
「所以这一讲后面所有的东西,只用到这三句话:
导数,是你动一格它动几格;
偏导数,是其余全按住时的那个数;
链式法则,是中间每一级乘起来。
没有极限,没有 ε,没有要背的公式。」
⛔⛔ 说「loss 是一个数」之前,先花一分钟把这句话的边界划清 —— 不划,后面 1.5 整节的论证都会被这一句绊住。 ⭐ 现场撞过:「一个 token 有十二万多个数,一条序列四千多个, 乘 batch 更多 —— 你凭什么说它只有一个?」
「先说清楚 —— 你看到的那些数全都存在,
只是它们不都叫 loss。中间压缩了两次。
⭐ 第一次:一个位置上,词表里十二万九千多个词各有一个分数 ——
那是「模型的回答」,不是「答得多差」。
我们只取正确答案那一格的概率,取负对数 ——
十二万九千多,变成一。」
🖥 屏幕:fig-mean 的 Ⓐ
—— 第二次压缩就指着这张网格讲。
「⭐ 第二次:一条序列四千多个位置,各有一个 loss;
乘上 batch,一步就是几千万个。
—— 把它们全部加起来,除以 token 总数。
⭐⭐ 几千万,再变成一。那个数,就是你在 loss 曲线上看到的那个点。」
⭐⭐⭐ 然后给那个「为什么非压不可」—— 这一句是这一格的全部价值。
「那为什么非要压成一个数?这不是为了好看。
⭐⭐⭐ 「输出端只有一个数」,正是「反向只走一遍」的前提。
一会儿 1.5 我会讲:种子插在右边,而右边只有一个数,所以只插一次。
⛔ 可如果最终目标是四千多个数呢?那你就得插四千多次种子。
多目标优化之所以贵,根子就在这儿。」
⭐ 最后拆一个会让台下觉得你前后矛盾的地方,十五秒。
「⚠️ 还有一句得说清,不然等会儿你们会觉得我前后打架:
「loss 是一个数」和「反向的种子有五亿多个数」—— 这两句同时成立。
⭐ loss 这个量是一个标量;可对它求导之后,是「每个位置 × 整个词表」,
五亿多个数。
—— 前者问的是那个量本身,后者问的是它的导数。」
⭐⭐ 在给种子之前,先花两分钟把 logits → loss 走一遍。 ⛔ 「logits」这个词后面要用十几次,而它还没被定义过。
⭐⭐ 先用四十秒交代 logits 从哪儿来 —— 不交代,下一张图开场那排数就是凭空的。
🖥 屏幕:fig-logits。
「先说这排分数是哪儿来的。
一个位置走完整条前向、六十一层过完,手里拿到的是一个向量
—— 七千一百六十八个数。
然后它乘上最后那一块权重,叫 LM head,
形状是七千一百六十八乘十二万九千二百八十。
⭐ 乘完,那个向量就被摊成了十二万九千二百八十个数
—— 词表上每个词各拿到一个分数。」
「⭐ 顺带两个数,都别停太久。
光这一块 LM head 就有九点二七亿个参数。
而所有位置一起算出来的那块 logits,bf16 存下来将近一个 G
—— 比 1.7 那张表里任何一个单独的张量都大。」
🖥 屏幕:fig-softmax,先只放 Ⓐ。
「好,这排数就叫 logits。
⛔ 它可正可负、没有范围,还不是概率。
从它到 loss,中间三步。」
「⭐ 第一步,取指数:全变正数,而且差距被拉开。
⭐ 第二步,除以总和:让它们加起来正好是一。—— 现在它是概率了。
⭐ 第三步,翻开正确答案,取那一格的概率,取负对数。
图上这个例子:正确那格是零点四九八,loss 就是零点六九六。完了。」
⭐ 然后 Ⓑ,一分钟,两个性质各三十秒。
🖥 屏幕:平移到 Ⓑ。
「两个性质,一个漂亮、一个救命。
⭐ 一,给所有 logits 加同一个数,概率完全不变。
所以绝对大小不重要,只有「差」重要 —— 指数干的事,是把「差」变成「比」。
⛔ 二,可别真直接取指数,会炸。真实 logit 能到几十上百,
一取指数就冲出 fp32 的上限。
⭐ 所以实现里先减去这排里的最大值再取指数 ——
靠的正是刚才那条平移不变。数学等价,数值不炸。」
⭐⭐⭐ 然后抛 Ⓒ 那一问 —— 先别给答案,让台下自己发现。 ⛔ 现场就是自己撞上来的,那一下的效果比你直接讲好得多。
「现在你再看一眼那个式子 —— 负 ln p。
❓ 里面只有正确答案那一格的概率。
那其余那十二万九千多个词呢?它们本来应该是零、现在概率大于零
—— 怎么一个都没出现在 loss 里?」
⭐⭐⭐ 停三秒,然后给答案。这一句是这一格的全部。
🖥 屏幕:平移到 Ⓒ。
「⭐⭐ 它们参与了,只是不以自己的名义 —— 它们全在分母里。
正确答案的概率,等于它自己的指数,除以所有格子的指数之和。
而那个和里,装着词表里每一个词。」
「你看这个实算:左边是原来,loss 零点六九六。
右边我只做一件事 —— 把一个「错」的分数抬高一格。
⛔ 而正确那一格,一个字都不改。
⭐⭐⭐ loss 涨到了 零点九七零。」
「而求导之后,它们全部显形:
正确那个是负零点五零,其余四个是正零点一八、正零点一八、正零点零七、正零点零七。
⭐ 每一个错的,梯度正好等于它现在占的概率 —— 占得越多,压得越狠。
加起来正好是零。
⭐⭐ 一句话记住:loss 的式子里看不见它们,梯度里看得见。而训练只用梯度。」
📌 被追问「那交叉熵不是应该对整个词表求和吗」时: 对 —— 完整形式确实是求和,只因为标签是 one-hot, 那个和里只剩一项非零。所以「只看一个」是 one-hot 的结果,不是定义。 ⭐ 反过来验证:标签不是 one-hot 时(label smoothing、蒸馏的软标签), 每一项就真的都会出现在 loss 里。
⭐⭐ 被问「loss 为什么是从十一点几到二」时,答完那个对应关系, 一定要接下面这一格。 ⛔ 全讲说过好几次「到了 2 附近每往下 0.01 都很贵」,却从来没解释过为什么。
「先说它俩的关系:它们不是「像」,它们就是同一个数的两副面孔。
⭐ 困惑度 = e 的 loss 次方,而困惑度的意思是
「模型在几个词之间犹豫」。
所以上端 十一点七七,就是在整个词表里瞎猜;
下端 二,对应在七八个词之间犹豫。
⛔ 顺带说准:上端由词表大小决定,换个词表就换一个数。」
⭐⭐ 在讲 bit 之前,先把「一个数」那三个字画出来 —— 一分钟。
🖥 屏幕:fig-mean,放 Ⓐ。
「看这张网格。
横着是位置:一条序列有四千零九十五个位置,每个位置都在猜下一个字。
竖着是这一批里的每一条序列。
⭐ 所以每一格就是一个 loss,每一格都是一个负 ln p,都在零到十一点七七之间。」
「这张网格有多大?按 V3 的口径 ——
一万五千三百六十乘四千零九十五,六千两百八十九万个格子。
⭐⭐ 把这六千多万个数全部加起来,再除一次 —— 就剩一个数。
⭐⭐⭐ 咱们开篇那句「错得有多离谱,是一个数」——
它就是在这一步变成「一个」的。」
⭐ 两个口径顺带说准,各一句,别展开。
「网格上有几个灰格,指一下 ——
那些位置不算分,不进分母。两种情况。
一种在行尾:这条文章不够长,后面拿空位填满,好摞成一个整齐的方块。
那儿根本没有字,猜什么都没意义。
一种在中间:短文章会几篇拼进同一条里,
拿上一篇的结尾去猜下一篇的开头,也没意义。」
「还有一句得说准:除的是格子数,不是序列数。
⛔ 不是每条序列先平均成一个数、再把这些数平均。
是所有格子一视同仁,加起来除一次。
⭐ 序列长短不一的时候,这两种算法结果不一样
—— 按行平均会把短序列里的每个字看得更重。」
⭐⭐⭐ 接着讲那一列 bit —— 它是这把尺上唯一一个没解释过的东西。
🖥 屏幕:fig-bits,先放 Ⓐ。
「表上第二列是 bit。
⛔ 先把一个误会挡掉:它不是「存这个词要几个字节」。
⭐ 它回答的是:把这个词从候选里挑出来,要问几个「是 / 不是」。
每问一次,候选减半 —— 所以要问几次,就是候选个数取以二为底的对数。」
「看这两把梯子。
左边是刚初始化:候选是整个词表,十二万九千多个。
一次一次砍半下去,要问将近十七次。
右边是训练到后期:候选只剩等效七个,三次就到头了。」
🖥 屏幕:展开下面折叠的 fig-bits-more,放 Ⓐ。
⭐⭐⭐ 这一格是重点,讲慢。台下最容易以为「是这个词变简单了」。
「那候选凭什么变少了?
⭐⭐ 不是这个词自己变简单了 —— 是它前面那段上下文。
没有上下文的时候,整个词表都有份,谁都可能。
有了「今天天气真」这么一句在前面,模型前向一跑,
绝大多数词的概率被压到几乎为零,只剩一小撮还在场。
⭐⭐⭐ 把十二万九千多个候选压成等效七个 —— 这就是模型干的全部活。」
「而这件事可以用一个数量出来:
十六点九八 减 二点八九,等于 十四点零九个 bit。
⭐ 二的十四点零九次方,正好是 一万七千五百倍
—— 候选就是缩小了这么多。
这十四个 bit,就是模型学会的全部东西。」
🖥 屏幕:平移到 fig-bits-more 的 Ⓑ。⚠️ 这一格三十秒,说准就走。
「最后把「等效」这个词说准,别留个错印象。
⛔ 困惑度七,不是说真的只剩七个候选 —— 词表一直是十二万九千多个。
⭐ 它的意思是:这份高低不齐的分布,跟在七个等概率的候选里挑,一样难。
所以困惑度量的不是候选的个数,是「相当于在几个词之间犹豫」。」
⛔⛔ 然后这一句一定要说准,别顺口讲错 —— 我讲的时候就错过一次。
「那为什么越到后面越贵?
⛔ 不是因为「对数尺度把后面压扁了」——
比例上它一点没变:loss 每降零点七,困惑度永远砍一半,
跟你在十一还是在二毫无关系。
⭐ 真正的原因有两条。」
「⭐ 一,绝对收益越来越小。
同样是「降一」:早期从十一点七七降到十点七七,划掉八万多个候选;
可到了 2 附近,从二降到一,只划掉不到五个 ——
因为剩下的本来就没几个了。」
⭐⭐⭐ 第二条才是根子,慢讲,说完停一拍。
「⭐⭐ 二,剩下的那点不确定性,有一部分是语言本身固有的。
「下一个字」真的可以是好几个,谁都猜不准,包括人。
⭐⭐⭐ 所以到了后面,你不再是在学习,你是在撞天花板。
那部分熵是不可约的 —— 模型再好也降不到零。」
📌 顺带一句很实用的:正因为有这个天花板, 比较两个模型的 loss,只在同一份数据、同一个 tokenizer 下才有意义 —— 换一份数据,那个天花板本身就换了。
好,现在给种子。这一段是全讲最好懂的一段,讲慢一点,它能买到后面的耐心。
「起点特别朴素:loss 是一个数。
那第一个梯度长什么样?网络最后吐出一个概率分布 ——
下一个字是「的」的概率零点三、是「了」的概率零点二;
而正确答案是一个只有一格是 1、其余全是 0 的东西。
第一个梯度,就是你猜的减去正确答案。
猜高了的地方是正数,该高没高的地方是负数。这个差,就是整条链的种子。」
⭐⭐⭐ 趁台下还跟得上,把整件事用一句大白话收一次 —— 这一格不要跳。 ⛔ 「梯度」这两个字会把一半的人吓住,而它的本意真的只是「一屋子人各提各的要求, 最后取个平均」。⭐ 先给这句人话,后面那些张量和矩阵乘才会被当成「实现方式」, 而不是「另一件更难的事」。
🖥 屏幕:fig-vote,先只放 Ⓐ。
「一条训练样本看完网络的输出,其实只会提一个要求:
该是「的」,那就把「的」推上去,别的推下去。
而且 —— 推多少,看差多远。 差得越离谱,要求越强烈。
⭐ 这就是刚才那颗种子,「预测减真值」,换成人话就是这一句。
⛔ 但注意:它只是希望。没有人能直接去改输出。」
🖥 屏幕:展开 fig-vote 底下折起来的那张
(fig-vote-bright)。
⛔ 那张的落点「一根权重的梯度 = 上游那一刻的亮度 × 下游传来的责任」
—— 手指按住它,停三秒。这一讲后面整本显存账,全挂在这一句上。
⚠️ 时间紧可以整段跳(下面到「众口难调」之前)。 它另开了一根轴 —— 主线问的是「要求怎么汇总」,这一段问的是 「改哪根线最划算」。跳了也不影响后面, 只是 1.6 讲「激活为什么扔不掉」时要自己补一句 「反向要用到前向那个亮度」。
「输出改不了,那怎么办?
想让一个数变大,其实只有三条路:改偏置、改权重、让上一层更亮。
⭐ 第三条走不通 —— 上一层也改不了,
于是这条要求就往回递了一层。「反向传播」这个名字,全部含义就在这儿。
⛔ 而真正值钱的是第二条,我们就看它。」
⭐⭐⭐ 然后指着那两根线讲 —— 这一格的全部力气都在这儿。 ⛔ 别念结论,让台下自己比那两个数。
「看这两根线,它们连到同一个输出。
上面那根的上游很亮,四点零;下面那根的上游很暗,零点二。
现在我把两根加粗同样多 —— 都加零点一。
⭐ 结果呢?上面那根让输出涨了零点四,下面那根只涨了零点零二。
⭐⭐ 同样的力气,回报差二十倍。—— 而这二十倍,正好是亮度之比。」
⭐⭐ 比完那两个数,立刻点名 —— 不点,台下不知道该把这一格挂在哪。
「说到这儿点个名:刚才那个「回报」,就是这根权重的梯度。
⭐⭐ 一根权重的梯度 = 上游那一刻的亮度 × 下游传来的责任。
这两根线下游的责任是一样的,差就差在前面那个乘数 —— 亮度。」
⭐⭐⭐ 落点。这一句是整本显存账的根,讲完停一拍。
「所以「改哪根线最划算」这个问题,
⭐⭐⭐ 答案不在反向里,在前向里 —— 它由那一刻的亮度决定。
而那个亮度,是前向算出来、必须被存下来的。
⭐ 这一讲后面整本显存账的根子,就在这一句上。」
⛔⛔ 然后把第二条路和这一讲的主题接上。这是本节最重要的一次接头。 ⭐ 讲完这句,后面所有关于「激活为什么扔不掉」的话都不用再论证了。
「回头想想第二条路那句「上游越亮越划算」。
要知道改哪根线回报最大,你得先知道那根线的上游当时有多亮。
—— 而那个亮度,是前向算出来的。
⭐⭐⭐ 所以反向必须回头看前向留下的东西。
这一讲后面要讲的那一大笔显存,根子就在这一句话上。」
🖥 屏幕:平移到 Ⓒ。 ⭐ 这一格是全讲最适合让台下笑一下的地方,别讲得太严肃。
⭐⭐⭐ 但这里要换一个层级讲,别再举那几个字。 ⛔ 上一格的「的 / 了 / 在」是一个位置内部的事; 这一格是位置与位置之间。一举那两个字,两层立刻塌成一层。
「但是 —— 不能只听一个位置的。
⭐ 注意这一格一支箭头就是一个位置,不是一个字。
四千多个位置,每一个都对这块权重提了自己的一份诉求 ——
往哪边改、改多少。
你看它们的方向 —— 各不相同。
⭐⭐ 这才是「众口难调」四个字的实际样子。」
⭐⭐⭐ 然后把它们加起来,让台下自己看那个长度差。
「那就全部加起来。batch 等于二的话,就是八千多支。
⭐ 看右边:各自的长度加起来有六点八,可合力只有两点零六。
⭐⭐⭐ 大部分互相抵消掉了 —— 剩下的那一点,才是真信号。
而这股合力,就是这块权重这一步要挪的方向。」
「⭐⭐ 所以「batch 越大越稳」这件事,到这儿就不玄了:
人越多,偏激的那几支越淹得住。
⭐ 而多卡训练里那道「跨卡汇总」,干的就是这个加法 ——
每张卡先加自己那批,再凑到一起。」
⭐⭐ 最后这一句是给后面几节埋的,一定要说:
「顺便说一句,后面讲多卡训练的时候,会有一道叫「跨卡汇总」的东西。
它干的就是这个平均 —— 每张卡先收自己那批人的意见,再凑到一起。
⭐ 所以 batch 这个东西,不是为了把卡喂饱才有的。
它首先是「别只听一个人的」。」
⭐⭐⭐ 这里要补一格,两分钟。它是现场问出来的,而且问出了一个真的洞。 ⛔ 刚才那张图写的是「样本一、样本二」—— 那个词会骗人。
🖥 屏幕:fig-push,先只放 Ⓐ。
「先纠一个我刚才讲漏的:一条序列,不是一个意见。
一条四千多长的序列,它自己就是四千多个意见 ——
每一个位置都在预测下一个字,每一个位置都有自己的诉求。
⭐ 而且每一个诉求,还是整个词表那么长的一排数。」
⭐⭐⭐ 然后答那一问。这句是这一格的全部,说完停一拍。
「那反向的时候,是只把对的那个推上去,还是错的那些也各自推下去?
—— ⭐⭐ 都做。而且是同一个动作。
你看这一格:正确答案是「的」,网络给它打了零点四。
那「的」这一格拿到的数是 零点四减一,负零点六 —— 负号,往上推。
而「了」现在占了两成,它拿到的是 正零点二 —— 正号,往下压。
⭐ 力度正好等于它现在占了多少:占两成的那个,被压的劲是占一成那个的两倍。」
⭐⭐⭐ 接着抖这一下 —— 它是这张图真正的高点。
「⭐⭐ 现在你把这一排数加起来看看:
负零点六,加零点二,加零点二,加零点一,加零点一 —— 正好是零。
⭐⭐⭐ 概率总量是守恒的。所以「推上去」和「压下去」根本不是两件事,
它是一次再分配。
⛔ 所以错的那些不是副作用 —— 它们每一个都领到了自己那一份。
至于剩下那十二万多个概率几乎是零的字?它们的那一份也几乎是零
—— 本来就没占地方,不用动。」
🖥 屏幕:平移到 Ⓑ,再到 Ⓒ。 ⛔ 这两格各三十秒,别停 —— 它们只是把 Ⓐ 那一套乘上去。
「Ⓑ:一条序列,四千零九十五个这样的位置。
⛔ 不是四千零九十六 —— 最后那个字没有「下一个」可预测。
Ⓒ:batch 等于二,唯一变的就是那个分母,从四千零九十五变成八千一百九十。
⭐ 「平均」发生的全部地方,就在这个除法上。」
⭐⭐ Ⓑ 那排箭头要补一句,十五秒。
不补的话,台下会把它读成「这个位置往哪边推」—— 那个读法是错的。
「看 Ⓑ 每个位置底下那支箭 ——
⛔ 它不是「这个位置往哪边推」。
到了这一层,已经没有单一的方向了。
⭐⭐ 词表上每一行都拽着一个七千多维的向量,
十二万九千行全部叠加,才得到那一支箭。
所以它是一支合力,不是一个方向 —— 图上画成一束细线收成一支粗箭,就是这个意思。
⭐ 「推高、压低」那套说法,只在刚才那一格、词表那一层才有所指。
—— 至于这一束怎么叠成一支的,下一格整格都在讲它。」
⭐⭐ 最后回答那个「能不能每个 token 各跑一遍」—— 台下一定有人这么想。
「有人会想:那是不是每个 token 各跑一遍反向,
算出各自那一整套梯度,最后把这些梯度平均?
—— ⭐ 那样算出来的结果,跟实际做法一模一样。
因为求导是线性的:先把 loss 平均再求导,等于先各自求导再平均。
⭐⭐ 所以实际只跑一次反向,不是抄近路 ——
是它跟那个想法等价,但便宜几千万倍。」
⭐⭐⭐ 最后补一格,两分钟 —— 它治的是一个听起来完全合理的误解。 ⛔ 这一格别省:现场自己把整条链复述了一遍,前四步全对, 第五步错了,而那一步恰好最要紧。
🖥 屏幕:fig-fold,先只放 Ⓐ。
「先把刚才那个「合力」说清楚 —— 那十二万九千个数,怎么变成一个方向的?
⭐ 关键是这句:词表里每一个字,在模型内部都占一个方向。
所以「往『的』那边拽零点六、往离开『了』的方向推零点二」……
五股力加起来,就是一个方向。那个合力有七千一百六十八个分量,
它就是这个位置的责任。」
⭐⭐ 然后把那个错法先说出来 —— 台下心里正是这么想的。
🖥 屏幕:平移到 Ⓑ,再到 Ⓒ。
「一条序列四千零九十五个位置,就是四千零九十五股这样的合力。
❓ 那下一步很自然就是 —— 把它们加起来求个平均,再拿这个平均往回传,对吧?
⭐⭐⭐ 不对。而且这是这一整段最要紧的一句。」
⛔ 停一拍,再给理由。理由只有一句,别展开。
「为什么不能加?
⭐ 因为第 i 个位置的责任,只能配第 i 个位置的输入。
你先把它们加起来,等于把第三个位置的责任,配到了第九百个位置的输入上。
—— 而「谁、在什么上下文里、提的什么要求」,
正是这份梯度全部的信息。加掉就没了。」
⭐⭐⭐ 然后给正确版,这一句是落点。
「正确的是:一行配一行,各乘各的,乘完之后才加。
⭐⭐ 所以「相加」这件事确实发生 ——
只是它不发生在那个七千一百六十八上,发生在权重梯度上,
而且每一层各结一次账。
那张「位置 × 宽度」的表,位置那一维是一路保留到最后的。」
⭐⭐⭐ 再补最后一格,三分钟 —— 这一格是整节的枢纽,别省。 ⭐ 它讲完,第一节开头那句「反向要付两笔乘法」才算真的落地。
🖥 屏幕:fig-settle,先放 Ⓑ
—— ⛔ 先答问题,再讲原理。
「先回答那个二选一:是每个算子各结一次,不是一层算完再结。
你看这一排 —— 一层里十几个算子,橙色的自己有参数,所以有账要结;
灰色的自己没参数,只把责任改个形状递过去。
⭐ 责任从右往左走,每碰到一个橙色的,就顺手结一次账。
⛔ 没有任何东西需要等一层走完。」
⭐⭐⭐ 然后放 Ⓐ —— 这是这一格真正的收获,也是回收第一节那句话的地方。
🖥 屏幕:平移到 Ⓐ。
「那「结一次账」到底在结什么?
一个带权重的算子收到责任之后,做的是两件事:
⭐ 第一件叫结账:把责任和这一层的输入相乘,沿着「位置」求和。
—— 位置那一维,在这一笔里被吃掉了。四千多个位置对这块权重的意见,
在这儿合成了一个数。这笔账不往下传,就留在那块权重上,等更新那一刻。
⭐ 第二件叫往前传:把责任乘上权重本身。
—— 位置那一维,在这一笔里完整保留。它就是上一层要收到的那份责任。」
⭐⭐⭐ 停一拍,然后回收。这一句是全节最值的一句。
「⭐⭐⭐ 现在回头看第一节那句话 ——
「反向要付两笔乘法,所以一加二等于三」。
那两笔,就是这两笔。
同一张责任表,两种收缩方式:一笔把位置维吃掉,一笔把位置维留着。」
⭐ 最后两条易错的,各十五秒,说完就走。
「最后两条特别容易搞错的:
⭐ 一,那个桶是固定大小的。四千个位置不是生出四千套参数,
是往同一个桶里加了四千笔。这就是为什么梯度是「每个参数一个数」。
⛔ 二,每层只加,不除。那个「除以总数」在最开头的种子里已经做过一次了
—— 每层再除一遍,六十一层就除了六十一次。
⭐ 所以严格说这一步叫求和,不叫求平均 —— 平均早就摊进每一笔里了。」
⭐⭐ 如果时间还够,加这一句 —— 它把第一节末尾那条通信优化接上了。
「顺带说一句:谁也不用等谁。
最后几层的账早就结完了,前面几层还在算 ——
⭐ 那段时间正好拿来把已经结完的那部分传出去。
这就是多卡训练里「把通信藏进计算里」的全部原理。」
⭐ 接着是最多人卡住的一处,必须专门点破:
「往回传的不是一个数。
是一整个张量,形状跟这一层的输出一模一样。
它的意思是:loss 对我这一层输出的每一个位置,各有多敏感。」
⭐⭐⭐ 这里插一格,三分钟。它回答一个几乎人人会问、而且很少被正面答的问题。
🖥 屏幕:fig-teacher,先只放 Ⓐ。
「有人一定会问:训练的时候,前面那些字要是猜错了,
会不会影响到后面这个位置?
—— ⭐ 不会。而且理由特别干脆:它压根不看自己猜的那个。
每个位置的输入永远是真值,是标准答案里的那个字,
不是模型自己刚吐出来的那个。」
「你看这张图:第三格猜错了,猜成了「空」。
⭐ 可下一格拿到的输入,是上面那一排真值里的「气」,
不是那个错的「空」。
⛔ 那条「预测 → 下一格输入」的路,在训练里根本不存在。
⭐⭐ 这件事有名字,叫 teacher forcing —— 教师强制。」
⛔ 顺手纠一个几乎人人有的画面,别跳过。
「⛔ 不过有一句要说准:这不是「一个 token 一个 token 地去查」。
训练里 Q、K、V 一把算完,注意力一把做完,所有位置同时。
⭐ 而这正是训练和推理最大的形态差别 ——
推理才是真的一个一个来,因为下一个字得等上一个字生成出来。」
⭐⭐⭐ 然后放 Ⓑ 和 Ⓒ。代价那一半比机制值钱得多,留足时间。
🖥 屏幕:平移到 Ⓑ,再到 Ⓒ。
「那推理的时候呢?前文全是它自己生成的。
⛔ 所以一旦错一个,后面每一个都建立在那个错的上面。
⭐⭐ 这个代价有个名字:曝光偏差。
它训练时从来没见过自己的错误 ——
一直活在一个「前文永远是对的」世界里。
⭐⭐⭐ 可推理时它一旦错一个,就走进了一个训练时从没见过的分布,
而在那儿它没有任何经验。」
⭐ 然后给那个「哦」的一下,停一拍。
「⭐⭐⭐ 这就解释了一个各位都遇到过的现象:
长文本生成,为什么会越写越偏。
—— 不是它突然变笨了,是它走进了自己没被训练过的地方。」
⭐ 收这一格,两条理由,快讲。
「那明知有这个毛病,为什么还这么训?两条理由都很实在。
一,并行。要是用自己的预测喂自己,第 t 个位置得等第 t 减一个算完 ——
四千多个位置就得串行四千多次,训练慢到没法做。
二,早期不发散。刚开始模型猜得一塌糊涂,拿它自己的输出喂自己,一步就飞了。
⭐ 所以这是一笔明知有代价、仍然划算的交易。」
📌 被追问出处时:teacher forcing 这个词是 Williams 和 Zipser 一九八九年在循环网络上起的; Bengio 他们二〇一五年提过 scheduled sampling 想缓解曝光偏差。 ⚠️ 但今天的大模型基本还是纯 teacher forcing。
🖥 屏幕:翻到 fig-3x,
放大 Ⓐ,一格一格念那三次矩阵乘。
⛔ 第②格那句「用前向存下来的输入」—— 用手指着它多停三秒,
这一讲后面全挂在这一句上。
「顺带说一句屏幕上那两个小 T 上标,叫转置。
⭐ 它不花算力 —— 行变列、列变行,一个数都没动。
至于为什么非它不可 —— 是形状逼出来的:
权重梯度必须跟权重同形、传给下游那块必须跟输入同形,
转置是唯一摆得上的摆法。」
⚠️ 备答(问到才展开,课件里有一整格收着):「为什么非转置不可?」 —— 答:「矩阵乘有一条死规矩,左边那个的列数必须等于右边那个的行数, 而对上的那一维乘完就被吃掉。你要的结果形状一旦定死,摆法就只剩一种。」 ⭐ 再追问就让他自己展开课件那一格,别在台上推。
⭐⭐ 然后跳到 Ⓑ。这是这张图的钥匙,也是本节的高点。
「为什么反向是两次,不是一次?
不是因为它「比较慢」。是因为它要回答两个不同的问题:
一,我这块权重该怎么改;二,我前面那一层该收到什么。
两个问题,两次乘法。所以一加二等于三 ——
训练比推理贵三倍,就是这么数出来的,不是估的。」
⭐⭐⭐ 在讲「偏导数」之前,先上那张小电路 —— 这一步不要省。 ⛔ 前面这几分钟全是道理,台下会点头,但点头不等于懂了。 ⭐ 这张图小到能用眼睛跟着走,它是这一节唯一一次「你可以自己验一遍」的机会。
🖥 屏幕:fig-circuit,放大 Ⓐ。
⭐ 先只念黑字,把前向走一遍;红字先不提。
「看这个式子:f 等于 a 加 b,再乘 c。
a 是 2,b 是负 3,加起来 q 等于负 1。
q 再乘 c 等于 4 —— f 等于负 4。
这就是前向,从左往右一遍走完。」
⭐ 现在回头走,一个门一个门地念红字。 ⛔ 这里要慢,每个数都让台下自己先想一秒。
「反向从最右边起步,f 对自己的梯度是 1。
先看乘法门。c 的梯度是多少?……是 q,也就是负 1。
q 的梯度是多少?……是 c,也就是 4。
⭐ 看出来了吗 —— 它俩换过来了。
再看加法门:上游给了 4,a 和 b 各拿走 4,原样分。」
🖥 屏幕:平移到 Ⓑ。
「所以常见的门就三种脾气,记脾气比记公式管用:
加法门是个分发器 —— 上游给多少,两边原样各拿一份。
乘法门是个交换器 —— 各自拿对方的前向值。
max 门是个路由器 —— 全给赢的那个,输的拿零。」
⭐⭐⭐ 然后是这一格的真正用处。讲之前停一拍。 —— 这一整讲后面所有关于「激活」的话,都从这一句长出来。
🖥 屏幕:平移到 Ⓒ。
「再看一眼乘法门。算 c 的梯度,我用到了 q。
而 q 是前向算出来的。
—— 所以 q 不能扔。
⭐ 把这一个门乘以几百亿次,就是我们后面要算的那张「激活」账单。
激活不是框架顺手缓存的东西。是反向的数学,要求它在场。」
⭐ 「偏导数为什么让这件事变容易」—— 这是台下最想听、最少人讲清的一段。
⛔⛔ 但在说「局部」之前,先把台下心里那个反对意见替他们说出来。 ⭐ 不说,「局部」两个字就是空的 —— 他们正堵着这口气。
「我知道有人在想什么。
『这个权重要影响到最后那个 loss,中间穿过的根本不是一个数,是一整个矩阵;
而且它的影响还取决于同一层里横着的那一排参数 —— 它们彼此还有影响。
这么牵一发动全身,你凭什么算得出来?』
—— ⭐ 我先说:这个反对意见是对的,而且比你想的还严重一点。」
🖥 屏幕:fig-derive,直接放 Ⓒ 的左半边。
⛔ 先别翻到右半边 —— 这一格的全部力气都在让他们先绝望一下。
「你看这张图的左边。
同一层里别的权重,先加进同一个出口;
然后往下一层散开,一层比一层宽。
⭐ 才走三跳,就已经两百一十六条路。
而真模型是六十层、每层七千多宽 ——
路径条数写出来是个两百三十二位的数字。」
⭐⭐⭐ 停两秒。然后翻到右半边 —— 这是这一段的高点。
🖥 屏幕:平移到 Ⓒ 的右半边。
「而算这个权重的梯度,只要两个数。
一个是前向的时候流进它的那个来料,
一个是反向的时候流到它出口的那个责任。乘一下,完。
⭐⭐ 那刚才那把扇子去哪了?
—— 它没有被忽略,它已经在『责任』那个数里面了。
因为反向那一趟,是按层一次算完的,不是按参数两两去算的。」
「⭐⭐⭐ 所以我要说清楚:「太复杂」这个感觉是对的,复杂是真的。
但那份复杂只付一次 —— 按层付,不按参数对付。」
⭐ 再补一句代价,这句话是往第三节埋的线。 ⛔ 别展开,一句话说完就走 —— 3.3b 整节都在还这笔账。
「代价也很清楚:参数两两之间的相互作用叫二阶导,
每两个参数就有一个数,6,710 亿个参数根本存不下。
⭐ 所以我们故意不算它。
而『故意不算』的代价,就是必须小步走。
⭐⭐ 所以学习率这个东西 —— 不是谁发明了它,
是我们放弃了二阶导,所以不得不有它。第三节再说。」
⭐⭐⭐ 插一格,四分钟 —— 把「二阶导」正面讲一次。 ⛔ 别省:这个词在这一讲里承重了好几处 (这儿、3.3b 的最优步长、Adam 那条线的动机),却从来没被定义过。
🖥 屏幕:fig-second,先只放 Ⓐ。
「先说它是什么。
一阶导你已经很熟了:你动一格,loss 动几格 —— 坡度。
⭐ 二阶导就是坡度自己的变化率:你动一格,坡度变几格。
翻译成画面就是 —— 这个地方弯得有多急。」
「⭐⭐ 一句话记住这个区别:
一阶导告诉你往哪走;二阶导告诉你,这个坡还能保持多久。
你看这两条曲线:两个点的坡度完全一样,
可一个离底二点零,另一个只离底零点二五 —— 差八倍。
⛔ 只看梯度,你分不出这两种处境。」
⭐⭐ 然后 Ⓑ,三十秒。它的用处很硬。
🖥 屏幕:平移到 Ⓑ。
「所以它能干嘛?最优步长可以算出来:
⭐ 梯度除以二阶导,一步到底 —— 不用试,不用调。
而且它正好治我们前面说的那个「拧反了」:
除以二阶导之后,不同参数才可比。
柯西一八四七年那篇末尾写的就是这个分工 ——
一阶负责从远处走过来,二阶负责最后收口。」
⚠️ 被问到「什么叫牛顿法」时才讲,约一分半 —— 不要主动插进主线。 (完整版折在课件 1.4b 里。)
「牛顿法本来不是做优化的,是解方程的 —— 求「f 等于零」那个 x。
做法很朴素:瞎猜一个点,在那儿画一条切线,看切线跟横轴在哪儿相交,
就跳到那儿,反复做。
⭐ 一句话:用切线代替曲线。曲线难解,直线一眼就看得出在哪过零。」
「那怎么变成优化的?求极小值,等于求「导数等于零」的那个点。
⭐⭐ 那就把这个办法用在导数身上 —— 于是就成了
「减去 导数 除以 二阶导」,也就是梯度除以二阶导。
⭐⭐⭐ 所以我刚说的那个最优步长,不是另一个公式,它就是牛顿法本身。
换个画面也一样:在这一点上贴一条抛物线,然后直接跳到它的底。」
「⛔ 那为什么不用?先不说它大到装不下、算不动 —— 那是下一格的事。
还有一条更要命的:loss 曲面不是碗形的。
在鞍点附近,牛顿法会朝着鞍点走,甚至朝山顶走 ——
因为它只管找「导数为零」的点,它不挑那个点是谷底还是山顶。」
⭐⭐⭐ Ⓒ 是这一格的力气所在。两个数字,一个比一个狠,中间停一下。
🖥 屏幕:平移到 Ⓒ。
「那为什么不用?
因为多参数的时候,它不是一个数,是一张表 —— 每两个参数之间一个数。
⭐ 所以它的大小是参数量的平方。
我算给你听:权重本身十六块卡就装下了。
⭐⭐⭐ 这张表 —— 十万亿块。
(停一拍)不是十万块,是十万亿块。」
「算的那边更绝望:真要拿它去解,朴素做法是参数量的三次方。
拿一台每秒百亿亿次的机器跑 —— 九十六亿年。
⭐ 而宇宙到现在也才一百三十八亿年。
⛔ 所以「我们故意不算二阶导」不是偷懒 ——
它压根不在可能性范围内。」
⭐⭐⭐ 最后一格,这是全节最值钱的一下。说完停一拍。 ⭐ 这是这一讲最容易被中文坑到的一处。
🖥 屏幕:平移到 Ⓓ。
「最后一件事,而且这一件最要紧:
⛔⛔ Adam 里那个「二阶矩」,不是「二阶导」。
它们中文都带「二阶」,纯属巧合。」
「二阶导:对参数求两次导,得到曲率 —— 这是几何,N 的平方个数。
二阶矩:对梯度取平方、求平均,得到「这个参数梯度平常多大」
—— 这是统计,N 个数。
⛔ 同样,「一阶动量」也不是一阶导 —— 它是梯度的滑动平均,
那个「一阶」指的是统计上的一阶矩,也就是期望。」
「⭐⭐⭐ 而最能说明问题的是尺寸:
二阶导是 N 的平方,Adam 那两份加起来是 两个 N。
所以 Adam 不是「近似了 Hessian」—— 它是换了一条路。
⭐ 它压根没打算去逼近那张表。这也是为什么它叫「自适应学习率」,
而不叫「近似牛顿法」。」
⭐ 铺垫做完了,现在那两个字才落得下去。
「关键只有两个字:局部。
每一个算子只需要知道我自己是怎么把输入变成输出的,就能写出自己的反向规则。
它完全不需要知道整个网络长什么样。
—— 这就是为什么自动微分能做成一个通用库:
矩阵乘写一个 backward,softmax 写一个 backward,
然后框架只干一件事,按顺序倒着串一遍。
没有任何人需要手推整个网络的导数。」
「反过来想才知道有多可怕:
你要真去写「loss 对第一层某个权重」的解析式,那个式子要穿过六十一层展开,
项数是天文数字,写不出来。
⭐ 链式法则真正的意思是:你永远不用把它展开。」
⭐⭐⭐ 然后把这一节跟那两笔乘法焊在一起 —— 这一格是本节真正的收口。 ⛔ 别省:前面讲了半天「局部」,台下心里还欠一句 「那『乘起来』到底是谁在乘」。
「还记得反向那两笔乘法吗?
图上第 ③ 笔是「拿责任乘上自己的权重,传给上游」。
⭐⭐⭐ 那一乘,就是链式法则的一环。
而「自己的权重」,就是这个算子的局部导数。」
「所以「六十一个局部导数按顺序乘起来」不是一个比喻 ——
⭐ 它就是反向那一趟里,第 ③ 笔被连做了六十一次。
⛔ 而第 ② 笔不在这条链上:它是从链上取值 ——
每一层各取各的,取完交给优化器,不往下传。」
⭐⭐⭐ 「按顺序乘起来」这句话说完,必须马上接下一句。 ⛔ 刚说完「把六十一个小导数按顺序乘起来」, 台下有人已经在想「那乘起来会怎样」。这一问是深度学习史上最出名的那个问题, 不接,后面讲归一化、讲残差、讲裁剪,全是无源之水。
🖥 屏幕:fig-vanish,先只放 Ⓐ。
「把六十一个数乘起来 —— 那乘起来会怎样?
看这张图。同一个六十层的网络,我只改一件事:每层的兑换率。
蓝色那条,每层一点二。你看它 —— 从右往左,直接冲出画面。
红色那条,每层零点八。它贴在轴上。
⛔ 我要专门说一句:那不是我画漏了,是它真的小到画不出来。」
🖥 屏幕:平移到 Ⓑ。 ⭐ 这一格换了对数轴,先解释一句为什么要换,不然台下会觉得你在换尺子糊弄人。
「线性的轴装不下这两头,得换成对数轴。
左边这个点,是零点八那条最靠输入的那层:一百万分之一点九。
右边这个点,是一点二那条:四万七千。
⭐⭐⭐ 中间隔着十个数量级。
而这两个兑换率 —— 零点八和一点二,只差两成。
所以这一格真正要留下的是这句:被指数放大的不是梯度,
是「每层偏离一多少」那个微小的偏差。」
🖥 屏幕:切到 fig-residual。
⭐ 这里不要急着讲 Ⓒ —— 台下刚被「十个数量级」镇住,
他现在最想听的是「那怎么办」。先把答案给他,再回头补 Ⓒ。
「所以 2015 年之前,层一深就训不动,全部原因就是这一条。
—— 那今天的六十一层、一百层,凭什么训得动?
⭐⭐⭐ 答案简单到有点扫兴:加一个加号。
原来每一层是『输出 = F(输入)』,改成『输出 = 输入 + F(输入)』。
就这一下,这一层的局部导数从『F 的导数』,变成了『一,加上 F 的导数』。」
「为什么这一下就够? 把六十一个括号乘开 ——
里面有一项是所有括号都取那个一。
⭐⭐⭐ 而一的六十一次方,还是一。
不管中间那些权重是大是小,梯度总有一条不衰减的路,直达任何一层。
⛔ 换句话说:残差把『乘』换成了『加』。
没有残差,第三层收不收得到梯度,取决于第四到六十一层那一整串乘积;
有了残差,各层的贡献是加起来的 ——
某一层学坏了,只是少加一项,不会把整条路乘没。」
「还有一条,讲完你就知道为什么它这么好训:
F 那一支初始化很小,不少实现直接把最后一个投影置零。
⭐ 所以刚开始每层的局部导数就是『一 + 很小』——
网络一上来等价于一个浅网络,再一层一层把 F 学起来。
⭐⭐ 一句话记住:残差不是给梯度加了条旁路,
是把每一层的局部导数从『某个数』,钉在了『一』附近。」
⛔ 别展开那个式子。原论文(He 等,arXiv 1512.03385; 恒等通路的干净推导在 arXiv 1603.05027)有一个漂亮的写法, 但「一的六十一次方还是一」已经是它的全部内容 —— 写出来只会让台下开始抄公式,不再听你说话。
⭐⭐ 然后回头补 Ⓒ —— 台下一定会问「那这个兑换率是谁定的」。
「那每层的兑换率从哪来?有好几截 —— 其中一截是激活函数的导数。
看这两条曲线。红的是 sigmoid 的导数 —— 它的峰值就这么高。」
「而这个数是算得出来的:sigmoid 的导数等于 σ 乘以一减 σ,
在 σ 等于二分之一的时候最大,恰好是零点二五。
⛔ 也就是说 —— 光是 sigmoid 那一下,每层就先乘了个不超过四分之一的数。」
⭐⭐⭐ 然后指绿线,这一句是这一格的落点。
「再看绿的,ReLU 的导数:正半轴恒等于一。
⭐⭐⭐ 这就是为什么 ReLU 一换上来,深网络忽然就训得动了 ——
它把每层那个「先天往下压」的系数,从四分之一变回了一。」
「⚠️ 我得补一句准的:权重那一乘还在外面, 所以不能说「一定衰减四倍」,只能说它先天就往下压。」
⭐⭐⭐ 最后讲这段历史 —— 这是全讲最好听的一个故事,值一分半钟。 ⭐ 讲的时候不要念论文题目的德文,说「一篇德文的硕士论文」就够了, 效果全在那个反差上。
「顺便说说这件事是怎么被发现的。
一九九一年,慕尼黑工业大学,一篇硕士论文。
⭐ 它是用德文写的,从来没有在任何英文期刊上发表过。
可就是这篇论文,第一次把「深网络为什么训不动」形式化地说清楚了。
三年后,大西洋另一边,Bengio 他们在 IEEE 上发了一篇 ——
标题叫《用梯度下降学长程依赖是困难的》。标题就是结论。」
⭐⭐ 然后给那个结尾。停一拍再说。
「这两拨人当时是各发各的,谁先谁后到今天还有争议。
⭐ 但故事的结尾挺好的:二〇〇一年,这四个人合写了一章,
题目叫《循环网络里的梯度流》。
当年分头发现同一件事的两拨人,十年之后坐到一起,把它总结了。」
⭐ 收这一格,一句话接回主线:
「最后提一个口径:这个问题最早是在循环网络上发现的,
不是在我刚才画的前馈网络上。
⭐ 但它们是同一件事 —— 循环网络按时间展开,
就是一个「层数等于序列长度」的超深网络。
当年那批实验的时间跨度是一千步,换算过来就是一千层。
⛔ 还有一条实用的:这两头的症状完全不同。
爆炸是吵闹的 —— loss 直接飞掉或者变 NaN,一眼看得见。
消失是静悄悄的 —— loss 就是不降,前面几层跟没训一样,
而且没有任何报错。⭐ 所以爆炸好查,消失难查。」
⭐⭐⭐ 最后一记,这是全节最深的一句,也是最容易被略过的一句。 ⛔ 这一段不要只用嘴讲 —— 上图,让台下自己数。
🖥 屏幕:fig-reverse,整张投,
先只指 Ⓐ 和 Ⓑ 两排,别急着说话。
⭐ 两排画的是同一条链,唯一的差别是箭头方向和种子插在哪一头
—— 这件事让人自己看出来,比讲出来有效得多。
「还有一个问题很少有人问:为什么是从后往前?
数学上两个方向都成立,算出来的结果一模一样。
区别只有一个 —— 你得把整条链走多少遍。」
「看上面这排。这叫正向模式:你想知道某个参数的梯度,
就在它身上插一个扰动,顺着链走到 loss。
可这一遍走完,你只拿到了这一个参数的梯度 ——
因为你这一遍只扰动了它一个。
6,710 亿个参数,就是6,710 亿遍。」
「再看下面这排。种子插在右边 ——
而右边只有一个数,就是 loss。
所以只插一次。
⭐⭐⭐ 关键在每个方块底下那个勾:往回走的路上,每一层的梯度顺手就到手了
—— 不是走完再统一算。
走到最左边的时候,6,710 亿个梯度已经全部在手里了。而你只走了一遍。」
⭐⭐ 这一条光说不够 —— 放那段九秒的动画,让他们看着等。
🖥 屏幕:anim-reverse。
「两条链一模一样,同时开跑。
上面那条是正向的算法:小球一次只能为一个参数跑一趟,跑完才点亮那一个。
下面那条是反向的:小球从 loss 出发往回走一趟,沿途所有参数一起点亮。
⭐ 现在注意看右边那摞方块 —— 跑一趟堆一块。
下面那条早就停了,只有一块;上面那条还在吭哧,一直堆到八块。
而真实模型里,那个『八』是6,710 亿。」
⭐ 让它循环两遍再往下讲 —— 那份等待本身就是论点。
🖥 屏幕:平移到 Ⓒ。 ⛔ 这一格是防止台下把结论记歪的 —— 不要跳过。
「所以规则只有一句:从窄的那一头起步。
⛔ 注意不是「反向传播永远更好」。
右边那个反例:十个参数、一百万维输出 ——
这时候你该从前往后,反向传播反而亏。
⭐ 我们之所以用反向,只是因为我们这一边正好是6,710 亿进、一个出。」
⭐ 收口回到账单 —— 这一句是给第二节的接口,不许省:
「回头看刚才第②步:算权重梯度,要用前向时存下来的输入。
—— 这就是激活扔不掉的根本原因。
不是谁设计得不好,是反向的数学本身要求它在场。」
⭐ 再补一小段,它是这一讲边界最正中间的一块。 —— ⛔ 时间紧可以整段跳,但跳之前先看一眼「不省算力」那条。
🖥 屏幕:fig-gradlife。
⭐ 2026-09-22 从第二节开头挪过来的 —— 这张图讲的就是这一段的事。
「一个梯度从算出来到被扔掉,中间要过五道。
每一道都有人在上面做文章 —— 要么省显存,要么省通信,要么省时间。
⭐ 记住这张图的用法:后面每讲一个优化,都能在这五道里指出它动的是哪一道。」
「刚才说的是梯度算出来那一刻。可它离被用掉还隔着好几道:
跨卡汇总、裁剪、也许还要累积几次,然后才交给优化器,用完扔掉。
—— 这几道每一道,推理里都没有。」
「其中那笔跨卡汇总有个反直觉的性质,值得单说:
它的量是参数量乘以每参数字节数 —— 跟 batch 完全无关。
你喂一条序列和喂一千条,传的是同样多的字节。
⭐ 而计算量是随 batch 线性涨的。所以 batch 越大,这笔通信被摊得越薄
—— 这就是为什么那些模型全都在往上爬 batch。」
「还有一件事:梯度是从后往前陆续出来的。
所以最后几层的梯度早就算好了,而前面几层还在算 ——
这段时间正好拿来传。
⭐ 算和传叠在一起,通信被藏进计算里 ——
这是训练里最重要的一类优化,而推理侧没有对应物。」
🖥 屏幕:切到 fig-act-bill,整张投。
这张图不用讲,指一下山顶那一竖说「峰值在这儿」,然后念两个数就走。
「一条四千长度的序列,不开重算,激活要 一百零四 GiB。
⭐⭐ 这个数你可以直接对着卡想:一块八十 G 的卡,连一条都放不下。
开了全量重算,峰值降到 五点零七 GiB —— 同一块卡能放十五条。
⚠️ 这两个数是我们自己按算子推的,没有第三方背书,当量级听。
⭐ 再往上就是乘 batch,线性的:per-device batch 八,两边各是
八百三十三 G 和四十一 G。」
⛔ 不要讲 forward-mode AD 的应用场景(雅可比向量积那一套)。 提一句「输出多的时候反过来更划算」就够,展开就是另一门课。
⚠️ 课件 1.7 那两张逐项拆解的表,整段跳过 —— 它是给会后自己算的人看的;台上提一句「拆解在课件里」就够。
⚠️ 那一百零四 GiB 报的时候必须带「自己推的」四个字。 这一讲后面还有好几个这样的数,第一次报就把规矩立住,后面省事。
🖥 本节主屏:课件 第一节 一个数怎么变成 6,710 亿个导数 —— 反向传播的原理 · 主图 fig-3x
第二节 代价:那些中间结果扔不掉 —— 以及第一个真正的取舍(7′)
🎯 这一节留一条判据(每省一字节付多少 FLOPs),和一个故事(判据没变,结论翻转)。
「上一节结束时,我们欠下一整条从头挂到尾的激活。
这一节要做的事很简单:拿第一样东西,去换第二样。
—— 这也是这门课到目前为止,第一次出现真正的取舍:
不是「有没有更好的办法」,是两样只能选一样,你选哪个。」
🖥 屏幕:fig-recompute,
只放 Ⓐ 那两组条。⭐ 这张图讲的是形状,不是数字 ——
让台下自己看出「上面那根只长了一小截,下面那根几乎归零」。
「重算是什么?一句话:不存过程,只存存档点。
前向算出来的中间结果我不留了;反向要用的时候,从这一层的入口再往前跑一遍。
代价是多跑一次前向,算力从三倍变四倍 —— 多三分之一。
⭐ 换回来的是刚才那个数的二十分之一。」
⛔ 2026-09-22:这里原来是把上一节那两个数再念一遍 —— 而这两个数上一节末尾刚报过。隔了不到五分钟再念一遍,台下只会觉得又在捋数。 这一格的内容是那个兑换比例,不是那两个数。
「⭐ 这个兑换比例夸张到不像是个权衡。
所以在大模型训练里,它默认就是开着的 ——
值得讨论的从来不是开不开,是开到哪一档。」
⭐⭐ 然后进本节的核心:判据。这一段要讲透,宁可砍后面也别砍它。
「怎么挑?只有一个数。
对每一个中间张量问同一句话:把它扔掉、反向时重算回来,每省一个字节要付多少次浮点运算?
比值小的扔,比值大的留。就这一个数,整张排序表自己就出来了。」
「而对线性层,这个数有个漂亮得出乎意料的闭式解 ——
它正好等于这个矩阵乘的输入宽度。
序列长度约掉了,输出宽度也约掉了。
⭐ 所以「哪个线性层最该重算」这个问题,不用算 —— 扫一眼 config 看谁输入最窄就行。」
🖥 屏幕:fig-per-byte,整张投。
⭐ 这是那三张要整张投的之一 —— 它的全部意义就在
两个模型的「交点各不相同」这个画面上,拆开看就没有了。
「看这张图。水平的那几条,是线性层 ——
水平的意思是它们的代价跟序列长度无关。
往上爬的那条,是 attention,它的代价随序列长度线性上升。
⭐ 关键在这儿:一条是常数,一条在往上爬 —— 那它们必然相交。」
🖥 屏幕:fig-per-byte,指两个交点
(紫色实线一组、橙色虚线一组)。
「但这张图上画了两个模型,而它们的交点不在同一个地方。
DeepSeek-V3 在一万三千一就交了;GPT-3 要到四万九千才交。
⭐ 为什么?因为斜率不一样。那条斜线的斜率,是模型自己的头维度定的
—— 换个模型,你要重画的是两条线,而不是把这条挪个位置。
⛔ 这一格我原来就画错过:把 V3 的斜率直接套在 GPT-3 上,
那个数就标错了。—— 而这一讲从头到尾在讲「别拿 A 的常数套 B」。」
⭐⭐⭐ 接下来是全讲最好的那个故事。讲之前先停一拍。
「「选择性重算」这个概念,出自英伟达二〇二二年的一篇论文。
它的判据跟我刚才说的一模一样 —— 挑那些「占显存不少、但重算起来不贵」的扔。
……而它选出来要重算的,恰恰就是 attention。
收益还很漂亮:GPT-3 省 70% 的激活显存,只付 2.7% 的算力。」
📌 被追问「2.7% 跟课件的数对不上」时:70% / 2.7% 是论文自己的口径 —— Megatron 传统公式,没有为 causal 折半;换成本课统一的 causal 口径, GPT-3 的 attention 占比是 1.37%。两个都对,只是约定不同。台上不用主动提。
⭐⭐ 别急着给答案 —— 先把矛盾摆足,问一句「谁错了」,让台下想三秒。 ⛔ 直接说「因为它的序列长度是 2048」,这一格就白讲了: 台下没经历那个矛盾,也就带不走那条判据。
「所以现在你们当审稿人 —— 谁错了?」
⭐ 停三秒。然后不要回答「谁错」,改成拆判据。
「先别急着说论文过时了。
回头看那条判据,它其实要三样输入:
一,那条斜线的斜率;二,那条平线的高度;三,你在哪个序列长度上问。
⭐⭐ 这三样,全都是模型自己的东西。
那两个不同的模型给出不同的答案,还奇怪吗?
—— 根本不是在辩论,是在两个坐标系里各自读数。」
⭐⭐ 然后一个个代进去 —— 第三样那儿要自曝,那是这一格最值钱的一下。
「为什么反过来了?
因为它的序列长度是两千零四十八。
你看图上 GPT-3 那根竖线 —— 它落在交点左边。
在那儿,attention 比图上每一条线性层都便宜。
论文没错。是前提变了。」
「⭐⭐ 所以这件事值钱的不是结论,是这句话:
同一条判据、同一个模型族、判据一个字没改,结论翻转 —— 变的只有序列长度。」
⭐ 收口两句,一句实用一句通用:
「实用的那句:这事今天基本不用你操心了。 FlashAttention 天生就不把分数矩阵写进显存、反向时现算 —— 等于把论文那条建议做成了默认行为。」
⚠️ 下面两句是备答:课件里 Megatron 源码那段已经折叠,不要主动讲。 只在有人问「那框架里 attention 还在不在重算名单上」时答,约半分钟。
「⛔ 别说成『框架的候选名单里 attention 根本不出现』—— 它还在名单上,而且是 selective 打开后的默认选项。 Megatron 的做法很有意思:它没有把这个默认改掉,而是在源码里钉了一条警告 —— 『融合 attention 下你不需要设它,请确认你真的需要』。」
「⭐ 为什么不直接改?因为改默认值会让别人照旧默认跑出来的结果复现不了。 —— 所以那个默认值就留在那儿,成了一枚化石。」
⭐⭐ 再插一条判据,它比上面那个故事更通用 —— 而且我自己栽过两次。
「顺带留一条判据给你们,我自己在这一讲里栽过两次:
⭐ 「顺手套一条听起来像常识的关系」,是最难发现的那一类错。
它不报错、也不会让你当场算崩 —— 它只是让后面每一个数都偏一点。
而且因为它听起来就是对的,你没有任何理由去怀疑它。
—— 我两次栽的是同一条「常识」:最宽的线性层等于 d_model。
V3 上漏了把头拼回去的那一层,GPT-3 上漏了 MLP 那一层 —— 哪个模型上都不成立。」
「通用的那句,请记住,它不只对重算成立:
凡是会改变数据分片形状的参数,都不能跨规模照抄。
—— 刚才那个例子说明这条规则比听起来更狠:
序列长度也在这个名单里,而且它翻转的不是收益的大小,是收益的正负号。」
⛔ 不要念那张名次表的每一行(课件 2.4 那张九行名次表,现在收在折叠块里)。 只说三档:「白捡的、划算的、绝不动的」—— 要细的人自己看, 台上念表是最快的催眠方式。
⚠️ 不要把 FlashAttention 讲成「一个优化」。 它在这里的角色是「把论文那条建议内建了」—— 讲成优化就跟这条线断开了。
🖥 本节主屏:课件 第二节 代价:那些中间结果扔不掉 —— 以及第一个真正的取舍 · 主图 fig-per-byte
第三节 有了导数,那一步该迈多大 —— 梯度下降与优化器(28′)
🎯 本节留三样:16 字节是哪五样、高精度的判据、以及学习率的量纲。
⭐⭐ 这是全讲最长、也最独立的一节。 时间紧的时候,前两节压缩、这一节保住 —— 它单独拎出来就是完整的一课。
⭐⭐ 开场先花一分半讲个人 —— 这一节后面全是账和公式, 先给它一张脸。 ⛔ 别跳过:现场是点名要的,而且台下听完这一段, 后面「为什么只好去估二阶导」就不用再解释动机了。
「在说账之前,先说一句这套东西是谁想出来的。
一八四七年,柯西。
⭐ 比神经网络早了一百多年。
论文标题直译过来是《求解联立方程组的一般方法》 ——
注意,他根本不是在做优化,他是在解方程。」
「他开篇先数落当时的标准做法,也就是消元,说了两个毛病:
一,很多情况下根本消不掉;
二,就算消得掉,最后剩下那一个方程复杂得不像话 ——
哪怕原来那几个方程都挺简单。
⭐ 于是他换了个题:与其去解方程,不如去找一个函数的最小值。」
「怎么把好几个方程并成一个函数?他写得特别干脆:
每个方程平方,加起来,让这个和等于零。
—— 因为平方都非负,这个和等于零,就等价于每一项都等于零。
⭐⭐ 于是「解方程」当场变成了「下山」。」
⭐⭐⭐ 这一句是这段的落点,说完停一拍。
「所以真正的发明不是微积分 —— 那是牛顿和莱布尼茨的。
是他这一下改题。我们今天训练模型,用的就是他这一下。」
⭐⭐ 再补原文末尾那句 —— 它是本节后半段的引子, 现在埋下,后面 3.3b 直接接。
「而他文章末尾还留了一句,我读到的时候愣了一下:
他说,用这个办法拿到已经比较接近的值之后,
『可以再用线性的、或者说牛顿的方法』快速逼近。
⭐⭐ 这句话把整件事切成了两半 ——
一阶负责从远处走过来,二阶负责最后收口。
一八四七年他就把分工写清楚了。
⛔ 而我们这一节后半段要讲的,就是 —— 二阶收不起口,怎么办。」
「好,回到账上。
每一个参数,训练时身上挂着十六个字节。」
🖥 屏幕:fig-optimizers,先放大 Ⓑ 那根尺子
—— ⛔ 不要先放 Ⓐ 那条谱系,会让人以为这一节在讲优化器历史。
「两字节 bf16 权重、两字节 bf16 梯度,再加十二字节 fp32 的三份:
主权重、动量、二阶矩。
权重只占 2,优化器那边占 12 —— 六倍。」
⭐⭐⭐ 然后是本节第一个判据。这一段是现场问出来的,讲法照抄现场:
「有人会问:为什么有三格是 fp32、两格是 bf16?
—— 不用一格一格记,它们服从同一条判据:
看这个量,老的贡献走不走。」
⭐⭐⭐ 别用嘴讲这条判据 —— 把图放上去,让它当场算给台下看。 ⛔ 「小的加上去会被舍掉」是一句算术, 听众只能选择信或者不信。⭐ 而这张图里的数是脚本真算出来的, 你可以当场说这一句,它特别管用。
🖥 屏幕:fig-precision,先放 Ⓐ。
「先看一个小数在机器里是怎么存的:分成两段。
指数那段管「能多大」,尾数那段管「能多细」。
⭐ 现在看中间这行 bf16 —— 它的指数段跟上面 fp32 一样长。
所以 bf16 能表示的范围跟 fp32 一模一样,掉的只是精细程度。
⭐⭐ 再看最下面 fp16。同样是十六位,可它把三位从指数挪给了尾数。
于是它更精细,但范围小了一大截 ——
小的梯度直接掉到零。这才是 fp16 需要 loss scaling 的原因,
跟「十六位不够用」一点关系都没有。」
🖥 屏幕:平移到 Ⓑ。 ⛔ 这一格是整节的高点,慢讲,中间要停两次。
「现在做一件事。假设一个权重是 1.0,
每一步要给它加 万分之三 —— 训练后期这是很典型的量级。
看这根数轴:bf16 在 1.0 附近,相邻两个能表示的数之间隔着零点零零七八。
⭐ 中间什么都没有 —— 不是精度差,是那些数压根存不下来。
而我们要加的那个万分之三,只有一格的百分之三点八。
⛔ 四舍五入 —— 直接舍回原地。」
⭐⭐⭐ 停一拍,然后抛那个问题。台下一定会答错。
「有人会想:那多加几次不就行了?加二十六次就够一格了嘛。
—— 我真的跑了一千次。
⭐⭐⭐ 结果是 1.0。一步都没动。
因为每一次都是从 1.0 开始加,每一次都被舍回 1.0。它跨不过去。
右边那格是对照:同样一千次,改用 fp32 —— 1.0 变成 1.3。」
⭐ 然后收这一句 —— 它把「保险起见」这个误解直接掐掉。
「所以「主权重要留一份 fp32」不是保险起见。
不留,训练到后期就真的停在原地了 —— loss 不降,而你查不出哪儿错了。
⭐ 顺便说:这些数不是我从哪篇论文引来的,
是画这张图的脚本里真写了一个 bf16 舍入函数当场算的,
还有三条断言盯着。你可以自己跑一遍。」
🖥 屏幕:平移到 Ⓒ。
「有了这个画面,那条判据就不用背了:
看这个量,老的贡献会不会永远不走。
主权重 —— 跨十万步不断加进微小增量,老的一直在里面。必须 fp32。
梯度和激活 —— 算出来、用掉、扔掉,根本没有「老的」。bf16 就够。」
⛔ 紧接着给那个第一方反例 —— 不给的话这条判据会被听成过度简化。
「不过这条判据我原来说得太粗了,有一条第一方证据把它逼得更准了。
DeepSeek-V3 的报告里明写:他们把一阶矩和二阶矩都放成了 bf16,没有可观察的性能退化;
而主权重和梯度仍然保 fp32。
为什么?因为动量和二阶矩是滑动平均 ——
每一步都乘一个小于一的系数再掺新值,老的贡献会被衰减掉。
⭐ 滑动平均不是累加。真正的分界不是「累不累加」,
是「老的贡献会不会永远不走」。」
⭐ 第二段:那条谱系。这一段讲得轻快一点,它是过渡不是重点。
🖥 屏幕:同一张图,平移到 Ⓐ。
「这张图不按算法怎么算排,按每个参数挂几份状态排。
SGD 零份 → 加动量一份 → AdaGrad、RMSProp 各一份 →
Adam 和 AdamW 两份都要。」
⭐⭐ 先补一段:权重衰减本身是什么。
—— 不补的话,下面那一格等于在改一个台下没见过的东西。
「先说权重衰减本身是个什么东西 ——
这个我们一路提了好几次,一直没正经定义过。
一句话:每一步都把权重往零缩一点点。
教科书给的理由是正则化:别让模型靠几个特别大的权重去死记硬背。
⛔ 可这个理由在大模型预训练上站不住 ——
我们单遍过数据、数据量远超参数量,压根没有过拟合的机会。」
「可你去翻配置,几乎所有大模型都带着它,而且清一色零点一。
那它留着干嘛?
⭐ 关键在这儿:后面接着归一化的那些权重,你把整块放大两倍,输出一模一样
—— 归一化会把这个放大抹掉。
所以权重的长度不改变函数。它只改变一件事:
同样迈一步,方向能转多少角度。
⭐⭐ 权重越长,同样一步转过的角度越小 —— 也就是有效学习率越低。」
「而训练过程里,权重是会慢慢变长的。
⭐⭐ 所以你不管它,有效学习率会自己一路往下漂。
权重衰减就是把长度按住,让它别漂走。
⭐ 所以它今天更像一个稳住有效学习率的旋钮,不是防过拟合的正则项。」
「那怎么衰减?把式子整理一下就清楚了 ——
每一步乘一个略小于一的数。
所以它是指数衰减:没有梯度推的话,权重会指数地趋向零。
⭐ 有多温和?拿 V3 那两个数算一遍:一万步下来只缩到八成。很轻。
⛔ 但有个陷阱:那个收缩比例里带着学习率。
你一改 schedule,正则强度跟着一起变 ——
以为只动了一个旋钮,其实动了两个。」
「最后一问最有意思:它为什么在优化器里?
⭐⭐ 答案是 —— 它本来不在。
它原本是 loss 的一项。你把它写进目标函数,
自动微分就会在梯度里自动产出这一项。
所以它最初的身份,是「你想优化什么」的一部分。」
「那为什么搬家?
因为只要它还在 loss 里,它就必然跟梯度走同一条管道
—— 动量、二阶矩、除以分母,一样不落。
而我们要的是均匀地拉。
⭐⭐ 而唯一能绕开分母的地方,就是更新那一步本身 —— 那一步归优化器管。
所以它从「你想优化什么」,变成了「你怎么走」。换的是归属,不是公式。」
⭐⭐ AdamW 这一格现场卡过。
别只说「被二阶矩除了一遍」—— 把两个参数摆出来比,它才成立。
「顺带把 AdamW 那个 W 说清楚,别让它白挂着。
权重衰减本身很简单:每一步把权重往零缩一点点,别让它越长越大。
问题只在于 —— 这个「往回缩」放在哪一步做。
老办法是把它混进梯度里:算梯度的时候多加一项,加的是 λ 乘权重本身。
听着挺自然,反正都是要减的东西。」
「⛔ 坏就坏在这儿。
一旦混进梯度,后面每一步都会一视同仁地作用到它头上 —— 包括除以根号 v。
你想两个参数,都已经长到十。
一个梯度天天很大,分母大,那份衰减被除小了 —— 几乎没被拉回来;
一个梯度常年很小,分母小,衰减被放大 —— 被往死里拉。
⭐⭐ 它俩都长到十,一样该被管住,可实际受到的约束正好反过来。」
「我们要的是「所有权重都均匀地往回拉一点」,
不是「按梯度大小分配惩罚」 —— 这两件事被混在一起了。
⭐ AdamW 的修法就一句:衰减不走分母。
梯度那条路一个字不改;落地那一步单独再扣一次,直接扣在权重上。
⭐⭐ 这就是 decoupled —— W 就是 weight decay 那个 W。」
「三十年一路往上加 —— 直到 2024 年,有人往回走了一步。
Muon 把二阶矩那一整份拿掉了,十六字节变十二。」
⭐⭐⭐ 但按字节排只是一种看法。再给一张图,换一条线看 —— 因果。 ⛔ 光念名字,台下只会记住「有这么几个」。 ⭐ 而这几个名字是一条链:每一个都在补上一个留下的洞。 讲完这一格,他们不用背了。
🖥 屏幕:fig-lineage,先只放 Ⓐ。
「我做了一件很简单的事:喂同一串恒定的梯度进去,
看每一家给出的有效学习率长什么样。
⭐ 梯度都不变了,那么一个健康的优化器应该给出一条平线。
凡是不平的,那就是它自己的毛病,赖不到数据头上。
看这四个小框里的曲线 —— 只有第一个和最后一个是平的。」
🖥 屏幕:平移到 Ⓑ。
「先看 AdaGrad,它的病在后期。
它的分母是「历史梯度平方的累加和」—— 只增不减。
于是有效学习率一路往下掉,跑到第六百步只剩稳态的百分之四。
⛔ 再强调一次:喂进去的梯度自始至终是同一个数。
不是数据变了,是那个只增不减的分母把它自己压死的。」
🖥 屏幕:平移到 Ⓒ。
「RMSProp 把「累加」换成「滑动平均」—— 分母会遗忘了,后期的病治好了。
⛔ 可它落下了新的:滑动平均是从零起步的。
头几步样本还没攒够,分母被严重低估 ——
第一步的更新被放大了三十二倍,直接冲出画面。
⭐ Adam 的偏差校正就是来修这一下的。你看绿线 —— 从第一步起就是平的。
⭐⭐ 还有一个细节挺妙:如果 Adam 只加动量、不做校正,
峰值只有六点六倍,不是三十二倍 ——
因为动量那一项自己也有偏差,两个偏差部分抵消了。」
⭐⭐⭐ 然后讲这三则出处。这一段是整节最好听的,值两分钟。 ⭐ 讲法:三个并排着讲,反差全在「出版物的规格」上。
「顺便说说这三个东西是怎么发表的,对比很有意思。
AdaGrad:正经的 JMLR 长文,整整三十九页。
⭐ 而且你去看题目 —— 《面向在线学习与随机优化的自适应次梯度方法》。
它根本不是为深度学习写的。」
「RMSProp —— ⭐⭐⭐ 它没有论文。
它唯一的「出版物」,是 Hinton 那门 Coursera 网课里的一页 slide。
今天所有引用它的论文,引的都是「第 6.5 讲」。
⭐ 而那页 slide 的副标题,本身就是这个算法的完整定义:
—— 「把梯度,除以它近期幅度的滑动平均。」
一句话,一页片子,成了这条链的中间一环。」
「Adam —— 这篇有两个地方我很喜欢,都印在论文里。
首页有个脚注:「作者顺序,由 Google Hangout 上掷硬币决定。」
⭐ 致谢里还有一句:「特别感谢 Ivo Danihelka 和 Tom Schaul 起了 Adam 这个名字。」
—— 这个名字不是作者自己起的。」
⭐⭐ 收这一格,用这一句。
「所以这条链最有意思的地方是 ——
一条改变了整个领域的技术链,中间那一环连篇论文都没有。
⭐ 而它成立的最硬的证据,是 Adam 论文自己证的:
AdaGrad 就是 Adam 的一个特例。
—— 后面那个能把前面那个含进去,这才叫链。」
⭐⭐⭐ 第三段:为什么顺着梯度走,loss 就会降。
⭐⭐⭐ 先把「本源」那一格讲了 —— 它比后面所有技巧都重要。 ⛔ 台下多半从没被人正经讲过为什么顺着梯度走就能变好。 不讲这一格,后面整节优化器就是一堆没有地基的技巧。
🖥 屏幕:fig-descent,先只放 Ⓐ。
⭐ 那两串球是真跑了一遍梯度下降算出来的,不是摆上去的
—— 可以直说这一句,台下会更认。
「先看最简单的情况:只有一个参数。
规则只有一句 —— 看看脚下的坡,往下坡那边挪一点。
斜率是正的就往左,是负的就往右。反复做。
脑子里放一个画面:一个球,从山上滚下来。」
⭐⭐ 然后指红色那一串,这是第一个「免费的好东西」。
「注意看红色这几个球之间的间距。
第一步跨得最大,然后一步比一步小。
—— 为什么?因为我们把步长取成跟斜率成正比。
越接近谷底,坡越平;坡越平,步子自然越小。
⭐ 没有人让它慢下来,是坡自己变平了。
所以它不会在谷底来回冲过头 —— 这一条是白送的。」
⛔⛔ 接着指绿色那一串。这是这一格最该留下的一句。 讲完停一拍。
「现在看绿色那串,它从右边出发。
两串球用的是一模一样的规则。
可是 —— 红色落进了浅的那个谷,绿色落进了深的。
⭐⭐⭐ 差别只有一个:它们从哪儿出发。
所以要说清楚:梯度下降从来没承诺过最优。它只承诺,每一步都在变好。」
🖥 屏幕:平移到 Ⓑ,再到 Ⓒ。
「加到两个参数,「斜率」这个词就不够用了 ——
一个数说不清方向,得用一个向量。那个向量就叫梯度。
它指的是上坡最快的方向,所以下坡就取它的相反数。
⭐ 而它的长度还顺带告诉你:这个坡有多陡。」
「到了6,710 亿个参数 —— 别再想「山」了,山画不出来。
换个读法:那就是一列6,710 亿个数。
每一项告诉你两件事:正负,说这个参数往上推还是往下推;
⭐⭐⭐ 相对大小,说哪一项改起来更要紧。
—— 它不只告诉你往哪走,还告诉你该先动谁。」
⭐⭐⭐ 紧接着把 fig-saddle 放上来 —— 这一格是用来「解毒」的。
⛔ 上一格刚说完「落在哪个谷取决于起点」,台下现在心里是发虚的:
那不就是碰运气吗?⭐ 如果不把这个印象拆掉,后面讲什么调参他们都会半信半疑。
🖥 屏幕:fig-saddle,先只放 Ⓐ。
「刚才那张图留了个阴影:满眼都是坑,掉哪个算哪个。
现在我要说的是 —— 那个画面,是一维骗你的。
看这三格。坡度为零的地方,其实不止一种。
第一种,两个方向都往上 —— 这才是真谷底,往哪走都变差,真卡住了。
第二种,两个方向都往下,那是山顶,一推就走,训练里基本遇不到。
⭐⭐ 第三种最要紧:一个方向往上,另一个方向往下。」
⭐ 这时候给那个比喻 —— 它比任何数学都好使。 ⭐ 如果台下有爬过山的,这一句一说完他们就懂了。
「第三种有个特别贴切的名字:垭口。
就是翻山时那个豁口。
沿着翻山的那条路走,它是整条路的最高点;
可你要是横过来、沿着山脊走,它又是最低点。
—— 站在那儿,脚下确实是平的。但它根本没封死,路就在旁边。
⭐ 中文管这种地形,就叫鞍部。数学上这个点就叫鞍点。」
⭐⭐⭐ 剖面图讲完,把它转起来 —— 三维的形状二维画不出来。
🖥 屏幕:anim-saddle。
「刚才那张图是切了两刀给你看剖面。
而它真正的形状是这样的:红线沿一个方向往上翘,绿线沿另一个方向往下沉,
两条在中间那个黑点交叉。
⭐ 站在那个点上,脚下确实是平的 —— 可绿色那条路一直都在。」
🖥 屏幕:平移到 Ⓑ。 ⛔ 这一格是整张图的论证,三行要一行一行念,别一口气扫过去。
「接下来这一步,是这一整格的关键。
要当真谷底,条件是「所有方向都得往上」。
一维图上只有两个方向 —— 两个都往上,很容易凑齐。
所以图上才会坑一个接一个。
可我们谈的是几千亿个参数,那就是几千亿个方向。
⭐⭐⭐ 要它们全都往上 —— 只要漏掉一个,它就只是个垭口,还能接着走。」
⛔ 这里必须自己踩一句刹车 —— 不然就讲过头了。 ⭐ 台下里但凡有数学背景的,此刻正想举手。你先说,比被问住强。
「我得说清楚:这是定义层面的话,不是概率论证。
各个方向的弯曲方向并不彼此独立,所以我不会给你一个
「罕见到十的负多少次方」那种数字 —— 那个数是编的。」
⭐⭐⭐ 然后补最要紧的一步 —— 为什么「封闭」和「很低」会挂钩。 ⛔ 不补,上面那段会被听成「高维禁止有坑」—— 那是错的, 四维能有封死的深坑,一千维也能有。
「⛔ 先掐掉一个错解:「维度一多就不会有坑」—— 这句话是错的。
四维能有一个四面封死的深坑,一千维也能有。数学上没有任何东西禁止它。
⭐ 真正成立的是这一句:一个又高又封闭的坑,在高维里极其罕见。」
⭐⭐⭐ 这一句是整段最深的一下,慢讲。
「那为什么「封闭」和「很低」会挂钩?
想一下「封闭」要求什么 —— 所有方向都得朝上,一个都不能漏。
⭐⭐ 可你站得越高,脚下能往下走的地方就越多 ——
下面还剩着一大片高度可以掉。
反过来,越接近最低处,能往下的方向越少,直到一个都不剩 ——
那才是谷底。」
「⭐⭐⭐ 所以结论要说准:
高维里那些让训练停下来的点,绝大多数是垭口,不是谷底 ——
而这不是因为谷底被禁止了,是因为谷底都在很低的地方,你还没走到。」
📌 被追问出处时:Dauphin 等,arXiv 1406.2572(NeurIPS 2014)。 摘要原话是:一般以为主要困难是「比全局最优高得多的局部极小大量存在」, 而他们论证更深也更根本的困难来自鞍点的大量存在,在高维问题上尤其如此。
🖥 屏幕:平移到 Ⓒ。
「而且这不只是推理,有人真去量过。
把训练一直跑到梯度为零,然后数一数:这个点有多少方向是往上的?
⭐ 结果是 —— 那个比例从来没到过 1。
换句话说:训练停下来的那些地方,总还剩一批方向是往下的。
它没走,不是因为没路,是因为坡太平了。」
⭐⭐⭐ 最后这个转折一定要讲 —— 它是整个第三节的引子。 ⛔ 只讲好消息,台下会觉得「那还调什么参」。
「所以「梯度下降为什么可以」,最深的那半个答案是这样的:
✅ 参数越多,它反而越不容易真卡住。
—— 顺带回答一个常见困惑:「参数多不是更难训吗?」
显存和算力上确实更难,但在「会不会卡死」这一项上,恰恰相反。
两件事各论各的。
⛔ 可坏消息是:卡不住,不等于走得快。
垭口附近坡极平、梯度极小,而我们的步长又是「跟坡度成正比」的 ——
那就会在那儿磨很久很久。
⭐⭐⭐ 记住这句 —— 我们接下来一整节要讲的那些优化器,
一多半就是在治这个。」
⭐⭐⭐ 话音刚落就上动量 —— 它是那句话的第一个答案,别隔开讲。 ⛔ 刚说完「卡不住但走得慢」,台下正等着「那怎么办」。 ⭐ 这一格只需要一个画面:一个球,一个浅坑,两条轨迹。
🖥 屏幕:fig-momentum,先只放 Ⓐ。
「办法叫动量。一句话就能说完:
这一步怎么动,不只看当前的梯度,还要看上一步是怎么动的。
—— 说白了就是给它一点惯性。
看这张图。同一条 loss、同一个起点,唯一的差别就是有没有惯性。
灰的那条,滚到半路这个浅坑就停了。
⭐ 而且我要强调:它是真停 —— 那一点的梯度已经归零,它动不了。
绿的那条,带着上一步的速度冲了过去,落进了后面那个更深的谷。
它还冲过了头,然后荡回来 —— 你看那几个点。」
⭐⭐ 然后 Ⓑ。这一格是机关,慢讲。 ⭐ 讲之前可以先问一句「它凭什么冲得过去」,让台下想三秒。
🖥 屏幕:平移到 Ⓑ。
「它凭什么冲得过去?
我把它刚越过坑底那一刻的账,拆成两项摆在这儿 ——
箭头的长度和方向,都是按真实数值画的。
第一项,梯度这一项:零点零九二,朝右。
⛔ 注意方向 —— 它在把球往回拉。因为球刚越过坑底,坡正拽着它回去。
第二项,惯性这一项:一点三零四,朝左。
两个加起来,净移动一点二一三,朝左 —— 继续往前。
⭐⭐⭐ 所以看清楚这一刻在发生什么:梯度是反对它继续走的。
是惯性把它带出去的。」
⭐⭐⭐ 然后讲历史。这段特别值,一分半钟。 ⭐ 它的杀伤力全在那个年份上,先把年份说出来再说别的。
「这个主意有多老?
一九六四年。
⭐ 比反向传播那篇 Nature 论文还早二十二年。
一位叫 Polyak 的苏联数学家,论文题目平平无奇,叫《加速迭代法收敛的一些方法》。
⭐⭐ 而他给这个方法起的名字是 —— 「小重球法」。
所以我刚才让你们脑子里放一个球,那个球不是我想出来的,是他起的名字。」
⭐⭐ 接着念那句原文 —— 它跟你刚讲完的 Ⓑ 一字不差。
「更妙的是,我刚才讲 Ⓑ 那段话,他在一九六四年就逐字写下来了:
—— 「运动不沿着力,也就是不沿着负梯度的方向走,因为有惯性。」
他还说,那一项会让它沿着谷底走。
⭐ 六十年前的一句话,说的就是我们刚才那三个箭头。」
⭐⭐⭐ 这里必须接一段 —— 不接,台下带走的是错的那一半。 ⛔ 你刚才那张图讲的是「冲过浅坑」,而那是三个机制里 日常最少用到的一个。真正每天在干活的是下面这个。
「不过我得说清楚一件事,不然你们会记错它的用处。
刚才那张图讲的是冲过浅坑。它是真的 ——
可上一格我们刚说完,高维里封闭的坑本来就罕见。
⭐ 所以「动量帮你逃出局部最小」这个说法,抓的是它最不常用的那一面。」
「它每天真正在干的,是另一件事。
你回想那个一边陡一边平的谷 —— 陡的方向左右横跳,平的方向慢慢蹭。
⭐ 横跳那个方向,梯度是一步正、一步负交替的;
动量把它们累在一起,正负相消,幅度被压下去。
⭐ 平缓那个方向,梯度一直同号;累在一起,越滚越快。」
⭐⭐⭐ 这一句是动量这一格真正的落点,慢念,说完停一拍。
「所以动量本质上是个筛子:
放大你一直朝着走的那个方向,压掉你来回摆的那个方向。
⭐⭐ 一句话 —— 它治的不是「出不了坑」,是「别再横着撞谷壁」。
而 Polyak 那句「让它沿着谷底走」,说的正是这一条。」
⭐⭐ 然后回答「那它什么时候不管用」—— 这个有上限,而且能算。 ⭐ 台上可以先反问一句「那为什么不干脆把动量开到最大」。
「那它什么时候不管用?
这个不用猜,有个上限,能算出来。
经典动量的更新是:速度 = β 乘上一步的速度,再加当前梯度。
梯度大小恒定的话,这个速度会一直累 ——
累到「一减 β」分之一倍为止。
β 取零点九,就是十倍。β 取零点九九,一百倍。」
「⭐ 这就是它全部的本钱。
β 等于零点九的时候,动量最多把有效步长放大到十倍 ——
坑壁比这个高,它就是冲不出去。
所以「有时候不管用」不神秘,也不是你调参没调好 ——
它带的动能是有限的,而且这个上限你现在就能算。
我们图上它冲得过去,就是因为那个坑的深度正好在十倍以内。」
⛔ 最后补一句反面,别让它听起来是纯赚。
「而且它会冲过头 —— 刚才你们也看到了,它荡了几下才停。
⭐ 动量拿「终点附近多晃几下」,换「路上不停下来」。」
🖥 屏幕:平移到 Ⓒ。
「最后一件事:那个 β 是什么。
「上一步的移动」里其实装着过去所有步,只是越老越轻 ——
每往前追一步就再乘一个 β。就是这排柱子。
所以它的有效窗口大约是 1 除以(1 减 β)。
β 等于零点九,就是十步左右。
⭐ β 不是玄学,它是一个「记多久」的旋钮。」
⭐⭐⭐ 然后抛这个包袱收尾。效果很好。
「顺便说 —— Polyak 在一九六四年给的经验取值是零点八到零点九九。
而今天 Adam 的默认 β₁ 是多少?零点九。
⭐ 六十年过去了,我们还在他给的那个区间里。
他甚至连调参顺序都写好了:先把动量关掉,把学习率调好;
等收敛慢下来了,再把动量加上。」
⛔⛔ 但收尾一定要踩这脚刹车,不然这一格会被听成「万能药」。
「不过我得说准一点。
⛔ 动量能冲过去的是「浅坑」,不是所有的坑。
图上那条能出来,是因为那个坑够浅;换个更深的坑,它一样出不来。
⭐ 所以它降低的是「从哪儿出发决定一切」的程度,不是消除它。
—— 它治的是「慢」,不是「最优」。」
⭐⭐ 最后这一句是本节的接头,一定要说。
「而那一整列数是从哪来的?
—— 就是第一节里,反向传播走一遍算出来的那一份。
⭐ 所以第一节和第三节,接头就在这儿。」
⭐⭐⭐ 第四段(换气点在这儿):那一步该迈多大。 ⛔ 前面三段讲的都是往哪边走,从这里开始换题目 —— 停两秒,喝口水,让台下知道翻篇了。 ⭐ 这一段是本节的高点,也是最少人讲过的角度。
「现在问一个看起来很蠢的问题:
梯度是怎么变成权重更新的?
最朴素那版只有一行:新权重等于老权重减去学习率乘梯度。
—— 可这一行凭什么成立?」
⭐⭐⭐ 先别上量纲 —— 两个旋钮就能让台下自己看出它拧反了。 ⛔ 这一格必须在白板上写数,光用嘴报没有力量。 ⭐ 写四个数就够:1000、100、1,然后是 10 和 1000。
「假设一台机器上只有两个旋钮,现在误差是一千。
甲很灵:拧一格,误差变一百。
乙很钝:拧一格,误差才变一。
—— 那要把这一千消掉,两个各该拧多少格?」
⭐ 停两秒,让台下自己算。这题是小学算术,人人算得出来 —— 而自己算出来的结论,才推得动后面那一整节。
「甲:一千除以一百,拧十格。
乙:一千除以一,拧一千格。
⭐⭐ 看出来了吗 —— 该拧的圈数,跟灵敏度是反着来的。
灵的少拧,钝的多拧。」
「那我们那一行代码给的是多少?
步长等于学习率乘梯度 —— 甲走一百份,乙走一份,一百比一。
⛔⛔ 需要的是一比一百,它给的是一百比一 —— 不是差一点,是正好拧反。
灵的那个被猛拧,冲过头、来回震荡;钝的那个几乎没挪。
⭐ 整台机器,被最钝的那个旋钮拖着走。」
⭐⭐ 再补一句,把第一节那个「梯度消失」接回来 —— 这句是全讲最容易被听反的一句。
「⭐⭐⭐ 顺带说一句,这一条正好解释了第一节那个梯度消失。
前面几层梯度只剩万分之十六 —— 那不等于前面几层不重要。
梯度小的意思是这个旋钮钝,也就是要走的路更长。
它不是不需要动,是比谁都更需要动 —— 而我们偏偏给了它最小的步子。」
⭐ 然后再上量纲 —— 它回答的是「为什么必须有个折算系数」。
「你仔细看:两边的单位对不上。
梯度的意思是「这个参数变一点,loss 变多少」,单位是 loss 除以参数;
可你要的是「参数该挪多少」,单位是参数本身。
所以中间必须乘一个东西把它折过来 —— 那就是学习率。
反推它的单位:参数的平方,除以 loss。」
「⭐ 所以学习率不是一个纯数字。
它跟你的 loss 有多大、权重有多大,全绑在一起 ——
这就是为什么换个模型、换个 batch,学习率就得重调。它压根不是通用常数。」
⭐⭐⭐ 而它到底该是多少 —— 先让台下亲眼看见那个痛。 ⛔ 「不同参数的梯度尺度差好几个数量级」这句话,说出来人人都点头, 可没人知道它长什么样。⭐ 这张图就是把那句话画出来 —— 讲完它,后面所有优化器都有了动机。
🖥 屏幕:fig-onelr,先只放 Ⓐ。
⭐ 先说清楚坐标:竖着弹的是陡的那个参数,横着爬的是平的那个,
谷底在右边。
「这是一个一边陡、一边平的谷。两条轨迹,
同一个谷、同一套规则,唯一的差别是学习率。
先看红色。它每弹一次幅度更大,弹着弹着就出画面了。
再看蓝色。它弹幅在收,最后是走到谷底了。
⭐⭐ 现在我告诉你这两个学习率差多少 —— 差一成。
红色比蓝色大百分之十。就这么点,一个炸了,一个没炸。
⛔ 你能下手的区间,就这么窄。」
⭐⭐ 然后指着蓝色那串锯齿 —— 这一句是这张图真正的收获。 ⭐ 大多数人看到「蓝色到底了」就以为它没问题。让他们再看一眼。
「可蓝色也不好。你看它那串锯齿 ——
每一步大半的力气,都花在左右横跳上了。
真正朝谷底去的,只有那一丁点横向的位移。
⭐ 它不是在走,它是在蹭。」
⭐⭐⭐ 那「到底该迈多大」有没有答案?—— 有,而且能算。
🖥 屏幕:fig-beststep。
「在一条抛物线上,最优步长是可以算出来的:
⭐ 梯度除以二阶导,一步到底。
—— 这个我们 1.4b 已经整节讲过了,这儿直接用。」
⭐⭐ 然后指 Ⓑ —— 这是这张图的机关。
「⭐ Ⓑ 那一格是机关:只看梯度会判断错。
陡谷的梯度是二、平谷是一 —— 看起来陡谷离得更远,该迈大步,对吧?
⛔ 错了。它其实离底更近。
⭐ 除以二阶导之后,两个才可比。」
⛔ Ⓒ 一句带过 —— 不要在这里展开讲二阶导是什么,1.4b 整节讲过了。
「⭐ Ⓒ 回答的是「为什么没人真去算」:
二阶导每两个参数之间就有一个,几千亿参数根本存不下。
于是只好去估它 —— 而那就是 Adam 分母那一坨的来历。」
🖥 屏幕:平移到 Ⓑ。 ⛔ 这三行是本讲自己的落点,一行一行念,第三行要停一下。
「那有人会说:取个中间值不就行了。
⭐⭐⭐ 问题就在这儿 —— 中间也没有好的。
第一行:再大一点,陡的方向直接发散。这个门槛是死的,
等于二除以陡峭程度,跟你想不想快一点毫无关系。
第二行:那就取最大的安全值。这时候平的那个方向走完一半,
要零点三七乘以陡峭比那么多步。图上这个谷陡峭比是二十五,所以九步。
⛔ 第三行 —— 真实模型上,这个比值是几个数量级。
按一千算,同一条公式给出三百六十四步。而这已经是最快的了。」
⭐⭐⭐ 收这一格,用这一句,然后直接进下一张图。
「所以我要说清楚:这不是参数没调好。
是这个谷的形状决定的 —— 而形状是模型给你的,不是你能选的。
⭐ 结论只有一条:别再找那个「最好的全局学习率」了,它不存在。
得给每个参数配它自己的那一个。
⛔ 而代价马上就来:「每个参数一个」,意味着你得为每个参数存东西
—— 这一讲开头那笔十二字节的优化器状态,根子就是这张图逼出来的。」
⭐ 然后一口气把自适应那条线串下来 —— 有了量纲这个框,它会讲得特别顺。
⛔⛔ 但先纠一句几乎人人都这么说、却把思路带偏的话。 ⭐ 这一下是这段的张力所在,别省。
「你多半听过一种说法:Adam 的分母是在估二阶导。
⛔ 这是后人回头加上去的解释,不是发明它的人的思路。
照这个理解走,你解释不了两件事:它为什么对稀疏数据特别管用,
以及它为什么会对「拿不准的方向」自动变谨慎。
⭐ 真实那条路,出发点根本不在几何上 —— 在统计上。」
⭐⭐ 三代人,每代只想通一件事。一代一句话,别铺开。
「第一代,AdaGrad,二〇一一年。 起点是一个很土的问题:
他们当时想的不是神经网络,是文本。
文本里「的」出现几百万次,某个专业术语只出现三次 ——
而罕见的那些往往信息量最大。
可全网络共用一个学习率的话,那个术语这辈子学不到东西。
⭐ 于是那个念头很自然:给每个参数配它自己的学习率,见得越少的步子越大。
怎么知道见得多少?把这个参数历史上的梯度平方全加起来,然后除以它的根号。
⛔ 注意 —— 这里一个字都没提曲率、没提二阶导。」
⭐⭐⭐ 然后回答「二阶矩到底是什么」。这一句是全节最该讲慢的一句。
「那「二阶矩」到底是个什么东西?
梯度的平方、取平均、再开根号 —— 这就是梯度的均方根。
翻译成人话:这个参数的梯度,平常大概多大。
⭐⭐ 它不是曲率。它是这个旋钮自己的一把尺子。」
「那除以它,究竟在干什么?
分子是当前这个梯度,分母是它平常多大 —— 一除,得到的是
「相对于它自己的常态,这一次算大还是算小」。一个无量纲的数。
⭐ 不管这个参数本来的梯度是一百还是零点零一,除完之后大家都在同一个刻度上。
⭐⭐ 这才是「自适应学习率」这个名字的真正含义:不看绝对值,看相对于自己的常态。」
「第二代,RMSProp。 起点是:那把尺子会过期。
AdaGrad 那个和是只增不减的,走着走着分母越来越大,步子越来越小,最后就停了。
Hinton 只改了一处:把「累加」换成「滑动平均」。
⭐ 背后的道理是这句:一个参数的「典型梯度大小」本身是会变的 ——
训练早期大、后期小。拿全部历史当尺子,等于拿一把过期的尺子量今天。」
「第三代,Adam。 起点是:分子分母口径不一致。
RMSProp 已经有尺子了,可分子还是当前这一步的原始梯度,它会抖。
所以给分子也做一个滑动平均 —— 那就是动量。
⭐ 于是分子分母对齐了:分子管方向,分母管尺度。」
⭐⭐ 这一句是白送的,讲出来台下会「哦」一声。
「而这一对齐,它顺手买到了一样没打算买的东西。
论文自己管这个比值叫信噪比:
梯度一直朝一个方向、很稳 —— 分子累得大、分母也稳,走满步;
梯度忽大忽小、正负乱跳 —— 分子正负相消变小,
可分母是平方,不管正负都在涨 —— 比值变小,自动缩步。
⭐ 所以它同时干了两件事:把灵钝差异拉平,外加对拿不准的方向变谨慎。
—— 后面这件事没人设计,是那个形状白送的。」
⭐⭐ 紧接着当场算几个数 —— 刚才那段全是话,这张图把话变成能心算的数。
🖥 屏幕:fig-adamcalc,先只放 Ⓐ。
「Adam 只记两笔账:m 是梯度的滑动平均,记方向;
v 是梯度平方的滑动平均,开个根号,就是这个参数平常的梯度有多大。
每步走的是学习率乘 m 除以根号 v。
⭐ 梯度一直是 2:m 是 2,v 是 4,根号 v 是 2,一除等于 1 —— 走一个学习率。
换成 200 呢?m 两百,根号 v 两百,还是 1。」
「⭐⭐ 步子跟梯度有多大没关系,这是故意的。
前面那个旋钮的例子说过,不同参数的梯度能差好几个数量级,一个学习率顾不过来。
除以根号 v,等于给每个参数单独归一化 —— 一个学习率就管住了所有参数。」
🖥 屏幕:平移到 Ⓑ。
「那大小扔了,梯度里还剩什么?方向,和方向有多一致。
梯度一会儿正十、一会儿负十:m 正负相消,只剩零点五左右;根号 v 还是十。
一除,每步只走零点零五,而且一来一回 —— 几乎原地不动。
⭐ 所以记一句:走多远,约等于学习率乘方向有多确定。」
🖥 屏幕:平移到 Ⓒ。
「台下这时候常有人问:每步都走一个学习率,到了谷底不会来回蹦吗?
看右边:离得远时,每步接近一个学习率;到了谷底,梯度只剩噪声,m 自己缩到零点二左右。
⭐ 可它不会自己停 —— 最后停稳,靠的是学习率调度把学习率降下来。
总步长归学习率管,不归梯度大小管。」
⭐⭐⭐ 最后把两条路摆一起收口 —— 这句话回扣本节开头的柯西。
「最后把两条路摆在一起,这才是这一节真正的道理。
柯西那条路是几何的:看这个方向弯得多急,用曲率去定步长。严谨,可付不起。
Adam 这条路是统计的:不看地形,看这个参数自己的历史 ——
它平常梯度多大,现在这一下算不算反常。
⭐ 两条路最后落在相似的地方,但出发点完全不同。
⭐⭐ 而这也是为什么它叫「自适应学习率」,而不是叫「近似牛顿法」。」
⭐⭐ 紧接着补上那个一直欠着的肯定回答:「那它到底是什么」。
「顺便把『矩』这个词说清楚。
统计里一阶矩就是期望,二阶矩就是平方的期望。
Adam 那个 v,就是梯度平方的滑动平均 —— 名字里那个『二阶』到此为止。
⭐ 这里有条值得较真的:它是未中心化的二阶矩,就是 g 平方的平均,
不是方差 —— 方差还要把均值减掉,
而 Adam 手里明明有均值,它偏偏没减。」
「而这不是疏忽。
梯度完全恒定的时候,动量和根号 v 相等,比值正好是一,走满步。
可你要是拿方差当分母 —— 恒定梯度的方差是零,一除就炸了。
⭐⭐ 没减均值,这个比值才天然有上界。
刚才那条信噪比,根子就在这儿。」
「那它到底有没有几何意义?—— 有一个,只是不是大家以为的那个。
你把 loss 曲面想成一个被拉得很长很扁的椭球:
有的方向梯度天天很大,有的方向常年很小。
Adam 做的事,是沿着每一根坐标轴,按那根轴上梯度的典型大小,把轴各自重新标度一遍
—— 把这个拉长的东西压回各方向可比。
⭐ 这叫对角缩放,是个货真价实的几何操作。」
「可它缩放的依据,是『这个方向平常动多大』,
不是『这个方向弯得多急』。
⭐⭐ 所以它治得了各方向尺度差太多,治不了某个方向弯得急。
还有一条边界:它只会沿坐标轴缩放,不会转动坐标轴。
真正的耦合要是发生在轴与轴之间,逐坐标各缩各的就够不着 ——
这正是后来 Muon、Shampoo 那一路想补的方向。」
「而这个『除掉尺度』还顺手带来一个后果,值得单说一句 ——
Adam 的更新量大约是动量除以二阶矩的根号 ——
分子分母的量纲互相抵消。
也就是说 Adam 把梯度的量纲给除掉了,这一步的大小变成一个常数。」
「⛔ 那个常数是多少?—— 不是 1,是 零点二。
—— 「量纲抵消了」只说明它是个常数,没说明它等于 1。
实测稳定在 0.2 到 0.3,而且不同尺寸的模型都一样。
⭐ 而且它能算出来 —— 有个很短的闭式解,代进常用的 β₁ 进去,
正好落在实测那个值上。」
⛔ 那个闭式解不要念 —— 式子在课件 3.3b,想核的人自己看。 (2026-09-22:这句原来写在台词里面,照稿念会念出来。)
「⭐⭐ 所以学习率在 Adam 里身份变了:它不再是折算系数,
它乘在一个 0.2 上,直接就是「这一步每个参数挪多远」。
—— 这就是为什么 Adam 的学习率那么好调、那么通用。不是玄学,是量纲被消掉了。」
「⭐⭐⭐ 而这个常数最漂亮的用法,是拿它当接口。
Kimi K2 从 Adam 迁到 Muon,用的就是这一招:把 Muon 的 update RMS 也校到 0.2,
于是 Adam 那一整套调好的超参可以整套搬过去。
—— 把一个量做成常数,常数就能当接口用。」
📎 Muon 从零讲(时间富余再讲,照念约七分钟;默认不念)
⛔ 主线里 Muon 仍只有收口前那一分钟(fig-muon Ⓒ)。
有人问「正交化到底在干嘛」,或者这一节提前讲完,就按下面七块顺着图讲。
📎 时间富余再讲(fig-orth,先指 Ⓐ 的直角,再指 Ⓑ 两根红绿箭头):「正交就是垂直。用数说,两根箭头对应位置相乘再相加等于零。
正交矩阵是每列长度一、两两垂直的矩阵,乘上去只转不拉:转三十度那个,把长度五的箭头转过去还是五。
反例两列长度也是一,可不垂直,一乘就拉到六点二八。
还有个上限:平面里最多两根互相垂直的箭头,长方形矩阵只有短边那一侧能正交,叫半正交。」
📎 时间富余再讲(fig-freq,先 Ⓐ,再 Ⓑ):「任何矩阵都能拆成几个互不干扰的分量,像均衡器:方向是频率,强度是振幅,强度的平方是能量。
二一一二这块,拆成强度三和强度一两个频率;元素平方和十,正好等于九加一。
拿 (1, 0) 去乘:先拆到两个频率上各零点七零七,各乘三和一,再合起来是 (2, 1),跟直接乘一样。
⭐ 频率不住在某一列,每行每列都是所有频率的混合。比如 6144×2048 这样的门控矩阵,最多两千零四十八个频率,个数来自短边。」
📎 时间富余再讲(fig-muonstep,从左往右指六站):「Muon 的一步:梯度进来,动量按九成五旧、半成新记下来,再掺一点当前梯度往前看一眼 —— 这三站就是带动量的 SGD。
Muon 自己的是后三站:先除以总大小,让每个频率的强度都不超过一;再跑五轮矩阵乘;最后乘一个形状系数和学习率,减到权重上。
嵌入、输出头、norm 的增益、偏置不走它,走 Adam。」
📎 时间富余再讲(fig-ns,先指 Ⓐ 两条曲线最左端,再 Ⓑ):「那五轮在干嘛?矩阵这样乘出来的奇数次多项式,只改每个频率的强度,方向一根不动。所以只要看一个数过五遍变成多少。
经典的那个太慢,零点零零一过五遍还不到零点零一;Muon 的系数让小数每轮放大三倍多,五遍到零点四七,大的在零点七到一点一之间晃。
⚠️ 超过一点二六会炸,所以第一步要先除以总大小。三个频率,强度十、一、零点零一,五轮后变成零点七零、零点七一、零点四七。」
📎 时间富余再讲(fig-keeplose,先绿的 Ⓐ,再红的 Ⓑ,最后 Ⓒ 左半):「保住了三样:频率方向不动;不会反向,更新跟动量的内积一定是正的,所以一定是下坡;动量里没有的方向,它也不凭空造。
丢掉的是强弱比例,故意的,排名还会被轻微打乱。
⭐ 二一一二拉平后是单位矩阵:两行从斜着、不等长变成垂直、等长,元素全变了,可两个频率方向原样。」
📎 时间富余再讲(fig-pot,先 Ⓐ 四只碗,再 Ⓑ 两条线):「一句大白话:Muon 是矩阵版的「只留正负号」,苏剑林管它叫 msign。
再打个比方,就是大锅饭:动量里有这个方向才有份,编制每步按数据重发;有份的每人约一碗,极弱的临时工只分到半碗,总量最后由学习率定。
⭐ 单步人人平等,长期论功行赏:一直被同一个方向推的越走越远,东一下西一下的原地打转。强弱从单步多大,换成了多步多一致。」
📎 时间富余再讲(fig-muonfam,先 Ⓐ 左右两半,再 Ⓑ 两条支):「强弱都扔了凭什么更好?两条理由。
一条是看出来的:Keller Jordan 发现普通更新几乎是低秩的,被少数几个方向霸占,正交化把幅度小但重要的稀有方向抬起来 —— 他自己说这是推测。
一条是算出来的:Bernstein 要求这一层对任何输入的输出变化不超过一个上限,在这个约束下降 loss 最多的一步,正好就是正交化的梯度。
家谱一句带过:只留正负号这条思路,从 1993 年的 Rprop 到 signSGD,Muon 是把它搬到了整块矩阵上。」
⭐⭐ 紧接着给一把能随时用的尺子 —— 台下这会儿正想问「那我怎么知道我设对了」。
🖥 屏幕:fig-updratio。
「那怎么知道自己的学习率设对没有?有一条能用眼睛对齐的线。
量的是更新量除以参数本身 —— ⛔ 注意是更新量,不是梯度。
经验值千分之一,图上那条黑线就是它。贴着线就大致合适。」
⛔ 但 Ⓑ 那一格必须讲 —— 它是这张图唯一的机关。
「⛔ 可 Ⓑ 那一格会让你意外:设得太大的那条,loss 反而更低。
—— 那是不是说这条线没用?不是。代价在别处:
权重被撑得老大、抖动也大了一截,
⭐⭐ 而学习率再往上抬一点点,就直接 NaN 了 —— 它当时离悬崖只有一步。
⭐ 所以这条比值不是「让 loss 最低」的指标,是「看你离悬崖多远」的指标。
(具体几倍、抬多少炸,在课件里;台上不用报。)」
⭐ 第五段:学习率怎么调。台下最想听这一段,但它最容易讲成玄学 —— 所以全程只报有出处的数。
🖥 屏幕:fig-lr-curve,先放大 Ⓐ。
「先看图上这两条曲线的形状不一样 ——
GPT-3 升完就一路下滑,V3 中间多了一段又长又平的平台。
⭐ 记住这个差别,它是这一段最后要收的那个包袱。
眼下你只用做三个决定:从哪升上来、升到多高、怎么降下去。
先说 warmup —— 这里有个流行的解释是错的。
大部分教程说:Adam 一开始样本太少、二阶矩估不准。
二〇二四年有一篇专门做系统实验的论文,明确说这不是主因。
真正的机制是:warmup 让网络能承受一个更大的目标学习率,
它把网络推到 loss 曲面上条件更好的区域去。」
⭐⭐ 「条件更好的区域」不能就这么放过去 —— 它听起来像同义反复。 把它接回 1.4b 那个二阶导,一句话就实了。
「可『条件更好的区域』是句什么话?得说具体。
你想一下在一条抛物线上迈步子:步子只要超过『二除以曲率』,
就不是走慢走快的问题了 ——
每一步都被放大,一步比一步远,直接翻出去。
所以能用多大的学习率,不是你说了算,是当前这块曲面的曲率说了算。
而训练最开始那一刻,曲率特别高 ——
高到你想用的那个峰值根本不合法。」
「那 warmup 干的事就很具体了:
先用一段小到安全的步子,让网络自己走到曲率更低的地方去。
等曲率降下来,那个峰值才变成合法的。
所以我刚才那句话得改一个字 ——
不是网络学会了忍受大步子,是曲面本身变平缓了。」
⭐⭐ 这三个问题现场一定有人问。三个是同一个误解的三个侧面 —— 先拆前提,不要逐条答。
「这儿一定有人要问:开局是十三万选一,那时候梯度不得特别大?
—— loss 大,不等于梯度大。
开局 loss 是十一点七七,确实是个大数。
可我们前面画过:logits 那一层的梯度是 p 减 y,每一项都夹在负一到正一之间。
⭐ 它跟词表是十三万还是一千,没关系。」
「第二个问题问得更好:梯度不是已经被 Adam 归一化过了吗?
对 —— 而这句话正好指着答案。
Adam 分子是动量、分母是梯度的均方根,量纲互相抵消 ——
所以每一步迈多远,基本就等于学习率本身,跟这一步梯度多大几乎没关系。
⭐⭐ 所以危险根本不来自「梯度大」。
大的不是你迈的那一步,是你脚下那块地的弯度。」
「这就回到我们讲过的二阶导了。
⭐⭐ Adam 除掉的是『陡』,它除不掉『弯』。
它手里那个二阶矩是统计量,而弯度是二阶导、是几何量 ——
它从来没算过。
所以论文那个词叫『预条件曲率』,意思就是在 Adam 处理完之后再量的曲率。
你问都处理过了为什么还高?—— 量的就是处理之后那个数,它依然高。」
「还有人会问:是不是一开始分母还没攒到值?
—— 这条 Adam 自己防了,它有偏差修正,专门补头几步累积不足。
⛔ 最后提醒一句,别把这个故事推太远:
不是「越往后曲率越低、学习率就能一路涨」。
那条曲线升到峰值就不涨了,后面还要降。
warmup 只负责把你送到峰值,不负责一直往上。」
「而且还有一条反直觉的:目标学习率固定的话,warmup 拉长基本没收益。
决定效果的是峰值本身;warmup 的价值是让你敢把峰值设高。
实际用多长?GPT-3 是头三亿七千五百万个 token,占总量的千分之一点二五。
—— 这一段短到可以不当成超参看。」
「峰值设多少?这个有现成的表可以抄,不用猜。
GPT-3 论文表 2.1 把八个规模一起列了:一亿两千五百万用六乘十的负四次方,
一路到一百七十五 B 的零点六。
⭐ 规律肉眼可见:模型越大,学习率越小、batch 越大。
而且幅度很温和 —— 一千四百倍的规模差,学习率只差十倍。
⛔ 注意那张表里 batch 和学习率是一起变的 ——
这是最容易漏的一条:你不能只调学习率不看 batch。」
🖥 屏幕:平移到 fig-lr-curve 的 Ⓑ。
「怎么降?两个流派。
老派是余弦:GPT-3 在两千六百亿 token 内降到峰值的百分之十,之后一直保持。
新派是先恒定、最后才降:DeepSeek-V3 升到峰值之后一路平着跑,
跑到十万亿 token 才开始降。
⭐ 新派流行的理由特别实在:余弦要求你一开始就知道总共训多少步,
因为曲线形状依赖终点;而恒定段可以随时截断,接一小段衰减就能出一个能用的
checkpoint。它把「训多久」这个决定,从开局推迟到了随时。」
「⭐⭐ 最后指一下图上那条横贯全场的虚线:
两派的终点,都落在峰值的十分之一附近。
⚠️ 两个样本不构成定律 —— 但足以说明「降到零」不是默认做法,
这一点跟很多人的印象相反。」
⭐⭐⭐ 报完学习率必须紧接着讲 batch —— 刚才那句「它俩绑在一起」 欠着一半没还。 ⛔ 这一格现场点名要过(「为什么 batch 开大了训练就会稳定,这里的理论也都讲讲」)。 ⭐ 台下对这一格的预期是「玄学」,而它其实只是平均的老道理 —— 讲完会很解气。整格 90 秒,不要展开成一节。
「那 batch 自己该开多大?
⭐ 先说一句反直觉的:batch 开大了训练会更稳,这件事一点都不玄。
你想想梯度是什么 —— 它是这一批样本各自意见的平均。
屋里坐八个人,混进一个特别偏激的,平均值被他拽走一大截;
屋里坐八百个人,同一个人基本就听不见了。
⭐ 所以抖动大概按根号 B 分之一在缩 —— batch 翻四倍,噪声减半。
就这么简单。」
「⛔ 那为什么不一直往大开?
你会听到两种说法:一种说再加样本也换不来等量的进步,
一种说batch 大了学习率就得跟着抬,可学习率抬不动。
⭐⭐⭐ 听起来是两条路,其实是同一条。
回到刚才那个式子 —— 最优学习率等于上限,除以「一加上噪声尺度比 batch」。
两边卡你的,是同一个噪声尺度。
⭐ 给个好记的锚:当 batch 正好等于那个噪声尺度的时候,
你的学习率预算刚好用掉一半。再往后翻多少倍,剩下那一半也只是慢慢逼近。」
「⭐⭐ 所以现场那两句听着打架的话,其实各说一半:
「大了才稳」说的是稳定性 —— 它单调受益,没有拐点。
「大了就不行」说的是样本效率 —— 它有拐点。
—— 选 batch 就是在这两条之间,找那个刚好够稳、又还没开始浪费的位置。」
⭐ 顺手把第三句流传很广的话也校准了 —— 三句一起收,这一格就完整了。
🖥 屏幕:fig-batch。
「还有第三句:『batch 开大就更快』。
这句话有前提,而且前提正好卡在你们这一档。
看 Ⓐ 这条曲线:左半段成立,右半段不成立。
左边卡还没喂饱,batch 大了步数变少、每步没变贵 —— 那是真的快。
⛔ 右边卡喂饱了,每步变贵的倍数,正好抵掉步数变少的倍数。
⭐ 而几百亿参数、几百张卡的训练,基本都在右边这一段
—— 所以在你们这儿,开大 batch 买到的是「稳」,不是「快」。」
⭐⭐ 这里一定会有人举手问「那我是不是得一路加卡」—— 先答了它。 ⛔ 不答,台下会把「batch 一路往上爬」听成「这是大厂才玩得起的东西」。
「这儿有个问题一定有人要问:batch 一路爬上去,是不是得一路加卡?
⭐ 不用。它爬的不是卡,是梯度累积。
回到刚才那个乘法 —— 要把 global batch 翻五倍,把「攒几次再更新」
从一次调到五次就行,卡一张不加。
⭐ 而且显存也不涨:攒梯度只是把更新往后推,
同时挂着的中间结果永远只有一份。」
「那代价是什么?
同样的卡、同样的吞吐,每秒处理的 token 数一点没变 ——
变的是攒够多少 token 才更新一次。
⭐⭐ 更新次数变少了,总时间不变。所以爬 batch 花的既不是卡,也不是时间,
花的是「更新频率」。
而这正是它划算的地方:早期临界 batch 小,开大是浪费;
后期临界 batch 涨上来了,少更新几次几乎不损失样本效率,
却能换到 all-reduce 变稀、噪声更小。」
⭐ 如果有人怀疑这事是不是真的,报一条出处就够 —— 推荐最后这条。
「这不是我编的,三条都查得到:
机制:OpenAI 二〇一八年那篇讲梯度噪声尺度的,摘要原话是
「随着一次训练中 loss 的下降,噪声尺度会上升」。
实践:DeepSeek-V3 报告正文 —— batch 在头四千六百九十亿 token 里
从 3072 爬到 15360。而它全程两千零四十八张卡,没中途加机器。
⭐ 框架:Megatron 有一个一等公民的开关叫 --rampup-batch-size,
三个参数是起始值、每次加多少、爬多少样本。
注意它要你给的是「目标 global batch」—— 从头到尾没问你要几张卡。」
⭐ 最后这一句留给回去写代码的人,它比上面所有理论都值钱。
「顺带提醒一个会静默咬人的坑:梯度累积攒完必须除以累积次数。
忘了除,梯度整整大 K 倍 —— 那跟把学习率乘 K 是一回事。
⛔ 而症状特别有迷惑性:代码跑得通、不报错、loss 一开始还在降,然后突然飞掉。
于是你会去查数据、查初始化 —— 它其实是个学习率问题,只是换了张脸。」
⭐ 然后两小段,各一分钟 —— 它们不是重点,但不说会留问号。 ⛔ 台下一定有人在想「那 β₁ β₂ 呢」「checkpoint 为什么那么大」。 ⭐ 这两个问题都能用已经讲过的东西一句话答完, 所以别跳过,也别展开。
「先补一句 β₁ 和 β₂ —— 大家一般当成「用默认值就行」。
⭐ 其实你们已经认识它了:讲动量的时候那个「记多久」的旋钮,就是它。
Adam 身上挂了两个:β₁ 管分子,记十步左右,把方向的抖动抹平;
β₂ 管分母,取 0.99 时记一百步左右,因为「这个参数平常梯度多大」这件事,
得用更长的时间才看得准。
⭐⭐ 所以 β₂ 调大 = 尺子更稳但反应慢,调小 = 跟得紧但噪声大。
还是那个「记多久」,没有第二件事。」
🖥 屏幕:fig-adamtime,先只放 Ⓐ。
「两笔账记性不一样长,有个直接后果:梯度一突变,m 十来步就跟上,v 慢半拍。
梯度从一跳到十,那一段每步就走得比一个学习率多 ——
β₂ 取原文默认的零点九九九时,最多冲到五倍;取大模型常用的零点九五,只多一成。」
🖥 屏幕:平移到 Ⓑ。
「顺带把偏差修正说清楚。m 从零起步,第一步只掺进一成梯度,偏小十倍;
第二步凑到零点一九,不是零了,但还偏小。
⭐ 所以除以这个「凑到多少」,正好补回来。五十步左右它就凑满了,除以一,修正自己消失。
v 那笔 β₂ 大,要凑得久得多。」
⭐⭐ 如果时间够,再加这一句 —— 它把前面那条精度判据往回咬了一口。 ⚠️ 这是我们自己推的,说的时候必须带上「这是猜想」。
「有意思的是 PaLM 让 β₂ 随步数变,越往后窗口越长 ——
到十万步的时候窗口能到一万步。
⛔ 那就跟我们前面那条判据打架了:我们说
「滑动平均有遗忘,所以 bf16 扛得住」。
可 β₂ 一路涨到 0.9999,那个遗忘就慢得快要不遗忘了 ——
v 越来越像一个真的累加器。
⚠️ 所以那条判据得带个前提:它成立的条件是「β 不随步数趋近 1」。
⛔ 这一条是我推的,不是论文说的 —— 当猜想听。」
「第二小段:checkpoint 要存什么?
—— 答案不用查文档,刚才那张十六字节的表直接就能推出来。
一格一格问「丢了能不能重建」:
bf16 权重,不用存,它是主权重的投影,转一下就有。
bf16 梯度,不用存,下一步重新算一份。
fp32 主权重、动量、二阶矩 —— 三个都得存,它们是历史,丢了只能从零重来。
⭐⭐⭐ 所以 checkpoint 的大小,正好就是那十二字节。
671B 的模型,一份七点三个 TiB。」
⭐ 然后这两句要说 —— 它们解释了两件工程上人人遇到过的事。
「这一下就解释了:
一,为什么 checkpoint 这么大、存这么慢 ——
它存的不是模型,是优化器。模型本身只占三分之一。
二,为什么「发布的模型权重」比 checkpoint 小得多 ——
发布只要那两字节的推理权重。一比六。
⛔ 最后提醒一句:只存这十二字节还不够,还有三样 ——
步数、数据读到哪儿了、随机数状态。
⭐ 第二样最容易漏,而且漏了最隐蔽:恢复之后把同一批数据重训一遍,
loss 曲线看着完全正常。」
⭐⭐⭐ 收口之前,加一段 LoRA —— 这是台下唯一会亲手跑的那种训练。 ⛔ 别把它讲成「一个新方法」。它不需要任何新概念, 就是刚才那张 16 字节的账换个算法重算一遍 —— 所以它只要三分钟。
「在收口之前插一段,因为这一段跟在座各位关系最大。
前面算的全是从零开始训。可各位这辈子真正会亲手跑的训练,
多半是拿别人训好的模型接着调。
—— 那 LoRA 到底省了什么?就用刚才那三本账,一本一本对。」
「第一本,常驻。底座冻住,只在旁边挂一对很瘦的小矩阵。
七十亿参数的模型:全量微调要一百 G,LoRA 只要十二点七 G
—— 差了将近八倍。
⭐ 为什么差这么多?因为那十六字节里,有十四字节是「只有要被更新的参数才需要」的。
冻住的参数只留两字节权重 —— 它退回成了推理的样子。」
「第二本,算力。这一条直接来自第一节。
还记得反向要付两笔乘法吗 —— 算输入的梯度、算权重的梯度。
冻住的那些层,第二笔可以整个不算:它的权重根本不更新,算出来也没人用。
所以前向一,反向只剩一 —— 三倍变两倍。」
⛔⛔ 第三本是这一段的重点,也是台下最容易误会的一条。讲之前停一拍。
「第三本,激活。很多人以为「只训千分之一的参数,训练就变得很轻」。
—— 显存上不是。
因为 adapter 是挂在每一层上的。最前面那层的 adapter 也要梯度,
而梯度只能从 loss 一路传回去。
所以整条链的激活,该在场的还得在场。
⭐ 结论很具体:LoRA 之后,激活往往成了新的大头 —— 所以 LoRA 还是要开重算。
这两件事不是替代关系,是叠加关系。」
「一句话收:LoRA 改的是「有多少参数带着那十六字节」, 它没有改变「反向要穿过整个网络」这件事。」
⭐⭐ 收口之前,给 Muon 一分钟 —— 而这一分钟只放一格。
⛔ fig-muon 有四格,Ⓐ Ⓑ Ⓓ 这次都别放。
⭐ 只有 Ⓒ 值这一分钟:它是台下唯一能看见的那个答案,
其余三格都得靠讲,而讲就超时。
🖥 屏幕:fig-muon,只放 Ⓒ,
一分钟后就切走。
「最后花一分钟说 Muon,只讲一个画面。
我们前面说「一步不许迈太大」—— 可「太大」得先有把尺子量。
⭐ 用一把尺量,「不许超过一格」圈出来的是个圆;
换另一把尺,圈出来的是个方。
同一个梯度方向,在圆上走到最远,是延长线上那一点 —— 那就是 SGD。
⭐⭐ 可在方上走到最远,落在角上 —— 那个角就是 Muon。」
⭐⭐⭐ 然后用这一句把整节接回去,讲完就切走。 ⭐ 这句话跟前面「最快是相对于你怎么量一步」那条前提是同一件事, 说出来台下会有「哦」的那一下。
「所以 Muon 不是「又一个新优化器」。
它跟 SGD 是同一个问题的两个答案 —— 区别只在你拿哪把尺子量「一步」。
Newton–Schulz 那五轮在干什么,课件 3.3b 前面有七张图,主线不展开。」
⚠️ 备答(问到才答,三句话就收,别主动开这个头):
「二阶矩扔了,那『各参数尺度差太远』这个病谁来治?」
—— 答:「正交化就在治同一个病,只是换了一层。它把那块矩阵的
奇异值全部拉成一样大,于是每个方向挪多少,跟那个方向原本梯度多大就脱钩了。
Adam 是逐元素抹尺度,Muon 是整块矩阵抹 ——
而且它够得着轴与轴之间,逐元素那种够不着。」细节在课件 3.4。
⚠️ 再追问「那是不是完全等价」—— 答:「不是。正交化只拉齐了各方向之间,
没说整体该迈多大 —— 那是后来 Moonlight 那篇才补上的。」
⚠️ 备答:「为什么只能作用于二维参数?」 —— 答:「那里其实是两种不一样的排除。 标量和向量是原理上不适用 —— 正交化要有多个奇异方向才有得拉平, 一个向量只有一个方向,拉平就退化成单纯归一化了。 可 embedding 和输出头是二维的、原理上完全做得了, 作者还是把它们留给 AdamW,理由是实测效果更好 —— 那是实证排除,不是原理排除。」
⭐ 本节收口,三句话,念完就走:
「这一整条线可以用一句话收:
梯度只告诉你往哪走,优化器决定走多远。
而几十年的演化全都在回答同一个问题 —— 这个「多远」该由谁说了算:
SGD 说由你说了算;Adam 说由梯度自己的历史尺度说了算;Muon 说由矩阵的几何说了算。」
⛔ 不要比较哪个优化器收敛快。本课没有这些优化器的对照实测 —— 说了就是编。课件里那张图刻意不含任何收敛曲线,台上也要守住。
⚠️ Muon 那一段控制在一分钟。它在这一讲里的角色只是「有人往回走了一步」, 展开讲 Newton-Schulz 会把节奏带偏。要展开就用前面那七块「时间富余再讲」,别临场自己推。
⚠️ 报学习率数字时,一定要连 batch 和 schedule 一起报。 单报一个数是没有意义的,而且台下真的会抄回去用。
⛔ LoRA 那一段不要展开讲「秩怎么选」「挂哪几个矩阵」。 那是另一门课。这里它的角色只有一个:同一张账换个算法重算一遍 —— 三分钟,到「激活不省」那句就收。
🖥 本节主屏:课件 第三节 有了导数,那一步该迈多大 —— 梯度下降与优化器 · 主图 fig-optimizers
第四节 这张账交给专题五(2′)
🎯 这一节只留一句:并行策略不是凭空设计出来的,是被这张账的大小顺序逼出来的。
「把前面几节的东西,按大小排一遍:
⭐ 优化器状态最大,每参数十二字节;权重和梯度一样大,各两字节;
激活没有固定大小 —— 看你这一步同时塞进多少 token。」
「卡装不下的时候,就按这个顺序往外切:
先切最大的、而且最少被用到的。
⭐ 这正好就是 ZeRO 那三级的顺序:先优化器状态,再梯度,最后权重。」
⭐⭐ 最后一句是本节的落点,说完就走。
「所以这个顺序不用背。
并行策略不是凭空设计出来的,是被这张账的大小顺序逼出来的。
至于怎么切、切给谁、切完通信涨多少 —— 那是专题五整讲的事。」
🖥 屏幕:课件 s四 那三句话那一屏就够。
⛔ fig-zero 在折叠块里,不要展开。
⛔ 不要讲通信量(2Ψ / 3Ψ)。被问「为什么不直接上 ZeRO-3」, 答一句「权重每层都要用,切开要先拼回来,通信最贵 —— 下一讲算」。
⛔ 不要把 FSDP 说成「另一种方案」。它约等于 ZeRO-3。
⚠️ 如果有人问「那 TP / PP 呢」—— 答「它们切的是另一个维度,下一讲」,别展开。
🖥 本节主屏:课件 第四节 这张账交给专题五 · 本节无图(故意的)
第五节 把这三件事,放到一台你摸得到的机器上(6′)
🎯 这一节只留一件事:缩到一台小机器上,激活照样比常驻那一块还大 —— 重算不是大模型的专利。
🖥 屏幕:fig-step,先整张投三秒,
再放大 Ⓐ。⭐ 这是全讲第一次把四项画在同一条时间轴上,让那个画面先落地。
「前面讲的都对,可全是六千七百一十亿参数、TiB 级的数 —— 它们没有分母。
这一节先把四项摆到同一条时间轴上看一眼,
再把同一件事缩到一个你能自己算一遍的模型上。」
「看这两条形状相反的带子:蓝的是前向堆起来的激活,橙的是反向攒出来的梯度。
⭐ 它们的高点差了大半个 step ——
所以「什么时候最挤」,得连着「挤的是哪一项」一起问。」
🖥 屏幕:anim-memtime。
「让这笔账跑一遍:前向往上堆,反向一边用一边放。
⭐ 峰值是某一个瞬间,不是训练的某个阶段 —— 而你要买的,是那个瞬间。」
⭐⭐⭐ 然后是本节的主菜。这是全讲唯一能手算的一格 —— 最好别砍。
🖥 屏幕:滚到课件 5.4,跟着那三步小表走。
「现在缩小。一个一亿两千五百万参数的模型 ——
就是 GPT-3 论文那张八档表最上面那一档:十二层,宽七百六十八。
一张卡,batch 八条,每条一千零二十四个 token。」
「先把这一讲的三件事,在这台机器上各落一句。
⭐ loss:八千多个位置,每个位置一个负的 ln p,取平均
—— 刚初始化时它就是 ln 词表,跟第一节那把尺一模一样。
⭐ 导数:一亿两千五百万个,代价是多跑两遍前向,不是一亿两千五百万遍。
⭐ 步长:Adam 给每个参数记两个滑动平均 —— 那是十二字节里的八个;
剩下四个是 fp32 主权重,跟 Adam 无关。」
「然后照搬那张十六字节的账。
这个模型的权重只有零点二三个 GiB,训练时却要占一点八六 —— 八倍。
多出来的全是训练才要的。」
⛔⛔ 下一句是这一节的全部价值,说之前停一拍。
「再数激活。一层里每个 token 留下的东西一项项加起来,
乘十二层、再乘八千多个 token —— 二点一一个 GiB。
⛔ 比常驻那一块还大。
一个一亿参数出头的小模型,序列才一千出头,batch 开到八就够了。
⭐⭐ 所以重算不是大模型的专利。」
「开了全量重算,激活掉到零点三二,省六点七倍;
代价跟大模型那边一模一样:算力从三倍变四倍,多付三分之一。
⭐ 这张小表,就是你笔记本上那个训练循环。」
📌 被追问「logits 算了没有」时:没算,是故意的。词表约五万, 一次性把整个 logits 算出来要零点七七 GiB,是那零点三二的两倍多; 真实实现分块算 loss,所以它不进总账 —— 那是口径选择,不是它不存在。
⭐ 时间够再讲这一格,一分钟 —— 它答的是台下一定会问的那句「那省的倍数怎么不一样」。
「多付三分之一,两边一样;可省的倍数,这边六点七,V3 那边二十点五 —— 差了三倍。为什么?
省多少取决于两样:一层里挂了多少东西,一共有多少层。
V3 一层挂得多,根子在 MoE;层数又是它的五倍。两样都吃亏,小模型省得少是必然的。」
「⭐⭐ 所以真正跟规模无关的只有三条:
多付三分之一、每参数十六字节、激活只认 token 总数。
⛔ 「省多少倍」不在这个名单里 —— 换个架构就得重算一遍。」
⛔ 交棒段(5.5)在课件里已折叠 —— 不讲。这里只说下面这半句就进第六节。 ⭐ 一定要说,否则台下会以为要下课了,第六节整节都在跟这个预期打架。
「不过先别收 —— 前面这些账,都默认了一个前提:这一步能正常跑完。
⭐ 最后一节讲的就是这个前提不成立的时候。」
fig-step 上的 Ⓑ 也别展开 ——
被问「激活要多大才追平常驻」时答:约六十二条 128K、或近两千条 4K,自己推的,当量级听。⛔ 不要把「省多少倍」那个式子写出来。说「一层挂多少、一共几层」就够,式子在课件 5.4。
⛔⛔ 不要在这里收全讲。那四条判据在第六节末尾 —— 在这儿收尾等于提前谢幕。
⚠️ 这一格的数几乎全是现算的(脚本里 assert 住),只有那一档模型的形状是查来的(GPT-3 论文表 2.1)。 报的时候说清这一点。
🖥 本节主屏:课件 第五节 把这三件事,放到一台你摸得到的机器上 · 主图 fig-step
第六节 训不崩 —— loss 飞了怎么办,以及怎么让它别飞(9′)
🎯 这一节留一条:评价任何稳定性手段,都要同时看「稳没稳」和「质量掉没掉」。
⭐⭐ 这一节的位置很特别 —— 它是唯一一节讲「出事了怎么办」的。 前面五节都在算账,可账算得再清楚,也回答不了训练现场最常问的那一句。 (⛔ 2026-09-22 改:原来写的是「前面六节」—— 数错了,它自己就是第六节。)
「前面我们把账算完了。
但真到了机器上,最常听见的一句话不是「显存不够」,而是 ——
「哎,loss 飞了。」」
⭐⭐⭐ 先花一分钟点名 —— 不然后面这一节全是「坏」,台下分不清谁是谁。 ⛔ 这一格讲义原来没有(教材 6.0 有)。⭐ 它的价值不在内容新, 在于把散在五个章节里的五种坏并排摆一次 —— 台下前面都听过,只是没人告诉他们这是五件不同的事。
「开始之前先点个名。这一讲从头到尾讲过五种不同的「坏」,
可它们散在五个章节里,各叫各的名字 —— 现场真正难的不是治,是先认出这是哪一种。
⭐ 我按「你在屏幕上会看到什么」来排:
一、loss 变 NaN —— 梯度爆炸。
二、前面几层一直不动 —— 梯度消失。
—— ⭐ 这两个是同一条连乘的两个方向:每一项平均大于一就指数涨,小于一就指数塌。
所以治法也是同一类。
三、loss 不降,可梯度明明不是零 —— 更新被舍入吞掉了。
四、loss 一路上翘,或者越弹越大 —— 步子迈太大。
五、平稳训练里突然一根尖 —— 这就是今天要讲的 spike。」
⛔⛔ 三和四之间那句一定要说 —— 它是这张表最值钱的一行。
「⛔ 特别注意三和四:现场都被叫成「训不动」,
可判据正好相反 ——
第三种要把步子放大、或者把精度提上去;第四种要把步子调小。
认错了会越治越糟。
⭐ 而它们各有一个一分钟能做的判据:
第三种 —— 算更新量的 RMS 除以参数的 RMS,跟二百五十六分之一比。
第四种 —— 把学习率砍一半重跑,立刻正常就是它。」
🖥 屏幕:fig-spike,先只放 Ⓐ,停三秒不说话。
⭐ 这张图的作用是让没见过训练曲线的人先有画面 ——
台下有一半人这辈子没盯过 loss 曲线,你直接讲「spike」他们脑子里是空的。
「上面这条红的,是 PaLM 训 540B 的时候,loss 大概长的样子。
一路往下走,那是它在变好。可你看这些往上扎的尖 ——
大约二十次。
再看下面这条绿的:同一套配方,换个小一点的模型,一个尖都没有。」
⭐ 这里要提醒台下两件事,都在图上写着。
「第一,这些尖出现的时刻完全没有规律 ——
挤在一起的有,隔很久才来一个的也有,训到很晚了还会来。
所以不要以为「开头挺过去就没事了」。
第二,纵轴上我一个刻度都没画,这是故意的。
论文只描述了这些尖长什么样,没给具体的数
—— 没有刻度的曲线是示意,有刻度的才是数据。」
🖥 屏幕:平移到 fig-spike 的 Ⓑ。
⭐⭐⭐ 这一格是整节的钩子,讲完要停一拍。
「而这一节真正刺耳的,是括号里那半句话 ——
梯度裁剪是开着的。
裁剪管的是「这一步最多迈多大」,它是所有人心里的那道保险。
保险开着,还是飞了二十次。
⭐ 所以问题不是「某一步迈太大」这么简单。
那到底是为什么?—— 论文自己说:不知道。
原话是训练成本太高,没能找到一个有原则的缓解办法。」
⛔ 这句「不知道」要原样讲出来,不要圆场。 ⭐ 台下将来自己训模型遇到 spike,会一遍遍去找自己哪个参数配错了 —— 告诉他们这是开放问题,比给他们三个技巧更有用。
🖥 屏幕:切到 fig-stability,先放大 Ⓑ。
⛔ 不要从 Ⓐ 开始 —— 先讲那个反直觉的实验,台下才会认真听后面的分类。
⭐⭐⭐ 然后是这一节的钩子。讲之前停一拍,让台下先给出第一反应。
「第一反应是什么?肯定是那批数据有问题。
他们去验了。做法很干净:把 spike 前后那几批数据单拎出来,
从另一个更早的 checkpoint 重新喂一遍。
……不飞。」
「⭐ 所以 spike 不是坏数据造成的。
是这批数据,和当时那个参数状态,两样撞在一起才出的事。
缺一样,都不会飞。」
「这一下就解释了他们那个看起来很土的办法为什么管用 ——
回滚到 spike 之前大约一百步,跳掉那二百到五百批数据,接着跑。
之后同一个点就不再飞了。
⛔ 但要说清楚:这不是修好了,是绕过去了。
论文自己也写着:由于训练成本太高,他们没能找到一个有原则的办法。」
🖥 屏幕:平移到 Ⓐ。
「知道了这一点,再看治法就有框架了。三类,治的是三个不同的位置。
治结构 —— 改网络本身,让它天生不容易飞:归一化放进残差块里、QK-norm、初始化。
治数值 —— 不让某些量长太大:z-loss、梯度裁剪。
治现场 —— 已经飞了怎么救:回滚加跳数据。
⭐ 越左越治本,越右越应急。所以「先动哪个」是有顺序的。」
⭐⭐⭐ 三类里挑一类往深里讲 —— 挑治结构,因为它顺带把 3.5 那个悬案收了。 ⛔ 2026-09-20 第 20 轮把这一格从本节开头挪到这里:原来它排在「一共有哪三类」之前 —— 台下还不知道有几类,就先听了「治法二」。编号是承诺,先有清单才能有编号。
🖥 屏幕:fig-prepost。
⭐⭐ 先摆零件,再讲位置 —— 这两格一个数都不报。
「讲两种放法之前,先把一层拆开 —— 不然那个差别没处落。
一层不是一条直线,是两条路并在一起。
一条是主干:输入原样往前走,什么都不做。
另一条是分支:同一个输入进注意力、或者进 MLP,算出一个修正量。
到层尾两条合流 —— 这就是第一节讲过的残差。
⭐ 而归一化是第三个零件。它总得插在这两条路的某个位置上。」
「而两种放法的全部差别,就是这个零件插在哪儿 ——
别的一个字都没改。
老的那种:先让两条路合流,再拿归一化去洗整条主干
—— 主干每过一层都被动一次手。
新的那种:归一化被塞进分支里面了 ——
主干那条路从头到尾没人碰,一路直通到顶。
先记住这个画面。到这儿还看不出谁好谁坏。」
「那现在说一句反直觉的:在老的那种放法里,归一化本身就是梯度消失的元凶之一。
⭐ 注意这句话有多怪 —— 我们一直以为归一化是来救场的。」
⭐ 机制用人话讲,别推公式。 ⛔ 台上一旦开始说「方差 1 加 1 等于 2」,注意力就全跑到算术上去了。 数在课件 6.5,想核的人自己看。
「机制一句话:老的那种做法是先把主干和分支加起来,再归一化。
可初始化那一刻,主干和分支是两个互不相干的随机向量 ——
加在一起,能量翻了一倍。
而归一化的职责就是把能量拉回原来那个水平。
⭐ 所以它每过一层,就把信号压掉一截。
一层一层下去 —— 最初那个输入到了深层,只剩极小的一点点。
看这张图那条红线:残差那条「直通路」,被指数地削掉了,
而且越靠近输入削得越狠。」
⭐⭐ 然后问那个扎人的问题 —— 让台下自己想三秒。
「那问题来了:既然它这么坏,为什么不干脆把归一化去掉?」
「—— 因为去掉之后,每加一层残差,能量就往上涨一截,一路涨到失控。
⭐ 所以问题从来不是「加不加归一化」,是「加在哪儿」。
新的放法把顺序换了:先归一化,再送进分支;主干那条路一路直通,不被碰。
这样每个残差分支是平权的 —— 那条指数衰减就没了。」
⭐⭐⭐ 这一格真正的高点在这儿。前面都是铺垫,这一句要单独讲、讲完停一拍。 ⭐ 屏幕这时候正好指着左右两半:曲线一模一样,连坐标都没动。
「而最反直觉的一条是这个 ——
这个「毛病」,换个场合就变成了功能。」
「你想微调的时候我们要什么:
优先调靠近输出的参数,别过度动靠近输入的 ——
免得把预训练学到的东西破坏掉。
而「梯度消失」的意思恰恰是 —— 越靠近输入,它对最终输出的影响越弱。
⭐⭐ 这正好就是微调想要的。
所以预训练好的老式结构,往往比新式的微调效果更好。
—— 同一条曲线,预训练时是毛病,微调时是功能。」
⭐ 顺手把第三节那个 warmup 悬案结掉 —— 两句话,别展开证明。
「这一格还顺手回答了第三节留下的那个问题:warmup 到底为什么要有。
老式结构在初始化那一刻,靠近输出的梯度就已经很大 ——
这时候用大学习率必然不稳,而 warmup 正是压住它的办法。
新式结构初始化时梯度就是良态的,所以可以把 warmup 去掉。
⭐ 所以第三节那三个解释不是在互相竞争:
一个说的是「当年为什么非要不可」,一个说的是「今天为什么还留着」
—— 问的根本不是同一个问题。」
「⭐ 但别就停在『可以去掉』 ——
V3 就是新式结构,它照样带着 warmup。
因为今天留着它的理由换了:
当年是为了活下来,今天是为了把峰值设得更高
—— 而峰值高,后面整段训练都快。」
⭐ 再补一个一分钟的小故事,它跟 6.1 那条规模效应是同一个模式。
「治结构还有一招,来历也很具体。
有人把视觉 Transformer 往上做到几十亿参数的时候,训了几千步就发散。
查出来的根因很好懂:注意力分数长疯了 ——
大到 softmax 之后,注意力权重塌成几乎只盯着一个位置。
⭐ 它不再是「分配注意力」,它变成了「死盯一个」。
治法很直接:做点积之前,给 Q 和 K 各做一次归一化 ——
这就是今天很多大模型标配的 QK-norm。
⚠️ 出处要说准:不是那篇论文发明的,原文写的是「我们采用某某的做法」;
它值得引,是因为它把这招用到了两百二十亿参数上,并留下了对照。
⛔ 而注意 —— 这又是一次「只在大规模上才出现」的故障。」
⭐⭐ 最后清两个常见误解。第一个配图讲 —— 这张图只有一根真数轴。
🖥 屏幕:fig-underflow。
「『既然 fp16 要做 loss scaling,那 bf16 是不是也得做』—— 不用。
⛔ 但理由不是『16 位够用了』—— 你想,fp16 也是 16 位,
而且它比 bf16 还更细一档。
⭐ 关键是:同样是这么多格子,两边的分法不一样。
fp16 把更多格子分给了『分得细』,bf16 把更多格子分给了『够得着多小』。」
「⭐⭐ 所以 fp16 真正的毛病不是不够细,是下不去。
梯度一小到某个程度,它直接变成零 —— 那个参数这一步就等于没收到任何消息。
看这根对数轴:fp16 的归零线在这儿,bf16 的下界远在左边,
中间那一大片绿全是 bf16 存得下、fp16 存不下的。」
「那 loss scaling 干的是什么?很朴素 —— 搬个位置躲开地板。
算之前先把整个损失放大一大截,把那些快掉到地板底下的小数整体抬起来;
更新之前再缩回去。
⭐ 而 bf16 的地板远得根本够不着,所以它压根不需要这个动作。
⚠️ 它的代价在别处 —— 它粗。所以 bf16 怕的是『一点一点累加』,
不是『掉到零』。这跟我们第三节那条判据正好接上。」
⭐⭐ 第二个误解不用图,一分钟。它是 6.2 那个救火办法的前提 —— 缺了它,6.2 是悬空的。
「第二个:训练这种东西,是不是根本没法复现?
—— ⭐ 能复现,而且很值。有人做到了逐比特一致:
从任何一个存档点重启,后面每一步跟原来那次一模一样,一个比特都不差。」
「靠两件事。一个是计算框架本身是确定的;
⭐ 另一个更容易被忽略 —— 数据管线也得是确定的。
这里的窍门是:第几批数据,只由「现在是第几步」决定。
跟你用了多少张卡、中间重启过几次,通通无关。」
⭐⭐⭐ 然后把它接回 6.2 —— 这一句是这个误解值得讲的全部理由。
「❓ 为什么这个重要?
—— 回想我们前面那个救火办法:训崩了,回滚到上一个存档点,跳过那几批数据接着跑。
⭐⭐ 那个办法的前提就是它。
数据管线要是不确定的,你连『跳掉哪几批』都说不出口 ——
因为你根本不知道刚才喂进去的是哪几批。」
⭐ 然后是本节的落点,也是全节最该带走的一句。
🖥 屏幕:平移到 Ⓒ。
「不过这一节真正的难点不是「怎么让它稳」。
让它稳太容易了 —— 学习率设成零,保证不飞。
难的是:稳住,而且不掉质量。」
「有人把这件事量出来了,做法很干净:
同一个配置反复跑,记两栏 ——
一栏是「几次能跑完」,一栏是「跑完之后有多聪明」。」
⭐⭐ 结论只讲中间那一行 —— 它是这张表唯一要带走的。 ⛔ 别念三行数,念了台下一个都记不住,而且那些数不是这一格的内容。
「结果里最刺眼的是中间那一行:
有个办法每次都跑完了 —— 「稳定」那一栏看着完美无缺。
⛔ 可模型笨了一大截。
⭐ 换成我们前面那把尺就有体感了:它从「在六个词之间犹豫」,
退到了「在几十个词之间犹豫」。」
「⭐⭐ 所以这一行的价值就一句话:
「每次都没崩」这件事,本身不构成证据。」
⭐ 再补一层方法论 —— 它比结论值钱,而且一分钟讲得完。
「这篇论文还有一处值得学:他们是故意挑了一个容易崩的配置来做这个实验,
还特意换到更容易出事的数据上。
❓ 为什么要这么干?
—— ⭐ 因为研究一个罕见的故障,你得先把它变得不罕见。
小模型很少崩,大模型贵到跑不起几次,那你怎么研究?
⚠️ 这不是作弊,这是正确做法 ——
但读数的时候你得知道:那个崩溃概率是被人为调高过的。」
⭐ 最后给一句可迁移的 —— 这句话同时也是全讲四条判据里的最后一条, 所以说完不要停,直接往下接收尾。
「所以记住这条 ——
评价任何一个稳定性手段,都要同时看两栏:稳没稳,以及质量掉没掉。
只看前一栏的话,「把学习率设成零」是最优解。」
⭐⭐⭐ 然后是全讲真正的收尾。念完就停,别补话。 ⛔ 别再报数了 —— 这一格的全部作用就是让台下带走四句话, 中间那些分数和门槛都在课件里。
「今天报了很多数。但我真正想留下的不是那些数,是四条判据。」
「一,要不要用高精度,比的是两个东西 ——
「这一项每一步挪动的幅度」,对上「这个格式能分辨的最小格」。
⭐ 挪得比一格还小,就等于没挪。
滑动平均每步都在遗忘,挪得动;
主权重是跨十万步一点一点攒的,单步只挪千分之几,挪不动。」
「二,该不该重算,看「每省一个字节要付多少算力」。
线性层的这个代价是固定的,就是它的输入宽度;
attention 那边随序列越拉越贵。
⭐ 两条斜率不一样 —— 那就一定会相交。」
「三,两个量如果对同一个东西的增长速度不同,
而且长得快的那个起点更低,那它们的排序早晚会翻过来。
⛔ 那个「起点更低」不能省 —— 长得快的要是起点也高,
两条线永远不相交,排序从头到尾不变。
⭐ 所以任何「A 比 B 划算」的结论,都得带上它成立的那一段。
脱了那一段,排序就没意义了。
—— 这一讲里它翻转过好几次,而且每次翻的那个变量还都不一样。」
「四,就是我刚说完的那一条:评价任何一个让训练变稳的招, 都要同时看「稳没稳」和「质量掉没掉」。」
⭐⭐⭐ 停一拍,最后一句,然后就停。
「数字会过期,这四条不会。」
⛔ 不要在这里推 Pre-LN 那串公式。⭐ 2026-09-22 更新:这一条原来写的是 「整段跳过,时间够才补」—— 那是把全讲最好的一个转折给跳了 (「同一条曲线,预训练是毛病、微调是功能」)。 现在上面给了一分钟的不带公式的讲法,这一段要讲; 真正该跳的只有那串方差推导,它在课件 6.5。
⚠️ 「小模型上没出现过」这句不要滑过去。 它是这一节跟 2.6 那条判据的接点 —— 这一讲里「不能跨规模照抄」已经是第三次出现了。
⚠️ 这一节没有任何我们自己的实测,全部来自公开论文。 被追问的时候可以直说 —— 这是有意为之。
🖥 本节主屏:课件 第六节 训不崩 —— loss 飞了怎么办,以及怎么让它别飞 · 主图 fig-stability
🚧 这份讲义还薄的地方
⭐ 诚实记一下,免得下次开课时把它当成成品。
- [ ] 没真讲过,时间表全是估的。第一次讲完请按实际用时回来改那张表 —— ⛔ 过期的时间表比没有时间表更糟。
- [ ] 没有课前题、也没有课后题。 这一讲其实很适合在第二节末尾问一句:「如果序列长度砍到 4K, 刚才那张排序表会怎么变?」—— 答案就在那张图上,但要台下自己说出来。
- [x] 第三节是个危险的长度(计划 28 分钟)。
✅ 2026-09-20 处理:原来「折算系数」跟「为什么能下降 / 鞍点 / 动量」
挤在同一段里,一口气二十分钟不换气。已把折算系数整段挪到两张图之前,
单独立成第四段并在那里设了换气点 —— 顺带跟教材的 3.3 / 3.3b
对齐了(原来讲义先讲折算、教材先讲下降,两边顺序是反的)。
⛔ 但地板仍远超计划的 28′(见上面地板表,每次 build 现数)。换气点治的是节奏,不是时长 —— 这一节要么再扩,要么按 build 的超时提示砍。
⚠️ 2026-09-20 又往这一节加了 90 秒(batch 该开多大 —— 原来整格没有讲义,而它是现场点名要的)。加之前先定了砍的顺序, 时间不够就按这个次序丢:① PaLM 的 β₂ 猜想(本来就标着「时间够再说」) → ② Adam 命名那段掌故 → ③ Polyak 1964 那两句引文 → ④fig-adamtime只留 Ⓑ 一句(2026-11-08 加的两格,约一分半)。 ⛔fig-adamcalc不要砍 —— 「梯度恒为 2 走多远」是这一节最该带走的数。 ⛔ 不要砍 batch 那一格 —— 它是被点名要的。 - [ ] 「6ND 低估五六倍」那一条还没有第三方佐证。 它是从我们自己算的 82.1% 反推的。能找到一篇实测就该补上出处, 在那之前台上必须说清它是推的。
📌 想清楚一条就从这儿划掉一条,并把结论写进对应小节。 ⛔ 别在课件里回答这些 —— 课件只呈现结论。