AI基础设施 · 12
两层 MLP 切在不同方向,怎样少做一次跨卡同步?
列切与行切改变中间结果由谁持有,也决定何时需要跨卡聚合。沿原 MLP 双支路读一次,比只记并行倍数更有用。
读完能判断:跟踪列并行与行并行的中间形状及最后一次聚合。
📑 本页目录(点开跳转)
12 · 张量并行
⏱ 26 分钟 | ⭐ 把一层切开放到多张卡上
🎯 一句话
两张卡都有空闲显存,但一层的权重和临时数据在任何一张卡上都放不下。只把不同样本交给不同卡,每张卡还是得加载完整的层。把不同层放到不同卡上时,过大的那一层也仍然完整。
张量并行(Tensor Parallelism,TP)把同一层的权重和部分计算拆给多个设备。它能缩小每卡的部分工作集,但各卡算完还要交换结果。本章用一个小矩阵算清两种切法,再判断什么时候值得为显存或计算并行付出通信开销。适用线性层也可评估第 11 章提到的 ZeRO-3 + TiledLinear 顺序分块。
✂️ 一、两种切法
假设一个 token 有两个输入特征,线性层要输出四个特征。把一个 token 写成一行 X,把权重写成矩阵 A。A 的每一列对应一个输出,每一行对应一个输入特征。这里用 Z 表示线性层结果,暂不加偏置。先算完整的 Z = XA,才能看出分卡后丢了哪部分。
取 X = [2, 1](1 × 2),A 的两行依次是 [1, −2, 0, 3] 和 [2, 1, 4, −1](2 × 4)。第一项是 2 × 1 + 1 × 2 = 4。其余三项依次是 2 × (−2) + 1 × 1 = −3、2 × 0 + 1 × 4 = 4、2 × 3 + 1 × (−1) = 5,所以 Z = [4, −3, 4, 5](1 × 4)。
| 切法 | GPU0 | GPU1 |
|---|---|---|
| 按输出列切 拼接 | [4, −3] | [4, 5] |
| 按输入行切 逐项求和 | [2, −4, 0, 6] | [2, 1, 4, −1] |
① 列并行(按列切 A)
每张卡都有完整的 X(1 × 2),权重却只留两列(2 × 2)。GPU0 算前两个输出,得到 [4, −3]。GPU1 算后两个输出,得到 [4, 5]。两张卡负责不同的输出位置,所以需要完整输出时,把两段按顺序拼接。若下一层能直接接分片,就可以保留分片,避免此处的 AllGather(收集各卡分片)。
逐元素激活只用当前位置的值,所以每段可独立做激活。例如 ReLU 把负数置为 0,两张卡分别得到 [4, 0] 和 [4, 5]。模型用 GeLU 时也能逐元素处理,本例用 ReLU 方便手算。
② 行并行(按行切 A)
每张卡只拿 X 的一个输入特征(1 × 1),以及 A 对应的一行(1 × 4)。GPU0 将第一行乘以 2,得 [2, −4, 0, 6]。GPU1 将第二行乘以 1,得 [2, 1, 4, −1]。两张卡都贡献了四个位置的部分和,逐项相加得到 [2 + 2, −4 + 1, 0 + 4, 6 − 1] = [4, −3, 4, 5]。若每张卡都需要完整结果,可用 AllReduce(归约后各卡都拿到结果)。
激活要等归约结果。第二项的两个部分和为 −4 和 1。先相加再做 ReLU 得 max(0, −4 + 1) = 0;先各自做 ReLU 再相加却得 0 + 1 = 1。有共享输出偏置时,也要保证完整结果只加一次。
这里的矩阵 A 按「输入 × 输出」书写。PyTorch 的 nn.Linear.weight 按「输出 × 输入」存储,计算 X 乘该权重的转置(再加偏置)。因此本章的列并行在 PyTorch 权重里对应切输出行,行并行对应切输入列。PyTorch Linear 文档
🧩 二、Megatron 的经典组合(⭐ 这一节是核心)
前馈网络(MLP)连续做两次线性变换,中间有逐元素激活。记 H 为 XA 激活后的中间结果,B 为第二层权重,Y = HB 为最终结果。第一层按输出列切后,每张卡手里已有第二层行并行所需的一段 H。
沿用前面的 ReLU 例,H = [4, 0, 4, 5],第一层留下 [4, 0] 和 [4, 5] 两段。取第二层权重 B(4 × 2),四行分别为 [1, 2]、[2, 0]、[0, 1]、[3, −1]。GPU0 直接拿前两行,算出 [4 × 1 + 0 × 2, 4 × 2 + 0 × 0] = [4, 8]。GPU1 拿后两行,算出 [4 × 0 + 5 × 3, 4 × 1 + 5 × (−1)] = [15, −1]。两张卡做一次求和,完整 Y 为 [4 + 15, 8 − 1] = [19, 7]。
这次少搬数据,是因为两层的中间布局正好匹配。若第一层先做行并行,要在逐元素激活前合并部分和;若第二层改做列并行而后续又要完整输出,还要拼回输出片段。通信次数取决于这些边界需要什么布局。
注意力也可以沿特征维切。例如普通 16 头注意力在两卡上各算 8 个完整的头,Q、K、V 投影列切后保留每卡负责的头,最后用行并行输出投影合并部分和。若分组查询注意力(GQA)里的多个 Q 头共享同一组 K/V,切分时必须让每个 Q 头能访问对应的 K/V;实现可能复制部分 KV 头或限制可用的 TP 度。
数清前向和反向。经典 Megatron 的完整 Transformer 层在前向有两次归约(注意力输出与 MLP 输出),反向还有两次(各列并行投影的输入梯度有来自不同卡的贡献)。这就是原论文配置中的每层 4 次 AllReduce。推理没有这两次反向通信;序列分片与不同实现也会改用其他集合操作。Megatron-LM 原论文 §3
📉 三、通信代价:为什么通常优先放在高速互联域
各卡要相加的部分和有多大?设 b 是 TP 组在一个训练微批里处理的序列数,s 是每条序列的 token 数,h 是每个 token 的隐藏特征数,w 是通信时每个元素的字节数。一个部分和的形状是 b × s × h,所以一次 AllReduce 在每个 rank 的逻辑输入大小 S = b × s × h × w 字节。rank 指通信组中各自参与操作的进程,这里一进程对应一张卡。
先算张量,再算每张卡实际要发多少
① 单次和整步的逻辑输入。取 b = 8、s = 2,048、h = 8,192、BF16 的 w = 2。代入 8 × 2,048 × 8,192 × 2 = 268,435,456 字节,即 256 MiB(1 MiB = 1,048,576 字节)。假设一个训练步只含一个微批,80 层各有 4 次,合计 320 次。320 × 268,435,456 = 85,899,345,920 字节,约 85.90 GB(1 GB = 109 字节)。这是把 320 个逻辑输入的大小相加。
② 选定算法后再算链路。用第 5 章的等分 Ring,设 p 为组内卡数,每个 rank 发 2 × (p − 1) 轮,每轮发 S ÷ p 字节。TP=8 时,单次每 rank 发 14 × (268,435,456 ÷ 8) = 469,762,048 字节,收同样多。整步每 rank 发 320 × 469,762,048 = 150,323,855,360 字节,约 150.32 GB。TP=2 时,发送系数 2 × (2 − 1) ÷ 2 = 1,整步每 rank 发约 85.90 GB。逻辑输入大小相同,每 rank 的发送量却不同。
③ 只估搬运时间。若 TP=8 时每 rank 有效单向发送速率是 100 GB/s,收发可重叠,仅搬这些数据约需 150.32 ÷ 100 = 1.50 秒。若只有 25 GB/s,则约 6.01 秒。它们是演示输入,没计启动、等待、链路竞争及计算重叠。实际要在相同消息大小与拓扑上测量;若工具报告的是 algbw,其分子是逻辑输入大小,直接用该口径估时间时不可再乘一次 Ring 系数。
TP 一般先在机内高速互联域测,是因为上面的通信可能在各层频繁发生。跨节点能否达到目标,还取决于集合算法、可用链路、负载和重叠。训练要连同反向评估步时与吞吐;推理要按预填充、解码各自的负载看首 token、后续输出间隔和吞吐。增加卡数会减小本地矩阵,却可能增加等待或让小矩阵难以跑满。NCCL Tests 的带宽口径
显存也要分两笔。假设模型的可切权重占 32 GiB,各卡还要复制 8 GiB 的其他数据(1 GiB = 230 字节)。不切时每卡 32 + 8 = 40 GiB。均匀做 TP=4 后,每卡是 32 ÷ 4 + 8 = 16 GiB,比把整个 40 GiB 除以 4 得到的 10 GiB 多。实际还要分开检查激活、缓冲区和推理的 KV Cache。
🔧 四、代码长什么样
用标准 Python 在 CPU 上复算。multiply 依次对每个输出列做乘加;left、right 是两组列片,first、second 是两组行片的部分和。最后对中间列片各做 ReLU,再用第二层权重的对应两行计算部分和。
# 按输入行存权重,复算正文中的两次乘法。
def multiply(vector, matrix):
return [sum(x * weight for x, weight in zip(vector, column))
for column in zip(*matrix)]
x = [2, 1]
a = [[1, -2, 0, 3], [2, 1, 4, -1]]
b = [[1, 2], [2, 0], [0, 1], [3, -1]]
left = multiply(x, [weights[:2] for weights in a])
right = multiply(x, [weights[2:] for weights in a])
column = left + right
first = multiply(x[:1], a[:1])
second = multiply(x[1:], a[1:])
row = [u + v for u, v in zip(first, second)]
hidden_left = [max(0, value) for value in left]
hidden_right = [max(0, value) for value in right]
partial_left = multiply(hidden_left, b[:2])
partial_right = multiply(hidden_right, b[2:])
joined = [u + v for u, v in zip(partial_left, partial_right)]
whole = multiply([max(0, value) for value in multiply(x, a)], b)
assert column == row == multiply(x, a)
assert joined == whole
print("同一线性层:", column, row)
print("MLP:", partial_left, "+", partial_right, "=", joined)
输出的两种线性层结果都是 [4, −3, 4, 5]。MLP 的两份部分和是 [4, 8] 与 [15, −1],合计 [19, 7]。代码里的拼接和求和只模拟集合通信的结果,不测真实设备。下面保留的类定义只是框架骨架:权重尚未初始化,行并行需要已建立的 dist 和 TP_GROUP,不能直接运行。
# 概念示意:列并行的线性层
import torch
import torch.nn as nn
import torch.nn.functional as F
class ColumnParallelLinear(nn.Module):
def __init__(self, in_f, out_f, tp_size, tp_rank):
super().__init__()
assert out_f % tp_size == 0
self.weight = nn.Parameter(torch.empty(out_f // tp_size, in_f))
# ↑ 只存自己那一片
def forward(self, x):
return F.linear(x, self.weight) # ⭐ 不需要通信
# 行并行
class RowParallelLinear(nn.Module):
def __init__(self, in_f, out_f, tp_size, tp_rank):
super().__init__()
assert in_f % tp_size == 0
self.weight = nn.Parameter(torch.empty(out_f, in_f // tp_size))
def forward(self, x):
out = F.linear(x, self.weight)
dist.all_reduce(out, group=TP_GROUP) # ⭐ 这里必须通信
return out
下面是 PyTorch 原生 TP 的配置骨架。需要先建立设备网格 tp_mesh 和模型;子模块名称、融合 QKV 的分片布局及输入输出约定都要按具体模型核对。PyTorch 张量并行文档
# 🧩 骨架:`model` 来自你自己的代码,这一段只看写法
# ⭐ PyTorch 原生(2.x)
from torch.distributed.tensor.parallel import (
parallelize_module, ColwiseParallel, RowwiseParallel)
parallelize_module(model, tp_mesh, {
"attn.qkv_proj": ColwiseParallel(),
"attn.out_proj": RowwiseParallel(), # ⭐ 列→行的配对
"mlp.gate_proj": ColwiseParallel(),
"mlp.up_proj": ColwiseParallel(),
"mlp.down_proj": RowwiseParallel(),
})
💡 别自己实现张量并行。用 Megatron-LM、PyTorch 原生 TP、 或推理侧的 vLLM/TensorRT-LLM(
tensor_parallel_size=8)。 自己写极容易在权重初始化、随机种子、梯度缩放上出微妙的错。
🧵 五、序列并行:一个重要的补充
列→行组合在块的输出处会把完整隐藏向量留在每张卡。对于按 token 独立执行的 LayerNorm 和 Dropout,可以把不同 token 分给不同卡,同时让每张卡保留其 token 的完整隐藏向量。这是这里的序列并行(Sequence Parallelism,SP)。
保留 token 分片,需要时再拼回
例如 4 个 token、每个 8 个特征、BF16 每元素 2 字节。原来每卡保存 4 × 8 × 2 = 64 字节。按 token 均匀分给两卡后,各保留 2 × 8 × 2 = 32 字节。减半的是这份中间张量的本地存量。切换布局所需缓冲、其他张量与总峰值要另外算。
沿用第 5 章和第 11 章的关系,先 ReduceScatter 再 AllGather 可得到 AllReduce 的结果。等分 Ring 下,同一个张量的这两段传输字节量合计可和原 AllReduce 相同;调用时机、重叠以及端到端耗时可能变化。这里切的是逐 token 操作之间的布局,与把注意力计算本身沿长上下文拆开的方案不同。
下面保留的是 Megatron 的参数示例。是否启用,要看框架版本、分片约束、额外缓冲与实测峰值。
# 🧩 骨架:`sequence` 来自你自己的代码,这一段只看写法
# Megatron 里开启
--sequence-parallel # ⭐ 几乎总是该开,和 TP 配套
⚠️ 六、四个坑
| 坑 | 说明 |
|---|---|
| 维度不能整除 | 均匀分片时,对应维度要能被 TP 度整除;注意力还要检查 Q/KV 头的配组及框架是否支持复制。 |
| 随机种子 | 复制的逻辑张量需一致、分片张量需匹配随机数流;使用框架的 RNG tracker |
| 词表并行的边界 | Embedding 按词表切时,要 mask 掉不属于自己的 token id |
| TP 度太大 | 通信占比可能上升;TP=8/16 的收益取决于拓扑、内核形状、负载与重叠 |
随机数流要跟着布局走。复制的是同一个逻辑张量时,各副本需要一致的随机掩码。分片中不同位置应由框架用匹配的随机流处理;如果不同分片复用了同样的掩码模式,丢弃事件可能相关。每个位置的丢弃概率仍可能不变,变化的是哪些位置一起被丢弃。
🔗 和站内其他章的关系
| 相关的地方 | 这里的位置 |
|---|---|
| 第 5 章 NVLink、PCIe 与跨机链路的带宽口径 | TP 通常优先使用高速互联的原因 ⭐ |
| 第 5 章 AllReduce=RS+AG | 序列并行的原理 |
| 第 11 章 ZeRO-3 | 对比:ZeRO 与 TP 都能跨机,效率取决于通信与拓扑 |
| 全景导论主线 2 · 模型怎样看懂一句话 MLP 和多头注意力 | 本章切的就是它们 |
| 第 14 章 | TP 在 3D 并行里的位置 |
✅ 检查点
- 用 1 × 2 输入、2 × 4 权重重算两种切法。各卡拿到什么?什么时候拼接,什么时候相加?
- 为什么不能把行并行的两个部分和分别做 ReLU 再相加?
- 在本章 MLP 中,为什么两层之间可以保留分片?如果下一层要完整输出,又要做什么?
- 经典 Megatron 的完整 Transformer 层训练有几次 AllReduce?推理少了什么?GQA 为什么还要查 K/V 布局?
- 逻辑输入为 256 MiB 的 Ring AllReduce 在 TP=8 时,每 rank 发多少?为什么不能把标称链路带宽直接当成有效通信带宽?
- 序列并行的 4-token 示例里每卡少存多少字节?Dropout 的随机数流要怎么匹配布局?
👀 答案
- 列切每卡拿完整输入和两列权重,得 [4, −3] 与 [4, 5],需要完整输出时拼接。行切每卡拿一个输入特征和一行权重,得 [2, −4, 0, 6] 与 [2, 1, 4, −1],逐项相加。
- 第二项先相加是 −4 + 1 = −3,做 ReLU 得 0;先分别做 ReLU 得 0 和 1,再相加得 1。
- 第一层列切留下的中间特征正好对应第二层的行片。末尾两卡持有同一输出的不同贡献,需归约;若最后采用列切而后续要完整输出,则需拼回不同输出位置。
- 经典配置的完整训练层是 2 次前向加 2 次反向。推理没有反向两次。GQA 的多个 Q 头共用 K/V,切分后各 Q 头仍必须能访问对应 K/V。
- 8 卡 Ring 共发 14 轮,每轮 256 ÷ 8 = 32 MiB,合计每 rank 发 448 MiB。实际链路可能共享,算法和拓扑也会改变流量及等待;应按相同配置测有效带宽。
- 每卡从 64 字节变成 32 字节,少存 32 字节。逻辑副本的掩码要一致,不同分片应由框架用匹配的随机流处理。
本节回顾
先记住这几件事
- 列切得到不同输出位置,完整输出靠拼接。行切得到同一输出的部分和,先求和再做非线性。
- 列切的输出分片可直接喂给下一层的行切。输出布局、前反向阶段和注意力头的配组决定还需哪些通信。
- 先分开数可切显存、逻辑张量字节和每 rank 的通信量,再结合实际拓扑、并行度和任务测耗时。
下一节 👉 13-流水线并行.md
条件与依据
这里四次 AllReduce 是经典 Megatron 前反向分解的示例,不覆盖所有序列并行或优化实现。AllReduce 输入张量大小不随 TP 度变化,不表示链路字节量与延迟都无关。Dropout 需让复制的逻辑张量一致、分片张量使用匹配的随机数流,不能概括成“TP 必须不同、DP 必须相同”。