🏠 总目录📚 本教程 流水线并行 ← →

AI基础设施 · 13

流水线排上了活,为什么开头和结尾还有空格?

每个 micro-batch 必须遵守前反向依赖。看同一时间列中的工作与空格,再比较 GPipe 和 1F1B 的取舍。

读完能判断:按同一时间列读 micro-batch 依赖,区分气泡、激活驻留与负载不均。

📑 本页目录(点开跳转)

13 · 流水线并行

⏱ 26 分钟 | ⭐ 手算气泡,再比较两种调度


🎯 一句话

同一个 80 层模型放不进一张卡,可以把它切成四段。若一段做完、下一段才开工,四张卡就轮流等。流水线并行(Pipeline Parallelism,PP)把模型沿深度分成阶段,再把一批数据分成小份,让不同阶段同时处理不同的小份。先跟一份数据走完整条链,再数它给其他阶段留下的空闲。


🏭 一、基本结构

模型 80 层,4 张卡: 前向传播:激活一站一站往右传 GPU0 层 1-20 GPU1 层 21-40 GPU2 层 41-60 GPU3 层 61-80 反向传播往回传 跨切分点:前向传激活,反向传对边界激活的梯度
在这个只使用 PP 的例子里,相邻阶段在三处接缝交换张量。下方箭头表示梯度逐级折返。

沿用图里的四个阶段和一批 8 条序列,每两条分成一个微批(micro-batch),共 4 个。GPU 0 做完第一个微批的前向,把输出张量(边界激活)送给 GPU 1,再逐级传到最后一段。最后一段算出损失,反向逐级传回的是损失对边界激活的梯度。每段用收到的梯度和自己的前向记录计算局部权重梯度,并把对上一段输出的梯度传回去。

3 个边界 × 4 个微批 × 2 个方向

假设每条序列长 2,048,每个位置的边界向量宽 8,192,激活与边界梯度均为每元素 2 字节的 BF16。每个微批单向发送 2 × 2,048 × 8,192 × 2 = 67,108,864 字节,即 64 MiB(1 MiB = 2²⁰ 字节)。

每个边界前向、反向各传 4 次,共 4 × 2 × 64 = 512 MiB。三个边界合计 3 × 512 = 1,536 MiB,即 1.5 GiB(约 1.61 GB)。这里把每次发送的有效载荷计一次,没有重复加上接收端,也没有把字节换成耗时。

若一个 TP 实现每层假设 4 次 AllReduce、每次的逻辑张量大小等于整批边界张量,80 × 4 × (4 × 64 MiB) = 81,920 MiB,约 85.9 GB。它是集合操作的逻辑张量之和。要对比实际通信,还要换算每个参与进程的发送量、物理路径与重叠时间。PP 跨机也要检查每条边界的带宽与延迟,见第 5 章。


🫧 二、气泡:流水线的原罪

如果一次只放一个微批入流水线,就要等它做完四段前向和四段反向,再让下一个进来。等长的 1 ms 槽里,每时刻只有一个阶段在算,其余三个空着。流水线填充是工作逐级到达,排空是最后几份工作逐级离开。这两段因依赖而闲下来的时间叫气泡(bubble)。

下图用 GPipe 的先前向、后反向调度。让四个微批依次进入,GPU 1 做 F1 时,GPU 0 已能做 F2。等整轮前向完成后,图中的反向按 B4 到 B1 启动。每个阶段的每次前向和反向都设为 1 ms,暂时忽略传输耗时。

同一时间列代表同时发生的工作。micro-batch 按依赖逐级前进;开头和结尾的空格是流水线气泡。为便于读图,假设各阶段前向与反向耗时相同。GPipe:四阶段 × 四个 micro-batchGPU 0F1B4F2B3F3B2F4B1GPU 1F1B4F2B3F3B2F4B1GPU 2F1B4F2B3F3B2F4B1GPU 3F1B4F2B3F3B2F4B1时间向右推进F:前向 B:反向 空格:等待
同一时间列代表同时发生的工作。micro-batch 按依赖逐级前进;开头和结尾的空格是流水线气泡。为便于读图,假设各阶段前向与反向耗时相同。

令 P 为阶段数(每阶段一张卡),M 为一次更新包含的微批数。前向时第一个微批走 P 槽,其余微批从最后一级每槽出来一个,共 P + (M − 1) 槽;反向同样长。每段只做 M 次前向和 M 次反向,忙 2M 槽,剩下 2(P − 1) 槽在等待。因此空闲槽除以总槽数为:

$$\text{气泡占比}=\frac{2(P-1)}{2(M+P-1)}=\frac{P-1}{M+P-1}$$

P = 4、M = 4 时,每段 14 槽中忙 8、闲 6,四段合计 56 个卡槽,24 个空闲,24 ÷ 56 ≈ 42.9%。若问「比只忙那 8 槽多花多少」,分母换成忙槽,6 ÷ 8 = 75%。吞吐则用完成的微批数除以墙钟时间:4 ÷ 0.014 秒 ≈ 286 微批/秒。一次只让一个微批通过,同样四份需 4 × 8 = 32 ms,吞吐是 4 ÷ 0.032 秒 = 125 微批/秒。

仍用四段,M = 16 时,气泡占比是 (4 − 1) ÷ (16 + 4 − 1) = 3 ÷ 19 ≈ 15.8%,M = 64 时是 3 ÷ 67 ≈ 4.5%。八段、64 微批则是 7 ÷ 71 ≈ 9.9%。M ≥ 4P 可作搜索起点。固定总批量时,微批增多意味着每份变小,内核效率与传输启动次数都可能变化。固定每份大小时,增多又会改变每步总批量。


⚡ 三、1F1B:现代标准调度

GPipe 先做完所有前向,所以每个阶段都得为 4 个微批留着前向记录。1F1B(One Forward One Backward)先让各段预热,再尽可能交替做前向和反向。一个 B 必须等自己的 F,以及下一阶段传回的梯度(最后一级从损失起算)。相邻 F 和 B 可能属于不同微批,B 做完才可释放对应的前向记录。

1F1B 四阶段四微批,每格 1 毫秒,前向和反向按依赖交错1F1B:四阶段 × 四个微批GPU 0F1F2F3F4B1B2B3B4GPU 1F1F2F3B1F4B2B3B4GPU 2F1F2B1F3B2F4B3B4GPU 3F1B1F2B2F3B3F4B4时间向右,每格 1 msF:前向 B:反向 空格:等待
与上图使用同样的四阶段、四微批和 1 ms 时间槽。先看 GPU 3 的 F1、B1,再沿 B1 向上找。用编号区分交替出现的前向和反向各属于哪个微批。

按图每遇到一个 F 记一份驻留记录,每完成一个 B 划掉一份。GPU 3 在 GPipe 中先 F1、F2、F3、F4,峰值 4 份。在 1F1B 中它 F1 后接 B1,F2 后接 B2,峰值只到 1 份。GPU 0 必须等 B1 穿过整个流水线,已先做了 4 次 F,峰值仍是 4 份。

同一批训练的激活峰值(微批份数)
阶段GPipe1F1B
GPU 044
GPU 143
GPU 242
GPU 341

若 GPU 3 每份需要保留 64 MiB 前向记录(单独设定的显存大小),峰值是 4 × 64 = 256 MiB 对 1 × 64 = 64 MiB。这类同步、非交错的安排中,GPipe 每段峰值份数随 M 增长,1F1B 每段受微批数和从该段到末段的距离限制。算实际显存还要看每份保存了什么、重算、梯度和缓冲区。

两图最后一个 B 都在第 14 槽完成,每段仍忙 8 槽、闲 6 槽。相同的理想气泡可以伴随不同的激活峰值。阶段不均衡、通信或重叠方式不同,实际耗时和内存峰值仍要测。两种图都让同一批的全部微批用同一轮权重,反向全部完成才进行这轮更新。GPipe · Megatron-LM §2.2

⭐ 交错式 1F1B(Interleaved)

一张卡可以放多个不连续的层块。比如 GPU 0 放层 1–10 和 41–50,GPU 1 放层 11–20 和 51–60。数据先走四张卡上的第一组,再走第二组。每卡放 v 块,共 P × v 个虚拟阶段。若每块恰是原阶段计算量的 1/v,并使用匹配的交错调度,忽略通信时,论文 §2.2中的气泡时间约缩至原来的 1/v,气泡占比变成 (P − 1) ÷ (vM + P − 1)。

仍用四段、四微批,每卡分两块。忙的 8 ms 不变,理想空闲由 6 ms 变成 6 ÷ 2 = 3 ms,合计 11 ms,3 ÷ 11 ≈ 27.3%。这个放置有 8 个层块,数据经过 7 个跨卡接缝,原来只过 3 个。边界传输和小块调度的开销可能吃掉收益,需核对微批数、调度器与实际链路。


⚖️ 四、切分策略:负载均衡是关键

还是四段四微批。假设前三段的前向、反向仍各 1 ms,GPU 3 因输出层和损失计算变成各 2 ms。按先前向后反向调度,第一份前向走完要 1 + 1 + 1 + 2 = 5 ms,随后三份离开末段的间隔由末段决定,是 3 × 2 = 6 ms,前向共 11 ms。反向第一份逆向走完同样要 5 ms,随后三个微批也是每隔 2 ms 完成,反向再用 11 ms。整步由均衡例的 14 ms 变成 22 ms,而 P 和 M 没变。

四张卡各占用 22 ms,总预算 88 卡·ms。前三段各忙 8 ms,末段忙 4 × (2 + 2) = 16 ms,共 40 卡·ms。余下 48 卡·ms 空闲,48 ÷ 88 ≈ 54.5%。这里连同不均衡造成的等待一起计,不能套用等长槽公式。

先测各段的前反向时间和边界传输,再调整层数。比如 80 层从每卡 20 层改成 22、21、21、16,把末段的一些层挪到前面作为候选。嵌入、输出层或不同类型的中间层也可能让各段不等重,换切分后还要查每段峰值显存和新边界的代价。


🔨 五、代码

先用 Python 3 复核上图 GPU 3 的前向记录峰值。前向加一份、反向减一份,按时序累计并记录最大值;程序打印 4 和 1。它只数驻留份数,运行时不需要 GPU 或 PyTorch。

def peak_records(actions):
    active = 0
    peak = 0
    for action in actions:
        active += 1 if action == "F" else -1
        peak = max(peak, active)
    return peak


print("GPipe:", peak_records("FFFFBBBB"))
print("1F1B:", peak_records("FBFBFBFB"))

下面保留 PyTorch 调度骨架,用来看阶段如何创建和收发。实际训练要按安装版本补齐分布式初始化、设备绑定、阶段输入和优化器;这里的 SplitPoint 还需导入,构造训练调度需传 loss_fn。最后一级的 step 返回合并后的模型输出,想收集各微批损失应传入 losses 列表。原注释中的 M ≥ 4P 是经验起点。

# 🧩 骨架:`model` 来自你自己的代码,这一段只看写法
# PyTorch 原生(2.x)
from torch.distributed.pipelining import pipeline, ScheduleGPipe, Schedule1F1B

pipe = pipeline(module=model, mb_args=(example_input,),
                split_spec={"layers.20": SplitPoint.BEGINNING,
                            "layers.40": SplitPoint.BEGINNING,
                            "layers.60": SplitPoint.BEGINNING})
stage = pipe.build_stage(rank, device)
sched = Schedule1F1B(stage, n_microbatches=64)    # ⭐ M ≥ 4P

for batch in loader:
    if rank == 0:      sched.step(batch)
    elif rank == last: losses = sched.step(target=labels)
    else:              sched.step()

💡 DeepSpeed 和 Megatron 也都提供流水线 —— Megatron 的 --num-layers-per-virtual-pipeline-stage 就是交错式 1F1B。


⚠️ 六、四个坑

坑 说明
micro-batch 太少 按本章的气泡口径先算,再试不同微批大小和通信开销
切分点不均衡 被最慢一级拖住 → 按实测耗时切 ⭐
BatchNorm 训练时每个微批的均值与方差可能不同于整批;要核对模型使用的归一化和统计策略
调试困难 报错栈横跨多个进程

按一轮更新核对梯度。 本例四个微批各含两条序列,一个流水线副本一次更新处理 4 × 2 = 8 条。若各微批损失都按样本取平均,等大小时先把四份梯度加起来,再除以 4,才等于对八条样本取平均。若按有效 token 取平均,且各微批的有效 token 数不同,要按各自的有效 token 数加权。框架如果已经缩放梯度,需对齐其损失归约约定。再配两个处理不同数据的 DP 副本时,全局批量是 8 × 2 = 16 条。


📊 七、三种并行的对比(重要)

数据并行 张量并行 流水线并行
切什么 数据 层内的矩阵 层(按深度)
通信频率 看同步与梯度分桶 通常在层内多次,依实现 每微批在相邻阶段收发
通信量 由梯度大小、集合算法和参与卡数决定 由层内同步的形状、频次和集合算法决定 边界激活与反向梯度的有效载荷
能跨机 ✅ 可行,效率依拓扑 ✅ ⭐
省参数显存 ❌ ✅ ✅
主要缺点 不省显存 偏好高速互联 气泡
单层工作集装不下 普通复制式 DP 不拆层;ZeRO-3 配合 TiledLinear 可用于适用线性层 层内分片是候选;核对每卡峰值 按完整层划分的 PP 本身不拆层;可组合 TP 或适用的顺序分块

⭐ 三者互补,不是三选一 —— 第 14 章讲怎么组合。


🔗 和站内其他章的关系

相关的地方 这里的位置
第 5 章 跨机带宽小 按每条边界的链路估传输耗时
第 12 章 层内同步 对齐逻辑载荷、每卡发送量和链路时间
第 9 章 梯度累积 微批是工作单位,梯度在一次更新内累计
第 14 章 3D 并行 PP 放在跨机维度
《Kaggle竞赛方法论》02 训练策略与正则化 梯度累加 那里它只是"省显存的招";在流水线里它是气泡公式的 M,直接决定效率 ⭐
《大模型全景导论》主线 2 · 模型怎样看懂一句话 一层长什么样 本例沿完整层划分;需测嵌入、输出层与中间层各自的开销

✅ 检查点

  1. 微批经过哪三个边界?前向和反向分别传什么?
  2. 同样四个微批,一次只放一个与 GPipe 各用多久?
  3. 每段忙 8 槽、闲 6 槽,空闲占比与相对开销各是多少?
  4. 固定总批量时,增大微批数会带来什么代价?
  5. 1F1B 相比 GPipe 改进了什么?气泡率变了吗?
  6. 交错式 1F1B 的思路和代价是什么?
  7. 若 GPU 3 的前向、反向各变成 2 ms,GPipe 一步多久?
  8. 四个等大的微批各用平均损失,怎样还原整批梯度?
  9. 三种并行里,哪些能跨机?单层工作集装不下时,TP 和顺序分块各有什么条件?
👀 答案
  1. 每对相邻阶段之间有一个切分点。前向传边界激活,反向传损失对边界激活的梯度。每个微批每方向 64 MiB,三个切分点合计 3 × 4 × 2 × 64 = 1,536 MiB。
  2. 一次只放一个微批是 4 × 8 = 32 ms。GPipe 让不同阶段处理不同微批,前向和反向各 7 ms,共 14 ms。
  3. 空闲占比用总槽作分母,6 ÷ (8 + 6) ≈ 42.9%。相对忙时开销用忙槽作分母,6 ÷ 8 = 75%。
  4. 每份变小,设备可能更难跑满,跨边界发送的次数也增加。实际激活显存要看每份大小和调度。
  5. 可尽早做已就绪的反向并释放对应记录。本例 GPU 3 从峰值 4 份降到 1 份,GPU 0 仍是 4 份。相同等长假设下两图同为 14 槽。
  6. 每卡放两块并交错执行,假设每块等长且忽略通信,空闲由 6 ms 降到 3 ms,气泡占比为 3 ÷ 11 ≈ 27.3%。本例跨卡接缝从 3 个增到 7 个。
  7. 前向首份 5 ms,后续间隔各 2 ms,共 5 + 3 × 2 = 11 ms。反向同样 11 ms,整步共 22 ms。
  8. 四份梯度求和后除以 4,再进行一次权重更新。损失按 token 平均而各份有效 token 数不同时,改用有效 token 数加权。
  9. DP、PP 和 TP 都能跨机;TP 的层内同步较频繁,效率需按拓扑与负载评估。TP 可通过层内分片降低每卡工作集;适用线性层还可评估 ZeRO-3 + TiledLinear 顺序分块。普通按完整层划分的 PP 本身不拆单层,分块方案仍需核对峰值、兼容性与吞吐。

本节回顾

⚡ 走神救援

先记住这几件事

下一节 👉 14-并行策略怎么组合.md ⭐

条件与依据

时间图展示的是等长计算、忽略通信、同批次一起更新的训练模型。线上推理没有反向,通常更关注首 token 延迟、后续 token 间隔和并发吞吐,不能套用这里的训练时序和气泡占比。

官方文档

打卡记录保存在你的浏览器里,首页能看到总进度