最近重新整理和 review 了一遍大模型分布式训练的知识,主要结合 Google 的 JAX Scaling Book(第三章)[1]、猛猿的四篇图解长文(DP/DDP[8]、DeepSpeed ZeRO[9]、Megatron-LM 张量并行[10]与 Megatron 混合精度源码解读[11])以及原始论文[2][5][6][7]。整篇按“显存与混合精度 → 命名网格与四种集合通信 → DDP/ZeRO → TP → PP → MoE → 64 卡配比”的顺序串下来。

显存与混合精度

显存花在了哪

参照 ZeRO 论文的划分[4],训练期 GPU 显存分成两大块:只与参数量 $\Phi$ 有关的模型状态(Model States)(权重、梯度、Adam 的一阶/二阶动量),以及受批大小、序列长度与内存分配节奏影响的剩余状态(Residual States)(激活值、通信临时缓冲区与碎片空间)。

现代大模型基本采用混合精度 + Adam:前向/反向吃 16-bit(FP16 或 BF16)权重并存 16-bit 梯度(共 $2\Phi + 2\Phi$),而优化器内保留 FP32 主权重与 Adam 状态 $m, v$(各 $4\Phi$,对通用优化器记为 $K\Phi$,Adam 下 $K=12$),静态基线共 $\mathbf{16\Phi}$。但在实际 optimizer.step() 更新阶段,16-bit 梯度需转换成 FP32($4\Phi$):若原地释放或覆盖旧的 16-bit 梯度,峰值为 $\mathbf{18\Phi}$;若代码里 16-bit 与 32-bit 梯度共存(例如梯度累积或 Megatron 拷贝阶段未立刻释放),峰值会到 $\mathbf{20\Phi}$:

组成部分 精度 每参数 7B 70B
计算权重(model_param) BF16 / FP16 $2\Phi$ 14 GB 140 GB
梯度 BF16 / FP32 $2\Phi$ / $4\Phi$ 14 / 28 GB 140 / 280 GB
FP32 主权重(main_param) FP32 $4\Phi$ 28 GB 280 GB
Adam 一阶动量 $m$ FP32 $4\Phi$ 28 GB 280 GB
Adam 二阶动量 $v$ FP32 $4\Phi$ 28 GB 280 GB
静态总计(基线 / 峰值) 混合精度 $16\Phi$(峰值 $18\Phi / 20\Phi$) 112–140 GB 1.12–1.40 TB

光是 7B 模型的静态状态就已经到 $112\text{–}140\text{ GB}$,单张 80 GB H100 还没算激活值就已经装不下了。

另一半大头是剩余状态,其中最主要的是前向保留给反向求导的激活值(Activations)。如果不做激活重计算,单层标准 Transformer(序列长度 $s$、微批 $b$、隐藏维 $h$、注意力头数 $a$)需要暂存的激活显存为[3]:

$$\text{Mem}_{\text{act/layer}} = s b h \left(34 + \frac{5 a s}{h}\right) \text{ 字节}$$

代入一个 70B 量级的配置($h = 8192, a = 64, L = 80$),哪怕只喂一条 $s = 4096, b = 1$ 的长样本,整网激活也要吃掉约 $\mathbf{521\text{ GB}}$——比权重本身还要大三倍多。

分布式混合精度

理解混合精度,先看三种浮点格式在表示范围(Exponent 位)和机器精度(Fraction 尾数位,可用满足 $1+\varepsilon \gt 1$ 的最小 $\varepsilon$ 衡量)上的取舍[11]:

格式 位宽 (S-E-M) 字节 绝对值表示范围 机器精度 $\varepsilon$ Loss Scale
FP32 1-8-23 4 B $10^{-38} \sim 3\times 10^{38}$ $0.00000012$ 无需
FP16 1-5-10 2 B $5.95\times 10^{-8} \sim 65504$ $0.00097656$ 动态 / 常量
BF16 1-8-7 2 B $10^{-38} \sim 3\times 10^{38}$ $0.00781250$ 无需或常量

为什么不能从头到尾纯用半精度训练?主要有两类数值障碍:

  • 舍入误差(Rounding Error):FP16 在区间 $[2^{-3}, 2^{-2}]$ 内的最小步进间隔固定为 $2^{-13}$,如果权重为 $2^{-3}$、单步梯度为 $2^{-14}$,直接相加会被舍入为 $2^{-3}+2^{-14}=2^{-3}$——这轮更新直接被吞掉(BF16 尾数更短、$\varepsilon$ 更大,更依赖 FP32 主权重更新)。
  • 梯度下溢(Underflow):实测训练后期约 67% 的激活梯度会落到 $2^{-24}$ 以下(超出 FP16 最小正规数下界),直接归零。把前向 Loss 放大 $S$ 倍(Loss Scale)就能同步抬高反向梯度脱离下溢区;而 BF16 指数位与 FP32 同宽(“先到了对的范围,再谈精度”),基本不会下溢,可省去动态 Loss Scale。

此外,LayerNorm / BatchNorm 参数与 Loss 本身显存极小却对数值极为敏感,因此始终保持 FP32。

在 Megatron 的 Float16OptimizerWithFloat16Params 源码实现中,有三个常被误解但非常关键的工程设计:

  • main_grad 并不代表“FP32 梯度”:当启用 Megatron 本地 DDP(DDP_impl == "local",即 params_have_main_grad=True)时,源码把同 dtype 的参数梯度打包进一块连续 MemoryBuffer(挂在 tensor.main_grad 上),目的是消除离散分配碎片、并用一次大块 AllReduce 同步。在 FP16 训练下 main_grad 本身仍是 FP16,真正转成 FP32 发生在优化器拷贝步骤。
  • main_param = param.detach().clone().float():初始化 FP32 主权重副本时不能只用 clone()(会留在计算图内多算梯度),也不能只用 detach()(仍与原 FP16 权重共享底层内存),必须先脱离计算图再深拷贝并转 float;随后复制 TP 分片属性及跨 PP 的共享 Word Embedding 标记(param.shared),并让 optimizer.param_groups 改指 main_param。
  • 带 hysteresis 的 DynamicGradScaler:遇到 inf/NaN 溢出时,Megatron 本轮必跳过权重更新,但并不会在首次溢出时立刻缩小 $S$,而是扣减一次累计计数器 _hysteresis_tracker,直到累计溢出满 hysteresis 次才执行 $\max(S \cdot \text{backoff\_factor},\, S_{\min})$ 并重置;反之连续 growth_interval 步无溢出才按 growth_factor 放大。
# 初始化 FP32 主权重(脱离计算图 + 独立内存)与动态缩放器的核心逻辑 [11]
main_param = param.detach().clone().float()
mpu.copy_tensor_model_parallel_attributes(main_param, param)

# DynamicGradScaler.update(found_inf): 累计 hysteresis 次溢出才退避,连续 growth_interval 无溢出才放大
if found_inf:
    self._growth_tracker = 0
    self._hysteresis_tracker -= 1
    if self._hysteresis_tracker <= 0:
        self._scale = torch.max(self._scale * self.backoff_factor, self.min_scale)
else:
    self._growth_tracker += 1
    if self._growth_tracker == self.growth_interval:
        self._growth_tracker = 0
        self._hysteresis_tracker = self.hysteresis
        self._scale = self._scale * self.growth_factor

在此基础上,Float16OptimizerWithFloat16Params.step() 每步严格按这 6 步推进:

  1. 梯度搬运与升精度(_copy_model_grads_to_main_grads):从 model_param.main_grad(或 .grad)转成 FP32 赋给 main_param.grad。
  2. 反缩放与全局 found_inf 共识(_unscale_main_grads_and_check_for_nan):先调用 torch._amp_foreach_non_finite_check_and_unscale_ 本地检查 inf/NaN 并除以 $S$,再对整个模型并行组(TP × PP)做一次标量 all_reduce(MAX),接着调用 grad_scaler.update(found_inf_flag);只要集群里任意一卡溢出,全体一齐跳过本步更新。
  3. 全局 L2 梯度裁剪(clip_grad_norm):当全局梯度范数 $\|g\|_2 = \sqrt{\sum_{r \in \text{TP}} \sum_{s \in \text{PP}} \|g_{r,s}\|_2^2} \gt c$ 时按 $g \leftarrow \frac{c}{\|g\|_2} g$ 整体缩放(求和时剔除 TP 组内重复参数如 LayerNorm,以免多算 TP 倍)。
  4. 零梯度统计(可选):count_zeros() 记录梯度的稀疏情况。
  5. 更新主权重(self.optimizer.step()):用裁剪后的 FP32 梯度更新 FP32 main_param(以及自始至终为 FP32 的 LN/BN 参数)。
  6. 回写计算副本(_copy_main_params_to_model_params):通过 Apex 的 _multi_tensor_copy_this_to_that(一个 kernel 内批量强转)把最新 FP32 主权重刷回 FP16/BF16 model_param。

分片与集合通信

设备网格与下标

卡数一多,光靠口头说“按行切、按列切”很容易糊涂。更好的做法是先给集群设备命名成一个多维网格,比如 32 张 GPU 组成 $\text{Mesh}(X=8, Y=4)$,再直接把切分轴写成张量维度的下标[1]:

  • $A[I, J]$(完全复制):没有下标,每张卡各自拿完整一份 $A$。
  • $A[I_X, J]$(单轴分片、跨轴复制):第 1 维沿 $X$ 切分、第 2 维不切;物理轴 $Y$ 没出现,代表在 $Y$ 方向上是互相复制的。
  • $A[I_X, J_Y]$(二维正交分片):每张卡拿 $\left(\frac{|I|}{|X|}, \frac{|J|}{|Y|}\right)$,内存降为 $1 / (|X|\cdot|Y|)$。
  • $A[I_{XY}, J]$(多轴合并切分):把 $X$ 和 $Y$ 展平后一起切分维度 $I$。
  • $A[I_X, J_X]$(非法):同一物理轴 $X$ 不能在同一张量上切两维,否则只有对角块存在。
  • $C[I, K]\{U_X\}$(未归约部分和):沿 $X$ 轴各卡拿到同形状 $[I, K]$ 的部分和,真值等于整组按位置相加。
import jax, jax.numpy as jnp

mesh = jax.make_mesh(axis_sizes=(8, 4), axis_names=('X', 'Y'))
P = lambda *spec: jax.NamedSharding(mesh, jax.sharding.PartitionSpec(*spec))

# E 只沿 4 卡的 Y 轴切,F 不切(沿着 X 轴有 8 份相同副本)
A = jnp.zeros((2048, 8192), dtype=jnp.bfloat16, device=P('Y', None))

举个很直观的例子:在 32 卡 $\text{Mesh}(X=8, Y=4)$ 上放一个形状 $[2048, 8192]$ 的 BF16 矩阵 $A$。同样是切第 0 维,$A[E_Y, F]$ 与 $A[E_{XY}, F]$ 的显存行为完全不同:前者只在 4 卡的 $Y$ 轴上切分,每卡拿着 $2048 / 4 = 512$ 行($512 \times 8192 \times 2\text{ B} = \mathbf{8\text{ MiB}}$),整网沿 $X$ 轴复制了 8 组;而如果要把行平摊到全部 32 张卡上,让每卡只拿 $64$ 行($\mathbf{1\text{ MiB}}$),下标必须写成 $A[E_{XY}, F]$。反过来从通信也很好验算:沿着 4 卡的 $Y$ 轴做一次 AllGather_Y,$512 \times 4 = 2048$ 正好拼回完整矩阵,而 $64 \times 4 = 256$ 还差 8 倍。

图 1:在 32 卡 Mesh(X=8, Y=4) 上对比 A[E_Y, F]、A[E_XY, F] 与 A[E_Y, F_X] 的本地切片、占用大小及同片副本分布,可点击任意卡查看。

四种集合通信

集合通信里的 All 指参与某个命名轴的一整组卡(例如固定 $X$ 的 4 张 $Y$ 轴卡)。区分四兄弟只看两件事:要不要按位置相加?做完每张卡拿到完整结果还是只留一片?

原语 分片签名 通信动作 常见训练环节
AllGather $[A_X, B] \to [A, B]$ 收集各卡切片按序拼成完整张量,消去下标 $X$ ZeRO-3 / FSDP 计算前临时拼回本层权重
ReduceScatter $[A, B]\{U_X\} \to [A_X, B]$ 按位置求和,再按某维切分留给各卡 梯度求和后各卡只保留自己管的那一片
AllReduce $[A_X, B]\{U_Y\} \to [A_X, B]$ 求和后让每张卡拿到完整总和($\text{RS} + \text{AG}$) DDP 同步梯度,或 TP 行并行合并部分和
All-to-All $[E_Y, F] \to [E, F_Y]$ 每卡切 $N$ 块,把第 $j$ 块发往第 $j$ 卡并拼接 MoE 路由发 token,或把行切分转为列切分

把同样两个初始向量喂给四种操作($\text{GPU}_0 = [1, 2]$、$\text{GPU}_1 = [3, 4]$),结果一目了然:

操作 GPU 0 结果 GPU 1 结果 单卡体积变化
初始输入 $[1, 2]$ $[3, 4]$ 各持原始半片($1\times$)
AllGather $[1, 2, 3, 4]$ $[1, 2, 3, 4]$ 直接拼接不求和,膨胀到 $2\times$
ReduceScatter $[1+3] = [4]$ $[2+4] = [6]$ 先归约相加再分发,缩减至 $0.5\times$
AllReduce $[4, 6]$ $[4, 6]$ 归约后人人拿完整和,先 RS 再 AG
All-to-All $[1, 3]$ $[2, 4]$ GPU 0 收第 0 块、GPU 1 收第 1 块,总体积不变

这里顺便厘清两个常见混淆。第一,AllReduce 不是 AllGather + Scatter,而是 ReduceScatter + AllGather:前半步完成按位置累加并分片(拿到 $[4]$ 与 $[6]$),后半步把分片拼回完整张量 $[4, 6]$;一旦下游计算只需要分片,做到 ReduceScatter 就停手,能直接省掉一半流量。

图 2:以 $[1, 2]$ 与 $[3, 4]$ 为输入,四种集合通信的数据流向与输出差异,其中 AllReduce 分解为 ReduceScatter + AllGather。

第二,AllGather 和 All-to-All 都在做拼接,但前者让全组拿同一份完整矩阵,后者只换切分方向。回到 $4$ 卡 $Y$ 组的 $A[E_Y, F]$(每卡起初各持 $512 \times 8192$,共 $8\text{ MiB}$):

操作 每张卡发送内容 结果形状 单卡显存
$\text{AllGather}_Y$ 把自己完整的 512 行广播给组内其余 3 卡 $[2048, 8192]$ $32\text{ MiB}$($4\times$)
$\text{AllToAll}_Y$ 把 8192 列切成 4 段,第 $j$ 段发往第 $j$ 卡 $[2048, 2048]$ $8\text{ MiB}$($1\times$)

在 AllToAll_Y 下,GPU 0 从四张卡各自收集「512 行 × 前 2048 列」并沿行拼起来,于是「每卡管一段行」就无冗余地变成了「每卡管一段列」。

图 3:相同初始矩阵 $A[E_Y, F]$ 在 4 卡 Y 轴上执行 AllGather_Y(显存膨胀 4 倍)与 AllToAll_Y(行切转列切、显存零膨胀)的对照。

选型只需问“下一步缺什么”:

  • 手里只有切片、下一步要完整张量 $\implies$ AllGather
  • 手里是完整部分和 $\{U_X\}$、下一步要人人拿完整和 $\implies$ AllReduce
  • 手里是完整部分和 $\{U_X\}$、下一步只需各自那一片 $\implies$ ReduceScatter
  • 要把按 $A$ 维切分转成按 $B$ 维切分(或把 token 路由到对应专家卡)$\implies$ All-to-All

通信耗时与对偶性

记未切分完整张量总字节为 $V$、轴上卡数为 $|X|$、单向链路带宽为 $W_{\text{ici}}$、单跳启动延迟为 $T_{\min}$。在双向环上跑 AllGather 或 ReduceScatter 时,每卡把 $\frac{V}{|X|}$ 分片同时向左右发送,覆盖全环需约 $\frac{|X|}{2}$ 跳;若同时跨越 $N_{\text{axes}}$ 个正交硬件轴,带宽同步放大,耗时的 Roofline 为:

$$T_{\text{AG / RS}} = \max\!\left(\frac{T_{\min} \cdot \sum_i |X_i|}{2},\; \frac{V}{W_{\text{ici}} \cdot N_{\text{axes}}}\right)$$

在带宽受限区(大张量),AllGather 和 ReduceScatter 耗时 $\frac{V}{W_{\text{ici}}}$ 与组内卡数 $|X|$ 基本无关,而 AllReduce 由两者串联,带宽耗时恰好翻倍成 $\frac{2V}{W_{\text{ici}}}$。

相比之下,双向环上的 All-to-All 只要 AllGather 四分之一的时间:AllGather 要把整份本地切片传过全部跨距,总流量按 $D^2$ 算;All-to-All 发往不同目标卡的数据互不相同,最近邻居只传 1 跳、最远只走 $D/2$ 跳,三角和压缩后总传输量降到 $1/4$。推广到多维网格 $(A \times B \times \dots)$ 共 $N$ 卡:

$$T_{\text{AllToAll}} = \frac{V \cdot \max(A, B, \dots)}{4 \cdot N \cdot W_{\text{ici}}} \xrightarrow{\text{1D 环 } (N = A)} \frac{V}{4 \cdot W_{\text{ici}}} = \frac{1}{4}\, T_{\text{AllGather}}$$
图 4:4 卡双向环上的逐跳通信过程,以及大张量带宽受限区四种原语的相对耗时(All-to-All 仅需 AllGather 的 1/4)。

最后还有一个在 FSDP 和序列并行里反复出现的数学对称性:用全 1 列向量 $\mathbf{u} \in \mathbb{R}^p$ 与 Kronecker 积 $\otimes$ 把 broadcast 和 reduce 写成线性算子矩阵:

$$\begin{aligned} \text{broadcast} &= \mathbf{u} \otimes \mathbf{I}_n, & \text{reduce} &= \mathbf{u}^\top \otimes \mathbf{I}_n = \text{broadcast}^\top \\ \text{AllGather} &= \text{broadcast} \otimes \mathbf{I}_p, & \text{ReduceScatter} &= \text{reduce} \otimes \mathbf{I}_p = \text{AllGather}^\top \end{aligned}$$

因为线性算子 $y = \mathcal{A}x$ 的反向梯度是 $\mathcal{A}^\top$,所以前向 AllGather 在反向求导时天然对应 ReduceScatter,反过来也一样。

分布式矩阵乘法

任何分布式的线性层都能写成 $A[I, J] \cdot B[J, K] \to C[I, K]$($J$ 是收缩内维)。按切分位置看,只有四种合法或需解冲突的情形:

  1. 收缩维 $J$ 两侧都不切:$A[I_X, J] \cdot B[J, K_Y] \to C[I_X, K_Y]$。前向零通信,典型例子就是标准 DP 前向和 Megatron 列并行。
  2. 仅一侧切了收缩维:$A[I, J_X] \cdot B[J, K]$。工程上(比如 FSDP)先执行 AllGather_X 把参数拼回完整矩阵,再本地相乘。在硬件算力 $C$、链路带宽 $W_{\text{ici}}$ 下,耗时 $\max(\frac{2BDF}{C}, \frac{2DF}{W_{\text{ici}}})$,只要微批总 token 数 $B > \frac{C}{W_{\text{ici}}}$ 就能把通信藏进算力里。之所以不采用“本地算完再 AllReduce”路线,是因为训练时激活通常也切在同一个 $X$ 轴上,冲突时只允许先把权重取回来。
  3. 两侧都在同轴 $X$ 切了收缩维:$A[I, J_X] \cdot_{\text{LOCAL}} B[J_X, K] \to C[I, K]\{U_X\}$。本地直接乘完,产出部分和 $\{U_X\}$,随后接 AllReduce_X(Megatron 行并行)或 ReduceScatter 保持输出切片(DP 梯度或序列并行)。
  4. 自由外维 $I, K$ 撞在同一轴 $X$ 上:$A[I_X, J] \cdot B[J, K_X]$。第 $i$ 卡只能算对角块 $(I_i, K_i)$,必须先对占用较小的一侧做 AllGather_X 解开冲突。

真正在 GPU 核里跑第 2、3 种情形时,可以把环上切块传输和分块 Tensor Core 乘加流水重叠起来(Collective Matmul),算第 $k-1$ 块的同时已经把第 $k$ 块拉到本地了。

图 5:分布式矩阵乘法 $A \cdot B \to C$ 的四种分片情形,决定每一步需要“零通信”、“前置 AllGather”还是“后置 AllReduce / ReduceScatter”。

数据并行与 ZeRO

DP 与 DDP

数据并行就是前向用情形 1(切 Batch 维 $B_{\text{DP}}$)、反向算权重梯度时沿 $B_{\text{DP}}$ 收缩,从而触发情形 3 得到部分和 $\{U_{\text{DP}}\}$。

最早的参数服务器(Parameter Server)DP[8] 由 1 个梯度聚合 Server(单机下常直接指定 GPU 0)和多个计算 Worker 组成。Worker 算完各自微批梯度 Push 给 Server 聚合,再 Pull 回全局梯度更新权重;若每张卡梯度为 $\Phi$、共 $N$ 卡,Server 收发各 $N\Phi$(全网总流量 $2N\Phi$),多机场景下 Server 成了随 $N$ 线性膨胀的单点带宽瓶颈(多 Server 模式可分摊到多个节点)。

为避免 Worker 在 Server 搬运期间空等,PS 也常配异步梯度更新(Bounded Delay):允许 Worker 在上一轮梯度未写回前继续用旧权重算下一批(如 1-Bounded Delay 要求第 12 轮开始前已完成第 10、11 轮更新),用略慢的 SGD 收敛换取更高的硬件利用率。

DDP 采用 Ring-AllReduce 彻底去掉中心服务器:每张卡把自己算出的完整梯度(切分的是梯度而非样本批)划成 $N$ 块(每块 $\Phi/N$),按环拓扑只与左右邻居通信——先跑 $N-1$ 跳 ReduceScatter(每卡发出 $(N-1)\frac{\Phi}{N}$ 并在主槽收齐总和),再跑 $N-1$ 跳 AllGather(同样发出 $(N-1)\frac{\Phi}{N}$ 广播完整和),每卡发送量恒为 $\mathbf{2\frac{N-1}{N}\Phi \approx 2\Phi}$,与总卡数 $N$ 无关。

工程上 PyTorch DDP 通过一卡一进程消除 GIL,依靠 C++ Reducer 将参数按反向计算逆序装进约 25 MB 的通信桶(bucket),把梯度同步异步隐藏在正在进行的反向计算背后。

ZeRO 与 FSDP

DDP 把通信摊平了,但 $N$ 张卡仍死存着 $N$ 份一模一样的 $16\Phi$ 模型状态,并各自重跑完全相同的 Adam 更新。DeepSpeed ZeRO[4][9](及 PyTorch FSDP)把“用完即弃、需要再拉”发挥到极致,沿数据并行组 $N_d$ 逐级切分优化器状态 $P_{os}$、梯度 $P_g$ 与参数 $P_p$:

拿之前两张卡的小数字举例($\text{GPU}_0$ 本地梯度 $g_0=[1,2]$,$\text{GPU}_1$ 为 $g_1=[3,4]$):在 DDP 下,AllReduce 后两张卡都拿着 $[4,6]$ 更新整套参数;而在 ZeRO-3 / FSDP 下,$\text{GPU}_0$ 平时只存前一半权重 $W_0$ 与优化器状态 $\text{OS}_0$,每次计算本层前向或反向前通过 AllGather(W) 临时借用完整权重、算完即删,随后直接跑 ReduceScatter(g)(正是前面的 Kronecker 转置对偶!),让 $\text{GPU}_0$ 只拿 $[4]$ 更新 $W_0$、$\text{GPU}_1$ 只拿 $[6]$ 更新 $W_1$。

策略 切分状态 单卡静态显存 7.5B (N=64) 单卡通信
DDP 无 $16\Phi$ 120 GB $2\Phi$(1×)
ZeRO-1 优化器状态 $P_{os}$ $4\Phi + \frac{12\Phi}{N_d}$ 31.4 GB $2\Phi$ / 论文 $3\Phi$
ZeRO-2 $P_{os}$ + 梯度 $P_g$ $2\Phi + \frac{14\Phi}{N_d}$ 16.6 GB $2\Phi$(1×)
ZeRO-3 / FSDP $P_{os}$ + $P_g$ + 权重 $P_p$ $\frac{16\Phi}{N_d}$ 1.9 GB $3\Phi$(1.5×)

关于 ZeRO-1 通信量的论文 vs 实操差异:原论文按概念把 Stage 1 写成对完整梯度做 AllReduce($2\Phi$)再对更新后权重做 AllGather($\Phi$),总计 $3\Phi$;而工程实现直接用 ReduceScatter(G)($\Phi$)配 AllGather(W)($\Phi$),流量与 Stage 2 同为 $2\Phi$。不过在 $m$ 步梯度累积(Gradient Accumulation)时,Stage 1 保留完整梯度能在本地累计满 $m$ 步再通信一次(省掉 $m-1$ 轮同步流量),而 Stage 2 每步算完层就得立刻散播梯度。

从 2 卡 PyTorch Memory Snapshot 实测还可以看到两个工程细节:

  • FP16 权重原地复用显存:ZeRO-1 更新后直接通过 _copy_(fp32) 就地覆盖计算副本并持久复用显存池。
  • Adam 动量惰性分配:一、二阶动量 $m, v$ 要等到第一个没有 NaN/inf 溢出、真正执行 step() 的迭代才会分配显存。

本质上,ZeRO 是“模型并行的形式,数据并行的实质”:即便 Stage 3 把权重也切到各卡,每次逐层计算前依然靠 AllGather 凑出该层完整权重(用完即删 peer 分片,避免全网峰值),各卡处理的依然是互不相同的样本 $X_i$。

在此之上,ZeRO-R 专门从三方面治理剩余状态:

  • $P_a$(激活切分):对张量模型并行(TP)组内的重复激活做切分(纯 DP 激活本就按 batch 切分)。
  • $C_B$(定长通信缓冲):先攒够固定大小的 buffer 再发送,避免零碎小包打不满通信带宽。
  • $M_D$(显存碎片整理):定期重整长短寿命张量交错释放留下的 HBM 碎片。

若显存依然吃紧,ZeRO-Offload / ZeRO-Infinity 会把计算密集的前/反向 FP16 权重与激活留在 GPU,把大显存低算力的 FP32 主权重、Adam 动量和参数更新计算卸载到 CPU 内存。

图 6:DDP 与 ZeRO-3 / FSDP 步内显存驻留和通信操作对照,以及 N=8 时单卡静态模型状态的压缩幅度。

张量并行

MLP、注意力与词表

ZeRO 没法摊薄单个微批计算瞬间的层内激活,单样本太大时依然放不下。张量并行(TP)[2][10]直接把单个线性层 $Y = X W$($X:[b,s,h]$,$W:[h,h']$)按行或按列切开:

  • 按行切(沿输入维 $h$):必须把 $X$ 同步按列切成 $X_1, X_2$;前向靠算子 $g$ 对部分和求和 $Y = X_1 W_1 + X_2 W_2$,反向则把梯度复制下发、再由算子 $f$ 把各卡 $\partial\mathcal{L}/\partial X_i$ 拼回。
  • 按列切(沿输出维 $h'$):每张卡只需拿完整 $X$ 算出各自输出片 $Y_i = X W_i$ 并拼接;反向时因为 $X$ 同时参与了每路乘法,算子 $f$ 必须将各卡传回的 $\partial\mathcal{L}/\partial X|_i$ 做 AllReduce 求和。

Megatron-LM 把列并行和行并行一前一后配对,恰好让夹在中间的非线性函数和 Softmax 全程零通信跑完:

  • MLP 层:输入 $X \in \mathbb{R}^{b \times s \times h}$,第一层权重按列切为 $A = [A_0, A_1]$,第二层按行切为 $B = \begin{bmatrix} B_0 \\ B_1 \end{bmatrix}$。之所以不先做行切,是因为 GeLU 非线性不可拆:$\text{GeLU}(Y_1+Y_2) \neq \text{GeLU}(Y_1)+\text{GeLU}(Y_2)$,若先做行切必须额外插一次 AllReduce;而按列切满足 $\text{GeLU}([Y_1,Y_2]) = [\text{GeLU}(Y_1),\text{GeLU}(Y_2)]$,各卡独立算完 GeLU 再喂进 $B_i$,仅出口做 1 次 AllReduce,整块前向 + 反向共 2 次 AllReduce(按半步通信量 $\Phi_{\text{TP}}=bsh$ 算共 $4bsh$):$$Z = \text{AllReduce}\!\left(\sum_i \text{GeLU}(X A_i)\, B_i\right)$$
  • 多头注意力(MHA):按 Head 数天然列切 $W^Q, W^K, W^V$(每卡各算 $h / \text{TP}$ 个独立完整的头,需保证总头数被 $\text{TP}$ 整除),输出投影矩阵 $W^O$ 按行切分,末尾同样是前向 1 次、反向 1 次共 $4bsh$。合计每个标准 Transformer 层在 TP 下前向 2 次、反向 2 次共 4 次 AllReduce($8bsh$);若叠加序列并行(Megatron-SP)[3],则将 AllReduce 拆成 AllGather 与 ReduceScatter,总字节完全不变,但消除了 LayerNorm 与 Dropout 残差路径上 TP 倍冗余激活。
  • 词表与输出交叉熵(VocabParallelCrossEntropy):Position Embedding $[s_{\max}, h]$ 较小可全卡复制,但 Word Embedding $[V, h]$ 按词表区间切分。例如 $V=300$ 分到 2 卡 $[0,150)$ 与 $[150,299)$、输入序列 [0,212,7,9] 时,两卡查表得 [ok,0,ok,ok] 与 [0,ok,0,0],一次 AllReduce 直接相加复原完整词向量。注意若同时开了 $\text{PP} \gt 1$,由于输入和输出共享同一套 Word Embedding,优化器更新前必须在第一和最后一个 Pipeline Stage 之间对词表梯度做 AllReduce。到了输出端计算交叉熵,如果直接 AllGather $[b,s,V]$ logits 会多传 $bsV$ 流量;改为各卡只同步三个轻量的 $[b,s]$ 标量(全局最大值做数值稳定、局部 $\sum e^{z'}$ 与目标 logit): $$\begin{aligned} m_{\text{global}} &= \text{AllReduce}_{\max}\!\left(\max_{j \in V_i} z_{i,j}\right), \qquad z'_{i,j} = z_{i,j} - m_{\text{global}} \\ S_{\text{global}} &= \text{AllReduce}_{\text{sum}}\!\left(\sum_{j \in V_i} e^{z'_{i,j}}\right), \qquad z'_{\text{target}} = \text{AllReduce}_{\text{sum}}\!\left(\mathbb{I}[y \in V_i]\, z'_{i,y}\right) \\ \mathcal{L} &= \log S_{\text{global}} - z'_{\text{target}} \end{aligned}$$

为什么工程上一定把 TP 锁在单机内、DP 放到跨机间?主要有两层原因:

  • 每层通信量对比:TP 每层通信量为 $8bsh$,标准 DP 为 $2h^2$,约掉公因子 $h$ 后即对比 $[b\cdot s]$ 与 $[h]$——两者同处 $10^5$ 量级,但大序列场景下 TP 通信量通常更大。
  • 决定性差异——反向梯度是否阻塞:DP 把本层算完的梯度扔进后台异步 AllReduce 后,下一层反向立刻接着计算;而 TP 每一层反向都必须死等本层 AllReduce 回传完 $\partial\mathcal{L}/\partial X$ 才能继续往下传播。

实测数据印证了这一点:Megatron 在 32 台 16 卡 DGX-2H(512 × V100-32GB)训练 GPT-2(1.2B → 8.3B)时,单机纯 TP 从 1→2→4→8 卡扩展效率为 100%→95%→82%→77%(每机用到 8 卡即顶满,更大学模型单机仍受激活显存限制);再在外围叠加 64 路跨机 DP 到 512 卡后,总吞吐达 15,100 TFLOPs,对比无通信理想值 $39 \times 512 = 19{,}968\text{ TFLOPs}$ 依然保持 76% Weak Scaling 利用率。

Megatron 实现细节

落地到 Megatron 的 mpu(parallel_state)源码,多维并行跑得通、不漂移,靠的是三处精细设计:

1. 3D 进程组划分(initialize_model_parallel):Megatron 固定按内层 TP → 中层 DP → 外层 PP的顺序展开全局 Rank 编号。假设 16 张卡(两台 8 卡机器)配 $\text{TP}=2, \text{PP}=2, \text{DP}=4$,这四套正交通信域各自承担完全不同的流量:

  • TP 组(步长 $1$,共 $8$ 个 $2$ 卡组):[0,1], [2,3], ..., [14,15],相邻编号保证落在同一台机的 NVLink 内。
  • DP 组(步长 $\text{TP}=2$,共 $4$ 个 $4$ 卡组):Stage 0 为 [0,2,4,6] 与 [1,3,5,7],Stage 1 为 [8,10,12,14] 与 [9,11,13,15]——专门在同位置切片的副本之间同步梯度。
  • PP 组(步长 $\text{world}/\text{PP}=8$,共 $8$ 条 $2$ 卡流水线):[0,8], [1,9], ..., [7,15],跨节点衔接不同流水阶段。
  • 模型并行全组 $\text{MP} = \text{TP} \times \text{PP}$(共 $4$ 个 $4$ 卡组):[0,1,8,9], [2,3,10,11], [4,5,12,13], [6,7,14,15]——每一组凑齐 1 份完整模型,专门给上一节的全局 found_inf 共识和全局 L2 梯度裁剪用。
图 7:16 卡集群($\text{TP}=2, \text{PP}=2, \text{DP}=4$)在 initialize_model_parallel 中生成的四套正交通信域与编号规律。

对应到 Megatron 的初始化源码,四重循环按上述步长构造全局排好序的 Rank 列表,并调用 torch.distributed.new_group(ranks);注意 PyTorch 要求哪怕当前卡不在某个 ranks 列表里,全集群所有进程也必须按完全相同的顺序一起调用 new_group 才能避免集合通信建组死锁:

def initialize_model_parallel(tp_size: int = 2, pp_size: int = 2):
    world_size = dist.get_world_size()          # 例如 16 = TP(2) * PP(2) * DP(4)
    rank = dist.get_rank()
    dp_size = world_size // (tp_size * pp_size)
    num_tp_groups = world_size // tp_size       # 8 个 TP 组
    num_pp_groups = world_size // pp_size       # 8 条 PP 流水线

    # 1. DP 组 (步长 = tp_size): [0,2,4,6], [1,3,5,7], ...
    for i in range(pp_size):
        start = i * num_pp_groups
        end = (i + 1) * num_pp_groups
        for j in range(tp_size):
            ranks = list(range(start + j, end, tp_size))
            group = dist.new_group(ranks)
            if rank in ranks:
                _DATA_PARALLEL_GROUP = group

    # 2. Tensor Parallel 组 (连续相邻, 步长 = 1):[0,1], [2,3], ..., [14,15]
    for i in range(num_tp_groups):
        ranks = list(range(i * tp_size, (i + 1) * tp_size))
        group = dist.new_group(ranks)
        if rank in ranks:
            _TENSOR_MODEL_PARALLEL_GROUP = group

    # 3. Pipeline Parallel 组 (步长 = num_pp_groups = 8):[0,8], [1,9], ..., [7,15]
    for i in range(num_pp_groups):
        ranks = list(range(i, world_size, num_pp_groups))
        group = dist.new_group(ranks)
        if rank in ranks:
            _PIPELINE_MODEL_PARALLEL_GROUP = group

    # 4. Model Parallel 全组 (TP x PP):[0,1,8,9], [2,3,10,11], [4,5,12,13], [6,7,14,15]
    for i in range(dp_size):
        ranks = [i * tp_size + p * num_pp_groups + t
                 for p in range(pp_size) for t in range(tp_size)]
        group = dist.new_group(ranks)
        if rank in ranks:
            _MODEL_PARALLEL_GROUP = group

2. 前反向对偶(conjugate)算子 f / g 与并行线性层串联:ColumnParallelLinear 入口调用算子 f(若 gather_output=False 则直接把切片结果交给 GeLU),随后 RowParallelLinear(input_is_parallel=True)直接吃切片输入并在出口调用算子 g。前向把同一份 $X$ 喂给所有 $A_i$,反向根据链式法则必须把各支路偏导加起来($\frac{\partial\mathcal{L}}{\partial X} = \sum_i \frac{\partial\mathcal{L}}{\partial Y_i}A_i^\top$),正好落在 f.backward 上:

class _CopyToModelParallelRegion(torch.autograd.Function):
    """算子 f:前向 Identity,反向 AllReduce(SP 开启时改为 ReduceScatter)"""
    @staticmethod
    def forward(ctx, input_): return input_
    @staticmethod
    def backward(ctx, grad_output): return _reduce(grad_output)

class _ReduceFromModelParallelRegion(torch.autograd.Function):
    """算子 g:前向 AllReduce(SP 开启时改为 ReduceScatter),反向 Identity"""
    @staticmethod
    def forward(ctx, input_): return _reduce(input_)
    @staticmethod
    def backward(ctx, grad_output): return grad_output

# ParallelMLP 前向组合(中间 GeLU 零通信):
# x -> f -> ColParallelLinear(gather_output=False) -> GeLU
#   -> RowParallelLinear(input_is_parallel=True) -> g -> out
图 8:Megatron-LM MLP 的前向 / 反向信号流与对偶算子 f / g;可切换查看开启 TP + SP 后如何将 AllReduce 拆回 AllGather 与 ReduceScatter。

3. 随机数状态追踪器(CudaRNGStatesTracker):Dropout 在模型并行区内外不能混用同一颗种子。切分后的隐状态上各卡负责不同神经元,需要用 base_seed + 2718 + tp_rank 初始化独立且固定的 model-parallel-rng;而在并行区外完全复制的残差流上,所有 TP 卡必须退出上下文切换回基础种子产生完全同步的掩码:

with get_cuda_rng_tracker().fork('model-parallel-rng'):
    # 切分区域(如自注意力头内部的 dropout):不同 tp_rank 掩码独立
    attention_probs = self.attention_dropout(attention_probs)
# 退出上下文后恢复共享 base_seed(残差流 dropout):同组 tp_rank 掩码完全一致
hidden_states = self.hidden_dropout(output)

正因为 TP 的同步 AllReduce 卡死在层内关键路径上无法异步掩盖,工程上几乎总是把 $\text{TP} \le 8$ 锁在单机 NVLink 域之内。

流水线并行

GPipe 与 1F1B

模型突破单机 8 卡放不下时,不能硬把 TP 跨机扩出去,转而沿网络深度垂直切分成 $P$ 个阶段(Stage)的流水线并行(PP),阶段之间只用极轻量的 P2P send/recv 传边界激活。

如果一次喂完整 Batch,同一时间只有 1 个阶段在跑,$P=4$ 时空闲气泡高达 $\frac{P-1}{P} = 75\%$。GPipe[5] 把 Batch 切成 $M$ 份微批次(Micro-batch)连续推入流水线,设前/反向单格各耗时 1 个节拍,总气泡率立即缩为:

$$r_{\text{GPipe}} = \frac{P - 1}{M + P - 1}$$

当 $M \ge 4P$(例如 $P=4, M=16$)时,气泡率降到 $\frac{3}{19} \approx 15.8\%$。

但前向积攒全部 $M$ 个微批次的激活会把 Stage 0 撑爆,所以 GPipe 标配了激活重计算(Re-materialization):前向时 Stage 内只保留边界输入、丢掉中间激活,等反向轮到时现场重算一次前向。这样用约 33% 额外算力换取了峰值显存降到 $\mathcal{O}\!\left(N + \frac{L}{P}\cdot\frac{N}{M}\right)$。

即便开了重计算,GPipe 依然要等所有 $M$ 份前向边界输入全算完才开始反向,Stage 0 缓存的微批数仍随 $\mathcal{O}(M)$ 线性增长。后续流水线调度通过交错前反向解决了这一瓶颈:

  • 1F1B:流水线填满后严格交替执行「一步前向 + 一步反向 + 立即释放激活」,气泡率与 GPipe 相同,却把峰值缓存微批数永久压低到阶段数 $\mathcal{O}(P)$。
  • Interleaved 1F1B:把每个阶段交错拆成 $v$ 个更细的层块,用稍微多一些的 P2P 通信把气泡率进一步压缩至 $\frac{P-1}{vM + P - 1}$。

注意实战里首尾两个 Stage 额外承载了 Embedding 与词表输出头,通常要适度减少首尾分配的 Transformer 层数以防显存和算力失衡。

图 9:$P=4, M=8$ 下 Naive、GPipe、1F1B 与 Interleaved v=2 的时间线推进,右侧实时显示 Stage 0 同时缓存的微批激活数量($\mathcal{O}(M)$ vs $\mathcal{O}(P)$)。

MoE 专家并行

路由与负载均衡

想继续做大总参数量、又不想让每个 token 的推理/训练算力同步线性暴涨,就会引入 MoE(Mixture-of-Experts):把 FFN 换成 $E$ 个专家子网,每个 token 每次由门控投影 $P = \text{Softmax}(x W_g)$ 动态选出得分最高的 Top-$k$ 个专家。

为让 GPU 内核保持规整的静态张量形状,不能任由 token 无限挤进同一个热门专家,需要预先规定每个专家槽位容量(Expert Capacity)[6]:

$$C = \left\lceil \frac{N_{\text{tokens}} \cdot k}{E} \cdot \text{capacity\_factor} \right\rceil$$

容量因子一般设 $1.0 \text{–} 1.5$。超过容量的 token 会被直接丢弃(借助残差连接跨过本层),没坐满的空槽则补零。

只靠交叉熵损失的话,门控很容易塌缩到只用少数一两个专家造成大量丢包,所以都会加一条可微分的负载均衡辅助损失:

$$\mathcal{L}_{\text{aux}} = \alpha \cdot E \sum_{i=1}^{E} f_i \cdot P_i$$

其中 $f_i$ 是该批实际落入专家 $i$ 的 token 比例,$P_i$ 是门控预测概率均值。由 $\sum f_i = \sum P_i = 1$ 及柯西不等式可知,当且仅当完全均衡 $f_i = P_i = 1/E$ 时损失取最小值 $\alpha$。

两趟 All-to-All 与分组

与 ZeRO-3“token 不动、搬运权重”相反,专家并行(EP)[7]让庞大的专家权重钉死在各自 GPU 上,改为靠两趟 All-to-All 来回寄送 token——而且前面已经算过,双向环上 All-to-All 的耗时只有 AllGather 的四分之一。

拿 2 卡为例:专家 $E_0$ 在 GPU 0、$E_1$ 在 GPU 1。Attention 算完后 GPU 0 拿着 $[a, b]$、GPU 1 拿着 $[c, d]$,门控把 $a, c$ 派去 $E_0$,$b, d$ 派去 $E_1$。第一趟 All-to-All(Dispatch)跨卡交换出 $b$ 和 $c$,各自就地算完专家 FFN;第二趟 All-to-All(Combine)按原路寄回,恢复成 $[a', b']$ 和 $[c', d']$ 进入下一层 Attention。

class _AllToAll(torch.autograd.Function):
    @staticmethod
    def forward(ctx, group, x):
        ctx.group = group
        out = torch.empty_like(x)
        dist.all_to_all_single(out, x, group=group)
        return out

    @staticmethod
    def backward(ctx, *grad_out):
        # All-to-All 的伴随算子仍是 All-to-All
        return (None, _AllToAll.apply(ctx.group, *grad_out))

# MOELayer forward 核心张量流:
dispatched = torch.einsum("sec,sm->ecm", dispatch_mask, x)
dispatched = _AllToAll.apply(ep_group, dispatched)          # 第 1 趟:发往目标专家
expert_out = experts(dispatched)
combined = _AllToAll.apply(ep_group, expert_out)            # 第 2 趟:原路归位
output = torch.einsum("sec,ecm->sm", combine_weights, combined)
图 10:MoE 两趟 All-to-All 完整周期,以及开启 4 卡热门偏斜场景时 CF=1.0 的容量截断与丢包示意。

在 DeepSpeed-Megatron 里,有一个很容易绕晕但非常关键的通信域拆分:非专家参数(Attention、Embedding、LN、Router)依然跨全部数据并行卡共享,而专家本身沿 $\text{EP}$ 切开了。假设共有 $8$ 张 DP 卡、$4$ 个专家且设 $\text{EP} = 4$,那整群恰好放下 $2$ 份专家副本——也就是 $\text{DP}(8) = \text{EP}(4) \times \text{EDP}(2)$:

  • EP 组({0,1,2,3} 和 {4,5,6,7}):组内拼齐 4 个不同专家,跑两趟 All-to-All 路由 token。
  • EDP 组({0,4}, {1,5}, {2,6}, {3,7}):只在编号相同的专家副本之间做梯度 AllReduce(GPU 0 的 $E_0$ 绝不会和 GPU 1 的 $E_1$ 混在一起求平均)。
  • 全局 DP 组({0..7}):其余共享参数照旧全组 8 卡一起同步梯度。

此外每个专家的 FFN 内部还可以继续套机内 TP,集群总规模保持 $\text{world\_size} = \text{PP} \times \text{DP} \times \text{TP}$,而专家分支拆成 $\text{DP} = \text{EP} \times \text{EDP}$。

图 11:8 卡集群上的正交分组 DP(8) = EP(4) × EDP(2):水平方向交换 token,垂直方向对齐同编号专家梯度,全局同步共享层权重。

4D 并行组合

把前面所有的维度摊到一张对照表里,组合起来的规律很明确:

策略 切分维度 核心通信 显存收益 适用链路
DDP 样本 $B_{\text{DP}}$ 反向分桶异步 AllReduce 批激活均分 $/ \text{DP}$ 最外层 IB / RoCE
ZeRO-1 / 2 +$P_{os}$ / $P_{g}$ 梯度 RS + 更新后参数 AG OS/G 均分,总流量仍 $2\Psi$ 最外层 IB / RoCE
ZeRO-3 / FSDP +$P_p$ 权重 逐层 AG(W) + RS(g),总流量 $3\Psi$ 静态状态缩为 $16\Phi / \text{DP}$ NVLink 或高带宽 IB
TP / TP+SP 层内列/行 (+$S_{\text{TP}}$) 每层前反向各 2 次阻塞通信 权重与全部层激活 $/ \text{TP}$ 机内 NVLink $(\le 8)$
PP (1F1B) 模型深度 ($P$ 阶段) 阶段间轻量 P2P send/recv 模型 $/ P$,激活封顶 $\mathcal{O}(P)$ 跨机节点(耐延迟)
EP (MoE) 离散专家 ($E_{\text{EP}}$) 每 MoE 层 2 次 All-to-All 稀疏专家权重 $/ \text{EP}$ NVLink / 满带宽 IB

落地到 64 张 H100-80GB(8 台 8 卡机) 集群时,遵循同一条原则——通信最重的维度锁进最快链路,从内往外排:

  1. 训练 70B 稠密模型($16\Phi \approx 1.12\text{ TB}$):先在单机内把 8 张卡用成 $\text{TP}=8$ 配序列并行(SP),保证关键路径每层 4 次同步绝不出网卡。单卡静态状态从 $1.12\text{ TB}$ 降到 $140\text{ GB}$,依然放不进 80 GB;接着跨 2 台机器切 $\text{PP}=2$ 配 1F1B(取微批数 $M \ge 8$ 把气泡压到 ~11%),单卡静态再劈半至 $70\text{ GB}$;剩下的 $\text{DP} = 64 / (8 \times 2) = 4$ 路叠加零额外流量的 ZeRO-1 分片优化器状态,单卡静态占用定格在 $\frac{4\Phi}{16} + \frac{12\Phi}{64} = 17.5 + 13.1 = \mathbf{30.6\text{ GB}}$,留出近 $50\text{ GB}$ 给长上下文激活。
  2. 同规模 64 卡训练稀疏 MoE:可配机内 $\text{TP}=4$ 配跨机 $\text{PP}=2$,腾出 $\text{DP}=8$ 路再精确拆成 $\text{EP}=4, \text{EDP}=2$:每组 4 卡各自切开专家跑两趟 All-to-All,EDP=2 只对齐相同专家副本,其余共享 Attention 和 Router 照常走全局 8 路 $\text{DP}$ + ZeRO-1。

引用

如果本文的笔记或交互动画对你有帮助,欢迎引用:

Chaoran Feng (2026). "Distributed LLM Training: Sharding, Collectives, and Parallelism". Chaoran Feng's Blog. https://www.falcary.com/blogs/distributed-training/

@article{feng2026distributed,
  title   = {Distributed LLM Training: Sharding, Collectives, and Parallelism},
  author  = {Feng, Chaoran},
  year    = {2026},
  month   = {October},
  url     = {https://www.falcary.com/blogs/distributed-training/}
}

参考资料

  1. How to Scale Your Model, Part 3: Sharded Matrices and How to Multiply Them. Austin, Bradbury, Blake, Chou, Douglas, Frostig, Levskaya, Pope, et al., Google DeepMind, 2025.
  2. Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism. Shoeybi et al., NVIDIA, 2019 (arXiv:1909.08053).
  3. Reducing Activation Recomputation in Large Transformer Models. Korthikanti et al., NVIDIA, 2022 (arXiv:2205.05198).
  4. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models. Rajbhandari et al., Microsoft DeepSpeed, SC 2020 (arXiv:1910.02054).
  5. GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism. Huang et al., Google Brain, NeurIPS 2019 (arXiv:1811.06965).
  6. GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding. Lepikhin et al., Google Brain, ICLR 2021 (arXiv:2006.16668).
  7. DeepSpeed-MoE: Advancing Mixture-of-Experts Inference and Training to Power Next-Generation AI Scale. Rajbhandari et al., ICML 2022 (arXiv:2201.05596).
  8. 图解大模型训练之:数据并行上篇(DP, DDP 与 ZeRO),猛猿(公众号:大猿搬砖简记),知乎。
  9. 图解大模型训练之:数据并行下篇(DeepSpeed ZeRO,零冗余优化),猛猿(公众号:大猿搬砖简记),知乎。
  10. 图解大模型训练之:张量模型并行(TP),Megatron-LM,猛猿(公众号:大猿搬砖简记),知乎。
  11. 图解大模型训练系列之:Megatron 源码解读 3,分布式混合精度训练,猛猿(公众号:大猿搬砖简记),知乎。