企业官网建设流程全解析

其中Parallelism的意思是“并行”。

可以这样快速记：

Data → 数据 → DP Tensor → 张量 → TP Pipeline → 流水线 → PP Expert → 专家 → EP Context → 上下文 → CP Virtual Pipeline → 虚拟流水线 → VPP

需要注意，Megatron 源码中有时还会看到更完整的叫法：

TP：Tensor Model Parallelism PP：Pipeline Model Parallelism VPP：Virtual Pipeline Model Parallelism

它们分别强调这是在做“模型并行”，含义与上表基本一致。

我们延续上次的方式：**先理解它为什么存在，再看数字例子，最后映射到 Megatron。**你之前的学习目标里也把 DP、TP、PP、EP、CP、VPP 列为了重点。

一、并行训练到底在“拆”什么？

先记住一句最重要的话：

所有并行策略，都是在拆分一次正常的模型训练，但拆分的位置不同。

假设我们要训练一个 Transformer：

输入数据 ↓ Embedding ↓ 第 1 层 Transformer ↓ 第 2 层 Transformer ↓ …… ↓ 第 8 层 Transformer ↓ LM Head ↓ Loss

现在单张 GPU 遇到三个问题：

1. 模型参数放不下

2. 一批数据算得太慢

3. 序列太长，激活值放不下

所以我们可以拆：

最容易记忆的版本：

DP：不同 GPU 吃不同数据 TP：不同 GPU 合作计算同一层 PP：不同 GPU 负责不同层 EP：不同 GPU 负责不同专家 CP：不同 GPU 负责不同 Token 位置

下面固定使用一个小模型讲解。

二、我们的示例模型

假设模型有：

Transformer 层数：8 Hidden Size：8 Attention Head：8 Batch Size：4 Sequence Length：4 GPU 数量：8

输入 Tensor 形状：

[
[Batch, Sequence, Hidden]

[4,4,8]
]

也就是：

4 条文本 每条文本 4 个 Token 每个 Token 是 8 维向量

单卡训练时：

GPU 0： 保存完整 8 层模型 处理完整 Batch=4 完成全部前向和反向

现在我们开始拆。

三、DP：数据并行

DP 全称：

Data Parallel，数据并行

1. DP 拆的是什么？

DP 拆的是Batch 数据。

假设使用两张 GPU：

总 Batch Size = 4 DP = 2

那么：

GPU 0：处理样本 1、样本 2 GPU 1：处理样本 3、样本 4

但是两张 GPU 都保存完整模型：

GPU 0：完整的 8 层 Transformer GPU 1：完整的 8 层 Transformer

示意图：

完整模型副本 样本 1、2 → GPU 0 → Loss 0 → 梯度 0 ↘ 梯度同步 ↗ 样本 3、4 → GPU 1 → Loss 1 → 梯度 1 完整模型副本

2. 为什么要同步梯度？

假设模型只有一个参数：

[
w=0.5
]

GPU 0 根据自己的数据算出：

[
grad_0=0.1
]

GPU 1 算出：

[
grad_1=0.3
]

两张 GPU 不能各自随便更新，否则参数会变得不同。

所以要把梯度平均：

[
grad=\frac{0.1+0.3}{2}=0.2
]

然后两张 GPU 都使用同一个梯度更新：

[
w_{\text{new}}

0.5-\eta\times0.2
]

这样更新后：

GPU 0 的 w = GPU 1 的 w

这个梯度同步通常使用：

All-Reduce

3. DP 的优点和缺点

优点：

• 增加训练吞吐量

• 更多 GPU 可以同时处理更多数据

• 理解和实现相对简单

缺点：

• 每张 GPU 都要保存完整模型

• 如果模型本身放不进一张 GPU，DP 没用

所以：

DP 主要解决“训练速度不够快”，不直接解决“模型太大放不下”。

4. Global Batch 公式

在 Megatron 中，经常看到：

[
GlobalBatch

MicroBatch
\times DP
\times Microbatch数量
]

例如：

Micro Batch Size = 2 DP = 4 梯度累积次数 = 8

那么：

[
GlobalBatch=2\times4\times8=64
]

意思是：

每张 GPU 每次处理 2 条数据 共有 4 个 DP 副本 连续累积 8 个 Microbatch 最终用 64 条数据更新一次参数

四、TP：张量并行

TP 全称：

Tensor Parallel，张量并行

这是 Megatron 最核心的并行方式之一。

1. TP 拆的是什么？

TP 拆的是：

同一层内部的大矩阵计算。

注意区别：

DP：两张 GPU 处理不同数据 TP：两张 GPU 处理同一批数据，并合作计算同一层

假设 Transformer 中有一个线性层：

[
Y=XW
]

权重矩阵：

[
W\in\mathbb{R}^{8\times8}
]

单卡时：

GPU 0 保存完整 W：[8, 8] GPU 0 计算完整 Y

当：

TP = 2

可以把这个矩阵拆成两半。

2. 最简单的数值例子

为了方便，把 Hidden Size 改成 4。

输入：

[
X=[1,2,3,4]
]

权重矩阵使用单位矩阵：

[
W=
\begin{bmatrix}
1&0&0&0\
0&1&0&0\
0&0&1&0\
0&0&0&1
\end{bmatrix}
]

正常结果：

[
Y=XW=[1,2,3,4]
]

现在用 TP=2，把 W 按列拆开。

GPU 0 保存前两列：

[
W_0=
\begin{bmatrix}
1&0\
0&1\
0&0\
0&0
\end{bmatrix}
]

GPU 1 保存后两列：

[
W_1=
\begin{bmatrix}
0&0\
0&0\
1&0\
0&1
\end{bmatrix}
]

两张 GPU 都接收同一个输入：

[
X=[1,2,3,4]
]

GPU 0 计算：

[
Y_0=XW_0=[1,2]
]

GPU 1 计算：

[
Y_1=XW_1=[3,4]
]

最后拼接：

[
Y=[Y_0,Y_1]=[1,2,3,4]
]

也就是：

┌→ GPU 0：计算输出前一半 [1, 2] 输入 X ──────┤ └→ GPU 1：计算输出后一半 [3, 4] 拼接后：[1, 2, 3, 4]

这就是最基础的 TP 思想：

一层太大，一张卡算不动，多张卡分别保存并计算这一层的一部分。

五、Transformer 中 TP 实际拆什么？

Transformer 层主要包含：

Attention MLP

TP 会拆它们内部的大矩阵。

1. 拆 Attention Head

假设：

Attention Head = 8 TP = 2

那么可以变成：

GPU 0：负责 Head 0～3 GPU 1：负责 Head 4～7

两张 GPU 处理的是同一批 Token，但负责不同 Attention Head。

同一个输入 Hidden States │ ├─ GPU 0：计算 4 个 Attention Head │ └─ GPU 1：计算 4 个 Attention Head │ └─ 合并结果

如果：

Attention Head = 64 TP = 4

通常每张 GPU 负责：

[
64/4=16
]

个 Query Head。

2. 拆 MLP

假设 MLP：

输入 Hidden Size = 8 中间 FFN Hidden Size = 32 输出 Hidden Size = 8

第一层线性变换：

[
[8]\rightarrow[32]
]

TP=2 时：

GPU 0：计算中间神经元 0～15 GPU 1：计算中间神经元 16～31

每张 GPU 只保存一半 MLP 权重。

第二层再把两边的计算结果合并成 Hidden Size=8。

Megatron 中常见的组合是：

Column Parallel Linear ↓ 激活函数 ↓ Row Parallel Linear

现在不需要背它们的源码，只要先理解：

Column Parallel：拆输出维度 Row Parallel：拆输入维度，并把部分结果相加

六、TP 为什么需要频繁通信？

因为两张 GPU 正在合作计算同一层。

例如：

GPU 0 只有输出的一部分 GPU 1 只有输出的另一部分

下一步计算可能需要完整结果，或者需要把部分结果相加。

因此 TP 常使用：

All-Reduce All-Gather Reduce-Scatter

而且通信可能发生在每一层。

所以 TP 的特点是：

通信非常频繁 通信数据量较大 最好放在高速互联的 GPU 之间

通常希望 TP GPU 位于：

同一台服务器 或者同一个 NVLink / NVSwitch 域

不适合随便跨慢速网络。

七、TP 的优点和缺点

优点：

• 减少每张 GPU 保存的单层参数

• 可以训练 Hidden Size 很大的模型

• Attention Head 和 MLP 很适合拆分

缺点：

• 每一层都可能通信

• 对 GPU 间带宽要求高

• TP 太大时，单张 GPU 分到的计算量太小，通信反而占主导

一句话总结：

TP 解决的是“单个 Transformer 层太大，一张 GPU 放不下或算不动”。

八、PP：流水线并行

PP 全称：

Pipeline Parallel，流水线并行

1. PP 拆的是什么？

PP 拆的是：

模型的不同层。

假设模型有 8 层，PP=2：

GPU 0：第 1～4 层 GPU 1：第 5～8 层

数据执行流程：

输入 ↓ GPU 0：Layer 1～4 ↓ 发送中间激活值 GPU 1：Layer 5～8 ↓ Loss

注意：

• GPU 0 没有第 5～8 层

• GPU 1 没有第 1～4 层

• 每张 GPU 只保存部分模型层

所以 PP 可以显著降低模型参数显存。

2. PP 的前向传播

假设输入形状：

[
[Batch,Sequence,Hidden]=[4,4,8]
]

GPU 0 执行第 1～4 层后，得到：

[
H_4\in\mathbb{R}^{4\times4\times8}
]

GPU 0 把这个 Tensor 发给 GPU 1：

GPU 0 --send H4--> GPU 1

GPU 1 接着执行第 5～8 层。

所以 PP 主要发送的是：

Stage 之间的激活值。

3. PP 的反向传播

前向：

GPU 0 → GPU 1

反向则相反：

GPU 1 → GPU 0

GPU 1 计算出：

[
\frac{\partial L}{\partial H_4}
]

然后将这个梯度发回 GPU 0。

GPU 0：Layer 1～4 前向激活 → GPU 1：Layer 5～8 GPU 0：Layer 1～4 ← 反向梯度 GPU 1：Layer 5～8

常见通信：

Send / Recv

九、为什么叫“流水线”？

如果只发送一个 Batch，会发生：

时刻 1： GPU 0 工作 GPU 1 等待 时刻 2： GPU 0 等待 GPU 1 工作

利用率很低。

因此会把一个大 Batch 拆成多个 Microbatch。

假设有 4 个 Microbatch：

M1、M2、M3、M4

仅看前向传播：

像工厂流水线：

GPU 0 加工前半部分 GPU 1 加工后半部分

到 T2 之后，两张 GPU 可以同时工作。

十、Pipeline Bubble 是什么？

刚才的表中：

T1：GPU 1 空闲 T5：GPU 0 空闲

这些空闲时间叫：

Pipeline Bubble，流水线气泡。

Pipeline Stage 越多，Microbatch 太少时，气泡比例越严重。

直觉上：

PP Stage 很多 + Microbatch 很少 → 大量 GPU 在等待 PP Stage 很多 + Microbatch 足够多 → 流水线利用率更高

这也是为什么 Megatron 需要：

Microbatch 1F1B Interleaved 1F1B VPP

其中 1F1B 意思是稳态阶段尽量：

做一次前向 再做一次反向

从而减少显存占用并提高利用率。

你现在不用深入 1F1B 的时间表，先记住：

PP 不是简单地把层放到不同 GPU 上，还必须安排好 Microbatch 的执行顺序。

十一、PP 的优点和缺点

优点：

• 每张 GPU 只保存部分层

• 特别适合层数很深的大模型

• 相比 TP，通信不发生在每个矩阵内部

• Stage 之间主要传递激活值和梯度

缺点：

• 存在 Pipeline Bubble

• 不同 Stage 计算量不均衡时，有些 GPU 会等待

• 需要把 Batch 拆成多个 Microbatch

• 调度比普通单卡训练复杂

一句话总结：

PP 解决的是“整个模型层数太多，所有层放不进一张 GPU”。

十二、TP 和 PP 到底有什么区别？

这是最重要的对比。

假设一个 8 层模型：

PP=2

GPU 0：拥有完整的 Layer 1～4 GPU 1：拥有完整的 Layer 5～8

拆的是层：

Layer 1～4 | Layer 5～8

TP=2

GPU 0：拥有每一层的一半 GPU 1：拥有每一层的另一半

拆的是层内部矩阵：

Layer 1： GPU 0 一半 + GPU 1 一半 Layer 2： GPU 0 一半 + GPU 1 一半 …… Layer 8： GPU 0 一半 + GPU 1 一半

最直观的区别：

PP：你做前四层，我做后四层 TP：每一层我们两个一起做

再形象一点：

PP 像工厂分工： 工人 A 负责组装前半段 工人 B 负责组装后半段 TP 像两个人抬一块重物： 同一个步骤太重，两个人一起完成

十三、DP、TP、PP 怎么组合？

真实大模型一般不会只用一种并行，而是组合使用。

假设一共有 8 张 GPU：

TP = 2 PP = 2 DP = 2

总 GPU 数：

[
2\times2\times2=8
]

1. 先看一个模型副本

TP=2、PP=2，因此一个模型副本需要：

[
TP\times PP=2\times2=4
]

张 GPU。

第一个模型副本：

Pipeline Stage 0：Layer 1～4 ├─ GPU 0：负责每层矩阵的一半 └─ GPU 1：负责每层矩阵的另一半 Pipeline Stage 1：Layer 5～8 ├─ GPU 2：负责每层矩阵的一半 └─ GPU 3：负责每层矩阵的另一半

表示成图：

TP=2 ┌────────────────┐ 输入 → PP Stage 0 │ GPU 0 + GPU 1 │ Layer 1～4 └───────┬────────┘ │ 激活值 ┌───────▼────────┐ │ PP Stage 1 │ │ GPU 2 + GPU 3 │ Layer 5～8 └────────────────┘

2. 再复制一个 DP 副本

第二个模型副本：

GPU 4、5：Stage 0 GPU 6、7：Stage 1

完整布局：

DP 副本 0： PP Stage 0：GPU 0、1，内部 TP=2 PP Stage 1：GPU 2、3，内部 TP=2 DP 副本 1： PP Stage 0：GPU 4、5，内部 TP=2 PP Stage 1：GPU 6、7，内部 TP=2

数据分配：

DP 副本 0：处理样本 1～4 DP 副本 1：处理样本 5～8

每个副本内部：

1. 使用 PP 拆层

2. 每个 PP Stage 内部使用 TP 拆矩阵

3. 反向完成后，两个 DP 副本同步对应参数的梯度

十四、并行组是什么？

Megatron 会为不同通信建立不同的 Process Group。

以上面的 8 张 GPU 为例：

TP=2 PP=2 DP=2

TP Group

合作计算同一个 Stage 内部矩阵：

(0, 1) (2, 3) (4, 5) (6, 7)

例如 GPU 0 和 GPU 1 一起计算 Layer 1～4。

PP Group

负责同一条 Pipeline 路径：

(0, 2) (1, 3) (4, 6) (5, 7)

例如 GPU 0 的输出传给 GPU 2。

为什么是 0→2、1→3？

因为 TP 分片必须一一对应：

TP 分片 0 → 下一个 Stage 的 TP 分片 0 TP 分片 1 → 下一个 Stage 的 TP 分片 1

DP Group

保存相同参数分片、处理不同数据的 Rank：

(0, 4) (1, 5) (2, 6) (3, 7)

例如：

GPU 0 和 GPU 4

都保存：

Stage 0 中 TP 分片 0 的参数

只是处理不同数据。因此反向后，它们需要同步梯度。

这个概念非常重要：

GPU 不只是属于一个组；同一张 GPU 会同时属于 TP Group、PP Group、DP Group。

例如 GPU 0：

TP Group：(0,1) PP Group：(0,2) DP Group：(0,4)

不同操作使用不同通信组。

十五、完整训练过程：8 张 GPU 的数字例子

配置：

GPU 总数 = 8 TP = 2 PP = 2 DP = 2 Micro Batch Size = 1 每个 DP 副本有 4 个 Microbatch

因此一次更新的 Global Batch：

[
1\times2\times4=8
]

流程如下。

第一步：DP 拆数据

DP 副本 0：样本 1～4 DP 副本 1：样本 5～8

第二步：拆成 Microbatch

每个副本：

M1：1 条文本 M2：1 条文本 M3：1 条文本 M4：1 条文本

第三步：PP Stage 0 前向

对于 DP 副本 0：

GPU 0、1 一起处理 M1 的 Layer 1～4

这里 GPU 0、1 使用 TP：

GPU 0：算每层矩阵的一半 GPU 1：算每层矩阵的另一半

第四步：发送给下一个 PP Stage

GPU 0 → GPU 2 GPU 1 → GPU 3

GPU 2、3 接着计算 Layer 5～8。

与此同时，GPU 0、1 可以开始计算 M2。

第五步：计算 Loss 和反向传播

最后一个 Stage 计算：

LM Head Loss Backward

梯度沿 Pipeline 反向传递：

GPU 2、3 → GPU 0、1

第六步：DP 同步梯度

两个 DP 副本都完成后：

GPU 0 ↔ GPU 4 GPU 1 ↔ GPU 5 GPU 2 ↔ GPU 6 GPU 3 ↔ GPU 7

对相同参数分片的梯度执行 All-Reduce 或等价操作。

第七步：更新参数

每张 GPU 更新自己保存的参数分片：

optimizer.step()

更新后，两个 DP 副本仍然完全一致。

十六、EP：专家并行

EP 全称：

Expert Parallel，专家并行

它主要用于 MoE。

假设一个 MoE 层有 8 个专家：

Expert 0～7 EP = 2

可以这样拆：

GPU 0：Expert 0～3 GPU 1：Expert 4～7

Router 对每个 Token 选择专家。

例如：

Token A → Expert 1 Token B → Expert 6 Token C → Expert 3

那么：

Token A 留在或发送到拥有 Expert 1 的 GPU Token B 发送到拥有 Expert 6 的 GPU Token C 留在或发送到拥有 Expert 3 的 GPU

典型流程：

Token ↓ Router 选择 Top-k Expert ↓ All-to-All 把 Token 发到专家所在 GPU ↓ 各 GPU 执行自己的专家 FFN ↓ All-to-All 把结果发回来 ↓ 加权合并

所以 EP 拆的是：

MoE Expert 的参数和计算。

EP 主要解决：

• 专家数量太多，专家参数放不下

• 将不同专家的计算分散到不同 GPU

它最典型的通信是：

All-to-All

十七、CP：上下文并行

CP 全称：

Context Parallel，上下文并行

它拆的是序列长度。

假设：

Sequence Length = 8 CP = 2

那么可以理解为：

GPU 0：Token 位置 0～3 GPU 1：Token 位置 4～7

原始 Hidden States：

[
[B,8,H]
]

拆开后，每张 GPU 大致保存：

[
[B,4,H]
]

它主要解决：

• 序列太长

• Attention 激活值显存太大

• 单卡放不下完整 Context

但是 Attention 中，一个 Token 需要看到其他位置的 K、V，因此不同 CP Rank 之间仍然需要交换信息。

所以 CP 不是简单地把序列砍开后互不联系。

一句话：

CP 让不同 GPU 保存和计算同一个样本的不同 Token 位置。

十八、VPP：虚拟流水线并行

VPP 全称：

Virtual Pipeline Parallel

它不是像 TP、PP 那样单独增加一种“拆分维度”，更像是：

对 PP 层进行更细的分块和交错调度。

假设 8 层、PP=2。

普通 PP：

物理 Stage 0：Layer 1～4 物理 Stage 1：Layer 5～8

使用 VPP 后，可以把每个物理 Stage 的层拆成多个模型 Chunk，例如：

Stage 0： Chunk 0：Layer 1～2 Chunk 1：Layer 5～6 Stage 1： Chunk 0：Layer 3～4 Chunk 1：Layer 7～8

执行顺序交错：

Stage 0 Chunk 0 → Stage 1 Chunk 0 → Stage 0 Chunk 1 → Stage 1 Chunk 1

这样可以让 Pipeline 的调度更细，降低一部分 Bubble。

先记住：

PP 决定模型分到几个物理 Stage；VPP 决定每个物理 Stage 内再分几个模型 Chunk，并交错执行。

十九、一张总表彻底区分

最重要的判断方法：

看到不同 GPU 吃不同样本：DP 看到不同 GPU 一起算同一个 Linear/Attention：TP 看到 GPU 0 算前几层、GPU 1 算后几层：PP 看到 Token 被 Router 发到不同专家：EP 看到长序列的 Token 位置被分到不同 GPU：CP

二十、映射到你之前的 Qwen 脚本

你之前的配置大致包含：

TP = 4 PP = 8 EP = 8

可以先这样理解：

TP=4

同一个 Transformer 层由 4 张 GPU 合作计算。

例如：

64 个 Query Head

粗略理解为每张 GPU 负责：

[
64/4=16
]

个 Head。

MLP 和其他大矩阵也会分成 4 份。

PP=8

60 层模型被放到 8 个 Pipeline Stage 上。

理想平均值：

[
60/8=7.5
]

所以无法每个 Stage 完全相同：

有的 Stage 7 层 有的 Stage 8 层

这就是为什么你之前的脚本中需要考虑非均匀 Pipeline 层分配。

EP=8

512 个 Expert 分布到 8 个 EP Rank 上。

如果均匀分配：

[
512/8=64
]

每个 EP Rank 保存大约 64 个专家。

Token 经过 Router 后，会通过 All-to-All 被发送到对应专家所在的 Rank。

不过要注意一个细节：

EP 在 Megatron 中通常与数据并行维度存在嵌套关系，不能在所有配置里都简单地把TP × PP × EP当成最终 GPU 总数。

不考虑 EP、CP 时，最基础的公式是：

[
WorldSize=TP\times PP\times DP
]

若加入 CP：

[
WorldSize=TP\times PP\times CP\times DP
]

EP Group 通常从相关的数据并行 Rank 中划分，具体还要看 Megatron 的并行 Rank 布局。初学阶段先不要把这个细节当作重点。

二十一、面试中怎么回答

问：DP、TP、PP 分别解决什么问题？

可以这样回答：

DP 将 Batch 拆给多个模型副本，主要提升训练吞吐，但每个副本仍需保存模型。TP 将单个 Transformer 层内部的矩阵、Attention Head 或 MLP 维度拆到多个 GPU，解决单层过大的问题。PP 将模型的不同层拆到不同 Stage，解决整个模型层数多、参数放不下的问题，并通过 Microbatch 流水线提高利用率。

问：TP 和 PP 的通信有什么区别？

TP 的 GPU 共同计算同一层，因此通常每层都会发生集合通信，例如 All-Reduce、All-Gather 或 Reduce-Scatter，对带宽要求很高。PP 主要在相邻 Stage 之间发送激活值和反向梯度，通常使用点对点 Send/Recv，但会产生 Pipeline Bubble。

问：为什么 DP 不能解决模型放不下？

因为普通 DP 的每个模型副本都需要保存完整模型参数。它拆的是数据，而不是模型参数本身。

问：为什么 PP 需要 Microbatch？

如果整个 Batch 一次通过 Pipeline，其他 Stage 会长时间等待。将 Batch 拆成多个 Microbatch 后，不同 Stage 可以同时处理不同 Microbatch，从而形成流水线并减少空闲时间。

二十二、现在必须牢牢记住的五句话

1. DP：不同数据，相同模型。 2. TP：相同数据，同一层由多张 GPU 合作计算。 3. PP：相同数据，不同 GPU 负责不同模型层。 4. EP：不同 GPU 保存不同 MoE 专家。 5. CP：不同 GPU 保存同一个样本的不同 Token 位置。

再加一句组合关系：

真实训练中： 先用 PP 拆层， 每个 PP Stage 内用 TP 拆矩阵， 再用 DP 复制模型并处理更多数据， MoE 层额外使用 EP， 长序列额外使用 CP。

三道自测题

第 1 题

总 GPU 数 = 16 TP = 2 PP = 4 CP = 1

暂不考虑 EP，则：

[
DP=\frac{16}{2\times4}=2
]

第 2 题

Micro Batch = 2 DP = 4 Microbatch 数量 = 8

Global Batch：

[
2\times4\times8=64
]

第 3 题

下面分别是什么并行？

GPU 0 处理样本 A，GPU 1 处理样本 B：DP GPU 0 计算前 4 个 Attention Head， GPU 1 计算后 4 个 Attention Head：TP GPU 0 计算 Layer 1～4， GPU 1 计算 Layer 5～8：PP