跳到主要内容

流水线并行

上一章讲的张量并行是把每一层内部切开算。它有个硬约束——只能在机内做,跨机不行。所以当我们要跨越很多台机器训练一个层数极多的大模型时,还需要另一种策略。

这一章讲流水线并行(Pipeline Parallelism, PP):不切算子,而是切层。第一台机器算前面几层,第二台机器算中间几层,第三台机器算后面几层,数据在机器之间"流"过去。听起来非常自然,但真的要跑起来,会遇到一个不小的麻烦。我们来看看这个麻烦是什么,以及大家是怎么绕过它的。

1. 一个最朴素的流水线​

设想一个 96 层的模型,4 张 GPU。最直觉的做法:

  • GPU 1 放第 1-24 层
  • GPU 2 放第 25-48 层
  • GPU 3 放第 49-72 层
  • GPU 4 放第 73-96 层

一个 batch 的数据来了:GPU 1 算前向,把结果发给 GPU 2,GPU 2 算完发给 GPU 3……最后 GPU 4 算完 loss,反向传播反着走一遍:GPU 4 → GPU 3 → GPU 2 → GPU 1。每两个相邻 GPU 之间只发送激活(前向)或激活的梯度(反向),通信量很小。

听起来很好,但你仔细想想利用率。

在任何一个时刻,只有一张 GPU 在工作。GPU 1 算的时候 GPU 2 在等,GPU 2 算的时候 GPU 1 和 GPU 3、4 都在等……4 张卡的利用率只有 1/4,跟只用一张卡差不多。

这就是"朴素流水线"没法用的根本原因:串行依赖让所有 GPU 大部分时间在空转。

2. GPipe:把 batch 切碎​

Google 提出的 GPipe 给出了一个非常聪明的解法:既然一个 batch 只能让一台机器工作,那我把 batch 切成很多小份,让它们错开着流过流水线不就行了?

具体做法:把 mini-batch 切成 MM 个 micro-batch。第一个 micro-batch 进入 GPU 1;等它转到 GPU 2 时,第二个 micro-batch 就可以进入 GPU 1 了;等第一个到 GPU 3 时,第二个到 GPU 2,第三个进入 GPU 1……画出来大概是这样:

时间 →
GPU 1: F1 F2 F3 F4 B4 B3 B2 B1
GPU 2: F1 F2 F3 F4 B4 B3 B2 B1
GPU 3: F1 F2 F3 F4 B4 B3 B2 B1
GPU 4: F1 F2 F3 F4 B4 B3 B2 B1
↑ 稳态:所有 GPU 都在工作 ↑

(F 代表某个 micro-batch 的前向、B 代表反向;数字是 micro-batch 的编号)

流水线在启动阶段还是有人空闲(左上角、右下角那些空隙叫 bubble),但一旦进入稳态,所有 GPU 都在工作。

利用率是多少?可以算出来,是 MM+P−1\frac{M}{M + P - 1}。MM 是 micro-batch 数,PP 是流水线阶段数。当 M≫PM \gg P 时,接近 100%。

但 GPipe 有一个隐患。它的调度是"先把所有 micro-batch 的前向都做完,再统一做反向"。为什么要这样?因为反向需要用前向保存的激活。所有 MM 份 micro-batch 的前向激活得一直存着,直到反向阶段用完才能释放——激活显存与 MM 成正比。

MM 太小,bubble 大、利用率低;MM 太大,激活显存爆炸。这是一个矛盾。

一般做法是 MM 开到 bubble 可接受的量(比如 M≥4PM \geq 4P,bubble 就在 20% 以内),然后开激活重算——反向时不用保存的激活,而是重新算一遍前向,代价是多 30% 左右的计算。这个组合下,GPipe 就能用了。

3. PipeDream 1F1B:把激活显存降下来​

后来微软的 PipeDream 提出了一个更好的调度:1F1B(One Forward One Backward)。

想法很直接:能不能让某个 micro-batch 的反向尽早发生,好让它的激活尽早释放?

答案是可以的。每张 GPU 交替执行一次前向和一次反向。稳态阶段的样子大致是:GPU 4(最后一段)连着做一个 micro-batch 的前向和反向,然后是下一个;GPU 3 也是交替;GPU 1(最前面一段)也交替。

关键的效果是:任何时刻,一张 GPU 手里最多同时保存 PP 个 micro-batch 的激活(PP 是流水线深度)——而不是 GPipe 的 MM 个。MM 是我们希望开大来减少 bubble 的、PP 是流水线本身的深度不可控。所以 1F1B 让"减 bubble"和"省显存"这两个目标不再冲突。

Megatron-LM 里用的是 1F1B + Flush 的版本:每一轮 MM 个 micro-batch 全部走完前向和反向再统一更新参数,这样能保证参数版本的一致性(如果反向用的参数和前向不是同一版本,梯度就没意义了)。

4. Interleaved 1F1B:再压 bubble​

我们再来看 bubble 的公式:P−1M+P−1\frac{P-1}{M+P-1}。当 PP 增大(跨机跨得越多),bubble 就越大。跨 16 台机、M=16M=16,那 bubble 已经接近 50%——太浪费了。

Megatron 提出了一个改进叫 Interleaved Pipeline(虚拟流水线):把每张 GPU 分负责的连续几层,改成负责几段不连续的层。

举个例子,本来 GPU 1 放第 1-24 层,现在改成 GPU 1 放第 1-6 层和第 49-54 层。相当于流水线被切得更"细"了,虚拟的流水线深度变成了 v⋅Pv \cdot P,vv 是每张 GPU 分几段。bubble 缩小到 1v⋅P−1M+P−1\frac{1}{v} \cdot \frac{P-1}{M+P-1}。

代价是每张 GPU 上的通信次数变成了 vv 倍——因为它要跟"上下段"通信 vv 次。跨机带宽如果够、通信可以和计算重叠,这个代价能吃下来。

5. Zero Bubble / DualPipe​

流水线的"终极目标"是把 bubble 压到 0。近年来有不少尝试:

Zero Bubble Pipeline(2023):把反向进一步拆成 B(激活梯度)和 W(权重梯度)两部分——W 不依赖后续层,可以延迟执行、填到 bubble 里。理论上能把 bubble 干到 0。

DualPipe(DeepSeek-V3):让 pipeline 双向执行——前向从头走到尾的同时,反向从尾往前走。两条方向的计算和通信互相错开填空隙。DeepSeek-V3 训练时就靠这个把 bubble 压得非常低。

这些是研究前沿,工业界主流还是 1F1B 或 Interleaved 1F1B。

6. 切成几段?每段多长?​

PP 的一个工程难点是切分策略。原则上要平衡两件事:

每一段的计算量要均衡。因为流水线的吞吐由最慢的一段决定,如果某一段特别慢,前后段都在等它。

每一段的显存也要够用。参数、激活、KV cache 都要在这一段的 GPU 上装下。

理论上均分层数就好,但实际有些细节:

Embedding 和 LM head 特别大。Vocab size × hidden 就是几百 MB 到几个 GB 的权重,而且它们的计算模式和中间的 Transformer block 不一样。通常单独放,或者让它们权重共享放在同一个 stage(tied embedding)。

流水线越靠前的 stage,激活压力越大。因为 1F1B 下最前面的 stage 手里同时挂着最多份 micro-batch 的激活(要等它们绕流水线一圈回来)。所以有时候会让前面的 stage 少放几层,用不均衡的切分来平衡实际显存。

7. 通信量与拓扑的匹配​

PP 的通信只发生在相邻 stage 之间,量也就是"激活的大小"。相比 TP 每层要 All-Reduce 全部激活、DP 每步要 All-Reduce 全部梯度,PP 的通信量是最小的。

所以拓扑上一个非常自然的匹配是:

  • 机内做 TP(通信密集,靠 NVLink)
  • 跨机做 PP(通信稀疏,靠 IB 就够)
  • 外层做 DP(通信可以和反向计算重叠)

这就是"3D 并行"的基本形态,我们下下章会详细讲。

8. 常见坑​

Global batch 会随 PP 度变化。global batch=micro batch×M×DP\text{global batch} = \text{micro batch} \times M \times \text{DP}。你改 PP 度或者 MM,全局 batch 就跟着变,学习率、warmup 步数都要重新调。这是个常见的调参陷阱。

Debug 很痛苦。Pipeline 的 bug 常常表现为"训练跑得起来、loss 曲线看起来也差不多,但收敛比预期慢一点"——这种模式的 bug 通常是激活版本或者参数版本对不齐。建议先在极小规模(比如 2 层模型、2 个 stage、M=2M=2)验证正确性再放大。

通信 backend。跨机的 P2P 通信要走 NCCL 的 P2P kernel,如果配置不当会退化到 CPU 中转,慢一到两个数量级。检查 nvidia-smi topo -m 看看 GPU 间的连接。

流水线并行到这里就讲完了。下一章我们看一个非常特殊的场景:MoE 模型的并行,它有自己独特的通信模式。