Transformer——Q144 分析模型并行的流水线气泡（Pipeline Bubble）时间占比

关注

原创最新推荐文章于 2026-09-15 08:17:21 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

大模型面试题54：如何减少分布式并行训练时出现的bubble 时间。气泡只在流水线并行（PP）中出现，DP/TP里没有这个问题。场景：把模型拆成2层（Layer1、Layer2），分给2张GPU（GPU1、GPU2）做PP；训练数据分3个批次（Batch1、Batch2、Batch3）。理想流水线：GPU1算完Batch1的Layer1，立刻传给GPU2算Layer2；同时GPU1开始算Batch2的Layer1 → 两张卡都不空闲。实际情况（出现气泡）第1步：GPU1算Batch1的Layer1，GPU2空闲 → 这就是气泡1；第2步。阅读详情

该问题归类到Transformer架构问题集——训练与优化——分布式训练。请参考LLM数学推导——Transformer架构问题集。

1. 问题背景

在深度学习领域，尤其是大语言模型（LLM）的训练过程中，随着模型规模的不断扩大，单设备的内存和计算能力往往难以满足需求。模型并行作为一种重要的分布式训练策略应运而生，它将模型的不同层分布到多个计算设备上，从而突破单设备的资源限制。

流水线并行是模型并行的一种具体实现方式，它将模型按层划分为多个阶段（Stage），每个阶段由一个或多个设备负责。在理想情况下，流水线并行可以实现各阶段的并行计算，大幅提高训练效率。然而，由于流水线的启动和结束阶段存在数据依赖，会导致部分计算设备处于空闲状态，形成所谓的 “流水线气泡”。这些气泡会降低整体计算资源的利用率，影响训练效率。因此，分析流水线气泡的时间占比对于评估流水线并行的性能、优化训练过程具有重要意义。

2. 技术原理与数学理论解析

2.1 流水线并行的基本原理

假设一个模型被划分为 S 个阶段（Stage），每个阶段处理模型的一部分层。同时，假设有 M 个微批次（Micro-batch）的数据需要处理。在流水线并行中，各阶段按顺序依次处理每个微批次的数据，形成一个流水线。

具体来说，当第 i 个微批次数据在第 j 个阶段处理时，第 i+1 个微批次数据可以同时在第 j-1 个阶段处理（如果存在的话），以此类推。这样可以实现各阶段的并行计算，提高整体效率。

2.2 流水线气泡的产生

在流水线的启动阶段，由于前面的阶段需要先完成对第一个微批次数据的处理，后面的阶段才能开始工作，因此会出现部分阶段空闲的情况。同样，在流水线的结束阶段，前面的阶段已经完成了所有微批次数据的处理，而后面的阶段还在处理剩余的微批次数据，也会导致部分阶段空闲。这些空闲时间就是流水线气泡。

2.3 数学模型推导

假设每个阶段处理一个微批次数据的时间为 T，则一个微批次数据在整个流水线中完成处理的总时间为 $S \times T$ （不考虑气泡）。

对于 M 个微批次数据，在理想情况下（没有气泡），总处理时间为 $T_{ideal} = (M + S - 1) \times T$ 。这是因为第一个微批次需要 $S \times T$ 时间完成，而后续的 M-1 个微批次每个只需要 T 时间即可完成（由于流水线的并行性）。

然而，由于存在气泡，实际总处理时间会更长。实际总处理时间为 $T_{actual} = M \times S \times T$ 。这是因为每个微批次都需要依次在 S 个阶段中处理，每个阶段处理时间为 T。

因此，流水线气泡的时间占比为：

$\begin{aligned} \text{Bubble Time Ratio} &= \frac{T_{actual} - T_{ideal}}{T_{actual}} \\ &= \frac{M \times S \times T - (M + S - 1) \times T}{M \times S \times T} \\ &= \frac{(M - 1)(S - 1)}{M \times S} \end{aligned}$

从这个公式可以看出，气泡时间占比与阶段数 S 和微批次数量 M 有关。当 S 和 M 都很大时，气泡时间占比会趋近于 1，这意味着流水线的效率会显著降低。

3. 根因分析

流水线气泡的产生主要有以下几个原因：

数据依赖：流水线中各阶段的处理存在严格的数据依赖关系，必须前一个阶段完成对某个微批次数据的处理后，下一个阶段才能开始处理该微批次数据。
启动和结束开销：在流水线的启动和结束阶段，由于部分阶段需要等待其他阶段完成工作，导致这些阶段处于空闲状态，形成气泡。
微批次数量限制：当微批次数量较少时，气泡时间占比会相对较高，因为启动和结束阶段的开销在总时间中所占比例较大。

4. 在 LLM 中的使用示例

4.1 GPT 模型训练

在训练 GPT 系列模型时，由于模型规模巨大，通常会采用流水线并行技术。例如，将 GPT 模型按层划分为 8 个阶段，使用 16 个微批次进行训练。

在这种情况下，根据前面的公式计算，流水线气泡的时间占比为： $\frac{(16 - 1)(8 - 1)}{16 \times 8} = \frac{15 \times 7}{128} \approx 0.82$ 这意味着约 82% 的时间是气泡时间，实际计算效率只有 18% 左右。这表明在这种配置下，流水线并行的效率较低，需要进行优化。

4.2 BERT 模型微调

在对 BERT 模型进行微调时，也可以使用流水线并行技术。例如，将 BERT 模型划分为 4 个阶段，使用 32 个微批次进行训练。

此时，流水线气泡的时间占比为： $\frac{(32 - 1)(4 - 1)}{32 \times 4} = \frac{31 \times 3}{128} \approx 0.73$ 约 73% 的时间是气泡时间，实际计算效率为 27% 左右。虽然比前面的例子有所提高，但仍然存在较大的优化空间。

4.3 T5 模型训练

T5 模型是一种大型的 Transformer 模型，训练时也会面临内存和计算资源的挑战。假设将 T5 模型划分为 12 个阶段，使用 64 个微批次进行训练。

流水线气泡的时间占比为： $\frac{(64 - 1)(12 - 1)}{64 \times 12} = \frac{63 \times 11}{768} \approx 0.90$ 约 90% 的时间是气泡时间，实际计算效率仅为 10% 左右。这表明在这种配置下，流水线并行的效率非常低，需要采取有效的优化措施。

5. 优缺点分析

5.1 优点

突破内存限制：模型并行可以将大型模型分布到多个设备上，从而突破单设备的内存限制，支持训练更大规模的模型。
提高计算效率：在理想情况下，流水线并行可以实现各阶段的并行计算，提高整体计算效率。
灵活性高：可以根据模型的结构和设备的配置，灵活地划分模型阶段，适应不同的训练需求。

5.2 缺点

流水线气泡问题：如前面分析所示，流水线并行会产生气泡时间，降低计算资源的利用率，影响训练效率。
通信开销大：各阶段之间需要频繁地传递数据，会产生较大的通信开销，进一步降低训练效率。
实现复杂度高：模型并行的实现相对复杂，需要考虑模型划分、数据流动、同步等多个方面的问题，增加了开发和调试的难度。

6. 优化策略分析

6.1 增加微批次数量

从前面的数学公式可以看出，增加微批次数量 M 可以降低气泡时间占比。当 M 足够大时，气泡时间占比会趋近于 0。然而，增加微批次数量也会增加内存消耗，需要在内存和效率之间进行权衡。

6.2 减少阶段数

减少模型划分的阶段数 S 也可以降低气泡时间占比。但阶段数过少可能会导致负载不均衡，部分设备的计算压力过大，而其他设备空闲。因此，需要根据模型的结构和设备的配置，合理地划分阶段数。

6.3 重叠计算和通信

通过重叠计算和通信操作，可以减少通信开销对训练效率的影响。例如，在某个阶段进行计算的同时，让其他阶段进行数据传输，从而提高整体效率。

6.4 动态调整流水线

根据各阶段的计算速度和通信延迟，动态调整流水线的执行顺序和节奏，尽量减少气泡时间。例如，对于计算速度较快的阶段，可以提前开始处理下一个微批次数据，以填补气泡。

7. 代码示例（基于 DeepSpeed）

import torch
import torch.nn as nn
import deepspeed

# 定义模型
class MyModel(nn.Module):
    def __init__(self, num_layers=12, hidden_size=768):
        super(MyModel, self).__init__()
        self.layers = nn.ModuleList([
            nn.TransformerEncoderLayer(d_model=hidden_size, nhead=12)
            for _ in range(num_layers)
        ])
    
    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

# 初始化DeepSpeed
model = MyModel()
args = {"deepspeed_config": "ds_config.json"}
model_engine, optimizer, _, _ = deepspeed.initialize(
    args=args,
    model=model,
    model_parameters=model.parameters()
)

# 训练循环
for epoch in range(10):
    for batch in dataloader:
        # 前向传播
        outputs = model_engine(batch)
        loss = criterion(outputs, labels)
        
        # 反向传播
        model_engine.backward(loss)
        
        # 优化步骤
        model_engine.step()