课件停在首屏，先不往下滚。

先说这一课的方法，因为它跟大多数讲大模型的材料不太一样。

市面上的材料，绝大多数是在给你结论 —— 告诉你 MoE 省算力、 MLA 省显存、FlashAttention 更快。这些话都对，但它们是听来的。 听来的东西有个问题：换一个场景你就不知道它还成不成立。

这一课只做一件事：算账。

具体怎么算？拿 DeepSeek V3 这个真实的模型，让一个 token 从进去到出来走完全程。 它每经过一个部件，我们就当场问同样的四个问题 —— 这一步的权重有多大、产生的激活有多大、要做多少次乘法， 还有第四个，也是最重要的一个：有没有什么东西在这里爆炸。

你会发现，最后那个问题往往才是重点。

停一拍。下面这段是这一讲真正的内容。

但要算账，就得先有尺子。算账最容易出的问题不是算错，是中途换了尺子。 所以我们先把口径钉死，后面一路不改。

滚到「算账口径」那四张卡片。

五条。第一，序列长度取 128K，也就是十三万一千零七十二个 token —— 差不多是一本小书。第二，batch 等于一，先把单独一条算清楚，要乘再乘。 第三，精度按 bf16，每个数占两个字节。第四，只算前向，不算反向。 第五，参照物是一个 TPU v7 device 的九十四点七四个 GB —— 所有算出来的数，最后都要拿它去除一下，不然没有感觉。

这五条里，最需要解释的是第四条。为什么只算前向？

这里可以问一句「有人猜到为什么吗」，然后自己答。

因为前向的账是事实，反向的账掺着决策。

前向就是一步一步的矩阵乘，每一步多大是确定的，没得选。 但反向不一样 —— 你得先决定：算完的中间结果要不要留着、还是等用到时重算； 优化器状态放哪张卡；梯度要不要攒几步再更新一次。 这些都是策略，不同的人选不同，算出来的数就完全不一样。

把决策混进事实里，这笔账就说不清了。所以这一课只算 所有人都必须付的那部分。反向留到专题四单独讲，那时候我们已经会算账了， 再谈策略才谈得动。

如果台下有人显得不耐烦，直接跳到「先猜一个数」那块互动， 让他们先猜完再回来补口径。

好，尺子立完了。下面从第一步开始 —— 一个字，是怎么变成一串数的。

滚到「模型底牌」那三张表。

这张表有二十多行，但千万别逐行念 —— 念完人就走神了， 而且这些数一次也记不住。

整张表你只需要当场挑出四个数，其余的等用到再回头指。

下面四个数，边说边用鼠标在表上点出来。

第一个，hidden_size 等于 7168。 这是残差流的宽度 —— 也就是那条贯穿全程的主干道有多宽。 后面每一步算激活，都是拿 token 数乘以它。 如果台下只能记住一个数，就让他们记这个。

第二个，61 层。 这个数本身不稀奇。稀奇的是紧挨着它的那一行 —— first_k_dense_replace 等于 3。意思是前 3 层是普通的 MLP， 从第 4 层开始才是 MoE。所以准确说是「3 层 dense 加 58 层 MoE」。 这个 3 和 58，后面算参数量的时候要反复用。

第三个数其实是个 false。 tie_word_embeddings = false。 这个字段的意思是：进门那张查词表的大矩阵，和出门那张把向量变回词的大矩阵， 不共享权重，是两份独立的。 很多模型选择共享，省一份参数；V3 选择不共享，代价是多出九亿多个参数。

这里埋一个钩子，别答。

可以顺口问一句：「为什么有的模型共享，有的不共享？」—— 然后说「这个留到最后一步，我们走到出口的时候再说」。不要现在答。

第四个不是一个数，是一句话，而且是这一讲最重要的一句：

这张表里的每一个数，都来自 DeepSeek 官方公开的配置文件。 没有一个是估的，也没有一个是我们自己测的。 后面所有的推导，都从这张表出发。

这句话必须说，因为它决定了台下信不信你后面算出来的东西。 等到最后合账那一步，我们算出总参数六千七百一十亿、激活三百六十六亿 —— 刚好对上官方公布的口径，那一刻这句话就兑现了。

滚到「第 1 步 · 从文字到向量」—— 左边一块词表矩阵、右边一条残差流张量、 中间一根「查表」箭头的那张图。

先说清楚输入端到底发生了什么。一句话进来，先被切成 token。

token 不等于字，也不等于词。 中文常见字大多一个字一个 token， 英文一个长单词可能被拆成两三段。切完之后，每个 token 就是一个整数编号 —— 在 V3 上这个编号的范围是 0 到 129,279，因为词表是 129,280。

滚到「分词：129,280 是怎么来的」下面那张横轴图 —— 上面绿色一条、下面红色一条、中间一根轴，讲的就是词表大小的两头拉扯。 这张图对着讲，不要念文字。

台下第一个反应通常是「129,280 这个数是怎么来的」。 先给结论：它一点都不特别。 看这根轴 —— Llama 2 是 3.2 万，Llama 3 是 12.8 万，V3 是 12.9 万， Qwen3 15.2 万，gpt-oss 20 万，Gemma 2 是 25.6 万。 V3 和 Llama 3 几乎就是同一个点。

指绿色那条词表往大做，赚的是：同一句话切成更少的 token。 序列变短，后面注意力里那个平方项立刻跟着掉 —— 这条到第 2 步会兑现。

指红色那条赔的有三样：两张表变大、 罕见词分到的样本变少所以学不好、出口那层要在整张词表上算 softmax。

这里有一句要说准 —— 「两张表变大」这一条，在 V3 身上几乎不成立。 因为表的大小只跟「词表 × 宽度」有关，跟 61 层一点关系都没有， 所以模型越大这笔占比越小：两张表加起来只占 671 B 的 0.28%。 真正拉住词表不让它继续变大的，是另外两条。

停一下。下面这句是这一讲的第一个反直觉点。

从编号变成向量，用的不是乘法，是查表。

模型里存着一张 129,280 × 7,168 的大表。 你的 token 编号是多少，就直接把第几行抽出来。 没有矩阵乘，没有加法，就是按下标取一行。

这是整个模型里最朴素的一步，也是唯一一步几乎不消耗算力的。 但它一点都不便宜 —— 因为那张表本身， 129,280 乘 7,168 等于 9 亿 2668 万个参数， bf16 下占 1.73 GiB。

指着「残差流张量」那一行。

接下来是第二笔账。查完表，128K 个 token 每个都变成了一个 7,168 维的向量， 摞在一起就是一个 131,072 × 7,168 的张量。 bf16 两个字节，算下来 1.75 GiB。

这里把两笔加起来，慢一点说。

一张表 1.73，一个张量 1.75，加起来 3.48 GiB。 而我们还没有进第一层。

这句话是这一讲的落点。说完停两秒，让它落地。

指着页面上那条贯穿全文的主干道示意（残差流那张图）。

最后交代一件事，它决定了后面 61 层怎么理解。

刚才那个 1.75 GiB 的张量不是用完就扔的中间结果， 它就是残差流 —— 一条从第 1 层一直通到第 61 层的主干道。 每一层都从它上面读一次，算完再写回去一次。

所以 7,168 这个宽度不是某一层的内部尺寸，是全程的主干道宽度。 这也是为什么上一讲说「只记一个数就记它」 —— 后面每一步要算激活占多少显存，公式都是 token 数 × 7,168 × 字节数。

如果台下问「7,168 这个数怎么定的」， 展开那个「哪一半是硬约束」折叠块，对着里面讲。不问就别展开。

那一块要讲的就一句话：7,168 能被 128 整除，也能被 256 整除 —— TPU 上矩阵单元是 128 或 256 见方，NVIDIA 那边 FP16 要求维度对齐到 8、 A100 上对齐到 64。它两边都不用补齐。

但紧接着要补一句，这只解释了「为什么不会是 7,000 或 7,200」， 没有解释为什么不是 6,144 或 8,192 —— 那两个也一样整除。 宽还是深，DeepSeek 从没公开说过怎么定的。

滚到「先看死穴：KV cache 为什么会失控」。

先说清楚这东西为什么必须存在。生成文字是一个字一个字往外蹦的， 每蹦一个新字，模型都得回头看前面已有的所有字。

问题是，如果什么都不存，每蹦一个字，前面几万个字的中间结果就得从头重算一遍。 第二个字重算一遍，第三个字再重算一遍 —— 越往后越亏。

所以做法很自然：把前面每个字算出来的那份中间结果存下来，下次直接拿。 存的这两样东西叫 K 和 V，存它们的地方就叫 KV cache。 这一步本身没毛病，是标准操作，所有模型都这么干。

停。下面开始讲「麻烦出在哪」。

麻烦出在它有多大，而且这个账有两个方向同时在长。

第一个方向：序列越长存得越多。 聊了十万个字，就得存十万份。
第二个方向：模型有多少层，每层都得存自己那一份。 61 层就是 61 倍。

单看哪一个都不吓人。但它俩是相乘的关系。 一个东西同时按两个方向线性长，乘起来就是灾难。

指着那张对数阶梯图 —— 从左往右一根柱子一根柱子地走。

但「灾难」两个字太虚，我们把账一步一步堆出来。 先假设 V3 用的是最传统的注意力，也就是不做任何优化的版本。

第一根柱子：一个 token、一层。 要存 32,768 个数 —— K 和 V 两份、128 个头、每头 128 维，乘起来就是它。bf16 下 64 KiB。 微不足道。

第二根：乘 61 层。 一个 token 走完全程，3.81 MiB。 还是不痛不痒。

第三根：乘 131,072 个 token。 488 GiB。

说完这个数停两秒。这是这一讲的第一个爆点。

提醒台下看纵轴：这张图是对数刻度，每一格 10 倍 —— 必须这样，否则第一根柱子细到看不见。 从最左到最右跨了将近 800 万倍， 而中间只做了两件极普通的事：乘层数，乘 token 数。

指红色虚线，然后指下面那个红框里的数字。

把它换算成能感觉到的东西。TPU v7 一张卡的显存是 94.74 GB， 这堆东西要五张多卡才装得下。而且这是一个用户、一段对话。 你要同时服务一百个人，就得再乘一百。

更刺眼的说法是这一句，可以直接背下来：

照这个存法，一段 23,699 个 token 的对话，光缓存就吃满一整张卡 —— 模型权重还一个字节都没放进去。

滚到喇叭口那张图。

最后看它随长度怎么变。横轴是序列长度，纵轴是 KV cache，两条线 —— 红的是传统存法，蓝的是 MLA。

两条都是直线，因为都是线性的。但斜率差 57 倍， 于是它们从同一个原点出发，越走越张开。 中间那个红色的口子，就是换一种存法能省下来的。

这里有一句话值得说出口：它不是一个固定的数，是一个随长度张开的口子。 上下文越长，换存法的收益越大 —— 这就是为什么长上下文一出现， 所有人都在改注意力。

这一讲到此为止。不要往下说 MLA 怎么做的。

收尾一句就够：「到这儿，该怎么办已经不用我说了。」 停一下，让他们自己接。

滚到「三个旋钮，四代方案」。

上一讲停在「该怎么办已经不用我说了」。这一讲就把「怎么办」摊开 —— 但先说件让人安心的事：能改的地方一共就那么几个，数得过来。

把上一讲那个公式中间那一项拆开：每 token 每层存多少个数 = 2 × KV 头数 × 每头维度。 2 是 K 和 V 各一份，动不了。剩下两个，再加上层数，就是全部旋钮。

指那张三行的表，一行一行走。

① 存几份 —— KV 头数，V3 是 128。这是唯一被反复拧的那个，因为它最猛： 拧到 8 就是除以 16，拧到 1 就是除以 128。代价也最直白 —— 多个 Q 头被迫共用同一份 K 和 V，丢掉的表达力找不回来。

② 每份多宽 —— 每头维度，业界基本钉在 128 没人动。两个原因： 它决定单个头能装多少信息，砍窄了每个头都变笨； 而且 kernel 只对几个固定宽度优化过，你省了显存，但跑不快。

③ 存几层 —— 让相邻几层共用一份，或者只让部分层看全长。 这个旋钮跟前两个不是一回事：它改的是「存不存」，不是「存多少」， 所以它不在四代那张表里。台下要是问起，一句话带过就行。

停。三个旋钮说完了，再进四代。 滚到四代那张图，从左往右一块一块指。

四代的历史，其实就是第一个旋钮从 128 拧到 1 的历史。

MHA，2017，Transformer 原版，每个头一份 KV。质量最好，cache 最大。

MQA，2019，Shazeer 一篇很短的论文，标题就叫「一个写头就够了」。 所有头共用一份，直接除以头数。

这里有个细节值得说出来，因为它解释了后面这十年 —— Shazeer 当年要解决的不是「装不下」，是「搬不动」： 生成每个字都要把 K 和 V 从显存里重新读一遍，卡的是带宽。 「装不下」是后来长上下文时代才有的问题。

GQA，2023，Ainslie 他们。不共用一份、也不各存一份，分组共用， 是前两者之间的插值。它能成为业界默认还有一个很现实的原因： 论文给了一个配方，用原始预训练 5% 的算力，就能把已有的 MHA 模型改造成 GQA —— 不用从头训。

停一下。下面是这一讲的爆点。 指最右边那块蓝的。

现在看 MLA。它一个旋钮都没拧。

128 个头还是 128 个头，每头还是 128 维，61 层一层不少。 它换的是存什么 —— 不存展开后的 K 和 V，改存一个 512 维的压缩向量， 外加 64 维单独走的位置信息，一共 576 个数。

让他们回头看四代对照表里那一列数字。

576 卡在 GQA 的 2,048 和 MQA 的 256 中间 —— 但质量比两个都好。

这句话说完要停，让他们自己想一下哪里不对。 在同一根轴上，这是不可能的 —— 省得比 GQA 多、质量还比 GQA 好？没这种好事。 它做得到，正是因为它根本不在那根轴上。

停两秒。然后给落点。

所以这一讲真正的落点，不是那四个名字，是一句话：

前三代拿质量换显存，MLA 拿算力换显存。

前三代是把信息删掉，删掉的回不来。 MLA 是把信息压起来，要用的时候现场展开成 128 个头 —— 信息没丢，代价是每次用都要多算一遍。

这个形状，做过训练的人应该觉得眼熟：不存中间结果、要用时重算一遍， 那就是重计算。某种意义上，MLA 就是对 KV cache 做重计算。

指黄色那个提醒框。

最后必须补一句边界，这句不补会误导人，但补错了更误导人： 「MLA 省显存」是一句推理侧的话 —— 因为训练里根本没有 KV cache。 缓存是解码才有的东西：一次吐一个字，前面的 K/V 要留着给下一步复用。 训练整条序列一次前向，没有下一步要复用，无从缓存。

训练侧对应的是激活显存，而到了这个量级重计算是开到顶的 —— 一层只留层入口那条残差流，展开成 128 个头的 K/V 是重算出来、用完就扔的。 所以 MHA 和 MLA 存下来的是同一条残差流，这笔账上打平，不是 MLA 赢。

不要说成「MLA 对训练没用」，那是另一个方向的错。 它在训练侧吃得到的是两处，都留到专题四：重计算松一档时可以只存 512 维隐向量； 上下文并行传 K/V 时传的是隐向量，通信量按同一个倍数掉。

收尾直接抛给下一讲：「压成 512、再展开回 128 个头 —— 听着像变魔术。 下一讲就拆开看它到底怎么做到的，以及为什么位置信息那 64 维必须单独走一条路。」

滚到「MLA 到底怎么做的」。左边是文字，右边有张小图，两边对着讲。

上一讲说 MLA 换了根轴。这一讲就把那根轴具体是什么说清楚，一句话： 存的时候压，用的时候升。

具体做法是 —— 一个 token 的 KV 信息，不按 128 个头分别存， 先压成一个 512 维的隐向量存起来；真要算注意力了， 再用一个矩阵把它升回 128 个头。

这里要强调一下：这个「升」是每次用都要做一遍的。 这就是上一讲那句「拿算力换显存」的落地方式 —— 显存里躺着的是 512，算的时候现场变出 128 个头。

停。压缩这半讲完了。下面是这一讲更难的那一半。

为什么位置信息不能跟着一起压？ 这是整个 MLA 里最绕的一处。

指蓝色那个「先说清楚 RoPE 是什么」的框。

先花二十秒说清 RoPE 是什么，台下多半只是听过这个词。

注意力本身看不见顺序 —— 把句子里的词打乱，算出来一模一样。 所以必须额外告诉它谁在前、谁在后。

RoPE 的做法很巧：不给向量加任何东西，而是按位置把它转一个角度 —— 第 1 个 token 转 1 度，第 100 个转 100 度。 两个向量做点积的时候，结果自然就带上了它们的角度差，也就是相对距离。

这里补一句好记的：它没往向量里塞任何新数字，只是把向量转了个方向。

停一下。下面这段是全课最容易讲糊的地方，慢下来。

麻烦就出在这个「转」上：转多少度，取决于这个 token 排在第几位。

如果先转角度、再压进隐向量，那这个隐向量里就掺进了位置。 而这个旋转是夹在两个矩阵中间的 —— 矩阵乘法不满足交换律，夹在中间的东西挪不走。

下面这句必须说准，说错了台下懂行的人会当场纠正你：

坏掉的不是正确性。 那样做模型照样能训、照样能跑，答案也是对的。 坏掉的是推理时一个很值钱的省法 —— 代价是每生成一个字，都得把前面所有 token 的 K 重新算一遍。

具体是哪个省法，别在这儿讲，留到下一讲。 这里只要台下接受「位置一旦掺进去，后面有笔账会变得很贵」，就够了。

指右边那张小图上金色那条支路。

所以 V3 的做法是把每个头劈成两半，各管一件事： 128 维不带位置，负责内容，可以压； 64 维带位置，负责顺序，不压，直接存。

指「576 = 512 + 64」那个框。

576 = 512 + 64。这就是 MLA 每 token 每层存的全部东西。

停两秒。下面这句是这一讲真正的落点。

这个 576，跟头数没有关系。 128 个头是它，256 个头还是它 —— 头数从这笔账里彻底消失了。

这才是 MLA 和前三代最根本的区别： 前三代是在头数上做除法，MLA 直接把头数从公式里拿掉了。 做除法总有除尽的那一天，拿掉就没有这个上限。

收尾再占一个便宜：那 64 维是 128 个头共用同一份的。 要是每个头存一份，就得多存 128 × 64 = 8,192， cache 从 576 涨到 8,704 —— MLA 就白做了。

滚到「⭐ 一个容易想当然的地方：7,168 和 16,384」。

先做一件事：请台下当场做个心算 —— 7,168 除以 128 个头，等于多少。

等两秒，会有人说出 56。别急着否定，先说下面这句。

这个除法背后藏着两个误解，而第二个比第一个更要命。

第一个误解简单：56 不是 V3 的每头维度。 V3 每个头是 128 维，128 个头拼起来是 16,384，是残差流的 2.29 倍。

停。下面这段是整节的地基，讲慢一点。

第二个误解是：以为输入被切开了。 很多人脑子里的画面是 —— 7,168 维排成一排，咔咔咔切成 128 段， 每段 56 维，一个头分一段。

不是这样。输入从来没有被切开。

指图里左边那把扇子。

128 个头，每一个都读入完整的 7,168 维。 每个头有自己的一个投影矩阵，形状是「7,168 乘以它自己的输出维度」， 用这个矩阵把完整的 7,168 压到自己的工作空间里去。

所以在教科书那种取值下，每个头的矩阵是 7,168 × 56； 在 V3 上，每个头的矩阵是 7,168 × 128。 左边那个 7,168 是不变的 —— 每个头都要看全部。

那「切」在哪儿呢？切在输出侧。 128 个头各自输出一小段，拼起来才有那个总宽度。

所以那个除法真正在说的是：「128 个头拼起来，正好等于输入的宽度」 —— 它说的是拼接的结果，不是输入被分掉了。

这里可以停一下问：那这个「正好等于」是必须的吗？

看懂了上面这段，这个问题根本不用回答 —— 显然不必须。 既然每个头的矩阵是「7,168 乘以 d」，那个 d 从来就是自由的， 爱设多少设多少，128 个头拼出来是多宽就是多宽。

指上下两条的对比，尤其是每个格子里写的矩阵形状。

上面那条是教科书取值：每头 7,168 × 56，拼起来正好 7,168。
下面那条是 V3：每头 7,168 × 128，拼起来 16,384。 然后靠 o_proj 收回残差流。

两条的输入完全一样 —— 都是每个头读完整的 7,168。差别只在每个头输出多宽。

转折：那为什么八年来大家都选「正好等于」？

因为那是 2017 年那篇论文里的一个取值，然后被抄成了直觉。

原论文写多头注意力的时候，输出投影矩阵的形状定义是 「头数乘每头维度」乘「隐藏层宽度」 —— 从定义的第一天起，这两个数就允许不相等。

紧接着那句是：「在这项工作中，我们用 8 个头，每个头取 d_model 除以 h」。 「在这项工作中」——这六个字说明它是个选择。 论文还把理由写出来了：这样取值，总计算量才跟「单头、全宽度」差不多。 理由是算力预算，不是数学必要。

下一个问题才是重点：既然一直可以，为什么以前没人做？

因为把头做宽，是要付 KV cache 的钱的。

标准存法下，每个头的 K 和 V 都要各存一份 —— 头一宽，每一份就变大，cache 跟着线性涨。 宽 2.29 倍，cache 就涨 2.29 倍。

所以在老框架下，「注意力做多宽」和「缓存多贵」是同一个旋钮。 你想要表达力，就得掏显存。大多数人选择不掏。

指右边那条从实线变成打叉的链。

MLA 把这条链剪断了。 上一讲说过它只缓存那个压缩向量， cache 大小是「（压缩维度 + 位置那 64 维）乘层数」 —— 请注意这个式子里没有头数，也没有每头维度。

这不是我的推断，是论文里写的公式 —— V2 论文 Table 1 那一行写的是 (d_c + d_h^R) · l， 在 V3 上就是 (512 + 64) × 61。 （口头讲不用报字母，说「576 乘 61 层」就行。 但如果台下有人拿着论文对，你要知道那 64 是算在里面的 —— 只说「压缩维度乘层数」会漏掉它。）

于是一个旋钮变成了两个。表达力归表达力，缓存成本归缓存成本。 V3 做的事，就是把「表达力」那个旋钮往上拧了 2.29 倍。

旁证：MLA 第一次出现的上一代 V2，残差流只有 5,120， 注意力内部同样是 128 × 128 = 16,384 —— 3.2 倍，比 V3 还激进。 官方没明说这是刻意的因果，但两代都这么配，很难当成巧合。

最后是代价。这一段千万别省，省了这一讲就成了单方面吹。 滚到「代价：撑宽要付三笔钱」那张图。先别说话，让台下看那条红色的竖虚线。

这张图上所有的条，都是对着中间那条红虚线量的。 虚线是「如果不撑宽、老老实实等宽做」的成本，定义为 1.00 倍。 条比虚线长，就是多付了钱。

这句说完停一下。整张图的读法就是这一句，读法不立住，后面三笔都白讲。

撑宽账面上要多付三笔，而 V3 只真的付了两笔。

指第一根红条。

第一笔，算力，2.29 倍。 工作维度从 7,168 撑到 16,384，注意力的计算量跟着涨。 这笔跑不掉 —— 而原论文当年设成「正好等于」，图的正是省这笔钱。 V3 是明确地拿算力换了表达力。

指第二根红条 —— 长度跟第一根一模一样，这不是巧合。

第二笔，o_proj 的权重，也是 2.29 倍。 它要跨 16,384 到 7,168 这道口子，一头宽了 2.29 倍，矩阵就大 2.29 倍。 51.38 M 变成 117.44 M，占了一层 MLA 权重的 63%。这笔也跑不掉。

两根一样长，是因为它们涨的是同一件事：那个 16,384。

指第三根 —— 黄色、虚线边框、最长的那根。

第三笔本来最吓人。 128 个头，每个头一个 7,168 × 192 的 Q 投影，直接投是 176.16 M —— 3.43 倍，屏幕上这根条冲得最远。

但请注意它是虚线画的。虚线的意思是「本该这样，而 V3 没这么干」。

手往下移一格，指绿色那根短条。

V3 没有直接投。它先把 7,168 压到 1,536，再从 1,536 升到 128 个头 —— 中间掐了一个窄腰。两段加起来 48.76 M。

这个数字说完停一下，它有点反直觉。

0.95 倍。绿条比红虚线还短 —— 比等宽做法还小 5%。

也就是说：V3 把注意力撑宽了 2.29 倍， 而 Q 投影的参数量反而比不撑宽的做法还少一点。

屏幕上从那根 3.43 倍的虚线条掉到 0.95 倍的绿条，这一跌就是 q_lora_rank = 1536 那个字段干的事。 而且它顺便讲清楚了两个 LoRA 的分工完全不同：

kv_lora 那个 512，省的是 KV cache，因为存的就是它。
q_lora 这个 1536，省的是权重 —— Q 根本不进 cache， 它压缩纯粹是为了让「把头做宽」这件事在参数上付得起。

图最底下那行绿字写的就是这句话 —— 如果时间紧，把那行念出来也行。

滚到「⭐ 完整的 shape 变换链」那张大图。先别急着讲，让台下看五秒。

这张图有点吓人，但它其实只说了三件事。 最上面进来一个矩阵，最下面出去一个同样形状的矩阵， 中间它被拆成了 Q、K、V 三样东西。

我们一条一条走。每一个方块就是一次变换 —— 方块里三行分别是：做什么、权重多大、出来是什么形状。

先定住起点，这个必须说清楚，否则后面全是悬空的。

起点：一批 token 进来，比如 128K 个，每个 7,168 维。 所以是一个 128K 乘 7,168 的矩阵。 这就是上一讲说的残差流。

指 Q 路那一列，从上往下。

① Q 路：先压下去，再升回来

第一步，q_a_proj，把 7,168 压到 1,536。 这个矩阵是 7,168 乘 1,536。 压完出来的东西，就是 Q 的潜空间表示。

第二步是个归一化，形状不变，跳过不讲。

第三步，q_b_proj，把 1,536 升到 24,576。 然后把这 24,576 一 reshape，就是 128 个头，每个头 192 维。

这里停一下，把 192 这个数点破 —— 它是后面所有事情的钥匙。

为什么每个头是 192，不是 128？ 因为 192 等于 128 加 64。 前面 128 维是「内容」，后面 64 维是专门留给位置编码的。

所以第四步是把每个头的 192 维劈成两段： 前 128 维叫 q_nope，一动不动；后 64 维叫 q_pe，拿去转 RoPE。

转完再拼回去，还是 192。Q 就定型了。 128K，128 个头，每头 192 维。

补一句，这句话决定了台下会不会把 Q 和 KV 搞混。

注意：Q 这一整条路，一个字节都不进 KV cache。 它压缩到 1,536，省的是权重和训练时的激活值，不是缓存。 上一讲那笔账就是这么来的。

切到 KV 路那一大列。

② KV 路：只存 576，其余全是现算的

K 和 V 共用一次下投影。 一个 7,168 乘 576 的矩阵，一把把残差流压成 576。

然后当场切开：前 512 叫 c_KV，后 64 叫 k_pe。

指金色虚线框。这是全图最重要的一句话。

整个模型推理的时候，要存起来的就只有这两块。512 加 64，等于 576。 就这么多。

停两秒。让这句话落地。

下面所有的方块 —— K、V、拼出来的那些 —— 全部是用的时候现算的，一个都不存。

接着往下：c_KV 过一层归一化，然后 kv_b_proj 把 512 升到 32,768。 reshape 一下是 128 个头，每个头 256 维。

再劈一刀：前 128 是 K 的内容部分，后 128 直接就是 V。 V 到这儿就定型了 —— 128K，128 个头，每头 128 维。 V 全程不碰 RoPE，一次都不碰。

回到 k_pe 那一小列。

那条只有 64 维的小路呢？它去转 RoPE 了。 转完之后，同一份广播给全部 128 个头 —— 注意图上它的形状是「128K，1，64」，那个 1 是关键，它只有一个头。

然后跟每个头自己的 K 内容部分拼在一起，K 定型：128 个头，每头 192 维。 跟 Q 正好对齐，可以打分了。

现在进最难的一段。先抛问题，别直接讲答案。

③ 为什么 RoPE 非得单开一条 64 维的小路

问台下：位置编码为什么不直接作用在整个向量上？为什么要单切出 64 维？

等一等。这个问题多数人答不上来，但会好奇 —— 这正是我们要的状态。

因为如果不这么做，前面省下来的 cache 会当场还回去。

推理的时候本来有一个很漂亮的省法： 把「K 的升维矩阵」提前乘进「Q 的矩阵」里，合成一个。 这样连 K 都不用算出来，直接拿 Q 去和缓存里那个 512 维打分就行。

但 RoPE 是一个跟位置有关的旋转 —— 它会夹在这两个矩阵中间。

矩阵乘法不能交换顺序，夹在中间的东西挪不走，这个合并就做不成了。

后果很具体：每生成一个字，都得把前面所有 token 的 K 重新算一遍。 省下来的显存，变成了重复计算。

指那个「转 / 不转」的小表。

所以他们做了一件很干脆的事：把位置信息隔离到一条小路上。

每个头的向量劈成两半，各管一件事。 前 128 维不转，负责内容，也负责保住「矩阵能合并」这个性质； 后 64 维转，位置信息全塞在这里面。

为什么能这么拆？因为点积天然可加。 两个拼起来的向量做点积，等于前半段的点积加上后半段的点积。

所以拼成 192 维算一次，其实就是「内容相似度」和「位置相关性」分别算完再相加 —— 互不干扰，各自那一半的数学性质都保住了。

最后一击：代价有多小。这句说完这一讲就到顶了。

这条位置小路只有 64 维，而且 128 个头共用同一份。

也就是说：多存 64 个数，换回「K 永远不用重算」。 576 里面那个 64，全部来历就是这个。

反过来算一下就知道有多划算：如果这条路不共享、每个头一份， 就要多存 128 乘 64，等于 8,192。 cache 从 576 直接涨到 8,704 —— MLA 就白做了。

下面有个收起的块，标题就是「那个自然的追问 —— Q 那 64 维为什么不也共用一份」。 不用点开，口头讲；真被追到细节了再展开。

这里台下十有八九会追一句：位置是 token 的属性、跟哪个头无关， 那 Q 那 64 维为什么不也共用一份？

因为它不是纯位置 —— 它是先从内容投出一个向量，再去转。 角度每个头一样，被转的东西每个头不一样。 于是每个头拿到一条不同的「距离 → 分数」曲线，共用就全绑死成同一条了。

但真正拍板的是账：Q 不进 cache，共用省不到东西，没理由做； K 进 cache，共用能把 8,192 压成 64，那笔损失才值得认。 这个不对称不是数学要求的，是成本决定的 —— 哪一侧花钱，哪一侧才做妥协。

指图最下面那一排。

最后收尾：Q 和 K 打分，除以根号 192，softmax，乘上 V， 128 个头拼成 16,384，o_proj 收回 7,168。 回到残差流，交给 MoE。

顺带看一眼那个红框 —— 打分矩阵是 128 个头乘以序列长度的平方。 它不进 cache，但它要占显存，而且是平方地占。 这就是下一讲要炸的第二个点。

滚到「⭐ 凭什么能压这么狠」，先停在标题上。

前面我们算出来 MLA 省了 56.9 倍。这个数听起来像魔术。 而魔术总有障眼法。

这一节我把它拆开。拆完你会发现，其中一大半根本不是压缩。

指两刀那张图。

第一刀：那 32,768 里只有 7,168 个自由度

标准做法每个 token 每层要存 32,768 个数。 128 个头，每个头 K 和 V 各 128 维，乘起来就是这个数。

这里问一句，让台下自己想三秒。

我问一个问题：这 32,768 个数，是从哪儿来的？

全都是那 7,168 维的输入乘出来的。 K 是一个 7,168 乘 16,384 的矩阵作用在输入上，V 也一样。

而一个 7,168 乘 16,384 的矩阵，秩最多只能是 7,168。

停。下面这句是这一节的核心，讲慢。

意思是：那个 32,768 维的向量，永远只在一个不超过 7,168 维的子空间里打转。

所以你只要把输入本身那 7,168 个数存下来，就能把 K 和 V 一个 bit 不差地还原出来。

这一步是可以证明的，不是我在感觉。 标准存法里有 4.57 倍是纯冗余 —— 砍掉它不叫压缩，叫别犯傻。

马上会有人问：那为什么以前没人这么干？先自问自答，别等他问。

那为什么八年来没人只存输入呢？因为要重算。 只存输入的话，每生成一个字，都得把前面所有 token 的 K 和 V 重新乘一遍。 省了显存，赔了算力。

MLA 真正的贡献，是让这个「重算」几乎不用真的发生 —— 就是上一讲说的矩阵吸收。 于是这 4.57 倍才第一次变成可以拿走的。

指第二刀。

第二刀：把「秩」限制到 576

剩下的 7,168 到 576，是 12.44 倍。这一刀是真的，是有损的。 但它压的不是数，是秩。

切到信息总线那张图。

你可以把那个 512 想成一条信息总线。 128 个头都挂在这条总线上取数据。

每个头用自己的矩阵去取，取出来的东西各不相同 —— 头之间的差异性一点没丢。 但是，总线上没有的东西，谁也拿不到。

所以 MLA 押的赌注可以写成一句话： 128 个头真正需要的信息通道，加起来不超过 512 种。

指那条金色虚线。

顺便解决一个上一讲留下的疑问：那 64 维的位置小路，为什么不在总线里。 图上那条虚线画得很清楚 —— 它是从输入直接旁路出去的，根本不经过总线。 因为位置信息一旦被压进这条共享总线，矩阵吸收就做不成了。

现在进最重要的一段。这一段决定台下觉得你可不可信。

论文凭什么这么说 —— 它没说

我得把话说清楚：上面那套「两刀」和「总线」的解释，是我推的，论文里没有。

DeepSeek 的论文在这一节从头到尾没有给任何理论证明。 没有秩分析，没有信息论论证，就是一句「我们这么做」。

这句话说完要停一下。诚实本身是有分量的。

但它给了硬碰硬的消融实验，在附录 D。那份数据才是真正的答案。

指绿框「⭐ 论文凭什么这么说」。课上只讲这个绿框， 下面那个「展开：那两张消融表的完整数据」不要点开。

大号 MoE，2,500 亿参数，同样的架构，只换注意力机制。 用标准注意力的，每个 token 缓存 86 万个数。用 MLA 的，3 万 4 千 6 百个 —— 是它的百分之四。

而质量，BBH、MMLU、C-Eval、CMMLU，四项全赢。

停一下。这一句是整个第 2 步的地基，不要赶。

而且它打败的不是软柿子 —— 它越过的是「不省 cache、质量最好」的那个基线。

如果台下有人露出不信的表情，这时候才点开那个展开块， 对着里面的四列表讲下面三句。

四项的具体分数：BBH 46.6 到 50.7，MMLU 57.5 到 59.0， C-Eval 57.9 到 59.2，CMMLU 60.7 到 62.5。

小号那组三胜一负 —— C-Eval 从 51.6 掉到 50.9。 这一格要老实指出来，不要跳过。展开块里那一格是红的，本来就是给这一刻准备的。

同一篇论文还先做了另一组对照：标准注意力、GQA、MQA 三选一。 MMLU 上，标准注意力 45.2，GQA 41.2，MQA 37.9。 传统那些省 cache 的办法，是真的会掉质量的。

最后一个问题，也是最难受的一个。

压了 57 倍，质量为什么反而更好

论文没有解释。下面两条是我的推测，请当推测听。

推测一：低秩瓶颈本身可能是一种正则化。 强迫所有头把信息挤过一个窄口，反而逼出更干净的表示。 但这里没有对照实验支持，我只能说「可能」。

推测二，我觉得更可能：省下的预算被花在了别处。 MLA 省出来的 cache，让他们敢把注意力内部撑到 16,384，是残差流的 2.29 倍。

所以真实的对比，可能不是「压缩 vs 不压缩」， 而是「窄瓶颈加超宽头」对「无瓶颈加常规头」。

收尾。把 512 这个数字的三重身份点出来。

最后收一句。512 这个数字不是随便定的，它同时决定三件事，而且是同一个旋钮。

一，cache 多大 —— 存的就是它。 二，模型能表达多少 —— 秩上限就是它。 三，「不用真算 K」那个优化划不划算 —— 总线越窄，合并出来的矩阵越小。

而 RoPE 那 64 维之所以必须待在总线外面，正是为了保住第三条。 一个数字，三件事，全都锁在一起。

滚到「⭐ Q、K、V 都到手了：这一仗到底怎么打」，停在那张五步图上。

先给个直觉，不要一上来就讲矩阵。

你读一句话，读到第五个字。你要理解它，得回头看看前面那四个字， 而且得判断哪几个字更重要。 打分做的就是这件事。

区别只有一个：模型有 128 个头，等于有 128 套不同的判断标准，同时在看。

这个比喻讲完停一秒，让它落地，再进流程。

① 点积：谁该看谁

拿当前位置的 Q，去跟每一个位置的 K 做点积。 方向接近，点积就大，意思是「这个位置我该多看一眼」； 不相干，甚至相反，就是小的或者负的。

每个头独立做一遍。所以这一步的产出是 128 张方阵，每张 13 万乘 13 万。

② 除以根号 192：不是玄学

192 个维度累加，点积的数值会跟着维度一起长大。

直接送进 softmax 会饱和 —— 几乎全部权重压给一个位置，其他的被压成 0，梯度也跟着没了。 除以根号 d，就是把幅度拉回能用的区间。

下面有个收起的块「关于『除以 √192』的两个细节」。 正常讲的时候跳过它；有人较真常数，当场展开，里面有代码和算式。

这里有两件事值得说准，但都不必展开。 第一，原始论文这一段的原话是「我们怀疑」，不是「我们证明」—— 它给的是直觉论证，不是定理。 第二，V3 代码里这个系数其实不等于 1 除以根号 192。 因为开了长上下文外推，它还要再乘一个系数，真实值是 0.1352 不是 0.0722。 原理一模一样，只是常数被外推方案改过。

③ 遮住未来：这是正确性，不是优化

第五个位置不许看第六个。 做法是把方阵的上三角全部设成负无穷，softmax 之后自然就是 0。

这句要重一点。台下经常把它当成一个工程细节。

这一步不是为了省什么，是为了对。 不遮的话，模型训练的时候就是在抄答案 —— 曲线会很漂亮， 但推理时后面的字还不存在，立刻垮掉。

④ softmax：把分数变成「取多少」

指图下半部分那张 8 乘 8 的缩略方阵，再指右边那几根柱子。

按行做归一化。做完之后，每一行加起来正好是 1。

这一行就是一个概率分布。 翻译成人话：「我这个位置的信息，百分之二十九从第一个位置取， 百分之四十七从第五个位置取。」

顺带把上一讲那个悬念收掉：为什么 128 个头到这里就合并不回去了。 因为 softmax 是逐行、逐头做的非线性运算。 非线性的东西，没法折叠回一个矩阵乘。

⑤⑥ 加权求和，然后拼起来出去

拿这套权重去对 V 加权求和，每个头吐出一个 128 维的向量。

128 个头拼成 16,384 维，过一次 o_proj 压回 7,168，汇回残差流。

最后这句是这一讲的收尾，说完停两秒。

o_proj 是一层里最大的一块矩阵，一亿一千七百万参数，占了 MLA 一层的六成。 而它之所以那么大、那么重要，是因为它是 128 个头之间唯一交换信息的地方。 在那之前，它们各算各的，谁也不看谁。

指那个「不是一类东西」的橙框。

这里插一句，它会在后面反复用到：这一段跟它前后的计算，根本不是一类东西。 投影是又大又规整的矩阵乘，形状固定，加速器最喜欢。 打分是 128 个小矩阵乘批在一起，中间还夹着一个逐行归约。

而且它跟序列长度是平方关系。序列翻倍，这一段翻四倍。 后面那个把人吓一跳的数，就是从这儿长出来的。

收尾：把一层 MLA 的权重账摆齐

往下滚一屏，停在「五个投影矩阵，一层多大」那张横条图。 不要念数字，先让台下看条长。

MLA 讲了这么久，其实一层只有五块权重。屏幕上就这五根条。

停两秒，让最上面那根蓝的自己说话。

最上面那根，o_proj，一根顶下面四根加起来还多 —— 六成三。 这跟刚才那句「它是 128 个头唯一交换信息的地方」是同一件事的两面： 它要一头连着 16,384、一头连着 7,168，两头都宽，所以它最大。

手指移到最底下那根黄色的短条 —— 短到几乎看不见。

而最下面这根，kv_a_proj，只有 4.13 M，两个百分点。 最大的那根和它差 28 倍。

下面这句是这张图存在的全部理由，说慢一点。

可是整个 KV cache 的账，从头到尾只由这根最短的条决定。 因为存进 cache 的就是它写出来的那 576 个数，别的四块一个字节都不进 cache。

权重最大的那块跟显存账没关系，权重最小的那块决定了整张显存账 —— 这两件事在这张图上是一眼能看出来的，用讲的讲不出来。

五块加起来 187 M，乘 61 层，11.41 B。 六千七百亿参数的模型，注意力全部加起来只占这么多 —— 约 1.7%。 剩下的都在 MLP 和 MoE 里，那是第 3、第 4 步的事。

滚到 KV cache 那张四方案对比图，红色虚线要在屏幕里。

第 2 步讲完了。我用三个数收个尾，一个比一个大。

爆点一 · 57 倍

同样 128K 上下文、batch 1、bf16。标准 MHA 的 KV cache 是 488 GiB， MLA 是 8.58 GiB。 差 56.9 倍。

手指红色虚线。

这条红线是一张 TPU v7 device 的 94.74 GB。 MHA 那根柱子要五张多卡才放得下 —— 而模型权重还一个字节都没算进去。 MLA 那根，一张卡还剩九成。

这里停一下。这是台下第一次直观看到「装不下」长什么样。

爆点二 · 4 TiB

滚到「真正的爆点」那一节，红色小方块阵列。

上面那个是存下来的。还有一个东西比它吓人得多， 但它从来不出现在任何显存报表里，因为它压根就没被存过。

注意力要给每个 token 对每个 token 打分。这是一个 13 万乘 13 万的方阵， 而且每个头一份，128 份。

算出来是 4.00 TiB。一层，一次。

让这个数停两秒，然后再给对照。

给两个对照，让它落地。 第一，整个模型的权重是 1.22 TiB —— 这张一层一次的中间矩阵，是全部权重的三倍多。 第二，按一张卡 94.74 GB 算，它等于 47 张卡。

指那片红方块。「屏幕上这一片，每一格是一张卡。」

所以 FlashAttention 不是一个「让它更快」的优化。 它是让这件事根本能做的前提。 做法就一句话：永远不把这张矩阵整个物化出来，分块算、边算边累加、算完就扔。

爆点三 · 81.8%，拖滑块

滚到那条曲线，手放在顶上的序列长度滑块上。

第三个数不用我说，我拖给你们看。

注意力里有两处的计算量是序列长度的平方 —— 打分和加权求和。 其他所有部分，投影、MLP、MoE，全都只是线性的。

滑块拖到 4K，停。再一档一档往右推，边推边念数。

4K 的时候，平方项只占 12.3% 的前向算力。这时候没人会觉得注意力是问题。

32K，52.9%，过半了。 128K，81.8%。 推到 1M —— 97.3%。

拖到头之后手离开滑块，停三秒再说下一句。这是全课最强的一个瞬间。

请注意：模型一个字都没有改。 参数量、层数、专家数，全都一样。 变的只是输入有多长，而瓶颈整个换了地方。

在这个规模上，「模型有多少参数」已经不是算力的主要矛盾了 —— 序列有多长才是。

切到最后那个绿框，然后过第 3 步。

这条曲线一被算出来，接下来该干什么就很明显了： 如果注意力吃掉九成算力，那就别让每个 query 都去看全部 token。

怎么不看、少看哪些、赔掉什么，那是专题三整整一课的事。 这一课只负责把「为什么非改不可」算出来 —— 就是屏幕上这条线。

滚到第 3 步开头，SwiGLU 那张三矩阵图要完整在屏幕里。

第 3 步，Dense MLP。这一节看着最简单，但它是后面整个 MoE 的对照组， 请大家跟着我把它记住。

结构：两个撑宽，一个压回

一个 7,168 维的向量进来，被撑宽到 18,432，再压回 7,168。 就这么一件事。

指三根灰色的张量条。「这三根条的高度是按真实宽度画的。」

撑宽这一步做了两份 —— 这是唯一需要解释的地方。 上面那条过一个 SiLU，变成阀门；下面那条原样不动，是水流。 两者逐元素相乘，然后压回去。

这就是 SwiGLU。三个矩阵，每个 7,168 乘 18,432。 一层 396 M 参数，三层加起来 1.19 B。

这里会有人举手。这个问题几乎每次都来，而且问得对。

那个必来的问题：为什么要三个矩阵

如果没人问，我自己问：经典 MLP 明明只有两个 —— 撑宽、过非线性、压回。 第三个矩阵图什么？

图的是让那个非线性变成活的。

经典写法里，非线性是死的。 不管什么输入、哪个通道，都按同一个规则压一遍，这个规则写死在函数里， 训练也改不了它。

SwiGLU 把「哪些通道该放行、放多少」变成了学出来的、而且跟着输入变的东西。 同一个通道，这个 token 来的时候阀门全开，下一个 token 来可能就关掉了。

下面这句是本讲最容易讲偏的一句，先停一下再说。

真正买到表达力的不是 SiLU，是那个乘号。

滚到那张八根条的消融图。先别念数字，让台下看它分成了哪两堆。

一张图把这件事钉死

这是提出 SwiGLU 那篇论文里的原始实验。八个写法，参数量和算力全部对齐， 训一样多的步数，比 perplexity —— 条越长越好。

先指上面那两根红的。

上面这一组是「只换激活函数、还是两个矩阵」。GELU、Swish。 两根都在基线左边 —— 也就是说，比原来的 ReLU 还差一点。

手往下移到那五根蓝的和黄的。

下面这一组是「加一个乘号、变成三个矩阵」。五个变体，全都赢。

这里停一下，让对比自己说话。

两组之间的差距，比组内任何两个的差距都大。 所以分界线在哪很清楚：在有没有那个乘号，不在用了哪个激活函数。

手指黄色那根，Bilinear。这根是整张图的题眼。

最能说明问题的是这一根 —— Bilinear。它两条路都不过任何激活函数， 就是两个线性变换直接相乘。 结果它照样赢过上面那两个「精心挑过激活函数」的写法。

连激活函数都不要，光靠一个乘号，就赢了。

顺手指最下面那根 GEGLU。这一句能防住一个常见误解。

还有一件值得说的：SwiGLU 1.636，GEGLU 1.633，基本打平， GEGLU 甚至还略好一点点。 所以 V3 选 SwiGLU，不是因为它是最好的那个。 这一组里挑哪个都差不多 —— 重要的是进了这一组。

指下面那个黄框。这一句一定要讲，它是本课诚实标准的一个样板。

最后必须补一句：这篇论文的作者自己说，他解释不了为什么门控管用。 原话是「我们不提供任何解释，我们把它的成功归于老天赏饭」。

所以刚才那句「乘法带来交互」是一个说得通的直觉，不是被证明的因果。 这张表能撑住的只有一件事：门控这一组确实赢，而且赢的不是激活函数。

而且它并不更贵

滚到下面那张三行的图，红色的「参数持平线」要在屏幕里。

这是最容易被漏掉的一点。多一个矩阵，听起来像多 50% 的参数，其实没有。

从上往下指三行。

第一行，经典写法，两个矩阵，惯例撑到 4 倍也就是 28,672 —— 411 M。

第二行，论文给的规则：三矩阵写法把中间宽度乘三分之二。 这样一来三个格子的总长，跟上面两个格子一样长 —— 还是 411 M。 参数和算力完全持平，这是那篇论文里写死的一条规则，不是我们凑的。

第三行是 V3 实际的：18,432，比规则再低一点，396 M。

这句说慢一点。

多了一个矩阵，参数反而少了 3.57%。门控那点表达力，在参数账上是白送的。

如果台下有人问「所以 18,432 就是这么反推出来的？」—— 这句要小心，见下面 Q&A 那条。

能说的是：18,432 落在那条规则附近，而且比它还省。 不能说的是「所以他们是照着这条规则定的」—— 论文没写。 而且今天多数模型其实没在守这条规则：Llama 3 和 Mistral 是 3.5 倍， Gemma 2 干脆 4 倍，都比规则宽得多。反倒是 V3 最接近原始规则。

四条好性质 —— 这一讲真正要留下的东西

滚到右边那张四条性质的表，一条一条指。

下面这四条，请大家记一下。三分钟之后我讲 MoE 的时候，会一条一条把它们拿走。

第一，每个 token 走完全相同的一条路。 形状是静态的、可预测的，编译期就知道。

第二，它就是一个大矩阵乘。 算力利用率天然就高，这是 MXU 最喜欢的形状。

第三，不需要任何通信来决定谁算什么。 没有调度，没有商量。

第四，编译器能提前把一切排好，运行时没有不确定性。

停一下，然后把这一讲的落点说出来。

这四条，MoE 一条都没有。

所以千万别把 MoE 理解成白捡的便宜。 MoE 确实省算力，省得很多 —— 但省下来的那部分，就是拿这四条换的。 下一讲讲的每一个麻烦，都能对回这里的某一条。

滚到最后那张三个方框的图。这是本讲的收尾，也是一个方法示范。

最后一个必来的问题：为什么偏偏是前三层

这个问题有一个流传很广的答案，我先说出来，然后告诉大家它为什么不能当答案讲。

那个流行说法是：靠近输入的层做的是通用活儿，基本的词法、局部句法， 每个 token 都要用，没什么可分工的。

停一下，让这个说法在空气里待两秒 —— 因为它听起来太顺了。

这个说法听起来非常合理。问题是，它不是 DeepSeek 给的理由。

从左往右指三个框。

去翻论文会看到一条链。最早提出这个做法的是 DeepSeekMoE，2024 年初。 它保留第一层 dense，而且给了理由 —— 原话是：他们观察到第一层的负载均衡收敛得特别慢。

这是一个训练稳定性的理由，跟「通用还是专用」一点关系都没有。

接下来 V2，同样保留第一层，但它只写了四个字：「沿用上一篇」。

再到 V3，改成前三层 —— 而这一次，论文只陈述了事实，没有给任何理由。 为什么从 1 变成 3，公开资料里查不到。

这里停两秒。下面这句是这一讲真正想留下的东西之一。

所以正确的讲法是：能说的是「最初的公开理由是训练稳定性」， 不能说的是「V3 选 3 层是因为前三层最通用」。 后面这句是我们的猜测，论文里没有任何依据。

把「负载均衡收敛慢」讲成「前几层比较通用」，是把一个训练现象换成了一个语义故事。 两者都可能对，但只有前者是能查证的。

指图最下面那行蓝字，一句话带过就走。

顺带一个小彩蛋：V3 的部署方案里，浅层这几个 dense MLP 是单独按 1-way 张量并行摆的，为的就是省掉那部分通信。 这反过来印证了刚才那四条好性质 —— dense 的好，是能在部署上兑现成真钱的。

滚到第 4 步开头，dense 和 MoE 并排那张图。

MoE 只有一个核心思想，我先把它说完，剩下的都是它的推论。

核心：把参数量和计算量解耦

刚才那三层 dense，每个 token 都要把整层的权重完整过一遍。 参数越多，每个字就越贵 —— 这两件事是死死绑在一起的。

MoE 就是想把这个绑定拆开。

做法是把一个宽 MLP 拆成很多个窄的。V3 是 256 个路由专家，加 1 个共享专家。 每个专家还是刚才那套三矩阵 SwiGLU，只是中间宽度从 18,432 缩到 2,048。

指那张「一个 token 的路径是它自己的」的图。

每个 token 进来，一个门控网络只挑 8 个路由专家给它， 再加上那个所有 token 都要过的共享专家，一共 9 个。 剩下 248 个，这个 token 碰都不碰。

下面这段是整讲的高点，慢下来。

⭐ 那个恰好相等

滚到那张九段拼一根的图，让两条红色虚线在屏幕里。

现在算笔账。一层里 257 个专家，参数是 11.32 B。 但每个 token 只激活 9 个 —— 折算下来是 396,361,728 个参数。

这个数，我上一讲讲 dense 的时候说过一模一样的。

停两秒。让台下自己反应过来。

不是接近，是完全相等。因为 9 乘以 2,048，正好等于 18,432。

指图上那两条红色虚线，从左端划到右端。

屏幕上这张图，九段拼起来跟上面那根 dense 条一样长。 不是画得像，是相等。

所以这句话可以说得很硬：MoE 那一层，每个 token 在专家上做的计算， 跟一层普通 dense MLP 严格相等。 但那一层里躺着的参数，是 dense 的 28.6 倍。

下面这句半秒钟带过，但要说 —— 它是这门课的信誉。

严格说还多一点点：MoE 得先跑一遍门控矩阵，7,168 乘 256， 相对那 396 M 是千分之五。 所以准确的说法是「专家那部分一个都不多，外加千分之五的分诊费」。

这就是落点。说完停一下再往下走。

这就是「参数量和计算量解耦」这句话的字面意思。 模型可以一直变大，而每个字的账单不动。

放到整个模型上

61 层里有 58 层是 MoE，权重加起来 656 B，占了 671 B 的九成八。

而每个 token 只真的用到其中 3.5%。 「671B 的模型，每个字只算 37B」——这句话的全部来源就在这儿。

切到那个「细粒度」的三张卡片。

顺带说一句为什么专家要做小做多。 同样的激活预算，8 个大专家里选 1 个，只有 8 种可能； 256 个小专家里选 8 个，组合数是十的十四次方量级。 专家越小越多，能表达的分工组合就越多。这是细粒度 MoE 的全部道理。

必须当场纠正的一条

语气换一下，这是一个纠正，不是一个补充。

最后一条，很重要，我需要当场纠正一下大家脑子里刚刚长出来的东西。

「专家」不是那种专家。

听到 expert 这个词，多数人想到的是医生、律师、翻译 —— 觉得是按领域分工的，这个专家管代码，那个管中文。 不是。

它们就是训练出来的 256 个窄网络，编号 0 到 255，没有任何人类可读的含义。

这里别停在「我说不是」，直接把证据摆出来。这一段以前是空口说的，现在有数了。 滚到那张红绿两半的图。先只讲左边那半。

这件事有人真的量过。做 Mixtral 那篇论文，专门拆开数了路由。

他们把不同领域的文本喂进去 —— 数学论文、生物摘要、哲学论文 —— 然后看每个领域各自把 token 送给了哪些专家。 如果真按学科分工，这三条分布应该长得很不一样。

结果三条分布几乎重合。 论文原话是「我们没有观察到专家分配跟主题之间有任何明显的规律」， 而且前面还加了一个词：surprisingly。 写论文的人自己也觉得意外。

手移到右边那半，指那三根绿条。

那它到底跟着什么走？他们换了个问法：相邻两个 token， 会不会被送到同一个专家？

八个专家随机选，这个比例应该是八分之一，12.5%。 第 0 层量出来 14.1%，基本就是随机。 但到了中间层，26.4% —— 是随机的两倍还多。

所以它跟的是局部结构，不是学科。 论文举的例子很具体：Python 里的 self、英文里的 Question， 总是走同一个专家；代码的缩进 token「总是」被分给同一批。

下面这句是这一段真正要留下的东西。

而这件事马上就是一个系统问题 —— 这才是我们关心它的原因。

局部性高，意味着做专家并行的时候更容易把某几个专家挤爆。 但反过来，局部性也意味着可以做缓存。 同一个性质，既是负载均衡的敌人，又是缓存的朋友。

指图下面那行适用范围，一句话带过。

要交代一句范围：Mixtral 是 8 专家 top-2，V3 是 256 专家 top-8， 这两组数不能直接换算。 它能证明的是那个否定结论 ——「按学科分工」这个直觉在实测里没出现。 V3 那 256 个到底怎么分，我没有查到同等力度的公开分析。

用分诊台那个比喻收尾，然后过 4b。

比喻是分诊台：它不懂医，它只是学会了「这种症状归那扇门」。 门后面具体是什么，它不关心，我们也不需要知道。

为什么要专门纠正这一条 —— 因为如果你以为专家是按领域分的， 那接下来讲的负载不均、辅助损失、分组限制，全都会显得莫名其妙。 「不就按领域派活吗，能有什么难的」。 难就难在没有领域这回事。

滚到 4b，路由数据流那张图，整张要在屏幕里。

门控网络长什么样，先给个数，可能跟你们想的不一样。

它是这一层里最小的东西

它就是一个矩阵，7,168 乘 256。参数量 184 万。

而它所在的那一层有 11.32 B 参数 —— 它占万分之一点六。

这句停一下，它是个很好的反差。

整个 MoE 最麻烦的东西，是这一层里最小的东西。

手指黄色那个 sigmoid 框。

打分这一步有个细节跟直觉不一样：用的是 sigmoid，不是 softmax。 softmax 是让 256 个分数加起来等于 1，专家之间互相抢。 sigmoid 是每个专家独立给一个 0 到 1 的分，谁也不影响谁。

真正的难点：负载均衡

门控是学出来的，它会自己形成偏好。 某几个专家早期表现好，就会被越挑越多，然后训练得更好，然后被挑得更多。 赢家通吃。

最后可能两百多个专家基本闲着，算力全堆在几个上面。

滚到那张四根条的图 —— 上下两半，上面红下面绿。

先看这件事到底有多贵，不然后面那套机制看起来会像小题大做。

专家是摊在不同卡上的。上面这半张图，四张卡分到的 token 是 40、20、25、15。 斜线那些格子是在干等。

这一层什么时候结束？等最慢那张卡。 于是买的四张卡里，有 37.5% 的算力是花了钱没用上的。

下面这句是这一段真正的分量。

而且它每一层都重来一次。58 层，每层都要等齐。

所以这不是「效率损失几个百分点」，是一个木桶问题 —— 整个集群按最慢那张卡的速度走。

（那四个数字是编的，只是为了让「谁在等」看得见。 真实失衡程度取决于数据和路由，不是一个固定的数 —— 台上要说这一句。）

老办法是在损失函数里加一项「分得匀不匀」的惩罚。 问题是你在让模型同时优化两件不相干的事 —— 答得对，和分得匀。 这两个目标会互相拉扯，最后两头都打折。

指左边那个蓝色的「偏置 b」小框，再顺着蓝箭头走一遍。

V3 的做法是给每个专家挂一个偏置。 谁最近吃太饱，就把它的偏置往下调，让它在竞争里稍微吃亏； 谁一直没人选，就调高。

而且它不是梯度学出来的，是按实际负载直接调的 —— 完全不进主目标的损失函数。

下面这段是副落点，慢下来，让图自己说话。

⭐ 偏置只挑不算

手沿着红色虚线框比一圈，然后指那条被剪断的地方。

请看这张图上的两条路。

蓝色这条带着偏置，它往下走，分组、选人，最后吐出 8 个编号 —— 然后就被剪断了。

手改指绿色那条，从 sigmoid 一路划到最底下的绿框。

绿色这条是原始分数，从 sigmoid 那一步直接旁路到最后，一路没碰过偏置。

最后加权用的，是绿色这条。

停两秒，然后给这句话。

所以偏置能把负载掰匀，却一个字节都没改变模型的输出。 调度归调度，不污染输出。

这带来三个很实在的好处：偏置可以任意大力地掰，掰得再狠输出也不失真； 它不参与反向传播，不跟主目标抢梯度；它是训练循环外面的一个动作， 想改策略不用动模型。

下面这段是补一个诚实。三十秒，但要讲。

⭐ 但「完全不用辅助损失」这句话，说过头了

滚到下面那张蓝黄两个框的图。

这套方法的名字叫 auxiliary-loss-free，直译就是「无辅助损失」。 名字很干净，实情没那么干净。

翻回论文原文，它写的是：虽然主要依赖这个无辅助损失的策略， 但为了防止任何单条序列内部出现极端失衡，还是同时用了一个补充的序列级均衡损失。 它接着说，这个损失的系数会被赋一个极小的值。

左框、右框，各指一下。

所以其实是两套机制，管的是两个不同尺度的问题。

左边的偏置管的是「跨步」的事 —— 每一步结束看一遍全局负载再调。 它管得了「某几个专家长期吃太饱」。

右边那个极小的损失管的是「一步之内」的事 —— 某一条序列碰巧把 token 全挤到少数几个专家上。 这件事发生在一步内部，偏置根本够不着，因为它一步才调一次。

这句是这一段的落点。

左边是策略，右边是保险丝。名字里的 free 说的是左边那件事是主力， 不是右边不存在。

要交代一句边界：「两套机制、各管一个尺度」是论文直接写的； 「所以那个系数才能取极小值」是我们的读法，论文没这么解释过。

最后一块：分组限制 —— 本讲的主落点

指那个「256 个分成 8 组，只准挑 4 组」的蓝框。

256 个专家被分成 8 组，每组 32 个。一个 token 最多只允许碰 4 组。

我问大家一个问题：这么限，是为了让模型学得更好吗？

真的停一下等反应。这个停顿是这一讲的支点。

一点关系都没有。

因为组就是机器。

一个 token 挑中 8 个专家，如果这 8 个散落在 8 台不同的机器上， 它的激活值就得发到 8 个地方去，算完再收回来。 这就是 all-to-all 通信。

限制到 4 组，就是直接把「一个 token 最多打扰几台机器」这个数按住了。

这是全课主线最锋利的一句，说完停三秒。

换句话说：一个通信约束，被直接写进了模型结构里。

这不是工程师在模型外面做的优化。这是模型定义本身的一部分 —— 你去读 V3 的 config，那两个数字就明明白白写在那儿。

如果时间还有三十秒，加这一段。它是「硬件先划线」最直白的一个证据。

而且论文里有一句，我第一次读到的时候愣了一下。

它说：虽然 V3 实际只选 8 个路由专家， 但在通信代价完全不变的前提下，这个数可以一路加到 13 个。

停一秒，让这句话落地。

读法是这样的：他们先按机器的形状定下「最多跨 4 个节点」这个盒子， 然后在盒子里看能塞多少专家。盒子能装 13，最后填了 8。

所以顺序是反的 —— 不是模型说要 8 个、系统去满足； 是系统先划了一条线，模型在线里挑了个数。

收尾，然后过 4c。

所以这一节的落点是：路由里几乎每一个设计， 都不是为了让模型更聪明，是为了让它能跑。 sigmoid、偏置、分组限制、最后再乘一个 2.5 的缩放 —— 没有一条是在提升表达能力。

滚到 4c，那张两条线交叉的图，整张要在屏幕里。

专家权重放不下在一张卡上 —— 一层就 21 GiB，58 层加起来 1.19 TiB。 所以专家一定是散在很多张卡上的。

于是就有了这道题：token 在这张卡上，它要用的专家在那张卡上。谁去找谁？

两条路，都能走通

手指绿色那条水平线，再指蓝色那条斜线。

第一条：把 token 送过去。 它选中了 8 个专家，就把它的激活值发到那 8 张卡上，算完再收回来。 发出去一次、收回来一次，每个 token 每层 224 KiB。

第二条：把权重搬过来。 各张卡先把自己手上那份专家权重广播给大家，凑齐之后本地算，token 一步都不用动。 一层 21.08 GiB。

下面这句是这一讲的支点，慢一点。

⭐ 关键不在两个数谁大，在两条线的形状

第一条的量，跟 token 数成正比 —— 图上是那条斜线。

第二条的量，跟 token 数完全无关 —— 你搬一次权重，这一批有 10 个 token 还是 1000 万个 token，搬的都是同样这 21.08 GiB。图上是那条水平线。

停一下，让大家自己看出下一句。

一条斜率是 1，一条斜率是 0。所以它们一定相交。

这就是为什么「要看场景」这句话在这里不是和稀泥 —— 它是从几何上看出来的。

手指红圈那个拐点。

相交的地方，大概是 9 万 8 千个 token。

拐点两边住着谁

依次指三个蓝点：左下、中间、右上。

推理 decode，一步就出几十个 token —— 远在拐点左边。挪 token 划算， 而且不是划算一点点，是差着好几个数量级。

训练一个 step，动辄上百万 token —— 远在右边。挪权重划算。

而一次 128K 的 prefill，13 万 1 千个 token —— 刚刚过拐点。

这句停两秒，它是给专题六埋的种子。

所以你会看到一个很有意思的现象：同一个模型、同一次推理请求， prefill 那一段和 decode 那一段，落在拐点的两边。 这两段为什么在很多事情上都是相反的，专题六会专门讲。这里先记住有这么回事。

把边界说清楚，这很重要

指图下面那行灰字，和右边那个黄箭头。

这个 9 万 8 千，不是一个工程门槛，不要拿去用。

它是个粗口径 —— 我只比了「每层要搬多少字节」， 没算 all-to-all 和 all-gather 的效率差异，那两种通信的代价本来就不一样。

而且拐点自己会动。 专家摊在越多张卡上，挪 token 那条线就被分摊得越薄，拐点就越往右移。

那它的价值在哪？在于它告诉你：这两个方案在同一个数量级上。

这是本讲最后一句，说完停三秒再翻页。

如果差着一百倍，那就没什么好选的了。正因为它们咬得这么近， 「二选一」才真的成立 —— 前面所有的账都有唯一答案，这一笔没有。

如果时间还够，指一下下面那行小字，只念名字。

这个方向上有一批专门的工作，名字听过就行：DeepEP、EPLB、dropless。 都是在这道题上做文章的，这门课不展开。

滚到 4c 最后，容量盒子那张对比图。

刚才提了一个词叫 dropless，我想花两分钟讲一下 —— 因为它背后是这门课的一条暗线。

先回到第七讲那四条好性质

第一条是：形状是静态的。 编译器在开跑之前就知道每个矩阵多大、每块内存放在哪，才能把整张图排好。

MoE 一来，这条断得最彻底。

这一批里有多少个 token 落到第 37 号专家头上？路由跑完才知道。而且下一批就变了。

这句停一下，这是整讲的病根。

可硬件要的是开跑之前就定死。

老办法：给每个专家发一个固定大小的盒子

手指左边那张图，从左到右三个专家依次点过去。

这个盒子多大，是你自己设的一个超参数，叫容量系数。

设完之后形状就又静态了 —— 每个专家永远算固定这么多个 token，编译器满意了。

但你看这张图里同一层同时在赔两笔钱。

指专家 A 上面那两个红色虚线框。

左边这个专家来了 6 个 token，盒子只装得下 4 个。多出来的 2 个 —— 直接丢掉。

丢掉的意思是：这两个 token 在这一层的输出被置零，只剩残差穿过去。 这一层对它们来说等于白过。

手改指右边那个画满斜线的专家 C。

而右边这个专家只来了 1 个 token，剩下 3 个格子拿零去填 —— 照样占算力、占显存， 算完是零。

下面这句是主落点，慢一点说。

所以这个容量系数是一个非常难受的旋钮：开小了丢真数据，开大了白烧算力。 两个方向都赔。

三个数字，说明这不是「调个参数」那么简单

滚到下面那个蓝框，三条一条一条念。

第一，丢 token 是真的伤质量。 同一组对照实验里，会丢的那版验证损失只降了 0.15，完全不丢的那版降了 0.26 —— 是前者的 1.73 倍。

第二，靠把盒子开大来不丢，很贵。那个例子里 MoE 层的算量涨了两倍多。

第三，而且你根本不知道该开多大。 有的模型这个系数要开到 11 才不丢；还有的模型，这个值会在训练中途毫无征兆地飙上去。

停两秒。

一个你不知道该设多少、设错了两个方向都赔、还会中途自己变的超参数。

如果台下有人较真，这三个数的适用范围要给： 那组实验是 Transformer-Small 规模、64 个专家、top-1 路由， 跟 V3 的 256 专家 top-8 差着量级。 它们能证明的是「容量系数这个旋钮本身是个麻烦」， 不能换算成「V3 如果丢 token 会掉多少分」。

dropless 干的事

手指右半张图。

它的思路很直接：不要盒子了。

把整个 MoE 层重写成一种叫 block-sparse 的矩阵乘法 —— 这种算子本来就能处理大小不一的块，所以来 6 个就算 6 个，来 1 个就算 1 个。

不丢，也不白算。

但真正的收获不是省了那点算力。 是那个旋钮直接不存在了 —— 你不用再调它，也不用担心它中途变。

那 V3 呢

滚到绿框。

V3 的技术报告写得很直白：因为负载在整个训练过程中一直保持得不错， 所以它训练时不丢弃任何 token。

这里停一下，然后回接第 9 讲。

请注意它给的理由 —— 是负载被掰得足够匀。

所以第九讲那个负载均衡的偏置，作用比我当时说的还要大。 我当时说负载不均是个木桶问题，大家一起等最慢那张卡。 现在你看到了另一半：在有容量盒子的世界里，负载不均会让 token 直接消失。

它不只是在防止变慢，它是在防止数据凭空不见。

还有半句话，很多人漏掉。三十秒。

那上线以后呢

报告那一小段其实是两句话，第二句一样重要： 他们还实现了专门的部署策略来保证推理时的负载均衡，所以推理时也不丢 token。

但训练和推理靠的不是同一套东西。 训练时有训练循环，可以每步调偏置。上线之后没有这个循环了。

推理靠的是搬专家：把线上观测到的高负载专家复制一份，额外部署。 prefill 阶段设了 32 个冗余专家，每张卡除了原本的 8 个再多带 1 个； 哪些是热点根据线上统计来定，每隔十分钟左右重新调一次。

下面这句是这一段值得留下的东西。

注意这个动作的边界：重排只在节点内部做，明确不增加跨节点的 all-to-all。 又一次 —— 先认拓扑，再谈优化。

收尾，过 4d。

滚到 4d，那张参数表，整张要在屏幕里。

先把账合上

这张表里每一个数，前面都推过了，现在把它们加起来。

单个专家 44.04 M，一层 257 个专家加一个门控 11.32 B，58 层 656.57 B。

一层注意力 187.11 M，61 层 11.41 B。三层 dense 1.19 B。进出口两张大表 1.85 B。

下面这个数字念慢一点，一位一位念。

加起来：671.03 B。官方口径 671B。

停两秒。

我想说清楚这一步的意义 —— 它不是对上了一个数字。

是把我们这两个小时用过的每一条公式，一次性验了。 隐藏维 7168、专家宽度 2048、SwiGLU 要三个矩阵、MLA 那几个秩 —— 任何一条记错了，这个总数都对不上。

这也是我推荐大家验算的方式：不要孤立地检查某个数对不对， 去找一个能把一整套公式串起来的外部锚点。

⭐ 表里最扎眼的一行

滚到那张蓝色 61 片 / 绿色一整块的对照图。

请看这两条。上面那条是全部 61 层注意力加起来，11.41 B。 下面那条是随便哪一层 MoE，11.32 B。

两条一样长。

这句停三秒，让它自己发酵。

六十一层的注意力，等于一层 MoE。

而我们刚才在第六讲算过：在 128K 长度上，注意力吃掉 81.8% 的算力。

所以注意力占参数 1.7%，占算力 81.8%。

参数量和计算量，是两本完全不同的账 —— 连排序都不一样。

如果时间够，指一下下面那个 MLA 拆解的蓝框。

顺带一个小发现，同样是「不同的账不同的答案」。 MLA 那 187 M 参数里，最大的一块不是压缩 KV 用的那几个矩阵， 是把 128 个头拼回残差流的输出投影，一个矩阵就占 62.8%。

压了半天缓存，参数大头在出口那一侧。 这不矛盾：MLA 压的是「每个 token 要存多少」，那是显存账； 这里数的是「这一层有多少参数」，那是参数账。

山和溪 —— 本讲主落点

滚到那张蓝条 / 绿条的图，再往下就是那张山的插图。

上面那条蓝的是 671.03 B，全部参数。下面那一小截绿的是 36.62 B， 一个 token 真正用到的。

差不多 18 倍。

下面这句是全课最容易被听错的地方，一定要重。

这 18 倍，全都是算力。显存，一个字节都没省。

中间那 634 B 参数，这一步确实闲着 —— 但它们必须待在显存里， 因为下一个 token 可能就要用其中的某几个。

指那张山和溪的图。

那座山是显存要扛的，那条溪才是算力要付的。

MoE 做的事，就是把山和溪分开。在它之前，你想要多大的山，就得付多大的水。

停一下，然后给出那句纠正。

所以「激活 37B」不等于「跟 37B 的稠密模型一样好养」。 你需要的显存，跟一个 671B 的稠密模型一模一样。

MoE 换来的是「同样算力下能装更多知识」，不是「同样显存下能跑更大的模型」。

收尾，过第 5 步。

最后把这一讲拎成一句：参数、算力、显存，是三本账。 一个部件在一本账上微不足道，在另一本账上可能就是主角。 第 7 步我们会把三本账并排放在一起看。

滚到第 5 步，那张左右对照图，整张要在屏幕里。

我先问大家一个问题：你脑子里的 Transformer 长什么样？

真的停一下，让他们在心里画。 手指左半张图。

大部分人会画成左边这样：一根管道。数据进第 1 层，出来进第 2 层，再进第 3 层， 一路传到底。

这个图像是错的。

手改指右半张。

它其实是一条总线

有一个宽度 7,168 的向量，从头到尾一路贯穿。

每一层做的事是三步：从它读一份，算出点东西，再加回去。

滚到下面那个公式框。

写成公式就一行：x 等于 x，加上 MLA 处理过的 x。 下一行，x 等于 x，加上 MoE 处理过的 x。

这两行重复 61 遍，整个模型就没了。

这是翻转时刻，重读「加」这个字，然后停两秒。

请注意是「加」，不是「替换」。这一个字是这一讲的全部重量。

为什么必须是加

两个理由，一个关于梯度，一个关于语义。

梯度上：加法给反向传播留了一条直达的高速路。 不然梯度要穿过 61 层的乘法，会衰减到什么都不剩。

语义上更有意思 —— 它让「什么都不做」成为默认状态。

某一层如果暂时没学到有用的东西，它输出接近 0，加上去等于没动， 不会破坏已经有的信息。

停一下，下面三条是这一讲的价值密度所在。

⭐ 这个区别带来三个能观察到的后果

第一，每一层看到的是「到目前为止的全部」，不是「上一层的输出」。

所以第 40 层可以直接读到嵌入层当初写进去的东西 —— 中间那 39 层没有把它冲掉，只是往上叠了东西。

第二，形状全程不变。7,168 进，7,168 出，61 层都一样。

所以你能随便插一层、删一层。 61 这个数字不是算出来的，是试出来的。

这一条在硬件上也很关键：因为整条流的宽度不变， 你可以按这个维度一路切下去做并行，不用每层重新规划。

手指左右两张图的底部注释，对着念。

第三，管道模型里第 30 层坏了，后面 31 层全废。 总线模型里第 30 层输出 0，只是少了一份贡献，别人照跑。

归一化摆在哪，一句带过

V3 用的是 pre-norm：先 norm，再进子层，子层的输出直接加回主干，主干本身不动。

另一种摆法叫 post-norm，是先加、再对加完的结果做 norm —— 那样这条总线上每隔一段就横着一个 norm，刚才说的那条「直达的高速路」就断了。

现代模型基本都站到了 pre-norm 这一边。 这里可以加一句给懂行的人听：2020 年 Xiong 那篇 Layer Normalization 的论文证过， post-norm 在初始化时输出层附近梯度很大，所以学习率 warm-up 是必需的； pre-norm 则可以把 warm-up 整个去掉。 「训不稳」这个说法，落到能验证的形式，就是这一条。

最后一个数字，它只立问题

滚到那个「1.75 GiB × 61」的框。

残差流在 128K 长度上，每层要留一份：131,072 乘 7,168 乘 2 字节， 正好 1.75 GiB。

61 层全留着，106.75 GiB。而一张卡是 88 GiB 出头。

停一下，然后补这句 —— 它比上面那个数更有冲击力。

请注意这个数字里一个权重都没有。全是中间结果。 权重那 1.22 TiB 是另外一笔账。

于是一个问题自己冒出来了：凭什么要留着？算完不能扔吗？

这里不要接着讲，让问题悬着。

「为什么反向非要这些中间量」，那是专题四的事。这一讲不答。

但屏幕上这段有半个答案，念一下就好，别展开 —— V3 论文里明写着：所有 RMSNorm 和 MLA 的上投影，反向的时候重算，不存。

所以真实系统面对「装不下」的第一反应，不是加卡，是问一句：这份非存不可吗？ 存不下就别存，反向时拿算力换回来。这是拿时间换空间，不是免费的。

这一句就够了，别顺势讲重算策略 —— 那是专题四。 如果时间还够，滚到最后那个 mHC 的框和它上面那张图，30 秒带过。

题外一眼。V3 只有一条残差流；V4 换成了 mHC，四条并行的残差流。

对着图说一句就行：变宽的是总线，不是车间。 层的输入输出还是 7,168 维，MLA 和 MoE 内部一个字节都不用改。

加宽残差流不是 DeepSeek 起的头，前人做过，问题是堆深了训不稳。 mHC 的那一下是把混合矩阵约束成双随机矩阵 —— 行和列和都是 1，信号既不放大也不消失。 所以它不是「更宽」，是「让更宽这件事变得能训」。

代价那句要小心讲 —— 不要说「4 倍宽所以显存 4 倍」。V4 论文用 fused kernel 加选择性重算把这笔账吃掉了大半， 他们给出的唯一绝对数是墙钟开销 6.7%。 细节在展开框里，课上不讲。

滚到第 6 步开头。

走完 61 层，手里还是那个 7,168 维的向量。现在要把它变回「下一个字是什么」。

动作只有两步：最后一次 RMSNorm，然后乘一个矩阵， 从 7,168 维摊开成词表的 129,280 维 —— 给每一个词打一个分。

softmax 一下，就是概率分布。温度就是在这一步起作用的。

顺带一个容易漏的配置

手指那个 tie_word_embeddings 的红框。

这个矩阵跟第 1 步那张嵌入表，形状一模一样，7,168 乘 129,280。

很多模型会让它们共享同一份权重，叫权重绑定 —— 毕竟「表示一个词」和「预测一个词」直觉上是一回事。

但 V3 的配置里这一项是 false。它认为读和写是两个不同的任务，各给一份。 代价是多 926 M 参数。

这也解释了第 7 步那张表里的一个数：嵌入相关是 1.85 B，不是 0.93 B —— 因为它数了两份。

这里换气。下面是这一讲的全部重量。

⭐ 现在看这个矩阵的输出

滚到那张红色的 logits 图，整张要在屏幕里。

131,072 个位置，每个位置 129,280 个分数，两个字节。

乘出来 31.56 GiB。

停两秒，让这个数落地，再给对照。

我给三个对照。它比 61 层 MLA 的全部权重加起来还大 —— 那个是 21.26 GiB。 它比一层 MoE 里 257 个专家的全部权重还大。它是残差流一份的 18 倍。

手指图下面那行「三个让它更难堪的细节」。

三个让它更难堪的细节

第一，这一步的算力只占整个前向的千分之五。

242.92 TFLOP，而整个前向是 52.5 PFLOP。 全程算力最少的一步，产出了全程最大的张量。

第二，算 cross-entropy 的时候，logits 通常要提到 fp32，不然数值不稳。

那就是 63.13 GiB —— 占单卡 88 GiB 的 72%。 一个纯临时的东西，吃掉四分之三张卡。

第三个对照我觉得最有意思。这 31.56 是训练的账， 因为训练每个位置都要算 loss。

推理的 prefill 只需要最后一个位置的 logits —— 252 KiB。

滚到那张左右对照图：左边一整块红板，右边一条绿细线。

同一个算子，训练和推理差 131,072 倍，正好就是序列长度。

右边那条绿线其实是骗你们的 —— 按真实比例它只有那个虚线框的十三万分之一高， 合零点零零一三个像素，画不出来。为了让你们看见，它被放大了大概一千倍。

这句话本身就是个记忆点，说完停一下。

所以「lm_head 这个算子贵不贵」这个问题， 脱离了「训练还是推理」，根本没法回答。

所以真实现是怎么做的

没人会把它整个物化出来。标准做法是分块： 一次只算几千个位置，当场把 loss 算掉、梯度攒下，扔掉这块再算下一块。

也就是把 loss 融进去，让那个大张量从头到尾都没有完整存在过。

这跟 FlashAttention 是同一类手法 —— 不要把中间结果落地。 这门课里第二次出现这个手法了。

下面是收口，慢下来。

⭐ 落点

滚到最后那个绿框。

请注意，这已经是这门课第三次撞上同一件事了。

第 2 步是 KV cache。第 5 步是激活。现在是 logits。

三次的形状一模一样：一个在参数表上根本不存在的东西， 体积超过了参数本身。

停，然后一字一句说下面这句。

所以这一步真正的收获不是 31.56 这个数，是这句话 —— 算显存只算权重，一定会算错。

如果时间还够，滚到 MTP 那个表，30 秒带过。

题外一眼：MTP

配置里还有一项，除了预测下一个字，还额外预测下下一个。 注意是「一个」，深度就是 1。

它是为训练造的 —— 论文自己写的目的就是「用 MTP 来改善训练」。 只预测下一个字，模型容易学成顺嘴溜；逼它同时看远一点，等于要求它有规划。

而且推理的时候可以直接把它丢掉，主模型照常工作。 论文里的消融实验就是这么做的，所以对比双方的推理成本完全一样。

但丢掉太可惜，所以它被顺手拿来做投机解码的草稿。 V3 实测第二个字的接受率 85 到 90%，端到端吐字速度一点八倍。

同一个东西，为训练造的，被推理捡了便宜。 为什么这笔买卖划算，是专题六的事，这里点到为止。

滚到第 7 步，那张总表整张在屏幕里。

我们走完了七步。这张表就是一路攒下来的全部。

给三秒让他们扫一眼，不要念。

我不打算逐行念它。它在屏幕上，你们随时能看。 我只用它回答三个问题。

问题一：一次 128K 前向，多少算力

52.5 PFLOP。

而其中 81.8% 是 attention 那个平方项。 不是那 671 B 参数，是那个跟序列长度平方成正比的东西。

问题二：常驻显存多少

权重 1.22 TiB，加 KV cache 8.58 GiB，一共 1.23 TiB。

问题三：要多少张卡

手指第三张橙色的卡片。

1.23 TiB 除以单卡的 94.74 GB。

停一拍，再报数。这是全课的收口。

14.3。

你不能有零点三张卡，所以是 15 张。

这里停久一点，然后说下面这句 —— 这才是重点。

这个数字本身不重要。重要的是它是除出来的。

今天开场我没有说「大模型需要并行」这句话，一次都没说过。 我们只是一步一步算，然后它自己出现了。

⭐ 但请不要把 15 记成「答案」

滚到下面那个黄色的警告框。

15 张卡是最乐观的可能值。它建立在五个假设上， 而每一个在真实训练里都不成立。

只算前向、batch 等于一、不含激活、不含临时缓冲， 还假设权重能完美打包。

滚到下面那张三条横杠的图，整张在屏幕里。

把峰值激活那 41.89 GiB 加进去，14.3 变成 14.7。 就是图上第二条 —— 你们看，跟第一条几乎一样长。这一步还好。

铺垫完了，下面这个数是这一段的落点。

但换成训练就不是一个量级了。看第三条。

每个参数要 16 个字节 —— 权重两个、梯度两个、 fp32 主权重四个、再加两个动量各四个。

手指第三条上那五个色块。

请注意这五段的比例：模型本身只占最左边那两个字节， 右边那 12 个字节全是优化器的。

671 B 乘 16，10.74 TB。除以 94.74，大概 113 个 device。

比这里多将近八倍。 那笔账是专题四的，这里只报个数 —— 但那三段橙紫红怎么砍， 基本就是专题四的全部内容。

这张图真正的信息不是 113，是那个形状，值得点一句。

这张图想说的其实不是 113 这个数，是这个形状： 前两条几乎一样长，第三条长了八倍。

因为①②③问的根本不是同一个问题。①问「权重放得下吗」， ②问「跑一次前向放得下吗」，③问「能不能训」。

而这三个问题，平时经常被同一句「这个模型要几张卡」混在一起问。 下次听到这句话，先反问一句是哪个口径。

所以这一页正确的读法是：连最省的口径都要 15 张， 而真实训练要八倍于此。

换个感觉：这些算力是多长时间

滚到下面那三张时间卡片。

PFLOP 是个没有体感的单位。除以硬件的算力，它就变成秒了。

单个 TPU v7 device 的 bf16 峰值大约 1153 TFLOP 每秒。 官方标的是每颗芯片 2307，而一颗芯片里有两个 device，除以二得来 —— 这个 2 比 1 后面还会再遇到。

理论极限，百分之百利用率：45.5 秒。

现实一点，按 35% 利用率：130 秒。

这句要慢，让它沉一下。

两分多钟，就为了把一段 128K 的输入过一遍。 而且这只是前向 —— 没有反向，没有参数更新。

摊到那 15 张卡上：8.7 秒。

手指第三张卡片下面那行小字。

但这个 8.7 后面跟着七个字：「假设并行完美无损」。

停两秒。这是整门课的入口，值得停。

那七个字，就是这门课剩下的全部内容。

把活分给 15 张卡，绝不等于快 15 倍。它们要互相传数据、 要等最慢的那一个、要为了省显存把一部分重算一遍。

那道差距有多大、从哪来、怎么缩小 —— 是专题五和专题七。

这一段结束了，换气，语气从「算」切到「验」。

⭐ 第 7.5 步：这些推导，能不能信

滚到第 7.5 步。

前面这些全是推导。所以有一个很自然的问题：能信吗？

能，而且不用占一张卡。

编译器本身就是一个静态分析器。把模型和并行配置喂给它提前编译一次 —— 这条路子一般叫 AOT —— 它就能报出这份配置要多少显存，全程不申请任何加速卡。

排队等卡之前就知道答案 —— 这是整个流程里最省钱的一步。

这句话要说，不然听众会以为下面在教工具。

但先说清楚：下面三条不是 AOT 的使用说明，这门课不讲怎么跑它。

下面三条讲的是：一个「不用跑就能告诉你答案」的工具，该信到什么程度。 这个问题跟工具无关 —— 换成任何一个性能模型、任何一份容量估算表，结论都一样。

铺垫完。下面三条是这一讲的价值密度所在。

这三条是我们自己踩出来的，不是书上的。

① 编译过了，不等于装得下

编译成功只说明这张图合法。 我们见过编译一路绿灯、但显存需求远超单卡上限的配置。

下面这句才是这一条真正的内容。

更麻烦的是：报错会误导人。

真正的编译失败，常常被报成「装不下」。 于是人就去调小 batch —— 方向完全错了。

这类「错误的错误信息」比没有信息更危险。 因为它会让你很有信心地朝错的方向使劲。

② 报出来的那个数，不是全部

它只是临时缓冲。参数和优化器状态是另外一笔账。

而且它不随并行度缩小 —— 你切得再宽，临时缓冲该多大还多大。 这一点最容易算错：以为加卡就能压下去，结果它纹丝不动。

③ ⭐ 贴着上限的那一带，它会失灵

远离上限的时候，AOT 非常可靠。

但逼近上限的那个窄带里，它判不准。我们判错过， 而且错的全落在这一带。

滚到那张三色横条的图。

看这张图：左边一大片绿的，右边一小片绿的，中间紧贴着上限有一条红的。 绿的地方判得准，红的地方判不准。

下面这句是这一条的钥匙，说慢一点。

现在请注意红带下面那行字 —— 真正值得一试的配置，几乎全挤在这一带。

想想也是：谁会花时间去试一个明显装不下、或者明显浪费的配置？

停，然后一字一句说下面这句。

也就是说：它最不准的地方，恰好就是你最需要它的地方。

而且这不是工具的 bug，是它的性质 —— 换个工具也一样。

所以 —— 不要把静态分析当神谕。它帮你排除掉大部分明显不行的配置， 但不替你做最后那个决定。

还有一个反直觉的

同一个模型、同样的并行配置，只是换了某个算子的实现， 显存需求就会变。而且方向不固定，有的变大，有的变小。

滚到那个深色的收口框。

所以整个 7.5 步就落在这一句上：显存不是模型的属性， 是「模型 × 实现 × 编译器」三者的属性。

全课最后一段，语气放松下来。

最后，留个钩子

我们今天从头到尾都在拿 94.74 这个数当分母。

算 KV cache 撞墙点用它，算激活装不装得下用它， 刚才算 15 张卡也用它。

停一拍。

但我一次都没解释过它从哪来。

为什么是 94.74，不是 96、不是 128？

为什么单个 device 的峰值是 1153，而官方标的是 2307？

为什么一颗芯片里会有两个 device？

不要回答。停两秒，然后收。

那是下一课。

今天这一课的任务，只是把「装不下」这个事实算出来 —— 而不是说出来。