先认识五种通信,再一刀一刀地切:数据、权重、专家、序列,最后连工作一起拆开。 每一刀都在补前面没管到的那一块。
这一讲另有一份讲义(授课稿)。
讲义写的是怎么讲:每一段的目的、讲到哪里该停、常见的误解、 被问到了怎么答。内容本身在你现在看的这份正文里。
两个用法。自己上台讲:照着讲义讲,台词、切图、时间都写着。 自学:把讲义整份丢给 AI,你会得到一个既有这一讲全部背景、 也知道该怎么讲的助教,让它带你走一遍。
每个数字的出处在文末台账;自己推出来的数,都标了「本课推导」。
第一问:按常规的混合精度 AdamW 训练,每个参数要在显存里常驻下面五样东西。各占几个字节?
| 权重(算的时候用的那一份) | 字节 |
| 梯度 | 字节 |
| 主权重(优化器更新的那一份) | 字节 |
| 一阶动量 m | 字节 |
| 二阶动量 v | 字节 |
2 + 2 + 4 + 4 + 4 = 16 字节。前两样是半精度(bf16),算矩阵乘用;后三样是全精度(fp32),给优化器用。 乘上 V3 的 6,710 亿参数:9.76 TiB,约合一万 GB —— 这还不含激活。
16 字节是常规口径,梯度按半精度算。实际用 bf16 训练时,框架常把累加梯度的那份放全精度(Megatron 默认就这样,V3 也是),那就是 18 字节。
预习(先想一想,答案在这一讲的 §2.2 揭晓):
专题四把账算完了:一个 6,710 亿参数的模型,按每参数 16 字节算(权重 2 + 梯度 2 + 优化器状态 12), 光常驻的训练状态就要 9.76 TiB,约合一万 GB。最大的一块卡显存也就两三百 GB,光放下就要三四十到五六十块卡,还没开始算。 一块卡装不下,就得切。问题是沿哪一维切。
📌 V3 全部训练 2.788M H800 GPU hours(DeepSeek-V3 技术报告 arXiv 2412.19437 摘要,含预训练、长上下文扩展与后训练);2,048 块 H800(sec. 3.1)。
📌 B300 每卡 288 GB(NVIDIA DGX B300 用户手册:8 × 288 GB);TPU v7 每芯片 192 GiB HBM3e。
⚠️ 本课推导:9.76 TiB = 6,710 亿 × 16 字节;318 年 = 2.788M ÷ 8,760 小时;57 天 = 2.788M ÷ 2,048 ÷ 24。
一个训练中的张量能下刀的维度有好几个:batch、序列、隐藏维、层、专家。这一讲从头到尾只讲一件事:
这一讲按一条接力线走:切一刀,付一笔通信;切完发现还有一块没管到,再切一刀。
量每一刀用两把尺子:它多出来的通信有多频繁(决定放哪根线),每搬一个字节换来多少计算(决定会不会被拖住,第三节)。
token 与 batch:token 是模型处理文字的最小单位,大致一个字;batch 是一步喂进去的那一批数据,本讲常按 token 数算。
张量与隐藏维:模型里流动的数据都是多维数组,叫张量;每个 token 用一串数表示,这串数的长度就是隐藏维(V3 是 7,168)。
激活:前向每一层算出来的中间结果。反向时还要用,所以得先存着。
注意力头:注意力被拆成几十份并排的小注意力,每一份叫一个头,各算各的。
micro-batch:把一步要算的一批样本再切成几小份,一份一份地过。
V3:本讲反复拿来举例的 DeepSeek-V3,6,710 亿参数的 MoE 模型。
Q、K、V:注意力里每个 token 算出三样东西:Q 是「我要找什么」,K 是「我是什么」,V 是「我带着什么内容」。
新 token 拿自己的 Q 去和前面所有 token 的 K 比,按相似度把它们的 V 加权合起来。
查询头与 KV 头:注意力分很多个头,每个头都有自己的 Q;K 和 V 的头可以更少,几个查询头共用一组 KV(极端情况只有一个 KV 头)。推理时缓存的是 KV,所以 KV 头的个数决定了 KV cache 能不能按头切开。
softmax:注意力给前面每个 token 打分,再把分数归一化成加起来等于 1 的权重,这一步叫 softmax。
MLA:DeepSeek 的一种注意力,把 K 和 V 压成一小份所有头共用,所以 KV cache 小得多,但也只剩「一个头」可切。
节点:一台机器,里面通常有 4 到 8 张卡,机器内部走高速互联(NVIDIA 的叫 NVLink)。
显存(HBM):卡上自带的高速内存,模型和中间结果都得放在这儿。
算力和带宽:算力是每秒能算多少次,带宽是每秒能搬多少字节。一件活要是搬得多算得少,就是「吃带宽」,反过来是「吃算力」。
ICI 和切片:TPU 芯片之间的专用快线叫 ICI;用 ICI 连在一起的一整块芯片叫一个切片,切片和切片之间走普通的数据中心网络。
device 和轴:v7 的一颗芯片,对软件显示成 2 个 device,并行度按 device 数;切片里的芯片排成三维网格,x、y、z 三个方向各叫一根轴。
rank:参与并行的一个进程,通常就对应一张卡(TPU 上是一个 device)。
v7 与 v7x:同一代 TPU(Ironwood)的两种叫法,本讲混用。
几路:「TP 8 路」就是 8 张卡一组做 TP。写成 TP4 × DP2,意思是每 4 张卡一组做 TP,这样的组有 2 份做数据并行,一共 4 × 2 = 8 张卡。
MoE 与专家:模型里有很多组并排的前馈层,叫专家;每个 token 由一个小的路由器挑出其中几个去算,其余的不碰。
所以参数很多,每个 token 实际用到的却很少。
KV cache:生成文字时,每个已经处理过的 token 都留下一份 K 和 V,后面的 token 算注意力时要回头看它们。
这份东西要一直存着,上下文越长越大。
prefill 和 decode:推理分两段。prefill 一口气读完整个 prompt,算出第一个字;decode 之后每一步只出一个字。
decode 这一步很轻,所以要把很多请求拼成一批一起跑:权重读一遍,一批请求一起用,batch 越大越划算。
后面每一刀都会多出一种通信。这一节先把它们认全:日常用到的是五种,AllReduce、AllGather、ReduceScatter、AllToAll,再加最朴素的一对一收发。 名字看着多,但每一个都只回答两个问题:谁发给谁;数据到了之后是拼起来、加起来,还是原样放着。
一组卡按同一个规则一起发、一起收,叫集合通信。下面几张图用同一套画法,只学一次:
把四张卡想成四个同学,卡 0 是班长。
这四个都有一个「班长」,数据全压在它一条线上,卡一多就堵。所以训练里天天跑的是下面那组。
按最朴素的做法(班长挨个发、挨个收),广播和归约的班长要扛下全部流量,卡越多越堵; 通信库会把它们排成一条链接力传,让班长只发或只收一份。收集和分发的班长省不掉那份量,它手里本来就是 n 份不同的东西:总量不随卡数涨,但全压在它一条线上。
All =「人人都拿到结果」:AllGather 是收集完发给每个人,ReduceScatter 是归约完切开、一人一块,AllReduce 是归约完发给每个人;AllToAll 独一份,不加也不拼。
拆开以后,中间还能塞进别的动作。后面好几种并行白捡的便宜全从这里来:ZeRO(第二节)、张量并行配序列并行(第三节)。
⚠️ AGRS/RSAG 是本课为了说清顺序起的简写,不是通用术语。
班长模式下卡 0 要收 n−1 份、发 n−1 份,成了全场的瓶颈。换个办法:首尾相连排成一圈,谁都不当班长。
这个环,其实就是把 AllReduce 拼成了 ReduceScatter + AllGather。换一种拼法比一比,就知道它为什么赢:
📌 两种拼法:NVIDIA NCCL 文档 Collective Operations(AllReduce = Reduce + Broadcast = ReduceScatter + AllGather)。
⚠️ 本课推导:朴素班长做法卡 0 发 n−1 份;环上每卡发 2(n−1)/n 份。通信库实际会给班长做法排链或走树,这里只比最朴素的两种。
代价是步数跟着卡数涨:数据小时比的是一步步的等待,环反而吃亏,所以通信库会按数据大小自己挑算法。
数据很大时比的是带宽,环几乎是最优的;数据很小时比的是一步一步的等待,步数多反而吃亏。 所以 NCCL 这类通信库会按消息大小,在环形、树形等几种算法之间自己挑。 NVLink 交换机(NVSwitch)还能在交换机里直接做加法,每张卡发出去的又能少将近一半。
TPU 这边更直接:芯片之间的 ICI 本身就连成环面,切片够大(每一维都是 4 的整倍数)时,每一维天然就是一个首尾相接的环; 更小的切片某一维只是一条线,环要在线上折返,带宽约减半。
环面还多给一样东西:一颗芯片有 X、Y、Z 三个方向的环。先沿 X 收、再沿 Y、再沿 Z,每一步只有一个方向在干活,最后一步还最重; 把数据切成三块、各挑一条轴起步(XYZ/YZX/ZXY),三个方向就一直满着,同样一次 AllGather 只按带宽算能快到三倍。 ReduceScatter 倒着走(大的一步在前),AllReduce 两段同理。⚠️ 这是本课推导:没算每一步的固定延迟,XLA 实际怎么切块、怎么排也没核对。
📌 多轴收集带宽成倍:How to Scale Your Model(scaling book)sharding 章(中文版:沿多个轴收集时,可用带宽成倍增加)。
⚠️ 本课推导:只按带宽算、不算每步延迟;三条轴带宽相同、每一维都是首尾相接的环(切片每一维是 4 的整倍数)。XLA 实际怎么切块、怎么排,没有核对过。
⚠️ 示意:每张卡寄给每张卡几个 token 是随手定的固定数,不是实测的路由分布;真实的 V3 每个 token 挑 8 个专家。
专家并行(第四节)用的是它的一般情形:数目不等、派发完还要原路合并;Ulysses(第五节)用的是每份一样大的特例,也就是转置。
八个名字里带班长的四个只是积木,日常用的是五种(最后一种一对一收发,第三节切层时用)。给会后查:
| 通信 | 做什么 | 每卡发出 | 后面谁在用 |
|---|---|---|---|
| AllReduce | 加完,人人一份 | 2(n−1)/n · S | 数据并行同步梯度;张量并行每层前向两次、反向两次 |
| ReduceScatter | 加完,各拿一块 | (n−1)/n · S | FSDP 反向分梯度;张量并行配序列并行 |
| AllGather | 拼完,人人一份 | (n−1)/n · S | FSDP 前向拼权重;张量并行配序列并行;推理切 KV 时收齐 Q |
| AllToAll | 只换位置 | (n−1)/n · S | 专家并行派发和收回 token;Ulysses |
| Broadcast / Reduce | 一对多 / 多对一 | S | 分发初始权重、汇总指标这类场合 |
| Send / Recv | 一对一 | 看传多少 | 流水线并行在 stage 之间传激活;Ring Attention 沿环传 KV |
环:ReduceScatter 3 步各发 1/4 份,AllGather 再 3 步,一共 1.5 份;班长:卡 0 发 3 份。卡越多差得越远。
最朴素的一刀是切数据:每张卡算不同的样本。 可它一开始根本没解决「装不下」,要一路削到 FSDP 才解决 —— 而最后那一步是要付钱的。
每张卡放一整份模型、各算一批样本;反向算完做一次 AllReduce 求平均,再一起更新。 一步只通信一次(频率最低,量却不小:V3 这么大的模型要是纯数据并行,每卡一步约发 2.7 TB)。每张卡还是存一整份 16 字节/参数 —— 装不下一点没变。
打个比方:V3 的全部权重是一整套四库全书,分放在 61 间书房里,一间一层。按 V3 的配置有 128 个阁(一个阁就是一张卡),数据并行等于每个阁都藏一整套。下面一节一节把重复的清掉。
先认清那三块:权重是模型本身;梯度是这一步算出来的「每个参数该往哪改、改多少」;优化器状态是优化器替每个参数记的账(主权重、两个动量),它最大。下文的 Ψ 就是参数个数。
口径:本课按 ZeRO 论文算,优化器状态指跨步常驻、要存进 checkpoint 的那几样;梯度每步重算、用完清零,单独算一块(所以 ZeRO 才能把「切梯度」单列一级)。Megatron 里累加梯度的精度(--main-grads-dtype)跟主权重、两个动量的精度归在同一组「精度感知优化器」参数里配,所以也有人把它算进优化器。
📌 出处:Rajbhandari 等,ZeRO,arXiv 1910.02054 sec. 5、sec. 7。原文:Pos、Pos+g 通信量与数据并行相同(2Ψ),Pos+g+p 最多 1.5 倍。Ψ 为参数个数,此处按元素数计。
⚠️ 每卡字节数本脚本现算并 assert;9.76 TiB 与专题四 5.1 同一口径(671e9 × 16 ÷ 1024⁴)。128 路 = V3 的 2,048 卡 ÷ 16 段流水线(技术报告 arXiv 2412.19437 sec. 3.2 给出 PP16,除法为本课推导)。只算常驻,不含激活。
16 字节里,12 个是优化器状态 —— 开场第二问的答案:最大的是它,先削它。巧的是,它也是最闲的那块:
ZeRO-1 切优化器状态,ZeRO-2 再切梯度,ZeRO-3 连权重也切。每张卡只长期存自己负责的那 1/n。 ZeRO-1 顺手还省了一笔计算:原来每张卡都把全部参数更新一遍,现在各更新各的 1/n。
前两级为什么不多花一个字节的通信?就是 §1.4 那个等式:
📌 ZeRO 原论文 arXiv 1910.02054 sec. 7:Pos、Pos+g 的通信量与数据并行相同(2Ψ)。Adam 逐元素更新:Kingma 与 Ba,arXiv 1412.6980 算法 1。
⚠️ 一步切成几个 micro-batch 时,只剩 ZeRO-1 严格白送:ZeRO-2 不留整份梯度,没法把几份梯度先攒起来,只好每份算完就 ReduceScatter 一次;所以配流水线(必须切 micro-batch)时,V3、Megatron 都选 ZeRO-1。
📌 DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 3.3.3:用 BF16 代替 FP32 追踪 AdamW 一、二阶矩,「未观察到性能退化」;主权重与用于 batch 累积的梯度仍保留 FP32。sec. 4.2:β₁=0.9、β₂=0.95。
📌 这不是默认做法:常规做法里优化器状态与参数同精度;Megatron-LM 要显式开启 --use-precision-aware-optimizer,再配 --exp-avg-dtype bf16 --exp-avg-sq-dtype bf16(命令行参数在 megatron/training/arguments.py;不开前者时 megatron/core/optimizer/optimizer_config.py 断言两者只能是 fp32)。PyTorch AdamW 默认 β₂=0.999。
⚠️ 本课推导:刻度与舍入按 bf16(8 位有效位、就近舍入)真算。V3 报告的验证是整套 FP8 方案(含 bf16 动量)对 BF16 基线,16B 与 230B 两个规模损失相对误差低于 0.25%;未单独消融 bf16 动量。
削完前两级,每参数还剩 2 字节的权重。V3 按 128 路算,每卡仍要 1.29 TiB(约 1,415 GB,一张卡才两三百 GB),照样装不下。 ZeRO-2 加再多卡也降不下去了:剩下的正是人人一整份的权重。只靠数据并行这一刀,大模型只能走到 ZeRO-3,也就是 PyTorch 里的 FSDP:每层要算之前先 AllGather 拼回这一层,算完就扔。
回到藏书楼。FSDP 切的时候根本不管书是什么:把一间书房的书一页页排成一长条,按长度等分成 128 段,每阁拿一段。切口常常落在一本书中间,所以每阁手里那段,可能是一本书的后半截接着另一本的开头 —— 单拿这一段谁也读不了。 要用这一间,就得把其余 127 段都抄过来,凑回整间(AllGather),读完把抄本扔掉,只留自己那段;反向算完,每一段的修改意见交回管那段的阁合并(ReduceScatter)。
📌 V3 配置:技术报告 arXiv 2412.19437 sec. 3.1–3.2(2,048 块 H800;PP 16、EP 64 跨 8 节点、ZeRO-1 数据并行);config.json(61 层,前 3 层 dense,256 个路由专家 + 1 个共享专家)。
⚠️ 本课推导:数据并行 128 = 2,048 ÷ 16。V3 实际用 ZeRO-1 不是 FSDP,这里借它的路数讲 FSDP 怎么切。PyTorch FSDP 第一版把一层的参数拍平成一条再等分;FSDP2 按每个参数的第 0 维切,单独一份同样不能直接拿来算。
注意跟后面 EP 的区别:EP 按整架分,每架都是一个完整专家,单独就能算;FSDP 切的是碎片,为的是通信好切块,拼回来之前没用。
通信是 3Ψ,数据并行的 1.5 倍;换来的是每卡常驻从 9.76 TiB 降到 78.11 GiB(约 84 GB,还不含激活)。可 V3 用的 H800 一张才 80 GB,光这些就已经放不下,更别说激活 —— 光切数据还不够,后面几刀就是这么来的。
数据并行一步说一次话,能放在慢链路上;FSDP 每层都要说,得放在快线里。
FSDP 每一步搬的是权重,搬多少只跟参数量有关,跟 batch 无关; 而每一步要算多少,跟每张卡分到的 token 数成正比。
一次喂进去的总 batch 又不能跟着卡数无限加,加太大模型反而学不好;所以卡越多,每卡分到的越少。 每张卡的 batch 一小,算得少、搬得一样多,时间就被搬权重吃掉了。 要继续加卡,又不想让每张卡越算越少,还能怎么切?
还有一句话能帮你分清下一刀:FSDP 形式上把模型切开了,实质还是数据并行 —— 算的那一刻,权重已经拼回一整份,每张卡算的是自己那批数据。 下一刀要的是:算的时候,权重也不拼回来。
ZeRO-1、ZeRO-2 不多花(AllReduce 本来就能拆成 RS+AG,中间那步本地更新不用传)。优化器状态最大,又最闲,只在更新那一下用。
FSDP 每一层都要把整层权重拼回来。只要每张卡的 batch 够大,这笔搬运能藏在计算后面; batch 一小,就藏不住了。第二刀不再拼权重,直接把权重切开:几张卡合起来算同一批 token,每张卡要处理的 token 数不会随加卡被摊薄。 这一节会连撞三堵墙:batch 一小,FSDP 被拖住,换 TP;TP 出不了一台机器,换 PP;PP 又有人闲着等。
先问一个朴素的问题:一份数据搬过来一次,能被用几回?用的回数多,搬的那点时间就藏得住;只用一回,卡就在等搬运。 换成数字,就是一个比值:每在网络上搬一个字节,能换来多少次计算。它要高过硬件自己的比值(每秒算多少次 ÷ 每秒搬多少字节),否则卡就在干等。
FSDP 这笔账很干净(⚠️ 推导,按稠密模型算):一步搬约 6Ψ 字节(前向、反向各拼一次 bf16 权重,再分一次梯度,各约 2Ψ), 算 6ΨT 次(专题四「每个 token 约 6 倍参数量次运算」,T 是每张卡分到的 token 数)。两者一除,正好等于 T,跟模型多大没关系。 更直观的看法:一个参数占 2 字节,每个 token 拿它做一次乘加,正好 2 次运算。所以送来一个参数,这张卡上有几个 token,它就被用几回。
打个比方:一间做门的工坊,卡是师傅,网络是跑腿的小工。小工搬两样东西:一样是工具(电刨、模具),就是权重;一样是门板,一块块正在加工、一道工序做完递给下一道,就是激活,每个 token 一块。 FSDP 让小工搬工具:一件工具送到,这个师傅手上的每块门板都拿它过一遍,门板越多,这趟越值。
⚠️ 推导,非论文原话:FSDP 一步搬 ≈ 6Ψ 字节(2 次 AG 拼 bf16 权重 + 1 次 RS 分 bf16 梯度)、算 6ΨT FLOPs;TP 一层 4 次 AllReduce 各发 ≈ 4Th 字节、算 72h²T/n。都按稠密层、通信与计算完全重叠算。
📌 v7:每芯片 bf16 2,307 TFLOP/s;ICI 1,200 GB/s 是 6 条链路收发合计,单方向按 600 GB/s 算(环上每张卡收多少就发多少,所以按「每秒收进来」讲也是 600);显存 7.38 TB/s,比网络快十二倍多,所以这里卡的是网络线(Inferact TPU megakernel 博客规格表、wiki ici-dcn,来源为 Google TPU7x 文档;6 条链路的拆分与发出方向 600 是推导)。只用一根轴时硬件线约高 3 倍。V3 隐藏维 7,168 取自 config.json。
⚠️ 分母该用实测带宽:在自己的网络上跑一次 AllGather(GPU 上用 nccl-tests),取它报的 busbw(按 AllGather 口径 = 数据量 ÷ 用时 × (n−1)/n)。细虚线假设实测只有标称的 70%,门槛升到约 5,493;70% 不是 v7 的实测数。
红虚线约 3,845:每张卡一步分不到三千八百多个 token,FSDP 就被拖住。这里的卡是 device,v7 一颗芯片是 2 个,按芯片数就是约 7,700。
分母要当心:该用你在自己网络上实测的带宽,不是规格表上的数。门槛 = 每秒能算多少次 ÷ 每秒实际拼得动多少字节的权重。 测法是真跑一次 AllGather(GPU 上用 nccl-tests),看它报的 busbw。它按 AllGather 的口径算:数据量 ÷ 用时 × (n−1)/n,扣掉了自己那份本来就有、不用收的部分,正好对上每张卡每秒实际收到的字节。 实测只跑到标称的七成,门槛就从 3,845 抬到约 5,493(图上细虚线,七成是假设的)。FSDP 那根轴要是只占几根链路、还跟别的轴抢线,这个数还得往上走。
红虚线 3,845 = v7 每芯片 2,307 TFLOP/s(bf16)÷ 每芯片每秒收进来约 0.6 TB/s(常说的 1.2 TB/s 是收发合计,环上每张卡收多少就发多少;⚠️ 这个拆分是推算,见台账)。 注意这里卡的是网络:权重收进来以后还要从显存读,可显存每秒 7.38 TB,比网络快十二倍多,那条线只有约 313(图最下面的灰虚线),远不是瓶颈。 这还是最乐观的线:只走一根轴,高约 3 倍; MoE 只靠 FSDP、不配专家并行,搬的是全部参数、算的只有被选中的那部分,再乘约 18 倍(V3 的 6,710 亿 ÷ 370 亿)。
async_op=True 拿回一个 work,再 work.wait()。limit_all_gathers,限制同时在路上的 AG。forward_prefetch/backward_prefetch)。张量并行把一层的权重矩阵本身切开,每张卡只存、只算其中一块。英伟达 Megatron-LM 的切法:
📌 出处:Shoeybi 等,Megatron-LM,arXiv 1909.08053 sec. 3(MLP 与 self-attention 的切法、f/g 两个通信算子)。
两个容易绕晕的地方。一、每张卡两块都有份:卡 0 拿上投影(UP)的一半,也拿下投影(DOWN)的一半,不是一张卡管 UP、另一张管 DOWN(那是按层切,后面讲的 PP)。 两块之间不通信,DOWN 算完才把部分和加一次,传的是激活。attention 那块同理:按头切,出口加一次。所以一层前向两次 AllReduce,反向再两次。
二、「横」「竖」只是画法:本课把 W1 画成「输入维 × 输出维」(X·W1),第一刀切的是输出维,看着是竖切;PyTorch 的 nn.Linear 把权重存成「输出维 × 输入维」,同一刀在它那里就是横切。 所以别记横竖,记第一块切输出维,第二块切输入维。Megatron 按 X·A 的画法起名,叫列并行(ColumnParallelLinear)和行并行(RowParallelLinear)。
顺序不能反过来,因为两次矩阵乘中间夹着一个不是线性的 GeLU:
📌 Shoeybi 等,Megatron-LM,arXiv 1909.08053 sec. 3:GeLU 非线性,按行切第一块需要在 GeLU 前同步;f 前向恒等、反向 AllReduce,g 反之。
⚠️ 本课反例:2 与 −3 是随手取的数,GeLU 按精确式现算。
TP 切不到的那几段小运算,由它的搭档 SP 沿序列切开:通信量不变,省激活显存。别被名字骗了,它不是第四刀(§8.8)。
TP 切不到的是逐个 token 的小运算(归一化、dropout、残差相加),那几段每张卡都存着一整份激活。 Megatron 的序列并行(SP)把它们沿序列切开,顺手把每次 AllReduce 拆成两半:进 TP 那块之前 AllGather 拼齐序列,出来时 ReduceScatter 切回。 就是第一节那个等式,所以通信量跟原来一样。
TP 让小工递的是门板(激活):几个师傅合干同一批门板,各做一半工序,做完得凑到一起合成。门板多一倍,要递的和要干的都多一倍,batch 在账里约掉了;隐藏维就是门板的尺寸,板子越大,每递一趟要干的活越多。 工具能提前送(算这一层时就把下一层的拿过来);门板是刚加工出来的,默认只能等这道工序做完再递,所以 TP 的通信很难藏进计算里。 剩下的只有隐藏维和 TP 度数:每字节换来的计算约 4.5 × 隐藏维 ÷ TP 度数(⚠️ 推导,稠密层)。 V3 的隐藏维 7,168,TP 8 路约 4,032。图上那条红线是最乐观的画法,所以看着刚好贴线(7,168 × 4.5 ÷ 3,845 ≈ 8.4);真实的红线还要更高,TP 8 路其实已经在线下(原因在下面「细一点」)。
所以 batch 小多用 TP,batch 大多用 FSDP:图上左边蓝线还没爬过红线,靠橙线;右边爬过去了,交给 FSDP。 前提是 TP 那条线本身在红线上面。像 V3 这样两条都贴着或落在线下,TP 本身就不划算(§3.7)。
两把刀能并存,大模型训练里也常常一起用。关键是切在不同的维上:把卡排成一张表,一行是一组 TP,一列是一组 FSDP。TP 按输出维把权重切成几条,FSDP 再把每一条按输入维劈开。
📌 Scaling Book(How to Scale Your Model)训练篇「FSDP + 张量并行」:In[B_X, D_Y] · W_in[D_X, F_Y] · W_out[F_Y, D_X],X 轴做 FSDP、Y 轴做 TP;原书在 TP 轴上用 AllGather + ReduceScatter 传激活,通信量跟一次 AllReduce 相同。
⚠️ 本课推导:一行共用同一批 token,所以 FSDP 那根轴每搬一字节换来的计算 = 这一行的 token 数;961 = 3,845 ÷ 4。两根轴会分走不同的链路,各自的门槛要按各自那几根链路的实测带宽重算,只会更高。
算一层时,先在列里 AllGather,把自己那一条拼齐。拼回的只是整矩阵的 1/TP,不是整个矩阵。再各算各的,最后在行里把部分和加一次。反向时,梯度按列 ReduceScatter 回各自的主人。
账也跟着变:同一行的几张卡用的是同一批 token,每张卡却只拼 1/TP 条,所以 FSDP 那根轴的门槛按一行的 token 数算。TP 4 路时,摊到每张卡只要约 961 个(⚠️ 推导,没按各轴的实测带宽修正)。 这才是「batch 小多用 TP」的真正意思:TP 把一行的 token 借给了 FSDP。代价是 TP 那根轴每层都要对账,得占最快的线。
要横跨很多台机器、走慢线,又不想像 FSDP 那样每层搬权重,就按层切。TP 是切宽,PP 是切深:
段与段之间只在边界上用一对一收发传激活,是所有刀里通信最少的,所以它能跨到慢线上。 可朴素地切,就是「4 张卡的显存、1 张卡的速度」:同一时刻只有一段在干活。于是把一批数据切成几份 micro-batch 轮着灌进去,像门厂的流水线: 刨光、开孔、上漆三道工序各守一个工位,门板一摞一摞往下传。第一摞刚进刨光时,后两个工位只能干等;最后一摞到了上漆,前两个工位又闲着。干等的那段,叫气泡:
📌 气泡占比:Narayanan 等,arXiv 2104.04473 sec. 2.2(GPipe/1F1B 的 bubble time fraction);交错式把气泡再除以每卡的虚拟段数 v。Zero Bubble:arXiv 2401.10241。DualPipe:github.com/deepseek-ai/DualPipe。
气泡跟理想计算时间之比是 (p−1) ÷ m,p 是段数,m 是 micro-batch 个数。份数越多越省,可每份太小,卡就吃不饱。
每一行空白的总长都一样,是 p−1 个前向加 p−1 个反向。在最早的 GPipe 调度里,每一份的激活都要攒着等反向;每份大小不变时,份数越多攒得越多; 1F1B 调度把同时在路上的份数限制在 p 以内,气泡一样大,省的是激活显存 —— 这也是个反转:PP 把参数切开了,每张卡的激活却没少多少,因为每段都得替好几个 micro-batch 攒着。
VPP 让每张卡负责几段不连续的层,气泡再除以每卡的段数; Zero Bubble 把反向拆成「算输入的梯度」和「算权重的梯度」,后者不急,挪去填空; DeepSeek-V3 用的 DualPipe 从流水线两头同时往里灌,更要紧的是把一对前向和反向的计算,跟专家并行的通信叠在一起藏掉(技术报告 sec. 3.2.1)。
micro-batch 不是为流水线发明的。它最早是梯度累积:一份模型副本一次装不下它该分到的那批数据,就按时间切成几份,一份接一份算前向反向,梯度攒起来,最后更新一次。流水线是借用了它,好让几段同时有活干。三层关系:全局批次 = 每份 micro-batch 的样本数 × 份数 × 数据并行份数。 开了 PP,「每卡批次」就只是记账:几段合起来才是一份副本,同一时刻吃同一份数据。MaxText 里全局批次 = per_device_batch_size × 设备数,micro-batch = 全局批次 ÷ num_pipeline_microbatches(份数须是段数的整数倍,默认等于段数)。
GPipe 多占显存,有个前提。总量固定时,切得再细,GPipe 攒的激活总量也不变(份数多了,每份也小了);真正的问题出在每份大小固定时:那时多切几份就是往批次里加数据,激活跟着涨。1F1B 的激活只跟「段数 × 每份大小」有关,跟份数、总批次无关。
1F1B 怎么排。第 k 段(从 0 数)先做 p−1−k 份前向热身,之后做一份反向、接一份新前向,一进一出交替,最后把剩下的反向做完。所以第一段最多同时攒 p 份,最后一段只攒 1 份。 为什么第一段不趁着等反向多发几份?稳定后整条流水线的节奏是每「一次前向 + 一次反向」出一份,一份从第一段出发再回到第一段大约要 p 个这样的周期;在路上的份数 = 节奏 × 在路上的时间 ≈ p。多发只会在路上排队、白占显存,一点不快。
前后显存不均怎么办。第一段攒 p 份、最后一段攒 1 份。常见的摊法:首尾段层数不均分(最后一段本来就扛着输出层和损失);只在前几段开重算;把激活临时挪到主机内存;或者换成 V 字形放法,让每张卡同时负责靠前和靠后的一段,各卡的激活峰值就拉平了(Qi 等,Pipeline Parallelism with Controllable Memory,arXiv 2405.15362,Zero Bubble 的后续)。
micro-batch 切多大。不是「一份塞满显存」,1F1B 下第一段要同时装 p 份。要的是刚好让单段算力跑满的最小那份:大模型一条序列就有几千个 token,矩阵已经不小,常常一两条就够,实测找拐点。再看份数:p=4、每份副本 64 条,每份 16 条只能切 4 份,气泡是理想时间的 3/4;每份 1 条切 64 份,只剩 3/64。经验上份数要到段数的四倍以上;凑不够就开 VPP、少切几段,或者上 Zero Bubble 一类调度。
DualPipe 的代价。技术报告表 2:每卡要存两份参数(正向那条流水线里是第 i 段,反向那条里是倒数第 i 段),激活峰值是 p+1 份,比 1F1B 还多一份。它的目的是藏住专家并行那约 1:1 的跨机通信、顺带减气泡。V3 吃得下两份参数,是因为专家并行切得很大,每卡权重本来就少。双向流水线 2021 年的 Chimera 就提过,DualPipe 把条件放宽到段数和份数是偶数即可。
PP 是给「慢线上的大规模」准备的。快线够大的地方就不用操这份心:TPU 一个 slice 里上千颗芯片都连在高速 ICI 上,FSDP 和 TP 在里面就跑得开,slice 之间再走数据并行。所以 MaxText 的 ici_pipeline_parallelism、dcn_pipeline_parallelism 默认都是 1,常见配法不开 PP,省下不少头发。GPU 这边,PP 之所以常见,是因为 TP 出不了 NVLink 那一圈,跨机那条慢线只能交给它。
拿贯穿全课的例子 DeepSeek-V3 来说,它里面没有 TP。报告自己的解释是显存优化做得够细,用不着代价高的 TP。 再看它的参数都在哪:几乎全在一种叫「专家」的窄矩阵里。专家本来就窄,再往里切,每份更小,要搬的激活却一点不少。真正该切的,是「专家」这一维。这是第三刀。
FSDP:它每搬一个字节换来的计算就等于每卡 token 数,token 少就藏不住。TP 每一层都要对账,而且门板要等这道工序做完才能递,藏不进计算,只能待在最快的那圈线里。
MoE 模型的参数几乎全在专家里。第三刀就切这一维:把不同的专家放到不同的卡上。 它多出来的通信只有一种,AllToAll;可它也带来了一个别的刀里最严重的病。
V3 除了最前面 3 层,其余 58 层都是 MoE 层:每层 256 个路由专家,每个 token 由路由器挑其中 8 个去算;另有 1 个人人都要过的共享专家。
📌 config.json:hidden_size 7,168、moe_intermediate_size 2,048、n_routed_experts 256、num_hidden_layers 61、first_k_dense_replace 3。671B 为主模型总参数,不含 MTP 模块。「其余」= 671B 减去路由专家,本脚本现算。
256 个路由专家 × 58 层 ≈ 6,539 亿参数,占全部的约 97%。换句话说,TP 那把刀要切的是「一个很宽的矩阵」,而 V3 里真正占地方的是「很多个窄矩阵」。 对后者,最省事的切法不是把每一个都劈开,而是把它们整个分给不同的卡:搬病人,不劈医生。图底那行就是 V3 训练的真实配置:PP16 + EP64,一路 TP 都没用。
回到第二节那座藏书楼:EP 是把每间的 256 个专家书架整架分给 64 个阁,每阁 4 架;PP 是把 61 间书房按顺序分成 16 段。都是按整件分,拿到手就能用 —— 跟 FSDP 切碎了再拼正好相反。
专家并行(EP)的通信只在 MoE 层里发生,就是 1.6 讲的 AllToAll,网络最怕的那种,每层两次: 派发,把每个 token 送到它选中的专家所在的卡;合并,算完再送回原来的卡。
V3 为了压住这两次 AllToAll,做了两件事:每个 token 最多去 4 台机器,跨机每台只发一份、到了再在机器里分;派发压成 FP8,合并还用 BF16。
📌 DeepSeek-V3 技术报告 arXiv 2412.19437:sec. 2.1.2 限制节点路由(按每台机器上最高的 2 个亲和分之和挑机器);sec. 3.2.2 先走 IB 到目标机器上同编号的卡、再走 NVLink 转发,NVLink 160 / IB 50 GB/s,13 个专家;sec. 3.3.3 派发 FP8、合并 BF16;sec. 4.2 M = 4、64 卡 8 台。
⚠️ 本课推导:28.7 KB = 4 × 7,168 × 1 字节;115 KB = 8 × 7,168 × 2 字节(不限节点、专家摊得够开时 8 个专家可能在 8 台别的机器上;V3 每层专家只摊在 8 台机器上,出发机器自己也算一台,按 V3 的摆法最坏是 7 份跨机)。红框是跨机先落地的同编号卡;被选中的是哪几张卡为示意。
账只跟去了几台机器有关:每台机器只收一份,到了机器里再走 NVLink 转给那几个专家。报告算过,NVLink 比跨机网络快约 3.2 倍,所以每台机器平均能转给 3.2 个专家而不多花时间;4 台 × 3.2 ≈ 13,同样的通信量最多能挑 13 个专家(V3 实际挑 8 个)。
这是训练和 prefill 的做法;decode 追求低延迟时改成按专家逐个直发(跳过机器里的转发,每个专家各收一份),份数就跟着选的专家数涨了。
别的刀负载均不均,大多事先就知道。EP 的不均最严重: 哪个专家忙、哪个专家闲,要等路由算完才知道,而且每一批数据都不一样。 最忙的那个专家算完之前,所有人都得等它。它还会越滚越大:越受欢迎的专家分到的 token 越多、学得越好、就越受欢迎,其余的专家荒掉 —— 花一个大模型的显存,训出一个小模型。所以这既是速度病,也是质量病。治法分两头:
📌 无辅助损失均衡:Wang 等,arXiv 2408.15664;V3 技术报告 arXiv 2412.19437 sec. 2.1.2、sec. 4.2(报告里这个步长叫偏置更新速度 γ,前 14.3T token 取 0.001,最后 500B token 置 0)。步长记作 u 是 Wang 等论文 Algorithm 1 的写法(bias update rate u,实验里也取 0.001),本图沿用。
⚠️ 本图为示意模拟(固定随机种子,8 选 2、u = 0.02),不是 V3 的实测负载。
一层 Transformer 里,attention 和专家是两种完全不同的形状(对不是 MoE 的那部分来说,EP 那一维其实就是数据并行):attention 的负担跟序列和 KV 有关, 专家的负担是那一大堆参数。所以同一批卡,在这两部分可以用两套切法。
📌 Megatron-Core moe/README.md(MoE Parallel Folding,例子 TP4·CP2·DP8·PP4 → ETP1·EP64·EDP1);论文 arXiv 2504.14960。TEP / DEP 定义:TensorRT-LLM tech blog 26。
挑哪种配法,差别大到什么程度?先认两个简称,再看我们自己测过的一次(图后「一次实测」那一框)。
推理里最常见的两种配法有简称:TEP(attention 用 TP、专家用 EP)和 DEP(attention 用数据并行、专家用 EP),后面的数字是总卡数。专家那一半两者一样,差别全在 attention:一起算同一批请求,还是各算各的一批。
📌 TensorRT-LLM 定义:TEP<N> shards both attention (TP) and experts (EP) across N ranks;DEP<N> keeps attention data-parallel (ADP) while distributing experts across N ranks。
⚠️ 专家那一步的通信按常见实现画:attention 用 TP 时各卡 token 相同,专家输出用 AllReduce 合并;attention 用数据并行时各卡 token 不同,走 AllToAll。示意 4 张卡、8 个专家。
TEP 的每个请求有几张卡一起算,单个请求出字快;可 attention 是按头切的,V3 这类笔记只有一个头的模型切不开,KV 在每张卡上都是整份(§5.4)。DEP 每张卡只存自己那批请求的 KV,同样的显存装得下更多请求,专家那一步分到的 batch 也更大;代价是:专家那一步改走 AllToAll,各卡请求长短不一时会忙闲不均,没请求的卡也得陪着跑一遍空前向。上面「各配各的」那张图左边那种配法(attention 用 TP 4 路 × 数据并行 2 路),算两者中间。别和 Megatron 的 ETP/EDP 混,见 §8.6。
前三刀切的是 batch、权重、专家,都没碰过「序列」这一维。可上下文一长,训练时的激活、推理时的 KV cache,都跟着序列长度往上涨 —— 涨到一条样本都放不进一张卡时,怎么办?
负载不均:最忙的专家决定所有人等多久。V3 给每个专家的分数挂一个偏置,超载减、欠载加;偏置只影响挑谁,不改算出来的权重。
一条样本自己放不进一张卡,那就把它沿序列切开。这是第四刀。训练和推理切的东西不一样,分开讲。
上下文并行(CP)把一条长序列切成几段,每张卡只存自己那段的激活。 难点只在注意力:每个 token 要看到它前面所有的 token,而那些 token 在别的卡上。两种办法:
Ulysses 为什么转置一下就不用传笔记?把注意力的活排成一张「段 × 头」表就清楚了:同一列里后面的段要看前面的段,同一行里头与头互不相干。 Ring 按行分,依赖跨了卡,只好让笔记转圈;Ulysses 先转置,让每张卡拿整列。
📌 DeepSpeed-Ulysses:Jacobs 等,arXiv 2309.14509(注意力前后各一次 AllToAll,序列长度与卡数同比放大时每卡通信量不变)。Ring Attention:Liu 等,arXiv 2310.01889。
⚠️ 示意:4 段 × 4 头、4 张卡;实际每一格是一整段 token 在一个头上的 Q、K、V。
一句话记住两者:Ring 是人不动、笔记转圈;Ulysses 是换个切法,每人拿全部笔记的几个头。
两者可以叠起来用,叫 USP:把表分成块,卡排成二维,一维在机器里做 Ulysses 的 AllToAll,另一维在机器之间走环,总卡数 = 两维相乘。 Megatron 的 CP 也支持这种分层组合。
📌 USP:Fang 与 Zhao,arXiv 2405.07719;xDiT 文档:ulysses-degree × ring-degree = sp-degree,去掉「sp-degree 必须小于头数」的限制,对异构网络更友好。
⚠️ 「AllToAll 放机器里、环放机器之间」是本课按两种通信的脾气归纳的常见摆法,不是论文的硬规定。
生成式模型的注意力有因果掩码:每个 token 只看前面的。于是越靠后的段算得越多,顺序切会让最后一张卡累死。 解法很简单:轻的配重的,一张卡拿一轻一重两块,叫之字形切,见下图。
📌 Megatron-LM megatron/core/utils.py:序列切成 2×cp_size 块,rank r 拿第 r 块和第 2·cp−r−1 块;文档 docs/user-guide/features/context_parallel.md 称其避免下三角的多余计算并保持负载均衡。每格数本脚本现算;对角格按整格计。对角格只算一半时是 2/6/10/14 对 8/8/8/8,顺序切差 7 倍。
长上下文、高并发的推理(decode 阶段)里,KV 常常是最大的一块。先记住一句:TP 按头切,DCP 按字切,下面两段就是这句话的展开。TP 在注意力里是按头分卡的:V3 的查询头有 128 个,分得开;MLA 把 KV 压成所有头共用的一份,只剩一个头,切不开。
很多模型把 KV 头定成 8 个,TP 8 路时每张卡正好分一组(Llama 2 70B 就是 8 个 KV 头)。一般地,TP 一旦超过 KV 头数 H,KV 就切不开了:每个头被复制 TP ÷ H 次(vLLM 文档原话:duplicated for tp_size / H times)。 MLA 模型只有一个 KV 头,TP 8 路就是每张卡一整份、8 份一模一样的 KV。4.4 里 V4-Pro 在 TP4 上白存 3 份,毛病就在这儿。
📌 vLLM context parallel 部署文档:KV cache 会被复制 tp_size / H 次;DeepSeek-R1 在 MLA 下只有 1 个 KV 头,-tp 8 就是 8 倍复制,可加 -dcp 8。KV 尺寸取自 V3 config.json,本脚本现算。
DCP(decode 上下文并行)让 KV 按 token 轮流存到几张卡上,用的还是原来那几张卡。按 token 轮流而不是一段一段地存,是因为笔记一直在长:新来的字也会均摊到每张卡上。
算注意力时,新 token 的 Q 发给所有卡,各自在自己那份 KV 上算,再把几份部分结果合并。注意力本身就是按分数加权平均,所以合并不能各除各的,要「先别除」:
📌 讲法:Ring Attention(Liu 等,arXiv 2310.01889)附录实现按分子、分母分别累加;分块 softmax 的数值稳定写法见 FlashAttention(arXiv 2205.14135)。
⚠️ 本课示例:数字是随手取的,按定义现算并断言。
每层多付三次通信(vLLM 默认实现:收齐 Q、交换归一化分母、合并输出),换回被 TP 白白复制掉的那几份 KV。 DCP 的度数最多开到 TP ÷ KV 头数,也就是刚好把复制的那几份收回来。用一种通信,换一份显存,又一次。
它照样用得上 batch:一批 1,000 个请求就是 1,000 行,每一行都这样拆开,每张卡管每个请求那 1/TP 段笔记,一步里把 1,000 行的那一段一起算。 换回来的是两样:装得下,每卡 KV 只剩 1/TP,同样的显存能放更长的上下文、更多的请求,batch 就大了;读得少,只开 TP 时 MLA 每张卡都要把整份 KV 读一遍(各卡算不同的头,读的却是同一份),开了 DCP 每步只读自己那 1/TP,长上下文时每一步的注意力也快了。
DCP 管的是 decode。prefill 那边要把一个长 prompt 切开、让第一个字早点出来,叫 PCP(prefill 上下文并行)。 两个名字只差一个字母,其实是一前一后的两步。把注意力看成一张「提问 × 笔记」表:prefill 一次有几千个提问,先按行切;decode 每步只剩一个提问,没行可切了,DCP 才进一步把这一行按笔记切开。
下一节把 prefill 和 decode 拆到两批机器上以后,它们正好可以一边一个(本课的归纳)。
说到这儿,prefill 和 decode 已经各要各的切法了:一个吃算力、要把 prompt 切开;一个吃带宽、要把 KV 摊开。 硬塞在同一批卡上,谁都配不好。那就干脆别切张量了,把这两种活拆到不同的机器上。这是第五刀。
不能。要「先别除」:每张卡交出分子和分母,分子加分子、分母加分母,最后只除一次。
前四刀切的都是张量:batch、权重、专家、序列。第五刀换个思路 —— 一个请求里本来就有性质完全不同的几段活,把它们拆到不同的机器上,每一边再挑自己的切法。
一个请求分两段。prefill 一口气吞下整个 prompt,几千个 token 一起过矩阵乘,吃的是算力; decode 每一步只出一个 token,却要把全部权重和 KV 从显存里读一遍,吃的是带宽。
你正看着回答一个字一个字往外吐,别人丢进来一本一百页的说明书,你的字就停了。语音助手更明显:说一句停一段,平均速度再快也觉得卡。 这就是两种活挤在同一批卡上:引擎每一步都要决定先干哪个。长 prompt 一来,它的 prefill 要占好几步, 这几步里所有正在出字的请求都得等:新请求的首字延迟(TTFT)和老请求的出字间隔(TPOT)一起变差。
decode 还有个脾气:每一步都要把权重从显存读一遍,读一次只够这一批用一次。一批要多大才不白读?
⚠️ 推导:稠密层一步读 2P 字节(bf16)、算 2Pb 次,每字节 = b;MoE 每个专家平均分到 b × 8 ÷ 256 个 token。只算读权重,读 KV 会让门槛更高。
📌 v7:每芯片 bf16 2,307 TFLOP/s;HBM 每 TensorCore 3,433 GiB/s、每芯片两个(wiki entities/tpu-v7)。V3 的 8/256 取自 config.json。
模型这边也在帮忙凑:MLA 把 KV 压小,一张卡装得下更多请求,一批就大。MegaScale-Infer 论文在 A100 上算过同一笔账:一批至少 156 个请求,Mixtral 每个专家只分到 39 个。
📌 DistServe arXiv 2401.09670:prefill 偏算力、decode 受显存带宽约束;拆开后多服务 7.4 倍请求或把 SLO 收紧 12.6 倍。
📌 本课程作者 TPU v7x 1P1D 部署(Qwen3-Coder-480B):KV 三段传输按带宽估算约 100 ms,占 1–2 s prefill 的 5–10%。8K prompt 的 KV ≈ 1.04 GB(FP8,按 config 现算),过 100 Gb/s 网络约 83 ms;长 prompt 宜 2P:1D,长输出宜 1P:2D。
分块 prefill(chunked prefill)能缓解:把长 prompt 切成小块,每一步跟 decode 拼着跑。 但块切小了 prefill 自己变慢(每一块都要把前面的 KV 重读一遍),两种活还在抢同一批卡,而且只能用同一套并行方式。PD 分离干脆把它们拆开: prefill 机器只做 prefill,算完把 KV cache 交给 decode 机器,decode 机器只管出字。
我们在 TPU v7x 上搭过一套 1P1D(Qwen3-Coder-480B,一台 v7x-8 做 prefill、一台做 decode),KV 从 prefill 那台的显存走到 decode 那台的显存:
📌 我们的 TPU v7x 1P1D 记录(wiki qwen3-coder-480b-pd-disagg-tpuv7x-20260425):三段按带宽估算约 10 / 80 / 10 ms、合计约 100 ms、占 prefill 5–10%(prefill 1–2 s 由此反推)。
⚠️ 本课推导:KV = 2 × 62 层 × 8 个 KV 头 × 128 × 8,192 × 1 字节 ≈ 1.04 GB;100 Gb/s = 12.5 GB/s → 约 83 ms。
| 段 | 路径 | 估算 |
|---|---|---|
| ① | HBM → 本机内存(PCIe) | 约 10 ms |
| ② | 本机内存 → 对方内存(数据中心网络,按单颗芯片的 100 Gb/s 份额保守估) | 约 83 ms |
| ③ | 对方内存 → HBM(PCIe),接进 decode 的 KV 池 | 约 10 ms |
| 合计 | 约 100 ms(10 + 83 + 10) |
中间那段:8K prompt 的 KV 是 2(K、V 各一份)× 62 层 × 8 个 KV 头 × 128(每头维度)× 8,192 × 1 字节(FP8)≈ 1.04 GB, 100 Gb/s 就是每秒 12.5 GB,走一趟约 83 ms。另有一个 CPU 上的转发代理负责把请求分给两边。
这一趟用的是第一节那个一对一收发,而且跨机器、走数据中心网络这根慢线;它敢跨出去,是因为一个请求只传一次。 从这一刀往后,调度的中心其实是那份笔记:KV 跟着请求搬家。Kimi 的 Mooncake 干脆把整套推理系统叫作「以 KV cache 为中心」。
反过来说,请求都很短、量也不大的时候,拆开多出来的这趟传输和两套机器就不一定划算,放在一起、用分块 prefill 缓解就够了。
拆开之后多了一个旋钮:prefill 和 decode 的机器配比。思路是让两边差不多同时忙满,DistServe 论文给过一道很干净的算术:
📌 DistServe(Zhong 等,arXiv 2401.09670)sec. 1 与图 1 的例子(13B 模型、单张 A100,90% 请求达标):同一 SLO 下单卡 goodput 1.6/5.6/10 rps,2P1D 每卡 3.3 rps、2.1 倍;作者博客「Throughput is Not All You Need」用同一组数讲了一遍。
⚠️ 本课推导:2P1D 每秒 min(2 × 5.6, 10) = 10 个,每卡约 3.3 个;混着做接 10 个要 ⌈10 ÷ 1.6⌉ = 7 张卡。
经验上长 prompt 的业务配 2P:1D,长输出的业务配 1P:2D。
DistServe 论文把配比和各自的并行方式一起搜,跟不拆开的系统比,同样的延迟要求下最多能多服务 7.4 倍的请求(对 DeepSpeed-MII),或者把延迟要求收紧最多 12.6 倍(对 vLLM)(OPT 系列模型,以 90% 请求达标为准)。上图那个「翻一倍多」是论文里一个单卡算例,7.4 倍是搜遍配比和切法之后的最好结果。
这才是拆开的真正收益:两边不再被迫用同一套并行方式。
decode 这边还能再拆。attention 要读每个请求自己的 KV,跟请求绑定;专家不管 token 来自谁,只要 batch 够大:decode 每步都要把专家权重读一遍,来的 token 越多,这一遍越值(§6.1)。 AFD(Attention-FFN 分离)把两者放到两组机器上:M 台只算 attention,N 台只放专家。
📌 MegaScale-Infer arXiv 2504.02263(disaggregated expert parallelism、ping-pong pipeline、每 GPU 吞吐最高 1.90×);Step-3 arXiv 2507.19427;vLLM 于 2026-07 发布实验性 AFD 插件。
每一层都要把 token 从 attention 那边发给专家(M → N),算完再收回来(N → M)。 为了不让这一来一回拖慢,把一批请求切成几个小批轮着跑:这一个在算 attention,另一个正好在算专家,还有一个在路上。 注意切的是 batch(按请求分组),不是序列:decode 每一步每个请求只出一个字,比如这一步有 3,000 个请求,就分成三组、每组 1,000 个字轮流走。 MegaScale-Infer 论文算过,要藏住通信至少得三个小批,通信慢的时候要四个;它报告每 GPU 吞吐最高提升 1.90 倍。
字节的 MegaScale-Infer、阶跃的 Step-3 都是这个路子;vLLM 在 2026 年 7 月出了实验性插件。
同样的思路还能往前推一段:多模态模型的视觉编码器单独部署,算好的 embedding 再传给语言模型(Encoder 分离, 跟 PD 连起来常写作 EPD)。训练里对应的是多模块异构并行:编码器和语言模型各用一套并行方式。
五刀讲完了,每一刀都有自己的通信和适用场景。真到一个集群上,它们要同时存在: 谁放在同一台机器里、谁跨机器、先定哪一刀的度数?
两种活不再互相拖,各自都能接满:论文的例子里 2 台 prefill + 1 台 decode 每秒接 10 个请求,混着做要 7 张卡。那趟 KV 只占 prefill 的一小截。
一套真实配置里常常有三四种并行叠在一起。剩下的问题只有一个:哪一刀放在哪根线上。摆对了,前面每一刀省下的都是真省;摆错了,全被网络吃回去。
一个集群里的线不是一样快的。GPU 这边,GB300 NVL72 把 72 块卡连成一个 NVLink 域,域里每块卡 1.8 TB/s(收发合计,下同); 出了这个域只能走网卡,每块卡 200 GB/s,差 9 倍。TPU 这边,一个切片里的芯片走 ICI(够大的切片连成 3D 环面,见 §1.5), 跨切片走数据中心网络,同口径比慢约 50 倍(换算见台账),比 GPU 那边的 9 倍悬殊得多。
刀也不是一样勤的。把每一刀一步要通信几次数一遍(本课推导,示意配置),差出三个数量级:
📌 次数为本课推导:TP 每层前反向各 2 次 all-reduce(arXiv 1909.08053 sec. 3);FSDP 每层 3 次(ZeRO 的 3Ψ,arXiv 1910.02054 sec. 7);EP、PP、DP 按调度数出;叠上 PP 时 TP 的次数要除以 PP 段数,开重算时 TP 每层是 6 次。链路:GB300 NVLink 5 每 GPU 1.8 TB/s;A4X Max 每节点 4 块 GPU、4 × CX-8 800 Gb/s。
先别往下看:TP、PP、DP 三个,谁该坐快线?把集群想成一栋写字楼就好猜了:
📌 Llama 3 技术报告 arXiv 2407.21783 sec. 3.3.2(并行维度由里到外 [TP, CP, PP, DP]);V3 技术报告 sec. 3.2(EP 64 跨 8 台机器)。
⚠️ 写字楼的比方为本课借喻(底子参考 CERFACS 讲并行的办公楼例子);圈的大小不代表带宽比例。
于是有一条默认的摆法:每一层都要说话的 TP、EP、FSDP、CP 先往最快的那一圈里放;PP 只在段边界说话,DP 一步只说一次,它们去跨慢线。 但光数次数不够,还要看它能不能跟计算叠起来。TP 叠不起来(每一块末尾那次 AllReduce 不做完,下一块就没法开始),所以必须待在快线里,度数上限就是那一圈的大小。
EP 和 FSDP 能靠提前发、边算边传藏住一部分,就有人让它们跨出去:V3 的 EP 64 就横跨 8 台机器 —— H800 机内外只差 3 到 4 倍,远没有 TPU 悬殊;Llama 3 把 FSDP 放在了最外层。 DP 那一次量虽然最大,但一步只有一次,而且反向从最后一层往前算,后面几层的梯度一算好就能先传。 第六节那趟 KV 也一样,一个请求只传一次,所以敢走数据中心网络这根慢线(指 TPU v7x 那套)。
同样 8 张卡、同样 TP4 × DP2,只改 TP 组放在哪。下面的时间是示意:快线传一次 1 格,慢线 9 格。
同一个颜色就是一个 TP 组;摆法二里上排、下排各是一组。一步是 8 轮 TP 加 1 次 DP:摆法一 8 × 1 + 9 = 17 格,摆法二 8 × 9 + 1 = 73 格(DP 那一对卡在同一台机器里,只花 1 格)。
放到真实集群上,这就是为什么 TP 一般不出一台 8 卡机器。GB300 把 NVLink 域扩到一整柜, 专家并行才敢往大了开(TP 受头数和矩阵效率限制,在整柜上也很少超过 8 或 16):快线那一圈画多大,这几刀就能切多深。
摆法和切法选错了,参数调得再细也只是在错的天花板下面打转。我们在 GB300 上跑 DeepSeek-V4-Pro 时撞上过一次。 图里的 1P1D 是一台 prefill 机器配一台 decode 机器,3P 是三台 prefill;DEP8 是 decode 那边 attention 每张卡各管一批请求、专家铺在 8 张卡上:
📌 本课程作者实测:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md(1p1d 14,563;3p1d 21,100;3p + DEP8 并发 512 为 55,153、并发 1,536 为 65,132)。GPU 数按每节点 4 块、prefill 与 TP4 decode 各 1 节点、DEP8 2 节点;每卡数本脚本现算。
TP4 decode 上能调的都调了(去掉 eager 模式、加 prefill 机器、调并发),总吞吐涨了四成五 —— 可这是拿多一倍的卡换来的,每卡反而掉了,出字间隔一直在 50 ms 上下。 换成 DEP8 那一步,同样的并发下出字间隔降到原来的四分之一,首字延迟也少了一半多。
真正属于「换切法」的那笔账,是 KV 不再在 4 张卡上各存一份(§5.4);decode 从 4 张卡加到 8 张,也把专家摊薄了一半。 两笔都换成了更大的 batch。这 8 张卡横跨两个计算托盘,但还在同一柜的 NVLink 快线里。先问切法对不对,再动参数。
把前面几节串起来,给一个模型挑并行方式,像闯五关,每一关一个是非题:
拿两个真实配置对一遍。读这张表,先看两个「不用」:V3 在 8 卡一台的 H800 上不用 TP;混元 3 在 TPU 上不用 EP。表里「DP 4 × FSDP 128」这类写法按乘法读:两种切法各切几份,乘起来就是总共多少份。
| 步骤 | 混元 3(295B MoE,TPU v7,256 芯片) | DeepSeek-V3(671B MoE,2,048 块 H800) |
|---|---|---|
| ① 装得下 | FSDP 128(专家权重也由 FSDP 切):再窄就爆显存 | ZeRO-1 摊优化器状态;EP 64 摊专家 |
| ② 快线多大 | 256 芯片在同一个切片里,全是快线,FSDP 已经能把专家也摊开,不用 EP;小规模试过一次 EP,吞吐反而掉了(见表下注) | 8 卡一台,不用 TP;EP 64 横跨 8 台机器,跨机那段是慢线,是个例外。为了少走慢线,规定每个 token 最多发到 4 台机器 |
| ③ 序列 | 4K / 8K,不用 CP | 预训练 4K,报告里没有 CP |
| ④ PP | 一个切片放得下,不用 | PP 16,用 DualPipe 把通信叠进计算 |
| ⑤ DP | 剩下的 4 倍全给 DP:DP 4 × FSDP 128,这是默认配方(v7 一颗芯片算 2 个 device,并行度按 device 数:256 芯片 = 512 个)。 最好成绩是把 FSDP 加宽到 256、用省下的显存把每个 device 的 batch 从 12 推到 16,比默认配方高 3%;加宽本身只慢不到 1%,收益全来自推大的 batch | 剩下的给 ZeRO-1 的数据并行 |
同一套五步,两个模型走出来的配置几乎没有重合,因为两台机器的快线长得不一样。 这也是为什么别人家的并行配置不能照抄:先看自己的线。
表下注:混元 3 那次 EP 实测是在 16 芯片上开 4 路,吞吐掉了 71%(只跑了一次),batch 同时减半,有混杂;换一种配法掉 37%。原始记录归因于环面上 all-to-all 要多跳,但 4 路时这笔账不大,原因还要再查。 V3 那一列按乘法读:PP 16 × 数据并行 128 = 2,048;EP 64 不另占卡,是在那 128 路数据并行里切专家(本课推导)。
配好之后要回答一个问题:卡加上去,每张卡的效率还剩多少。有两种量法:
衡量的数叫扩展效率:加卡后每卡的吞吐 ÷ 加卡前每卡的吞吐。 我们没有干净的 strong scaling 实测;最接近的是同一个 DP 4 × FSDP 128,每个 device 的 batch 从 12 降到 8,每芯片从 580 掉到 453:每张卡的活一少就吃亏。
下面是我们自己的两组实测,只能组内比。左边是一次 weak scaling:卡 ×4、global batch ×4。右边比的是同样的卡、FSDP 铺多宽。
📌 本课程作者实测:gpu-tpu-pedia tpu/Hunyuan3-295B-Pretraining/TUNING-v7 sec. 3.7(五种分法,pdbs 8)、sec. 4.1(64 与 256 芯片同为 580,pdbs 12)。数字是每芯片 TFLOP/s。
左边那组说明 DP 方向几乎是白送的:4 个 64 芯片的组之间,一步只有一次梯度 all-reduce, 按 v7 的 ICI 粗算,就算几组共用链路、打个折扣,也占不到一步 23.5 秒的百分之一(本课推导)。 不过这 4 组在同一个切片里,DP 走的是 ICI,这个结论不能直接推到跨切片。
右边那组才是要小心的:卡没变、batch 没变,只是把 FSDP 从四分之一的芯片铺到全部芯片,每拼一次权重要走的步数多了、每块数据更小,延迟摊不掉,就少了 11%。FSDP 再窄(64 份、32 份)每份权重太大,加上激活就放不下了。 所以在 batch 还能加的时候,加卡要连 batch 一起加,多出来的卡优先当副本。
到这里,每一种并行都有了来处:它切什么、多出什么通信、该放在哪根线上。 下一节把它们摊在一张全景图和几张表上,那些 TEP8、DEP16、DP4 × FSDP128 的写法,就都读得懂了。
TP:每层都要对账、又藏不住。PP 只在段边界递一次,能跨机器;DP 一步只说一次,最远能跨数据中心。
名字很多,DP、FSDP、TP、SP、CP、PP、EP,推理那边还有 DCP、PCP、DEP、TEP…… 但归起类来只有四种。前面五刀里,切权重和切专家都算模型并行。先把类认清楚,名字就好记了。
判据只有一个:看它切的是什么。先看一张图,再看表:
📌 归类与通信原语汇总自本讲第一到第七节;「能否跨慢线」是默认摆法,例外(V3 的 EP 跨机、Llama 3 的 FSDP 在最外层)见第七节。
| 刀法 | 切的是什么 | 每张卡手里有什么 | 典型 |
|---|---|---|---|
| 数据数据并行 | batch,或者说请求 | 算不同的样本,模型在逻辑上是完整的 | DP、FSDP、Attention DP |
| 序列序列并行 | 一条样本内部的 token | 同一条样本的一段;训练时是一段激活,推理时是一段 KV cache | CP、Ulysses、DCP |
| 模型模型并行 | 权重 | 只有模型的一部分:矩阵的几列、几层、几个专家 | TP、PP、EP |
| 解耦解耦 | 工作的阶段或模块 | 只干一种活:只做 prefill,或者只算专家 | PD 分离、AFD |
下面几张表就按这四类排。「新」表示 2025–26 年才出现或才普及。 这四张是查阅用的,第一次读可以直接跳到 8.6;表里有不少前面没讲过的名字,用到时再回来翻。
| 名称 | 切什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| DP / DDP | batch,模型整份复制 | 线性扩吞吐 | 训练:梯度 all-reduce,每个 step 一次。推理:没有,前面靠 router 分流 | 训 · 推 |
| ZeRO-1 / 2 / 3 | 依次多切一样:优化器状态 → 梯度 → 参数 | DP 每张卡存一份完整状态,是纯冗余 | reduce-scatter + all-gather;ZeRO-1/2 通信与 DP 相同(ZeRO-2 切 micro-batch 时每份都要 RS 一次);ZeRO-3 每层都要把参数 all-gather 回来 | 训 |
| FSDP / FSDP2 | 就是 ZeRO-3,PyTorch 原生版本 | 通信量是 DP 的 1.5 倍,显存却随卡数线性下降 | 前向 all-gather 权重,反向再 all-gather 一次、再 reduce-scatter 梯度 | 训 |
| HSDP | 机内分片,机间复制(例:混元 3 的 DP 4 × FSDP 128,不过它整个在一个切片里) | 把最频繁的 all-gather 圈在高带宽域里 | 机内 AG / RS,机间 all-reduce | 训 |
| ZeRO++ | ZeRO-3 上再加三招 | 跨节点通信太贵 | 权重量化成 INT8 再 all-gather;节点内多存一份参数;梯度也量化 | 训 |
| 跨 DCN 的 DP | DP 横跨多个 slice 或数据中心 | DP 每个 step 才通信一次,最适合放上慢链路(PP 也能) | DCN 上的梯度 all-reduce | 训 |
| DiLoCo 新 | 每个副本先自己走几百步,再同步一次 | 跨数据中心训练:论文里每 500 步才同步一次,通信次数降到几百分之一 | 一次外层梯度同步(Streaming 版分片轮流同步,跟计算重叠) | 训 |
| Attention DP 新 | 只在 attention 层按请求切,专家层另配 | MLA 只有 1 个 KV 头,开 TP8 会把 KV 复制 8 份;改成 DP,每张卡只存自己那批请求的 KV | 后面接 EP 时是 all-to-all;没活的卡也得跑一遍空前向陪着同步 | 推 |
-dp 不开 -ep,专家层走的是 TP 而不是 EP。一条样本太长,一张卡放不下它,就沿序列切开。这一类在训练和推理里的动机完全不一样: 训练切的是激活,推理切的是 KV cache。所以分两张表。
训练侧(以及推理的 prefill):切激活
| 名称 | 切什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| Megatron SP | 只切 LayerNorm、Dropout、残差这几段的激活,必须跟 TP 搭配(按「切什么」归到这一列;按用途它是 TP 的搭档,见 §3.3) | TP 切不到的那部分激活,每张卡都存了一整份 | 把 TP 的 all-reduce 拆成 all-gather + reduce-scatter,总量不变 | 训 · 推 |
| CP(Context Parallel) | 所有激活沿序列切 | 长上下文训练,上下文到几十 K 以上基本都要用 | ring 传 KV,或者 all-to-all,或者 all-gather,可以分层组合 | 训 |
| Ulysses | 序列切和 head 切来回转换 | 长序列:序列长度和卡数同比放大时,每张卡的通信量不变 | attention 前后各一次 all-to-all;度数不能超过 head 数(GQA 模型卡在 KV 头数上) | 训 |
| Ring Attention | KV 分块沿一个环传递 | 度数不受 head 数限制 | 环上点对点传递,跟计算重叠 | 训 · 推 |
| Striped / USP / 2D-Attention | 改 token 的分配方式;Ulysses 和 Ring 叠成二维 | ring 在 causal mask 下各卡负载不均;两者的限制互补 | 同上两种的组合 | 训 |
| PCP(Prefill CP) 新 | prefill 阶段的 query token | 长 prompt 的首字延迟(TTFT) | all-gather KV,或者 ring | 推 |
| Chunked PP 新 | 长 prompt 切成块,依次灌进流水线 | prefill 的启动延迟只跟第一块成正比 | 流水线的点对点 | 推 |
推理 decode 侧:切 KV cache。这是 2025–26 年最热的一块
| 名称 | 切什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| DCP(Decode CP) 新 | KV cache 的序列维,按 token 轮流存到各卡 | TP 一旦超过 KV 头数,KV 就开始复制。MLA 只有 1 个头,TP8 就是 8 份一模一样的 KV。 DCP 把这份冗余变回容量 | 每层三次(vLLM 默认实现):all-gather 收齐 Q、交换 LSE、合并输出 | 推 |
| Helix 新 | 同一组卡在一层里换两次布局:attention 按 KV 序列切(再叠一维不超过 KV 头数的 TP),FFN 按 TP × EP 切 | 百万 token 级的 decode:读 KV 和读权重两件事都要摊开 | attention 后一次 all-to-all 交换部分结果;FFN 段照样有 TP 的 all-reduce 或 EP 的 all-to-all | 推 |
MaxText context_autoregressive | decode 时 KV 沿序列切,FFN 按专家切 | 同上,TPU 上的做法 | XLA 自动插入 | 推 |
这一类真正在切权重。按下刀的位置再分三种:矩阵内部、层、专家。
切矩阵内部(张量并行)
| 名称 | 切什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| TP | 矩阵先按列切、再按行切,两两配对 | 单层的权重或计算放不下 | 每层前向两次、反向两次 all-reduce,频率极高,所以只能待在最快那一圈(NVLink 域、同一切片的 ICI);v7 上 TP8 只有 4 颗芯片,已经在线下 | 训 · 推 |
| 2D / 2.5D / 3D TP | 把矩阵切成网格 | 1D TP 的通信随度数上涨 | 沿网格的行、列广播和归约 | 训,已基本不用 |
| GTP 新 | 在 TP 轴上再把权重切一层,用的时候再收回来 | Megatron 文档原话:GTP_remat is an implementation of ZeRO-3。只不过它切在模型并行轴上 | 逐个权重异步 all-gather,梯度 reduce-scatter | 训,实验性 |
切层(流水线并行)
| 名称 | 切什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| PP | 层,分成若干 stage | 模型太深,或者跨机只剩低带宽链路 | stage 边界的点对点,量最小;代价是气泡 | 训 · 推 |
| VPP(交错 1F1B) | 每张卡放几段不连续的层 | 把气泡缩小 | 点对点的次数变多 | 训 |
| Zero Bubble 新 | 把反向拆成两半:激活的梯度和权重的梯度 | 拿权重梯度那一半去填气泡 | 点对点 | 训 |
| DualPipe | 两个方向同时灌流水线 | V3 的专家通信太重,要把前反向的计算和通信完全叠起来 | 点对点,跟 EP 的 all-to-all 叠在一起 | 训 |
切专家(MoE)
| 名称 | 切什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| EP | 不同专家放到不同的卡上 | 专家总参数太大 | token 发出去、算完收回来,两次 all-to-all。发给谁由数据决定,所以负载会不均,这是 EP 最重的病 | 训 · 推 |
| Wide-EP 新 | EP 铺到 32、64 甚至更多张卡 | 每张卡只放几个专家,decode 时每个专家分到的 batch 就大了 | 大规模 all-to-all,要专门的通信库 | 推 |
| ETP | 单个专家内部再做 TP | 单个专家本身太大;细粒度 MoE 一般设成 1 | 专家内部 all-reduce | 训 |
| EDP | 专家侧剩下的那一维数据并行,由别的维度推出来 | 专家梯度要在哪些卡之间求和 | 专家梯度 all-reduce | 训 |
| Parallel Folding 新 | attention 层和专家层各用一套切法,铺在同一批卡上 | 打破「EP 不能超过 DP」的老限制。比如 attention 用 TP4 · CP2 · DP8,专家可以直接 EP64 | 两套通信组 | 训 |
前三种刀法切的都是张量。这一类切的是工作:把不同性质的活拆到不同的机器上, 每一边再挑自己的并行方式。
| 名称 | 拆什么 | 解决什么 | 多出来的通信 | 场景 |
|---|---|---|---|---|
| PD 分离 | prefill 和 decode 放到不同机器 | prefill 吃算力,decode 吃带宽,放在一起互相拖累首字延迟和出字速度 | KV cache 跨机传输 | 推 |
| AFD 新 | attention 放一组机器,专家放另一组 | 专家那边汇集好几组 attention 的 token,把专家的 batch 做大;两边的机器配比也能分开调 | 每层一来一回:attention → 专家发一次,专家 → attention 收一次,要切三四个小批把它藏起来 | 推 |
| Encoder 分离 | 多模态模型的视觉编码器单独部署 | 编码器和语言模型抢资源 | embedding 传输 | 推 |
| 多模块异构并行 | 编码器和语言模型各用一套并行方式 | 多模态训练里两部分的形状差太远 | 两套网格之间的桥接通信 | 训 |
推理这边,MoE 模型的并行配置通常用一个简称加一个数字说完,比如 TEP8、DEP16。 前一个字母说 attention 怎么切,后面的 EP 说专家怎么切。
| 简称 | attention 层 | 专家层 |
|---|---|---|
| TEP<N> | TP,N 张卡一起算 | EP,铺在同样 N 张卡上 |
| DEP<N> | Attention DP,每张卡自己管一批请求 | EP,铺在同样 N 张卡上 |
这是 TensorRT-LLM 的原文定义:TEP<N> shards both attention (TP) and experts (EP) across N ranks. DEP<N> keeps attention data-parallel (ADP) while distributing experts across N ranks. vLLM 的用法与此一致。
PD 分离时两边经常各选一种,但哪边用哪种没有定式,要看模型和负载: vLLM 部署 Kimi K3 用的是 TEP8 做 prefill、DEP16 做 decode; TensorRT-LLM 那篇文章举的例子却是 DEP4 做 prefill、TEP8 做 decode。
其它常听到的组合说法:
判据:它有没有多切出一维。没有的,就不是新的并行方式。
| 名称 | 它实际是什么 |
|---|---|
| TBO / SBO / DBO | 把通信藏到计算后面:两批数据错开跑,一批在通信时另一批在计算 |
| Async TP、TP 通信重叠、collective matmul | 还是 TP,只是把通信和矩阵乘切成小块交错着做 |
| EPLB、冗余专家 | 负载均衡:把热门专家多复制几份再重新摆放。修的是 EP 的病,本身不切新维度 |
| Offload、重计算 | 拿时间换显存,或者拿主机内存换显存 |
| 分块 prefill(chunked prefill) | 推理调度:把长 prompt 切成小块跟 decode 拼着跑,缓解互相卡住(§6.1);别跟 §8.3 的 Chunked PP 混:那个也用在推理 prefill,但块是灌进流水线并行的,真的多切了一维 |
| 词 | 在不同地方的意思 |
|---|---|
| SP | 至少三种:Megatron 的 SP(只切 LayerNorm 那几段,跟着 TP);DeepSpeed 说的 SP(指 Ulysses); 以及泛指一切切序列的做法。Megatron 里「所有激活都切」叫 CP |
| CP | 训练里指切激活。vLLM 把它拆成两个开关,对卡数的作用相反:PCP 加卡,DCP 不加卡;功能也不同,一个压首字延迟,一个扩 KV 容量 |
| DP | dense 模型上是独立副本;MoE 推理里其实是 Attention DP,每一步都要同步 |
| ETP | Megatron 指专家内部的 TP;TensorRT-LLM 的 Hybrid ETP 指专家层 TP 和 EP 混用 |
| hierarchical | ZeRO++ 的分层分片、Megatron 的分层 CP,是两件不同的事 |
| 卡/芯片/device | GPU 上一张卡就是一个 device;TPU v7 一颗芯片对软件显示成 2 个 device,并行度按 device 数 |
| 带宽 | 有的按单向报、有的按收发合计报:本讲的 1.8 TB/s(NVLink)、1.2 TB/s(ICI)是收发合计,800 Gb/s、100 Gb/s(网卡)是单向 |
| 并发与 batch | 并发是在排队的请求数,batch 是同时在算的请求数 |
拿开场那个 V3 试一次:PP 16、EP 64、ZeRO-1 数据并行(技术报告 sec. 3.2)。 PP 是切深,只在段边界收发,敢跨机器;EP 是切专家,每层两次 AllToAll,所以规定每个 token 最多去 4 台机器;ZeRO-1 是切数据,一步一次 ReduceScatter + AllGather,最便宜。 三刀、三种通信、三根线 —— V3 那行看着像天书的配置(PP 16、EP 64、ZeRO-1),现在读得懂了。
⭐ 回到开头那个问题:从哪儿下刀。五刀切的东西各不一样,付的账却是同一种:拿一种通信,换一份显存或一份算力。 所以选并行策略,说到底是在选你愿意付哪一种通信、付多频繁、放在哪根线上。
最后一句也是第三节和第六节那把尺子:硬件线是算力 ÷ 带宽,负载线由你的切法决定。这一讲的每一刀,都是在让某条负载线爬到硬件线上面去。
① 一个 MoE 模型要在一柜 GB300(72 块卡、同一个 NVLink 快线圈)上做 decode,attention 那一半和专家那一半,你会各怎么切?先答三问,再对照 7.3。
② TEP8 和 Megatron 的 ETP8,名字只差一个字母顺序,意思有什么不同?先自己查,再看 8.6 那个红框。
按「结论 ← 材料」排。第八节 2026-09-23 核对,第一节 2026-09-24 核对,其余各节 2026-09-25 经十轮评审与两遍试讲复核。
| 结论 | 材料 |
|---|---|
| 各集合通信每卡发出的量(第一节的表) | NVIDIA/nccl-tests:doc/PERFORMANCE.md 的 bus bandwidth 修正系数:AllReduce 2(n−1)/n,ReduceScatter / AllGather / AlltoAll (n−1)/n,Broadcast / Reduce 1 |
| 环形 ReduceScatter 的逐步推演、班长模式 | wanghonglei《分布式深度学习集体通信原语——从零到精通》(2026-06-27)第 1–2 章;图里每一步由脚本按调度现算并断言。块号比原文挪了一位,让卡 k 最后拿第 k 块 |
| 开场题:常规混合精度每参数 16 字节;V3 实际把 m、v 存成 bf16,主权重与累积梯度留 fp32 | DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 3.3.3(原文:用 BF16 代替 FP32 追踪 AdamW 一、二阶矩,「未观察到性能退化」;主权重与用于 batch 累积的梯度仍保留 FP32);常规做法里优化器状态与参数同精度(PyTorch 默认);Megatron-LM 需显式开启 --use-precision-aware-optimizer 再配 --exp-avg-dtype bf16 --exp-avg-sq-dtype bf16(Megatron Core MoE 文档;命令行参数在 megatron/training/arguments.py,不开精度感知优化器时 megatron/core/optimizer/optimizer_config.py 断言两者只能是 fp32);Megatron 的「精度感知优化器」参数组里并列 --main-grads-dtype、--main-params-dtype、--exp-avg-dtype、--exp-avg-sq-dtype(arguments.py),本课口径仍把梯度单列;V3 每参数约 14 字节为本课推导(计算用权重的精度报告未写,按 BF16 计);bf16 训练时 Megatron 默认把梯度累加与 all-reduce 放 fp32(megatron/training/arguments.py:「bfloat16 requires gradient accumulation and all-reduce to be done in fp32」),此时梯度 4 字节、每参数 18 字节 |
| V3 的 FP8 方案整体验证:损失相对误差低于 0.25% | 同上 sec. 3.3 与附录 B.1:约 16B、230B 两个规模各训约一万亿 token,整套 FP8 方案(含 bf16 优化器状态)对 BF16 基线;报告未单独消融「动量用 bf16」这一项 |
| 动量能不能用 bf16,要看 β₂ | V3 的 AdamW β₁=0.9、β₂=0.95(技术报告 sec. 4.2);PyTorch AdamW 默认 β₂=0.999。⚠️ 本课推导:bf16 有效位 8 位,相邻两数的相对间隔 2⁻⁷~2⁻⁸,四舍五入丢掉小于半个间隔(最小约 0.2%)的改动;β₂=0.999 时新值每步只占 0.1%。独立证据:Dettmers 等 arXiv 2110.02861,分块量化的 8 比特优化器状态能追平 32 比特 |
| V3 全部训练 278.8 万 H800 卡时;一块卡约 318 年 | DeepSeek-V3 技术报告摘要(含预训练、长上下文扩展与后训练);318 年 = 2.788M ÷ 8,760 小时,本课推导 |
| ZeRO 的本地更新不需要通信;梯度裁剪要一次标量 AllReduce | Adam 逐元素更新(Kingma 与 Ba,arXiv 1412.6980 算法 1);梯度裁剪按全体梯度的范数(Pascanu 等 arXiv 1211.5063),分片时各卡算局部平方和再 AllReduce(本课归纳) |
| ZeRO 各级的显存与通信(第二节) | Rajbhandari 等,ZeRO,arXiv 1910.02054 sec. 5、sec. 7:Pos、Pos+g 通信量与数据并行相同(2Ψ),Pos+g+p 最多 1.5 倍;显存 16Ψ → 16Ψ/Nd |
| TP 的切法与通信次数;SP 不增通信(第三节) | Megatron-LM arXiv 1909.08053 sec. 3(前向 2 次、反向 2 次 all-reduce);arXiv 2205.05198 sec. 4.2.2(AG+RS 替代 all-reduce,无额外通信);查询头数须被 TP 整除、KV 组数与 TP 互为倍数或约数:megatron/core/transformer/transformer_config.py 的校验 |
| PP 气泡 (p−1)/m;交错式除以 v | Narayanan 等 arXiv 2104.04473 sec. 2.2.1–2.2.2;Zero Bubble arXiv 2401.10241;DualPipe README |
| DualPipe 两份参数、激活峰值 p+1;Chimera 先例 | DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 3.2.1、表 2 |
| V 字形调度拉平各卡激活峰值 | Qi 等 arXiv 2405.15362 |
| MaxText:PP 默认 1;micro-batch = 全局批次 ÷ num_pipeline_microbatches | MaxText configs/base.yml 注释 |
| V3 训练并行配置;参数分布 | DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 3.2(16 路 PP、64 路 EP、ZeRO-1,不用 TP);config.json(61 层、前 3 层 dense、256 专家、moe_intermediate_size 2048、hidden 7168) |
| 每字节换多少计算、v7 硬件线约 3,845 | ⚠️ 本课推导(稠密近似、完全重叠);v7 2,307 TFLOP/s bf16;官方给每芯片 ICI 1,200 GB/s,另给 200 GB/s 一档;把它理解成每条链路收发合计,「6 条链路 × 200、发出方向 600」才对得上,这是推导(按 scaling book 单链路单向 9e10 算约 540,硬件线约 4,270,所以取 3,800–4,300 区间);按 device 口径同样约 3,845(一颗芯片的两个 device 共用链路,算力和带宽一起减半)(wiki ici-dcn、Inferact 博客规格表)。2026-09-25 更正:旧版误用 1,200 得出 1,922;TP 那条线的 4.5 系数按标准注意力加 4 倍宽 MLP 推出(V3 实际是 MLA 加 MoE,只作示意) |
| V3 的 EP 细节:最多 4 节点、FP8 派发 BF16 合并、无辅助损失的负载均衡 | DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 2.1.2、sec. 3.2.2、sec. 3.3.3;每 token 跨节点派发 ≈ 28.7 KB 为本课推导 |
| V3 负载均衡的超参与「不丢 token」;NVLink / IB 3.2 倍、同通信量最多 13 个专家 | 同一份报告 sec. 4.2(偏置更新步长 γ = 0.001,最后 500B token 置 0;序列级平衡损失 α = 0.0001;M = 4、64 卡 8 台)、sec. 2.1.2(No Token-Dropping)、sec. 3.2.2(160 / 50 GB/s,4 × 3.2 ≈ 13) |
| Parallel Folding 的例子 | Megatron-Core megatron/core/transformer/moe/README.md;arXiv 2504.14960 |
| GB300 上 TP4 → DEP8:同并发 512 总量 2.61 倍、每卡 2.09 倍(DEP8 并发 1,536 时每卡 2.47 倍、TTFT 95 s);调参 +45% | 本课程作者实测:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/README.md 与 VLLM-V4PRO-RUNBOOK.md(TP4 decode 14,563 → 调参后 21,100,16 GPU、每卡 1,319;DEP8 65,132,20 GPU、每卡 3,257 tok/s) |
| 激活随序列长度增长 | Korthikanti 等 arXiv 2205.05198 式 (1):每层 sbh(34 + 5as/h) |
| Ring Attention;Ulysses 通信量恒定、并行度不超过头数 | arXiv 2310.01889;arXiv 2309.14509 sec. 3.2(4Nh/P,N 与 P 同比放大时不变);头数上限见 USP arXiv 2405.07719 sec. 3 |
| CP 的之字形切法 | Megatron-LM megatron/core/utils.py(2×cp 块,rank r 拿第 r 与 2·cp−r−1 块);docs/user-guide/features/context_parallel.md |
| KV 被 TP 复制 tp/H 次;DCP 复用 TP rank | vLLM context parallel 部署文档;vllm/config/parallel.py docstring。V3 每 token KV 70,272 字节按 config.json 现算。config 里 num_key_value_heads=128 是 MLA 解压后的头数,推理缓存的是压缩后那一份,vLLM 当作 1 个 KV 头 |
| PD 分离的动机与收益(第六节) | DistServe arXiv 2401.09670(prefill 偏算力、decode 受带宽约束;7.4 倍请求是对 DeepSpeed-MII,12.6 倍更紧的 SLO 是对 vLLM) |
| v7x 上 1P1D 的 KV 三段约 100 ms(带宽估算);2P:1D / 1P:2D | 本课程作者的部署记录(KV 用时为按带宽估算,非计时):wiki qwen3-coder-480b-pd-disagg-tpuv7x-20260425。8K KV ≈ 1.04 GB、过 100 Gb/s 约 83 ms 为本课推导(Qwen3-Coder config:62 层、8 个 KV 头、head_dim 128) |
| 每一刀每步的通信次数(第七节) | ⚠️ 本课推导(60 层、8 个 micro-batch 的示意配置):TP 每层 4 次(arXiv 1909.08053 sec. 3),FSDP 每层 3 次(arXiv 1910.02054 sec. 7),EP / PP / DP 按调度数出 |
| GB300 NVLink 1.8 TB/s / 每 GPU 800 Gb/s 网卡;9 倍 | wiki sources/nvidia-gpu-comparison-20260311、analyses/gb300-a4x-max-network-congestion-control(A4X Max 每节点 4 GPU、4 × CX-8 800 Gb/s);9 倍为本课按双向口径换算 |
| 混元 3 的 scaling 与五步对照 | 本课程作者实测:gpu-tpu-pedia tpu/Hunyuan3-295B-Pretraining/TUNING-v7 sec. 3.7(五种分法 404 / 450 / 453 / OOM / OOM)、sec. 4.1(64 与 256 芯片同为 580)、sec. 3.6(DP2 × FSDP256、pdbs 16 得 599)、EP 4 路在 16 芯片上 −71%(单次)。sec. 4.1 一步 23.54 s;组间 all-reduce 占不到百分之一为本课推导(原文 12 ms 的算式前后不一致);换配法 EP 掉 37% 与 FSDP 加宽只慢不到 1%(450 对 453)见 TUNING-v7 sec. 3.7 |
| DCP 每层三次通信 | vllm/config/parallel.py 中 dcp_comm_backend 的 docstring(默认 ag_rs 每层 3 次 NCCL 调用,a2a 后端 2 次) |
| ZeRO-2 切 micro-batch 不再白送;配 PP 选 ZeRO-1 | DeepSpeed 文档:流水线并行不兼容 ZeRO-2/3;V3 技术报告 sec. 3.2(ZeRO-1);Megatron distributed optimizer |
| TP 每字节换多少计算 ≈ 4.5 × 隐藏维 ÷ TP、V3 TP8 ≈ 4,032 | ⚠️ 本课推导:每层 4 次 AllReduce 各发约 4Th 字节、算 72h²T/n(标准注意力+4 倍宽 MLP),对 V3 只作示意 |
| decode 时 EP 按专家逐个直发 | DeepEP 低延迟模式(deepseek-ai/DeepEP README);V3 技术报告 sec. 3.4 |
| V3 的集群与每 token 最多 4 节点 | DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 3.1(2,048 块 H800、节点内 NVLink、节点间 IB)、sec. 2.1.2、sec. 3.2 |
| strong / weak scaling | Amdahl 1967;Gustafson 1988(Reevaluating Amdahl's Law);临界 batch size:arXiv 1812.06162 |
| NVSwitch 在交换机里做加法(NVLS) | NCCL NVLS 算法(NVIDIA NCCL 文档);「少将近一半」为按每卡发出约 S 对 2(n−1)/n·S 的本课推导 |
| TPU 切片何时首尾成环、小切片带宽约减半 | How to Scale Your Model(scaling book)TPU 章节:只有整 cube(4 的倍数)才有环回;Google Cloud TPU7x 拓扑文档 |
| 3D 环面三块轮换、AllGather 快三倍 | How to Scale Your Model(scaling book)sharding 章:多轴收集时可用带宽成倍增加;63 对 21 为本课按 4×4×4 只算带宽的推导,XLA 实际调度未核对 |
| Llama 3 把 FSDP 放在最外层 | Llama 3 技术报告 arXiv 2407.21783 sec. 3.3.2(并行维度顺序 [TP, CP, PP, DP]) |
| V3 每 token 激活 370 亿参数、预训练 4K | DeepSeek-V3 技术报告 arXiv 2412.19437 摘要与 sec. 4.1 |
| TorchTitan 的「4D」 | TorchTitan 论文 arXiv 2410.06511 sec. 2.1.5 与表 6(4D parallelism = FSDP + TP + PP + CP);摘要只写到 3D(Llama 3.1 405B、512 卡),现 pytorch/torchtitan README 已不用「4D」这个说法 |
| 「最大的一块卡显存也就两三百 GB」 | NVIDIA B300 每卡 288 GB HBM3e;Google TPU7x 每芯片 192 GiB HBM(源码写十进制 206 × 10⁹ 字节 ≈ 191.85 GiB);9.76 TiB ≈ 10,700 GB(十进制) |
| DCN 每芯片 100 Gb/s;跨切片同口径慢约 50 倍 | Google Cloud TPU7x 文档(第五轮 TPU 专家评审核对);100 Gb/s 按单向计、×2 得双向约 25 GB/s,对 ICI 双向 1,200 GB/s 约 48 倍,为本课推导(只按单向比则约 96 倍) |
| TEP / DEP 的定义 | TensorRT-LLM tech blog 26(DeepSeek V4 on Blackwell)原文;vLLM Kimi K3 blog(2026-07-27) |
| Megatron 里没有 TEP / DEP;ETP / EDP / Parallel Folding | NVIDIA/Megatron-LM main:megatron/core/transformer/moe/README.md;论文 arXiv 2504.14960 |
| PCP 加卡、DCP 不加卡、DCP 复用 TP rank | vllm-project/vllm main:vllm/config/parallel.py 的 docstring;vLLM context parallel 部署文档 |
| Attention DP 的动机与开关 | SGLang DP / DPA 指南;TensorRT-LLM docs/source/features/parallel-strategy.md;vLLM data parallel 部署文档 |
| Helix | arXiv 2507.07120;TensorRT-LLM tech blog 22 |
| GTP 原话 | Megatron-LM docs/api-guide/core/generalized_tensor_parallel.md |
| Zero Bubble / DualPipe | arXiv 2401.10241;github.com/deepseek-ai/DualPipe |
| DiLoCo | arXiv 2311.08105;Streaming DiLoCo arXiv 2501.18512;MaxText 的 diloco mesh 轴 |
| AFD | MegaScale-Infer arXiv 2504.02263;Step-3 arXiv 2507.19427;vLLM AFD Plugin blog(2026-07-23) |
| Chunked PP | LMSYS blog(2026-01-15);Mooncake arXiv 2407.00079 |
| MaxText 的并行轴 | AI-Hypercomputer/maxtext:src/maxtext/configs/base.yml、docs/guides/optimization/sharding.md |
← 回 课程总纲 ·
上一讲 专题四 · 反向与优化器 ·
想自己讲一遍?看 本讲讲义(授课稿)
本页由 Courses/tools/topic05-build.py 生成 —— 正文写在那个脚本里。