这份讲义怎么用
两个用法。
① 上台讲:照着念,台词、切图、每段几分钟都写着。
② 自学:把这一整份丢给 AI,你会得到一个既有全部背景、
也知道该怎么讲的助教,让它带你走一遍。
内容本身在课件那边,这一份只管「怎么讲」。
课程作者 Chris Yang · Google Cloud AI Infra 架构师。
| 🎯 | 这一节要留下什么 讲完之后台下脑子里该剩的那一句。 |
| 🗣 | 讲稿 黄底的可以照着念。 |
| 🖥 | 屏幕 该滚到课件的哪张图、放哪段动画。
⭐ 这些提示挂了 class="board",构建时逐条对账,
指了不存在的图或小节号会当场报出来。 |
| ⚠️ | 别讲什么 这一节最容易跑偏的方向。 |
⏱ 时间:主线 84′
⛔ 这一讲是一条接力线,不能跳。 每节最后那句「这一刀留下的问题」就是下一节的开场,时间再紧也要念。 要压时间,压每一节中间的例子,别压首尾。
| 段落 | 分钟 | 能不能砍 | 说明 |
|---|---|---|---|
| 零 开场 | 5 | 不能 | ⭐ 开场热身题(16 字节)必须做;只立一句话:用一种通信换一份显存或算力 |
| 一 五种通信 | 10 | 不能 | ⭐ 那个等式必须讲;1.7 的系数表不讲 |
| 二 切数据 | 10 | 不能 | ⭐ 前两级白送、最后一级付 50% |
| 三 切权重 | 14 | 不能 | TP 与 FSDP 各管一边;为什么先列后行要讲(GeLU 反例);FSDP×TP 二维切;PP 只讲气泡 |
| 四 切专家 | 10 | 不能 | ⭐ 负载不均是 EP 最重的病 |
| 五 切序列 | 13 | 不能 | ⭐ KV 复制那张图一定要放 |
| 六 切工作 | 11 | 不能 | PD 分离的厨房比方;配比算术;AFD 为什么要三个小批 |
| 七 摆到机器上 | 7 | 不能 | ⭐ 说得勤的放快线;先选切法再调参 |
| 八 全景与收尾 | 4 | 收尾不能砍 | 示范读一行;点三个坑;回到开场那一句 |
| 合计 | 84 | 第九节(出处台账)不进课堂,被追问时翻 |
⛔ 上面那张表是计划,下面这张是地板。 「地板」= 把讲稿一字不落念完、再加切图的时间,一句现场发挥都没有,也不含等动画转完一圈的时间(全讲约 3 分钟)。每次 build 现数。
| 节 | 台词汉字 | 切图 | 地板 | 计划给的 |
|---|---|---|---|---|
| 第零节 开场:一张卡装不下 | 721 | 3 | 4.4′ | 5′ |
| 第一节 先认识五种通信 | 1,606 | 8 | 10.0′ | 10′ |
| 第二节 第一刀:切数据 | 1,627 | 8 | 10.1′ | 10′ |
| 第三节 第二刀:切权重 | 2,346 | 10 | 14.2′ | 14′ |
| 第四节 第三刀:切专家 | 1,634 | 7 | 9.9′ | 10′ |
| 第五节 第四刀:切序列 | 2,199 | 10 | 13.5′ | 13′ |
| 第六节 第五刀:不切张量,切工作 | 1,838 | 6 | 10.7′ | 11′ |
| 第七节 摆到机器上 | 1,081 | 6 | 6.9′ | 7′ |
| 第八节 全景与收尾 | 716 | 1 | 3.8′ | 4′ |
| 合计 | 84′ | 84′ | ||
🧵 上台之前:把两条暗线记在心里
① 每一刀都付一种通信。 讲每一刀时都点一次名:它多出来的是第一节那五种话里的哪一种。讲到第七节,台下自己就能说出「那它该放快线还是慢线」。
② 每一刀都在补前面没管到的那一块。 batch 小了 FSDP 撑不住,补上 TP;V3 的参数几乎全在专家里,补上 EP;上下文一长一条样本放不下,补上 CP;prefill 和 decode 要的切法不一样,补上 PD 分离。 ⛔ 一旦讲成「接下来介绍另一种并行」,这条线就断了。
⭐ 如果只能让台下带走一句话: 选并行策略,就是在选你愿意付哪一种通信、付多频繁、放在哪根线上。🖥 投屏怎么放
⭐ 这一讲有十几段动画,全是无声循环。 放动画时先闭嘴看一遍,等它转完一圈再开口;边放边讲,台下眼睛和耳朵会打架。
⭐ 课件右下角有个「折叠讲解」按钮(或按 T),投屏前按一下。 不开的话,台下会低头读字,不听你讲。
第零节 开场:一张卡装不下(5′)
🎯 这一节只留一句:用一种通信,换一份显存或一份算力。
🖥 屏幕:课件 s零 最上面的「🎯 开场热身」,点开,先只露第一问的表,别往下滚(导语里有第一问的答案)。第二、三问是预习,题里不给答案。
「上课先做一道题,回顾上一讲。DeepSeek-V3,六千七百一十亿参数,按常规的混合精度训练,每个参数要在显存里常驻五样东西:算的时候用的权重、梯度、优化器更新的主权重、一阶动量、二阶动量。各占几个字节?」
💬 互动:等台下报数,填进表里,点「对答案」。
「二、二、四、四、四,一共十六个字节。前两样是半精度,算矩阵乘用;后三样是全精度,给优化器用。
乘上六千七百一十亿,九点七六 TiB,大约一万 GB。
十六字节是常规口径,梯度按半精度算。真用 bf16 训练时,框架常把累加梯度的那份放全精度,Megatron 默认就这样,那就是十八字节。」
「再留两道预习题,先想,不用现在答。
第二问:这十六个字节里哪块最大?要是让你削,先削哪块?
第三问:V3 其实没按十六字节存,它把其中两块压成了半精度。是哪两块?主权重为什么不能压?
这两道讲到第二节揭晓。」
🖥 屏幕:收起热身题,往下到导语。
「现在最大的一块卡,显存也就两三百 GB,光放下这一万 GB 就要三四十到五六十块卡。
而且别以为只有大模型才要切:八十亿参数的小模型,照样十六个字节一个参数,一百二十八 GB,一张 80 GB 的 H100 就放不下。
这还没算激活,就是每一层算出来、留着反向要用的中间结果,序列一长,它比这些还大。」
「就算放得下,一块卡也算不完。V3 的报告写着,全部训练用了两百七十八万八千个 H800 卡时,换成一块卡,要算三百一十八年。
所以切开,不只为了放得下,也为了算得快。
V3 的报告里,这一切就写成一行:PP 16、EP 64、ZeRO-1。现在看是天书,下课前你会读懂它。」
「可是一切开,每块卡手里就只有一部分,缺的那部分在别人那儿,只能互相传。每切一刀,卡和卡之间就多一种通信。
这门课只立一句话:每一刀都是拿一种通信,去换一份显存,或者一份算力。」
🖥 屏幕:fig-roadmap,只指盒子标题和下面的红字;「过路费」那一行先不念,第一节就认识它们。
「今天的剧情就这一条线:切一刀,付一笔通信;切完发现还有一块没管到,再切一刀。
每一刀我们都问同样三句:它切什么?付哪种通信?放哪根线?
五刀:数据、权重、专家、序列,最后连「活」本身一起拆开。你看每个盒子底下的红字,就是这一刀留下的问题,它逼出下一刀。
让你来切,第一刀切在哪?大多数人会先把数据分一分,每块卡算几条样本。没错,第一刀就从这儿开始。」
「不过下刀之前,得先认识卡和卡之间会说哪几种话。每一刀多出来的,都是其中一种。」
🔍 讲深一点:十六个字节为什么是这五样、两座山、三百一十八年怎么变成两个月(被追问或时间富余时用;不计入地板)
「为什么要存五样,不是一份权重就完了?前两样,权重和梯度,用半精度是为了快:矩阵乘是训练里最重的活,半精度算得快,搬的字节也少一半,显存和带宽都省。」
「后三样给优化器,它管的是这一步该怎么改。Adam 每个参数记两本账:一阶动量记它最近一直往哪个方向走,把梯度的方向平均一下,别被一两个噪声样本带偏;二阶动量记它的梯度平时有多大,给每个参数定自己的步子,梯度一直大的步子迈小,一直小的迈大。」
「所以 Adam 的聪明,是靠每个参数多记两个数换来的。这两个数,加上那份全精度的主权重,三样各四个字节,就占了十六里的十二。」
「十八字节是怎么回事?一步训练常常要把很多小批的梯度累加起来,加的次数多了,半精度那几位有效数字不够用,小的数加到大的数上会被吞掉。所以 Megatron 默认把累加梯度那份放成全精度,二变四,十六就成了十八。」
「注意这十六个字节只跟参数有多少个有关,跟一次喂多少数据、句子多长都没关系,模型定了它就定了。激活不一样:它跟一批多少条、每条多长、模型多宽、多少层全都成正比,序列从四千拉到十几万,它就跟着涨几十倍。」
「所以显存里其实有两座山:一座跟着模型走,一座跟着数据走。后面五刀,有的专门削第一座,有的专门削第二座。」
「八 B 很多人觉得小,推理的时候一张卡随便跑。可推理只要权重那两个字节,训练要十六个,差了八倍。」
「反过来算:V3 用的是两千零四十八张 H800,两百七十八万八千卡时摊下去,大约一千三百多个小时,不到两个月。三百多年变成不到两个月,前提是两千张卡真的一起忙,不能互相干等。」
「所以切开有两个动机:为了放得下,切模型的状态;为了算得快,让更多卡分担计算。两个动机,代价都一样:卡和卡之间要说话。」
名字一上来就是一堵墙。它们在后面都是从「上一刀的问题」里长出来的,那时候再叫名字,台下才记得住。
🖥 本节主屏:课件 第零节 开场:一张卡装不下 · 主图 fig-roadmap
第一节 先认识五种通信(10′)
🎯 这一节留两样:AllReduce 能拆成两半;AllToAll 是人人给人人发不一样的东西。
🖥 屏幕:按右下角「折叠讲解」(或按 T),fig-coll-1n 整张。
「一千张卡要把各自的结果加起来,你一定以为找个班长最省事?班长一个人要收发 999 份;大家围成一圈,每人只传 1.998 份。
名字看着一大堆,其实每一种只回答两个问题:谁发给谁;东西到了之后,是拼起来、加起来,还是原样放着。」
「先花十秒学会看图,后面所有图都是这个画法。四张卡,一张一个颜色:卡 0 蓝、卡 1 橙、卡 2 绿、卡 3 紫。每张卡的数据切成四小块,虚线框是空的。
最要紧的一条:哪块上面出现竖条纹,就是被加过了,条纹里有几种颜色,就是几张卡的数加在了一起。」
「用一个班级来想。四个同学,每人一份作业,切成四块。最简单的几种都有一个班长,就是卡 0。
左上,班长把整份作业给每个人发一份,叫广播;右上,班长把一份作业拆开、一人分一块,叫分发。
左下,大家把自己那块交给班长拼起来,叫收集;右下,大家把整份交给班长,班长把对应的分数加起来,叫归约。」
🖥 屏幕:往下展开「看它们动起来」那四段小动画,先闭嘴看一圈,再点开收集、归约两段全屏对比。
「看的时候注意一件事:收集和归约只差一个动作。东西都送到班长那儿,一个拼起来,一个加起来。你看归约之后班长手里那四块,条纹里四种颜色都有,就是四个人的数加在了一起。」
「班长模式有个毛病:按最笨的做法,所有东西都要挤过班长那一条线,人一多,班长就堵死了。
所以训练里真正天天在跑的,是名字前面带 All 的那几个。All 的意思就是:结果人人都有一份,不用再找班长要。」
🖥 屏幕:fig-coll-nn 整张,再放下面三段动画。它们按环一步一步走,每一步落地会自动停住:停住时指一下粗框那块,再点「下一步」。
「左上是全收集,AllGather:开始每人一块,结束每人四块都有,只拼不加。
右上是归约分散,ReduceScatter:开始每人一整份,结束时卡 0 只拿第 0 块的总和、卡 1 只拿第 1 块的总和,先加,再分。
左下是全归约,AllReduce:开始每人一整份,结束每人都有四块的总和。数据并行同步梯度,用的就是它。右下那个长得不一样,先放着,最后讲。」
🖥 屏幕:fig-ar-split,整张。
「这张是今天最重要的一个等式:全归约,等于先「加完每人分一块」,再「拼起来人人一份」,也就是 AllReduce 等于 ReduceScatter 加 AllGather。
先加,每人拿到一块总和;再拼,每人拿到全部总和。结果跟一步到位完全一样。」
「为什么要拆?因为拆开之后,这两半可以放到不同的时间去做,中间还能塞进别的动作。
下一节第一刀你就会看到:中间塞进一个「更新」,每张卡就少存一大块东西,通信却一个字节都不多。」
🖥 屏幕:anim-ring,一步一停:每步停住时讲一句「粗框那块又多加进一个人」,再点「下一步」;第 1 步停住时专门指卡 3 那块,它是从右边出去、沿底下绕回卡 0 的。
「那没有班长,怎么做到人人一份?围成一个环,每人只跟右边的邻居说话。
先做 ReduceScatter:每一步,每张卡同时把手里的一块发给右边,再从左边收一块,加到自己同号的那一块上。第一步之后有的块是两个人的和,第二步三个人的和;四张卡转三步,每人手里都有一块是四个人的总和,就是条纹四种颜色都齐了的那块。」
「接着用同一个环再转三步,这次只拼不加,把各自那块总和传给所有人。这后三步就是 AllGather,合起来就是一次 AllReduce。」
🖥 屏幕:fig-ar-two-ways,先左后中,最后指右边那张小表。
「同一个 AllReduce,其实有两种拼法。左边是班长做法:先全加到卡 0,再从卡 0 发回去,卡 0 要发三份,别人各发一份。
中间就是刚才的环:先 ReduceScatter 再 AllGather,四张卡每张都只发一点五份。结果一模一样,差的只是谁在干活。
右边就是开头那两个数:九百九十九份对一点九九八份。所以这个等式是全课最重要的一个:它不光成立,还是赢家。」
「环也有代价:步数跟着人数涨。数据很大的时候,比的是每个人的带宽,环几乎最省;数据很小的时候,比的是一步一步的等待,步数多反而吃亏。
所以通信库会按数据大小自己挑算法,小数据改走树形。TPU 更直接:用 TPU 专用快线连在一起的一整块芯片叫一个切片,大切片上芯片之间本来就连成环。」
🖥 屏幕(选讲,台下有 TPU 背景再放):展开「细一点」,anim-torus,先闭嘴等它转完一圈(47 秒,可一步一停):逐轴那幕每步只亮一个方向,轮换那幕三个方向全亮。静图 fig-torus-3ring 留给会后自学。
「TPU 的环还多一层:一颗芯片有 X、Y、Z 三个方向的环。先沿 X 收、再沿 Y、再沿 Z,每一步只有一个方向在干活,最后一步还最重。
把数据切成三块,各挑一条轴起步,三个方向就一直满着,同样一次 AllGather,只按带宽算能快到三倍。ReduceScatter 倒着走,AllReduce 两段同理。」
🖥 屏幕:先放 fig-a2a(① 那堆交叉的粗细线、② 反过来的同一批线、③ 右下角的转置小图),再放 anim-a2a,手动模式:停在「卡 0 收了 11 个」那一幕,再看原路飞回。
「最后一种最特别,叫 AllToAll。每个人手里有要给每个人的一份,而且每一份都不一样,就像每个人各做一次分发。
在专家并行里最典型:每个 token 由路由定好去哪张卡,派发时所有卡同时往所有方向寄,每人寄给每人的数目都不一样,收的人忙闲不均;专家算完,再沿原路寄回,叫合并。
每份一样大时,它正好是把一张表转置一次,但那只是特例。」
「为什么网络最怕它?每一份都是写给某一个人的私信,路上没法边走边合并;前面几种都能排成只跟邻居说话的环,它不行,任意两张卡之间都有东西要走,拼的是整个网络的横截面有多宽;而且每一份多大,要等模型算到这一层才知道。
记住它。后面切专家的时候,每一层都要用它两次:动画里寄过去一次,最后字幕说的原路寄回又是一次。」
「数一下。刚才看了八个名字,但带班长的四个只是积木。日常真正用到的就五种:AllReduce、AllGather、ReduceScatter、AllToAll,再加最朴素的一对一收发。
后面把模型按层切成几段时,段和段之间传东西就用它。」
「这一节带走两件事就够了:AllReduce 能拆成两半;AllToAll 是人人给人人发不一样的东西。
开场那张路线图上,每个盒子那行「过路费」,都是这五种里的某一种。
话认全了,第一刀:切数据。」
🔍 讲深一点:环为什么省、什么时候吃亏、AllToAll 为什么难;TPU 的 2D/3D 环面怎么做(被追问或时间富余时用;不计入地板)
一、环为什么这么省
「把账从四张卡推到 n 张卡,跟着数。数据切成 n 块,每一步发 n 分之一份;ReduceScatter 走 n 减一步,AllGather 也走 n 减一步。一千张卡代进去,九百九十九乘二、除以一千,就是开头那个一点九九八。卡再多,也只是无限接近二。」
「这就是环最了不起的地方:每张卡要发的量,几乎跟人数无关。班长反过来,人数翻十倍,班长的活也翻十倍。」
「顺便看两半各占多少:ReduceScatter 差不多一份,AllGather 也差不多一份。等式不光在结果上成立,在花费上也是一半一半。下一节只做其中一半的场合,就只付一份的钱。」
二、环什么时候反而吃亏
「刚才数的是字节,没数步数。一千张卡的环要走将近两千步,每一步都得等上一步的数据到了才能开始;每步哪怕只有一点固定的启动时间,乘两千也攒成一大段。」
「所以一次通信的时间是两部分相加:步数乘每一步的固定开销,加上数据量除以带宽。数据大,第二部分占大头,环几乎最省;数据小,比如只加总一个数,第一部分占大头,步数多就成了致命伤。」
「树形就是冲着步数去的:一千张卡两两合并,大约十轮合到一个人手里,再十轮发回去。字节上不如环省,可步数从两千降到二十。所以通信库看数据大小自动挑,大块走环,小数据走树。」
三、AllToAll 为什么让网络头疼
「把集群从正中间劈成两半。AllReduce 走环,每张卡只跟邻居说话,劈开的地方只有两条线有东西过;AllToAll 每张卡都要给其他每一张寄一份,差不多一半的数据都要穿过中间那道缝。它拼的不是某一根线快不快,是这道缝有多宽。」
「这就看出机器的差别了:GPU 在一个 NVLink 域里,是交换机把所有卡连起来,谁跟谁都是一跳,缝很宽;环形连接的机器,寄到对面的信要经好几个邻居转手,每根线上同时挤着别人的信。」
「还有两个麻烦。每张卡给每个人寄多少,要等路由算完才知道,往往得先互相报个数再真正去寄;被挤爆的专家那张卡特别忙,大家都得等它。而且私信没法合并:AllReduce 走到半路就能先加,越走越少,AllToAll 一个字节都省不掉。」
「最后一对一收发最朴素:一张卡直接交给另一张,只跟邻居说话,量也不大,是五种里最不挑网络的。」
四、平面的环:2D 环面
「十六颗芯片排成四行四列,每颗四根线:左、右、上、下。每一行最右连回最左,每一列最下连回最上,所以每行、每列都是一个四个人的环。这种首尾都接上的网格,叫环面,torus。」
「十六个人串成一个大环也能做,可每颗芯片只用上左右两根线,上下闲着,而且前后要走三十步。环面的做法是一个方向一个方向来:先每一行各做一次 ReduceScatter,四行同时做,每人手里剩四分之一份,是这一行的和。」
「再每一列拿手里这四分之一份做一次 ReduceScatter,每人只剩十六分之一份,可这一小块已经是全部十六个人的和。后半段倒过来,先沿列、再沿行 AllGather 拼回去,人人都有全部的总和。」
「数一下。字节上,行里发大约四分之三份,列里只处理四分之一份、发十六分之三份,合起来十六分之十五,后半段一样,差不多两份,跟大环一样。步数上,每段是四个人的小环走三步,四段一共十二步,大环要三十步。字节没多,步数少了一大截。」
「还剩一个浪费:做行时上下的线闲着,做列时左右的线闲着。把数据劈成两半,前一半先行后列,后一半先列后行,四根线就全用上了。每根线还是双向的,再分一份顺时针、一份逆时针,又快一倍;四个人的环,最远的人只隔两跳。」
「单独的 AllGather 和 ReduceScatter 是同一个套路,只走一半:AllGather 先传小块、后传大块;ReduceScatter 反过来,大的先走,越走越小。」
「前提是环真的首尾接上。TPU 的切片每一维都是四的整数倍时,每一维天然是闭合的环;切片小的时候,有的方向两头没接上,只是一条线,最远的数据得一路走过去,慢不少。」
五、立体的环:3D 环面
「立体就是再加一个方向。四乘四乘四,六十四颗芯片,每颗六根线。先沿 X 做 ReduceScatter,剩四分之一;再沿 Y,剩十六分之一;再沿 Z,剩六十四分之一,这一小块就是全部的和。然后沿 Z、Y、X 一路 AllGather 拼回去。」
「六段小环,每段三步,十八步;六十四个人串一个大环,前后要一百二十六步。字节还是差不多两份,一点没多。」
「线闲着的问题也一样办:数据劈三份,轮着换顺序,第一份走 X、Y、Z,第二份走 Y、Z、X,第三份走 Z、X、Y。三个方向同时忙,可用带宽就是一个方向的三倍。所以一刀占的轴越多,能用的线越多,讲摆到机器上的时候会回来。」
「AllToAll 在环面上没这个待遇:也能一个方向一个方向地送,可私信路上不能合并,远的信要转好几跳,路过的每根线上都挤着别人的信。它拼的始终是中间那道缝,这道缝在环面上不如一台大交换机宽,切专家时要回头算这笔账。」
六、一根线到底能跑几个方向:全双工,和 v7x 的账
「常见的误解是:环形通信就是右边那根线发、左边那根线收,所以一根线只走一个方向。其实每根 ICI 链路是全双工的,跟邻居之间相当于两条单行道,一条左往右,一条右往左,两个方向同时满速,互不抢带宽。」
「单向环只用了一半:每颗芯片往右发、从左收,右边那根线回来的方向、左边那根线出去的方向都没人用。所以六根线其实是十二条单行道。三块轮换让三个轴一起忙,用上六条;每块再劈两半、顺逆各走一半,十二条全满,可用带宽在三倍之上再翻一倍。」
「拿 v7x 算。官方只给了每颗芯片 ICI 一共 1200 GB 每秒。拆开是本课的推导:六条链路,每条两个方向合计 200,每个方向 100;发出方向六条加起来 600,收也是 600,合计才是 1200。外部锚点是 scaling book 给 v7 的单链路单向 90 GB 每秒,对得上。」
「所以看到 ICI 带宽,先问是单向还是收发合计。算 AllGather 要多久,得拿发出方向的带宽去除;直接拿 1200 去除,算出来就快了一倍。」
⚠️ 环形和树形怎么挑,只点一句「小数据改走树形」,不展开(2026-09-25 现场认可这一讲法后放宽)。
🖥 本节主屏:课件 第一节 先认识五种通信 · 主图 fig-coll-nn
第二节 第一刀:切数据(10′)
🎯 这一节留一句:越闲的越先削;前两级白送,最后一级多付一半的通信。
🖥 屏幕:滚到课件第二节标题。
「先卖个关子:ZeRO-3 故意多付一半的通信,大模型却几乎都在用它。多花的那一半,换回了什么?
第一刀最朴素:每张卡算不同的样本,这叫数据并行。
每张卡放一整份模型,各算各的。算完,每张卡都得出一份「每个参数该往哪边调、调多少」,这叫梯度;样本不同,梯度就不同,所以做一次 AllReduce 求个平均,再一起更新。」
「它一步只说一次话,是今天所有刀里说话最不勤的。但不勤不等于量小:V3 这么大的模型要是纯数据并行,每张卡每一步要发出去大约 2.7 TB,只是一步才发一次。」
「可它根本没解决「装不下」:每张卡还是一整份,9.76 TiB,一个字节没少。
打个比方:把 V3 的全部权重想成一整套四库全书,存进 61 间书房,一间就是一层。V3 的配置是 128 路,就是 128 个阁,每阁都放一整套:谁也不缺,可 128 个阁存了 128 份一模一样的书。」
💬 互动:先别切屏(图的标题和落点带就是答案),回扣开场第二问:「128 份一模一样的书,开场那十六个字节里,你先削哪块?」等台下答「那十二个」。
🖥 屏幕:这时再切 fig-zero-mem,先按住最上面那根最长的条,之后逐行往下指(「V3 每卡常驻」那列的红字 1.29 TiB,留到讲到「可削到这儿」那句再指)。
「那就把重复的削掉,按大小一样一样削,这叫 ZeRO。每个参数 16 个字节:蓝的是权重,2 个;橙的是梯度,2 个;绿的这一大段是 12 个,是优化器替它记的账,叫优化器状态。
最大的先削。往下看:ZeRO-1,账每人只记自己那一份,绿的没了;ZeRO-2,梯度也只留自己那份,橙的也没了;ZeRO-3,连权重也切,短到看不见。」
🖥 屏幕:fig-zero-busy,先指绿色那条长长的虚线,再从下往上指。
「为什么是这个顺序?看一步里谁在忙。绿的优化器状态最大,却只在最后更新那一下用,整整一步都在显存里干放着,削它谁也不耽误。
橙的梯度到反向才一层层出现;蓝的权重从头忙到尾。越闲的越先削,最忙的最后削,而削了它,每层用之前就得先把别人那几段复制过来。」
🖥 屏幕:fig-zero-step,从左往右一格一格指:①、②、③。
「前两级的账很好算。账既然每人只记一段,梯度总和也只用拿自己那一段,所以不做 AllReduce,只做 ReduceScatter;就地更新完,再 AllGather 把新权重拼回给大家。
这两步加起来,正好就是一次 AllReduce 的量。所以从纯数据并行走到 ZeRO-1、ZeRO-2,通信一个字节都不多,每人却只替自己那份记账。」
「中间那一步「就地更新」为什么不用传?因为 Adam 是一个参数一个参数算的:第 i 个参数的新值,只看它自己的梯度、自己的两个动量、自己的主权重,跟别人没关系。所以四张卡各更新四分之一,跟一张卡全更新一遍,结果一模一样。
只有一个例外:梯度裁剪要看全体梯度有多长,这得凑一下。每张卡先算自己那段的平方和,再把这一个数加总一次,量小到可以忽略。」
🖥 屏幕:往下到第三问的绿框,展开它下面的「细一点」,放 fig-bf16-beta 那把刻度尺。
「揭晓第三问。V3 把两个动量压成了半精度,主权重留在全精度。注意优化器状态里没有梯度:梯度只是每步的原料,用完就清零;要全精度的是梯度累加器。算下来,V3 的优化器状态从十二字节降到八字节,累加器另算四字节。
看这把尺子:刻度是半精度在 1 附近能存的数,相邻差一百二十八分之一。绿的是 β₂ 零点九五,新值占百分之五,一步挪过了好几格,存得住;红的是默认的零点九九九,新值只占千分之一,连半格都没挪过,一存又回到原处,动量就卡住了。」
「主权重为什么不能压?它每步只加一点点,还要一直累加下去,小于半格的更新全被舍掉。所以 V3 敢压动量,不敢压主权重。」
「可削到这儿,看「每卡常驻」这一列:每张卡还要 1.29 TiB,一千四百多 GB,还是装不下。」
🖥 屏幕:fig-siku,先指 ③ 那条红线,再指阁 3 那个红框,最后指 ④。
「只能走到最后一级:连权重也切,也就是 PyTorch 里的 FSDP。这一级就不白送了。
回到藏书楼。FSDP 切的时候根本不管书是什么:一间书房的书一页页排成一长条,按长度等分成 128 段,每阁拿一段。看阁 3:一本书的后半截,接着另一本的开头,单拿这一段,谁也读不了。
要用这一间,就把 128 段各抄一份拼回整间,读完把抄本扔掉,只留自己那段。抄齐就是 AllGather。」
「再看底下:后面要讲的 EP 正好相反,是整架分,一架就是一个完整专家,拿着就能用。FSDP 切成碎片,只是为了通信好切块,拼回来之前没用。」
🖥 屏幕:fig-fsdp-step,整张。
「看这两行。数据并行一层两块颜色:加一次,拼一次。FSDP 是这样:要算这一层之前,先把别人那几段复制过来拼成整层,算完扔掉复制件;到了反向,也就是倒着算梯度的时候,这一层又要用,只好再复制一次,最后再把梯度加一次。
一共三块,多出来的就是中间这块蓝的。所以通信多出一半。」
🖥 屏幕:anim-fsdp,先闭嘴等它转完一圈(14 秒)。
「看计数器:前向每层复制一次,反向每层再复制一次、再分一次梯度,三层走完是九次。
换来的是:每张卡常驻的东西从大约一万 GB 降到 84 GB 左右,这还没算激活。
可 V3 用的 H800 一张才 80 GB,已经放不下了。光切数据还不够,后面几刀就是这么来的。」
「再补一句给懂行的:一步切成好几个 micro-batch 的时候,ZeRO-2 就不再白送了。它不留整份梯度,没法把几份先攒起来,只好每一份算完就加一次。ZeRO-3 包含 ZeRO-2,这个麻烦它一样有,还要每个 micro-batch 再把权重拼一遍。所以配流水线的时候,V3 选的是 ZeRO-1,没用 ZeRO-3;显存是靠流水线和专家并行压下来的。」
🔍 讲深一点:ZeRO-1 一步到底怎么走、累加器算谁的、梯度规约传什么精度、V3 为什么只开 ZeRO-1(被追问或时间富余时用;不计入地板)
一、ZeRO-1 切的到底是什么
「全精度那份主权重,本身就算在优化器状态里:十二个字节是主权重四、一阶动量四、二阶动量四。ZeRO-1 切的就是这十二个,三样一起切。」
「切完每张卡上还有:一整份半精度权重,拿来算前向反向;一整份梯度;外加自己那一段的主权重和两个动量。怎么分段?所有参数排成一长条等分,每张卡管一段,不是按层分给谁。」
二、一步怎么走
「更新一步只有一次,在所有层的反向都走完以后,不是每层一次。前向用整份半精度权重一层层算下去,反向一层层倒回来,攒出一整份梯度。」
「反向结束,本来该 AllReduce。可每张卡只管一段主权重,别人那几段的梯度总和它用不上,所以只做 ReduceScatter,拿到自己那段的总和。」
「拿这段梯度,加上手里这段主权重和动量,算出新主权重,再转成半精度。这时卡上的整份半精度权重里,只有自己那段是新的,其余还是旧的。」
「所以最后 AllGather,各自把新的那段发给大家,收回来的直接覆盖旧值,每人拼回一整份新权重,下一步前向拿它算。工程上 ReduceScatter 可以按桶在反向途中边算边发,但更新那一下,一步只有一次。」
三、累加器算谁的
「累加器不在优化器状态里,它占的是梯度那一格。十六字节的算法默认一步一个 batch,梯度算完就用。一步切成好几个 micro-batch,就得先把几份梯度加起来,用半精度加,小的会被舍掉,所以开一个全精度累加器,梯度那格二变四。」
「ZeRO-1 不切它,每张卡一整份。拿 V3 算:半精度权重约 1.3 TB,全精度累加器约 2.7 TB,正好两倍;主权重和动量切成一百二十八份,加起来只有几十 GB。削完前两样,卡上最大的一块反而是累加器。」
「也正因为累加器得攒整份,ZeRO-2 一切梯度就没地方攒,只好每个 micro-batch 都做一次 ReduceScatter。按 V3 论文给的精度推一下它自己的账:权重二、累加器四、主权重四、两个动量各二,一共十四。」
四、梯度规约传半精度行不行
「直觉是本地攒完了,传半精度就够,带宽省一半。坑在 ReduceScatter 本身就是求和:环上每一跳收到别人的部分和、加上自己的、再往下传,同一个数要连加一百多次。」
「按半精度传,每一跳的部分和都要按半精度存一次、舍入一次,越往后部分和越大,后来加进去的小值越容易被吞掉。麻烦不在传的那一下,在每一跳都得用它存部分和。」
「两种做法都有人用。Megatron 有个开关 grad_reduce_in_fp32,管梯度缓冲和规约用全精度还是半精度;英伟达给 DeepSeek 那类模型写的配方里,就把它关掉了,梯度全程半精度,显存和带宽都省一半,拿精度换。V3 论文里数据并行这次规约用什么精度,没写明。」
「这也是数据并行和 FSDP 跑久了 loss 会差一点的主要来源:两边加的顺序不同,浮点加法换个顺序结果就不一样,训练再把这点差别放大。」
五、梯度活多久,每一级各切了谁
「严格说,梯度用不着跟权重活得一样长:反向时一层层冒出来,更新完就能清零,前向那段并不需要它。但 Megatron 这类框架会提前开好一整块连续的梯度缓冲区,整步不释放,所以算显存账时把它当常驻,二加二再加三个四,十六字节。」
「开了累加器,不是在半精度梯度旁边再多四个字节,而是顶替它:每层反向算出的半精度梯度马上加进全精度累加器,随手就扔。半精度梯度只是一层层临时出现,常驻的只有累加器。梯度那格二变四,十六变十八,不是二十。」
「谁切谁:ZeRO-1 只切主权重和两个动量那十二个字节;累加器算在梯度那一格,跟着梯度走,ZeRO-1 不动它。ZeRO-2 切梯度,累加器也跟着切;ZeRO-3,也就是 FSDP,再加上权重,三样都切成一百二十八份。」
「切梯度的那几级,反向算到某一层,这一层完整的梯度在每张卡上短暂出现一下,紧接着做一次 ReduceScatter,每张卡只留自己那一百二十八分之一的总和,整层梯度马上释放。有 micro-batch 时,就是每个 micro-batch 都这么来一次,加进自己那段累加器。」
六、V3 到底用的是哪一级
「V3 论文写的是:16 路流水线,64 路专家并行,加 ZeRO-1 的数据并行。2048 张卡除以 16 路流水线,正好 128 路数据并行,课上那个 128 就是这么来的;但这 128 路上开的是 ZeRO-1,不是 FSDP。」
「ZeRO-3 包含 ZeRO-2,所以 ZeRO-2 遇上 micro-batch 的麻烦它一样有,而且更重:除了每个 micro-batch 一次 ReduceScatter,前向反向还要每层再 AllGather 一遍权重。流水线一步要跑很多个 micro-batch,这些通信就翻很多倍。」
「不切梯度和权重,显存靠别的刀:16 路流水线每卡只放十六分之一的层,64 路专家并行再把专家摊开。剩下最大的优化器状态,ZeRO-1 一刀切掉,通信还不多花。正文里 128 路 FSDP、每卡降到 84 GB 那段,是假设只用数据并行这一刀的推演,用来说明光切数据不够,不是 V3 的真实配置。」
「再记一件事:数据并行一步说一次话,FSDP 一步要说成百上千次。说得越勤,越只能放在快线上,讲摆到机器上的时候会回来。」
「这一刀留下什么问题?FSDP 每一步搬的是权重,搬多少只看模型多大;可是算多少,跟每张卡分到的 token 数成正比,token 大致就是一个字。
卡越加越多,一次喂的总量却不能跟着无限加,加太大模型反而学不好,每张卡分到的就越来越少。
算得少、搬得一样多,时间就全被搬权重吃掉了。这就逼出了第二刀。」
2.4 那两条是「这一刀能放多远」的延伸,台上不讲,被问到再说「机内 FSDP、机间数据并行」。
⚠️ 数据并行是「说话最不勤」,不是「最省」:它一步的通信量其实很大(V3 每卡约 2.7 TB),低的是频率。
⚠️ 「FSDP 白送」这句话最容易说错。白送的是 ZeRO-1、ZeRO-2;ZeRO-3 多付一半。
micro-batch 时只剩 ZeRO-1 白送,台上已经讲了;原因写在课件「ZeRO 的一步」那张图的出处里。
🖥 本节主屏:课件 第二节 第一刀:切数据 · 主图 fig-zero-mem
第三节 第二刀:切权重(14′)
🎯 这一节只留一句:FSDP 搬工具、看 batch;TP 递门板、看隐藏维。
🖥 屏幕:滚到课件第三节标题。
「「少」到底是多少?先问个朴素的问题:一份东西搬过来一次,能被用几回?
想象一间做门的工坊:师傅干一件活两秒,小工送一趟东西要五秒,师傅再快也得等。每张卡就是师傅,网络就是小工。
小工搬两样东西。一样是工具,电刨、模具,这就是权重;一样是门板,一块块正在加工的门,一道工序做完递给下一道,这就是激活,每个字一块。
要看的是:小工每送来一个字节,够师傅忙多久。」
「尺子的一头是硬件:师傅手多快,除以小工腿多快。TPU v7 一颗芯片每秒算两千三百多万亿次;网络每秒能给它收进来大约六千亿字节。一除,三千八百多。
注意是「收进来」:FSDP 要算这一层,得先把别人那几段权重收进来。环上每张卡收多少就发多少,两个方向各六千亿,常说的一万二千亿是收发加在一起。
就是说每收进来一个字节,得有三千八百多次活等着,师傅才不用等。」
「还有一件事要分清:这里卡的是网络,不是显存。权重收进来以后,还要从显存里读出来算,可显存每秒能读七万三千多亿字节,比网络快十二倍多,那条线只有三百一十多,就是图最下面那条灰虚线,远不是瓶颈。真正让师傅等的,是网络那条腿。」
🖥 屏幕:fig-intensity,整张,先指红色横虚线。
「横轴是每张卡这一步分到多少个 token;竖轴是每收进来一个字节换来多少次计算。
红线就是那个三千八百多,线下涂红的那片,就是师傅在等小工。」
「蓝的斜线是 FSDP。它让小工搬的是工具,也就是权重,就是上一节每层都要抄齐拼回的那间书房。一件工具送到,这个师傅手上的每块门板都要拿它过一遍,门板越多,同一趟送货够师傅忙得越久。
算出来特别干净:一个参数两个字节,每个字拿它做一次乘加,正好两次运算,一约就掉。所以每送一个字节换来的计算,正好等于每张卡分到的 token 数。所以每张卡一步分不到三千八百多个 token,FSDP 就被拖住了。这是我们按最乐观的算法自己推的。」
「三千八百多个 token 是什么概念?V3 预训练一条样本 4K 个 token,差不多就是每张卡一条;再少,搬权重的时间就露出来了。」
🖥 屏幕:还在 fig-intensity,指红线上面那条细虚线。
「这里有个坑:红线的分母,也就是小工的腿速,不能抄规格表。规格表上的是物理带宽,可真拼一次权重,路上有各种损耗。
该用的是你在自己网络上实测出来的数:真跑一次 AllGather,GPU 上就是跑 nccl-tests,看它报的 busbw,就是扣掉算法本身的账以后,每张卡每秒实际收到多少字节。
实测只跑到规格的七成,门槛就从三千八百多抬到五千五左右,就是这条细虚线,七成是我假设的。FSDP 要是只占了几根链路、还跟别的并行抢线,门槛还得往上走。」
「第二刀不再搬权重,直接把权重矩阵切开,叫张量并行,TP。」
🖥 屏幕:fig-tp-mlp,整张。
「一个 MLP 有两块权重,先放大的叫 UP,再缩回来的叫 DOWN。英伟达的 Megatron 用了一个巧思:第一块权重按输出维切一刀,第二块按输入维切一刀。
两个人各拿一半,蓝的只跟蓝的乘,橙的只跟橙的乘,中间谁也不用问谁。通信被整个推到了出口,只在最后做一次 AllReduce 加一下。
用工坊的话说:两个师傅合干同一批门板,各做一半工序,做完得把门板凑到一起合成,这一凑就是那次 AllReduce。」
🖥 屏幕:anim-tpsplit,先闭嘴看完一圈(9 秒)。
「两个容易绕晕的地方。第一,每张卡两块都有份:卡 0 拿 UP 的一半,也拿 DOWN 的一半,不是一张卡管 UP、另一张管 DOWN,那是后面要讲的按层切。UP 和 DOWN 之间不说话,DOWN 算完才加一次,传的是激活。
第二,横着切还是竖着切,只是画法。我们把权重画成「输入维乘输出维」,第一刀切输出维,看着是竖的;PyTorch 把权重存成「输出维乘输入维」,同一刀在它那儿就是横的。所以别记横竖,记第一块切输出维,第二块切输入维。」
🖥 屏幕:fig-tp-order,先左后右。
「为什么非得先竖着切?反过来试试。先横着切,每张卡手里是同一个数的一份,要加起来才是它:卡 0 是 2,卡 1 是负 3,真值负 1。
GeLU 不是一条直线。先加再过,是负 0.159;各过各的再加,是 1.950,符号都反了。所以只能先加,凭空多一次通信。
竖着切,每个数整个落在一张卡上,GeLU 各算各的。」
「数一下这一下来几次。前向,MLP 出口一次,attention 出口一次。反向倒过来:X 是两张卡共用的,两边各算出 X 的一半梯度,入口处又得加一次。
一层前向两下、反向两下,每一层都来。所以它只能待在最快的那一片互联里,GPU 上一般不出一台机器。」
🖥 屏幕:切回 fig-intensity,指两条橙色平线。
「回到这张图,TP 这条线是平的。为什么?TP 让小工递的不是工具,是门板,也就是算到一半的中间结果,激活。每个字一块门板,字多一倍,要递的多一倍,活也多一倍,一除就约掉了。」
「它只看两件事:每个字在模型里用多长一串数表示,这叫隐藏维,就是门板的尺寸,板子越大,每递一趟要干的活越多,线越高;再就是切几份,切得越碎,每人的活越少,送的却没少,线就往下掉。
V3 切 8 份是这条实线,按最乐观的红线刚好贴线,实际已在线下;切 32 份是下面那条虚线。」
「所以两把刀各管一边:一次喂进去的那一批数据,叫 batch,batch 小的时候多用 TP,大的时候多用 FSDP。
图上就是:左边蓝线还没爬上来,靠橙线;右边蓝线爬过去了,交给 FSDP。」
🖥 屏幕:fig-fsdp-tp,先 ① 的左边大矩阵,再右边 8 张卡;然后 ② 从左往右;最后 ③ 两个框对比。
「那 FSDP 和 TP 能不能一起用?能,而且大模型训练里常常一起用。诀窍是两刀切在不同的维上。
看这 8 张卡,排成两行四列。TP 先按输出维把权重竖着切成四条,一列一条;FSDP 再把每一条上下劈成两半。每张卡只存八分之一。
一行四张卡是一组 TP,看的是同一份数据;一列两张卡是一组 FSDP,数据各不相同。」
「算一层分三步。第一步,列里 AllGather:同一列的两张卡把上下两半拼齐。注意,拼回来的只是自己那一条,整个矩阵的四分之一,不是整个矩阵。
第二步,各算各的,一行四张卡拿着同一份数据,各算四分之一。第三步,行里 AllReduce,把部分和加起来,传的是激活。」
「最妙的是账。只用 FSDP 时,每张卡拼一整层,只给自己那些 token 用。一起用时,每张卡只拼四分之一条,却是给这一行四张卡的全部 token 用。所以 FSDP 的门槛按一行的 token 数算,摊到每张卡只要九百六十个左右。
这才是「batch 小多用 TP」的真正意思:TP 把一行的 token 借给了 FSDP。代价是 TP 那根轴每层都要对账,得占最快的线。」
🖥 屏幕:fig-wide-deep,先左后右,数红点。
「TP 出不了最快的那一片。要横跨很多台机器、走慢线,又不想每层搬权重,就换个方向切。
TP 是切宽:每一层切成四条,所以每一层都得对账,左边红点一层一个。PP 是切深:前两层给卡 0,再两层给卡 1,只在段和段的交界递一次门板,用的是第一节那个一对一收发,右边只有三个红点,所以敢走慢线。」
「可朴素地切深,是四张卡的显存、一张卡的速度:同一时刻只有一段在干活。
所以把一批数据切成几份轮着灌进去。还是那间门厂,换成流水线:刨光、开孔、上漆三道工序各守一个工位,门板一摞一摞往下传。第一摞刚进刨光时,后两个工位只能干等。」
🖥 屏幕:anim-pipeline,闭嘴让 4 个和 8 个 micro-batch 都放完(14 秒)。静图 fig-pp-bubble 留给自学。
「工位上干等的那段,就是这些灰色的格子,叫气泡:开头要等后面几段灌满,结尾要等前面排空。
一批数据切得越碎,气泡越小,你看同样多的活切成 8 份,灰色短了一半。可也不是越碎越好:总的活没变,可每一份太小,矩阵太窄,卡的算力用不满,每段之间递一次门板的等待也跟着份数变多。切过了头,省下的气泡又被吃回去了。」
🔍 讲深一点:GPipe 到底新在哪(被追问或时间富余时用;不计入地板)
一、流水线不是它发明的,它新在「同步」
「GPipe 是 Google 二零一八年的论文。按层切段、几段接力,这个想法早就有;它做的是把流水线变成同步的、通用的。核心就是本节这一招:一批切成几个 micro-batch 轮着灌,所有 micro-batch 的梯度先攒起来,最后只更新一次。」
「这样训出来的结果,跟不切流水线、一张大卡从头算到尾,数学上完全一样。同时期微软的 PipeDream 走的是异步路线,不同的 micro-batch 用不同版本的权重算梯度,气泡没了,但结果跟原来不一样,得另外担心收敛。GPipe 选的是不改训练结果的那条路,代价就是本节的气泡。」
二、跟重算绑在一起
「每段只存段边界那一份激活,段内部的激活前向算完就扔,反向时再算一遍。拿一点计算换回大量激活显存。今天说的 activation checkpointing,是 GPipe 把它跟流水线绑在一起推广开的。」
三、气泡的账和当年的规模
「论文的结论是:micro-batch 的份数到段数的四倍以上,气泡就小到可以忽略。课件里「份数要到段数的四倍以上」就是从这儿来的。它当时拿这套方法训了一个六十亿参数、一百二十八层的 Transformer,做一百多种语言的翻译。」
「本节那张静图画的就是 GPipe 的排法:先全部前向,再全部反向。后来的 1F1B 气泡一样大,省的是激活显存。」
「这一刀留下的问题,要从一个反常的例子说起:V3 训练的时候,一点 TP 都没用。报告说是显存抠得够细,用不着。
再看参数都在哪:几乎全在一种叫「专家」的窄网络里。切进一个很窄的矩阵,每人分到的活更少,要递的门板一块不少,跟刚才那条平线往下掉是同一个道理。
那就别劈矩阵,按专家切。」
只说结论:TP 的账跟 batch 无关,只跟隐藏维和切几份有关。式子在课件 3.4。
⚠️ PP 的三种改进(VPP、Zero Bubble、DualPipe)点名就够,别一个个讲机制。
🖥 本节主屏:课件 第三节 第二刀:切权重 · 主图 fig-intensity
第四节 第三刀:切专家(10′)
🎯 这一节留两样:EP 最重的病是负载不均;attention 和专家可以各配各的切法。
🖥 屏幕:滚到课件第四节标题。
「V3 的参数,97% 都在专家里。可病人不会平均挂号:最忙的那个专家,决定所有人等多久。
这类模型叫 MoE:V3 除了最前面三层,每层有 256 个并排的小网络,叫专家;每个字只挑其中 8 个去算,其余不碰。」
🖥 屏幕:fig-moe-params,整张;讲完再指底下的绿框。
「先看这根条:100 份参数里,97 份在专家身上;注意力、词表这些,还有每层一个人人都要过的共享专家,加起来只有右边那一小截。」
「那用上一刀的 TP 去切专家行不行?不划算:V3 每个专家中间那一层只有两千零四十八维,TP 切 8 份,每张卡只剩两百五十六维,矩阵小得可怜,要递的门板却一块不少。
所以对 MoE 模型,最省事的切法不是把每个专家劈开,而是把专家整个分给不同的卡:搬病人,不劈医生。这叫专家并行,EP。
回到那座藏书楼:256 个专家书架整架分给 64 个阁,每阁 4 架,拿着就能用;跟 FSDP 切碎了再拼正好相反。
你看底下这行,就是 V3 训练时的真实配置:16 路流水线、64 路专家并行,TP 一路都没有。」
🖥 屏幕:anim-ep,先闭嘴看完一圈(10 秒);讲病的时候再放一遍,等专家 0 门口排出 7 个再指。
「它的通信就是第一节最后那一种,AllToAll。
像医院分诊:每个 token 先由路由决定去看哪几个专家,派过去,在专家门口排队;看完,再送回原来的卡。每一层两次。
AllToAll 是网络最怕的那种。V3 压它用了两招。」
🖥 屏幕:fig-ep-route,先左后右,最后指绿色短弧。
「左边是不管不顾:一个 token 选了 8 个专家,要是 8 个专家各在一台别的机器上,就跨机发 8 份。
右边是 V3:路由挑专家之前先挑机器,最多 4 台。每台机器跨机只发一份,先落到同编号的那张卡,再走机器里的 NVLink 转给真正的专家。派发还从两个字节压成一个。一算,是左边的四分之一。」
「为什么敢在机器里多转几手?算一下这笔账。跨机那一份,一台机器只收一次;到了机器里,再走 NVLink 转给那几个专家。NVLink 比跨机网络快大约 3.2 倍,所以跨机慢慢送到一份的时间里,机器里已经能转出去 3.2 份,不多花时间。
4 台机器,每台转 3.2 个专家,4 乘 3.2,差不多 13。所以报告说,同样的通信量,其实能选到 13 个专家,V3 只用了 8 个。账只跟去了几台机器有关,跟选了几个专家无关。」
「可这一刀真正的病不在通信,在这根队。别的刀切得匀不匀,大多是配置定的,事先就知道。
EP 不行:哪个专家忙,要等路由算完才知道,而且每一批都不一样。你看专家 0 门口排了 7 个,别的只有一两个,所有卡都得等它排完。」
「更要命的是 V3 一个 token 都不丢。别家常设一个容量上限,专家门口满了就把多的扔掉;V3 不扔,所以不均就直接变成等待。」
「而且它会越滚越大:越受欢迎的专家分到的 token 越多,学得越好,就越受欢迎,别的专家荒掉。花一个大模型的显存,训出一个小模型。」
🖥 屏幕:fig-ep-bias,从左往右三张,指红虚线。
「老办法是在训练目标里罚「分得不匀」,等于逼分诊员改诊断,会拖累模型学东西。V3 换了个办法:在门口挂个号牌。
号牌就是给每个专家的分数加一点、减一点:每一步结束看一眼,谁超载就减 0.001,谁闲着就加 0.001。」
「为什么说它不改诊断?路由给每个专家打一个分,这个分有两个用处:一是挑前 8 名,二是决定挑中的专家说话的分量。号牌只加在「挑前 8 名」那一步;挑中以后,分量还是按原来的分算。所以它只影响病人被分到哪个门口,不改医生的诊断。你看这个示意模拟,最忙的从平均的两倍多,慢慢压到一点零几倍。
推理的时候,再把热门的专家多复制几份,分到不同的卡上。」
🖥 屏幕:fig-fold。
「还有一件事。一层里,attention 和专家是两种完全不同的形状。
你看左边:4 张卡一组,合起来算一份 attention,两组各管一批请求。右边同样这 8 张卡,每张放 32 个专家。」
🖥 屏幕:fig-tep-dep,先左后右,一行一行对着比:请求、注意力、KV、专家,最后看底下四行。
「推理里最常见的两种配法各有简称:TEP 和 DEP,后面跟的数字是一共几张卡。专家那一半两边一样,都是铺开;差别全在 attention:几张卡是一起算同一批请求,还是各算各的一批。」
「先看左边 TEP4。四批请求,四张卡每张都有;attention 按头切,每张卡算四分之一的头。可 V3 这类模型的笔记只有一个头,切不开,所以每张卡都得存一整份全部请求的笔记,红框那四份,白存了三份。
每层 attention 算完,四张卡各有一份部分结果,要 AllReduce 加起来。加完以后每张卡都有全部的 token,专家那一步就各算本卡的专家,再 AllReduce 合一次。好处是每个请求有四张卡一起算,单个请求出字快。」
「再看右边 DEP4。D 就是数据并行:每张卡只管自己那一批请求,只存自己的笔记,一点不重复;attention 在本卡算完,不用通信,代价是 attention 的权重每张卡都存一整份,不过在 MoE 模型里它只占几个百分点。
到了专家那一步,每张卡手里只有自己请求的 token,得 AllToAll 派发到专家所在的卡,算完再合并回来。
好处是笔记不重复,同样的显存装得下多得多的请求,每个专家分到的 batch 也更大,吞吐就上去了。坑是各卡的请求长短不一,忙闲不均;一张卡暂时没请求,也得陪着跑一遍空的前向,不然别人的 AllToAll 等不到它。」
「一句话:TEP 追求单个请求快,DEP 追求一起跑得多。出字那一段拼的是吞吐,笔记又最占地方,所以常常选 DEP。」
「差别能有多大?我们在 GB300 上测过:出字那一段从 TP4 换成 DEP8,同样并发下每张卡的吞吐翻了一倍。细账第七节算。」
「其中最大的一笔,就是刚才左边那排红框:笔记切不开,TP4 就在四张卡上各抄一遍。为什么切不开,下一刀细讲。
这就是这一刀留下的问题:专家摊开了,attention 那一半还有样东西跟着对话长度往上涨,前三刀谁都没碰过:序列。」
被追问 GB300 倍数时:运行手册里的「2.85 倍」是 DEP8 并发 768 对 TP4 并发 512 的总量比(60,065 ÷ 21,100),「3.09 倍」是并发 1,536 那行。同并发 512 是 2.61 倍,课件用的是这个。
⛔ 不要把 TEP / DEP 跟 Megatron 的 ETP / EDP 放在一起讲。
名字只差一个字母顺序,意思完全不同。台上提了就得花三分钟解释,课件 8.6 有专门的警告框,会后让人自己看。
⚠️ GB300 那个例子要说「每张卡」、说「同样并发」:每卡 2.09 倍(总量 2.61 倍)。并发拉到 1,536 每卡能到 2.47 倍,但首字要等 95 秒,别拿那个数当头条。
🖥 本节主屏:课件 第四节 第三刀:切专家 · 主图 fig-moe-params
第五节 第四刀:切序列(13′)
🎯 这一节留一句:训练切激活,推理切 KV;TP 超过 KV 头数,多出来的全是复制。
🖥 屏幕:滚到课件第五节标题。
「一个 128K 的请求,光笔记就 8.58 GiB。你以为切到 8 张卡上,笔记也就分成 8 份?不一定,有一种切法是原样存 8 次,白存 7 份。
训练的时候,是每层要存的激活跟着序列变长;推理的时候,是这份笔记。」
「先把账算清楚,为什么一条样本会放不下。
训练这边:每一层要存的激活,至少跟序列长度成正比,序列长一倍,激活多一倍;要是不用 FlashAttention,注意力那一项还跟长度的平方成正比。
推理这边算得更具体。V3 每个字存一份压缩过的笔记,512 个数,再加 64 个数的位置信息,一共 576 个数,每个数 2 个字节,61 层都要存,一个字就是七万多字节。
128K 个字乘下来,8.58 GiB,差不多是一张 80 GB 显卡的九分之一。这还只是一个请求,线上同时有几十上百个。」
「训练这边叫上下文并行,CP:一条长序列切成几段,每张卡存一段。
难点只在注意力:每个 token 要看它前面所有的 token,而那些 token 在别的卡上。」
🖥 屏幕:anim-ringattn,先闭嘴看半圈(整圈 9 秒)。
「一种办法叫 Ring Attention。每个 token 手里有一个提问,叫 Q,拿它去翻别人的笔记。
自己的 Q 不动,别人的笔记 KV 沿着环一段段传过来,来一段算一段,边算边传。转一圈,自己那一行就填满了。又是第一节那个环。」
「它为什么藏得住通信?每一步传的是一段笔记,量跟段长成正比;算的是这一段提问对这一段笔记,量跟段长的平方成正比。
段越长,算的涨得比传的快。所以恰恰是序列越长,这个环越好用。」
「每张卡最后怎么拿到完整答案?它的提问跟每一段笔记都见过一面,每次得到一份部分结果,转一圈把几份合起来。怎么合有个坑,本节后面讲 DCP 时一起说,是同一招。」
「另一种叫 Ulysses。先说一个词:注意力分很多个头,V3 有 128 个,各算各的。
Ulysses 用的是 AllToAll 每份一样大的特例,也就是转置,把按段切换成按头切:每张卡拿到全部序列、一部分头,本卡就能算完,算完再转回去。
一句话记住:Ring 是人不动、笔记转圈;Ulysses 是换个切法。」
🖥 屏幕:fig-ulysses,先 ① 左边的灰表(指红色竖箭头、再指一行),再 ① 右边 Ring;然后 ② 从左往右三张表。
「Ulysses 光听容易糊涂,换张图看。把注意力的活排成一张表:一行是一段序列,一列是一个头。
先看这张表的脾气:同一列里,后面的段要看前面的段,所以跨段就得传笔记;同一行里,头与头各算各的,分开算根本不用说话。
Ring 是按行分:每张卡一段、全部头。列里的依赖跨了卡,只好让笔记沿环转一圈。」
「Ulysses 的想法是:既然行里没依赖、列里有依赖,那我按列分不就好了?
进来的时候是按段分的,因为前面的逐 token 运算本来就按段切。做一次 AllToAll:卡 k 把自己那行的第 j 格发给卡 j,留 1 格,发 3 格。
换完就是中间这张:每张卡一个头、全部的段。这一列要看的东西全在本卡,注意力在本地算完,一次都不用问别人。算完再 AllToAll 一次,换回按段分,接着做后面的运算。」
🖥 屏幕:anim-ulysses,切手动模式,一步一步点「下一步」:先停在头 0 散在四张卡的那一幕,再看卡 0 单独发,最后大家同时照做(共 26 秒)。
「动画里再看一遍,这回按卡摆:每张卡左边一列是按段,右边一列是按头。先看卡 0:头 0 留下,头 1、2、3 分别飞到卡 1、2、3 的右列。其余三张卡同时照做。换完,每张卡右列就是一个头的全部四段。」
「两者各有长短。Ulysses 的好处是:序列长一倍、卡也多一倍,每张卡的通信量不变。
它的天花板是头数:换成按头切以后,每张卡至少得拿一个完整的头,所以并行度不能超过头数;KV 头比提问头少的模型,就卡在 KV 头数上。
Ring 没有这个上限,但每一步要等一段笔记传过来。」
🔍 讲深一点:Ulysses 跟 TP 差在哪;拿 V3 一步一步走一遍;什么场景用 Ulysses、什么时候配成 USP;Ulysses 跟 Ring 各好在哪(被追问或时间富余时用;不计入地板)
一、注意力里面,跟 TP 一模一样
「换完以后,每张卡算几个头、全部序列,这跟 TP 切注意力确实是同一个样子。也别想着「序列只切一段就退化成 TP」:Ulysses 里序列切几段、头就分几组,两个数都等于卡数,绑在一起,没法只切头不切序列。」
二、区别全在注意力外面
「看三件事。权重:TP 按头把权重切开,每张卡只用自己那几个头的投影;Ulysses 先投影、后换手,每张卡要给自己那段 token 算出全部头的 Q、K、V,用的时候得有全部头的投影权重。Ulysses 本身只省激活,不省权重;论文是叠上 ZeRO-3,平时把权重分片存,用到时再 AllGather。
注意力外面:TP 每张卡都拿着完整的序列;Ulysses 每张卡只拿自己那一段,用完整权重自己算完,MLP 那段一个字节都不用传。
传的东西:TP 传部分和,输出投影后做一次 AllReduce,把整条序列的激活加起来;Ulysses 传激活本身,每张卡只传一份里的卡数分之一。」
「跟它最像的是 Megatron 的 TP 加序列并行:那边进注意力前,把整条序列的输入 AllGather 到每张卡;Ulysses 先在本卡算出 Q、K、V,再互相换。论文比的就是这两种:Megatron 每张卡每层传 4Nh,Ulysses 是 4Nh 除以卡数。」
三、拿 V3 走一遍:128 个头、一百万 token、128 张卡
「V3 的 config 是 128 个头。MLA 先不管,假装每个头的 Q、K、V 都是 128 维。序列取 2 的 20 次方,一百零四万八千多,切 128 段,每段正好 8192 个 token。卡 0 拿第 0 段,卡 1 拿第 1 段,依此类推。」
「第一步,各算各的投影。每张卡用全部头的投影权重,把自己那 8192 个 token 变成 Q、K、V。这时手里是自己那段的全部 128 个头:光 Q 就是 8192 × 128 头 × 128 维,半精度 256 MiB,K、V 一样大。」
「第二步,第一次 AllToAll。每张卡把 Q 按头切成 128 块,每块是 8192 个 token 乘一个头,2 MiB。几号头就寄给几号卡,自己那号留下。K、V 照做。
寄完看卡 5:128 张卡各寄来一块,全是头 5,分别属于第 0 到第 127 段。按段号从小到大接起来,就是头 5 在整条一百万 token 上的 Q、K、V。这就是「拼」,顺序不能乱。」
「第三步,算。卡 5 直接调 FlashAttention,带着因果遮罩算完头 5,不用找别人要任何东西;一百万乘一百万的分数矩阵不会真摆出来,是一块一块算的。白捡一个好处:每张卡都算一个头的整条序列,活一样多,因果遮罩不会让谁忙谁闲。」
「第四步,第二次 AllToAll,原路寄回。卡 5 把头 5 的输出按段切成 128 块,第几段寄回第几号卡。
寄完看卡 0:收到头 0 到头 127,全是第 0 段。顺着头的方向拼起来,就是第 0 段完整的注意力输出。这就是「合」。」
「第五步,回到老样子。卡 0 用完整的输出投影把 128 个头压回 7168 维,加残差、LayerNorm、MLP,全在本卡把自己那 8192 个 token 算完。下一层再来一遍。」
四、账
「每张卡每层往外寄:Q、K、V 三份加输出一份,每份 256 MiB 寄走 127 块,合起来约 1 GiB,正好是 4Nh 除以 128。反向沿同一条路倒着走,按对称再来这么多。
换成 TP 128 路:每张卡要拿着完整的一百万 token,一层的输入激活就是 14 GiB;每次 AllReduce 加的也是这 14 GiB,走环每张卡要发将近两倍,注意力和 MLP 各一次。」
「一句话:注意力里面,Ulysses 就是 TP 那种按头分;区别是它先投影再换手,投影要用全部头的权重,注意力外面每人只管自己那一段,代价是前后各换一次手,每张卡只换卡数分之一。」
五、什么场景用 Ulysses,什么时候配成 USP
「先说权重:Ulysses 自己不省权重,但这事本来就交给 ZeRO-3 或 FSDP。论文 3.3 节把序列并行那组卡直接并进 ZeRO-3 的分片组;下面那个视频生成的例子,配的也是 FSDP 加 USP。所以它受限不在权重,在头数和网络。」
「适合的场景:batch 很小、序列很长,说准一点,是一条样本自己就塞不进一张卡。数据并行按样本分,最多分到一张卡一条,再往下分不动,只能在样本里面切。序列不长、batch 很大,直接数据并行就够了,轮不到它。」
「场景一,长上下文训练:把模型从几千 token 续训到几十万、上百万,每张卡连一条样本的激活都放不下。Ulysses 管激活,ZeRO-3 管权重。
场景二,视频生成推理。Wan 2.1 的 README 里,八卡推理就是 FSDP 加 USP,14B 模型写的是 Ulysses 等于 8。一个请求只出一段视频,batch 是 1;高清视频切成 token,序列很长;注意力是双向的,没有因果遮罩,也没有 KV cache。用户要的是这一个请求快,数据并行帮不上,只能把这一条序列拆到八张卡上。
同一个 README 里还有反面例子:1.3B 模型只有 12 个头,除不尽 8,README 写的是八卡改用 Ring。」
「不适合的:LLM 推理的 decode,每步只出一个 token,没有长序列可切,切 KV cache 走的是本节后面的 DCP。已经开了 TP 的,TP 也按头切,头先被分掉一轮,留给 Ulysses 的就少了。」
「什么时候配成 USP,三种情况。
卡数比头数多:USP 论文的例子,Llama 3 8B 只有 8 个 KV 头,想开 16 路,就配 Ulysses 8 × Ring 2。
头数除不尽:上面那个 12 头的模型,README 推荐纯 Ring;按 USP 的规则也可以配 Ulysses 4 × Ring 2,12 能被 4 整除。这一条是按规则推的,README 里没写。
跨机器:AllToAll 最怕慢线,Ulysses 那一维留在一台机器的 8 张卡里走 NVLink;Ring 只跟邻居说话、能边算边传,放到机器之间。」
「回到 V3 的例子,按字节算(每卡每层前向,头维照前面假设):纯 Ulysses 128 路约 1 GiB,跨机器的不到 1 GiB;USP 机器里 Ulysses 8、机器之间 Ring 16,光跨机器那段环就约 7 GiB 半。
所以 128 个头够分、网络的 AllToAll 吃得住时,纯 Ulysses 反而传得最少;USP 是头不够分、或者 AllToAll 跨机器跑不满时的退路。这笔账按公式推,没有实测。」
「一句话:一条样本自己塞不下、又想让一个请求变快,用 Ulysses;头不够分或者要跨机器,配成 USP;权重一律交给 FSDP 或 ZeRO-3。」
六、Ulysses 到底好在哪:跟 Ring 比一比
「常见的误会是 AllToAll 传得多。其实反过来:还是 V3 那个例子,每卡每层前向,Ring 每张卡要收齐另外 127 段的 K、V,约 64 GiB;Ulysses 约 1 GiB,差六十多倍。
原因看卡数加倍:Ring 每张卡总得把整条序列的 K、V 见一遍,卡再多这个量也不变,约 2Nh;Ulysses 每张卡只换自己那份的卡数分之一,4Nh 除以卡数,卡越多传得越少。」
「Ulysses 另外三个长处。
注意力整块算:换完手每张卡是一个头的整条序列,直接调现成的 FlashAttention,稀疏、滑动窗口这些变体也不用改;Ring 要把注意力拆成小块、一块块合 softmax,得专门写 kernel,块小了算力吃不满。
天然不偏科:每张卡都算一个头的整条序列,活一样多;Ring 碰上因果遮罩,后面的段看得多、前面的段闲着,得把序列打乱重排才拉得平。
步数少:每层前后两次 AllToAll;Ring 要一步一步传 127 次。」
「Ring 的长处两条:没有头数上限;能边算边传。注意力的计算量跟序列长度的平方涨,序列很长时每一步算的比传的大得多,那六十多 GiB 能藏在计算后面。Ulysses 的 AllToAll 藏不了,卡在关键路径上,传完才能算。
所以 128 卡、一百万 token 直接上 Ring 能跑,计算多半盖得住通信;代价是网卡上多跑六十多倍的字节,还要跟数据并行、专家并行抢同一根线。头够分、AllToAll 吃得住,Ulysses 更省。」
🖥 屏幕:fig-usp,先 ① 左表到右表那一步,再指右表里的红色上下箭头;最后 ② 那张对比表。
「两种还能叠起来用,叫 USP。还是那张表,这回分成块。4 张卡、2 台机器。
第一步,在机器里做 AllToAll,这就是 Ulysses,只在 2 张卡之间:机器一的卡 0 拿前两段的头 0、头 1,卡 1 拿前两段的头 2、头 3;机器二同理,拿后两段。
现在每张卡是两段乘两个头。头已经分开了,剩下跨段的部分交给环:拿同一批头的上下两块互传笔记,卡 0 和卡 2 一对,卡 1 和卡 3 一对,这一步走机器之间。」
「看下面这张对比表。USP 的总卡数 = Ulysses 那一维乘环那一维。头数上限只管 Ulysses 那一维,环那一维随便加,所以头少的模型也能切到很多卡上。
摆法也顺:AllToAll 最怕慢线,留在机器里;环一步只跟邻居说话、还能边算边传,放到机器之间。这是按两种通信的脾气归纳的常见摆法,不是论文的硬规定。」
🖥 屏幕:anim-usp,手动模式一步一步点(共 27 秒);在「卡 0 管头 0、1,可段 2、3 的笔记在卡 2 上」那一幕多停一会儿。
「动画里看先后:先是机器一里卡 0、卡 1 互换头,机器二同时照做;这时候红框告诉你,卡 0 缺的是段 2、3 的笔记,在对面机器上。
第二步,半透明的抄件跨机器飞过去,卡 0 和卡 2 互换、卡 1 和卡 3 互换。各自算完,抄件就扔,再在机器里换回按段分。」
🖥 屏幕:fig-cp-zigzag,先只指左边的三角。
「生成式模型还有个麻烦:每个 token 只看前面的,越靠后的段算得越多。按顺序切,卡 3 算 15 格,卡 0 只算 3 格,大家都得等卡 3。」
💬 互动:盖住右半边,连同标题和落点带(标题里就写着「之字形切正好摆平」),问「8 块、4 个人,怎么分最公平?」等有人说出「轻的配重的」。
「把最轻的一块和最重的一块配成一对,交给同一张卡。右边这样分,每张卡都是 9 格。」
🖥 屏幕:fig-kv-dup。
「推理这边更反直觉。V3 提问的头有 128 个,笔记却压成了一个头,大家共用。
TP 是按头切的:提问分得开,笔记那一个头切不开,只能每张卡各存一份一模一样的。8 张卡,红色那 7 份是白存的。
上一节 GB300 那个 V4-Pro 也是一个笔记头,TP4 白存了 3 份,毛病之一就在这儿。」
「一般的规律是这样:TP 按头切,笔记有几个头,就最多分给几张卡。
很多模型把笔记定成 8 个头,比如 Llama 2 70B,TP 8 路正好一张卡一个头,一点不浪费。TP 一旦超过笔记的头数,每个头就被复制「TP 除以头数」次。
MLA 把笔记压成了一个头,这个除法最难看:TP 开几路,就存几份。」
🖥 屏幕:anim-dcp,先闭嘴看完第一幕「只开 TP,四块红」,等画面换成 DCP 再开口(整圈 11 秒)。
「解法叫 DCP:笔记按 token 轮流存到这几张卡上,还是原来那几张,一张不加。
新字的提问发给每张卡,各自在自己那份笔记里查,最后合一下。每层多付三次通信:收齐提问、交换分母、合并结果,换回被复制掉的显存。又是拿通信换显存。」
「两个细节。为什么按 token 轮流存,不是一段一段地存?因为笔记一直在长,每出一个字就多一条,轮流存,新来的字也自然均摊到每张卡上。
DCP 开几路?最多开到 TP 除以笔记头数,也就是刚好把被复制的那几份收回来,再多就没东西可收了。」
🖥 屏幕:fig-softmax-merge,先中间(错的),再右边(对的)。
「合的时候有个坑:注意力是按分数加权平均,要除以所有分数的总和,可每张卡只看得到自己那份笔记。
各除各的再平均,是 14,错了:卡 1 只有一个字,却占了一半的票。正确做法是先别除,分子加分子、分母加分母,最后只除一次,是 11。
跟合并两个班的平均分一样,得带上人数。所以每张卡还得交出自己的分母,这就是中间那一次通信在交换的东西。Ring 在路上这样合并,DCP 在终点这样合并,是同一招。」
「推理其实分两段:先一口气读完整个问题,叫 prefill;再一个字一个字往外出,叫 decode。DCP 管的是 decode。」
「prefill 那边也有对应的一种,叫 PCP:把一个长问题切到几张卡上一起读,第一个字出得早。
两个只差一个字母,其实是一前一后的两步。把注意力看成一张表,一行是一个提问,一列是一条笔记。prefill 一次有几千个提问,就按行切:四千行切成四份,每张卡一千行,每行在一张卡上算完,只是要把前面的笔记收齐;它为了快,要另外加卡。」
「decode 每步只剩一个提问,没有行可切了,DCP 才进一步,把这一行按笔记切开,每张卡算一段,再按先别除合起来;它为了装得下,用原来那几张卡。」
「这一刀留下的问题:prefill 读一个长问题,要的是把序列切开;decode 要的是 DCP 把笔记摊开。同一批卡只能摆一种切法,硬塞在一起,谁都配不好。」
⚠️ Ulysses 只讲结论(通信量不随规模涨、并行度不超过头数),不推公式。
⚠️ Ring Attention 那段动画画的是不带因果掩码的情形,别说成它自带负载均衡。
2026-09-26 现场:五、六两节被嫌「随便一提就过去」,已把课件里的推导(8.58 GiB 的来历、Ulysses 的上限、TP÷头数、DCP 度数、PCP)写进台词。
🖥 本节主屏:课件 第五节 第四刀:切序列 · 主图 fig-kv-dup
第六节 第五刀:不切张量,切工作(11′)
🎯 这一节留一句:把性质不同的两种活拆到两批机器上,每一边才能挑自己的切法。
🖥 屏幕:滚到课件第六节标题。
「拆给两批机器,中间还得来回搬东西,听上去更费卡?结果反过来:3 张卡能顶 7 张。
上一节留下的问题是:prefill 和 decode 要的切法不一样。其实不只切法,连吃的东西都不一样。
前四刀切的都是张量。第五刀换个思路:一个请求里本来就有两种很不一样的活,干脆拆到两批机器上。」
「上一节说过,推理分两段。prefill 一口气读完整个问题,几千个 token 一起算,卡算不过来,这叫吃算力;
decode 一次只出一个字,每一步却要把权重和笔记从显存里读一遍,读都读不过来,这叫吃带宽。」
💬 互动:问「用聊天 AI 的时候,觉得等第一个字更烦的举手?觉得字蹦得慢更烦的?」举手就行,不点人答。
「两种都烦,而且放在一起会互相传染。你正看着回答一个字一个字往外吐,别人丢进来一本一百页的说明书,你的字就停了。
先照顾新来的,老用户的字就卡住;先照顾老用户,新来的就一直等第一个字。
这两种烦各有名字:等第一个字的时间叫首字延迟,TTFT;字和字之间的间隔叫 TPOT。语音助手最明显,平均速度再快,说一句停一段,就觉得卡。
挤在同一批卡上,引擎每一步都得决定先干哪个。长问题一来,它的 prefill 要占好几步,这几步里所有正在出字的请求都得等:TTFT 和 TPOT 一起变差。」
🖥 屏幕:anim-pd,先闭嘴,看上面那条被截断(整圈 11 秒)。静图 fig-pd 台上不放。
「像一个厨房:有人备菜,有人出菜。放在一起的时候,来了一桌大单,备菜要占好几分钟,这几分钟里所有桌都等着上菜。你看上面那条,长橙块落下来,那几格一个字都没出。
拆开之后,备菜的在另一个灶台上做,做完把备好的料递过来,出菜那边一步不停。这盘料,就是上一节那本笔记,KV cache。」
「下面那条多用了一批机器,比的是出字断不断。」
「有人会问:把大单切成小块,跟出菜穿插着做,不就行了?这叫分块 prefill,确实能缓解。
可它有两个问题。块切小了,备菜自己变慢,因为每一块都要把前面的笔记重读一遍;更根本的是,两拨人还在抢同一个灶台,只能用同一套切法。
PD 分离干脆拆开:prefill 机器只做 prefill,算完把笔记交给 decode 机器,decode 机器只管出字。」
🖥 屏幕:fig-kv-trip,先指上面那根灰条,再指下面那根细三色条。
「这一趟要多久?我们在 TPU v7x 上搭过一套,一台做 prefill、一台做 decode,跑 Qwen3-Coder-480B:八千 token 的问题,按带宽估大约一百毫秒,只占 prefill 的百分之五到十。这个模型笔记小,换模型得重算。
它敢走慢线,是因为一个请求只传一次。记住这一点,下一节要用。」
「一百毫秒怎么来的?主要是中间那段跨机器。八千个字的笔记:K、V 两份,62 层,8 个笔记头,每头 128 个数,每个数 1 个字节,乘出来约 1.04 GB。
机器之间按每颗芯片分到 100 Gb/s 保守估,也就是每秒 12.5 GB,路上八十多毫秒;两头从显存到内存各十毫秒左右,合起来一百毫秒上下。
从这一刀往后,调度的中心其实是那份笔记:它跟着请求搬家。Kimi 的 Mooncake 干脆把整套推理系统叫作「以 KV cache 为中心」。
反过来,请求都很短、量也不大的时候,多出来这趟传输和两套机器就不一定划算,放在一起、用分块 prefill 缓解就够了。」
🖥 屏幕:fig-pd-ratio,先上排七张灰卡,再下排三张。
「拆开到底省不省?有篇论文算过一笔很干净的账:一张卡两样都做,每秒只接得住 1.6 个请求;只做 prefill 能接 5.6 个,只做 decode 能接 10 个。
两张做 prefill、一张做 decode:prefill 那边两张合起来每秒 11 个多,decode 那边 10 个,三张卡每秒接 10 个;混着做要接 10 个,得 7 张卡。多用一种机器,反而省了一半多的卡。
思路是让两边差不多同时忙满。经验上,长问题的业务配两台 prefill 一台 decode,长回答的业务反过来,一台 prefill 两台 decode。
论文把配比和各自的切法一起搜,同样的延迟要求下,最多能多服务 7.4 倍的请求,比的是 DeepSpeed-MII。刚才那个三顶七,只是其中一个单卡算例。」
「更重要的是,两边终于可以用不同的切法了。prefill 这边用上一节的 PCP,把几千个提问按行切到几张卡上一起算,第一个字出得早,代价是要另外加卡;decode 这边用 DCP,每个请求只剩一个提问,就进一步把笔记切开,装得下、读得少。」
🖥 屏幕:往回滚到第六节最上面那张 fig-decode-ai(课件里它排第六节第一张,讲稿故意留到这里才用),先指红线,再指蓝点,最后指橙点。
「先把 decode 的脾气算清楚。它每一步都要把权重从显存里读一遍,读一次只够这一批用一次。一批里有多少个请求在一起出字,读一个字节就换来多少次计算。
还是第三节那把尺子,师傅和小工,只是这回小工是从仓库,也就是显存,往工位上搬工具:每出一个字,工具都得搬一趟,一批有几块门板,这趟就用几回。v7 每秒算两千三百多万亿次,每秒从显存读七万多亿字节,一除三百一十多。一批凑不到三百来个请求,师傅就在干等。」
「MoE 更难。每个专家只分到这一批的三十二分之一,V3 是 256 个里挑 8 个。所以一批得凑到一万个左右,每个专家才吃得饱。
字节的 MegaScale-Infer 论文在 A100 上算过同一笔账:一批至少 156 个请求,Mixtral 每个专家只分到 39 个。模型这边也在帮忙凑:MLA 把笔记压小,一张卡装得下更多请求,一批就大。
一张卡哪来一万个请求?只能让很多张卡把自己的 token 都送到同一批专家那儿去:专家铺到更多卡上,送 token 来的请求也更多,每个专家分到的 batch 就更大。这就是 DEP、Wide-EP,还有下面这个 AFD,说到底都在凑这一批。」
🖥 屏幕:fig-afd,先指左边的连线,再指右边三条道。
「decode 这边还能再拆一层:attention 跟请求绑在一起,专家只要 token 够多。把两者放两组机器,叫 AFD,专家那边同时接好几组 attention 的 token,这一批就凑大了。」
「代价是每层来回一趟,所以把这一批请求分成三组轮着跑。注意切的是 batch,不是序列:decode 这一步每个请求只有一个字,比如三千个请求,就分成三组、每组一千个字。盯着 A 看:算 attention 一格,去半格,专家一格,回半格,第 3 格又轮到它,两边都填满了。」
「为什么是三个小批?MegaScale-Infer 算过:要把一来一回的通信藏住,至少得三个,通信慢的时候要四个。它报告每张 GPU 的吞吐最高提升 1.9 倍。字节的 MegaScale-Infer、阶跃的 Step-3 都是这个路子。」
「同样的思路还能往前推一段:多模态模型的视觉编码器单独部署,算好的向量再传给语言模型,跟 PD 连起来常写作 EPD。
说到底,第五刀就一个意思:性质不同的活,别挤在一起,拆开以后每一边挑自己的切法。」
「这一刀留下的问题:五刀都讲完了,可真到一个集群上,它们是同时存在的。
谁放在一台机器里,谁跨机器?摆错了位置,前面每一刀省下来的,都会被网络吃回去。」
⚠️ KV 那一趟只讲中间那段怎么算(1.04 GB ÷ 12.5 GB/s),两头各「十毫秒左右」一带而过。
⚠️ 动画里的格数是示意,不是实测时序;「16 步出 11 个字」别当成实测数字说。
🖥 本节主屏:课件 第六节 第五刀:不切张量,切工作 · 主图 anim-pd
第七节 摆到机器上(7′)
🎯 这一节留一句:说得勤的放快线,说得少的才走慢线;先选对切法,再调参数。
🖥 屏幕:课件 s七,停在标题上。
💬 互动:先别切到 fig-freq(它的标题就是答案)。先问:「把集群想成一栋写字楼。TP 像几个人合写合同、每段都要对一遍;PP 像按章节递稿;DP 像另一个组下班前对一次账。谁必须坐同一张桌?」记下台下怎么分,讲完这一段再回来对。
🖥 屏幕:fig-freq,整张,先指下半截。
「同样的卡、同样的切法,只换一种摆法:一个走 17 格,一个走 73 格。
一个集群里的线,不是一样快的。先看图下半截:GB300 一整柜 72 块卡连成一个 NVLink 域,每块卡 1.8 TB/s(收发合计);出了这一柜只能走网卡,每块卡 200 GB/s,慢九倍。TPU 更悬殊:一个切片里走 ICI 快线,跨切片走数据中心网络,同口径比慢五十倍左右。
再看上半截:刀也不是一样勤的。我们按一个示意配置,数了每一刀一步要说几次话:TP、EP、FSDP 每一层都要说,一步上千次;PP 十几次;DP 一步一次。」
🖥 屏幕:fig-office,由里往外指三圈。
「刚才投的票,对一下:合写合同的必须同桌,递稿子隔层楼也行,对账在别的城市都可以。说得勤的坐里圈,说得少的去外圈。
光数次数还不够,还要看能不能边算边传、藏到计算后面。TP 藏不住:每一块末尾那次加总不做完,下一块就没法开始,所以它必须待在快线里。
EP 和 FSDP 能提前发、藏住一部分,就有人让它们跨出去:V3 的专家并行横跨了 8 台机器,因为 H800 机器内外只差三到四倍,远没有 TPU 悬殊;Llama 3 把 FSDP 放在了最外层。」
「数据并行那一次量虽然大,也好办:反向从最后一层往前算,后面几层的梯度一算好就能先传。」
🖥 屏幕:anim-meshmap,一步一停:摆法一第 1 轮停住时指同色箭头「环在机器里」;摆法二第 1 轮停住时指红箭头「这两段过慢线,其中一段从外面绕回来」。
「8 张卡、TP4 乘 DP2,同一个颜色就是一个 TP 组。
摆法一,TP 组就在一台机器里,八轮来回都走快线,只有最后那一次 DP 过慢线。摆法二,TP 组横跨两台机器,一轮要等最慢那一段,所以每一轮都按慢线算。
算一下:摆法一,八轮快线 8 格,加一次 DP 过慢线 9 格,17 格;摆法二,八轮都按慢线算,8 乘 9 是 72,DP 那一对恰好在同一台机器里只花 1 格,73 格。
17 格对 73 格,慢四倍多。快慢一比九是示意,不是实测。」
🔍 讲深一点:在 TPU 上,摆法是怎么写出来的:GSPMD 和普通 SPMD(被追问或时间富余时用;不计入地板)
一、普通 SPMD:你替每张卡写程序
「SPMD 是一种编程模式,单程序、多数据:每张卡跑同一份程序,各吃各的那份数据。普通的写法里,每张卡拿哪一块、什么时候通信、调哪个 AllReduce,全得自己手写。Megatron 的张量并行,就是这样一行一行手写出来的。」
二、GSPMD:你写一张大卡的程序,编译器替你切
「GSPMD 是 Google 二零二一年的论文,是 XLA 编译器里的功能。按「只有一张大卡」的样子写程序,只在几个关键张量上标一下:这个维度沿着网格的哪个轴切。编译器把标注传播到其余张量上,自己决定每一步怎么切,自己插入 AllGather、ReduceScatter 这些通信,最后生成一份每张卡都跑的程序。」
「它的价值有两条。一是通用:数据并行、张量并行、FSDP、专家并行,都只是换一种标注,不用改模型代码;第三节那张两行四列的 FSDP 乘 TP,在 TPU 上就是这么标出来的。二是能扩展:不管多少张卡,编译出来都只有一份程序,编译时间不跟着卡数涨。」
三、跟这一节的关系
「本节说的摆法,在 TPU 上就落在这一步:先把芯片排成一个多维网格,再决定哪根轴给 TP、哪根给 FSDP。轴挑错了,就是动画里的摆法二。今天 JAX 里 jit 加 sharding 的写法,还有 MaxText,底下用的都是它;它的前身是 GShard,二零二零年用来训六千亿参数的 MoE 翻译模型。」
「一句话:普通 SPMD 是你替每张卡写程序;GSPMD 是你写一张大卡的程序,编译器替你切。」
「换回第三节那把尺子看:每根线都有自己那条硬件线。线慢九倍,门槛就高九倍。隐藏维跟 V3 一样宽的模型,TP 8 路在 TPU 快线上刚好贴线,放到慢一个数量级的线上就远远掉下去了。
所以 TP 一般不出一台 8 卡机器;GB300 把快线扩到整柜,专家并行才敢往大了开。」
🖥 屏幕:fig-topo。
「切法选错了,参数调得再细也没用。切专家时说 GB300 那笔细账留到这儿,现在算,按每张卡看。
原始脚本每卡 1820。TP4 上能调的都调了,prefill 从一台加到三台,总数从一万四千五涨到两万一千一,涨了四成五,可卡也翻了一倍,每卡反而掉到 1319,出字间隔一直在 50 毫秒上下。
最后一行换的是 decode 的切法:换成 DEP8,卡也从 4 张变成 8 张。同样的并发,每卡 2758,两倍多;出字间隔从 46.8 毫秒降到 11.8 毫秒,首字延迟从 55.8 秒降到 22.8 秒。出字间隔为什么同时降下来,原始记录里没有拆开归因。」
「钱从哪来?切序列时说过,TP4 把笔记在四张卡上各存一份;换成 DEP8,笔记不再重复,专家也摊到 8 张卡上,省下的显存都变成了更大的 batch。
这 8 张卡横跨两台机器,但还在同一柜的快线里。先问切法对不对,再动参数。」
🖥 屏幕:滚到 7.4 那张对照表。
「把前面几节串起来,挑并行像闯五关:装得下吗?快线那一圈多大,TP、EP 别超过它;序列长吗?还不够、或者非跨慢线不可,才上 PP;还剩卡,全给数据并行。」
「表里只看两个「不用」。V3 在 8 卡一台的 H800 上不用 TP,专家并行横跨 8 台。
腾讯的混元 3 在 TPU 上,256 颗芯片全在一个切片里、全是快线,FSDP 已经能把专家摊开;小规模试过专家并行,16 颗芯片开 4 路,吞吐掉了七成,那次 batch 同时减了一半,混着别的因素,原因还没查清;最后不用 EP,专家交给 FSDP 切。
同样五步,走出来几乎没有重合,因为快线长得不一样。别人家的配置不能照抄,先看自己的线。」
「到这里,每一刀切什么、多出什么话、该放哪根线,都齐了。下一节把它们摊在一张图上,那些 TEP8 之类的写法就读得懂了。」
fig-scale 台上跳过(2026-09-25 串讲后砍掉,省约 1 分钟,也不在接力线上),留给会后自学;被问到就说「加卡时连 batch 一起加,多出来的卡优先当副本」。⚠️ 别把「GPU 一跳就到、TPU 环面要绕路」接在混元的例子后面讲:教材自己说 4 路时绕路这笔账不大,接在一起台下会听成原因。
⚠️ GB300 那套的 KV 走的是柜内 NVLink,别指着它说「这就是走慢线」;「走慢线」说的是 TPU v7x 那套 PD 分离。
⛔ 不要逐行读 7.4 那张对照表。
挑一格讲就够:混元 3 在 TPU 上不用 EP(单次小规模实测掉七成,原因没查清),V3 在 H800 上不用 TP(8 卡一台)。 两个「不用」放在一起,这张表的意思就出来了。
⚠️ 动画里 17 格对 73 格是示意模型,不是实测。
🖥 本节主屏:课件 第七节 摆到机器上 · 主图 fig-freq
第八节 全景与收尾(4′)
🎯 这一节只留一句:名字再多,先问它切的是什么、多出哪种通信、该放哪根线。
🖥 屏幕:课件 s八,放 8.1 那张全景图 fig-panorama,讲解保持折叠(右下角按钮这时显示「展开讲解」,别按)。这一节只切这一次屏,不要往下滚到表格。
「最后看一眼全景,分四列:切数据、切序列、切模型、拆工作。
今天是五刀,这里四列,因为切权重和切专家都算切模型,并成了一列。
判据只有一个:看它切的是什么。切数据,每张卡算不同的样本;切序列,每张卡拿一条样本的一段;切模型,每张卡只有模型的一部分;拆工作,每张卡只干一种活。」
「两个容易归错的地方。FSDP 算切数据,不算切模型:它确实把权重分片存着,可每层算之前都拼回整间书房,每张卡算的还是自己那份样本,省的是显存,不改变谁算什么。
序列并行单独成一类:严格说它也在切数据,只是切一条样本的内部;但它专门对付长上下文,通信方式也跟 DP 完全不同,放一起反而讲不清。」
「怎么读?拿 EP 这一格试一次。在哪一列?切模型,来自第三刀,切专家。
多出来的是哪种话?AllToAll,第一节最后那一种。该放哪根线?看右上角的圆点:实心的敢走慢线,空心的待在快线里。EP 是空心。
图上每个名字,都这样问三句。」
💬 互动:「现在你来读 PP。」等台下说出「切模型、一对一收发、实心,敢走慢线」。
「图底下这行,是 TEP8、DEP16 这种推理写法:切专家时讲过,前面的字母说 attention 怎么切,后面的 EP 就是刚读的那一格,数字是一共几张卡。
PD 分离时两边常各选一种,但没有定式:vLLM 部署 Kimi K3 是 prefill 用 TEP8、decode 用 DEP16,TensorRT-LLM 那篇文章的例子却反过来。」
「图下面那几张表是会后查的地图,我只点三个最容易踩的坑。
一、同一个 DP,在 MoE 推理里意思变了:vLLM、SGLang 里给 MoE 开 DP,开的是 Attention DP,专家层还是大家一起跑,每一步都得同步,没活的卡也得陪着跑空前向;只开 DP 不开 EP,专家层走的是 TP。
二、TEP、DEP 不是 ETP、EDP:前者是推理侧说 attention 怎么切,后者是 Megatron 训练侧说专家内部的 TP 度数和专家梯度在哪些卡之间求和,Megatron 仓库里搜 TEP、DEP 是零结果,别互相换算。
三、有些常被当成并行的其实不是:TBO、Async TP、EPLB、Offload、分块 prefill,都没有多切出一维,是藏通信、治负载、换显存或者调度。」
「回到开场那条接力线:每一刀都在补前面没管到的那一块,可每一刀都一样,拿一种通信,换一份显存或者一份算力。」
「再读一遍开场那个 V3:PP 16、EP 64、ZeRO-1 数据并行。切深、切专家、切数据;段边界收发、AllToAll、一步一次;敢跨机器、限 4 台、最便宜。开场像天书的一行配置,现在读得懂了。」
「所以选并行策略,说到底是在选:你愿意付哪一种通信,付多频繁,放在哪根线上。
型号会换,数字会过期,这一句不会。」
⛔ 不要逐行讲全景表(2026-09-26 现场:三个坑点名讲,其余不读)。
它是会后查的地图。台上只示范一次「怎么读一行」就够。
⚠️ 收尾那一句念完就停,别再补「还有什么问题」之外的话。
🖥 本节主屏:课件 第八节 全景与收尾 · 主图 fig-panorama
🚧 这份讲义还薄的地方
- [ ] 没真讲过,时间表是估的。第一次讲完按实际用时回来改。
- [ ] 没有课前题、也没有课后题。 第七节末尾很适合问一句:「如果换成 GB300 那种整柜 72 卡共用一条快线的机器,V3 那套配置里哪一刀最值得改?」