并行策略

一个模型装不进一块卡,就得切开分到很多卡上。
每切一刀,就在那一维上多出一种通信。用一种通信,换一份显存或一份算力。

先认识五种通信,再一刀一刀地切:数据、权重、专家、序列,最后连工作一起拆开。 每一刀都在补前面没管到的那一块。

前置 专题四(那张 16 字节的账) 口径 截至 2026-09 ⏱ 讲约 84 分钟

课程作者 Chris Yang·Google Cloud AI Infra 架构师

这一讲另有一份讲义(授课稿)。

讲义写的是怎么讲:每一段的目的、讲到哪里该停、常见的误解、 被问到了怎么答。内容本身在你现在看的这份正文里。

两个用法。自己上台讲:照着讲义讲,台词、切图、时间都写着。 自学:把讲义整份丢给 AI,你会得到一个既有这一讲全部背景、 也知道该怎么讲的助教,让它带你走一遍。

每个数字的出处在文末台账;自己推出来的数,都标了「本课推导」。

第 零 节

一张卡装不下

🎧 本节讲课录音约 3 分 42 秒
🎯 开场热身:DeepSeek-V3 训练时,每个参数占的那 16 个字节都是什么? —— 第一问复习专题四,第二、三问预习这一讲。不做也不影响这一讲

第一问:按常规的混合精度 AdamW 训练,每个参数要在显存里常驻下面五样东西。各占几个字节?

权重(算的时候用的那一份) 字节
梯度 字节
主权重(优化器更新的那一份) 字节
一阶动量 m 字节
二阶动量 v 字节

预习(先想一想,答案在这一讲的 §2.2 揭晓):

  1. 第二问:这 16 字节里哪一块最大?要是让你削,先削哪块?
  2. 第三问:DeepSeek-V3 其实没按 16 字节存,它把其中两块压成了半精度。是哪两块?主权重为什么不能压?

专题四把账算完了:一个 6,710 亿参数的模型,按每参数 16 字节算(权重 2 + 梯度 2 + 优化器状态 12), 光常驻的训练状态就要 9.76 TiB,约合一万 GB。最大的一块卡显存也就两三百 GB,光放下就要三四十到五六十块卡,还没开始算。 一块卡装不下,就得切。问题是沿哪一维切。

一张卡:放不下,也算不完 —— 切开是为了放得下,也为了算得快 DeepSeek-V3,6,710 亿参数,常规混合精度训练(每参数 16 字节) B300 TPU v7 2,048 张卡一起算 放不下:9.76 TiB 要摊到几块卡上 B300(每卡 288 GB):38 块 TPU v7(每芯片 192 GiB):53 块 算不完:278.8 万 H800 卡时 一块卡:318 年 2,048 张卡一起算:约 57 天 ← 同一把尺子,短到只剩一条线 卡时含预训练、长上下文扩展和后训练。 所以要切:可每切一刀,卡和卡之间就多一种通信 左边这一万 GB 还只是模型状态;激活跟 batch × 序列长度成正比,序列一长比它还大。 切开之后,你缺的那块在我这儿、我缺的在你那儿,只能互相传 —— 这一讲只讲这件事。
左边是放不下,右边是算不完。
一格一块卡;右边两根条用的是同一把尺子。
出处与口径

📌 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、序列、隐藏维、层、专家。这一讲从头到尾只讲一件事:

一句话 用一种通信,换一份显存或一份算力。
选并行策略,就是在选你愿意付哪一种通信、付多频繁、放在哪根线上。

这一讲按一条接力线走:切一刀,付一笔通信;切完发现还有一块没管到,再切一刀。

一条接力线 —— 红字就是下一刀出场的理由 盒子里:这一刀切什么、多付哪种通信(过路费)。盒子下面的红字:它留下的问题,逼出下一刀 留下的问题 → 下一刀的理由 先认识五种通信,再一刀一刀切 第一刀 切数据 切 batch;再削掉重复存的 过路费: AllReduce 拆成两半 ↳ 留下的问题 batch 一小,搬权重就藏不住 第二刀 切权重 切进矩阵、按层切 过路费: 每层 AllReduce;段间收发 ↳ 留下的问题 参数几乎全在很窄的专家里 第三刀 切专家 专家整个分给不同的卡 过路费: 每层两次 AllToAll ↳ 留下的问题 上下文一长,一条样本装不下 第四刀 切序列 训练切激活,推理切 KV 过路费: 环上传 KV;收齐 Q、合结果 ↳ 留下的问题 prefill、decode 要的切法不一样 第五刀 切工作 prefill、decode 分开放 过路费: 一请求一趟 KV 传输 ↳ 留下的问题 刀这么多,谁坐快线? 摆到机器上 说得勤的坐快线 过路费: 摆错一次,同样的卡慢几倍 每一刀都不白来,也都不是最后一刀 它多付一种通信,换回一截显存或一份速度。 它没管到的那一块,就是下一节开头要解决的问题。
红字是剧情:每一刀留下的问题,就是下一节的开头。
每一节最后一小节「这一刀留下的问题」,就是这里的一格红字。

量每一刀用两把尺子:它多出来的通信有多频繁(决定放哪根线),每搬一个字节换来多少计算(决定会不会被拖住,第三节)。

遇到不认识的词,回这儿查:张量、激活、注意力头、MoE、KV cache、prefill 与 decode、Q/K/V、MLA、显存、ICI、「几路」……(专题一、三讲过,这里各一句话)

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 越大越划算。

第 一 节

先认识五种通信

🎧 本节讲课录音约 8 分 21 秒

后面每一刀都会多出一种通信。这一节先把它们认全:日常用到的是五种,AllReduce、AllGather、ReduceScatter、AllToAll,再加最朴素的一对一收发。 名字看着多,但每一个都只回答两个问题:谁发给谁;数据到了之后是拼起来、加起来,还是原样放着。

1.1 先学会看图

一组卡按同一个规则一起发、一起收,叫集合通信。下面几张图用同一套画法,只学一次:

1.2 一个人对所有人:四个基本动作

把四张卡想成四个同学,卡 0 是班长。

先认识四个基本动作 —— 一个人对所有人 四张卡,一张一个颜色。数据切成四块。条纹块 = 几张卡的数加在了一起,虚线框 = 这里没有数据 卡 0 的数据 A 卡 1 的 B 卡 2 的 C 卡 3 的 D Broadcast 广播 一份 → 人人一份 之前 之后 卡 0 A0 A1 A2 A3 A0 A1 A2 A3 卡 1 A0 A1 A2 A3 卡 2 A0 A1 A2 A3 卡 3 A0 A1 A2 A3 卡 0 的整份数据,复制给每一个人 Scatter 分发 一份拆开 → 一人一块 之前 之后 卡 0 A0 A1 A2 A3 A0 卡 1 A1 卡 2 A2 卡 3 A3 卡 0 把自己那份切成四块,一人发一块 Gather 收集 一人一块 → 拼成一份 之前 之后 卡 0 A0 A0 B1 C2 D3 卡 1 B1 卡 2 C2 卡 3 D3 每人交一块给卡 0,卡 0 按顺序拼起来 Reduce 归约 人人一份 → 加成一份 之前 之后 卡 0 A0 A1 A2 A3 Σ0 Σ1 Σ2 Σ3 卡 1 B0 B1 B2 B3 卡 2 C0 C1 C2 C3 卡 3 D0 D1 D2 D3 每人交一整份给卡 0,卡 0 逐块相加 两两成对,差别只在一个动作 广播和分发是一变多,收集和归约是多变一。 收集和归约的区别只在于:数据到了之后拼起来还是加起来。 这四个都有一个「班长」卡 0,按最朴素的做法,所有流量都挤在它一个人的线上。训练里真正天天在跑的是没有班长的几个:AllGather、ReduceScatter、AllReduce;AllToAll 则是每个人各做一次分发。
四个有班长的动作:广播、分发、收集、归约。
收集和归约只差一个动作:数据到了之后是拼起来,还是加起来。
看它们动起来:四支小动画,一步一停
Broadcast 广播:卡 0 的整份数据,复制给每一个人(7 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)
Scatter 分发:卡 0 把第 j 块发给卡 j,自己只留第 0 块(7 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)
Gather 收集:每人把自己那块交给卡 0,卡 0 按顺序拼起来(7 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)
Reduce 归约:每人把整份交给卡 0,卡 0 逐块相加(7 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)

这四个都有一个「班长」,数据全压在它一条线上,卡一多就堵。所以训练里天天跑的是下面那组。

细一点:班长到底怎么堵、通信库怎么缓解

按最朴素的做法(班长挨个发、挨个收),广播和归约的班长要扛下全部流量,卡越多越堵; 通信库会把它们排成一条链接力传,让班长只发或只收一份。收集和分发的班长省不掉那份量,它手里本来就是 n 份不同的东西:总量不随卡数涨,但全压在它一条线上。

1.3 人人对人人:训练里天天在跑的四个

训练里天天在跑的四个 —— 人人对人人,没有班长 名字前面带 All 的,意思是结果人人都有一份。画法不变:条纹 = 加过,虚线 = 空 卡 0 卡 1 卡 2 卡 3 AllGather 全收集 一人一块 → 人人一整份 之前 之后 卡 0 A A B C D 卡 1 B A B C D 卡 2 C A B C D 卡 3 D A B C D 只拼不加。FSDP 前向时用它把整层权重拼回来 ReduceScatter 归约分散 人人一整份 → 各拿一块总和 之前 之后 卡 0 A0 A1 A2 A3 Σ0 卡 1 B0 B1 B2 B3 Σ1 卡 2 C0 C1 C2 C3 Σ2 卡 3 D0 D1 D2 D3 Σ3 先加再分。卡 k 只拿到第 k 块的总和 AllReduce 全归约 人人一整份 → 人人一份总和 之前 之后 卡 0 A0 A1 A2 A3 Σ0 Σ1 Σ2 Σ3 卡 1 B0 B1 B2 B3 Σ0 Σ1 Σ2 Σ3 卡 2 C0 C1 C2 C3 Σ0 Σ1 Σ2 Σ3 卡 3 D0 D1 D2 D3 Σ0 Σ1 Σ2 Σ3 数据并行同步梯度用的就是它 AllToAll 全交换 卡 k 给卡 j 寄一份(这里画每份一样大的特例) 之前 之后 卡 0 A0 A1 A2 A3 A0 B0 C0 D0 卡 1 B0 B1 B2 B3 A1 B1 C1 D1 卡 2 C0 C1 C2 C3 A2 B2 C2 D2 卡 3 D0 D1 D2 D3 A3 B3 C3 D3 不加也不拼,只换位置。MoE 派发 token 用它 前三个是一家人,第四个是另一回事 AllGather 是拼,ReduceScatter 是加完再分,AllReduce 是加完人人一份。拆开来看,AllReduce 正好等于先 ReduceScatter、再 AllGather(顺序见 1.4)。 AllToAll 不加也不拼:每张卡给每张卡发一份不一样的。任意两张卡之间都有流量,所以它对网络最挑剔。
名字带 All 的,结果人人一份。
AllToAll 是另一回事:不加也不拼,只换位置;这里画的是每份一样大的特例。
AllGather 全收集:按环转三步,每步人人把刚拿到的那块传给右边,只拼不加(20 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)
ReduceScatter 归约分散:按环转三步,每步人人往右发一块、收的人加上;三步后卡 j 握着第 j 块的总和(23 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)
AllReduce 全归约:同一个环转两圈,先加三步(ReduceScatter)、再拼三步(AllGather)(41 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)

All =「人人都拿到结果」:AllGather 是收集完发给每个人,ReduceScatter 是归约完切开、一人一块,AllReduce 是归约完发给每个人;AllToAll 独一份,不加也不拼。

1.4 AllReduce 可以拆成两半

全课最重要的一个等式 —— AllReduce = ReduceScatter + AllGather 同一个 AllReduce,拆成两半来做,结果一模一样。后面好几种并行,用的就是这两半中的某一半 卡 0 卡 1 卡 2 卡 3 拆成两半 开始:人人一整份 卡 0 A0 A1 A2 A3 卡 1 B0 B1 B2 B3 卡 2 C0 C1 C2 C3 卡 3 D0 D1 D2 D3 ReduceScatter 之后:各拿一块总和 Σ0 Σ1 Σ2 Σ3 AllGather 之后:人人一份总和 Σ0 Σ1 Σ2 Σ3 Σ0 Σ1 Σ2 Σ3 Σ0 Σ1 Σ2 Σ3 Σ0 Σ1 Σ2 Σ3 ① ReduceScatter 先加,每人留一块 ② AllGather 再拼,发给每个人 每一步,每张卡发出去的数据都是整份的 (n−1)/n;两步加起来 2(n−1)/n —— 跟 NCCL 给 AllReduce 定的带宽系数是同一个数 所以后面能反复白捡便宜 数据并行本来就要做一次 AllReduce。ZeRO 把它拆开:先用 ReduceScatter 分梯度、各自更新,再用 AllGather 拼回新权重 —— 前两级通信总量不变,显存却省下来了。 同理,张量并行配上序列并行时,也是把每层那次 AllReduce 拆成这两半,分别挪到不同位置去做。
先加后拼,跟一步到位的结果完全一样。
拆开之后,两半可以放在不同的时间点去做。

拆开以后,中间还能塞进别的动作。后面好几种并行白捡的便宜全从这里来:ZeRO(第二节)、张量并行配序列并行(第三节)。

细一点:同样是 AG 和 RS 两个动作,顺序和中间夹什么,决定了它是谁
  • AllReduce:先 RS 后 AG,两半之间什么都不夹,就是同一个环转两圈(§1.5)。
  • 先 AG 后 RS,中间夹一段计算:进门拼齐、算、出门切回。FSDP 拼权重(§2.3)、SP 拼序列(§3.3)都是这个形状,专家并行用 AllGather 派发 token 时也是(Megatron 的 allgather 派发器)。本课简写成 AGRS。
  • 先 RS 后 AG,中间夹优化器:ZeRO 分梯度、各自更新、再拼新权重(§2.2)。字母顺序跟 AllReduce 一样,差别在中间多了一步更新。本课简写成 RSAG。
  • AG 和 RS 互为转置:前向在某处做 AG,反向在同一处就做 RS,反过来也一样。所以 SP 的反向按位置看两者对调了,按时间看还是先 AG 后 RS:反向先碰到的是前向的出口。
  • FSDP 比较特殊:前向只有 AG。反向那次 AG 不是转置来的,是把前向扔掉的权重再拼一次;RS 才是前向 AG 的转置。

⚠️ AGRS/RSAG 是本课为了说清顺序起的简写,不是通用术语。

1.5 没有班长,怎么做到的:环

班长模式下卡 0 要收 n−1 份、发 n−1 份,成了全场的瓶颈。换个办法:首尾相连排成一圈,谁都不当班长。

同一个环转两圈:前三步加(ReduceScatter),后三步拼(AllGather),合起来就是一次 AllReduce。卡 3 发出的那块从右边出去、绕回卡 0。 (41 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)

这个环,其实就是把 AllReduce 拼成了 ReduceScatter + AllGather。换一种拼法比一比,就知道它为什么赢:

同一个 AllReduce,两种拼法 —— 班长累死,还是人人平摊 S = 一整份数据。条长 = 这张卡一共要发出去多少份(最朴素的班长做法,不排链) 卡 0 卡 1 卡 2 卡 3 拼法一:Reduce + Broadcast(班长) 卡 0 3 份 卡 1 1 份 卡 2 1 份 卡 3 1 份 卡 0 那一条线扛下全部,卡越多越堵 拼法二:ReduceScatter + AllGather(环) 卡 0 1.5 份 卡 1 1.5 份 卡 2 1.5 份 卡 3 1.5 份 实心 = RS 那 3 步,空心 = AG 那 3 步,各 3/4 份 人人一样忙,所有的线同时在用 卡再多,也发不满两份 卡数 n 班长:n − 1 环:2(n−1)/n 2 1 1 4 3 1.5 8 7 1.75 1,000 999 1.998 公式里的 −1:自己那块不用寄给自己 所以通信库几乎都选拼法二 两种拼法算出来的结果一模一样,差的只是谁在干活:拼法一压在卡 0 一个人身上,拼法二摊给所有人。 而拼法二的两半,就是 ReduceScatter 和 AllGather —— 后面几刀白捡的便宜,全从这个拆法里来。
结果一样,差的是谁在干活。
右边那张小表:班长那列跟着卡数涨,环那列永远不到 2。
出处与口径

📌 两种拼法:NVIDIA NCCL 文档 Collective Operations(AllReduce = Reduce + Broadcast = ReduceScatter + AllGather)。

⚠️ 本课推导:朴素班长做法卡 0 发 n−1 份;环上每卡发 2(n−1)/n 份。通信库实际会给班长做法排链或走树,这里只比最朴素的两种。

代价是步数跟着卡数涨:数据小时比的是一步步的等待,环反而吃亏,所以通信库会按数据大小自己挑算法。

细一点:环形和树形怎么挑、NVSwitch 在交换机里做加法、TPU 的环面

数据很大时比的是带宽,环几乎是最优的;数据很小时比的是一步一步的等待,步数多反而吃亏。 所以 NCCL 这类通信库会按消息大小,在环形、树形等几种算法之间自己挑。 NVLink 交换机(NVSwitch)还能在交换机里直接做加法,每张卡发出去的又能少将近一半。

TPU 这边更直接:芯片之间的 ICI 本身就连成环面,切片够大(每一维都是 4 的整倍数)时,每一维天然就是一个首尾相接的环; 更小的切片某一维只是一条线,环要在线上折返,带宽约减半。

环面还多给一样东西:一颗芯片有 X、Y、Z 三个方向的环。先沿 X 收、再沿 Y、再沿 Z,每一步只有一个方向在干活,最后一步还最重; 把数据切成三块、各挑一条轴起步(XYZ/YZX/ZXY),三个方向就一直满着,同样一次 AllGather 只按带宽算能快到三倍。 ReduceScatter 倒着走(大的一步在前),AllReduce 两段同理。⚠️ 这是本课推导:没算每一步的固定延迟,XLA 实际怎么切块、怎么排也没核对。

3D 环面上的 AllGather —— 三块数据错开路线,三条轴一起忙 4×4×4 切片,每颗芯片起手 1/64。条长 = 这条轴搬了多久(单位:1/64 份数据过一条轴),两边同一把尺子 块 A 块 B 块 C 逐轴:X 走完才走 Y、再走 Z 3 15 63 X 轴 闲 Y 轴 闲 Z 轴 闲 用时 63 每一步只有一条轴在忙;第 3 步一步就占了 48/63 轮换:A 走 XYZ、B 走 YZX、C 走 ZXY 1 5 21 X 轴 Y 轴 Z 轴 用时 21 同样的色块摆开了:三条轴从头忙到尾,用时 1/3 数据一样多,差的是有几条轴同时在干活 X、Y、Z 各是一个环:逐轴走,每一步只用上一个方向;轮换走,三个方向一直满着,带宽翻三倍。 ReduceScatter 倒着走(大的一步在前),AllReduce = 两者接起来;只按带宽算,同样快三倍。
同样的色块,左边排队,右边摆开。
4×4×4 切片;只按带宽算,不算每步延迟。
出处与口径

📌 多轴收集带宽成倍:How to Scale Your Model(scaling book)sharding 章(中文版:沿多个轴收集时,可用带宽成倍增加)。

⚠️ 本课推导:只按带宽算、不算每步延迟;三条轴带宽相同、每一维都是首尾相接的环(切片每一维是 4 的整倍数)。XLA 实际怎么切块、怎么排,没有核对过。

同一个 4×4×4 立方体演两遍:逐轴时每一步只亮一个方向,轮换时三个方向全亮;右下两根用时条同一把尺子,63 对 21。 (47 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。)

1.6 AllToAll:每人给每人一份不一样的

AllToAll —— 每人给每人寄一份,份份不同,多少也不同 以专家并行为例:每个 token 由路由定好去哪张卡(格子里的数字);颜色 = 从哪张卡出发 卡 0 出发 卡 1 出发 卡 2 出发 卡 3 出发 ① 派发:人人同时往所有方向寄,线越粗寄得越多 出发:每张卡 8 个 token,各去各的卡 收到:按出发的卡排好 卡 0 1 0 2 3 1 3 1 0 卡 1 0 0 0 2 1 2 3 3 卡 2 0 0 0 2 1 1 0 3 卡 3 1 0 2 3 0 2 1 2 卡 0 收 11 个 卡 1 收 8 个 卡 2 收 7 个 卡 3 收 6 个 虚线 = 寄给自己:不走网络。其余每一根都要跨卡,而且全部同时出发 卡 0 收了 11 个、卡 3 只收 6 个:大家都得等卡 0 算完 ② 合并:专家算完,原路寄回 卡 0 卡 0 卡 1 卡 1 卡 2 卡 2 卡 3 卡 3 同一批线, 方向反过来: 每个 token 回到 出发的卡、原来的位置 每层两次:派发一次, 合并一次 ③ 特例:每份一样大,就是一次转置 卡 k 一行 卡 j 一行 转置 Ulysses 在按段、按头之间换, 用的就是这个等量的特例 为什么网络最怕它 每份多大要等路由算完才知道(数目不等时常叫 AllToAllv),收件的人忙闲不均,最忙的那张卡决定大家等多久。 每一份都是私信:路上没法像 AllReduce 那样边走边合并,也排不成只跟邻居说话的环,任意两张卡之间都有流量,拼的是整个网络的横截面。
派发乱射、合并原路回;每份一样大时才是转置。
数目是示意;真实的每份多大,要等路由算完才知道。
出处与口径

⚠️ 示意:每张卡寄给每张卡几个 token 是随手定的固定数,不是实测的路由分布;真实的 V3 每个 token 挑 8 个专家。

派发时同时往所有方向乱射,数目各不相同;算完沿同一批线原路飞回。 (20 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看;手动模式每一步停住。)

专家并行(第四节)用的是它的一般情形:数目不等、派发完还要原路合并;Ulysses(第五节)用的是每份一样大的特例,也就是转置。

1.7 一张表收住

八个名字里带班长的四个只是积木,日常用的是五种(最后一种一对一收发,第三节切层时用)。给会后查:

「每卡发出」按环形算法算;S 是一整份数据(AllGather 指拼好之后那份,ReduceScatter 指加之前那份);Broadcast/Reduce 按链式接力算。
通信做什么每卡发出后面谁在用
AllReduce加完,人人一份2(n−1)/n · S数据并行同步梯度;张量并行每层前向两次、反向两次
ReduceScatter加完,各拿一块(n−1)/n · SFSDP 反向分梯度;张量并行配序列并行
AllGather拼完,人人一份(n−1)/n · SFSDP 前向拼权重;张量并行配序列并行;推理切 KV 时收齐 Q
AllToAll只换位置(n−1)/n · S专家并行派发和收回 token;Ulysses
Broadcast / Reduce一对多 / 多对一S分发初始权重、汇总指标这类场合
Send / Recv一对一看传多少流水线并行在 stage 之间传激活;Ring Attention 沿环传 KV
这一节只要带走两件事 ① AllReduce 可以拆成 ReduceScatter 和 AllGather 两半,后面好几刀都靠它白捡便宜。
② AllToAll 是唯一一个人人对人人发不同数据的,专家并行离不开它,网络也最怕它。
后面五刀,每一刀多出来的通信都是这张表里的某一行。话认全了,第一刀:切数据。
考考自己:四张卡做一次 AllReduce:环形做法下每张卡一共发出几份数据?最朴素的班长做法下,卡 0 要发几份?

环:ReduceScatter 3 步各发 1/4 份,AllGather 再 3 步,一共 1.5 份;班长:卡 0 发 3 份。卡越多差得越远。

第 二 节

第一刀:切数据

🎧 本节讲课录音约 8 分 19 秒

最朴素的一刀是切数据:每张卡算不同的样本。 可它一开始根本没解决「装不下」,要一路削到 FSDP 才解决 —— 而最后那一步是要付钱的。

2.1 数据并行:每张卡一整份模型

每张卡放一整份模型、各算一批样本;反向算完做一次 AllReduce 求平均,再一起更新。 一步只通信一次(频率最低,量却不小:V3 这么大的模型要是纯数据并行,每卡一步约发 2.7 TB)。每张卡还是存一整份 16 字节/参数 —— 装不下一点没变。

打个比方:V3 的全部权重是一整套四库全书,分放在 61 间书房里,一间一层。按 V3 的配置有 128 个阁(一个阁就是一张卡),数据并行等于每个阁都藏一整套。下面一节一节把重复的清掉。

2.2 ZeRO:越闲的越先削

先认清那三块:权重是模型本身;梯度是这一步算出来的「每个参数该往哪改、改多少」;优化器状态是优化器替每个参数记的账(主权重、两个动量),它最大。下文的 Ψ 就是参数个数。

口径:本课按 ZeRO 论文算,优化器状态指跨步常驻、要存进 checkpoint 的那几样;梯度每步重算、用完清零,单独算一块(所以 ZeRO 才能把「切梯度」单列一级)。Megatron 里累加梯度的精度(--main-grads-dtype)跟主权重、两个动量的精度归在同一组「精度感知优化器」参数里配,所以也有人把它算进优化器。

ZeRO:把重复的削掉,一次削一样 —— 前两级白送,最后一级要付 50% 的通信 每个参数 16 字节,按专题四那张表的口径拆成三块。例子:DeepSeek-V3,6,710 亿参数,128 路数据并行(2,048 卡 ÷ 16 段流水线) 权重 2 字节(bf16) 梯度 2 字节(bf16) 优化器状态 12 字节(fp32) 每张卡要常驻多少字节 / 参数 条长 ∝ 每参数字节数 每参数字节(切成 128 份之后) V3 每卡常驻 每步通信 数据并行 16.00 字节 9.76 TiB 2Ψ ZeRO-1 4.09 字节 2.50 TiB 2Ψ(=数据并行) ZeRO-2 2.11 字节 1.29 TiB 2Ψ(=数据并行) ZeRO-3 = FSDP ← 放大 20 倍才看得见 0.125 字节 78.11 GiB 3Ψ(1.5×) 被切掉的那几块没有消失:每张卡只剩自己那 1/128。 前两级白送,最后一级要付钱 ZeRO-1、ZeRO-2 通信量跟数据并行一个字节都不多(一步只同步一次时),却已经把 16 字节削到约 2 字节。 可 V3 按这个算每卡还要 1.29 TiB,一张卡照样装不下。 只有 ZeRO-3 能降到每卡 78.11 GiB,代价是通信从 2Ψ 变成 3Ψ,多一半。 可一张 H800 才 80 GB,约 84 GB 装不进去,激活更没地方放:光切数据还不够。
16 字节里,优化器状态独占 12 个 —— 所以先削它。
ZeRO-3 那条细得要放大才看得清:16 个字节切成 128 份,每份只剩 0.125。
出处与口径

📌 出处: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 份、反向 2 份、最后一小段更新) 权重 2 字节 梯度 2 字节 优化器状态 12 字节 一步:前向 → 反向 → 更新 前向 反向 更新 权重 ZeRO-3 最后削:最忙,削了每层都得先复制回来 多付一半通信 梯度 ZeRO-2 再削:反向时才一层层出现 白送 优化器状态 整整一步都在显存里干放着 ZeRO-1 先削:最大又最闲,只在更新那一下用 白送 实心 = 这段时间在读写它;虚线 = 占着显存,但没人碰 最大的恰好也最闲,所以先削它 优化器状态占 16 字节里的 12 个,一步里只在最后更新那一下用:每张卡只管自己那 1/n,谁也不耽误。 越往上越忙:权重每一层都要用,削了它,每层算之前就得先把别人那几段复制过来,这就是 FSDP 多付的那一半通信。
虚线那一长条,就是 ZeRO-1 白捡的地方。
时间轴是示意,只画每块东西什么时候被读写。

ZeRO-1 切优化器状态,ZeRO-2 再切梯度,ZeRO-3 连权重也切。每张卡只长期存自己负责的那 1/n。 ZeRO-1 顺手还省了一笔计算:原来每张卡都把全部参数更新一遍,现在各更新各的 1/n。

前两级为什么不多花一个字节的通信?就是 §1.4 那个等式:

ZeRO 的一步:中间那次更新只在自己卡上做 —— 拆开的 AllReduce,正好把它夹在中间 四张卡;梯度按参数切成四段,卡 k 负责第 k 段。条纹=几张卡的加在一起,虚线框=这张卡不存 卡 0 卡 1 卡 2 卡 3 一步里发生的三件事 反向算完:各有一整份梯度 卡 0 g0 g1 g2 g3 卡 1 g0 g1 g2 g3 卡 2 g0 g1 g2 g3 卡 3 g0 g1 g2 g3 ReduceScatter:只拿第 k 段的总和 Σ0 Σ1 Σ2 Σ3 本地更新第 k 段(不通信) W0 W1 W2 W3 AllGather:拼回整份新权重 W0 W1 W2 W3 W0 W1 W2 W3 W0 W1 W2 W3 W0 W1 W2 W3 ① ② ③ 中间那步不用通信:Adam 是逐个元素算的 第 i 个参数的新值只看它自己的梯度、两个动量和主权重。四张卡各更新一段,跟一张卡全部更新一遍,结果一模一样。 ① + ③ 正好是原来那一次 AllReduce,一个字节不多;唯一例外是梯度裁剪:各卡算自己那段的平方和,再 AllReduce 一个数。
① ReduceScatter、③ AllGather 拼起来就是原来那次 AllReduce。
多出来的只是中间那一格:每张卡只更新自己那一段。
出处与口径

📌 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。

开场第三问的答案:V3 把两个动量压成了半精度,主权重留在全精度(批次累积用的那份梯度也是) 注意优化器状态里没有梯度:梯度只是每步喂给优化器的输入,用完就清零;要放全精度的是把几个小批的梯度加起来的那个累加器。
算下来(本课口径,见 2.2):V3 的优化器状态从 12 字节降到 8 字节(主权重 4 + 两个动量各 2),梯度累加器另算 4 字节;再加计算用的那份权重(报告没单独写精度,按常规 BF16 推,2 字节),每参数约 14 字节(本课推导)。
主权重每步只加一点点、要一直累加,压了会被舍掉;动量能不能压要看 β₂ —— 展开下面「细一点」那把刻度尺(V3 用 0.95,PyTorch 默认 0.999)。
细一点:动量为什么压得了、主权重为什么压不得 —— 一把刻度尺
动量能不能存成 bf16:看一步挪多远 —— 挪不过半格,就被舍回原处 刻度=bf16 在 1 附近能表示的数(相邻差 1/128)。v ← β₂·v + (1−β₂)·g²;假设当前 v=1,新来的 g² 是它的 2 倍 β₂=0.95(V3) β₂=0.999(PyTorch 默认) 一把 bf16 的刻度尺 1.0000 1.0078 1.0156 1.0234 1.0312 1.0391 1.0469 1.0547 1.0625 新值占 5%:挪到 1.050,存成 1.0469 —— 留下来了 新值占 0.1%:挪到 1.001,不到半格(0.0039),存成 1.000 —— 被舍掉了 所以 V3 敢把两个动量存成 bf16,主权重却不行 动量是滑动平均,β₂ 不太接近 1 时每步挪得够远,bf16 存得住;V3 用的是 0.95。 主权重每一步只加一点点、而且要一直累加下去:小于半格的更新全被舍掉,所以留在 fp32。
绿的那一步挪过了几格,红的那一步没挪过半格。
舍入按 bf16 真算;假设新来的 g² 是当前 v 的 2 倍。
出处与口径

📌 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.3 ZeRO-3 = FSDP:最后那 2 个字节要付 50%

削完前两级,每参数还剩 2 字节的权重。V3 按 128 路算,每卡仍要 1.29 TiB(约 1,415 GB,一张卡才两三百 GB),照样装不下。 ZeRO-2 加再多卡也降不下去了:剩下的正是人人一整份的权重。只靠数据并行这一刀,大模型只能走到 ZeRO-3,也就是 PyTorch 里的 FSDP:每层要算之前先 AllGather 拼回这一层,算完就扔。

回到藏书楼。FSDP 切的时候根本不管书是什么:把一间书房的书一页页排成一长条,按长度等分成 128 段,每阁拿一段。切口常常落在一本书中间,所以每阁手里那段,可能是一本书的后半截接着另一本的开头 —— 单拿这一段谁也读不了。 要用这一间,就得把其余 127 段都抄过来,凑回整间(AllGather),读完把抄本扔掉,只留自己那段;反向算完,每一段的修改意见交回管那段的阁合并(ReduceScatter)。

一座藏书楼,三种分法 —— FSDP 切碎了、拼回来才能读;EP 整架分、拿着就能用 把 V3 的全部权重想成一整套四库全书:一间书房 = 一层,一个阁 = 一张卡。阁数按 V3 的真实配置 Dense 书房 注意力目录台 共享书架 专家书架 ① 藏书楼 = 模型:61 间书房 = 61 层 前 3 间:Dense 后 58 间:MoE,大多数长得一模一样 第 1 间在最左,数据从左往右一间一间过 整套约 6,710 亿个参数;这是全部的书,不是其中一本 放大一间 MoE 书房 目录台 共享架 256 个专家书架,每架是一个完整的专家 ② 数据并行:128 个阁,每阁一整套 阁 1:整套 阁 2:整套 阁 3:整套 阁 4:整套 … 阁 128:整套 谁也不缺,可每个阁都被同一套书占满 128 个阁存了 128 份一模一样的书 ③ FSDP:每间书房拍平、按长度等分,每阁只拿一段 示意画 8 段,实际 128 段 第 k 间的书, 一页页排成一条 书 1 书 2 书 3 书 4 书 5 书 6 书 7 阁 1 阁 2 阁 3 阁 4 … 阁 126 阁 127 阁 128 红线等距切, 不看书的边界 阁 3 手里:一本书的后半截 + 另一本的开头 单拿这一段,读不了 要用第 k 间 128 段各抄一份,拼回整间(AllGather) 读:这一层算完 扔掉抄本,只留自己那段 反向时再抄一次 ④ 对比:EP、PP 按整件分,拿到手就能用 EP 256 架分 64 阁 阁 1:书架 1–4 阁 2:书架 5–8 阁 3:书架 9–12 … 阁 64:书架 253–256 每阁 4 整架,一架就是一个完整专家 拿着就能用;要查,就跑去那一阁 PP 61 间分 16 段 每段按顺序拿几间完整的书房 一间就是一整层,拿着就能算 每段约 4 间(示意;V3 实际每段几层,报告没写) 区别在拿到手的那一份能不能单独用 FSDP 不管书的边界,只按长度等分,为的是通信好切块;所以单独一段没用,每次用之前都得 AllGather 拼回整间。 EP、PP 按整件分:一架是一个完整专家,一间是一整层,拿着就能算。它们付的是别的钱:token 得跑去找专家,层与层得排队递活。
单独一段读不了:这是 FSDP 跟 EP、PP 最大的区别。
阁数按 V3 的真实配置:数据并行 128、EP 64、PP 16。
出处与口径

📌 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 切的是碎片,为的是通信好切块,拼回来之前没用。

FSDP 为什么多 50% —— 反向时要把扔掉的权重再拼一次 同一层、同一步。每个色块是一次通信,量都是这一层权重的 (n−1)/n 份 AllGather(拼回整份) ReduceScatter(加起来再分) 计算 一层 · 一步 数据并行 前向 反向 RS AG 2 份(RS + AG = 一次 AllReduce) FSDP AG 前向 扔掉权重 AG 反向 RS 3 份 = 1.5× 拼一次、扔掉、再拼一次 FSDP 每层前向前拼一次权重,算完就扔,所以显存里永远只有一层是完整的;反向要用时,只好再拼一次 —— 多出来的正是这一份。 反过来也成立:前向后不扔(PyTorch 叫 reshard_after_forward=False),通信就回到 2 份,代价是整个反向期间都攥着完整权重。又是一次拿通信换显存。
数据并行一层做两次通信,FSDP 做三次。
多出来的那次 AllGather,是反向时把前向扔掉的权重再拼回来。
整层只在用的那一刻出现;平时每张卡只拿着每层的四分之一。 (14 秒无声循环,Manim 渲染。)

通信是 3Ψ,数据并行的 1.5 倍;换来的是每卡常驻从 9.76 TiB 降到 78.11 GiB(约 84 GB,还不含激活)。可 V3 用的 H800 一张才 80 GB,光这些就已经放不下,更别说激活 —— 光切数据还不够,后面几刀就是这么来的。

⚠️ 哪几级白送,哪一级要付钱 ZeRO-1、ZeRO-2 白送(切 micro-batch 时只剩 ZeRO-1,原因见「ZeRO 的一步」那张图的出处);ZeRO-3 多付一半,对大模型来说非付不可。

2.4 这一刀能放多远:看频率

数据并行一步说一次话,能放在慢链路上;FSDP 每层都要说,得放在快线里。

细一点:数据并行、FSDP、HSDP、DiLoCo 各能放多远
  • 数据并行、ZeRO-1:一步通信一次,可以放在慢链路上,最远能横跨数据中心。
  • FSDP:每一层都要拼一次权重,一步下来多出成百上千次(第七节有个数),得放在高带宽域里。
  • HSDP 是两者的折中:机内 FSDP、机间数据并行。高频的拼权重留在机内,跨机只剩梯度同步,量也除以了机内的分片数。
  • DiLoCo 再往前一步:每个副本先自己走几百步再同步一次,专门为跨数据中心训练设计。
⚠️ HSDP 的梯度同步,写法不对会被编成一次全员 AllReduce HSDP 的梯度要在两根轴上求和,最后按 FSDP 那根轴切开,各回各的主人。
省的做法:先在机内 FSDP 轴上 ReduceScatter,每人只剩 1/F;再在机间数据轴上,对这 1/F 做 AllReduce。
费的做法:两根轴并成一个大组,对整份梯度做一次 AllReduce,每人拿到整份总和后只留自己那块。AllReduce 里 AG 那一半拼回来的东西随手就扔了;跨机那段搬的也是整份,不是 1/F。
让编译器自动切分时(比如 JAX 的 GSPMD),跨两根轴求和有可能被编成后一种,我们实测碰到过。查法:在编译后的 HLO 里找 all-reduce,看它的 replica group 是不是把两根轴都包进去了。
纯 FSDP 只有一根轴,没有这个问题。跟跨不跨机房无关,要看的是有没有多出一根数据轴。

2.5 这一刀留下的问题

FSDP 每一步搬的是权重,搬多少只跟参数量有关,跟 batch 无关; 而每一步要算多少,跟每张卡分到的 token 数成正比。

一次喂进去的总 batch 又不能跟着卡数无限加,加太大模型反而学不好;所以卡越多,每卡分到的越少。 每张卡的 batch 一小,算得少、搬得一样多,时间就被搬权重吃掉了。 要继续加卡,又不想让每张卡越算越少,还能怎么切?

还有一句话能帮你分清下一刀:FSDP 形式上把模型切开了,实质还是数据并行 —— 算的那一刻,权重已经拼回一整份,每张卡算的是自己那批数据。 下一刀要的是:算的时候,权重也不拼回来。

考考自己:ZeRO 三级里,哪两级不多花一个字节的通信?为什么先削优化器状态?

ZeRO-1、ZeRO-2 不多花(AllReduce 本来就能拆成 RS+AG,中间那步本地更新不用传)。优化器状态最大,又最闲,只在更新那一下用。

第 三 节

第二刀:切权重

🎧 本节讲课录音约 11 分 37 秒

FSDP 每一层都要把整层权重拼回来。只要每张卡的 batch 够大,这笔搬运能藏在计算后面; batch 一小,就藏不住了。第二刀不再拼权重,直接把权重切开:几张卡合起来算同一批 token,每张卡要处理的 token 数不会随加卡被摊薄。 这一节会连撞三堵墙:batch 一小,FSDP 被拖住,换 TP;TP 出不了一台机器,换 PP;PP 又有人闲着等。

3.1 FSDP 的尽头:搬一个字节,换来多少计算

先问一个朴素的问题:一份数据搬过来一次,能被用几回?用的回数多,搬的那点时间就藏得住;只用一回,卡就在等搬运。 换成数字,就是一个比值:每在网络上搬一个字节,能换来多少次计算。它要高过硬件自己的比值(每秒算多少次 ÷ 每秒搬多少字节),否则卡就在干等。

FSDP 这笔账很干净(⚠️ 推导,按稠密模型算):一步搬约 6Ψ 字节(前向、反向各拼一次 bf16 权重,再分一次梯度,各约 2Ψ), 算 6ΨT 次(专题四「每个 token 约 6 倍参数量次运算」,T 是每张卡分到的 token 数)。两者一除,正好等于 T,跟模型多大没关系。 更直观的看法:一个参数占 2 字节,每个 token 拿它做一次乘加,正好 2 次运算。所以送来一个参数,这张卡上有几个 token,它就被用几回。

打个比方:一间做门的工坊,卡是师傅,网络是跑腿的小工。小工搬两样东西:一样是工具(电刨、模具),就是权重;一样是门板,一块块正在加工、一道工序做完递给下一道,就是激活,每个 token 一块。 FSDP 让小工搬工具:一件工具送到,这个师傅手上的每块门板都拿它过一遍,门板越多,这趟越值。

两把刀,两种账 —— FSDP 看 batch,TP 看隐藏维 纵轴:每在网络上搬 1 字节,换来多少 FLOPs(本课推导,稠密层近似)。低于硬件线 = 算得没有搬得快,被通信拖住 FSDP 搬工具:= 每卡 token 数 T TP 递门板:= 4.5 × 隐藏维 ÷ TP 度数 v7 网络线(ICI)≈ 3,845 线下:师傅(卡)在等小工(网络) 线上:师傅忙得过来 0 2,048 4,096 6,144 8,192 每张卡这一步的 token 数 T 0 2,048 4,096 6,144 8,192 ← T < 3,845:FSDP 被拖住 FSDP TP 8 路 ≈ 4,032 TP 32 路 ≈ 1,008 v7 网络线 ≈ 3,845 显存线 ≈ 313(不是瓶颈) 实测只跑到 7 成 ≈ 5,493 (假设的示意) batch 小就换 TP,batch 大就用 FSDP FSDP 每字节换来的计算 = 每卡 token 数:在 v7 上每卡少于约 3,845 个 token,就搬得比算得慢。 加卡又不想加 batch,FSDP 迟早掉到线下。 TP 的账跟 batch 无关,只看隐藏维 ÷ TP 度数:V3 的隐藏维 7,168,TP 8 路 ≈ 4,032 按最乐观的线才勉强在线上,32 路 ≈ 1,008 就掉下去了 —— TP 有一个跟 batch 无 关的上限。
FSDP 那条斜线看 batch,TP 那几条平线看隐藏维。
低于红色虚线,就是算得没有搬得快。
出处与口径

⚠️ 推导,非论文原话: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 怎么来的,什么情况下门槛更高

红虚线 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 亿)。

细一点:「藏在计算后面」具体是怎么藏的
  • 一次通信拆成两条指令:start 把活交出去,计算接着往下走;done 表示「我要用结果了,没到就等」。XLA 的 HLO 里就叫 all-gather-start/all-gather-done;PyTorch 里是 async_op=True 拿回一个 work,再 work.wait()。
  • done 只等自己:它不是全员屏障,只等自己那份数据到齐。可环上谁慢,谁的数据就晚到,所以慢卡还是会间接拖住你。
  • 藏,就是把 start 提前、done 推后,中间塞进计算。FSDP 算第 i 层时就 start 第 i+1 层的 AG,这叫预取;反向梯度的 RS 晚几层再 done。
  • 代价是显存:start 那一刻接收 buffer 就得占上,一直占到 done 之后用完。提前得越多,同时在路上的层越多。所以预取要限流,PyTorch FSDP 有 limit_all_gathers,限制同时在路上的 AG。
  • 发得早不等于传得早:通信走的通道有限,同一条通道上的集合通信一个接一个排队。前面一个大的没传完,后面提前发的也只能干等。排程要看通道上的队,不能只看指令发出的时刻。
  • 循环会卡住它:JAX 常把每层(或每几层)写成一个循环体(scan)。start 和 done 必须在同一轮里配对,最多只能在一层里面挪。想在这一层算的时候拉下一层的权重,得让编译器把通信挪到上一轮去,XLA 里管这件事的 pass 叫 collective pipeliner。⚠️ 实测:它挪的时候不把显存算进去,挪多了可能爆显存。
  • PyTorch FSDP 不写成循环,由运行时按层的顺序预取(forward_prefetch/backward_prefetch)。
  • TP 难藏也是这个道理(§3.4):要传的激活是这一层刚算出来的,没法提前 start。

3.2 TP:切进矩阵内部

张量并行把一层的权重矩阵本身切开,每张卡只存、只算其中一块。英伟达 Megatron-LM 的切法:

TP 切 MLP —— 先按列切,再按行切,中间一次通信都不用 两张卡的例子。灰 = 两张卡都有的完整副本,蓝 / 橙 = 各自那一半;虚线是切口。蓝的只跟蓝的相乘,所以中间不用找对方要东西 卡 0 的那一半 卡 1 的那一半 完整副本 Y = GeLU(X · W1) · W2 Megatron-LM 的切法 X 输入 X 每张卡都有整份 × W1:竖着切一刀 左半在卡 0,右半在卡 1 = 中间结果也是左右两半 GeLU 逐个元素算,各算各的 × W2:横着切一刀 上半在卡 0,下半在卡 1 = 部分和 + 部分和 AllReduce 唯一一次通信 Y 每张卡拿到整份 切法的全部巧思,就是把通信挤到最后一次 第一块按列切、第二块按行切:中间结果各留一半、各自过激活函数,两次矩阵乘之间零通信。 attention 同理:按头切,每张卡算自己那几个头,出口处一次 AllReduce。 于是一层前向 2 次、反向 2 次 AllReduce,每层都有,频率极高。
列切接行切,中间结果不出卡。
这是 Megatron-LM 的切法,attention 按头切也是同一个思路。
出处与口径

📌 出处:Shoeybi 等,Megatron-LM,arXiv 1909.08053 sec. 3(MLP 与 self-attention 的切法、f/g 两个通信算子)。

通信只在最后那一下;可每一层都有这一下。 (9 秒无声循环,Manim 渲染。)

两个容易绕晕的地方。一、每张卡两块都有份:卡 0 拿上投影(UP)的一半,也拿下投影(DOWN)的一半,不是一张卡管 UP、另一张管 DOWN(那是按层切,后面讲的 PP)。 两块之间不通信,DOWN 算完才把部分和加一次,传的是激活。attention 那块同理:按头切,出口加一次。所以一层前向两次 AllReduce,反向再两次。

二、「横」「竖」只是画法:本课把 W1 画成「输入维 × 输出维」(X·W1),第一刀切的是输出维,看着是竖切;PyTorch 的 nn.Linear 把权重存成「输出维 × 输入维」,同一刀在它那里就是横切。 所以别记横竖,记第一块切输出维,第二块切输入维。Megatron 按 X·A 的画法起名,叫列并行(ColumnParallelLinear)和行并行(RowParallelLinear)。

顺序不能反过来,因为两次矩阵乘中间夹着一个不是线性的 GeLU:

为什么非得先竖着切 —— GeLU 是弯的,部分和不能各过各的 同一个 MLP:Y = GeLU(X · W1) · W2。只看中间结果里的某一个元素 卡 0 手里的 卡 1 手里的 错 对 先横着切,每张卡只有一份部分和(随手取 2 和 −3,真值 −1) 输入 GeLU 之后 卡 0:GeLU(2) = 1.954 卡 1:GeLU(−3) = -0.004 真值:GeLU(−1) = -0.159 各过各的再加:1.954 + (-0.004) = 1.950 ✗ 差了十几倍,符号都反了:这个元素必须先加齐,才能过 GeLU 两种切法,这个元素走的路 横切在先 2 −3 AllReduce −1 GeLU -0.159 多一次通信,每个 MLP 都要付 竖切在先(Megatron) −1 没有 不用问别人 GeLU -0.159 整个元素只在卡 0 上,零通信 所以一层 4 次 AllReduce:前向 2 次、反向 2 次 前向:MLP 出口一次、attention 出口一次。 反向倒过来:入口处 X 的梯度是两张卡各算一半、要加起来,又各一次。
一个元素、两张卡、两种顺序。
反过来切,GeLU 之前就得先通信一次。
出处与口径

📌 Shoeybi 等,Megatron-LM,arXiv 1909.08053 sec. 3:GeLU 非线性,按行切第一块需要在 GeLU 前同步;f 前向恒等、反向 AllReduce,g 反之。

⚠️ 本课反例:2 与 −3 是随手取的数,GeLU 按精确式现算。

3.3 SP:TP 的搭档

TP 切不到的那几段小运算,由它的搭档 SP 沿序列切开:通信量不变,省激活显存。别被名字骗了,它不是第四刀(§8.8)。

细一点:SP 切的是哪几段、怎么做到通信量不变

TP 切不到的是逐个 token 的小运算(归一化、dropout、残差相加),那几段每张卡都存着一整份激活。 Megatron 的序列并行(SP)把它们沿序列切开,顺手把每次 AllReduce 拆成两半:进 TP 那块之前 AllGather 拼齐序列,出来时 ReduceScatter 切回。 就是第一节那个等式,所以通信量跟原来一样。

3.4 TP 的上限:跟 batch 无关

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 度数还受哪两条约束
  • ① 3,845 假设三根轴都用满、而且每根轴首尾连成环;TP 8 路只有 4 颗芯片(v7 一颗芯片算 2 个 device),两个折扣叠在一起:切片太小成不了环(§1.5),又只用得上一两根轴(§3.1),实际门槛高好几倍。
  • ② Megatron 的 TP 通信默认要等它做完才能往下算,藏不进计算里。
  • 注意力头要按整个分:Megatron 要求查询头数能被 TP 度数整除(KV 头更少的模型,KV 头数和 TP 只要一个能整除另一个,TP 更大时 KV 就复制)。
  • TP 每层都要通信,只能待在最快的那一圈互联里(GPU 上一般不出一个 NVLink 域)。

3.5 FSDP 和 TP 一起用:二维切

两把刀能并存,大模型训练里也常常一起用。关键是切在不同的维上:把卡排成一张表,一行是一组 TP,一列是一组 FSDP。TP 按输出维把权重切成几条,FSDP 再把每一条按输入维劈开。

FSDP 和 TP 一起用:两刀切在不同的维上 —— 每卡常驻 1/8,拼回来也只是自己那一条 8 张卡排成 2 行 × 4 列:一行是一组 TP(看同一份数据),一列是一组 FSDP(同一条权重的上下两半)。以 MLP 第一块权重 W1 为例 TP 0 那一条 TP 1 TP 2 TP 3 ① 怎么切:TP 竖着分 4 条,FSDP 再把每条上下劈开 整块 W1(输入维 × 输出维) 输出维:TP 切成 4 条 输入维:FSDP 劈成上下两半 TP 0 TP 1 TP 2 TP 3 数据第 1 份 只存这 1/8 行 1 · 列 1 只存这 1/8 行 1 · 列 2 只存这 1/8 行 1 · 列 3 只存这 1/8 行 1 · 列 4 数据第 2 份 只存这 1/8 行 2 · 列 1 只存这 1/8 行 2 · 列 2 只存这 1/8 行 2 · 列 3 只存这 1/8 行 2 · 列 4 同一行:数据相同、权重条不同(TP) 同一列:权重条相同、数据不同(FSDP) ② 算一层:先列内拼,再各算各的,出口行内加 ① 列内 AllGather(FSDP) ② 各算各的 ③ 行内 AllReduce(TP) 拼齐 拼回的是第 2 条:整矩阵的 1/4,不是整个矩阵 同一份数据 X(这一行共用) 每张卡算中间结果的 1/4;GeLU 也各算各的 这一段不通信 部分和 部分和 部分和 部分和 加起来 = Y W2 算完只是部分和,出口加一次 传的是激活,不是权重 ③ 账怎么算:TP 把一行的 token 借给了 FSDP 只用 FSDP 每张卡拼一整层,只给自己那 T 个 token 用 门槛:每卡 T ≥ 3,845 FSDP × TP 4 每张卡只拼 1/4 条,却给这一行的全部 token 用 门槛:一行 ≥ 3,845 个 token,摊到每卡约 961 能并存,而且互补:batch 小时 TP 替 FSDP 撑住 FSDP 切输入维、在列内拼;TP 切输出维、在行内加。两刀切在不同的维上,互不打架:每卡常驻 1/8,拼回来也只是自己那 1/4 条。 代价在 TP 那根轴:每层前向两次、反向两次对账,还藏不进计算,所以 TP 占最快的那一圈线,FSDP 用剩下的。
FSDP 在列里拼,TP 在行里加;拼回来的只是自己那一条。
切法对照 Scaling Book 训练篇;961 是本课推导。
出处与口径

📌 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 那根轴每层都要对账,得占最快的线。

3.6 PP:按层切

要横跨很多台机器、走慢线,又不想像 FSDP 那样每层搬权重,就按层切。TP 是切宽,PP 是切深:

TP 切宽,PP 切深 —— 一个每层都要对账,一个只在交界递一次 同一个 8 层的模型、4 张卡。颜色 = 这一块归哪张卡 卡 0 卡 1 卡 2 卡 3 要通信的地方 切宽(TP):每一层都切成四条 层 1 层 2 层 3 层 4 层 5 层 6 层 7 层 8 每一层都要 四张卡对账 (attention、MLP 各一次 AllReduce) 每层都要通信 → 只能坐最快的那圈线 切深(PP):两层一段,一张卡一段 层 1 层 2 层 3 层 4 层 5 层 6 层 7 层 8 只在段的交界 递一次门板 (一对一收发) 只 3 处通信 → 能跨慢线;代价是有人闲着等 一个切宽、一个切深,各付各的代价 切宽:每张卡每层只算四分之一,可每一层都得跟另外三张卡对账,所以 TP 出不了一台机器。 切深:卡和卡之间几乎不说话,所以 PP 敢横跨很多台机器;代价是流水线灌满、排空时有人在等。
红点就是通信:左边每层一个,右边只有三个。
各家对「横切、纵切」的叫法正好相反,本课只说切宽、切深。

段与段之间只在边界上用一对一收发传激活,是所有刀里通信最少的,所以它能跨到慢线上。 可朴素地切,就是「4 张卡的显存、1 张卡的速度」:同一时刻只有一段在干活。于是把一批数据切成几份 micro-batch 轮着灌进去,像门厂的流水线: 刨光、开孔、上漆三道工序各守一个工位,门板一摞一摞往下传。第一摞刚进刨光时,后两个工位只能干等;最后一摞到了上漆,前两个工位又闲着。干等的那段,叫气泡:

PP 的代价:气泡 —— 开头等人灌满,结尾等人排空 4 个 stage、8 个 micro-batch,GPipe 式时间表(先全部前向、再全部反向)。反向按前向的 2 倍长画 前向 反向 气泡:这一段在空等 一步里每个 stage 在干什么 stage 0 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 stage 1 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 stage 2 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 stage 3 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 时间 → 气泡 ÷ 理想计算时间 = (p−1) ÷ m = 3 ÷ 8 ≈ 38% 气泡是纯损失,只能摊薄,不能消灭 stage 越多、micro-batch 越少,气泡越大:(p−1) ÷ m。 所以 PP 要配足够多的 micro-batch;总批次不变时,份数越多每份越小,切过了头,卡就吃不饱。 后来的调度都在跟这块空白较劲:交错式(VPP)把每段再切细,Zero Bubble 拿权重梯度去填缝,DualPipe 两头同时灌。代价都是更复杂的调度和更多的点对点通信。
浅灰色就是气泡:这一段在干等。
4 段 8 个 micro-batch,气泡是理想计算时间的 3/8。
出处与口径

📌 气泡占比:Narayanan 等,arXiv 2104.04473 sec. 2.2(GPipe/1F1B 的 bubble time fraction);交错式把气泡再除以每卡的虚拟段数 v。Zero Bubble:arXiv 2401.10241。DualPipe:github.com/deepseek-ai/DualPipe。

micro-batch 从 4 个加到 8 个,灰色的气泡跟着缩一半。 (14 秒无声循环,Manim 渲染。)

气泡跟理想计算时间之比是 (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 从哪来、切多大;1F1B 具体怎么排;前后显存不均;DualPipe 的代价

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 那一圈,跨机那条慢线只能交给它。

3.7 这一刀留下的问题

拿贯穿全课的例子 DeepSeek-V3 来说,它里面没有 TP。报告自己的解释是显存优化做得够细,用不着代价高的 TP。 再看它的参数都在哪:几乎全在一种叫「专家」的窄矩阵里。专家本来就窄,再往里切,每份更小,要搬的激活却一点不少。真正该切的,是「专家」这一维。这是第三刀。

考考自己:每张卡分到的 token 很少时,FSDP 和 TP 哪个先被通信拖住?TP 为什么出不了一台机器?

FSDP:它每搬一个字节换来的计算就等于每卡 token 数,token 少就藏不住。TP 每一层都要对账,而且门板要等这道工序做完才能递,藏不进计算,只能待在最快的那圈线里。

第 四 节

第三刀:切专家

🎧 本节讲课录音约 9 分 06 秒

MoE 模型的参数几乎全在专家里。第三刀就切这一维:把不同的专家放到不同的卡上。 它多出来的通信只有一种,AllToAll;可它也带来了一个别的刀里最严重的病。

4.1 为什么该切专家

V3 除了最前面 3 层,其余 58 层都是 MoE 层:每层 256 个路由专家,每个 token 由路由器挑其中 8 个去算;另有 1 个人人都要过的共享专家。

V3 的参数几乎全在专家里 —— 该切的是「专家」这一维 按参数量画成一根横条。每个专家 = 3 块 7,168 × 2,048 的矩阵(gate / up / down) 路由专家 其余:注意力、共享专家、稠密 MLP、词表 671B 按参数量摊开 路由专家 ≈ 6539 亿 (约 97%) 其余 ≈ 171 亿(约 3%)↑ 一个专家 ≈ 4404 万参数 × 256 个 × 58 层 V3 训练时一点 TP 都没用 技术报告的理由是显存抠得够细,用不着代价高的 TP。本课补一句:专家只有 2,048 宽,切 TP 更不划算;而专家有 256 个,天然就是一维可以切的。 V3 的训练配置:16 路 PP + 64 路专家并行 + ZeRO-1 数据并行,不用 TP(技术报告 sec. 3.2)。
那一小截灰色,是注意力、共享专家、稠密 MLP 和词表加起来的全部。
路由专家的份额由 config.json 的尺寸现算。
出处与口径

📌 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 切碎了再拼正好相反。

4.2 EP:token 飞去专家那里

专家并行(EP)的通信只在 MoE 层里发生,就是 1.6 讲的 AllToAll,网络最怕的那种,每层两次: 派发,把每个 token 送到它选中的专家所在的卡;合并,算完再送回原来的卡。

派发、排队、合并。那一根排得最高的队,决定了所有卡什么时候能往下走。token 的颜色表示它从哪张卡出发,每张卡下方两个框是它的专家。 (10 秒无声循环,Manim 渲染。)

V3 为了压住这两次 AllToAll,做了两件事:每个 token 最多去 4 台机器,跨机每台只发一份、到了再在机器里分;派发压成 FP8,合并还用 BF16。

派发一个 token:跨机只发一份,到了机器里再分 每个 token 选 8 个路由专家;一台机器 8 张卡。左边按专家摊得很开的一般情形画,右边是 V3 的做法 token 出发的卡 持有被选中专家的卡 跨机:慢线(IB) 机器内:快线(NVLink) 红框 = 跨机先落地的同编号卡 不限节点、BF16:8 个专家各在一台机器上,跨机 8 份 出发的机器 8 份 × 14,336 字节 ≈ 115 KB V3:最多 4 台机器、FP8:跨机 4 份 出发的机器(卡 3) 4 份 × 7,168 字节 ≈ 28.7 KB (左边的 1/4) 为什么是「跨机少发、机器里多分」 NVLink 160 GB/s,约是跨机 IB 50 GB/s 的 3.2 倍:跨机送到的一份,在机器里平均转给 3.2 个专家也不添开销。 所以报告说同样的通信量最多能选 13 个专家(4 台 × 3.2);只跟去了几台机器有关,跟选了几个专家无关。
同一个 token,左边跨机 8 份,右边 4 份、每份还小一半。
机器里那几根绿色短弧几乎是白送的。
出处与口径

📌 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 追求低延迟时改成按专家逐个直发(跳过机器里的转发,每个专家各收一份),份数就跟着选的专家数涨了。

4.3 EP 最重的病:负载由数据决定

别的刀负载均不均,大多事先就知道。EP 的不均最严重: 哪个专家忙、哪个专家闲,要等路由算完才知道,而且每一批数据都不一样。 最忙的那个专家算完之前,所有人都得等它。它还会越滚越大:越受欢迎的专家分到的 token 越多、学得越好、就越受欢迎,其余的专家荒掉 —— 花一个大模型的显存,训出一个小模型。所以这既是速度病,也是质量病。治法分两头:

门口挂个号牌:偏置怎么把队伍拉平 —— 只管排号,不管诊断 示意模拟:8 个专家挑 2 个、每步 1,024 个 token,天生的偏好一个比一个低。每步结束,超载的偏置减一点、欠载的加一点 这个专家这一步接了多少 token 平均线 第 0 步:最忙的是平均的 2.26 倍 专家 0 1 2 3 4 5 6 7 第 30 步:最忙的是平均的 1.30 倍 专家 0 1 2 3 4 5 6 7 第 150 步:最忙的是平均的 1.08 倍 专家 0 1 2 3 4 5 6 7 最忙的那个专家,决定所有人等多久 老办法是在训练目标里罚「分得不匀」,等于逼分诊员改诊断,会拖累模型本身学什么。 V3 的偏置只加在「挑谁」的分数上,算出来的权重不动:只管排号,不管诊断。训练最后 500B token 连偏置也停了。
红虚线是平均:柱子越齐,所有人等得越少。
示意模拟,8 选 2、调得比 V3 快,为了几十步就看得出来。
出处与口径

📌 无辅助损失均衡: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 的实测负载。

4.4 attention 和专家,各配各的

一层 Transformer 里,attention 和专家是两种完全不同的形状(对不是 MoE 的那部分来说,EP 那一维其实就是数据并行):attention 的负担跟序列和 KV 有关, 专家的负担是那一大堆参数。所以同一批卡,在这两部分可以用两套切法。

attention 和专家,各配各的切法 —— 同一批卡,两套映射 8 张卡的示意。同一张卡在注意力层里是某个 TP 组的一员,到了专家层就换一个身份 第一组:管请求 A 第二组:管请求 B 一个小方块 = 一个专家 一层 Transformer 里,同一张卡换两次身份 注意力层:4 张卡一组切一份 attention,两组各管一批请求 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 请求 A 请求 B AllToAll 专家层:8 张卡各放 32 个专家,所有请求的 token 都往这儿送 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 attention 是一块大矩阵,专家是一堆小矩阵:各切各的 attention 那块大矩阵切成条,4 张卡一组合起来算;两组各管一批请求。专家本来就是 256 个小块,整个分出去就行。 训练里 Megatron 叫它 Parallel Folding;推理里 attention 用 TP 的叫 TEP,用数据并行的叫 DEP,图里这种一半一半的也有。
左右两边是同样的 8 张卡。
进 attention 时按 TP 组干活,进专家层时每张卡管 32 个专家。
出处与口径

📌 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:一起算同一批请求,还是各算各的一批。

TEP 和 DEP:attention 那一半怎么切 —— 一起算同一批,还是各算各的一批 同样 4 张卡、同样 4 批请求(颜色 = 哪一批);专家那一半两边一样:8 个专家铺在 4 张卡上,每卡 2 个 请求 1 请求 2 请求 3 请求 4 TEP4:attention 用 TP,四张卡一起算同一批 请求 注意力 KV 笔记 专家 卡 0 1/4 的头 全部 KV(整份) 专0 专1 卡 1 1/4 的头 全部 KV(整份) 专2 专3 卡 2 1/4 的头 全部 KV(整份) 专4 专5 卡 3 1/4 的头 全部 KV(整份) 专6 专7 attention 出口 AllReduce:四份部分结果加起来 专家那一步 token 本来人人都有,各算本卡专家,再 AllReduce 好处 每个请求四张卡一起算,单个请求更快 坑 KV 切不开,每张卡存一整份:TEP4 白存 3 份 DEP4:attention 用数据并行,各算各的一批 请求 注意力 KV 笔记 专家 卡 0 全部的头 只存自己的 专0 专1 卡 1 全部的头 只存自己的 专2 专3 卡 2 全部的头 只存自己的 专4 专5 卡 3 全部的头 只存自己的 专6 专7 attention 各算各的,不用通信 专家那一步 AllToAll 派发到专家所在的卡,算完合并回来 好处 KV 不重复,装得下更多请求,吞吐大 坑 各卡请求长短不一、忙闲不均;没请求的卡也得陪跑 差别全在 attention 那一半:一起算同一批,还是各算各的一批 TEP:同一批请求四张卡一起算,单个请求快;可 MLA 这类只有一个 KV 头的模型,KV 在每张卡上都得存一整份。 DEP:每张卡只管自己那批请求,KV 不重复、batch 能开大;代价是专家那一步换成 AllToAll,还要防各卡忙闲不均。
专家那一半一样;attention 那一半,一个一起算、一个各算各的。
示意:4 张卡、4 批请求、8 个专家。
出处与口径

📌 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。

一次实测:换一种切法,每张卡的吞吐翻一倍 GB300 上跑 DeepSeek-V4-Pro(vLLM),decode 从 TP4 换成 DEP8(attention 数据并行 8 路、专家 EP8),同样并发下每张卡的吞吐是调完参的 TP4 的 2.09 倍。 最属于「换切法」的一笔在 attention 那一半:KV 不再在 4 张卡上各存一份(§5.4 讲为什么)。attention 权重虽然每张卡要存一份,但在 MoE 模型里只占几个百分点。注意上面的图画的是 V3(每卡 32 个专家),实测用的是 V4-Pro。
完整的账(卡数、并发、首字延迟)在 §7.3。

4.5 这一刀留下的问题

前三刀切的是 batch、权重、专家,都没碰过「序列」这一维。可上下文一长,训练时的激活、推理时的 KV cache,都跟着序列长度往上涨 —— 涨到一条样本都放不进一张卡时,怎么办?

考考自己:专家并行最重的病是什么?V3 用什么办法治,为什么不拖累模型学东西?

负载不均:最忙的专家决定所有人等多久。V3 给每个专家的分数挂一个偏置,超载减、欠载加;偏置只影响挑谁,不改算出来的权重。

第 五 节

第四刀:切序列

🎧 本节讲课录音约 13 分 52 秒

一条样本自己放不进一张卡,那就把它沿序列切开。这是第四刀。训练和推理切的东西不一样,分开讲。

5.1 一条样本为什么会放不下

5.2 训练:CP 把激活沿序列切开

上下文并行(CP)把一条长序列切成几段,每张卡只存自己那段的激活。 难点只在注意力:每个 token 要看到它前面所有的 token,而那些 token 在别的卡上。两种办法:

Q 留在原地,KV 沿环转一圈,每张卡把自己那一行填满。 (9 秒无声循环,Manim 渲染。画的是不带因果掩码的情形。)

Ulysses 为什么转置一下就不用传笔记?把注意力的活排成一张「段 × 头」表就清楚了:同一列里后面的段要看前面的段,同一行里头与头互不相干。 Ring 按行分,依赖跨了卡,只好让笔记转圈;Ulysses 先转置,让每张卡拿整列。

Ulysses:转置一下,就不用传笔记了 —— Ring 按行分,Ulysses 换成按列分 把注意力的活排成一张表:一行是一段序列(一段 token),一列是一个头。四种颜色是四张卡 卡 0 卡 1 卡 2 卡 3 ① 先认识这张表:列里有依赖,行里没有 注意力的活 头0 头1 头2 头3 段0 段1 段2 段3 同一列:后面的段要看前面的段 跨段 → 得传笔记(K、V) 同一行:头与头各算各的 跨头 → 分开算,不用说话 Ring:按行分 头0 头1 头2 头3 段0 段1 段2 段3 每张卡:一段 × 全部头 要看别的段, 笔记就沿环转一圈 所以关键在于:按列分,列里的依赖就全落在一张卡上。Ulysses 做的就是这件事。 ② Ulysses:前后各一次 AllToAll 进来时:按段分 头0 头1 头2 头3 段0 段1 段2 段3 AllToAll 后:按头分 头0 头1 头2 头3 段0 段1 段2 段3 再 AllToAll:换回按段分 头0 头1 头2 头3 段0 段1 段2 段3 AllToAll AllToAll 每张卡:一个头 × 全部段 这一列要看的全在本卡:注意力本地算完 卡 k 把自己那行的第 j 格发给卡 j: 留 1 格,发 3 格 后面的逐 token 运算 又按段各算各的 Ring 靠传笔记,Ulysses 靠换切法 好处:序列长一倍、卡也多一倍,每张卡的通信量不变;注意力本身一次都不用等别人。 代价:每层前后各一次 AllToAll(网络最怕的那种),而且卡数不能超过头数;KV 头比查询头少的模型,卡在 KV 头数上。
列里有依赖、行里没有:按列分,注意力就不用问别人。
示意:4 段 × 4 头、4 张卡。
出处与口径

📌 DeepSpeed-Ulysses:Jacobs 等,arXiv 2309.14509(注意力前后各一次 AllToAll,序列长度与卡数同比放大时每卡通信量不变)。Ring Attention:Liu 等,arXiv 2310.01889。

⚠️ 示意:4 段 × 4 头、4 张卡;实际每一格是一整段 token 在一个头上的 Q、K、V。

AllToAll 一步一步看:先看卡 0 怎么发,再看大家同时照做;换完每张卡拿一个头的全部段。 (26 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看;手动模式每一步停住。)

一句话记住两者:Ring 是人不动、笔记转圈;Ulysses 是换个切法,每人拿全部笔记的几个头。

两者可以叠起来用,叫 USP:把表分成块,卡排成二维,一维在机器里做 Ulysses 的 AllToAll,另一维在机器之间走环,总卡数 = 两维相乘。 Megatron 的 CP 也支持这种分层组合。

USP:Ulysses 和 Ring 叠起来 —— 表分成块:机器里转置,机器之间走环 还是那张「段 × 头」表。4 张卡、2 台机器:总卡数 = Ulysses 那一维(2)× 环那一维(2) 卡 0(机器一) 卡 1(机器一) 卡 2(机器二) 卡 3(机器二) ① 两步:先机器内 AllToAll,再机器间走环 进来时:按段分 头0 头1 头2 头3 段0 段1 段2 段3 机器内 AllToAll 后:按块分 头0 头1 头2 头3 段0 段1 段2 段3 机器内 AllToAll (Ulysses 2) 卡 0↔卡 1 换列,卡 2↔卡 3 换列 机器间走环(Ring 2) 拿同一批头的上下两块互传笔记: 卡 0 ↔ 卡 2(头 0、1),卡 1 ↔ 卡 3(头 2、3) 每张卡:两段 × 两个头 头已经分开了,跨段的部分交给环 算完注意力,再在机器内 AllToAll 一次,换回按段分。 ② 三种放在一起比 表怎么分 通信 上限 适合放在 Ring 按行(段) 笔记沿环一对一传 没有 可以跨机器 Ulysses 按列(头) 前后各一次 AllToAll 卡数 ≤ 头数 机器里(快线) USP 按块 机器内 AllToAll + 机器间环 只有 Ulysses 那一维 ≤ 头数 两种各放各的 USP = 两刀叠起来:总卡数 = Ulysses 那一维 × 环那一维 头数上限只管 Ulysses 那一维,环那一维可以随便加,所以头少的模型也能切到很多张卡上。 AllToAll 最怕慢线,留在机器里;环一步只跟邻居说话、还能边算边传,放到机器之间。
机器里转置、机器之间走环:头数上限只剩一维。
「AllToAll 放机器里、环放机器之间」是本课归纳的常见摆法。
出处与口径

📌 USP:Fang 与 Zhao,arXiv 2405.07719;xDiT 文档:ulysses-degree × ring-degree = sp-degree,去掉「sp-degree 必须小于头数」的限制,对异构网络更友好。

⚠️ 「AllToAll 放机器里、环放机器之间」是本课按两种通信的脾气归纳的常见摆法,不是论文的硬规定。

先在机器里换头,再在机器之间传笔记:机器里走 AllToAll,跨机器只走环。 (27 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看;手动模式每一步停住。)

5.3 causal 带来的不均

生成式模型的注意力有因果掩码:每个 token 只看前面的。于是越靠后的段算得越多,顺序切会让最后一张卡累死。 解法很简单:轻的配重的,一张卡拿一轻一重两块,叫之字形切,见下图。

因果注意力切序列:顺序切会不均匀 —— 之字形切正好摆平 序列切成 2 × 4 = 8 块。行 = 查询块,列 = KV 块,每一格是一对要算的注意力;因果掩码只留下三角形 卡 0 卡 1 卡 2 卡 3 8 × 8 的因果注意力块,谁算哪几行 顺序切:卡 r 拿第 2r、2r+1 块 块 0 → 卡 0 块 1 → 卡 0 块 2 → 卡 1 块 3 → 卡 1 块 4 → 卡 2 块 5 → 卡 2 块 6 → 卡 3 块 7 → 卡 3 卡 0:3 格 卡 1:7 格 卡 2:11 格 卡 3:15 格 之字形切:卡 r 拿第 r 块和第 7−r 块 块 0 → 卡 0 块 1 → 卡 1 块 2 → 卡 2 块 3 → 卡 3 块 4 → 卡 3 块 5 → 卡 2 块 6 → 卡 1 块 7 → 卡 0 卡 0:9 格 卡 1:9 格 卡 2:9 格 卡 3:9 格 顺序切差好几倍,之字形切完全均匀 因果掩码让越靠后的块算得越多。顺序切时卡 3 要算 15 格、卡 0 只算 3 格,大家都得等卡 3。 之字形把「最轻的一块」和「最重的一块」配成一对交给同一张卡,每张卡都是 9 格 —— Megatron 的 CP 就是这么切的。
同样 8 块,换一种分法,最忙和最闲从差好几倍变成一样忙。
每格数由脚本按因果掩码现算。
出处与口径

📌 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 倍。

5.4 推理:KV cache 被 TP 复制了

长上下文、高并发的推理(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 份,毛病就在这儿。

推理时切序列:KV cache 被 TP 复制了几份 —— DCP 把复制变回容量 DeepSeek-V3,一个 128K 上下文的请求。每 token 的 KV = (512 + 64) × 61 层 × 2 字节 = 70,272 字节 重复存的那几份 真正需要的那一份 8 张卡上,这一个请求的 KV 各占多少 TP 8 路 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡 8.58 GiB 合计 68.6 GiB(8 份一样的) TP 8 + DCP 8 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡 1.07 GiB 合计 8.58 GiB(刚好一份) TP 超过 KV 头数,多出来的全是复制 MLA 的 KV 只有一个头。TP 8 路时每张卡都存完整的一份,7 份是白存的。 DCP 让 KV 按 token 轮流落到 8 张卡上,每卡只剩 1/8;它不增加卡,直接复用 TP 那几张。
红色那 7 份,存的是一模一样的东西。
KV 尺寸取自 V3 的 config.json。
出处与口径

📌 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 轮流而不是一段一段地存,是因为笔记一直在长:新来的字也会均摊到每张卡上。

KV 轮流落到四张卡上;每一层多几次通信,把 Q 收齐、把结果合起来。 (11 秒无声循环,Manim 渲染。先放只开 TP 时的样子做对照。)

算注意力时,新 token 的 Q 发给所有卡,各自在自己那份 KV 上算,再把几份部分结果合并。注意力本身就是按分数加权平均,所以合并不能各除各的,要「先别除」:

分块算注意力,合并时先别除 —— 分子加分子,分母加分母,最后只除一次 注意力 = 按分数加权平均。三个 token:分数取指数后是 2、1、1,值是 10、4、20。卡 0 拿前两个,卡 1 拿第三个 卡 0 卡 1 错 对 两张卡各自算自己那份笔记 卡 0:2×10 + 1×4 分子 24 分母 3 卡 1:1×20 分子 20 分母 1 分子 = Σ 权重×值,分母 = Σ 权重 (分母取个对数,就是常说的 LSE) 各除各的,再平均 卡 0:24 ÷ 3 = 8 卡 1:20 ÷ 1 = 20 平均:(8 + 20) ÷ 2 = 14 ✗ 卡 1 只有一个 token,却占了一半的票 先别除:最后只除一次 分子:24 + 20 = 44 分母:3 + 1 = 4 44 ÷ 4 = 11 ✓ 跟三个 token 放在一张卡上算的一样 所以每张卡除了结果,还得交出自己的分母 跟合并两个班的平均分一样:得带上各班人数,不能把两个平均数再平均。 Ring 在路上一段一段这样合并,DCP 在终点这样合并,是同一招。
两个平均数不能再平均,得带上各自的「人数」。
分子分母各自交上来,最后只除一次。
出处与口径

📌 讲法: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,长上下文时每一步的注意力也快了。

5.5 prefill 那边也有一种

DCP 管的是 decode。prefill 那边要把一个长 prompt 切开、让第一个字早点出来,叫 PCP(prefill 上下文并行)。 两个名字只差一个字母,其实是一前一后的两步。把注意力看成一张「提问 × 笔记」表:prefill 一次有几千个提问,先按行切;decode 每步只剩一个提问,没行可切了,DCP 才进一步把这一行按笔记切开。

PCP 和 DCP:先按行切,行切到只剩一行,再把这一行切开 —— DCP 不是跟 PCP 对等的另一刀,是行切到头以后的下一步 注意力是一张「提问 × 笔记」表:一行 = 一个新 token 的提问(Q),一列 = 前面一个 token 的笔记(K、V);只看前面,所以是三角 卡 0 卡 1 卡 2 卡 3 PCP(prefill):Q 有几千个,按行切(例:4,000 行 → 每卡 1,000 行) 笔记(K、V)→ 提问 卡 0 卡 1 卡 2 卡 3 prefill:几千个提问一起来 表又高又宽,活很多 按行切给 4 张卡: 每一行在一张卡上算完, 结果不用合 可卡 3 那两行(红框) 要看左边全部笔记: 得先把前面的 KV 收齐 为了 算得快:第一个字早出来 卡 在 TP 之外再加一维,要加卡 多出的通信 收齐前面几段的 KV DCP(decode):只剩 1 个 Q,没行可切了,再把这一行按列切开 这一步:每个请求只有 1 个新提问(表只有一行),前面存了一长串笔记 笔记按 token 轮流存:第 0 条卡 0、第 1 条卡 1……(原来那 4 张 TP 卡,不加卡) 卡 0 → 这一行的一部分:分子 + 分母 卡 1 → 这一行的一部分:分子 + 分母 卡 2 → 这一行的一部分:分子 + 分母 卡 3 → 这一行的一部分:分子 + 分母 四份部分结果 → 先别除:分子加分子、分母加分母,最后除一次 实际是一批:1,000 个请求 = 1,000 行,每行都这样拆,每张卡存每个请求四分之一的笔记 为了 装得下、读得少:每卡 KV 只剩 1/4,每步只读 1/4 卡 用原来那几张 TP 卡,不加卡 多出的通信 收齐提问、交换分母、合并结果 先切行;行切到只剩一行,再切这一行 PCP:prefill 一次有几千个 Q,按行切开,每行在一张卡上算完、结果不用合,但要收齐前面的笔记;为了第一个字早出来,另外加卡。 DCP:decode 每步只剩 1 个 Q,没行可切,只能进一步把这一行按列(笔记)切开,各算一段再按先别除合起来;为了装得下,用原来的卡。
Q 多就按行切;decode 只剩一个 Q,才进一步把这一行切开。
示意:8 个提问、16 条笔记、4 张卡;PCP 实际也按之字形分行摆平负载。

下一节把 prefill 和 decode 拆到两批机器上以后,它们正好可以一边一个(本课的归纳)。

5.6 这一刀留下的问题

说到这儿,prefill 和 decode 已经各要各的切法了:一个吃算力、要把 prompt 切开;一个吃带宽、要把 KV 摊开。 硬塞在同一批卡上,谁都配不好。那就干脆别切张量了,把这两种活拆到不同的机器上。这是第五刀。

考考自己:两张卡各自算出注意力的一部分结果,能不能直接取平均?

不能。要「先别除」:每张卡交出分子和分母,分子加分子、分母加分母,最后只除一次。

第 六 节

第五刀:不切张量,切工作

🎧 本节讲课录音约 10 分 42 秒

前四刀切的都是张量:batch、权重、专家、序列。第五刀换个思路 ——  一个请求里本来就有性质完全不同的几段活,把它们拆到不同的机器上,每一边再挑自己的切法。

6.1 prefill 和 decode 为什么会打架

一个请求分两段。prefill 一口气吞下整个 prompt,几千个 token 一起过矩阵乘,吃的是算力; decode 每一步只出一个 token,却要把全部权重和 KV 从显存里读一遍,吃的是带宽。

你正看着回答一个字一个字往外吐,别人丢进来一本一百页的说明书,你的字就停了。语音助手更明显:说一句停一段,平均速度再快也觉得卡。 这就是两种活挤在同一批卡上:引擎每一步都要决定先干哪个。长 prompt 一来,它的 prefill 要占好几步, 这几步里所有正在出字的请求都得等:新请求的首字延迟(TTFT)和老请求的出字间隔(TPOT)一起变差。

decode 还有个脾气:每一步都要把权重从显存读一遍,读一次只够这一批用一次。一批要多大才不白读?

decode 为什么非要把一批做大 —— 读一遍权重,只够这一批用一次 横轴:一步里一起出字的请求数 b(对数刻度)。纵轴:从显存读 1 字节权重,换来多少次计算(本课推导,只算读权重) 稠密层:= b MoE 的一个专家:= b ÷ 32(V3 挑 8/256) v7 显存线 ≈ 313 1 4 16 64 256 1,024 4,096 16,384 一步里一起出字的请求数 b 1/16 1 16 256 显存线 ≈ 313 稠密:b ≈ 313 才吃饱 MoE:b ≈ 10,000 才吃饱 线上:卡算得过来 线下:卡在等显存把权重读出来 所以 decode 的各种做法,都在凑一个大 batch PD 分离让 decode 机器只管出字,一批能攒得更大;DEP 让 attention 各管各的请求,专家那边收齐所有卡的 token。 Wide-EP 把专家铺到更多卡上、每张卡只放几个,AFD 干脆让一组专家机器同时接好几组 attention 机器的 token。
蓝线看一批有多少请求,橙线还要再除以 32。
跟第三节那张「搬一个字节换多少计算」是同一把尺子,只是这回搬的是显存。
出处与口径

⚠️ 推导:稠密层一步读 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 个。

第五刀:把两种活拆到两批机器上 —— decode 不再被 prefill 卡住 示意时间线(不是实测时序)。每格是一步;绿色的 decode 一格一格往外出字,橙色是一次长 prompt 的 prefill decode:每步出一个字 prefill:一口吞下 prompt KV cache 传输 同一批卡 vs 分开两批 放在一起 长 prompt 的 prefill 这 5 步所有人的 decode 都停住 prefill 机器 decode 机器 prefill KV cache 传过去(按带宽估算约 100 ms) 一直稳定地出字 拆开换来的:出字不再被打断 放在一起时,一个长 prompt 的 prefill 就能让所有人停几步。拆开后 decode 那条线一格不少。 代价只是多一趟 KV 传输:KV 从 prefill 机器的显存走到 decode 机器的显存。
上面那条被截走的几格,就是拆开要换回来的东西。
下面那条多用了一批 prefill 机器,比的不是谁出字多,是出字断不断。时间线是示意;100 ms 是按我们 v7x 那套的带宽估算的。
出处与口径

📌 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。

同样 16 步,上面那条被长 prefill 截走了 5 步;下面那条一格没少。 (11 秒无声循环,Manim 渲染。格数是示意,不是实测时序。)

分块 prefill(chunked prefill)能缓解:把长 prompt 切成小块,每一步跟 decode 拼着跑。 但块切小了 prefill 自己变慢(每一块都要把前面的 KV 重读一遍),两种活还在抢同一批卡,而且只能用同一套并行方式。PD 分离干脆把它们拆开: prefill 机器只做 prefill,算完把 KV cache 交给 decode 机器,decode 机器只管出字。

6.2 代价:一趟 KV 传输

我们在 TPU v7x 上搭过一套 1P1D(Qwen3-Coder-480B,一台 v7x-8 做 prefill、一台做 decode),KV 从 prefill 那台的显存走到 decode 那台的显存:

一趟 KV 传输,只占一次 prefill 的 5–10% —— 网络不是瓶颈 我们在 TPU v7x 上的 1P1D(Qwen3-Coder-480B),8K token 的 prompt。KV 传输是按带宽估算,不是计时实测 prefill(1–2 秒) ① ② ③ 同一把时间尺:0 到 2 秒 0 500 ms 1000 ms 1500 ms 2000 ms 一次 prefill 1–2 秒 一趟 KV 传输 10 + 83 + 10 ≈ 100 ms 放大 10 倍: 10 ms ① 显存 → 本机内存(PCIe) 83 ms ② 本机 → 对方(数据中心网络 100 Gb/s) 10 ms ③ 对方内存 → 显存(PCIe) 敢走慢线,是因为一个请求只传这一次 这个模型 KV 头少(8 个)又用 FP8 存,8K prompt 的 KV 约 1.04 GB;换一个 KV 大得多的模型、换网络,要重算。 对比第三节的 TP:它每一层都要通信,只能待在最快那一圈;这里一个请求就一趟,跨机器也藏得住。
下面那条细细的三色条,就是拆开要付的全部代价。
放大 10 倍那行才看得清三段。
出处与口径

📌 我们的 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 缓解就够了。

6.3 两边各配几台

拆开之后多了一个旋钮:prefill 和 decode 的机器配比。思路是让两边差不多同时忙满,DistServe 论文给过一道很干净的算术:

拆开以后,3 张卡顶混着做的 7 张 —— 各干各的,谁也不拖谁 同一套延迟要求下,一张卡每秒接得住几个请求(DistServe 论文的例子,13B 模型、单张 A100) 两样都做 只做 prefill 只做 decode 每张卡每秒接得住几个请求 混着做 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 7 张 ≈ 11.2 个/秒 拆开 prefill 5.6 个/秒 prefill 5.6 个/秒 decode 10 个/秒 3 张 = min(2 × 5.6, 10) = 10 个/秒 每张卡接的请求翻了一倍多,配比就是这么算出来的 两边各有各的上限:prefill 一张接 5.6 个,decode 一张接 10 个,所以配 2 比 1,两边差不多同时忙满。 长 prompt 的业务 prefill 更累,就多配 prefill;长回答的业务多配 decode。
多用一种机器,反而省卡。
每张卡接的请求翻了一倍多,是因为谁也不再拖谁。
出处与口径

📌 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 倍是搜遍配比和切法之后的最好结果。

6.4 两边各挑各的切法

这才是拆开的真正收益:两边不再被迫用同一套并行方式。

6.5 AFD:attention 和专家分到两组机器

decode 这边还能再拆。attention 要读每个请求自己的 KV,跟请求绑定;专家不管 token 来自谁,只要 batch 够大:decode 每步都要把专家权重读一遍,来的 token 越多,这一遍越值(§6.1)。 AFD(Attention-FFN 分离)把两者放到两组机器上:M 台只算 attention,N 台只放专家。

再拆一层:attention 和专家也分开 —— 专家那边一次接好几家的 token AFD(Attention-FFN 分离)。示意:M 台 attention 机器、N 台专家机器,三个小批轮着跑 attention 机器 专家机器 小批 A(盯着它看) 小批 B 小批 C 每一层都要跑一趟 M → N → M attention 机器 1 attention 机器 2 attention 机器 3 专家机器 1 专家机器 2 去(M → N):token 发给专家 回(N → M):算完送回来 三个小批轮着跑:去、回各占半格 attention A A A B B B C C 去 A A A B B C C 专家 A A A B B C C 回 A A B B C C 0 1 2 3 4 5 6 7 8 看 A:第 0 格算 attention,去半格,专家一格,回半格,第 3 格又轮到它。 单程通信超过半格,一圈就超过 3 格,得四个小批(MegaScale-Infer)。 拆得越细,每一边越能挑适合自己的机器和切法 专家那边同时接几台 attention 机器的 token,凑出来的 batch 比单台大得多;两边的机器数也能分开调。 代价是每一层都有一趟来回,得靠几个小批轮着跑藏住(论文里要三四个才藏得住);两边之间的网络要够快。
拆开的不是张量,是一层里的两种活。
机器数和格子都是示意。
出处与口径

📌 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 月出了实验性插件。

6.6 多模态:编码器也单独放

同样的思路还能往前推一段:多模态模型的视觉编码器单独部署,算好的 embedding 再传给语言模型(Encoder 分离, 跟 PD 连起来常写作 EPD)。训练里对应的是多模块异构并行:编码器和语言模型各用一套并行方式。

6.7 这一刀留下的问题

五刀讲完了,每一刀都有自己的通信和适用场景。真到一个集群上,它们要同时存在: 谁放在同一台机器里、谁跨机器、先定哪一刀的度数?

考考自己:把 prefill 和 decode 拆到两批机器上,还要多搬一趟 KV,为什么反而省卡?

两种活不再互相拖,各自都能接满:论文的例子里 2 台 prefill + 1 台 decode 每秒接 10 个请求,混着做要 7 张卡。那趟 KV 只占 prefill 的一小截。

第 七 节

摆到机器上

🎧 本节讲课录音约 9 分 33 秒

一套真实配置里常常有三四种并行叠在一起。剩下的问题只有一个:哪一刀放在哪根线上。摆对了,前面每一刀省下的都是真省;摆错了,全被网络吃回去。

7.1 线有快有慢,刀有勤有懒

一个集群里的线不是一样快的。GPU 这边,GB300 NVL72 把 72 块卡连成一个 NVLink 域,域里每块卡 1.8 TB/s(收发合计,下同); 出了这个域只能走网卡,每块卡 200 GB/s,差 9 倍。TPU 这边,一个切片里的芯片走 ICI(够大的切片连成 3D 环面,见 §1.5), 跨切片走数据中心网络,同口径比慢约 50 倍(换算见台账),比 GPU 那边的 9 倍悬殊得多。

刀也不是一样勤的。把每一刀一步要通信几次数一遍(本课推导,示意配置),差出三个数量级:

每一刀多久说一次话 —— 说得勤的放快线,说得少的才走慢线 每步通信次数(按实际比例,本课推导)。示意配置:60 层、8 个 micro-batch、每层都是 MoE 放在最快的那一层线上 可以跨到慢线上 一步里的通信次数 TP 1,920 次 每层 4 次 all-reduce EP 1,920 次 每个 MoE 层 4 次 all-to-all FSDP 1,440 次 每层拼一次、反向再拼一次、再散一次 PP 16 次 每个 micro-batch 过段边界一来一回 DP 1 次 每步一次梯度 all-reduce 0 500 1,000 1,500 两种线差多少(GB300 NVL72,每块 GPU,双向) 一柜之内:NVLink 1,800 GB/s 出了这一柜:网卡 200 GB/s ← 差 9 倍 上下两张图一对,摆法就出来了 TP 每一层都要通信又藏不住,必须待在 NVLink 域里(GB300 是一整柜 72 块);EP、FSDP 能边算边传时才敢跨出去。 PP 一步十几次、DP 一步一次,跨到慢线上也吃得消。TPU 上同理:切片里走 ICI,跨切片走数据中心网络。
次数差三个数量级,线速差一个数量级,两边一对就是摆法。
次数是示意配置下的推导;带宽取 GB300 每块 GPU 的双向值。
出处与口径

📌 次数为本课推导: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 报告里 [TP, CP, PP, DP] 的排法一样 同一张桌:最快的那圈线 同一栋楼:集群网络 别的楼:慢线 由里到外,一圈比一圈慢 同一张桌:TP、EP、FSDP、CP 合写合同,每段都对一遍 同一栋楼:PP 按章节递稿(只在段边界) 别的楼、别的城市:DP 下班前对一次账(一步一次) 同一张桌是哪一圈? · 8 卡一台的机器:这一台 · GB300 NVL72:一整柜 72 块卡 · TPU:一个切片 为什么这么排 一步里说话的次数差三个数量级, 线速差一个数量级: 每根线上说的话, 要跟它的速度配得上。 这是默认摆法,也有人故意往外挪 能边算边传、藏得住的刀才敢往外挪:V3 的 EP 横跨了 8 台机器,Llama 3 把 FSDP 放在了最外层。 TP 藏不住,每一块末尾那次加总不做完下一块就没法开始,所以它几乎不出里圈。
合写合同得同桌,递稿子隔层楼也行,对账可以在别的城市。
圈的大小不代表带宽比例,只表示由里到外越来越慢。
出处与口径

📌 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 那套)。

7.2 摆错一次是什么样

同样 8 张卡、同样 TP4 × DP2,只改 TP 组放在哪。下面的时间是示意:快线传一次 1 格,慢线 9 格。

一轮通信要等最慢的那一段传完,所以摆法二每一轮都按慢线算。红箭头就是过慢线的那几段。 (29 秒,Manim 渲染;默认连续播放,取消勾选「连续播放」就能点「开始」一步一步看。一步 8 轮 TP、1 次 DP,快慢 1 : 9 是示意。)

同一个颜色就是一个 TP 组;摆法二里上排、下排各是一组。一步是 8 轮 TP 加 1 次 DP:摆法一 8 × 1 + 9 = 17 格,摆法二 8 × 9 + 1 = 73 格(DP 那一对卡在同一台机器里,只花 1 格)。

放到真实集群上,这就是为什么 TP 一般不出一台 8 卡机器。GB300 把 NVLink 域扩到一整柜, 专家并行才敢往大了开(TP 受头数和矩阵效率限制,在整柜上也很少超过 8 或 16):快线那一圈画多大,这几刀就能切多深。

7.3 先选对切法,再调参数

摆法和切法选错了,参数调得再细也只是在错的天花板下面打转。我们在 GB300 上跑 DeepSeek-V4-Pro 时撞上过一次。 图里的 1P1D 是一台 prefill 机器配一台 decode 机器,3P 是三台 prefill;DEP8 是 decode 那边 attention 每张卡各管一批请求、专家铺在 8 张卡上:

调参和换切法,不是一个量级 —— 看每张卡,不看总数 GB300 · DeepSeek-V4-Pro · vLLM,4K 进 1K 出。条长是每块 GPU 的吞吐(tok/s),括号里是总数和卡数 TP4 decode DEP8 decode 每块 GPU 每秒出多少 token 1P1D,TP4 decode 原始脚本(并发 256) 1,820 (总 14,563,8 块卡) 3P1D,TP4 decode 加 prefill、调并发后的最好成绩 1,319 (总 21,100,16 块卡) 总数 +45%,每卡 -28% 3P + DEP8 decode decode 卡 4→8 张,并发 512 2,758 (总 55,153,20 块卡) 条越长越好,按每张卡算 参数调得再好,也只是那一种切法的天花板 在 TP4 上加机器、调并发,总数 +45%,其实是靠多一倍的卡换的;出字间隔一直钉在约 46.8–53 ms。 换成 DEP8,同样并发下每卡 2.09 倍、出字间隔降到约 12 ms;把并发拉到 1,536 每卡能到 2.47 倍,但首字要等 95 秒。
比吞吐要按每张卡比:三次实测用的卡数是 8、16、20。
本课程作者实测,4K 进 1K 出。
出处与口径

📌 本课程作者实测: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 快线里。先问切法对不对,再动参数。

这一段的细账:每个数、口径,以及原始记录里没归因的地方
  • 去掉 eager 模式(即打开 CUDA Graph)只多 2.6%;加 prefill 机器、调并发,总数从 14,563 涨到 21,100(+45%),出字间隔始终在 46.8–53 ms。
  • 换 DEP8,同样并发 512:出字间隔 46.8 ms → 11.8 ms,首字延迟 55.8 秒 → 22.8 秒。同一套在并发 256 时首字只要 7.8 秒,并发 512 下多出来的大部分是排队。
  • 出字间隔为什么同时降下来,原始记录里没有拆开归因。
  • GB300 一个计算托盘 4 块卡;prefill 到 decode 的 KV 也走柜内 NVLink,不走网卡。并发是排队的请求数,batch 是同时在算的请求数。
  • 图里后两行都是并发 512,第一行是原始脚本的并发 256。DEP8 把并发拉到 1,536,总量能到 65,132(每卡 2.47 倍),但那时首字要等 95 秒,prefill 又成了瓶颈。
  • 吞吐是 prompt 和输出 token 加在一起算的。跟最早的原始脚本(每卡 1,820)比,DEP8 每卡约 1.5 倍。

7.4 五步怎么选

把前面几节串起来,给一个模型挑并行方式,像闯五关,每一关一个是非题:

  1. 第 1 关 装得下吗?装不下:权重和优化器状态摊不开就上 FSDP / ZeRO(第二节);MoE 的专家太多就上 EP(第四节); 推理时 KV 放不下就上 DCP(第五节)。
  2. 第 2 关 快线那一圈有多大?TP、EP 的度数别超过它(8 卡一台的机器就是 8,GB300 一柜是 72,TPU 看切片)。
  3. 第 3 关 序列长吗?训练长上下文加 CP,推理长 prompt 加 PCP。
  4. 第 4 关 还不够,或者非跨很慢的线不可?这时才上 PP:它只传段边界的激活,量小、频率低,能跨慢线,代价是气泡(第三节)。
  5. 第 5 关 还剩卡吗?全给 DP:一步只通信一次,最便宜。

拿两个真实配置对一遍。读这张表,先看两个「不用」: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 路数据并行里切专家(本课推导)。

7.5 怎么评:加卡之后掉了多少

配好之后要回答一个问题:卡加上去,每张卡的效率还剩多少。有两种量法:

衡量的数叫扩展效率:加卡后每卡的吞吐 ÷ 加卡前每卡的吞吐。 我们没有干净的 strong scaling 实测;最接近的是同一个 DP 4 × FSDP 128,每个 device 的 batch 从 12 降到 8,每芯片从 580 掉到 453:每张卡的活一少就吃亏。

下面是我们自己的两组实测,只能组内比。左边是一次 weak scaling:卡 ×4、global batch ×4。右边比的是同样的卡、FSDP 铺多宽。

加卡怎么加 —— 当副本几乎不掉,摊得更薄就掉 混元 3 在 TPU v7 上的实测,每芯片 TFLOP/s。v7 一颗芯片算 2 个 device,DP × FSDP 按 device 数(64 芯片 = 128 个)。左右两组每个 device 的 batch 不同 多出来的卡当 DP 副本 FSDP 铺得更宽 放不下 同配方放大 4 倍(每个 device 的 batch 12) 580 64 芯片 FSDP 128 580 256 芯片 DP 4 × FSDP 128 同样 256 芯片,只改怎么分(每个 device 的 batch 8,不能跟左边比) 404 DP 1 FSDP 512 450 DP 2 FSDP 256 453 DP 4 FSDP 128 爆显存 DP 8 FSDP 64 爆显存 DP 16 FSDP 32 加卡时要连 batch 一起加 左边每卡的活不变,4 倍的卡换来 4 倍的吞吐 —— weak scaling 100%。组和组之间每步只有一次梯度 all-reduce。 右边一个 FSDP 组从 128 个 device 扩到 512 个,拼权重的步数多了、每块更小,固定延迟摊不掉:404 比 453 少 11%。
同样多的卡,当副本用和摊薄了用,差 11%。
本课程作者实测;左右两组每卡 batch 不同,只在组内比。
出处与口径

📌 本课程作者实测: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 一起加,多出来的卡优先当副本。

7.6 这一节留下的问题

到这里,每一种并行都有了来处:它切什么、多出什么通信、该放在哪根线上。 下一节把它们摊在一张全景图和几张表上,那些 TEP8、DEP16、DP4 × FSDP128 的写法,就都读得懂了。

考考自己:TP、PP、DP 三个,谁最该坐最快的那圈线?谁可以去跨慢线?

TP:每层都要对账、又藏不住。PP 只在段边界递一次,能跨机器;DP 一步只说一次,最远能跨数据中心。

第 八 节

全景:今天所有的并行方式

🎧 本节讲课录音约 6 分 40 秒

名字很多,DP、FSDP、TP、SP、CP、PP、EP,推理那边还有 DCP、PCP、DEP、TEP…… 但归起类来只有四种。前面五刀里,切权重和切专家都算模型并行。先把类认清楚,名字就好记了。

8.1 四类刀法

判据只有一个:看它切的是什么。先看一张图,再看表:

全景:四类刀法,每个名字挂两样东西 —— 用哪种通信,能不能跨慢线 切权重和切专家都归「模型并行」。● 可以跨慢线 ○ 要快线(AFD、Wide-EP 跨机但每层都走,也要快网;有例外见第七节) 数据并行 序列并行 模型并行 解耦 数据并行 切 batch DP AllReduce ● ZeRO-1 RS + AG ● FSDP AG ×2 + RS ○ HSDP 机间那一维可跨慢线 ● Attention DP AllToAll(随 EP 走) ○ 序列并行 切一条样本 Megatron SP AG + RS(TP 的搭档) ○ Ring Attention Send/Recv 沿环 ○ Ulysses AllToAll ○ DCP 推理:AG + 合并,每层 3 次 ○ PCP 推理:切长 prompt ○ 模型并行 切权重 TP AllReduce,每层 ○ PP Send/Recv,段边界 ● EP AllToAll,每个 MoE 层 ○ Wide-EP EP 铺到几十张卡 ○ 解耦 拆工作 PD 分离 KV 跨机传一次 ● AFD 每层 attention→专家→attention ○ Encoder 分离 embedding 传一次 ● 读名字先问两句:它切的是什么,它多出来的是哪种通信 切什么定了它在哪一列;多出来的通信定了它该放在哪根线上。说得少的才敢跨慢线。 TEP8、DEP16 这类推理简称,是把 attention 的切法和专家的切法拼在一起说:前一个字母管 attention,EP 管专家。
名字再多,先问它在哪一列、圆点是实是空。
圆点是默认摆法,例外见第七节。
出处与口径

📌 归类与通信原语汇总自本讲第一到第七节;「能否跨慢线」是默认摆法,例外(V3 的 EP 跨机、Llama 3 的 FSDP 在最外层)见第七节。

刀法切的是什么每张卡手里有什么典型
数据数据并行batch,或者说请求 算不同的样本,模型在逻辑上是完整的DP、FSDP、Attention DP
序列序列并行一条样本内部的 token 同一条样本的一段;训练时是一段激活,推理时是一段 KV cacheCP、Ulysses、DCP
模型模型并行权重 只有模型的一部分:矩阵的几列、几层、几个专家TP、PP、EP
解耦解耦工作的阶段或模块 只干一种活:只做 prefill,或者只算专家PD 分离、AFD

下面几张表就按这四类排。「新」表示 2025–26 年才出现或才普及。 这四张是查阅用的,第一次读可以直接跳到 8.6;表里有不少前面没讲过的名字,用到时再回来翻。

8.2 数据并行类

名称切什么解决什么多出来的通信场景
DP / DDPbatch,模型整份复制线性扩吞吐 训练:梯度 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 的 DPDP 横跨多个 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」,在 MoE 推理里意思变了 dense 模型上开 DP,是几份互不相干的副本。MoE 模型在 vLLM / SGLang 里开 DP, 实际开的是 Attention DP:专家层还是大家一起跑,所以每一步所有 rank 都要同步。
vLLM 还有一个坑:只开 -dp 不开 -ep,专家层走的是 TP 而不是 EP。

8.3 序列并行类

一条样本太长,一张卡放不下它,就沿序列切开。这一类在训练和推理里的动机完全不一样: 训练切的是激活,推理切的是 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 AttentionKV 分块沿一个环传递度数不受 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_autoregressivedecode 时 KV 沿序列切,FFN 按专家切 同上,TPU 上的做法XLA 自动插入推

8.4 模型并行类

这一类真正在切权重。按下刀的位置再分三种:矩阵内部、层、专家。

切矩阵内部(张量并行)

名称切什么解决什么多出来的通信场景
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 两套通信组训
MoE 层有自己的一套并行维度 训练时 Megatron 把 attention 层记作 TP × CP × DP × PP,把专家层记作 ETP × EP × EDP × PP, 两套是分开配的。推理时同样如此,只是换了一套名字,见 §8.6。
这是 MoE 模型调并行时自由度最大、也最容易配错的地方。

8.5 解耦类

前三种刀法切的都是张量。这一类切的是工作:把不同性质的活拆到不同的机器上, 每一边再挑自己的并行方式。

名称拆什么解决什么多出来的通信场景
PD 分离prefill 和 decode 放到不同机器 prefill 吃算力,decode 吃带宽,放在一起互相拖累首字延迟和出字速度KV cache 跨机传输推
AFD 新attention 放一组机器,专家放另一组 专家那边汇集好几组 attention 的 token,把专家的 batch 做大;两边的机器配比也能分开调 每层一来一回:attention → 专家发一次,专家 → attention 收一次,要切三四个小批把它藏起来推
Encoder 分离多模态模型的视觉编码器单独部署编码器和语言模型抢资源embedding 传输推
多模块异构并行编码器和语言模型各用一套并行方式多模态训练里两部分的形状差太远两套网格之间的桥接通信训

8.6 组合简称:TEP 和 DEP

推理这边,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。

⛔ TEP / DEP 不是 ETP / EDP 名字只差一个字母的顺序,说的却是两件事。
TEP / DEP 是推理侧的叫法,说的是 attention 怎么切,DEP 里的 D 是 Attention DP。
ETP / EDP 是 Megatron 训练侧的叫法,说的是专家内部的 TP 度数,以及专家梯度在哪些卡之间求和。
Megatron 仓库里搜 TEP / DEP,结果是零。所以这两套名字并列记,不要互相换算。

其它常听到的组合说法:

8.7 常被当成并行、其实不是的

判据:它有没有多切出一维。没有的,就不是新的并行方式。

名称它实际是什么
TBO / SBO / DBO把通信藏到计算后面:两批数据错开跑,一批在通信时另一批在计算
Async TP、TP 通信重叠、collective matmul还是 TP,只是把通信和矩阵乘切成小块交错着做
EPLB、冗余专家负载均衡:把热门专家多复制几份再重新摆放。修的是 EP 的病,本身不切新维度
Offload、重计算拿时间换显存,或者拿主机内存换显存
分块 prefill(chunked prefill)推理调度:把长 prompt 切成小块跟 decode 拼着跑,缓解互相卡住(§6.1);别跟 §8.3 的 Chunked PP 混:那个也用在推理 prefill,但块是灌进流水线并行的,真的多切了一维

8.8 同名不同义

词在不同地方的意思
SP至少三种:Megatron 的 SP(只切 LayerNorm 那几段,跟着 TP);DeepSpeed 说的 SP(指 Ulysses); 以及泛指一切切序列的做法。Megatron 里「所有激活都切」叫 CP
CP训练里指切激活。vLLM 把它拆成两个开关,对卡数的作用相反:PCP 加卡,DCP 不加卡;功能也不同,一个压首字延迟,一个扩 KV 容量
DPdense 模型上是独立副本;MoE 推理里其实是 Attention DP,每一步都要同步
ETPMegatron 指专家内部的 TP;TensorRT-LLM 的 Hybrid ETP 指专家层 TP 和 EP 混用
hierarchicalZeRO++ 的分层分片、Megatron 的分层 CP,是两件不同的事
卡/芯片/deviceGPU 上一张卡就是一个 device;TPU v7 一颗芯片对软件显示成 2 个 device,并行度按 device 数
带宽有的按单向报、有的按收发合计报:本讲的 1.8 TB/s(NVLink)、1.2 TB/s(ICI)是收发合计,800 Gb/s、100 Gb/s(网卡)是单向
并发与 batch并发是在排队的请求数,batch 是同时在算的请求数

8.9 带走三句话

以后遇到一个没见过的并行名字,先问三句 ① 它切的是什么?(数据、序列、模型,还是把活拆开)
② 它多付哪种通信?(第一节那五种之一)
③ 这种通信该放哪根线?(一步里说得越勤,越要靠里;第七节那栋写字楼)

拿开场那个 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,主权重与累积梯度留 fp32DeepSeek-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 的本地更新不需要通信;梯度裁剪要一次标量 AllReduceAdam 逐元素更新(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;交错式除以 vNarayanan 等 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_microbatchesMaxText 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 rankvLLM 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-1DeepSpeed 文档:流水线并行不兼容 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 scalingAmdahl 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 亿参数、预训练 4KDeepSeek-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 rankvllm-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 部署文档
HelixarXiv 2507.07120;TensorRT-LLM tech blog 22
GTP 原话Megatron-LM docs/api-guide/core/generalized_tensor_parallel.md
Zero Bubble / DualPipearXiv 2401.10241;github.com/deepseek-ai/DualPipe
DiLoCoarXiv 2311.08105;Streaming DiLoCo arXiv 2501.18512;MaxText 的 diloco mesh 轴
AFDMegaScale-Infer arXiv 2504.02263;Step-3 arXiv 2507.19427;vLLM AFD Plugin blog(2026-07-23)
Chunked PPLMSYS 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 生成 —— 正文写在那个脚本里。