必知必会：大模型训练通信开销计算详解与面试指南

必知必会：大模型训练通信开销计算详解与面试指南

AI-Compass 致力于构建最全面、最实用、最前沿的AI技术学习和实践生态，通过六大核心模块的系统化组织，为不同层次的学习者和开发者提供完整学习路径。

• github地址：AI-Compass👈：https://github.com/tingaicompass/AI-Compass
• gitee地址：AI-Compass👈：https://gitee.com/tingaicompass/ai-compass

为什么通信开销很重要？

通信开销如同隐匿的丝线，牵动着大模型训练的每一个环节。在分布式训练中：

• 显存墙：单个计算设备无法容纳大模型训练时所需的显存
• 通信墙：系统内不同计算设备需要进行密集的数据传输以满足信息同步等要求

符号约定

1. 集合通信原语详解

1.1 核心问题

• 分布式训练中 GPU 之间有哪些基础通信方式？
• 各通信原语之间有什么组合关系？
• 不同并行策略分别依赖哪些通信原语？

1.2 原文核心要点

在分布式训练过程中，不同的 GPU 之间可以通过集合通信原语来传递模型参数、梯度等信息。核心原语包括 Broadcast、Scatter、Gather、Reduce、All-Gather、Reduce-Scatter、All-Reduce 和 All-to-All 八种，它们是所有并行策略的通信基石。

1.3 通俗理解

直观类比

想象你在一个快递分拣中心工作，有 4 个分拣员（GPU），每人负责一个区域的包裹：

• Broadcast（广播）：总部发了一张新的分拣规则表，复印 4 份发给每个分拣员——每人拿到的内容完全一样
• Scatter（分发）：一大批包裹到了，总部按目的地拆成 4 堆，每个分拣员只拿到自己负责区域的那堆——每人拿到的内容不同
• Gather（收集）：每个分拣员把自己分好的包裹送回总部汇总——多方汇聚到一处
• Reduce（规约）：4 个分拣员各自统计了自己区域的包裹数量，总部把 4 个数字加起来得到总数——汇总时带了"求和"计算
• All-Gather（全收集）：每个分拣员把自己的分拣清单分享给所有同事——每人最终都有完整的全局清单
• All-Reduce（全规约）：4 个分拣员各自统计包裹数，互相通信后每人都知道总数——边计算边共享
• All-to-All（全交换）：每个分拣员有 4 类包裹，分别发给对应的同事——每人既发又收，完全交换

核心要点

• 原语是所有并行策略的通信积木，掌握原语就掌握了通信开销计算的基础
• All-Reduce 是最核心的原语，它可以分解为 Reduce-Scatter + All-Gather
• 不同原语对应不同的并行场景：数据并行用 All-Reduce，ZeRO 用 Reduce-Scatter + All-Gather，专家并行用 All-to-All

建立了直觉之后，下面我们用具体的示意图和对比表来严格定义这些通信原语。

1.4 八大通信原语

1. Broadcast（广播）

一个发送者，多个接收者

将一个GPU的完整数据复制到所有其他GPU上。

操作前:                    操作后:
┌───┬───┬───┬───┐         ┌───┬───┬───┬───┐
│ A │   │   │   │   →     │ A │ A │ A │ A │
└───┴───┴───┴───┘         └───┴───┴───┴───┘
GPU0 GPU1 GPU2 GPU3       GPU0 GPU1 GPU2 GPU3

应用场景：模型初始化时，将主节点的参数广播到所有工作节点。

2. Scatter（分发）

一个发送者，多个接收者（数据分片）

将一个GPU的数据切片后分发给不同GPU，每个GPU获得不同的部分。

操作前:                    操作后:
┌─────────────┐            ┌───┬───┬───┬───┐
│ A │ B │ C │ D │    →     │ A │ B │ C │ D │
└─────────────┘            └───┴───┴───┴───┘
    GPU0                   GPU0 GPU1 GPU2 GPU3

与Broadcast的区别：

• Broadcast：每个GPU收到完整相同的数据
• Scatter：每个GPU收到不同的数据片段

3. Gather（收集）

多个发送者，一个接收者

将多个GPU的数据收集到一个GPU上。

操作前:                    操作后:
┌───┬───┬───┬───┐         ┌─────────────┐
│ A │ B │ C │ D │    →    │ A │ B │ C │ D │  （其他GPU为空）
└───┴───┴───┴───┘         └─────────────┘
GPU0 GPU1 GPU2 GPU3            GPU0

4. Reduce（规约）

多个发送者，一个接收者（带计算）

将多个GPU的数据规约运算（如求和SUM、求最大值MAX、求乘积PROD）后发送到一个GPU。

操作前:                    操作后:
┌───┬───┬───┬───┐         ┌───────────────┐
│ A │ B │ C │ D │    →    │ A+B+C+D       │  （其他GPU为空）
└───┴───┴───┴───┘         └───────────────┘
GPU0 GPU1 GPU2 GPU3            GPU0

5. All-Gather（全收集）

多个发送者，多个接收者

= Gather + Broadcast

每个GPU都收集到所有GPU的数据。

操作前:                    操作后:
┌───┬───┬───┬───┐         ┌─────────────┬─────────────┬─────────────┬─────────────┐
│ A │ B │ C │ D │    →    │ A,B,C,D     │ A,B,C,D     │ A,B,C,D     │ A,B,C,D     │
└───┴───┴───┴───┘         └─────────────┴─────────────┴─────────────┴─────────────┘
GPU0 GPU1 GPU2 GPU3       GPU0          GPU1          GPU2          GPU3

6. Reduce-Scatter（规约分发）

多个发送者，多个接收者

在所有GPU上按维度执行相同的Reduce操作，再将结果发散到集群内所有GPU上。

操作前:                              操作后:
GPU0: [A0,A1,A2,A3]                 GPU0: [A0+B0+C0+D0]
GPU1: [B0,B1,B2,B3]       →         GPU1: [A1+B1+C1+D1]
GPU2: [C0,C1,C2,C3]                 GPU2: [A2+B2+C2+D2]
GPU3: [D0,D1,D2,D3]                 GPU3: [A3+B3+C3+D3]

7. All-Reduce（全规约）

多个发送者，多个接收者

= Reduce + Broadcast = Reduce-Scatter + All-Gather

在集群内所有GPU上都执行相同的Reduce操作，并将结果发送到所有GPU上。

操作前:                    操作后:
┌───┬───┬───┬───┐         ┌─────────┬─────────┬─────────┬─────────┐
│ A │ B │ C │ D │    →    │ A+B+C+D │ A+B+C+D │ A+B+C+D │ A+B+C+D │
└───┴───┴───┴───┘         └─────────┴─────────┴─────────┴─────────┘
GPU0 GPU1 GPU2 GPU3       GPU0      GPU1      GPU2      GPU3

8. All-to-All（全交换）

多个发送者，多个接收者（完全交换）

每个GPU将自己的数据发散到所有GPU，同时收集所有GPU的数据。

操作前:                              操作后:
GPU0: [A0,A1,A2,A3]                 GPU0: [A0,B0,C0,D0]
GPU1: [B0,B1,B2,B3]       →         GPU1: [A1,B1,C1,D1]
GPU2: [C0,C1,C2,C3]                 GPU2: [A2,B2,C2,D2]
GPU3: [D0,D1,D2,D3]                 GPU3: [A3,B3,C3,D3]

与All-Gather的区别：

• All-Gather：不同GPU向某一GPU收集到的数据相同
• All-to-All：不同GPU向某一GPU收集到的数据不同

1.5 通信原语对比表

<!-- trick-image:start idx=1 platform=blog -->

<!-- trick-image:end idx=1 -->

组合关系：

• All-Reduce = Reduce + Broadcast = Reduce-Scatter + All-Gather
• All-Gather = Gather + Broadcast

1.6 小结

2. 数据并行的通信开销计算

2.1 核心问题

• 数据并行的工作原理是什么？
• 朴素 All-Reduce 和 Ring-All-Reduce 的通信量分别是多少？
• Ring-All-Reduce 为什么更高效？

2.2 原文核心要点

数据并行策略中，每个 GPU 保存完整模型副本，训练数据被拆分。各 GPU 计算梯度后通过 All-Reduce 同步。Ring-All-Reduce 通过环形拓扑将通信量均匀分配到每个 GPU，避免单点瓶颈。单卡通信量为 2×(N-1)×Φ/N ≈ 2Φ。

2.3 通俗理解

直观类比

想象你在一个班级里做小组作业：

朴素方式（班长汇总法）：30 个同学各做一份答案，全部交给班长。班长一个人汇总 29 份答案，算出最终版本，再抄 29 份发回去。班长累得半死，其他人在旁边等着——这就是单点瓶颈。

Ring 方式（传话游戏法）：30 个同学围成一个圈，每人把答案分成 30 段。第一轮，每人把第 1 段传给右边的同学并加上自己的；第二轮继续传递第 2 段……经过 29 轮传递，每人手上都有了完整汇总结果。虽然传了很多轮，但每轮每人只处理一小段，没有人特别累。

核心要点

• 朴素 All-Reduce 的总通信量和 Ring-All-Reduce 相近（~2NΦ），但负载分布天差地别
• Ring-All-Reduce 分为 Reduce-Scatter 和 All-Gather 两阶段，各需 N-1 次通信
• 实际工程中几乎都用 Ring-All-Reduce，因为它消除了单点瓶颈

建立了直觉之后，下面我们用数学公式来严格定义通信量的计算方法，并给出具体的数值示例。

2.4 技术原理与公式推导

掌握了直观类比后，接下来我们用精确的数学语言来刻画通信量的计算方法。这样在实际工作中就能准确预估不同配置下的通信开销。

工作原理

在数据并行策略中：

1. 每一个GPU上都保存一份完整的模型副本
2. 训练数据被拆分成多份，分配给不同的GPU
3. 每个GPU对所接收的数据进行前向传播和反向传播，计算出一份梯度
4. 这份梯度被传送给负责梯度收集的GPU做聚合操作（一般是梯度累加）
5. 聚合完成后，负责梯度计算的GPU会从负责梯度收集的GPU处拉取完整的梯度结果并更新模型参数

两种 All-Reduce 实现方式

方式一：朴素 All-Reduce

假设有N个GPU参与数据并行，其中：

• 1个GPU负责梯度收集
• N-1个GPU负责梯度计算

通信开销公式：

$$
C_{\text{naive}} = 2 \times N \times \Phi
$$

通信过程：

1. 负责梯度收集的GPU承载的通信量：(N-1) × Φ
2. 每个负责梯度计算的GPU的通信量：Φ
3. 所有负责梯度计算的GPU通信总量：(N-1) × Φ

问题：当N增大时，整个系统的总通信量约为 2 × N × Φ，且收集梯度的GPU成为瓶颈。

数值计算示例：

假设用 4 张 GPU 训练 LLaMA-7B（Φ = 7B）：

$$
C_{\text{naive}} = 2 \times 4 \times 7\text{B} \times 2\text{B/param} = 112 \text{ GB}
$$

方式二：Ring-All-Reduce（环形全规约）

核心思想：将数据切分成N份，通过环形拓扑结构进行传输，避免单点瓶颈。

两个阶段：

阶段1：Reduce-Scatter

• 将数据切分成N份
• 进行N-1次通信
• 每次通信量：Φ/N
• 最终每个GPU拥有一个大小为Φ/N的完整梯度片段

阶段2：All-Gather

• 进行N-1次通信
• 每个GPU将自身拥有的大小为Φ/N的完整梯度发送给相邻的GPU
• 最终所有GPU都拥有完整梯度

可视化流程：

为了更直观理解Ring-All-Reduce的工作原理,下图展示了4个GPU环形拓扑下的两阶段数据流动:

flowchart TD
    subgraph RS["阶段1: Reduce-Scatter (3轮)"]
        direction LR
        RS1["轮1: GPU0→GPU1→GPU2→GPU3→GPU0<br/>各GPU聚合1/4数据"]
        RS2["轮2: 继续环形传递并聚合<br/>每GPU完成2/4数据片段"]
        RS3["轮3: 最后一轮传递<br/>每GPU持有完整的1/4梯度"]
        RS1 --> RS2 --> RS3
    end

    subgraph AG["阶段2: All-Gather (3轮)"]
        direction LR
        AG1["轮1: GPU0→GPU1→GPU2→GPU3→GPU0<br/>各GPU收集1/4完整梯度"]
        AG2["轮2: 继续环形传递<br/>每GPU拥有2/4完整梯度"]
        AG3["轮3: 最后一轮传递<br/>所有GPU拥有完整梯度"]
        AG1 --> AG2 --> AG3
    end

    RS --> AG

    style RS fill:#e1f5ff
    style AG fill:#fff4e1

上图说明:

• Reduce-Scatter阶段: 数据切4份,环形传递3轮,每轮传输Φ/4,每GPU最终持有1/4的完整聚合梯度
• All-Gather阶段: 将完整梯度片段环形传递3轮,每GPU收集其他GPU的完整片段,最终所有GPU拥有完整梯度
• 每卡通信量: (3 × Φ/4) × 2 = 1.5Φ × 2 = 3Φ/2 ≈ 2Φ (当N较大)

单个GPU通信量公式：

$$
C_{\text{Ring}} = 2 \times \frac{N-1}{N} \times \Phi \approx 2\Phi \quad (\text{当 } N \text{ 较大时})
$$

推导过程：

$$
C_{\text{Ring}} = \underbrace{(N-1) \times \frac{\Phi}{N}}_{\text{Reduce-Scatter}} + \underbrace{(N-1) \times \frac{\Phi}{N}}_{\text{All-Gather}} = 2 \times \frac{(N-1) \times \Phi}{N}
$$

整个系统通信量：

$$
C_{\text{Ring,total}} = N \times C_{\text{Ring}} = 2 \times (N-1) \times \Phi \approx 2N\Phi
$$

数值计算示例：

同样 4 张 GPU 训练 LLaMA-7B（Φ = 7B）：

$$
C_{\text{Ring}} = 2 \times \frac{4-1}{4} \times 7\text{B} \times 2\text{B/param} = 2 \times \frac{3}{4} \times 14\text{ GB} = 21 \text{ GB}
$$

2.5 两种方式对比

<!-- trick-image:start idx=2 platform=blog -->

<!-- trick-image:end idx=2 -->

关键结论：Ring-All-Reduce的总通信量与朴素All-Reduce接近，但每个GPU上的通信量更为均衡，从而缓解了通信瓶颈问题。

2.6 小结

3. 张量并行的通信开销计算

3.1 核心问题

• 张量并行如何切分模型参数？
• 前馈网络层和注意力层各需要几次 All-Reduce？
• 一个完整 Transformer 层的通信量是多少？

3.2 原文核心要点

张量并行将模型参数切分成多个参数块放到不同 GPU 上独立计算，最后聚合结果。Megatron-LM 将 FFN 层的第一个矩阵按列切分、第二个按行切分，前向和反向传播各需一次 All-Reduce。一个完整 Transformer 层的总通信量为 8×b×s×h。

3.3 通俗理解

直观类比

想象你和同事一起做一张超大的拼图（矩阵乘法）：

拼图太大了，一个人的桌子放不下。于是你们把拼图纵向切成两半，一人拼左半边，一人拼右半边。拼完各自的部分后，需要把结果拼到一起看全貌——这就是前向传播的 All-Reduce。

发现有几块拼错了（反向传播计算梯度），你们各自修正自己那半边的错误，修好后再汇总一次看哪些地方还需要调整——这就是反向传播的 All-Reduce。

一个 Transformer 层有两大组件（注意力 + FFN），每个组件都要"拼一次 + 修一次"，所以一共需要 4 次 All-Reduce，总通信量为 8 × b × s × h。

核心要点

• 张量并行的通信发生在每一层的前向和反向传播中，频率远高于数据并行
• 通信量与激活值大小 b×s×h 成正比，而非模型参数量 Φ
• 因此张量并行适合用在机内高带宽互联（NVLink 600 GB/s）的 GPU 之间

建立了直觉之后，下面我们用数学公式来严格推导张量并行的通信量。

3.4 技术原理与公式推导

<!-- trick-image:start idx=3 platform=blog -->

<!-- trick-image:end idx=3 -->

理解了"拼图"的直觉后，下面我们看看 Megatron-LM 如何在工程上实现这个切分策略，以及通信量的精确计算方法。

Megatron-LM 切分方法

张量并行策略的基本思路：

1. 将模型的参数切分成多个参数块
2. 将不同的参数块放到不同的GPU上进行独立计算
3. 最后将计算的结果进行聚合以完成训练

以Transformer模型为例，主要涉及：

• 词嵌入层（通信开销较小）
• 前馈神经网络层（FFN）
• 多头注意力层

前馈神经网络层的通信开销

前馈神经网络层的计算分为两步：

Y = GELU(XA)    # 第一个线性层 + 激活函数
Z = Dropout(YB)  # 第二个线性层 + Dropout

其中：

• X是输入数据，维度为(b, s, h)
• A是第一个全连接层，维度为(h, h')，通常h' = 4h
• B是第二个全连接层，维度为(h', h)

张量切分方式：

• A沿着列维度切分：A = [A₁, A₂]
• B沿着行维度切分：B = [B₁, B₂]ᵀ

可视化数据流：

下图展示了2-GPU张量并行下FFN层的矩阵切分和通信流程:

flowchart TD
    subgraph Input["输入 X (b,s,h)"]
        X[X 在各GPU复制]
    end

    subgraph GPU1["GPU 1"]
        A1["A₁ 列切分<br/>(h, h'/2)"]
        Y1["Y₁ = GELU(XA₁)<br/>(b,s,h'/2)"]
        B1["B₁ 行切分<br/>(h'/2, h)"]
        Z1["Z₁ = Y₁B₁<br/>(b,s,h)"]
    end

    subgraph GPU2["GPU 2"]
        A2["A₂ 列切分<br/>(h, h'/2)"]
        Y2["Y₂ = GELU(XA₂)<br/>(b,s,h'/2)"]
        B2["B₂ 行切分<br/>(h'/2, h)"]
        Z2["Z₂ = Y₂B₂<br/>(b,s,h)"]
    end

    subgraph AR["All-Reduce"]
        Z_final["Z = Z₁ + Z₂<br/>(b,s,h)"]
    end

    X --> A1
    X --> A2
    A1 --> Y1 --> B1 --> Z1
    A2 --> Y2 --> B2 --> Z2
    Z1 --> Z_final
    Z2 --> Z_final

    style AR fill:#ffe1e1
    style GPU1 fill:#e1f5ff
    style GPU2 fill:#e1ffe1

上图说明:

• 输入X: 在各GPU上复制,无需通信
• 矩阵A列切分: 每GPU计算一半输出通道(h' = 4h的一半)
• 矩阵B行切分: 每GPU的输出Z₁、Z₂需通过All-Reduce聚合
• 通信点: 前向传播1次All-Reduce(聚合Z),反向传播1次All-Reduce(聚合∂L/∂X)

通信过程示意：

前向传播:
┌─────────────────────────────────────────────────────────────┐
│  输入X → [复制到各GPU] → GPU₁计算XA₁  → GELU → Y₁B₁ → Z₁   │
│                        → GPU₂计算XA₂  → GELU → Y₂B₂ → Z₂   │
│                                                    ↓        │
│                                          [All-Reduce聚合Z]  │
└─────────────────────────────────────────────────────────────┘

反向传播:
┌─────────────────────────────────────────────────────────────┐
│  ∂L/∂Z → [分发到各GPU] → GPU₁计算梯度                       │
│                        → GPU₂计算梯度                       │
│                                    ↓                        │
│                          [All-Reduce聚合∂L/∂X]              │
└─────────────────────────────────────────────────────────────┘

FFN 层通信开销公式：

每次 All-Reduce 的通信量等效于一次 Reduce-Scatter + 一次 All-Gather，数据大小为 $b \times s \times h$：

$$
C_{\text{AllReduce}} = 2 \times b \times s \times h
$$

前向传播 1 次 + 反向传播 1 次 = 2 次 All-Reduce：

$$
C_{\text{FFN}} = 2 \times C_{\text{AllReduce}} = 4 \times b \times s \times h
$$

数值计算示例：

假设 LLaMA-7B 的一个 Transformer 层，使用 2 路张量并行：

$$
C_{\text{FFN}} = 4 \times 4 \times 2048 \times 4096 \times 2\text{B} = 256 \text{ MB}
$$

多头注意力层的通信开销

多头注意力层在张量并行下的通信结构与 FFN 层相同：

• 前向传播：1次All-Reduce
• 反向传播：1次All-Reduce

$$
C_{\text{Attn}} = 4 \times b \times s \times h
$$

完整 Transformer 层通信开销

对一个包含前馈网络层和多头注意力层的Transformer来说：

$$
C_{\text{layer}} = C_{\text{FFN}} + C_{\text{Attn}} = 4bsh + 4bsh = 8 \times b \times s \times h
$$

数值计算示例（续上例）：

$$
C_{\text{layer}} = 8 \times 4 \times 2048 \times 4096 \times 2\text{B} = 512 \text{ MB}
$$

3.5 小结

4. 流水线并行的通信开销计算

4.1 核心问题

• 流水线并行如何切分模型？
• 前向和反向传播的通信量分别是多少？
• GPipe 如何优化流水线并行？

4.2 原文核心要点

流水线并行将模型的不同层拆分到不同 GPU 上，前向传播时逐层传递激活值，反向传播时逐层回传梯度。总通信量为 2×(N-1)×b×s×h，通信方式为点对点（P2P）传输。GPipe 通过微批次（micro-batch）机制提高 GPU 利用率。

4.3 通俗理解

直观类比

想象一条汽车生产流水线：

车间 1 负责焊接车架，车间 2 负责安装发动机，车间 3 负责喷漆，车间 4 负责装内饰。每辆车依次经过 4 个车间。

• 前向传播：车架焊好后从车间 1 送到车间 2（传递激活值），发动机装好后送到车间 3……一共需要在 3 个车间之间传递半成品
• 反向传播：质检发现问题后，从车间 4 开始逐步回溯哪个环节出了问题（回传梯度），同样经过 3 个车间间的传递
• GPipe 优化：不是等一辆车完全做完再做下一辆，而是把一批车切成小批次，像"流水线"一样同时开工多辆车，减少车间的空闲等待时间

核心要点

• 流水线并行的通信是点对点（P2P），只在相邻 GPU 之间传递
• 通信量公式：2×(N-1)×b×s×h，与切分点数量和激活值大小成正比
• 流水线并行通信量通常远小于张量并行，但有气泡问题（GPU 空闲等待）

建立了直觉之后，下面我们用数学公式来严格推导流水线并行的通信量。

4.4 技术原理与公式推导

有了"汽车生产流水线"的直觉，现在我们用数学公式来精确计算流水线并行的通信量，并理解 GPipe 是如何通过 micro-batch 提升效率的。

工作原理

对于朴素的流水线并行，其主要思想是将模型的不同层进行拆分，然后放到不同的GPU上。

前向传播过程：

1. 放置了模型第一层的GPU先进行前向传播
2. 将该层的输出传给放置了第二层的GPU
3. 以此类推，直到所有层都依次完成前向传播

反向传播过程：

1. 从放置了模型最后一层的GPU开始
2. 依次在不同GPU上计算不同层的梯度
3. 当所有层的梯度都完成计算后，才对模型的权重进行更新

流水线并行模型示意图:

                    模型输出计算损失L
                          ↑
┌─────────────────────────────────────┐
│         模型最后一层        │ GPU_N │ ←─┐
├─────────────────────────────────────┤    │
│              ...             │ ...  │    │ 反向传播
├─────────────────────────────────────┤    │ ∂L/∂Z_N-1, ..., ∂L/∂Z_1
│           模型层2           │ GPU_2 │    │
├─────────────────────────────────────┤    │
│           模型层1           │ GPU_1 │ ←─┘
└─────────────────────────────────────┘
     ↑                    │
   输入                   │ 前向传播
 MiniBatch               │ Z_1, Z_2, ..., Z_N-1
     ↓                    ↓
[MicroBatch₁] [MicroBatch₂] ... [MicroBatch_n]

GPipe 方法与通信开销

GPipe是一种经典的流水线并行方法，通过引入micro-batch（微批次）处理和激活值重算机制，有效解决了朴素流水线并行所存在的GPU利用率过低以及中间结果消耗过大的问题。

通信开销公式：

假设：

• mini-batch的大小是b
• 模型被切分到N个GPU上
• 分布在不同GPU之间的中间结果Z的维度大小为(b, s, h)

前向传播通信量（N-1 个中间结果）：

$$
C_{\text{forward}} = (N-1) \times b \times s \times h
$$

反向传播通信量（N-1 个偏导数）：

$$
C_{\text{backward}} = (N-1) \times b \times s \times h
$$

流水线并行总通信量：

$$
C_{\text{PP}} = C_{\text{forward}} + C_{\text{backward}} = 2 \times (N-1) \times b \times s \times h
$$

数值计算示例：

假设 LLaMA-7B（32 层）使用 4 路流水线并行，每个 GPU 放 8 层：

$$
C_{\text{PP}} = 2 \times (4-1) \times 4 \times 2048 \times 4096 \times 2\text{B} = 2 \times 3 \times 64\text{ MB} = 384 \text{ MB}
$$

对比：同配置下张量并行总通信量为 16 GB，流水线并行仅 384 MB——但流水线并行有"气泡"（idle time）问题。

4.5 小结

5. ZeRO 优化技术的通信开销计算

5.1 核心问题

• ZeRO 三个级别分别切分什么内容？
• 为什么 ZeRO-1/2 的通信量与数据并行相同？
• ZeRO-3 额外增加了多少通信开销？

5.2 原文核心要点

ZeRO（Zero Redundancy Optimizer）分三个级别：ZeRO-1 切分优化器状态，ZeRO-2 额外切分梯度，ZeRO-3 进一步切分模型参数。ZeRO-1/2 单卡通信量均为 2Φ（与数据并行相同），ZeRO-3 为 3Φ（增加 50%），但换取了与 GPU 数量成正比的显存节省。

5.3 通俗理解

直观类比

想象你和 7 个同学一起背一本 700 页的词典：

• 数据并行（不用 ZeRO）：每人都买一本完整的词典（700 页），各自背不同的章节做练习，做完后互相对答案。问题是每人都得揣着一本厚词典——书包装不下！
• ZeRO-1：每人还是各有一本词典和一本笔记本（参数+梯度），但 8 本参考书（优化器状态）只买 1 套，每人保管 1 本。背完对答案时，需要找到保管对应参考书的同学来核对——沟通量不变，但书包轻了。
• ZeRO-2：词典还是每人一本，但笔记本和参考书都只各买 1 套分着保管。书包更轻了，沟通量还是一样。
• ZeRO-3：连词典都只买 1 套，700 页拆成 8 份每人 87 页。每次要查别的部分时得找同学借（All-Gather），查完立刻还回去。多了"借书还书"的麻烦（+50% 通信），但每人只需要带 87 页——书包最轻。

核心要点

• ZeRO-1/2 通信量 = 2Φ，与数据并行完全相同（因为 Reduce-Scatter + All-Gather = All-Reduce）
• ZeRO-3 多出的 1Φ 来自前向和反向传播时各需一次 All-Gather 收集参数
• 核心权衡：通信量增加 50%，换取显存线性扩展

建立了直觉之后，下面我们用数学公式来严格分析 ZeRO 各级别的通信开销。

5.4 技术原理与公式推导

理解了"词典分工"的类比后，现在我们详细剖析 ZeRO 三个层次的通信流程和通信量计算，看看为什么 ZeRO-3 要付出 50% 的额外通信代价。

ZeRO-1：优化器状态分片

特点：

• 每个GPU都存有一份完整的模型参数
• 每个GPU只存有部分优化器状态

通信过程：

1. 前向传播 + 反向传播后：每个GPU各自得到一份梯度

2. Reduce-Scatter：对梯度进行聚合，每个GPU得到部分聚合梯度

   • 单卡通信量：Φ
3. 参数更新：各GPU使用自己的优化器状态更新对应部分参数

4. All-Gather：从其他GPU上把更新好的部分模型参数取回来

   • 单卡通信量：Φ

ZeRO-1 单卡通信量公式：

$$
C_{\text{ZeRO-1}} = \underbrace{\Phi}_{\text{Reduce-Scatter}} + \underbrace{\Phi}_{\text{All-Gather}} = 2\Phi
$$

ZeRO-2：优化器状态 + 梯度分片

特点：

• 每个GPU都存有一份完整的模型参数
• 每个GPU只存有部分优化器状态和部分梯度

通信过程：

1. 前向传播后，反向传播时需要Reduce-Scatter获取其他GPU的梯度

   • 单卡通信量：Φ

2. All-Gather：从其他GPU上把完成梯度更新的部分模型参数取回来

   • 单卡通信量：Φ

ZeRO-2 单卡通信量公式：

$$
C_{\text{ZeRO-2}} = \underbrace{\Phi}_{\text{Reduce-Scatter}} + \underbrace{\Phi}_{\text{All-Gather}} = 2\Phi
$$

ZeRO-3：优化器状态 + 梯度 + 参数分片

特点：

• 每个GPU只存有部分模型参数
• 每个GPU只存有部分优化器状态和部分梯度

通信过程：

前向传播：

1. 需要完整模型参数，因此需要逐层All-Gather收集模型参数

2. 每一层完成前向传播后，立即把不属于自己维护的模型参数丢弃

   • 单卡通信量：Φ

反向传播：

1. 需要使用梯度结果对原始参数求偏导数，因此需要逐层All-Gather

2. 每一层完成反向传播后，立即把不属于自己维护的模型参数丢弃

   • 单卡通信量：Φ

参数更新：

1. 每个GPU各自都会得到一份梯度

2. 需要Reduce-Scatter获得完整的聚合梯度用于更新模型参数

   • 单卡通信量：Φ

ZeRO-3 单卡通信量公式：

$$
C_{\text{ZeRO-3}} = \underbrace{\Phi}_{\text{前向 All-Gather}} + \underbrace{\Phi}_{\text{反向 All-Gather}} + \underbrace{\Phi}_{\text{Reduce-Scatter}} = 3\Phi
$$

5.5 ZeRO 通信开销对比

<!-- trick-image:start idx=4 platform=blog -->

<!-- trick-image:end idx=4 -->

关键结论：ZeRO-3通过更激进的分片策略换取更大的显存节省，但代价是增加了50%的通信开销（从2Φ增加到3Φ）。

ZeRO-3 相对 ZeRO-2 的额外通信量比例：

$$
\frac{C_{\text{ZeRO-3}} - C_{\text{ZeRO-2}}}{C_{\text{ZeRO-2}}} = \frac{3\Phi - 2\Phi}{2\Phi} = 50\%
$$

数值计算示例：

以 LLaMA-7B（Φ = 7B）在 8 张 GPU 上训练为例：

$$
C_{\text{ZeRO-1}} = C_{\text{ZeRO-2}} = 2 \times 7\text{B} \times 2\text{B/param} = 28 \text{ GB}
$$

$$
C_{\text{ZeRO-3}} = 3 \times 7\text{B} \times 2\text{B/param} = 42 \text{ GB}
$$

结论：ZeRO-3 多付出 14 GB 通信开销，但单卡显存从 112 GB 降到 14 GB，使 7B 模型可以在 8 张 A100-80G 上训练。

5.6 小结

6. 通信开销综合对比与选型指南

6.1 各并行策略通信量汇总

6.2 选型决策流程

<!-- trick-image:start idx=5 platform=blog -->

<!-- trick-image:end idx=5 -->

下图展示了并行策略的选型决策流程：

flowchart TD
    A[模型能放进单卡?] -->|是| B[使用数据并行 DP]
    A -->|否| C[显存主要被优化器占用?]
    C -->|是| D[使用 ZeRO-1/2]
    C -->|否| E[单层参数能放进单卡?]
    E -->|是| F[流水线并行 PP]
    E -->|否| G[张量并行 TP]
    F --> H[超大规模模型?]
    G --> H
    D --> H
    H -->|是| I[3D并行: DP + TP + PP]
    H -->|否| J[当前策略即可]
    I --> K[TP 优先机内 NVLink]
    I --> L[PP 用于跨机相邻层]
    I --> M[DP 用于机间通信]

上图展示了从单卡到 3D 并行的选型路径：优先考虑简单策略，逐步引入更复杂的并行方式。

6.3 3D 并行配置示例

下图展示了 3D 并行中三个维度的协同关系：

flowchart LR
    subgraph DP["数据并行 (DP=2)"]
        subgraph PP1["流水线并行 (PP=4)"]
            subgraph TP1["张量并行 (TP=4)"]
                G1[GPU 0] --- G2[GPU 1]
                G2 --- G3[GPU 2]
                G3 --- G4[GPU 3]
            end
            subgraph TP2["张量并行 (TP=4)"]
                G5[GPU 4] --- G6[GPU 5]
                G6 --- G7[GPU 6]
                G7 --- G8[GPU 7]
            end
            TP1 -->|激活值 P2P| TP2
        end
        subgraph PP2["流水线并行 (PP=4)"]
            subgraph TP3["张量并行 (TP=4)"]
                G9[GPU 16] --- G10[GPU 17]
            end
            subgraph TP4["张量并行 (TP=4)"]
                G11[GPU 20] --- G12[GPU 21]
            end
            TP3 -->|激活值 P2P| TP4
        end
        PP1 -.->|梯度 All-Reduce| PP2
    end

上图展示了 32 GPU 的 3D 并行布局：TP=4 使用机内 NVLink，PP=4 用于层间传递，DP=2 用于机间梯度同步。

6.4 3D 并行通信开销

配置示例（32 GPU）：

• 数据并行度 $D_{\text{dp}} = 2$
• 张量并行度 $D_{\text{tp}} = 4$
• 流水线并行度 $D_{\text{pp}} = 4$

3D 并行各维度通信量公式：

$$
C_{\text{TP}} = 8 \times b \times s \times h \quad \text{（每层，All-Reduce 激活值）}
$$

$$
C_{\text{PP}} = 2 \times (D_{\text{pp}} - 1) \times b \times s \times h \quad \text{（P2P 传递激活值）}
$$

$$
C_{\text{DP}} = \frac{2\Phi}{D_{\text{tp}} \times D_{\text{pp}}} \quad \text{（All-Reduce 梯度）}
$$

设计原则：

1. TP优先使用机内通信：NVLink带宽高（600 GB/s）
2. PP次之：相邻层尽量在同机器
3. DP使用机间通信：通信频率最低，对带宽要求最低

6.5 通信优化方法

7. 高频面试题及答案

Q1: 请解释 All-Reduce 和 Ring-All-Reduce 的区别？（基础）

答案：
两者目标相同（让所有 GPU 拥有完整规约结果），但实现方式不同。朴素 All-Reduce 由一个节点收集聚合再广播，存在单点瓶颈；Ring-All-Reduce 通过环形拓扑分 Reduce-Scatter 和 All-Gather 两阶段完成，每卡通信量均为 2×(N-1)×Φ/N ≈ 2Φ，负载均衡无瓶颈。

详细说明：

公式：

$$
C_{\text{Ring}} = 2 \times \frac{N-1}{N} \times \Phi \approx 2\Phi
$$

Q2: 数据并行和张量并行的通信开销有什么区别？（基础）

答案：
数据并行通信量为 2Φ，仅在反向传播后同步梯度；张量并行通信量为 8×b×s×h（每层），在每层的前向和反向传播中都需要通信。前者与模型参数量成正比，后者与激活值大小成正比。

详细说明：

Q3: ZeRO-1、ZeRO-2、ZeRO-3 的区别及通信开销？（进阶）

答案：
ZeRO-1 切分优化器状态，ZeRO-2 额外切分梯度，ZeRO-3 进一步切分参数。ZeRO-1/2 单卡通信量为 2Φ（与 DP 相同），ZeRO-3 为 3Φ（增加 50%），但显存节省与 GPU 数量成正比。

详细说明：

公式：

$$
C_{\text{ZeRO-1}} = C_{\text{ZeRO-2}} = 2\Phi, \quad C_{\text{ZeRO-3}} = 3\Phi
$$

ZeRO-1/2 通信量与 DP 相同的原因：Reduce-Scatter + All-Gather = All-Reduce。ZeRO-3 多出的 1Φ 来自前向和反向传播各一次 All-Gather。

Q4: 流水线并行的通信开销公式是什么？如何理解？（进阶）

答案：
公式为 2×(N-1)×b×s×h。N-1 是切分点数，b×s×h 是激活值大小，×2 因为前向和反向各传一次。通信方式为 P2P，仅相邻 GPU 之间传递。

详细说明：

公式：

$$
C_{\text{PP}} = 2 \times (N-1) \times b \times s \times h
$$

Q5: 什么是集合通信原语？请列举并解释主要原语（基础）

答案：
集合通信原语是分布式系统中多节点间数据传输的基本操作，共 8 种。按模式分为 1→N（Broadcast/Scatter）、N→1（Gather/Reduce）、N→N（All-Gather/Reduce-Scatter/All-Reduce/All-to-All）三类。

详细说明：

Q6: 在万卡集群中，为什么说"优化器状态可以忽略不计"？（进阶）

答案：
在 3D 并行（DP×TP×PP）环境下，优化器状态被所有 GPU 分担。1024 卡集群中，优化器状态每卡只需存储 12Φ/1024 ≈ 0.012Φ，相比参数和梯度的 2Φ/(TP×PP) 占比极小。

详细说明：

公式：

$$
M_{\text{per\_gpu}} = \frac{2\Phi}{D_{\text{tp}} \times D_{\text{pp}}} + \frac{2\Phi}{D_{\text{tp}} \times D_{\text{pp}}} + \frac{12\Phi}{D_{\text{dp}} \times D_{\text{tp}} \times D_{\text{pp}}}
$$

Q7: 张量并行中，前馈神经网络层为什么需要 2 次 All-Reduce？（进阶）

答案：
FFN 层包含两步线性变换（Y=GELU(XA), Z=Dropout(YB)），A 按列切分、B 按行切分。前向传播需 All-Reduce 聚合 Z，反向传播需 All-Reduce 聚合 ∂L/∂X，各一次共 2 次，通信量 4×b×s×h。

详细说明：

公式：

$$
C_{\text{FFN}} = 2 \times C_{\text{AllReduce}} = 2 \times 2bsh = 4bsh
$$

Q8: 比较数据并行和 ZeRO 的通信开销（进阶）

答案：
ZeRO-1/2 通信量为 2Φ，与数据并行完全相同，因为 Reduce-Scatter + All-Gather = All-Reduce。ZeRO-3 通信量为 3Φ，多出的 1Φ 来自前向和反向传播各一次 All-Gather 收集参数。

详细说明：

核心权衡：ZeRO-3 用 50% 额外通信换取线性显存扩展能力。

Q9: 3D 并行是什么？如何计算其通信开销？（综合）

答案：
3D 并行组合数据并行（DP）、张量并行（TP）、流水线并行（PP）。TP 使用机内 NVLink 高带宽，PP 用于层间传递，DP 用于机间梯度同步。

详细说明：

设计原则：TP 优先机内（带宽最高）→ PP 次之 → DP 用于机间（频率最低）。

Q10: 如何优化大模型训练的通信效率？（进阶）

答案：
六大优化手段：通信计算重叠、梯度累积减少频率、梯度压缩减少数据量、Bucket 融合降低启动开销、分层 All-Reduce 减少跨机流量、拓扑感知调度匹配物理拓扑。

详细说明：

Q11: Ring-All-Reduce 的通信步数和带宽利用率如何计算？（进阶）

答案：
Ring-All-Reduce 需要 2×(N-1) 步通信，每步传输 Φ/N 数据。在理想情况下，所有 GPU 在每一步都同时收发数据，带宽利用率接近 100%。延迟与 N 成正比，但单步传输量与 N 成反比，总传输量与 N 无关。

详细说明：

公式：

$$
T_{\text{Ring}} = 2(N-1) \times \left( \alpha + \frac{\Phi}{N \times \beta} \right)
$$

其中 $\alpha$ 为单次通信延迟，$\beta$ 为链路带宽。

Q12: 如果同时使用 ZeRO-3 和张量并行，通信开销如何叠加？（综合）

答案：
两者的通信是独立叠加的。ZeRO-3 的 3Φ 通信量针对模型参数的收集和梯度聚合（跨数据并行组），张量并行的 8bsh/层通信量针对激活值的聚合（机内 TP 组）。实际中 ZeRO-3 通常与 DP 配合，而非与 TP 同时使用，因为 TP 本身已经切分了参数。

详细说明：

8. 大厂常见面试题

本节面试题来源于互联网公开的大厂面试真题和高频考点。

Q13: 在实际训练中，如何判断通信是否成为瓶颈？有哪些诊断方法？

出处：字节跳动/阿里云 AI Infra 岗位面试真题

答案：
通信瓶颈的核心判断指标是"计算开销/通信开销"的比值（Computation-to-Communication Ratio）。当通信时间占训练步时间的比例超过 30%，通常认为通信已成为瓶颈。

详细说明：

Q14: DeepSpeed ZeRO 与 FSDP（PyTorch FullyShardedDataParallel）有什么异同？

出处：Meta/微软 LLM 训练工程师面试高频题

答案：
两者核心思想一致——都将优化器状态、梯度和参数进行分片以节省显存。FSDP 是 PyTorch 原生实现，API 与 DDP 相似，易于迁移；DeepSpeed ZeRO 提供更细粒度的配置（Stage 1/2/3）和丰富的工程优化（offload、infinity 等）。

详细说明：

Q15: 训练 70B 参数量的模型，如何设计并行策略和通信方案？请给出具体配置。

出处：综合预测题（结合 LLaMA-70B 等开源模型训练实践）

答案：
以 128 张 A100-80G 为例，推荐采用 3D 并行：TP=8（机内 NVLink），PP=2（跨机），DP=8（机间），配合 ZeRO-1 切分优化器状态。

详细说明：

通信量估算：

$$
C_{\text{TP}} = 8 \times b \times 4096 \times 8192 \times 2\text{B} \approx 4\text{ GB/层}
$$

$$
C_{\text{PP}} = 2 \times 1 \times b \times 4096 \times 8192 \times 2\text{B} \approx 0.5\text{ GB}
$$

$$
C_{\text{DP}} = \frac{2 \times 70\text{B} \times 2\text{B}}{8 \times 2} = 17.5\text{ GB}
$$

总结

核心知识点回顾

思维导图结构

大模型训练通信开销
├── 集合通信原语
│   ├── 1→N：Broadcast / Scatter
│   ├── N→1：Gather / Reduce
│   └── N→N：All-Gather / Reduce-Scatter / All-Reduce / All-to-All
├── 数据并行 (单卡 2Φ)
│   ├── 朴素 All-Reduce：单点瓶颈
│   └── Ring-All-Reduce：均衡负载 = RS + AG
├── 张量并行 (单层 8bsh)
│   ├── FFN：A 列切 + B 行切 → 4bsh
│   ├── Attention → 4bsh
│   └── 适合机内 NVLink
├── 流水线并行 (2(N-1)bsh)
│   ├── 按层切分，P2P 传递
│   ├── GPipe micro-batch 减少气泡
│   └── 适合跨机通信
├── ZeRO 优化
│   ├── ZeRO-1：切分优化器 → 2Φ
│   ├── ZeRO-2：+切分梯度 → 2Φ
│   └── ZeRO-3：+切分参数 → 3Φ
├── 3D 并行
│   ├── TP 机内 (NVLink)
│   ├── PP 跨层 (P2P)
│   └── DP 机间 (All-Reduce)
└── 通信优化
    ├── 重叠 / 累积 / 压缩
    └── 融合 / 分层 / 拓扑

参考文献

1. Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism
2. GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism
3. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models

<!-- Reviewed: 2026-02-13, 深度重新审校：增加2个核心Mermaid图(Ring-All-Reduce两阶段流程+张量并行矩阵切分数据流)/原有2个Mermaid图(选型流程+3D并行配置)/丰富的通俗化类比(快递分拣/课堂小组/拼图/流水线/词典)/完整公式+符号表+数值示例/15个面试题/总计4个Mermaid图+1400行全面内容 -->

AI-Compass 致力于构建最全面、最实用、最前沿的AI技术学习和实践生态，通过六大核心模块的系统化组织，为不同层次的学习者和开发者提供完整学习路径。

• github地址：AI-Compass👈：https://github.com/tingaicompass/AI-Compass
• gitee地址：AI-Compass👈：https://gitee.com/tingaicompass/ai-compass

🌟 如果本项目对您有所帮助，请为我们点亮一颗星！🌟