专题六 · 推理

这份讲义怎么用

两个用法。
① 上台讲:照着念,台词、切图、每段几分钟都写着。
② 自学:把这一整份丢给 AI,让它当助教带你走一遍。

内容本身在课件那边,这一份只管「怎么讲」。 课程作者 Chris Yang · Google Cloud AI Infra 架构师。

⏱ 时间:主线 90′

⛔ 第零、一节不能砍。 第零节立住「decode 每一步都搬一趟」,第一节算清这一趟为什么贵;后面每节开头都拿它接。
全讲十节约 90 分钟,不中场休息。想深挖哪一节,课件每节末尾都有通往完整版(L300)的链接。
台词里的 4K、128K 这类长度,K 读作「千」。
下面的地板含互动约 82 分钟(每次 build 现数,以表为准):地板只按每分钟 200 字念稿算,指图、等回答、接追问都不在里面。各节余量不一:第七节最多,两分多钟;第一、五节一分多钟;第六、八节含互动已略超计划,那两节的追问留到课后。台下问得多,就放在余量大的节答。第零节开头那道回顾题只给一分钟,别展开讲专题五。

段落分钟能不能砍一条主线
零 推理为什么贵?这几年又是怎么一步步变便宜的?8—decode 每一步都把整车货(权重+KV)搬一趟;省钱只有两条路:一趟多坐人、少搬货
一 为什么几千字的 prompt 一趟读完,吐字却一趟只出一个?9—公交车:开一趟油钱固定;prefill 满载,decode 一趟只拉一个人
二 那多拉几个人不就行了?batch 能开多大?9—公交每站都停:随上随下(连续批);座位就是 KV,代价是每个人等得更久
三 KV cache 到底占多少,怎么省?8—每人一本笔记:一行多厚(MLA/GQA)、纸别浪费(分页)、算过的不再算(前缀复用)
四 多卡跑:TEP 还是 DEP?11—谁把笔记复印了几份;判据 TP 路数 ÷ KV 头数;容量和速度分开看,SGLang 两头 DEP 座位坐满才换吞吐;大 EP 把专家那趟车坐满
五 长上下文:DCP 和 PCP 有啥区别?10—谁搬家:PCP 搬 KV、答案不用拼;DCP 搬 Q、答案要拼;谁小搬谁
六 PD 分离:多搬一趟 KV,凭什么接的人更多?9—两种活互相拖(换成厨房的比方:一个灶台备菜,一个灶台出菜);分开后各开各的批
七 投机解码:怎么一趟出好几个字?11—先猜后验:猜对白赚,猜错只亏一点;batch 越大越不灵;草稿离大模型越来越近(EAGLE 要训、MTP 差在谁训)
八 量化:少搬字节,掉不掉点?8—位数减半、搬运下限减半;专家压 4 bit、注意力最多 8 bit;KV 也能压
九 第一天上手,先问哪几个问题?7—回到那一趟:八问是一个问题——这一趟卡在哪
合计90

⛔ 上面是计划,下面是地板(台词 200 字/分钟 + 每次切屏 15 秒 + 每个互动半分钟,每次 build 现数)。

节台词汉字切图地板计划给的互动 / 可跳含互动跳后
第零节 推理为什么贵?这几年又是怎么一步步变便宜的?1,02956.4′8′2 / 07.4′7.4′
第一节 为什么几千字的 prompt 一趟读完,吐字却一趟只出一个?94886.7′9′2 / 07.7′7.7′
第二节 那多拉几个人不就行了?batch 能开多大?1,18467.4′9′2 / 08.4′8.4′
第三节 KV cache 到底占多少,怎么省?97056.1′8′2 / 07.1′7.1′
第四节 多卡跑:TEP 还是 DEP?1,45089.2′11′2 / 010.2′10.2′
第五节 长上下文:DCP 和 PCP 有啥区别?1,22077.8′10′2 / 08.8′8.8′
第六节 PD 分离:多搬一趟 KV,凭什么接的人更多?1,28698.7′9′1 / 09.2′9.2′
第七节 投机解码:怎么一趟出好几个字?1,12287.6′11′2 / 08.6′8.6′
第八节 量化:少搬字节,掉不掉点?1,11667.1′8′2 / 08.1′8.1′
第九节 第一天上手,先问哪几个问题?91855.8′7′2 / 06.8′6.8′
合计73′90′19 / 082′82′

第零节 推理为什么贵?这几年又是怎么一步步变便宜的?(8′)计划 8′ · 含互动 7.4′

🖥 本节主屏:课件 第零节 推理为什么贵?这几年又是怎么一步步变便宜的? · 主图 fig-s0-chain

🎯 这一节只留一句:每出一个字,整车货搬一趟;这几年的每一招,都是在补上一招留下的洞。

🖥 屏幕:停在第零节标题下的折叠框「开场热身:五种并行,各自要用哪几种集合通信?」,点开;五行勾选先不点「对答案」。

「开讲前,先把上一讲捡回来。专题五切了五刀:DP、FSDP、TP、PP、EP,每切一刀,就多出一种通信。
表上横着是五种通信:AllReduce、AllGather、ReduceScatter、AllToAll,还有一对一收发。每一行,勾上它训练一步要用的那几种,可以勾不止一个。给大家一分钟。」

💬 互动:各自在页面上勾;没开页面的,我一行一行念,大家举手。一分钟后点「对答案」,红底的行请一位说说怎么想的。期望答案:DP 勾 AllReduce;FSDP 勾 AllGather 和 ReduceScatter;TP 勾 AllReduce;PP 勾一对一收发;EP 勾 AllToAll。

「DP 和 TP 拆成 AllGather 加 ReduceScatter 也算对,AllReduce 本来就是这两半拼起来的。
这张表全是训练的账。训练时答案是现成的,整段一起算,只看吞吐。推理不一样:人坐在屏幕前等着。」

「先看一个大家天天都在经历的画面。你往聊天框里贴一份四千字的文档,问一句,按回车。
等了一下,第一个字出来了;然后字一个一个往外蹦,速度挺匀。要是思考模型,它还得先自己想上一大段,才开始回答你。」

「屏幕那头,一颗很贵的芯片在给你干活。规格表上最显眼的是它每秒能算多少次。
可这几千个字一个个往外蹦的时候,这份算力绝大部分时间闲着,在等货送到。今天就讲两件事:这样吐字为什么贵;这几年又是怎么一步步变便宜的。」

🖥 屏幕:滚到「用户只等两个数:第一个字,之后每个字」,停在 fig-s0-life,先指红点,再指后面一串绿格。

「刚才那个画面,画出来就是这张图。先把你的文档整段读一遍,叫 prefill,读完吐出第一个字,就是这个红点。后面每个绿格出一个字,叫 decode。
你作为用户,只感觉得到两件事:第一个字等了多久,后面每个字隔多久。」

「顺带说个词:模型吐的单位叫 token,中文里大致一个字,今天就叫「字」。
那串紫色阶梯,每出一个字高一格,就是待会要讲的 KV:它记着前面每个字,越写越长。」

🖥 屏幕:滚到「贵在哪」,停在三条要点和绿框「全课一句话」。

「贵在哪?全课拿 DeepSeek-V3 算账。它每出一个字,要用到大约三百七十亿个参数,一个参数存一个字节,就是三十七 GB。为什么只用一部分,第一节讲。
这三十七 GB 住在显存里,好比仓库。真正做乘法的地方,旁边只有一张小工作台,大约是仓库的一千五百分之一。」

「工作台放不下,就只能每出一个字,都把这三十几 GB 从仓库重新搬一趟。
货还有第二种,叫 KV。写下一个字,要回头看前面每一个字;看过一遍留下的东西存起来,下一步直接翻,不用重算。
这就是每个人的一本笔记,对话越长越厚,十几万字的对话,一本就有八 GiB 多。」

「打个比方,这是一辆公交车。权重是车自带的货,每开一趟都得拉着,油钱固定,坐一个人还是坐满,差不多。笔记是乘客随身带的,人越多越重。
所以省钱只有两条路:一趟多拉几个人,或者把货减轻。只有一招不碰这一趟,把两种活拆开放,第六节讲。」

💬 互动:问台下「多拉人、减轻货,你能先想到哪一招?」,等两三个回答。期望答案:一车多拼几个人(后面叫 batch)属于多拉人,把每个数存得更小(量化)属于减轻货;答不上也没关系,下面那张表就是答案。

🖥 屏幕:滚到「四年怎么变便宜」,停在 fig-s0-chain,从左边二〇二二往右扫一遍;再往下停在那张七行的表。

「这几年变便宜,大多是沿着这两条路一步步走出来的。表上名词很多,今天只看「卡在哪」这一列。
二〇二二年,车中途不停站,一车人要陪最慢的那个坐到终点;改成每站都能上下车,车就坐满了;车一满,座位又被笔记占住。
后面每一行都是这样:补上一个洞,又露出下一个。每节接一环,今天不用记名字。」

「还有两股外力一直在推:上下文一路开到一百万字,每人的笔记越来越厚;思考模型一题先想几百到几千字,一个字一个字吐的那段成了大头。后面好几招,都是被这两股力逼出来的。」

🖥 屏幕:滚到表下的蓝框「先猜一个数」,指着框里的 DeepSeek-V4-Pro。

「留一道题,最后一节揭晓:同一套 GB300、同一个模型 DeepSeek-V4-Pro、每个用户出字一样快,光改软件,每张卡的吞吐是首发那天的几倍?一倍半、两倍,还是五倍?记住你猜的数。
第一节就回到开头那个画面:读四千字只等一下,吐字却一个一个来,为什么?」

⚠️ 这一节最容易跑偏的地方⚠️ 开场勾选题只花一分钟:不点名、不展开每种通信怎么走,那是专题五的事;被问「推理时用哪几种」:表还能用,轻重变了,TP 那几次 AllReduce 数据不多、卡在延迟,EP 也不一定走 AllToAll(课件答案表下那行小字),细节第四节和完整版第六节。
⛔ 那个倍数这里不揭晓,留到第九节;说漏就没悬念了。
⚠️ 这一节只给地图,表里每一行都别展开,后面每节自己会讲;一展开就回到流水账。
⚠️ 被问「为什么只用三百七十亿」:MoE 每层有几百个专家,每个字只挑几个,第一节讲;总参数 6,710 亿。
⚠️ 被问「V3 六千多亿参数一颗芯片装不下,三十七 GB 是谁在搬?」:开场为了画面说成一颗芯片;实际是好几颗分着存、分着读,每颗只搬自己那份,下限按卡数摊(第八节备答:八颗 v7 FP8 至少 0.63 ms,正好单芯片 5 ms 的八分之一,本课推导)。「每出一个字」严格说是「每走一步」,一步里车上每人各出一个字,第一节讲。
⚠️ 被问「GPU 也每步重搬吗」:也是,道理一样;GPU 片上缓存多大,课件没给,别现场报。
⚠️ 被问「推理降价这么多,都是系统的功劳吗」:不是,AI Index 主要归给更强的小模型,开场那道题只算软件那一份。价格降了多少倍不报:都是价格口径(完整版台账已改定性),本课只用同卡同模型同交互档的 5.1 倍。
⚠️ 口播取整的原数:工作台=TPU v7 一颗芯片的片上存储 128 MiB(两个 TensorCore 各 64 MiB),约整颗芯片 192 GiB 显存的 1/1,500(按一个 device 算也一样:64 MiB 对 94.75 GiB;别拿整颗的 128 MiB 去比一个 device 的显存);「八 GiB 多」=128K 时 8.58 GiB;「一百万字」=2024-02 Gemini 1.5 Pro 预览 1M(2023-11 GPT-4 Turbo 先开到 128K);思考模型=2024-09 o1、2025-01 R1。
⚠️ 开场画面里的「四千字」只是举例,跟第一节 prefill 4K 对上;「算力绝大部分时间闲着」指一个人用时(第一节算出只用上 0.32%)。
⚠️ 被问「轴最右边两个空心点」(从主线挪到这里):模型这边的新动向。一个把大部分层换成线性注意力,笔记不再一个字记一份,每人只留一本固定厚度的;一个是循环模型,同一段层多跑几圈。思路都早就有,图上放的是进主流大模型那年;给引擎出的新题见完整版第十三节和第零节。

第一节 为什么几千字的 prompt 一趟读完,吐字却一趟只出一个?(9′)计划 9′ · 含互动 7.7′

🖥 本节主屏:课件 第一节 为什么几千字的 prompt 一趟读完,吐字却一趟只出一个? · 主图 anim-trip

🎯 这一节只留一句:prefill 卡算力,decode 卡搬运;decode 一趟只拉一个人,油钱照付。

「回到上一节开头那个画面:四千字的文档,等一下就出第一个字;可后面的回答,是一个字一个字往外蹦的。
读四千个字一趟就完,吐字却一趟只出一个。同一颗芯片,前后两段为什么差这么多?」

🖥 屏幕:滚到「一趟喂几行」,停在三条要点。

「还是那辆公交车。每开一趟,就是把权重从显存搬一遍;车上每个座位,坐一个字,就是矩阵乘里的一行。
prefill 像旅行团:文档是现成的,四千个字一起上车,一趟拉满。decode 往外吐字,每个人每一趟只能上一个字。一趟里有几个人,车上才有几行。」

「为什么不能让后面的字先上车?因为第二个字是什么,要等第一个字到站才知道。
训练能整段一起算,是因为答案早就写在那里;推理没有答案,只能一个一个来。」

「那车上坐多少人才算满?拿 TPU v7 的算力除以带宽,得三百一十三,叫屋脊点:从显存读进一个字节的工夫,芯片能算三百一十三次。
车上每多坐一个人,搬来的每个字节就多算一次。所以要坐满三百一十三人,算的那头才不干等。四千人的旅行团远远过线;只拉一个人,算力只用上三百多分之一。」

🖥 屏幕:停在 fig-s1-ai,先指红线,再指右上的橙点,最后指左下那串绿点。

「橙点是 prefill,在线上面,卡的是算力。绿点是 decode,全在线下面,卡的是搬运。」

💬 互动:问「DeepSeek-V3 出一个字要读三十七 GB,一颗 v7 每秒读七点三七 TB,读一遍要多久?」停五秒。期望答案:约五毫秒。有人报五秒,提醒分母是 TB。

🖥 屏幕:滚到「5 毫秒在搬」,停在 anim-trip。先取消勾选「连续播放」,点「⟲ 重来」回到开头,再点「开始」,看权重一格格搬上工作台;第一次停住时先指蓝条,再指几乎看不见的橙条。

「对,五毫秒。那算要多久?零点零一六毫秒,就是这根细到看不见的橙条。
一颗很贵的芯片,九成九以上的时间在等货从仓库搬过来。」

🖥 屏幕:点「下一步」,看第二个字又把整车权重搬一遍。

「出完这个字,下一个字呢?工作台放不下三十七 GB,刚才那车权重已经扔了,得从头再搬一趟。又是五毫秒,还是只出一个字。」

🖥 屏幕:再点「下一步」,看一趟喂 313 行,橙条一路追上蓝条。

「同一车权重,一趟坐三百一十三人,算的时间才追上搬的时间。
反过来读更有意思:在这之前,多上一个人,这一趟几乎不变长。车反正要开,多上来的人等于白搭车。
所以换更快的计算单元没用,下限是带宽定的。」

🖥 屏幕:滚到「多拉几个人」,停在 fig-s1-wkv,先指蓝段,再指紫段。

「办法很直接:一趟多拉几个人。车自带的货是公用的,人越多,每人摊到的蓝段越短。
可紫段不动。那是每个人自己的笔记,谁的笔记谁自己读,拼多少人都摊不掉。」

「对话一长,紫段就成了主角:几百个人一车、每人十几万字的对话,每趟要搬的货里,笔记占了快八成。
座位最后是被笔记占满的,第三节专门讲。」

🖥 屏幕:滚到「MoE 又把凑好的人拆散」,停在 fig-s1-moe,先指左边填满的方块,再指右边那条细线。

「还有一刀。模型每一层分两步:先回头翻笔记,叫注意力;再过一个大的前馈网络。MoE 把这个前馈网络拆成好多份,每份叫一个专家。
用公交车说,每一层就是一个换乘站:DeepSeek-V3 每站有两百五十六条支线,每个字只坐其中八条。这就是开头说的「每个字只用三百七十亿」。」

💬 互动:问「好不容易凑齐两百五十六个人上车,到了换乘站,每人挑八条支线。每条支线平均上几个人?」停五秒。期望答案:八个(256 × 8 ÷ 256)。

「对,平均只剩八个。每条支线是一辆单独的车,权重单独搬,一趟只拉八个人。车又空了,回到一趟只拉几个人的老问题。
要让每条支线都坐满,完整版按 H100 算过,一步得凑九千多个字。这就是第四节要解的题:把专家铺到更多卡上。」

🖥 屏幕:停在绿框「这一节带走」。

「这一节带走一句:prefill 卡算力,decode 卡搬运。想让每一趟值回油钱,就得多拉人。
后面三节就走这条路:先让车一直坐满,再给笔记腾座位,最后把被 MoE 拆散的人收回来。先问第一步:多拉几个人不就行了?」

⚠️ 这一节最容易跑偏的地方⚠️ 口播取整的原数:屋脊点 313=v7 bf16 2,307 TFLOP/s ÷ 7.37 TB/s;decode 实际要凑约 343 人才过线(比 313 多一点是因为输入输出也要读写);「九成九以上在等」=算力只用上 0.32%;「快八成」=256 人、每人 128K 时 KV 占每字读取字节的 78%;「每条支线坐满」=每个专家约 300 行(完整版第三节按 H100)。
⚠️ 「零点零一六毫秒」=一个字约 740 亿次运算 ÷ 每秒 4,614 万亿次(W8A8,FP8 算力,L300 第一节讲义的备注),不是屋脊点用的 bf16 2,307;老兵拿 bf16 一除会得 0.032 ms,比例照样是 0.32%(权重按两个字节读就是 10 ms;这两个数是本课推导)。被问就这么答,别改口播。
⚠️ 五毫秒、百分之零点三二是按规格推的理想下限,不是实测;只算权重,不算 KV、通信和 kernel 开销。
⚠️ 「每多坐一个人,每个字节就多算一次」按十六位算:一个权重两个字节,跟车上每一行乘加一次是两次运算,正好抵上(从口播挪来;口播改成「读一个字节的工夫能算三百一十三次」,别说成「每字节配三百一十三次运算」,听着像配方)。
⚠️ 屋脊点只讲「读一个字节的工夫能算几次」这个直觉,别推强度公式,那是 L300 第一节的事。
⚠️ 「每人摊九点一四 GB」留在完整版;被问「人多了专家是不是也读得多」:是,车自带的货也会涨一些,六十四人约碰到八成七的专家(完整版第一节图注:1 − (1 − 8/256)64 ≈ 87%),别展开算式。
⚠️ 被问「五毫秒一个字,那每秒两百个字,为什么第二节说两字隔七十多毫秒」:那是另一套硬件、另一个模型、一车几百人;人多了每一步要读的笔记多,每一步就长。五毫秒是一个人、只算权重的理想下限。
⚠️ 「九千多个 token」是完整版第三节按 H100 屋脊约 300 算的;v7 上的对应数课件没算,别现场报。
⚠️ 被问「V3 存的是 FP8,屋脊线怎么按 bf16 画」:换 FP8 算力翻倍、屋脊点约六百二十六,可每个参数也只占一个字节,每字节算的次数也翻倍,比例还是百分之零点三二。
⚠️ 「快八成」(78%)是按字节算的比例,不是说八颗芯片真装得下 256 人 × 128K 的笔记。
⚠️ 被问「H100 上也是这样吗」:道理一样,比值不同;课件只算了 v7,别现场报 GPU 的屋脊数。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「注意力靠 FlashAttention 就能把算力填满,凑三百多人只是为了 EP 吧?」→ 前半句反了。FlashAttention 省的是打分表不落显存,管的是 prefill 和训练(一次几千行查询);decode 每人一行查询、读一整本私有笔记,拼多少人都摊不掉,就是图上不动的紫段。注意力每字节能算几次,看一份 KV 被几个查询头共用:MHA 一个、GQA 一组、MLA 全部头共用一份(第三节)。凑三百多人是给共用权重凑的:注意力前后的投影、共享专家、稠密层;路由专家每个只分到八行,要九千多个 token 才过线,所以第四节铺大 EP。

第二节 那多拉几个人不就行了?batch 能开多大?(9′)计划 9′ · 含互动 8.4′

🖥 本节主屏:课件 第二节 那多拉几个人不就行了?batch 能开多大? · 主图 anim-contbatch

🎯 这一节只留一句:连续批让座位不空着;座位数由 KV 定;人越多,每个人越慢。

「上一节说,decode 一趟只拉一个人太亏,那就多拉几个。这一节的招,模型一行不改、kernel 一个不换,只改怎么排队,就多接了几十倍的人。
难在哪?乘客不是一起上车、一起下车的。有人问一句『今天星期几』就走了,有人要你写三千字的报告。」

🖥 屏幕:滚到「老办法」,停在两条要点。

「最早的做法叫静态批:凑满一车,一起出发,一起到站。先答完的人下不了车,座位就空着。
车每开一步,权重照样整趟搬一遍,那些空座位就是白搬。
为什么不中途换人?不是没人想到,是老引擎只有一个按钮:整批跑完。走到第几步,调度器根本看不见。」

🖥 屏幕:滚到「每站都停」,播 anim-contbatch,先指上面一组越来越多的灰格,再指下面一组。

「二〇二二年有篇论文叫 Orca。第一招:每走一步,就停下来看一眼,谁写完了马上下车,门口排队的马上补上。
看动画,上面的灰格越走越多,那就是空座位;下面一格都没有。同样的步数,下面做完的人明显多。」

「这招后来叫连续批,今天 vLLM、SGLang 都这么排。
还是那辆公交车:老办法像包车,凑满一车一起到站;连续批才是公交本来的样子,每站都停,到站的下,等车的上。」

「可每个人写到的位置都不一样,有人写到第三个字,有人写到第三千个字,凭什么能拼进同一趟?这是 Orca 的第二招。
乘权重那一步,根本不管这一行是谁的,所有人接成一长条一起乘,权重读一遍,大家共用。」

「只有注意力拼不了。注意力就是回头翻自己的笔记,每人的笔记长短不同、内容不同,只能拆开,各翻各的。
所以一步里,大部分活拼着干,只有翻笔记那一小段分开干。」

「新人上车也有讲究。一条几万字的长 prompt,要是一口吞下,那一步就特别长,车上正在出字的人全被卡一下。
所以把它切成小块,每一步只带一块,跟着车慢慢上,这叫分块 prefill。最后一块算完,第一个字当场出来,下一步他就是车上普通的一员。」

「门口一步只进一两个,车上怎么坐满几百人?因为进门只占一步,出字却要坐上几百上千步。隔几步补一个人,车就一直是满的。
门口不是瓶颈,座位才是。」

🖥 屏幕:滚到「座位就是 KV」,先停在第一段,别往下滚 —— 下面那张图是第二道题的答案。

「那车上最多坐几个人?每个人在车上,都得占一块 KV,就是上一节说的那本笔记。显存里装得下几本笔记,就有几个座位。
座位和吞吐之间,就一笔账:每秒出几个字,约等于车上人数,除以两字间隔。」

💬 互动:问「两字间隔稳在五十毫秒,想让一张卡每秒出一万个字,车上至少得坐几个人?」停五秒。揭晓:五百人(本课口算:一万 × 零点零五秒)。

「可要是显存只装得下三百本笔记呢?吞吐就钉在六千上下。门口再来多少人,也只能排队。
这就是座位不够。」

💬 互动:问「那就多给座位。我们在 GB300 上跑 V4-Pro,给 KV 池多分一点显存,车上能多装百分之十三的人。按刚才的公式,吞吐该涨多少?实际涨了多少?」停五秒,让大家报数 —— 多数人会说十三。揭晓:只涨百分之零点八。

🖥 屏幕:下到 fig-seats,先指最上和最下两根,再指中间两根。

「公式没错,错在我们以为两字间隔不变。多出来的人,代价落在每个人头上:每两个字之间,等得长了将近一成。
为什么变长?权重早被大家摊薄了,新上车的人带来的全是自己的笔记。人多了,每一步要翻的笔记就多,每一步就慢。
人多一成多,每步也慢近一成,一除,几乎抵掉了。」

🖥 屏幕:滚到「batch 开多大」,停在 fig-s2-pareto,手指沿绿线从右往左划。

「把这笔账画全,就是这条线。横轴是每个人每秒拿到几个字,纵轴是每张卡每秒一共出几个字。
往左走,车越挤,卡越划算,每个人越慢:让每个人慢一半多,每张卡出的字能多十倍。
所以「每人要多快」得先定下来,这一档后面就叫交互档。」

「所以有人跟你说『我们每卡吞吐是你的两倍』,第一句先问:每个人拿到多快?可能人家只是站在线的更左边。
线上真有人选左边:DeepSeek 每个用户每秒只拿二十来个字,换来很高的吞吐。」

🖥 屏幕:停在绿框「这一节带走」。

「回头看,这一节就三步:多拉人,靠连续批让座位不空着;最多拉几个,看显存装得下几本笔记;拉多了,每个人慢一点。
这一招有多大用?Orca 论文里,同样的延迟下,能服务的请求是老办法的三十六点九倍。」

「座位既然是笔记定的,下一个问题就很自然:每人那本笔记到底有多厚,能不能薄一点?
笔记一薄是两头赚:坐得下更多人,每一步要翻的少了,每个人也更快。这一节一路在讲取舍,这是少有的不用取舍的一招。」

⚠️ 这一节最容易跑偏的地方⚠️ 三十六点九倍的口径是 GPT-3 175B、每字中位延迟同压在 190 毫秒、对 FasterTransformer 静态批,不是今天引擎之间的比。
⚠️ 动画里的请求长度是示意,同样 15 步静态批做完 8 个、连续批 14 个,只说明灰格去哪了,别当实测倍数报(口播只说「明显多」)。
⚠️ 曲线两头原数:每人每秒 173 字时每卡 895,68 字时每卡 9,759(课件第二节);口播「慢一半多、多十倍」是取整(68/173 ≈ 0.39,9,759/895 ≈ 10.9)。
⚠️ DeepSeek 那个吞吐是每节点(8 卡)约 14,800,硬件和模型都不同,被问别跟曲线的每卡数直接比。
⚠️ 曲线那三个点是 InferenceX 的 vLLM;别把 SGLang 的 11,200、首发日的 2,200 放这里比,那是第九节揭晓的数。
⚠️ chunked prefill 只说一句「切块跟车上」,被问一步里怎么拼、块多大,指向完整版第三节。
⚠️ 13% 那组原数:每个 rank 同时在跑的请求 886 → 999(dep8 一个 rank 就是一张卡,口播说「每卡人数」),两字间隔 77.7 → 85.3 ms(口播「长了将近一成」,85.3/77.7 ≈ 1.10),吞吐 10,614 → 10,704。
⚠️ 「人数 ÷ 两字间隔」只做口算,别推导,台上也不必报公式名(排队论里叫 Little 定律,被问再说);图里「吞吐上限约 3%」是本课按 999/886 × 77.7/85.3 推的(口播「一除几乎抵掉」),886 → 999 是 L300 台账记的「每 rank 请求」(mem-fraction 0.85 → 0.88,+13%),口播说「能多装」不说「多坐」只是保守;涨不动的原因原记录没拆,别解释成谁的错。
⚠️ 「五百人」「钉在约六千」是本课推导的口算,不是实测:人数 ≈ 每秒字数 × 两字间隔 = 10,000 × 0.05 s = 500;每秒字数 ≈ 300 × 1000 ÷ 50 ms = 6,000。
⚠️ 被问「门口要多快补人」:每人写一千字、车上三百人,平均每三步补一个就够;是完整版第三节的示意算账,不是实测。
⚠️ 被问「分块 prefill 就完全不卡了吗」:后面的块要读前面全部笔记,会更重;128K 切 8K 一块,末块约是首块的 7 倍,指向完整版第三节。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「每步都要 CPU 挑人,GPU 不就干等?」→ 让 CPU 提前一步:GPU 算这一步时,CPU 已排好下一步。它不等上一步结果,先假设人人都接着写,刚吐的字留在显卡上直接接力;谁写完了晚一步才认出来,下一轮再请下车。SGLang 这招吞吐 1.1 倍(完整版 3.3)。(2026-10-22 试讲追问后补)

第三节 KV cache 到底占多少,怎么省?(8′)计划 8′ · 含互动 7.1′

🖥 本节主屏:课件 第三节 KV cache 到底占多少,怎么省? · 主图 fig-s4-batch

🎯 这一节只留一句:座位数 = KV 池 ÷ 每人那本笔记的厚度。想多坐人,先把每行写薄,再让纸别浪费,最后算过的不再算。

「上一节最后说,座位就是每人那本笔记:他说过的每个字记一行,写下一个字,要把前面每一行都翻一遍。
那这本笔记到底多厚?先按最老的写法算一笔,你会吓一跳。」

🖥 屏幕:滚到「一行多厚」,停在三条要点。

「模型翻笔记,是同时从很多个角度看:有的盯语法,有的盯这个『他』指的是谁。每个角度叫一个注意力头。
最老的写法叫 MHA,每个头各抄一份自己的笔记。按 V3 的形状算,一个人把上下文聊满,光笔记就五百多 GB,两颗半芯片都装不下。这是我们按形状推的,真这么记根本跑不起来。」

「所以第一步,把每一行写薄。GQA 让几个头合抄一份,Llama 分八组,就只抄八份。DeepSeek 的 MLA 更狠:每层只记一条压缩过的摘要,所有头都对着这同一条摘要算。
在笔记这件事上,MLA 只算一个 KV 头,下一节要用。一除,笔记只剩 MHA 的五十七分之一左右,这是我们自己除的。」

「写薄了会不会变笨?GQA 原论文拿一个模型试过:解码快了五倍多,平均分几乎没动。
这只是一个模型、一台机器上的数,方向可以信,倍数别照搬。」

🖥 屏幕:滚到「笔记越长」,停在 fig-s4-batch,先指最上面那根三段横条,再指绿线。

「可写薄只是每行变薄,行数还是跟着字数涨。看这张图:半颗 v7 芯片,软件里叫一个 device,扣掉权重和一小段预留,剩四十多 GiB 放笔记。绿线是 MLA,上下文四千字,能坐一百七十多人。」

💬 互动:问「同一个 device、同一个 V3,上下文从四千拉到三万二千,长了八倍。人数会变成多少?」停五秒,让大家报。揭晓:正好剩八分之一,一百七十二变二十一。再指红线尽头那个红叉:MHA 还没到三万二千,就一个人都坐不下了。

「字数翻倍,人数就减半。所以长上下文贵在两头:车上坐不下几个人,这一趟只分给几个人;坐上车的每个人,每一步要翻的笔记也更厚。
厚度这一步先讲到这儿。剩下能动的,是这些纸怎么摆。」

🖥 屏幕:滚到「纸别浪费」,播 anim-paged,等请求 2 结束那一下,指块 2 和块 5。

「第二步:纸别浪费。老办法不知道谁会写多长,就给每人先留一整本最厚的,还得是连在一起的一大块显存。没写到的地方空着,别人也借不走。」

💬 互动:问「这样预留,KV 那块显存实际用上了几成?」请两三个人报数,停五秒。揭晓:只有两到四成(vLLM 论文实测 20.4%–38.2%)。

「vLLM 的 PagedAttention 改成活页本:一页装固定几行,写满了再领下一页,领到哪页算哪页,一张页表记着顺序。
看动画,请求 2 一走,它那两页马上给了请求 4。利用率到了九成六。」

「代价是笔记散在显存各处,翻的时候得先查页表。
换来的不只是不浪费:两个人开头一模一样,页表指向同一页就行,不用各抄一份。第三步就从这里长出来。」

🖥 屏幕:滚到「算过的不再算」,停在 fig-s4-disk。

「第三步:算过的不再算。很多请求开头一样,比如同一段系统提示词、多轮对话的前几轮。那段笔记已经写好了,留着,下一个人接着往后写。
笔记就从用完就扔的草稿纸,变成了缓存;挤不下,先挪最久没人翻的。」

「DeepSeek 干脆把这些笔记存到磁盘上,一天里过半的输入能命中。一条很长的 prompt,第一个字从等十三秒变成半秒。
磁盘不是最慢吗?慢是慢,可把现成的笔记读回来,还是比整段从头重算快得多。」

「但它只认一字不差的开头。每行笔记都是看着前面所有字写出来的,开头改一个字,后面每一行都跟着变,只能重写。」

🖥 屏幕:停在绿框「这一节带走」。

「三步各省一样:写薄省的是每本的厚度,分页省的是空着的纸,前缀复用省的是重算的时间。vLLM 论文里,对手有一套已经会连续批,同样延迟下的吞吐还是它们的二到四倍。
不过这都是一张卡的账。模型大到要好几张卡一起跑,每人那本笔记是只存一份,还是每张卡都复印一份?这就是下一节:TEP 还是 DEP。」

⚠️ 这一节最容易跑偏的地方⚠️ 「五百多 GB、两颗半芯片」是本课按 V3 形状推导(V3 128 个头,一个字 3,997,696 字节约 4 MB;「聊满」= 128K,3,997,696 × 131,072 ≈ 524 GB ≈ 488 GiB,对一颗 192 GiB);没有哪个模型真这么存。
⚠️ GQA 的分数是论文报的平均分(T5-XXL 改成 8 组、TPU v4;47.1 对原版 47.2,口播「几乎没动」),别说成通用倍数;论文的 GQA 模型是在原模型上改的,被问怎么改、要不要再训,指向原论文。
⚠️ 被问「MLA 解压不费算力吗」:出字时所有头直接对摘要算,每头要算的乘加比展开多(完整版第五节,约 3.4 倍);decode 缺的是带宽不是算力,所以划算。
⚠️ 「约 1/57」「快约 5.4 倍」都是本课推导(两个公开数相除);MHA 那行是拿 V3 形状假想的,没有哪个模型真这么存。
⚠️ GQA 和 MLA 两行是不同模型(Llama-3.1-70B 对 V3),别说「MLA 比 GQA 小几倍」当同模型对比。
⚠️ MLA 摘要每层 576 个数、1,152 字节,61 层;1/57 就是拿它对 MHA 那行除的。
⚠️ 「四十多 GiB」= 一个 device 94.75 GiB 先留 10% 给激活,再减十六分之一权重:94.75 × 0.9 − 39.1 ≈ 46.2 GiB(课件 fig-s4-batch 顶条同算法)。46.2 GiB 是一个 device 的池子,按权重全切粗算,实际非专家权重每个 device 各存一份,池子更小;被问拆法,指向完整版第四节。
⚠️ 原口播「单是分页这一步」说过头,vLLM 的 2–4 倍是整套系统对比,不是单独开关分页的消融;改说「对手有一套已经会连续批」(作者复现的 Orca)。二到四倍的口径是 vLLM 论文(SOSP 2023)、同样延迟、对 FasterTransformer 和作者复现的 Orca,不是今天引擎之间的比。
⚠️ 「一条很长的 prompt」原文是 128K、高复用的 prompt。磁盘那张图上下两栏出自两份不同时期的材料,别把「过半命中」和「13 秒到半秒」说成同一次统计。
⚠️ 紫线(线性注意力混合)、DSA/V4 怎么省读省存、前缀按块算哈希,本节都不讲,被问指向完整版第四节。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「对话太长,删掉早先几轮截断上下文,缓存还管用吗?」→ 大半不管用。开头一变,后面每行笔记都对不上;LMCache 论文报这种截断能让前缀命中率掉一半。(2026-10-20 从课件主线挪到备答:用法上的坑,不是本节主线)
🛠 GPU 老兵「KDA 跟 MLA 什么区别?不也是读一份、算好多头吗?」→ 两条路。MLA 还是笔记,每个字记一行、随字数变厚,薄在压缩成一条摘要、所有头共用这一份,所以每字节能多算几次。KDA 是线性注意力,不记笔记,每个头存一块固定大小的状态(head_dim × head_dim 的矩阵),每来一个字就改一次,上下文多长它都这么大;但每头各有一块、不共用,每一步读出来改完还要写回,每个数只算几次,仍然卡搬运。所以 MLA 赢在每字节多算,KDA 赢在长上下文不挤座位;实际模型混着用,K3 是 69 层 KDA + 24 层 MLA(K3 config)。KDA 的状态池和前缀命中另有麻烦,见第五节 DONT 和完整版第四节。
🛠 GPU 老兵「KDA 的头数一定和 MLA 一样吗?」→ 不一定,是设计选的。K3 config 里是两个独立字段(linear_attn_config.num_heads 与 num_attention_heads),恰好都填 96、head_dim 128。对齐图的是张量并行按同一个数切头、kernel 好对齐,不是数学要求。顺带一句:KDA 头越多,状态块越多、要搬的越多,跟 MLA「头越多、一份摘要被用得越多次」正好相反。

第四节 多卡跑:TEP 还是 DEP?(11′)计划 11′ · 含互动 10.2′

🖥 本节主屏:课件 第四节 多卡跑:TEP 还是 DEP? · 主图 fig-s6-dep-kv

🎯 这一节只留一句:TP 会把每人的笔记复印「TP 路数 ÷ KV 头数」份;DEP 不复印,赢在每一步变短;大 EP 把专家那趟车坐满。

「上一节把笔记写薄了。可像 DeepSeek-V3 这么大的模型,一张卡根本装不下,得好几张卡一起跑。
专家那一半,大家的做法一样,分给各张卡。吵的是注意力那一半:几张卡合起来算同一批人,还是各带各的人?」

🖥 屏幕:停在「名字拆开读」框。

「先把名字拆开。TEP、DEP,后面两个字母都是 EP,说的是专家,两边一样。只有第一个字母在变:T 是 TP,按头切;D 是数据并行:算注意力时各卡各拉各的人,到了专家那站再全体合伙。
下一节会碰到 DCP、PCP,也是三个字母,可那组的首字母是阶段,decode 还是 prefill。两组名字不是一个拆法。」

🖥 屏幕:滚到「谁把笔记复印了几份」,停在 fig-s6-tep-dep-t5。

「回想上一节:看的角度叫查询头;笔记按份记,一份叫一个 KV 头:常见的 GQA 记 8 份,MLA 只记一份,算 1 个 KV 头。
TP 按头切,每张卡算几个头,拿那几个头的笔记。KV 头比卡多,各拿各的;比卡少,几张卡只好共用同一个头,那个头的笔记就复印几份。」

「复印几份?就一个除法:TP 路数除以 KV 头数。DeepSeek 这类只有一个 KV 头,开 8 路 TP,8 张卡共用它,每人的笔记就复印 8 份。
复印不光占地方。每一步,8 张卡各自把同一本笔记从头读一遍,读的字节也翻了 8 倍。」

💬 互动:问「Qwen3.5-397B 的全注意力层 32 个查询头、两个 KV 头,也开 8 路 TP,每人的笔记复印几份?」停五秒。期望答案:四份(8 ÷ 2)。再补一句:8 个 KV 头的模型正好一卡一头,不复印。

「DEP 不一样:每张卡带自己那批人,笔记只放一份。这件事要分两条轴看:一条是地方够不够,一条是一步快不快。」

🖥 屏幕:滚到「容量和速度分开看」,停在 fig-s6-dep-kv,先盖住下半张。

「先看地方。TEP4 四张卡放同一批人,一份正本三份复印;DEP 每张卡放自己的一批。算到每张卡上,最多能装下 4 倍的人。
⭐ 注意,4 倍是天花板。来的人少,多出来的座位空着,换不来吞吐。」

「那这 4 倍吃不吃得到?讲一个我们自己破的案子。
16 台 GB300,用 SGLang 跑 V4-Pro。这套部署把读文档和吐字拆到两批机器上,为什么这么拆,第六节讲。大部分机器读题,两台拼成一组写字,两批的注意力都用 DEP。目标是官方博客报的每卡一万一千二。」

🖥 屏幕:露出下半张,先指拓扑条,再指第一行 727。

「第一次跑通,只有六千九,差一大截。
第一条线索:每张卡同时在写的才 727 人,座位没坐满。
座位为什么空?V4-Pro 每人的笔记分两本,一本记全文,一本只记最近一段,两本按一个比例分显存。比例切歪了:一本已经塞不下新人,另一本还空着一大截。」

💬 互动:问「把比例调平,座位从 727 涨到 886,多两成。猜吞吐涨多少?」停五秒。揭晓:指第二行,涨了五成多。比座位涨得还多:读题那头一直在喂,座位一空出来就有人坐。

「尝到甜头,我们接着给笔记多分显存。还记得第二节那道题吗?座位多一成多,吞吐只涨百分之零点八。那道题就出自这个案子的这一步。
这回凶手换了:座位不缺了,是人一多每一步都拖长,多上的人全被抵掉。」

「结案一句话:座位要有人坐、每一步别跟着拖长,才换得来吞吐。我们最后停在官方目标的 95.6%。
写字那组再加宽,我们也试过,反倒亏了,毛病出在读题那头,第六节讲。」

「另一条轴,一步快不快,只有 vLLM 一组旁证:decode 从 TP4 换 dep8,两字间隔缩到四分之一左右,按全部卡算,每卡吞吐两倍出头。分母怎么数有讲究,第九节算。」

「代价也有。DEP 不是多开几辆车:专家这批大货还是分到各卡,不整套复制;可注意力的权重和状态,每张卡得自己备一份。Kimi 的 K3 就栽在这:它大部分层不记逐字的笔记,每人只揣一张固定大小、随写随改的便条。DEP 下每张卡得把所有头的便条整池装下,DEP8 一加载就爆显存,只好退回 TP。这个洞,下一节接。」

🖥 屏幕:滚到「大 EP」,播 anim-bigep,先指上面 EP8 那 8 行,再指下面约 128 行。

「还记得第一节那张图吗?每层几百个专家,每人只挑 8 个,好不容易凑满一车人,摊到每个专家头上只剩 8 行。
解法就是把专家铺开。出了一台机器还在分,叫大 EP。DeepSeek 线上 decode 铺了 144 张卡,每张卡只管两个专家,热门的专家多备几份,正好分匀。」

「动画里一列一列看,铺开换来三样。
车坐满了:每个专家分到的人,从 8 个变成一百二十多个。
读得少了:每张卡每层要读的专家,只剩原来的十六分之一。
显存腾出来了:专家只占 5 个多 GB,剩下全给笔记。」

🖥 屏幕:滚到「为什么做得成」,停在 fig-s6-bigep-net。

「铺这么开,不怕网络扛不住吗?网上跑的只是人,笔记和专家都待着不动:一个字一步来回最多十 MB 左右,比它读一步笔记少一个多量级。
量不是问题,难在等。58 个专家层,每层一去一回,出一个字要等 116 次。」

「等的时间不藏起来,省下的读权重时间就全赔进去。所以把车上的人分成两拨,轮着来:一拨在算,另一拨在路上;人太少就别拆,拆了反而慢。
DeepSeek 用普通 8 卡机加 InfiniBand、GPU 自己发数据,就做成了。」

🖥 屏幕:滚到「所以 NVL72 这类大域,对推理特别合适」,停在 fig-nvl72,先指 1× 那条虚线;说到「不全是」时指图下黄框。

「NVL72 更省事:一整柜的卡在同一个 NVLink 域里,专家铺到几十张卡都不出柜。SGLang 在上面跑 DeepSeek,每卡 decode 是 H100 上大 EP 部署的将近三倍,再压低精度,将近五倍。
可图下黄框说了,这里面还混着显存、精度、kernel,不全是大 EP 的功劳。只能说:大 NVLink 域给大 EP 留足了余量。」

「那 TP 就没用了?两种时候 DEP 不占便宜:KV 头够分,一卡一头,本来就不复印;人少,笔记本来就不挤。DEP 是为人多设的。」

🖥 屏幕:停在绿框「这一节带走」。

「这一节带走:DEP 不复印笔记,座位坐满才换吞吐;大 EP 把专家那趟车坐满。
可退回 TP 的模型,笔记还是被复印,上下文一长就装不下。下一节:长上下文,DCP 和 PCP 有啥区别?」

⚠️ 这一节最容易跑偏的地方⚠️ 口径:K3 的「便条」=KDA 线性注意力,每个请求一块固定状态;九十三层里六十九层是这种层(L300 第六节)。DEP 下每个 rank 要装全部头的整池状态,两次加载都爆显存;TP8 按头切给八张卡。「便条」这个词第六、九节还会用,这里先立住。案子里「两批机器」=PD 分离,口播只点一句,别在这里展开为什么拆
⚠️ 主线数据是 SGLang、GB300、14 台 prefill 各 dep4 + decode dep8、输入 4096、14 路 × 并发 1050(runbook :851-858)。727 → 886 涨 54% 但峰值只从 11,851 到 12,063,别说成「座位多两成,算力利用就多五成」,只说端到端涨了多少。
⚠️ 口播取整:「六千九」= 6,887;「涨了五成多」= 10,614(+54%);「另一本还空着一大截」= 全文池 93%、滑窗池 63%;「十六分之一」= 1.41 GB → 88 MB(本课推导,和 8 → 128 次同一个 16 倍)。10,704 tok/s 是 95.6% 那一档的每张 decode 卡端到端吞吐;官方 11,200 的分母没写明,本课按 decode 卡读(课件本节已注明),被问别说成官方口径。第二节 13% → 0.8% 就是本组 886 → 999 那一步。
⚠️ 速度旁证:我们 SGLang 那套没拿 TP 比过;vLLM 那组同样并发,两字间隔 46.8 → 11.8 ms(「四分之一左右」),「两倍出头」即 2.09 倍,那次 decode 卡也从 4 张换成 8 张,分母留到第九节讲。
⚠️ NVL72 倍数的测法:decode 是先压慢、攒满请求再放开测的;H100 基线有一组开了模拟 MTP,GB200 没开。
⚠️ 2.09 倍只当旁证:V4-Pro、GB300、vLLM、并发 512、按全部卡(含 12 张 prefill 卡)算,本课推导;按 decode 卡算 1.31 倍。别说成「DEP 永远快两倍」,也别把它和 SGLang 那组比。
⚠️ 别拿「输出 × 间隔」算的「车上人数」(输出 × 间隔)去讲容量:那是速度的结果,跟池子能装几批是两件事。dep16 那组是 12 台 prefill 对 dep8 的 14 台,卡数配比也变了,别说成「dep16 不如 dep8」。
⚠️ EP144 怎么每卡正好两个:256 个专家加 32 份冗余=288 份,一卡两份。8 → 约 128 行=144 卡 × 每卡 32 人 × 每人 8 个 ÷ 288 份,按每卡 32 个请求、负载均匀推导;1.41 GB → 88 MB、81.7 → 5.1 GB 按 V3 专家大小(FP8)推导,都不是线上实测。
⚠️ 128 次只和 8 次比,别拿去对第一节的 313:硬件和精度都不同,没说过线。
⚠️ 「512 里剩下的不在 decode 车上」是本课推导,原记录没拆这几百个请求各在哪。
⚠️ 被问「等一次多久」:DeepEP 在 EP256 上一去一回约 554 µs(分发 194 + 汇回 360),× 58 层约 32 ms 是不重叠上限(本课推导),别和 V4-Pro 的 11.8 ms 比;被问「批多小算太小」:SGLang 每卡 32 个 token 时拆微批反而慢 27%。一组最多 128 张卡陪跑(一张出事全组下线)。
⚠️ 「约 10 MB」是本课推导的上限(每 token 172 KB × 58 层);「少一个多量级」比的是 4K 上下文一步读的 288 MB 笔记(L300 6.4),上下文更短差距就小,被问要带上这个条件。
⚠️ NVL72 的倍数只对 H100 上的大 EP 部署,混着显存、精度、kernel、PD 分离,不全是大 EP 的功劳;3.8 倍是 prefill、4.8 倍是 decode;口播「将近三倍/将近五倍」=decode 2.7 倍(未压精度)/4.8 倍(取整)。不报任何对 B200 的倍数。
⚠️ TEP/DEP 是 TRT-LLM 的叫法,≠ Megatron 的 ETP/EDP;被问细节指向完整版第六节。
⚠️ 双微批只点一句「一批算一批传」;EPLB、TPU 上的 DP 注意力本节都不讲,被问指向完整版第六节。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「两本笔记到底是哪两个池?比例非得手调吗?」→ 每层都两样都有:全长池放压缩后的整段(CSA 四个并一条、HCA 一百二十八个并一条),滑窗池放最近一百二十八个原样 token。比例大致是每人固定的滑窗槽数除以平均长度,所以跟输入长度走;十月的 SGLang 不传比例时能自动留。我们七月是手调的(完整版 4.2)。(2026-10-22 试讲追问后补)
🛠 GPU 老兵「上百张卡绑成一个实例,坏一张怎么办?」→ 全组陪着下线,这是大 EP 的代价之一。完整版 6.4 里 prefill 反着来,不往大铺,每个实例只用 2–4 张卡;原文列的好处里就有一条:出事波及的卡少。DeepSeek 线上 decode 照样铺大,靠的是不怕重启慢:重启要几分钟,就多留几台顶着、把请求改送别的实例;重启时按剩下健康的卡重定 EP 大小,有几张用几张。要下线的实例先给 1 分钟宽限,没跑完的请求连 KV 一起转走(完整版 6.4)。(2026-10-20 从主线挪到备答:可靠性的事,不是本节主线)
🛠 GPU 老兵「座位只多两成,吞吐怎么涨了五成多?」→ 原记录没拆原因,只有两条读数能摆:decode 自报峰值几乎没动(11,851 → 12,063),涨的是端到端;十四台 prefill 一直在喂,座位一空出来就有人坐。别说成「算力利用率多了五成」,也别现场编更多因果。
🛠 GPU 老兵「铺了大 EP,是不是就不用九千多并发了?128 张卡就是九百?」→ 全局要的 token 数不变,EP 只是把它摊到各卡。按完整版 H100 每个专家约 300 行:300 × 256 ÷ 8 ≈ 9,600 个 token 一步;每卡要坐的人 ≈ 9,600 ÷ 卡数。32 张卡、每卡 8 个专家,每卡约 300 人;128 张卡、每卡 2 个专家,每卡约 75 人,不是九百(本课推导,不算冗余专家)。省下的是每卡要读的专家权重。巧的是 32 卡、每卡约 300 人,跟第一节那条线差不多重合,但硬件口径不同,别当成「同时过线」报。
💰 管预算的「几个高端用户、并发很小、每人要非常快,用 TEP 还是 DEP?」→ TEP(注意力走 TP),再开投机。人少时一步几乎全花在读权重上:TP 按头把注意力和稠密层权重切开,各卡读一份、一起读完同一步,等于几张卡的带宽合起来服务同一批人;DEP 每卡自备整份注意力权重,一个人的注意力只在一张卡上算,人少时单人不变快(本课的解释)。TP 复印笔记的代价只在人多时咬人:完整版 6.2 TPU 那组,并发 512 时 DEP 领先六成多,并发 64、decode 为主那条打平。TP 的天花板是每层那次加总,数据小、卡在延迟,卡数翻倍不减半,所以别切出 NVLink/ICI 域,头数要能被卡数整除。人少算力闲,投机验证几乎白送(量级见第七节备答 TensorRT-LLM 那组)。但投机不只属于低并发:本节 V4-Pro 那组(GB300、vLLM)两边都开着 DSpark(每步猜 7 个),实测最高吞吐正是 DSpark + dep8(并发 1,536,65,132 tok/s);那组没跑关掉 DSpark 的对照,DSpark 占多少说不出。会翻车的是固定猜几个的 MTP:B200 上 V4-Flash 用 DEP8 开 MTP,十档并发全变慢(第七节);DSpark 忙时少验、闲时多验,所以能和 DEP 叠(本课的解释)。部署上按档分池:高端池 TP + 投机、单价高;批量池 DEP + 大 EP(投机用 DSpark 这类自适应的照样开),即第二节那条线的左右两头。

第五节 长上下文:DCP 和 PCP 有啥区别?(10′)计划 10′ · 含互动 8.8′

🖥 本节主屏:课件 第五节 长上下文:DCP 和 PCP 有啥区别? · 主图 anim-whomoves

🎯 这一节只留一句:分卡之后谁小搬谁。PCP 搬笔记,买到首字早;DCP 搬提问,买到装得下,长上下文才净赚。

「先想一个场景:一个 agent 一下甩过来十二万八千字的上下文,差不多一本中篇小说。马上出两件事。
第一,第一个字要等很久,模型得先把这本小说从头读一遍。第二,车上坐不下:上一节 K3 退回了 TP,每人的笔记被复印好几份,这么长的笔记,显存装不了几本。
一个慢,一个挤。这一节两招,一招治一个。可两招其实是同一个动作:把这本小说按字切成几段,分给几张卡。差别只在一件事:谁搬家。」

🖥 屏幕:停在「名字别按字母记」框。

「两招叫 PCP 和 DCP,P 是 prefill,D 是 decode,按最常用的阶段起名。可机制本身不绑阶段,Meta 那篇百万字推理的论文就按谁在搬起名:一个传笔记,一个传提问。所以咱们只记谁搬家。」

🖥 屏幕:滚到「谁搬家」,停在 anim-whomoves。先取消勾选「连续播放」,点「⟲ 重来」回到开头,再点「开始」,等它第一次自己停住,先指卡 0 到卡 2 上的灰框。

「为什么总得有人搬?回想注意力在干嘛:每个新字拿着一个提问,去前面所有字的笔记里查一遍,打分、加权平均。
每张卡只存自己那段笔记,提问在这张卡、笔记在那张卡,就查不了。要么传笔记,要么传提问。诀窍就一句:谁小,传谁。」

「先看读题,也就是 prefill。好比小组考试:一本书的题分给四个人,每人一段,可每道题都可能要查前面全书的笔记。
题目几千道,笔记也几千行,条数一样多。可比一比每一条多厚:一道题的提问,每个头都要一份,V3 有一百二十八个头;笔记在 MLA 里只有一条共用的摘要。一个字的提问比它那行笔记厚几十倍。所以搬笔记。」

🖥 屏幕:连点三次「下一步」,每站停住时,先指卡 0 里那段刚绕回来、已经变暗的笔记(路过不查),再指其余卡上新亮起的绿格。

「四个人围成一圈,笔记一册一册往下传。每人接到一册查一册,查的时候下一册已经在路上,搬家的时间藏在查的后面。
这就是 PCP:提问不动,笔记传阅,几个人一起读,第一个字早出来。早多少?Meta 把一百万字分给一百多张卡一起读,七十七秒读完。」

💬 互动:点「下一步」进 DCP 之前问「换成写字:每步只有一个新字,只剩一个提问。可前面躺着十二万多行笔记,分在八张卡上。要搬,你搬哪个?」停五秒,等人喊。期望答案:搬那一个提问。

「对,搬那一个提问。笔记按字轮流存在八张卡上,谁也不动;每一步把这个提问复印八份发下去,每张卡查自己那一册,查完交回来汇总。这就是 DCP。」

🖥 屏幕:点「下一步」看提问飞进四张卡(图上画四张,当八张看),再点一次看分子、分母在终点拼。

「答案怎么拼有个讲究:每张卡交上来的是分子和分母,先别除,加总以后只除一次;把几个平均数直接再平均就错了。PCP 在环上每收一册合一次,DCP 在终点合一次,同一招。」

🖥 屏幕:滚到「同样切八份,买到的不一样」,停在 fig-s7-kv-dup-t5,先指上排八根一样高的条:一根绿,七根红。

「DCP 买到什么?第一节说过,写字卡在搬。MLA 一层只有一个笔记头,TP8 八张卡每张存一整份,七份是复印件,每一步还把同一份各读一遍。
DCP 把复印件变成分册:每张只存八分之一,也只读八分之一。V3 一个 128K 的请求,每卡从八 GiB 多降到一 GiB 出头。」

「搬家有路费:每一层都要多一趟,发提问、收分子分母。
K3 一个人用,输入越拉越长,TP8 每个字越来越慢,DCP8 几乎不涨,读笔记确实分摊了。可 DCP8 起点就高了四毫秒左右。」

「这四毫秒去哪了?TP8 每出一个字,八张卡之间要对一百多次账,每次只是一小笔,拼的是等。有个开关叫 symm-mem:八张卡在显存里各留一块一模一样的区域,互相直接往对方那块里写,省掉来回握手。一个人用时,它值三成五。」

「可 SGLang 在 K3 上一开 DCP,就强制把它关掉,原因是会让 decode 录好的那张 CUDA Graph 算错。DCP 起点高出的那四毫秒,基本就是丢了这个开关。所以 K3 上它主要赚的是装得下。」

🖥 屏幕:滚到「DCP 什么时候赚」,先别露 fig-s7-dcp-gain。

「那什么时候开?看笔记装不装得下,笔记总量就是长度乘人数。」

💬 互动:问「4K 输入、八个人用的客服,开不开 DCP8?换成 128K 的 agent 长对话呢?」停一下再露图。期望答案:4K 不开,装得下,开了白付路费;128K 开,不开就排长队。

「先看 128K 那个高点。K3、八个人同时用,TP8 装不下,有人只能在门外排队,首字要等半分钟;开 DCP8 全装下,两秒出头,吞吐翻到三倍多。
再看最左边 4K。笔记本来装得下,DCP 只剩路费,四个点全在线下面。」

「最后一条:DCP 只管注意力那一半。它叠在注意力的 TP 上,卡还是那几张,只是把复印件改成分册;专家那边照旧,开 EP 也行,所以常见写法是 TEP 加 DCP。
不能配的是 DEP:DCP 的路数从注意力 TP 那组卡里借,DEP 注意力那边每组只有一张卡,没得借。K3 正是 DEP 起不来、注意力退回 TP,才用得上它。」

🖥 屏幕:停在绿框「这一节带走」。

「这一节带走一句:谁小搬谁。读题搬笔记,叫 PCP,买首字早;写字搬提问,叫 DCP,买装得下,长输入、人多才净赚,短输入反而亏。
可读题和写字还挤在同一批卡上,互相抢。下一节:把它们拆到两批卡上,明明要多搬一趟笔记,凭什么接的人更多?」

⚠️ 这一节最容易跑偏的地方⚠️ 108 → 365 tok/s(+237%,口播统一说「三倍多」)的口径是 K3、GB300、SGLang、TP8 跨 2 节点、128K 输入 1K 输出、并发 8,TP8 取调过参的最好一档;「三倍多」是本课按两个数算的。别说成「DCP 快三倍」:4K 四档并发全亏,并发 1 亏 26%(正好等于丢掉 symm-mem 的损失)。
⚠️ 「谁小搬谁」是本课给的直觉。Meta 原文选传 KV 还是传 Q,判据是通信能不能藏进注意力计算:新 token 占比低于约 3.25% 才换传 Q。被老兵追问就这么答。
⚠️ 「提问发到每张卡」说的是 DCP 每张卡都要拿到这一步的 Q,收齐提问、交换分母、合并结果都是多出的通信(vLLM 默认后端每层 3 次)。
⚠️ 8.58 → 1.07 GiB(口播「八 GiB 多 → 一 GiB 出头」)是 V3 一个 128K 请求的纸面账(每 token 70,272 字节)。「TP8 装不下」:TP8 默认配置、不开投机只装得下约 79 万 token(实测),128K × 8 = 100 多万是本课推导。
⚠️ Meta 的 77 秒是 128 张 H100(口播「一百多张卡」)、Llama3 405B、1M token prefill。课件另有「1 到 8 台翻倍约减半,8 → 16 台只降约 35%」,口播不报;被问「是不是越切越快」就答这一句,别说成一直线性。
⚠️ 线性注意力状态接力、HiCache 冲突、Ring 和 Ulysses、7.3 并排显存账本节都不展开,被问指向完整版第七节。
⚠️ 「首字要等半分钟、两秒出头」是 128K、并发 8 时首字中位数:TP8 调得最好的一档 32.1 s(默认档 39.3 s)对 DCP8 2.3 s,含排队。官方另说 DCP8 把整组卡能存的 KV 从 1.5M token 撑到 12.2M。
⚠️ K3 自己的 KDA 状态池 DCP 不切,DCP 只拆 MLA 层的笔记。
⚠️ 「名字按阶段起」:DCP/PCP 是推理框架里的叫法(SGLang 参数叫 --dcp-size)。Meta 论文(arXiv 2411.01783)叫 pass-KV/pass-Q,完整 prefill 用 pass-KV,decode 和缓存命中高的 partial prefill 用 pass-Q;NVIDIA Helix 论文管后一派叫 KV 并行(KVP)。
⚠️ 「越拉越长、几乎不涨、起点高一截」那组数:K3、SGLang、并发 1,TP8 每 token 4K 11.1 ms → 128K 12.0 ms;DCP8 15.2 → 15.3 ms。4K 时关掉 symm-mem 的 TP8 是 15.1 ms,所以 DCP8 起点高的约 4 ms 基本是 symm-mem 被强制关掉的损失(本课按两行数推的)。官方大规模预设说开 DCP8「并发上限 +72%,引擎吞吐不变,ITL ×1.8」。别说成「DCP 让每个字更快」。
⚠️ 10-22 试讲后改写:symm-mem(symmetric memory)=各卡在显存里留同形的一块、可直接写对方那块,给小消息 all-reduce 省握手;K3 bs=1 开它 +35%(87.8 对 64.9 tok/s,runbook §11.2);「一百多次」= 93 层 × 每层至少 2 次 all-reduce ≈ 186(runbook §11.0.4 的推算);DCP 时强制关是 SGLang 对 K3 的模型设置(原文「due to decode CUDA graph correctness issues」),不是 DCP 机制上做不到,被问别说成「DCP 都不能开」。「四毫秒基本是它」是本课按两行数推,别说成「全是」。
⚠️ 「提问比笔记厚几十倍」:V3 每个字的提问 128 头 × 192 维 = 24,576,MLA 笔记一行 512+64 = 576,约 43 倍(本课推导);吸收写法下提问是 128 × 576,约 128 倍。q_lora_rank 1536 不是参与比对的提问,只是投影中间那层瓶颈。
⚠️ 「吞吐翻到三倍多」从带走句挪进 128K 那段,正文先讲再带走。
❓ 台下可能问(备答,不计地板)
🧑‍🎓 新人「为什么不能直接把几个平均数再平均?」→ 点开「想看算术」折叠:卡 0 拿两个字,24 ÷ 3 = 8;卡 1 拿一个,20 ÷ 1 = 20。再平均得 14 是错的,卡 1 只有一个字却占了半票;分子加分子、分母加分母,44 ÷ 4 = 11 才对。分母是这几个字的权重和,不是字数。(2026-10-22 试讲后从主线互动挪到折叠和备答)
🛠 GPU 老兵「MLA 的提问不是先压到 1536 维吗?DCP 为什么不传压缩的,到了再解压?」→ 能传,但划不来。解压要用那块展开矩阵,按 TP 每张卡只存自己那几个头的八分之一;各卡自己解压全部头,就得每张卡存一整块、每步整块读一遍,每层多读约四千万个参数,换来少传一百多 KB 的提问。decode 卡在读,车上不到约三百个 token 时传提问更便宜(本课按 V3 形状推);八张卡还把解压重复算八遍。SGLang 的做法是各卡算自己那几个头的提问,再在 DCP 组里 all-gather。另外就算按 1536 比,笔记 576 也还是小的那个,PCP 搬笔记的结论不变。(2026-10-22 试讲追问后补)
🛠 GPU 老兵「4K 亏多少?长度一样,人数会改结论吗?」→ 4K 四档并发全亏,最多 −26%;同是 8K,并发 8 亏 11%、并发 32 赚 24%,所以看笔记总量不单看长度(课件「DCP 什么时候赚」那几条,从口播挪来)。
🛠 GPU 老兵「DCP 的完整拓扑怎么写?」→ TEP + DCP:注意力先按头切(TP),再把复印件改成分册;专家照旧按 EP 分(从口播挪来)。
🛠 GPU 老兵「上下文多长,注意力算得比专家多?」→ Qwen3.5-397B 全模型 decode 约 34K、prefill 约 68K(本课推导,课件「不看算力交叉点」那条);单看一层全注意力是 8.4K/16.9K。开不开 DCP 不看这个,看笔记放不放得下。
🛠 GPU 老兵「PCP 出错会报错吗?」→ 往往不报。某张卡漏收别段的 KV,照样通顺,只是跟不切时不一样;算得少反而更快,快得反常先核输出。线性注意力层带着随 token 滚动的状态,每段从零起步就全错,得接力传状态。(2026-10-20 试讲后从主线挪到备答:排错细节,不是本节主线)
🛠 GPU 老兵「DCP 也是八卡并行算注意力,不也加速吗?怎么只说省地方?」→ 对,两样都给。跟 TP 比:MLA 只有一个笔记头,TP8 每张卡每步把整份笔记各读一遍;DCP8 每张卡只读八分之一,读笔记的时间分摊了。代价是每层多一轮通信(收齐提问、交换分母、合并结果),K3 上还得关 symm-mem。实测并发 1 时 DCP8 每字 15.3 ms 对 TP8 12.0 ms,但从 4K 到 128K,DCP8 只涨 0.1 ms、TP8 涨 0.9 ms。读笔记占比越大(越长、注意力层越多),加速那一面越显出来;K3 只有 24 层 MLA,净账主要赚在装得下。
🧑‍🎓 新人「DCP 只能用在 decode、PCP 只能用在 prefill 吗?」→ 不是,名字只是按最常用的阶段起的。判据是谁小:Meta 在缓存前缀很长、新输入很短的 prefill 里也传提问。
🧑‍🎓 新人「那 PCP 也是切 KV 吗?」→ 是。两招切法一样,都按 token 切,每张卡存自己那段的 KV;prefill 时提问也长,所以提问跟着一起切,decode 只有一个提问切不了。区别只在传 KV 还是传 Q(Meta 的 pass-KV/pass-Q 就是同一种切法、两种传法)。细节差别:Meta 为了因果三角负载均衡把序列切成 2N 块首尾配对,DCP 按 token 轮流放。
🛠 GPU 老兵「不都是一开八吗,哪个要加卡?」→ 对,两招都是一切八份,「加不加卡」不是机制区别,是部署习惯:SGLang 的 DCP8 叠在原来那组 TP8 上(拓扑写作 TP8+DCP8),卡还是那八张;Meta 的 CP 是在每台 TP8 之外再叠一维,128 张卡=16 台 × 8。所以台上不讲加卡,讲各自买到什么。
🛠 GPU 老兵「DCP 能开几路?」→ 最多 TP 路数 ÷ KV 头数;DEP 的 TP 是 1,所以叠不上。
🛠 GPU 老兵「DEP 下一个长请求的笔记全在一张卡上,不正该切吗?」→ 叠不上是现在的做法:完整版 7.3 给的约束是「度数最多 TP ÷ KV 头数」,SGLang 的 DCP 借的是注意力 TP 那组卡(TP8+DCP8 还是那八张),DEP 的 TP 是 1 就开不了;Meta 的 CP 是跨机器叠的另一维(完整版 7.2 拿两台 CP2 对 TP16,本课读法)。完整版第七节没给 DEP 再叠一维 CP 的实测,台上别说能还是不能。(原口播「没东西可拆」说过头)
🛠 GPU 老兵「开了 DCP,专家那边开什么 EP?」→ TEP。DCP 叠在注意力的 TP 上、用同一组卡,专家照旧按 EP 分(完整版 7.3 表里写作 TEP16 + DCP16)。DEP 的长上下文难处不是复印,是每卡一整份注意力权重和状态,DCP 帮不上。
🛠 GPU 老兵「每层多出的三次通信分别是什么?」→ vLLM 默认后端(dcp_comm_backend="ag_rs"):① all-gather 提问:权重按头切,每卡只投影出自己那份头,可本地那段 KV 所有头都要查,先收齐全部头的 Q;② all-gather LSE:kernel 在本地已经除过分母,但留下 log-sum-exp(每人每头一个数,很轻),收齐后各卡算出自己该占的比例,缩放局部结果;③ reduce-scatter 输出:相加得完整结果,按头分回各卡,接上按头切的输出投影。所以「先别除」是课堂说法,实现是「除了,但把分母记着」。代价主要是等不是量:V3 61 层 MLA × 3 = 每个 token 多 183 次集合通信,K3 24 层 × 3 = 72 次(本课按层数乘)。两个现成省法:a2a 后端把 ②③ 合成一次 all-to-all,源码注释写 MLA 每层 3 次降到 2 次;dcp_q_replicate 每卡放一整份提问投影,省掉 ①,代价是重复算投影。两者没有公开实测,台上别报快多少。(出处:vLLM 主干 vllm/config/parallel.py、vllm/v1/attention/ops/dcp.py,2026-10-17 版)
🛠 GPU 老兵「PCP 不是也要合吗,怎么说不用拼?」→ 不用跨卡拼。Ring 在每张卡上边收边按「先别除」合,DCP 在终点合,是同一招。
🛠 GPU 老兵「93% 并行效率,跟 8 到 16 台只降 35% 矛盾吗?」→ 两个数 L300 都有(1M token 77 s、效率 93%;128K 8 台 5.85 s、16 台 3.8 s),但 93% 在哪个长度、哪几个卡数之间算的,原文没写清,台上别硬答。
🛠 GPU 老兵「DCP 能和 HiCache、投机一起开吗?」→ HiCache 开 L3(远端存储),或 L1+L2 叠投机,就得退回纯 TP。
🛠 GPU 老兵「PD 分离时 decode 用 DCP 更好吗?」→ 官方数反而 TP8 略高:1P1D decode TP8 2,808 tok/s,2P2D decode DCP8 2,633;分母和输入长度官方没写,不能和本节的数比。
🛠 GPU 老兵「为什么 4K 并发 1 正好亏 26%?」→ 正好等于关掉 symm-mem 的损失:开 DCP 时 SGLang 对 K3 把 symm-mem 强制关掉(模型设置,不是 DCP 机制上用不了)。
🧑‍🎓 新人「笔记为什么按字轮流放,不前一半后一半?」→ 新字不停地写进来,轮流放各卡才能一直一样多(本课的解释)。

第六节 PD 分离:多搬一趟 KV,凭什么接的人更多?(9′)计划 9′ · 含互动 9.2′

🖥 本节主屏:课件 第六节 PD 分离:多搬一趟 KV,凭什么接的人更多? · 主图 fig-s9-pd-ratio-t5

🎯 这一节只留一句:PD 分离不让 decode 少搬,只让它不被打断;两边各按自己的上限开批,所以多递一趟料(KV),接的人反而更多。

「上一节留了个洞:读题和写字还挤在同一批卡上。每张卡装的人越多,一个长 prompt 进门,耽误的人也越多。
这一节的办法是拆:两种活分到两批机器上。第零节说过有一招不碰那一趟,就是它。代价是每个请求多搬一趟 KV。多搬一趟,凭什么接的人反而更多?」

🖥 屏幕:滚到「两种活互相拖」,停在 anim-pdsplit,等它播一圈;先指上组的红框,再指下组那支紫箭头。

「一格是一步。前四步 A、B、C 每步各出一个字,然后长 prompt 来了,橙色占五格。
上组混在一起:它占住整台机器,红框里五格一个字都没出。下组拆开:prefill 在自己机器上算,出字那台一格不断。代价就是那支紫箭头,传一趟 KV。」

🖥 屏幕:停在「一个厨房:备菜和出菜」框。

「换回专题五那个厨房:读题是备菜,整段 prompt 一次备完;写字是出菜,一盘一盘往外端,一次多端几盘才划算。
来一桌大单,备菜占住灶台好几分钟,所有桌干等。真饭馆没有让一个灶台又备菜又出菜的。拆开就是两个灶台,备好的料递过去一趟,那盘料就是 KV,前面那本笔记。」

「第二节那招,把长 prompt 切几段夹进去呢?那只是把大单拆成几小单,灶台还是两样活抢。
拆开不让出菜少搬,只保证它不被打断,才敢一次端满一托盘。」

🖥 屏幕:滚到「凭什么接的人更多:各按各的上限」,停在 fig-s9-pd-ratio-t5,先指上排七张卡,再指下排三张卡。

「看 DistServe 论文的例子。一张卡两样都做、守住延迟,每秒只接一点六个请求。拆开单干的卡快得多,数写在下排卡上。
按工作量摊,掺着做也该有三个多(本课推导),怎么才一点六?」

「差在「守住延迟」。它其实是两条:首字不能等太久,字与字之间不能卡。只数两条都守住的,行内叫 goodput,上桌凉了的不算。
一个灶台得同时防两头最坏的情况:大单一来,出菜就断。两头都防,只能少接单。」

💬 互动:指着下排问「prefill 卡一张接五点六个,decode 卡一张接十个。要接住每秒十个请求,最少几张卡,怎么配?」期望答案:三张,两张 prefill 配一张 decode。

「对,两边差不多同时忙满。混着做,七张卡才接十一个出头;现在三张接十个,每张卡接的人翻了一倍多。
多搬一趟不要紧,要紧的是两边都跑到自己的上限。」

🖥 屏幕:滚到「多搬的那一趟有多贵」,停在 fig-s8-kv-trip-t5,先指上面那根长条,再指中间那根三色细条(最下面那根是它放大十倍)。

「那多递的这一趟贵不贵?看我们在 TPU 上的 Qwen3-Coder:一个八千 token 的 prompt,备菜要一到两秒;递料按带宽算约一百毫秒,是个零头。
为什么这么少?TP 每层都要通信,只能挤机器里最快那圈线;递料一个请求才一次,走慢点的网也不碍事。」

🖥 屏幕:停在 fig-s8-prfaas,先指两根橙柱,再指两根绿柱。

「可单趟便宜,不等于总量便宜。一个备菜灶台每秒要递好多份料。同一条专线,普通模型料厚,只够并一两台 prefill;混合模型有些层只记近处、或只揣一张便条,料薄,能并十几二十台。
所以料薄的模型才敢把备菜间放到别的机房;料厚的,最好别让 KV 出 NVLink 域。」

🖥 屏幕:滚到「拆开之后:各怎么切、配几台、什么时候别拆」,停在「两边各怎么切」框,先指 prefill 那条,再指 decode 那条。

「拆开还有个好处:两个灶台可以各按各的脾气摆。看我们自己搭的 V4-Pro,两头都是 DEP,差在宽度和份数:
prefill 是十四个小组,每组一台机器四张卡,组和组不说话;decode 只有一个大组,横跨两台机器八张卡。」

「prefill 卡在算,一个长 prompt 自己就喂饱算力,不用凑人;组开小,跨机器的通信少,要接更多就多开几份。
decode 卡在搬,得凑一大批,专家权重读一遍才划算:EP 开宽,每个专家攒的人多;注意力走 DP,每人的笔记只存一份。好比很多个小灶台各自备菜,一条大流水线集中出菜。」

「第四节说写字那组再加宽反倒亏,就是这儿。我们试过宽到十六张卡,每一步的时间少了近一半;可备菜灶台少了两个,喂不饱,每张出菜卡反倒掉了四成。
宽了就得有人喂,所以配几个灶台得算。」

🖥 屏幕:往下停在「配比先算起点,再扫」那条。

「起点能算:decode 每秒送走多少请求,乘每个请求的输入长度,就是 prefill 每秒得吞多少字,再除以一台 prefill 吞得动多少。
可同一个 V4-Pro,公式、官方配方、实测扫出来,三个数都不一样。起点只是起点,还得扫到每张 decode 卡的输出不再涨为止。」

🖥 屏幕:停在 fig-s9-2p1d,先指左边每卡输出那格,再指右边首字那格。

「再多加一个灶台呢?看这张:每卡少了三成,可首字最慢的那批快了将近一半。
总输出为什么不涨?一个请求从发出到收完要一分多钟,首字省下的不到一秒,摊进去看不出。多一个灶台,买的是首字,不是吞吐。」

「也有不该拆的时候:客人少,两种活本来不打架,拆开就是白递一趟。TPU 上单并发拆开,首字慢成将近三倍,输出只多一成多。
别照搬别人的配比,拿自己的负载去量。」

🖥 屏幕:停在绿框「这一节带走」。

「这一节带走:不让 decode 少搬,只让它不被打断,两个灶台各按上限开。进步多少?Kimi 线上用的 Mooncake,比此前的系统多接一倍多的请求。
可拆不拆,decode 还是一步只出一个字。下一节:能不能一趟出好几个字?」

⚠️ 这一节最容易跑偏的地方⚠️ goodput 口播只给一句白话;完整定义在 L300 第二节:规定比例(如九成)的请求首字、字间隔都达标时,每张卡能扛的最大请求速率。
⚠️ 「多接一倍多」是 Mooncake FAST'25 正式版对此前系统:A800 多接 115%、H800 多接 107%。DistServe 的 7.4 倍是「最多」、口径是九成以上请求守住延迟时每卡能接的请求率,对 vLLM、DeepSpeed-MII;Splitwise 的 2.35 倍比的是同成本同功耗吞吐。三个数口径不同,别横比。
⚠️ 1.6/5.6/10 是 DistServe 论文的 OPT 13B、单张 A100 例子(专题五原图);「7 张约 11.2」「3 张 10 个」都按图上算。
⚠️ 一趟约 100 ms 是 Qwen3-Coder-480B(KV 比 V3 厚)、8K prompt、KV 约 1.04 GB、显存→内存→100 Gbps 网→对方显存的按带宽估算,不是计时,口播「零头」=只占 prefill 一到两秒的 5–10%;换 KV 大得多的模型要重算。「五秒多」是本课拿这 1.04 GB 按 V4-Pro 实测的 200 MB/s 换算的,不是 V4-Pro 自己的 KV。
⚠️ 「为什么混着做只有 1.6」:拆成首字、字距两条约束来讲,出处是 DistServe 摘要(已补进 L300 9.1 和 §十六台账)。「三个多」是 1 ÷ (1/5.6 + 1/10) ≈ 3.6,本课推导,只用来点出「不对劲」。
⚠️ 配比三个数(口播只说「三个数都不一样」):公式约 9.8、官方 8、实测扫出 14;8 卡 × 11,200 ÷ 1,024 ≈ 87.5 req/s,× 8,192 ≈ 71.7 万 tok/s,÷ 一个 prefill 7.28 万 ≈ 9.8(L300 9.1 的推算);官方配方 8 个,我们那套 SGLang runbook 早期自己扫出 14 个,14 → 16 每张 decode 卡只涨 2%。
⚠️ PrFaaS 那张:32K 输入、一台 8×H200 每秒外送的 KV;「够并几台」= ⌊100 ÷ 每台外送⌋,是 L300 的本课推导。
⚠️ 「一分多钟、不到一秒」:报告的平均端到端约 65 s,平均首字 2.40 → 1.73 s,省 0.67 s。
⚠️ 2P1D 那张:DeepSeek-V3、B200、SGLang+NIXL、并发 128;TTFT 是客户端测的、含排队;每卡 −31%、P99 TTFT −48%。
⚠️ 「慢成将近三倍、只多一成多」= 95 → 281 ms(≈2.96 倍)、输出 +12%;是 Qwen3-Coder、两台 v7x-8、1K 进 1K 出、单并发,中位数,单点测量。「输出只多 12%」指吞吐还是每字速度,L300 原文没写清,被问别展开;多出的 186 ms 花在哪,L300 也没拆,台上别编。
⚠️ 三层软件、两个搬运库在两个引擎上结论相反、混合模型尾巴、配比公式推算、AFD/EPD 本节都不展开,被问指向完整版第八、九节。
⚠️ 「两边各怎么切」:14 份 dep4 + 1 份 dep8、16 台 GB300,是我们自己的 SGLang 部署(L300 6.1);dep16 那次 TPOT 60 → 33 ms、每张 decode 卡 9,032 → 5,270(L300 6.1)。「prefill 卡在算所以组小、多份」「decode 卡在搬所以 EP 宽」是本课按第一、四节的机制讲的道理,不是 SGLang 原文的表述。SGLang 在 GB200 上的旁证见 L300 8.5。TEP+DCP、prefill 加 PCP 是推的配法,我们这套没用到,台上要说清。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「网络配错了会报错吗?上线前查什么?」→ 不报错,只是首字慢。vLLM 在 GB300 上跑 V4-Pro 踩过:配置漏了,KV 绕道主机内存,每秒约 200 MB,一趟 5 秒多,配对后快两个数量级。上线前先量 KV 传输带宽,再比字:temperature 设 0,拆与不拆逐 token 对,前几个就分叉多半是 bug,几百个后才分叉可能是浮点差。(2026-10-20 试讲后从主线挪到备答:排错细节,不是本节主线)
🧑‍🎓 新人「传的是权重还是 KV?」→ KV。权重两边各自常驻,每个请求只传它自己那份 KV。
🛠 GPU 老兵「NIXL 和 Mooncake 哪个好?」→ 别这么问,问这个引擎、这张网上哪条路通;共同点是同一个 NVLink 域里 KV 别出域(完整版 8.2)。
🛠 GPU 老兵「100 Gbps 太保守了吧?」→ 是保守估。换 GPU 网卡,A4X 400 Gbps 约 21 ms,GB300 800 Gbps 约 10 ms(L300 的本课推导)。
🛠 GPU 老兵「PD 的每卡数,分母算 prefill 卡吗?」→ 不少 PD 报告默认只除 decode 卡;把 prefill 卡也算进去,结论能翻。这就是第九节第二问。
🛠 GPU 老兵「混合模型拆 PD 有什么特别?」→ 不能让 decode 补算尾巴,递归状态会把那几个 token 吃两遍,所以要全传;Qwen3.5 每请求搬约 349 MB。
🛠 GPU 老兵「KV 拉取失败怎么办?」→ vLLM 的失败策略设 fail,一次瞬时拒收引擎就死;设 recompute 稳,但约交 17% 的税(12 个 prefill 时每卡 3,187 → 2,645)。

第七节 投机解码:怎么一趟出好几个字?(11′)计划 11′ · 含互动 8.6′

🖥 本节主屏:课件 第七节 投机解码:怎么一趟出好几个字? · 主图 anim-spec

🎯 这一节只留一句:搬一趟权重,猜对几个就出几个;人一多,白送的就没了。草稿离大模型越来越近,EAGLE 和 MTP 差在谁训。

「上一节留了个洞:拆不拆,decode 都一步只出一个字,每个字都把权重搬一趟。
要每人出字快,batch 就开不大;推理模型又一答几千字。能不能搬一趟,出好几个字?」

🖥 屏幕:滚到「先猜后验:猜对白赚,猜错只亏一点」,停在 anim-spec。先取消勾选「连续播放」,点「⟲ 重来」回到开头,再点「开始」,等它第一次自己停住再开口。

「已经写到床前明月。小模型一口气猜四个字,四小格紫色,很快。大模型搬一趟,一大格灰色,把这几个位置一起算了。
从左往右比:前两个对,第三个错。错的那格换成大模型自己的字,后面全扔。搬一趟,出三个字。」

🖥 屏幕:点「下一步」,等第二次停住;讲完重新勾上「连续播放」。

「第二步四个全对,最后一格大模型顺手也算了,白送一个,出五个。」

💬 互动:问「要是小模型四个全猜错,这一趟出几个字?」期望答案:一个,跟不开一样多。

「对。碰到第一个错就停,猜对几个出几个,再加大模型自己那一个,最差也出一个。」

🖥 屏幕:停在「徒弟打草稿,师傅一次批」框,再往下停在 fig-s11-bytes,指右边两根时间条。

「换个比方:小模型是徒弟打草稿,大模型是师傅一次批。徒弟摆好的字是现成的输入,师傅像读 prompt 一样一遍读完。
人少时,一步的时间都花在搬权重上,稠密模型批五个字跟写一个字都只搬一趟:车反正要开。
MoE 没这么便宜,每个位置挑自己的专家,多验几个就多读几批。K3 就是 MoE,开了投机,一趟慢了四成多。」

「随机采样时,徒弟抽的字跟师傅抽的对不上怎么办?不比字,比把握:师傅对这个字的把握不比徒弟低就收,低了按比例收。
数学上保证跟大模型自己写没差别,只改速度,不改答案。」

「账是一个除法:每步出几个字,除以一步慢几倍。K3 八张卡一个人用,一趟带回将近七个字,扣掉一趟慢的那四成多,每个字快到四点八倍。
这是关掉随机、每次挑最大那个字测的,偏乐观:一开随机,就得按把握比例收,收下的少。官方按正常采样给的参考也低一截。」

🖥 屏幕:滚到「人一多就不灵」,停在 fig-s11-conc,从最左那根绿柱往右指到第四根(并发 64);最右那根紫柱不讲(那是拉长上下文,留给备答)。

💬 互动:指着柱子问「一个人用快四倍多,六十四个人一起用,还剩几倍?」听两三个数,停五秒。期望答案:一点七倍出头,还赚,赚得少了。

「还赚,可赚得少了。白送的前提是算力闲着。
六十四个人,每人一趟验七八个位置,一趟就是四五百行,算力不再闲着,草稿里每个字都得真算。草稿自己还占显存,存笔记的池子少了将近两成。」

「更极端的是为大 batch 配的 DEP:八张 B200 开模型自带的草稿,十档并发全部变慢。
所以先开在人少、每人要很快出字的那一档;大 batch 的部署先实测。」

🖥 屏幕:滚到「草稿从哪来:离大模型越来越近」,停在 fig-s11-tree,沿时间轴从左往右扫。

「草稿从哪来?这条线就一件事:离大模型越来越近。
最早另找一个小模型。后来草稿长到大模型身上:EAGLE 偷看大模型吐字前手里那串数,就是「我想说什么」,照着猜。
再后来 DeepSeek 把草稿训进主模型,叫 MTP。二〇二五年的 EAGLE-3,SGLang、vLLM 都已经合进去了。」

「图上没画的最新一步,是一趟出一整块草稿,快,可块里每一格看不见前一格选了哪个字。
DeepSeek 线上原来只开一步的 MTP,就被这一路的 DSpark 替下了。它补了两刀。」

🖥 屏幕:往下滚过折叠着的 DSpark 实测数据(不点开),停在 anim-dspark-draft,让它连续播放;讲第二刀时滚到 anim-dspark-sched。

「第一刀补草稿。「Yes,」后面可以接 of course,也可以接 no problem。第二格看不见第一格选了 of 还是 no,两种说法各押一半,就可能拼出「of problem」。加一个很轻的小头,从左往右看一眼前一格,拼串就没了,几乎不加时间。
第二刀补验证。给每一格估个把握:机器闲就多验,忙就少验,没把握的字不占名额。人不多时,每人能验到四到六个。」

🖥 屏幕:滚到「EAGLE 和 MTP:长得一样,差在谁训」,停在 fig-s11-eagle,先指图例的橙、蓝两色;讲连猜时指右下的灰柱、绿柱。

「先纠一个常见误会:EAGLE 不是免训练,只是训得少。
大模型冻住,入口和出口那两层直接借,只训中间橙色一小段。给 70B 配的这块不到 1B 参数,一台 A100 服务器一两天。」

「MTP 结构跟它几乎一样,差在谁训:MTP 是厂家预训练时一起训,随模型发布;EAGLE 是发布以后,谁都能外挂上去训。
那一层 MTP 能连猜好几个吗?原版只练过猜一步,硬让它连猜,第三个位置几乎全错;按连猜微调过,还能收下三成多。所以想多猜几步,草稿得按连猜练过。」

🖥 屏幕:停在绿框「这一节带走」。

「这一节带走:搬一趟权重,猜对几个出几个,最差也出一个。K3 一个人用,每个字快到四点八倍;六十四个人用,剩一点七倍。
人一多投机就帮得少了,每一趟还是那么重。下一节换一根杠杆:把货变轻。」

⚠️ 这一节最容易跑偏的地方⚠️ 4.81 倍和 4.22 倍别混:前者是每字间隔(K3、GB300、8 卡、单人),后者是端到端吞吐、含首字时间;64 人那档 1.74 倍也是吞吐口径。一趟约 16 ms 是本课反推(2.31 × 6.96),台上说「慢了不到一半」。
⚠️ B200 那组(V4-Flash、vLLM、DEP8 开 MTP,−3% 到 −37%)是 EP 加 DP 的高吞吐配法,结论不能搬到只用 TP 的低延迟配法。
⚠️ 温度那组:V4-Pro、GB300、草稿是贪心的 DSpark,4K 进 1K 出、并发 256;接受率 1.16% 对 34%,吞吐 944 对 2,911 tok/s(3.1 倍)。1.16% 低于理论值的原因(每步猜 7 个、第一个被拒后面作废)是本课推导,本节不展开。
⚠️ 草稿谱系各家倍数口径不同,不能横比;被问 EAGLE 2.7–3.5 倍、EAGLE-3 最多 6.5 倍(batch 64 吞吐 1.38 倍)时说清各自对的是不投机、在自己的模型上测。
⚠️ EAGLE 训练量:70B 可训参数 0.99B、6.8 万条 ShareGPT、A100 服务器 1–2 天(EAGLE 论文)。MiMo-7B 连猜 70%/10%/近零(2%)→ FastMTP 81%/56%/36%、平均 2.03 倍。
⚠️ 一趟 11.1 → 16.1 ms(1.45 倍)是 K3、GB300、bs=1 的时间账;L300 注明这 1.45 倍不能全归给多读的专家。左图 V3「验 8 个 = 验 1 个的 4.4 倍」是均匀路由的本课推导,偏高。
⚠️ 6.96、4.81 倍是 SGLang、temperature 0、random 数据集、block 7(偏乐观;6.96 离理论最大接受长度多近,L300 没写,别说「贴着上限」);4.73/2.61 是 vLLM K3 runbook 里官方温度 1.0、top-p 0.95 的参考接受长度。两组引擎不同,别直接相除。
⚠️ 口播删掉「跟第一节那条算力线一个量级」(硬件、模型都不同,老兵会抓),L300 原话只是「工位先忙满」。「六十四人 × 七八个位置 ≈ 四五百行」是本课推导,只取量级:K3 草稿块 7 个,加大模型自己那一位共 8 个位置,64 × 7 = 448、64 × 8 = 512;第一节那条线约 313–343 行,是 v7 上按稠密权重算的,K3 跑在 GB300 上、又是 MoE(每个专家分到的行少得多),不是同一条线,别说「已经过线」。
⚠️ KV 池 787,504 → 637,504 token(−19.0%,口播说「将近两成」),K3 开 DSpark。B200 那组并发 1 也慢 12%,原因原文没给。
⚠️ 「对不上按两边概率的差重新抽」是标准拒绝采样(投机采样)的做法;台上只说到这一层。
⚠️ DSpark:DeepSeek 2026-07,以 DFlash 为骨干,补顺序小头+按存活概率和负载定验几个;V4 预览版上线两周后替下 MTP-1(每次验 2 个字)。V4-Flash 并发不到 200 时每请求验约 4–6 个。
⚠️ DSpark 数据图(DSpark 论文 arXiv 2607.05147):左图 Qwen3-4B 逐位接受率,正文只给了数,0.74、0.63、0.78 是「块里更靠后」处,论文没写是第几位,别说「最后一位」;数学第一位 EAGLE-3 0.81、DFlash 0.88、DSpark 0.93。右图 Qwen3-8B 表 1,数学/代码/闲聊各三个基准平均,含大模型补的那 1 个字;九个基准平均正好复现正文的「比 DFlash 高 18.4%、比 EAGLE-3 高 26.7%」。
⚠️ 两支 DSpark 动画里的分数(of 55%、course 95% 等)、每格把握、吞吐表都是示意;「16–18%」(Qwen3 4B–14B 对 DFlash)、「batch 128 草稿 4–16 个只慢 0.2–1.3%」是论文实测;排队和「降了就停」照论文 Algorithm 1。线上版(论文 §5.2)去掉了「降了就停」、用两步之前的把握定总数,台上不展开,被问指向完整版 11.3。
⚠️ n-gram、PD 碰上投机掉出 CUDA Graph、max-running-requests 被重设成 48 本节不展开,被问指向完整版 11.3、11.4。
⚠️ 「一百个数随便抽,一百次才对上一次」是示意(Google 投机解码回顾博客的均匀分布反例),不是实测。「师傅把握不比徒弟低就收、低了按比例收」是接受概率 min(1, 大模型概率 ÷ 草稿概率) 的白话;贪心草稿押十成时,收下的概率就是大模型给这个字的概率(本课推导)。
⚠️ 口播压缩的口径:「关掉随机、每次挑最大那个字」=温度 0 贪心;「官方按正常采样给的参考低一截」=温度 1.0、top-p 0.95 的接受长度代码类 4.73、创作类 2.61(对 6.96);「几乎不加时间」=batch 128 草稿 4–16 个只慢 0.2–1.3%,换回每轮多收下 16–18%;「第三个位置几乎全错」=近零(2%),「三成多」=FastMTP 36%;「一趟慢了四成多」=11.1 → 16.1 ms。Medusa、DFlash 的名字口播不念,课件和图上有。
⚠️ 「扣掉一趟慢的那四成多」=6.96 ÷ 1.45 ≈ 4.8(本课按两数一除,只为口播接得上;台账里 4.81 = 11.1 ÷ 2.31 是两个实测每字间隔之比,16 ms 反倒是反推的 2.31 × 6.96,别说成「先量了一趟慢多少再算出四点八」);「一开随机就得按把握比例收,收下的少」只说方向,温度坑细节在备答;「只开一步的 MTP」去掉「敢」:为什么只开一步原文没给,别和后面 MiMo 连猜的数接因果;「帮得少了」而非「帮不上」:64 人仍有 1.74 倍,只有 DEP 那组全变慢。
❓ 台下可能问(备答,不计地板)
🧑‍🎓 新人「随机采样时,为什么不直接比两边抽的是不是同一个字?」→ 就像两人各从一百个数里随便抽,一百次才对上一次,可他俩想法明明一样,所以比把握不比字;退回的按两边概率的差重抽。温度零永远挑概率最大的字(贪心),温度一按概率掷骰子,V4-Pro 的服务端默认就是一。
🧑‍🎓 新人「DSpark 第二刀,为什么忙的时候闲聊只分到一个名额?」→ 闲聊第二格往后活下来的概率太低,放进去多半白验,不如让给写代码那行;动画里闲时 15 个候选收 14 个,忙时只放 7 个(示意)。
🧑‍🎓 新人「DFlash 一趟出一整块,块里是啥、怎么出的?」→ 一张填空卷。Qwen3 上一块 16 格:第一格是刚确认的那个字(上一轮师傅补的),后面 15 格放同一个占位符,就是空格。徒弟只有 5 层,入口出口两层借师傅的不训;师傅读前文时从浅到深挑 5 层的那串数,揉成一份「师傅在想什么」的笔记,在徒弟每一层当额外的 KV 塞进去(EAGLE-3 只喂在入口)。跑一趟,15 个空格互相看得见、都查这份笔记,同时填满。「扩散」就是填空,普通扩散模型要反复擦了重填,DFlash 只填一遍。训练照这个来:真实回答里随便挑一个字当第一格,后面 15 个盖住让它填。毛病也在「同时填」:空格互相看到的都是空格,不知道旁边最后填了啥,所以拼出「of problem」,越往块尾越不准。(DFlash 论文 arXiv 2602.06036 §4、§5:block size 16、LLaMA 3.1 为 10;5 层草稿、Qwen3 Coder 为 8;目标模型 5 层隐状态拼接后投影,注入每层草稿 KV;共享且冻结 embedding 和 LM head;单次前向;训练随机采 anchor。)
🛠 GPU 老兵「草稿抽法和温度对不上会怎样?」→ 贪心草稿每次押十成,温度 1.0 的大模型给哪个字都只几成把握,按比例收,大多退回。GB300 上压 V4-Pro,压测工具没发温度、服务端按默认 1.0,接受率 1.16%;发温度 0 接受率 34%,吞吐 3.1 倍。K3 的草稿按概率抽,温度 1.0 照样对得上。接受率掉了不报错,线上当一级指标告警。(2026-10-20 试讲后从主线挪到备答:属于配置错误,不是主线)
🧑‍🎓 新人「猜错了会不会比不开还慢?」→ 字数上不会,最差出一个;时间上可能,验证变慢又总猜错时就会,DEP 那组就是。
🛠 GPU 老兵「压测发温度 0 算不算作弊?」→ 不算,但两边要对齐,报数写明温度。
💰 管预算的「生产要不要开?」→ 低并发、要跟手的档先开;大 batch 部署先实测;开了就把接受率当一级指标告警。
🛠 GPU 老兵「贪心草稿碰温度 1.0,接受率怎么低到 1.16%?理论值没这么低。」→ 理论接受率是大模型给这个字的概率,会降但不归零;实测按「收下 ÷ 猜的」算,每步猜 7 个,第一个被拒后 6 个跟着作废(本课推导)。
🛠 GPU 老兵「接受率差近三十倍,吞吐才差三倍?」→ 吞吐看每趟平均多出几个字,不看接受率本身;接受率掉到 1% 时每趟还是至少出一个字。
🛠 GPU 老兵「拿温度 0 压出来的数,线上是不是虚高?」→ 看草稿怎么抽:贪心草稿碰上温度 1 的用户确实塌,所以 K3 那种按概率抽的草稿才适合线上;报数必写温度。
🛠 GPU 老兵「上下文变长为什么也缩?」→ 4K 时 4.22 倍,32K 只剩 1.32 倍。不开投机时每字间隔只从 11.1 涨到 11.4 ms,验证本不该因此变贵;更可能是接受长度掉了或草稿读长 KV 变慢,没实测,是推导。
🛠 GPU 老兵「MTP 猜几层最好?」→ TensorRT-LLM 8 张 B200 跑 R1,单用户 111 tok/s;开 1 层 198,3 层 253,5 层反降到 239。换了卡和模型,只当量级。
🛠 GPU 老兵「不想训草稿怎么办?」→ n-gram(Prompt Lookup):到提示词里找一样的片段照抄。vLLM 4 张 H100 跑 Llama 3 70B,摘要类最多 2.8 倍;同条件小草稿模型跑对话 1.5 倍。

第八节 量化:少搬字节,掉不掉点?(8′)计划 8′ · 含互动 8.1′

🖥 本节主屏:课件 第八节 量化:少搬字节,掉不掉点? · 主图 fig-s12-bytes

🎯 这一节只问一件事:少搬字节,掉不掉点?省:位数减半,一趟的下限减半;专家压到四位、注意力最多八位,整步省一半左右。掉:误差大多半路被消化,会放大误差的是 softmax,所以护着注意力;掉多少要实测。

「上一节最后说,人一多,投机就帮得少了。
第零节说过省钱两条路:一趟多坐人,或者少搬货。前面大多在多坐人,这一节换另一条:车不变,货变轻。
货一变轻,谁都会问:模型会不会变笨?这一节就答这个,分两半:省多少,掉不掉点。」

🖥 屏幕:滚到「位数减半,搬运下限减半」,停在 fig-s12-bytes,先指左边四根条从上往下。

「货变轻,就是权重少用几位存:十六位、八位、四位。为什么直接见效?第一节算过,人少时一步几乎全花在读权重上,字节少一半,一步的下限也少一半。
人多也一样:MoE 摊到每个专家头上只剩几行,照样是读权重说了算;省下的显存还能多放几本笔记。」

💬 互动:问「四位只有十六个格子。一组权重里最大的一千,最小的千分之一,怎么塞进去?」听几种说法,停五秒。期望答案:每一小组数配一个倍数,先除再存。

「对,这个倍数叫缩放。几个数共用一个,存时先除,读时乘回。为什么只让几个共用?一箱货里混进一根长钢管,尺子就按钢管定,小螺丝全量成零;组越小,尺子越贴身。缩放也占字节,所以四位不是正好再减一半。」

🖥 屏幕:滚到「专家压到 4 bit,注意力最多 8 bit」,指第一段三个参数数。

「那全都压到四位吗?先看货里装的是什么。gpt-oss 一百二十 B 的模型卡分开列了:专家几乎占了全部,注意力不到百分之一。OpenAI 只把专家压成四位,整个模型就装进一张卡。」

🖥 屏幕:下到 fig-s12-ledger,先只指最上面那根条;揭晓时从上往下扫三根,指着蓝段说「一动不动」。

💬 互动:问「专家从十六位压到四位,只剩四分之一。整步要读的字节,剩多少?」听两三个数,停五秒。期望答案:一半左右,不是四分之一。

「一半左右。看蓝的注意力,一动不动。按占地它不到百分之一,可 MoE 每个字只读几个专家,注意力每层整份读,专家一压,它就占了快四成。
那注意力为什么不也压到四位?占地太小,压了省不了多少;而且它最怕误差。这就到了下半个问题:掉不掉点。」

🖥 屏幕:滚到「掉不掉点」,先指「误差过四道关」那四条;讲到「掉多少」再往下到 fig-ppl,先指最右的红点,再指最左的灰点,最后指中间的绿点,再指下面两条。

「跟着一个误差走一趟:从某个权重被四舍五入,到最后出字,它要过四道关。
第一关,挪到平的地方。训练就是一路往错得少的地方走,训完的模型停在谷底,谷底大多是平的,权重挪一点,绝大多数方向不疼;GPTQ 就是把误差往平的方向推。
第二关,互相抵掉。四舍五入有进有舍,几千个数一加,大半抵消。怕的是那根长钢管,所以前面要分小组。」

「第三关,只看谁排第一。小噪声让每个词的分数都晃一点,只有前两名本来挨得很近才会换人。
第四关是放大器:softmax。常有人说 softmax 能把误差补回来,正相反,打分差一点,概率差的是指数倍。专家的输出直接加回去,误差一路是线性的;注意力打分、路由选专家都要过 softmax,所以要护着。有人把注意力计算直接压成八位整数,Llama2 做选择题掉到跟瞎猜差不多;同一篇先把离群值抹平,八位又几乎无损。
所以各家注意力最多放八位,还得专门处理。」

「误差能消化,不等于不掉点。量化是药三分毒,同样四位,掉多少看怎么压。平均分还会骗人:准确率没变,也可能是对变错、错变对正好抵掉。
图上是困惑度,大致是每个字在几个词里犹豫,越低越好。直接四舍五入的红点,离十六位的灰点远;多花心思挑尺子的绿点,往回挪了一半。」

「再往前一步,换专为四位设计的格式:按 NVIDIA 博客,R1 从八位压到 NVFP4,主要语言任务掉点在百分之一以内。
走得最远的,训练时就照着四位练:Kimi K2 Thinking 官方说「无损」,可没写跟什么精度比。所以听到「无损」,先问一句:跟谁比的?」

🖥 屏幕:滚到「KV 也能压」,先指上面几条,再下到 fig-kvq,指两根绿条都停在红虚线右边。

「最后,笔记也能压。上下文一长,大头是 KV。存成八位,改个开关的事;Kimi K3 的高吞吐配方列为必开,不开就装不下那么多人。
图上两个例子,一个存八位、一个直接存四位,绿条都停在红虚线右边,省不满一半:左边那个有一截本来就没压,右边那个多出来的是缩放。」

🖥 屏幕:停在绿框「这一节带走」。

「这一节带走:整步省一半左右;误差大多半路被消化,softmax 要护着,掉多少拿自己的基准实测。
进步多少?vLLM 给 Llama 3 70B 换八位,每字间隔最多降一半;gpt-oss 只压专家,一张卡装下。
招都讲完了。最后一节回到那一趟:拿到一个模型、一批卡,从哪下手。」

⚠️ 这一节最容易跑偏的地方⚠️ 口径:原来「压成八位就瞎猜 → 所以最多放八位」前后打架,补上 L300 12.1 已有的半句:SageAttention 先把 K 的离群值平滑掉,8 bit 端到端几乎无损。瞎猜那组是直接压、没处理离群值;「最多放八位」指注意力权重 FP8(V4、TPU 上 R1)。
⚠️ 口径:「做选择题掉到跟瞎猜差不多」=SageAttention 报告 Q、K、P、V 直接压 INT8 后 Llama2 的 MMLU 只剩 25.5%(四选一瞎猜就是 25%)。「平均分会骗人」从第三关挪到「掉多少看怎么压」那段,翻转出处不变
⚠️ 下限是本课推导的理想值:DeepSeek-V3、37B 激活参数、8 颗 TPU v7、一个人用、带宽跑满,只算权重,不含 KV、激活和通信;实际一步更慢。0.63 ms 是第一节单芯片 5 ms 的 1/8。
⚠️ vLLM FP8 那组:2 张 H100、2024-07,稠密 Llama 3 70B 每字间隔最多降到 1/2;MoE 的 Mixtral 8x7B 只到 1/1.6,被问再说,原文没给原因。
⚠️ gpt-oss-120b:专家 114.71B、注意力 0.96B、嵌入和输出层 1.16B,98% 是本课推导(114.71 ÷ 116.83)。整步 10.2→5.0 GB(BF16 专家→MXFP4 专家)也是本课按 config 推的,注意力、输出层按 BF16 算。
⚠️ 掉点只有「1% 以内」一档有出处(NVIDIA 博客,R1-0528,FP8→NVFP4,主要语言任务)。K2 Thinking「无损」没写对照精度;同卡 FP4 对 FP8 快多少,没有官方同条件的数,别现场估。
⚠️ FP8 KV 同显存 1.63 倍是 V3.2 布局的本课推导(1,284 ÷ 788 字节),不是通用倍数;NVFP4 KV 比 FP8 再省约一半、精度损失不到 1% 是 NVIDIA 博客口径。
⚠️ 「注意力快四成」是 fig-s12-ledger 的本课推导:MXFP4 专家时注意力 1.9 GB ÷ 合计 5.0 GB ≈ 38%。注意力不压到四位有两条理由:省不了多少地方(L300 原话)、它更怕误差(L300 第十二节「为什么压了不掉点」第四条)。注意力 FP8 的出处:DeepSeek-V4 模型卡「其余大多 FP8」,L300 记录的 TPU 上 R1 和 GLM-5.1 是专家 FP4、注意力 FP8。
⚠️ 「每个专家只剩几行」接第一节、第四节的 8 行(本课推导:256 × 8 ÷ 256)。
⚠️ AWQ:WikiText-2 困惑度,16 位 5.47、AWQ 4 bit 5.60、RTN 5.73(课件 l8-3 原数);「损失追回一半」本课推导:比十六位多出的困惑度 0.26 → 0.13。
⚠️ V3.2 的 1.63 倍:只算 MLA 是 1,152 ÷ 656 ≈ 1.76,加上每层 132 B 的 FP8 indexer key 降到 1,284 ÷ 788 ≈ 1.63(本课推导)。
⚠️ MXFP4 和 NVFP4 的缩放格式、R1 在 v7x-8 上 FP8 放不下、CUDA Graph 和 kernel 融合本节都不展开,被问指向完整版第十二节。
⚠️ 「长钢管」是示意:一组里一个特别大的数把共用缩放撑大,小数就被量成零(LLM.int8() 博客的离群值例子讲法);「组越小尺子越贴身」只说方向,组大小的具体数被问再说(MX 32、NVFP4 16)。困惑度「每个字在几个词里犹豫」只是直觉,不是严格等式。
⚠️ 「为什么压了不掉点」四条的出处全在 L300 第十二节正文和出处表:谷底平(AdaRound、Sagun 等、GPTQ);噪声抵消是本课解释,离群值见 LLM.int8()、Super Weight;翻转见 Dutta 等 2024;softmax 指数放大是本课推导,旁证 DeepSeek-V3(训练场景)、SageAttention(INT8 注意力 MMLU 25.5%,压的是注意力计算的 Q、K、P、V,不是权重)。别说成「softmax 能补精度」。
⚠️ 口径(「TPU v7 没有四位算力也照样快」挪回备答已有那条;K3 必开 FP8 KV 的「每组卡 128 个请求」只在课件;softmax 那道互动删了,误解在第四关口头纠正。主线改成「省多少/掉不掉点」两半,原数都在这里):DeepSeek-V3 八颗 v7 下限 0.63 ms 那段挪进备答;vLLM 那组是 2 张 H100;gpt-oss「专家几乎占了全部」=98%,「一张卡」=一张 80 GB 的卡;ledger 整步 10.2 → 5.0 GB 口播只说「一半左右」;AWQ 三个困惑度口播改成指图(红点=RTN 5.73、绿点=AWQ 5.60、灰点=十六位 5.47);K2 Thinking 低延迟模式约快 2 倍、基准只报了 INT4 的分,只在课件;KV 那张图:左 V3.2 BF16 → FP8 每 token 每层 1,284 → 788 字节(多出来的是没压的位置编码、新加的缩放、本来就是 FP8 的索引键),右 V4.1-Flash 主 KV 原生 FP4、比原先 FP8 小 45%(没缩满一半那截是缩放:FlashMLA README 每 token FP4 256 B 数据 + 32 B 缩放 = 288 B,FP8 512 + 16 = 528 B,本课推导;口播说「多出来的是缩放」。README 还写 FP4 只能用于 extra_k_cache,k_cache 那份仍是 FP8,被问别说整份 KV 都是 FP4)。「四道关」只是把原来的四条按误差的路径排顺,内容没变;「八位整数」=INT8。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「拿一个真模型算算,下限到底多少?」→ DeepSeek-V3 每字读 370 亿参数,8 颗 TPU v7 分着读,FP8 至少 0.63 ms,正好是第一节单芯片 5 ms 的八分之一(本课推导,只算权重、带宽跑满,实际更慢)。(从主线挪到备答)
🛠 GPU 老兵「量化后掉点,先查什么?」→ 两处尺子:① INT4 是 −8 到 7,存文件整体加 8,读时要减回去,Kimi K2.6 的记录里加载漏了这步,输出崩成重复乱词、照常出字不报错;② KV 只设 fp8 不校准,vLLM 缩放全取 1.0。量化后先看输出、跑基准再上线。(2026-10-20 试讲后从主线挪到备答:配置/加载错误,不是主线)
🛠 GPU 老兵「softmax 导数有界,怎么叫放大器?」→ 说的不是导数,是比例:打分差 δ,概率乘上 eδ(L300 12.1 第四条,本课推导,指数的性质),差一点就是成倍地偏;专家输出加回残差,误差按线性传。打分过 softmax、路由过 top-k,还可能直接换掉选中的那几个 token 或专家。
🧑‍🎓 新人「量化和投机能一起开吗?」→ 能,一个让每趟少搬,一个让一趟多出几个字,管的不是一件事。
🛠 GPU 老兵「TPU 没有 FP4 算力,FP4 有什么用?」→ 省的是从显存搬的字节和容量,片上解开很便宜;别说 FP4 在 TPU 上算得更快。
💰 管预算的「压到 4 bit 能省一半卡吗?」→ 看放不放得下和一步多快两件事;整步字节只省一半左右,掉点要拿自己的基准实测。
🛠 GPU 老兵「MXFP4 和 NVFP4 差在哪?」→ MX 每 32 个数共用一个 E8M0 缩放;NVFP4 每 16 个数一个 FP8 E4M3 缩放,另有每张量 FP32 二级缩放。NVIDIA 用 8B 混合模型训 1T token,loss 比 BF16 高:MXFP4 约 2.5%,NVFP4 约 1.5%。
🛠 GPU 老兵「R1 在 TPU 上为什么非 FP4 不可?」→ v7x-8 上 FP8 专家每 device 约 101.8,超过 94.75 的上限;FP4 约 60.9,连注意力约 70,装下了。单位混着:README 记 GB,94.75 是运行日志的 GiB(约 101.7 GB),不管按哪个读,FP8 都放不下。
🛠 GPU 老兵「INT4 和 FP4 是一回事吗?」→ 不是。FP4(E2M1)是浮点,0 附近密、远处疏;INT4 是 −8 到 7 等距。加 8 没减回去这个坑只有 INT4 有。
🛠 GPU 老兵「推理模型也这么扛压吗?」→ 不完全。2025 年有研究测推理模型:八位、权重四位激活十六位基本无损,再往下风险明显,模型越小、题越难掉得越多。长思维链连出几千个字,小翻转会累积(这条是本课推测)。
🧑‍🎓 新人「专家为什么比别的地方耐压?」→ MoQE(2023)实测专家层比稠密 FFN 耐压,二位专家照样可用,原文没给机理,别现场编。
🧑‍🎓 新人「能不能直接训成四位?」→ 能,K2 Thinking 就在后训练里做量化感知训练;代价是得由出模型的厂家在训练时做。

第九节 第一天上手,先问哪几个问题?(7′)计划 7′ · 含互动 6.8′

🖥 本节主屏:课件 第九节 第一天上手,先问哪几个问题? · 主图 fig-s14-eight

🎯 这一节只留一句:八问其实是一个问题——这一趟卡在哪?先对尺子、量清楚,答案自己指向某一招。各招叠在同一辆车上,光改软件,每卡五点一倍。

「现在换个身份:你第一天接手一个模型、一批卡,老板问能不能再便宜点。从哪下手?
整门课其实只给过一个答案:decode 每一步都要把权重和 KV 搬一趟。所以第一天只问一个问题:这一趟,卡在哪?」

🖥 屏幕:fig-s14-eight 整张,先别管编号,指中间那辆车。

「这张图把整门课画在了一起:仓库是显存,工位就是第零节那张小工作台,芯片在那儿算,中间就是那辆车。这些图钉,是这一个问题拆成的八个小问题(第七问拆成两枚)。不用一枚一枚背,我们顺着这辆车走一遍。」

「量之前,先对尺子,两件事:哪一档,分母几张卡。
档位就是出字要多快。同一个模型,档位一换,每卡吞吐能差十倍以上;在没人受得了的慢档上翻几倍,没用。
分母:第四节 DEP 那个两倍出头,是按全部卡算的;那次 decode 卡也跟着加了,只算 decode 卡,就剩一点三倍。尺子没对齐,后面赚没赚都说不清。」

「尺子对好,量这一趟,两个数:货多重,坐了几个人。
货多重,第一节教过:一步要搬的字节除以带宽,就是一步最快能多快。实测比这个下限慢好几倍,问题不在卡少,先查布局和调度。
坐几个人,看第三节:显存能放几个人的笔记,batch 上限就定在那。」

💬 互动:问「你量完发现:一步的时间离下限已经很近,可车上只坐了八个人,显存满了。先从哪下手?」请两三个人说,停五秒。期望答案:座位——压薄笔记、别把笔记复印好几份、或者把货变轻腾出地方。

「对,卡在座位上。这时候开投机帮不上,加卡也只是多开一辆一样空的车。量清楚了,答案自己会指向某一招。」

🖥 屏幕:滚到「卡在哪,用哪招」,一行一行往下指。

「按卡点串一遍。
车上人少、一趟太空:多坐人。连续批让人随上随下;MoE 把人拆散到各个专家,就上 DEP、大 EP,把专家那趟车坐满。
座位不够:压薄笔记、分页、复用前缀;多卡别把笔记复印好几份;上下文特别长,按序列切。」

「长 prompt 一来就卡住出字:备菜和出菜分灶台,就是 PD 分离。
人少、要每个字都快:投机,一趟出好几个。
不管卡在哪,少搬字节总有用:量化。」

「顺序别反过来。还是第四节那组 vLLM 实测:只调参数涨两成多;先换对切法,两倍出头。」

🖥 屏幕:滚到「开场那道题:光改软件,几倍?」,先停在第一段那道题。

💬 互动:念一遍开场那道题,问「开场猜一倍半的举手;两倍的;五倍的。」各数一下人头,停五秒。期望答案:五倍上下,本课推的是五点一倍。

🖥 屏幕:下到 fig-soft5x,先指左边两根柱子。

「首发那天每卡约两千二,六月到了一万一千二,卡、模型、出字快慢都没换。
一除,五点一倍,本课推的;博客标题写五倍。猜五倍的,这回赢了。」

「这五倍里各招占多少,博客没拆,六月那条还开了 MTP;分母是哪些卡,也没写明。所以前面各节的倍数别乘起来:后一个的起点就是前一个的终点,同一口径的总账只有这一笔。
以后谁再报个倍数,先问三句:比的是谁,哪一档,分母几张卡。」

「路也没走完。有些新模型的部分层不记逐字的笔记,只揣一张随写随改的便条,截不出前半段给别人复用,前缀缓存就难做。这是下一个洞。」

🖥 屏幕:停在绿框「这一节带走」。

「最后回头看一眼这辆车。第一节:每一步都要把权重和 KV 搬一趟,人少时车是空的。
后面每一节都在这辆车上加一招:把人坐满,腾出座位,备菜不挡出菜,一趟多出几个字,货变轻。
这些招一层层叠在同一辆车上,卡没换、模型没换、每个人出字一样快,就是开场那个五倍。」

「整门课就一句话:decode 每一步都要把权重和 KV 搬一趟;每一招,要么让这一趟分给更多人,要么干脆少搬。」

⚠️ 这一节最容易跑偏的地方⚠️ 5.1 倍只认这个口径:GB300、DeepSeek-V4-Pro、SGLang、同一交互档,首发日约 2,200 → 六月约 11,200 每卡,本课推导;博客标题写 5 倍。六月那条开了 MTP、首发日没开,MTP 占多少博客没拆。被问市场降价,别给倍数,课程不引价格口径的数。
⚠️ 「成本约降到五分之一」是本课推导:完整版 2.3 的公式 每字成本 = 每卡每小时价 ÷ 每卡吞吐;2,200 ÷ 11,200 ≈ 0.196。两个前提:① 卡价不变;② 「每卡」按全部卡(含 prefill 卡)算。博客没写明分母,若是只除 decode 卡、prefill 卡数又没跟着降,全部卡的成本降幅会小于 5 倍。比值 5.1 本身不受分母影响(两数同一张图、同一口径)。
⚠️ 只调并发 +28% 和 2.09 倍出自同一份 vLLM 实测记录(GB300、V4-Pro,VLLM-V4PRO-RUNBOOK.md:446-489;3p1d 并发 256 → 512,总吞吐 16,459 → 21,100),所以台词说「第四节那组」;第四节正文没写 28%,课件这里标了见完整版第十节。口播只说「两成多」。
⚠️ 「几十倍」出自完整版第十五节第二问(指向完整版第二节);本课只拿第四节 2.09 → 1.31 举例。编译 60–90 s / 同形状不到 1 s 出自完整版第十四节,「中央厨房」是那里的比喻。
⚠️ 111 → 198(MTP 1 层)→ 253(3 层)→ 239(5 层)是 TensorRT-LLM 8×B200 DeepSeek-R1 单用户每秒 token,模型和硬件都和 5.1 倍那组不同,只作量级参考;开太多层反降。
⚠️ 「便条」指线性注意力层的递推状态:定长、每来一个字整张改写,所以截不出某个前缀对应的那一份。
⚠️ 各节结尾的倍数不能连乘:Orca 比的是 FasterTransformer,分页比的已经有 Orca。被问「加起来快了多少倍」就这么答。
⚠️ 收尾那一句念完就停。
⚠️ 口径:分母那段 decode 卡从 4 张换成 8 张(口播「也跟着加了」),1.31 口播取整「一点三倍」;「两倍出头」=2.09。收尾「这些招一层层叠在同一辆车上」照完整版第十五节末行「①–⑪ 叠起来」和 15 节落点那一串的说法,只说叠起来,不说五倍分给了哪几招(博客没拆)。
⚠️ 「在没人受得了的慢档上翻几倍也没用」只讲道理,没有对应的数;被问例子就指回第二节那条曲线(换档差十倍以上)。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「车头那枚 8 号钉是什么?」→ 上线前跑通:TPU 按固定形状整图编译,像中央厨房按几种份量提前备好流程;没编过的档第一个请求等 60–90 s,之后不到 1 s,所以先把常用档跑一遍(完整版第十四节)。(2026-10-20 试讲后从主线挪到备答)
🧑‍🎓 新人「八问要背下来吗?」→ 不用,图上都有;记住顺序就行:先对齐尺子和负载,再挑招。
💰 管预算的「只能先做一件,做哪件?」→ 课件没有按成本排序。本课的建议就是八问的顺序:先校准尺子,再选切法,最后才调参数。
🛠 老兵「5.1 倍分母是哪些卡?」→ 博客没写明 decode 卡还是全部卡,完整版台账照实记「官方未写明」;五分之一成本按全部卡、卡价不变推。
🛠 GPU 老兵「5.1 倍里 MTP 占多少?」→ 官方没拆。博客分开报的两条曲线(不开 MTP 在 40 那档 2.1 倍、开 MTP 在 80 那档 2.6 倍)档位不同,不能相减。

🚧 这份讲义还薄的地方

  • [x] 已从头串讲一遍:交棒对齐、比方统一到公交车(第六节厨房、第七节徒弟是明说换比方)、计划按地板重分。
  • [x] 外行和推理专家读过零到四节:补了层、头、KV 头、Little 定律怎么数人、2.09 倍和 1.31 倍两种分母。
  • [x] 外行和推理专家读过五到九节:补了加权平均、温度与抽样、量化的容量和每步字节两笔账、编译为什么要提前做、5.1 倍的分母,各节补到接近计划分钟。
  • [x] 补回零到四节的「为什么」:第零节开头加专题五回顾题,五到九节逐句顺了口语,各节含互动都在计划减 0.3 到 1 分钟之间。
  • [ ] 上面几轮之后还没从头到尾串讲计时;进度见 Courses/reviews/T6-L200-STATE.md。