7.2 数据并行与 ZeRO:把模型状态拆开装

本页范围:第 7 章第 2 节 | 整理时间:2026-09-30

快速浏览

核心问题70B 模型光模型状态就要 1120 GB 显存,单卡装不下;把成百上千张卡组织起来训练,数据怎么分、梯度怎么合、显存怎么省?
本节主张数据并行(DDP)让每张卡装一份完整模型、各算各的数据、反向后把梯度跨卡求平均,用通信换算力扩展,但它不省显存;ZeRO 把模型状态(优化器状态、梯度、参数)逐级切分到各卡,用少量通信换显存随卡数线性下降;梯度累积沿时间轴摊大 batch,三根支柱彼此正交、可以叠加。
一句话结论DDP 解决「算得过来」,ZeRO 解决「装得下去」,梯度累积解决「batch 够大」——70B 模型 64 卡训练,每卡模型状态从 DDP 的 1120 GB 一路压到 ZeRO-3 的 17.5 GB。
关键词
数据并行DDPall-reducering all-reduce模型状态ZeRO梯度累积显存冗余

  7.1 节把单卡内的账算清了:混合精度加 Adam,每个参数要占 16 字节的模型状态(fp16 参数、fp16 梯度各 2 字节,fp32 主参数、动量、方差共 12 字节)。把这个账乘上模型规模,矛盾立刻尖锐起来:70B 模型仅模型状态就要 1120 GB,没有任何一张显卡装得下;就算装得下,单卡算几千亿 token 也要算到猴年马月。预训练要真正落地,必须把成百上千张卡组织成一台「大机器」。

  组织多卡有三根最基础的支柱:把数据摊到多卡(数据并行)、把模型状态切到多卡(ZeRO)、把 batch 摊到时间轴(梯度累积)。本节沿这条线展开,路线图如下:

  1. 从 DP 到 DDP:各算各的 batch,梯度跨卡求平均(7.2.1):数据并行的工作机制,ring all-reduce 如何让通信量与卡数近似无关,通信又怎样藏进计算里;
  2. 显存冗余:N 张卡存 N 份相同的家当(7.2.2):DDP 的显存账——算力摊开了,模型状态却一份没省,模型一大 DP 自己先装不下;
  3. ZeRO 三级切分:不复制,改分管(7.2.3):优化器状态、梯度、参数逐级切开,每级省多少、通信涨多少,70B 模型 64 卡算一笔对比总账;
  4. 梯度累积:把大 batch 摊到时间轴上(7.2.4):小显存装大 batch 的标准手法,loss 为什么要除以累积步数,minimind 里的真实默认配置。

  读完本节,你应该能看懂任何一份大模型训练方案里「ZeRO-2 + 梯度累积」这类配置的含义,并估算出每张卡的显存大头花在了哪。

  图 1 标出数据并行在预训练工程中的位置,图 2 展示模型状态在多张卡上的分布方式。

原创示意图 · 非论文原图 训练数据: 收集 · 清洗 · 配比 (第 1 章) 预训练: 海量语料自监督 (第 6 章) 训练工程: 并行 · 精度 · 稳定 (本节内容) 中间训练: 收口 · 长上下文 (第 8 章) SFT: 学会对话格式 (第 9 章) 偏好对齐: RLHF / DPO (第 10 章) 推理训练: RLVR / GRPO (第 11 章) 推理与部署: 解码 · 加速 (第 12–13 章) 实线框:已讲章节 虚线框:后续章节
图 1:训练工程在 LLM 生命周期中的位置。数据(第 1 章)与预训练目标(第 6 章)就位后,这一站要把训练分摊到成百上千张卡上真正跑起来,随后才轮到中间训练(第 8 章)、SFT(第 9 章)、偏好对齐(第 10 章)、推理训练(第 11 章)与推理部署(第 12–13 章)。本节是这一站的第一块拼图:只管多卡之间「数据怎么分、模型状态怎么装」。

  图 1 里这个紫框放大之后长什么样?同一个模型、同一批卡,「复制」与「分管」两种装法各是什么形状?把 DDP 与 ZeRO 并排拆开看:

原创示意图 · 非论文原图 局部放大:DDP 复制 vs ZeRO-3 分片(4 卡示意) 输入:模型状态 16Ψ(三件套)→ 输出:每卡显存占用;配色与本页图 4 一致 DDP:4 卡各存一份完整模型状态 GPU 0 = 16Ψ GPU 1 = 16Ψ GPU 2 = 16Ψ GPU 3 = 16Ψ 每卡 16Ψ · 4 卡合计 64Ψ,其中 48Ψ 是内容完全相同的复制税 ZeRO-3:不复制,改分管 三件套各切 4 片,GPU i 只保管第 i 片 优化器状态 12Ψ → 切 4 片 每片 3Ψ 梯度 2Ψ → 切 4 片 每片 0.5Ψ 参数 2Ψ → 切 4 片 每片 0.5Ψ GPU 0 各 1/4 片 = 4Ψ GPU 1 各 1/4 片 = 4Ψ GPU 2 各 1/4 片 = 4Ψ GPU 3 各 1/4 片 = 4Ψ 每卡 4Ψ · 4 卡合计 16Ψ,零冗余;要用整份时靠通信临时拼回(all-gather) 优化器状态(fp32,12Ψ) 梯度(fp16,2Ψ) 参数(fp16,2Ψ)
图 2:同一个 16Ψ 的模型状态,两种装法。上:DDP 让 4 张卡各存一份完整副本,集群合计 64Ψ,其中 48Ψ 是复制税;下:ZeRO-3 把优化器状态、梯度、参数各切 4 片,每卡只保管 1/4(合计仍 16Ψ,零冗余),代价是需要整份时靠通信临时拼回。代入正文 7.2.3 的账:70B 模型 64 卡,DDP 每卡 1120 GB,ZeRO-3 每卡 17.5 GB。

7.2.1 从 DP 到 DDP:各算各的 batch,梯度跨卡求平均

  数据并行(Data Parallelism, DP)的思想朴素得可爱:模型复制 N 份,N 张卡各拿一份;训练数据切成 N 份,各卡吃各的;唯一需要商量的事发生在反向传播之后——各卡把算出的梯度拿出来求平均,再各自用平均梯度更新参数。好比一个班分头做同一套卷子的不同页,交卷前把错题汇总对一遍答案,每人按汇总结果订正:大家起点相同、订正内容也相同,下一轮的「水平」自然仍然一致。

  把一个训练步拆开看,DP 的标准动作是五步:

  1. 一致初始化:N 张卡从同一份参数出发(同一种子或广播同一份权重);
  2. 数据切分:采样器把数据集切成互不重叠的 N 份,各卡只读自己那片(PyTorch 里叫 DistributedSampler);
  3. 各卡独立前向、反向:全程零通信,各算各的 loss 和梯度;
  4. 梯度跨卡求平均:一次集合通信,让所有卡拿到相同的平均梯度;
  5. 各卡本地更新:用平均梯度跑自己的优化器 step。

  为什么第 5 步之后各卡参数还严格一致?因为更新所需的全部输入都一致:参数一致(第 1 步保证)、梯度一致(第 4 步保证)、优化器状态一致(各卡从相同初始状态出发、历史更新完全相同)。三个一致推出下一个训练步的参数还是一致——这个「一致性不变式」是 DP 正确性的全部秘密。

  梯度求平均还有一个漂亮的数学性质:它让 N 卡训练严格等效于一个大 batch 的单卡训练。设每张卡的 batch 大小为 \(B\),第 \(i\) 张卡在自己的数据上算出梯度 \(g_i\),则平均梯度恰好等于把 \(N \times B\) 条样本拼成一个大 batch 算出的梯度:

\[ \bar{g} \;=\; \frac{1}{N}\sum_{i=1}^{N} g_i \;=\; \nabla \mathcal{L}_{\text{batch}=N \times B} \tag{1} \]
公式 (1):各卡局部梯度的平均,就是全局大 batch 的梯度——因为全局 batch 的均值损失,正是各卡局部均值损失再取平均(各卡 batch 相同时成立)。符号说明:\(\bar{g}\) 是平均梯度;\(N\) 是卡数;\(g_i\) 是第 \(i\) 张卡在本地 batch 上算出的梯度;\(\mathcal{L}_{\text{batch}=N \times B}\) 是把 N 份数据拼成大 batch 后的均值损失;\(\nabla\) 表示对全部参数求梯度。

  因此,DP 在数学上等同于大 batch 训练,只是把计算分配到了 N 张卡上。DP 下的全局 batch 也直接乘上卡数:单卡 batch 32、64 卡,全局 batch 就是 2048 条。

all-reduce 全归约 all-reduce = 全员各自出一份数据,归约(求和/平均等)后全员各拿一份相同结果

all-reduce 是一种集合通信原语:N 个参与者各贡献一个张量,按某种运算(求和、平均、取最大)归约成一份结果,再让每个人都拿到这份结果。DP 的第 4 步就是一次梯度 all-reduce。它不是某个框架的发明,而是高性能计算领域几十年的标准原语,NCCL、MPI 都提供实现。

就像 N 个人各自统计了班里一部分同学的分数,开会时把数字加总再当众宣布平均分——散会时每个人手里的平均分都一样。

  all-reduce 怎么实现,直接决定 DP 能扩到多少卡。最朴素的方案是选一张主卡:大家把梯度发给它,它求平均后广播回去。梯度和参数一样大,70B 模型就是 140 GB(fp16),主卡的网口瞬间被打爆,卡数越多堵得越死——通信量随 N 线性增长,这条路走不远。

  工业界通用的答案是 ring all-reduce:把 N 张卡排成一个环,每张卡只和左右两个邻居通信。算法分两阶段:先做 reduce-scatter,绕环 N−1 步,每步每张卡只传梯度总量的 \(1/N\),走完每卡手里攒出「全局已求和」的 \(1/N\) 切片;再做 all-gather,同样绕环 N−1 步,把这些切片分发给全员。合起来,每张卡的总发送量为:

\[ \text{每卡通信量} \;=\; 2\cdot\frac{N-1}{N}\cdot M \;\approx\; 2M \tag{2} \]
公式 (2):ring all-reduce 的每卡通信量——两个阶段各传 \((N-1)/N \cdot M\),合起来约等于两倍梯度大小,与卡数基本无关。符号说明:\(M\) 是待同步的梯度总大小(等于参数量乘以每参数字节数);\(N\) 是卡数;因子 \((N-1)/N\) 在 N 较大时趋近 1,比如 64 卡时约 0.984。卡数翻十倍,每卡通信量几乎不变——这正是 DP 能铺到上万卡的关键。

  还有一个工程细节让 DP 的实际开销比纸面更小:通信与计算重叠。反向传播是从后往前逐层算的,最后一层的梯度最早算好。PyTorch DDP 把梯度分成若干桶(bucket),某桶的梯度一齐就立即发起该桶的 all-reduce,同时继续算前面层的梯度——通信藏在计算背后,理想情况下一步训练只多出「最后一个桶」的等待时间(Li et al., 2020)。

原创示意图 · 非论文原图 完整训练数据集 数据分片 0 数据分片 1 数据分片 2 数据分片 3 GPU 0 GPU 1 GPU 2 GPU 3 完整模型副本 完整模型副本 完整模型副本 完整模型副本 前向 + 反向 前向 + 反向 前向 + 反向 前向 + 反向 本地梯度 g₀ 本地梯度 g₁ 本地梯度 g₂ 本地梯度 g₃ (此阶段零通信) (此阶段零通信) (此阶段零通信) (此阶段零通信) 梯度 all-reduce(跨卡求平均):ḡ = (g₀+g₁+g₂+g₃)/4 各自 step 更新 各自 step 更新 各自 step 更新 各自 step 更新 θ ← θ − η·ḡ θ ← θ − η·ḡ θ ← θ − η·ḡ θ ← θ − η·ḡ 一步只同步一次梯度;初始一致 + 梯度一致 ⇒ 各卡参数始终一致,等效全局 batch = 单卡 batch × 4
图 3:DDP 一个训练步的完整流程。数据被切成互不重叠的分片,各卡持完整模型副本独立前向反向,梯度经 all-reduce 求平均后各自更新,参数保持一致。

  DDP 的通信节奏:前向、反向各算各的,零通信;一步训练只在反向时同步一次梯度,通信量约两倍梯度大小,且与卡数近似无关。这就是它能从 8 卡一路扩到上万卡的原因。

7.2.2 显存冗余:N 张卡存 N 份相同的家当

  DDP 把算力和数据摊开了,显存却一份没省。回头清点每张卡必须常驻的模型状态(model states),按 7.1 节的 16 字节账,它们分三件套:

模型状态内容精度每参数显存
参数前向反向计算用的权重fp162 字节
梯度反向算出的参数梯度fp162 字节
优化器状态fp32 主参数 + 一阶动量 + 二阶动量fp3212 字节

  三样合计每参数 16 字节。关键问题是:DDP 里这 16 字节在每张卡上各存一份,且内容完全相同。N 张卡的集群,模型状态总占用是 \(16\Psi N\) 字节(\(\Psi\) 是参数量),其中真正互不相同的有效信息只有 \(1/N\)——其余全是为维持「一致性不变式」付出的复制税。拿 70B 模型、64 卡算账:每卡 1120 GB,集群合计约 71.7 TB,其中 70.6 TB 是冗余。

  注意:DP 的扩展瓶颈是显存而不是算力。ZeRO 论文给过一个直观的观察:混合精度训练下,超过约 1.4B 参数的模型(16 字节账约 22.4 GB),在 32 GB 显卡上用基本 DP 就已经装不下了——这还没算激活值。模型越大,DDP 越先被自己的冗余卡死。

模型状态 Model States model states = 训练全程必须常驻的「模型本体」数据

ZeRO 论文把训练显存切成两大块:模型状态(优化器状态、梯度、参数)与剩余状态(residual states:激活值、临时缓冲、显存碎片)。大模型场景下模型状态是显存大头,且它在 N 卡之间完全复制,是 ZeRO 的主攻目标;激活值等剩余状态靠激活重计算等手段处理,属于另一条战线。

模型状态像搬家时必须随身带的全套家当,激活值像做饭时临时摆在台面上的菜——前者长期占地,后者随做随收。

  矛盾清楚了:数据并行天然地复制模型状态,而复制在单卡装不下时毫无意义——64 张「各自装不下」的卡拼起来,还是 64 张各自装不下的卡。要破局,就得动「人人一份完整副本」这个前提。

7.2.3 ZeRO 三级切分:不复制,改分管

  2020 年微软提出的 ZeRO(Zero Redundancy Optimizer,零冗余优化器)给出了系统的解法:模型状态不再复制,而是切分(partition)到 N 张卡上,每张卡只保管 \(1/N\),需要用到不在自己手里的部分时,再临时通过通信取来。好比 64 个人合租一套 64 卷的百科全书:与其每人买一套,不如每人只保管一卷,要写论文时互相借——书架压力降 64 倍,代价是多跑几趟腿(通信)。

  模型状态有三件套,切分也就按三步走,逐级加码:

Stage 1:切优化器状态

12Ψ 的大头先切。每卡只存 1/N 的优化器状态,只负责更新 1/N 的参数,更新完互相广播。

Stage 2:加切梯度

梯度跟着参数走。每卡只保留自己负责那 1/N 参数的梯度,反向结束时跨卡归约并各取所属切片。

Stage 3:连参数也切

每卡只存 1/N 参数,前向反向算到哪层,临时收集哪层的完整参数,用完即弃。

  Stage 1(优化器状态切分)。三件套里优化器状态占 12 字节,是最大的那块,先拿它开刀。切完后每卡只保管 \(1/N\) 的 fp32 主参数、动量、方差,step 时只更新这 \(1/N\) 参数,再通过一次 all-gather 把各卡更新好的参数切片拼回全员。参数(2Ψ)和梯度(2Ψ)暂时还是全量,每卡占用变为 \(4\Psi + 12\Psi/N\)。

  Stage 2(再加梯度切分)。既然每卡只更新 \(1/N\) 的参数,它只需要这 \(1/N\) 参数的梯度——反向结束时,原来的梯度 all-reduce 退化成一次 reduce-scatter:梯度跨卡求和的同时,每卡只收下自己负责的那段切片,其余直接丢弃。每卡占用进一步降到 \(2\Psi + 14\Psi/N\)。

  Stage 3(连参数也切)。最激进的一步:参数本身也切开,每卡只存 \(1/N\)。前向算到某层时,先用 all-gather 临时收集该层完整参数,算完立刻释放;反向同理。每卡占用压到 \(16\Psi/N\)——模型状态显存随卡数线性下降。把三级合写在一起:

\[ \text{Stage 1:}\; 4\Psi + \frac{12\Psi}{N}, \qquad \text{Stage 2:}\; 2\Psi + \frac{14\Psi}{N}, \qquad \text{Stage 3:}\; \frac{16\Psi}{N} \tag{3} \]
公式 (3):ZeRO 三级切分下每卡的模型状态显存(对照 DDP 基线的 \(16\Psi\))。白话解读:Stage 1 只把 12Ψ 的优化器状态摊到 N 卡;Stage 2 把 2Ψ 的梯度也摊掉;Stage 3 连 2Ψ 的参数都摊掉,全部模型状态都只剩 \(1/N\)。符号说明:\(\Psi\) 是模型参数量(个);\(N\) 是数据并行卡数(ZeRO 论文记作 \(N_d\));系数 16 = 2(fp16 参数)+ 2(fp16 梯度)+ 12(fp32 优化器状态,论文记作 \(K=12\))。卡数较大时,三级分别接近 4 倍、8 倍、N 倍节省。

  把 70B 模型、64 卡(十进制 GB,1 GB = \(10^9\) 字节)代入,算一笔完整对比账:

方案每卡优化器状态每卡梯度每卡参数每卡合计相对 DDP
DDP(基线)840 GB140 GB140 GB1120 GB1×
ZeRO Stage 113.1 GB140 GB140 GB293.1 GB≈3.8×
ZeRO Stage 213.1 GB2.2 GB140 GB155.3 GB≈7.2×
ZeRO Stage 313.1 GB2.2 GB2.2 GB17.5 GB64×

  DDP 下 1120 GB 没有任何单卡装得下,ZeRO-3 的 17.5 GB 一张 32 GB 卡就能扛——从「64 张卡各自装不下」到「64 张卡合力轻松装下」,同一批硬件的能耐天差地别。ZeRO 论文算过更大的账:1T 参数模型、16 字节账共约 16 TB,1024 张卡切分后每卡 16 GB,落在常规显卡容量之内。

原创示意图 · 非论文原图 每卡模型状态显存(70B · 64 卡 · 不含激活值) 优化器状态(fp32 主参数+动量+方差,12Ψ) 梯度(fp16,2Ψ) 参数(fp16,2Ψ) 优化器状态 840 梯度 140 参数 140 1120 GB · 1× DDP(基线) 梯度 140 参数 140 293 GB · ≈3.8× Stage 1 参数 140 155 GB · ≈7.2× Stage 2 17.5 GB · 64× Stage 3 被切分的段每卡只留 1/64:柱高按真实比例绘制,Stage 3 仅剩一条细线——这就是「随卡数线性下降」的形状
图 4:DDP 与 ZeRO 三级的每卡模型状态显存对比(70B · 64 卡)。紫色优化器状态先被切掉,青色梯度随后,最后琥珀色参数也被切开,柱高从 1120 GB 压到 17.5 GB。

  显存省得漂亮,通信代价呢?这正是 ZeRO 设计最巧妙的地方。回忆 ring all-reduce 的两个阶段:reduce-scatter 加 all-gather。DDP 的梯度 all-reduce 本来就是这两步的组合,通信量 \(2\Psi\)。Stage 1 和 Stage 2 只是把这两步拆开重新点名——梯度用 reduce-scatter 各取所属切片(\(\Psi\)),参数更新后用 all-gather 拼回全员(\(\Psi\)),总量仍是 \(2\Psi\),与 DDP 一字不差。Stage 3 因为参数不在手边,前向、反向各要多做一次参数 all-gather,总量升到 \(3\Psi\),即多花 50% 通信。

  ZeRO 的账本:Stage 1、Stage 2 的显存节省(最高约 8 倍)是白赚的,通信量与 DDP 完全相同;只有 Stage 3 才付通信税(+50%),换来显存随卡数线性下降。工程上 DeepSpeed 把三级做成配置开关,按显存缺口逐级加码即可。

  切分还能再往外卸。ZeRO-Offload(Ren et al., 2021)把优化器状态和梯度卸到 CPU 内存、参数更新放在 CPU 上算;ZeRO-Infinity(Rajbhandari et al., 2021)基于 Stage 3 进一步把状态卸到 NVMe 硬盘,打通 GPU—CPU—NVMe 三级存储,让单台机器也能撬动超大模型的微调。它们换的是更便宜的容量,付的是更慢的带宽。

  本页显存数字用十进制 GB(1 GB = \(10^9\) 字节),与 ZeRO 论文口径一致;若按二进制 GiB(\(2^{30}\) 字节)计,1120 GB 约等于 1043 GiB。另外所有对比只算模型状态,激活值显存另计——长序列、大 batch 时激活同样可观,由激活重计算等技术负责。

7.2.4 梯度累积:把大 batch 摊到时间轴上

  还有一根支柱,与「卡」无关,与「时间」有关。6.2 节讲过,大模型配大 batch:batch 越大梯度估计越准。可 batch 一大,激活值显存先爆——前向每一层的中间结果都要留着等反向。梯度累积(gradient accumulation)的思路是:不一次喂大 batch,把它切成 \(k\) 个 micro-batch 分 \(k\) 步喂,每步只反向不更新,梯度在参数的 .grad 里自然累加,第 \(k\) 步才做一次优化器更新、清零重来。总算力并没有多花——同一份 batch 分 \(k\) 次算完,只是参数更新要等满 \(k\) 步——激活显存却只占 micro-batch 那一份。

  这里有一个必须小心的细节:PyTorch 的损失默认对 batch 内样本取均值,而 .grad 是累加不是覆盖。如果不加处理,\(k\) 步累积得到的是各 micro-batch 梯度之和,比大 batch 的梯度大了 \(k\) 倍。所以每步的 loss 要先除以 \(k\) 再反向:

\[ \nabla \mathcal{L}_{\text{大 batch}} \;=\; \frac{1}{k}\sum_{i=1}^{k} \nabla \mathcal{L}_{i} \qquad\Longleftrightarrow\qquad \texttt{loss\_i / k} \;\text{再 backward} \tag{4} \]
公式 (4):大 batch 的均值损失梯度,等于各 micro-batch 均值损失梯度的平均——所以累积时每步 loss 先除 k,k 步累加出来的梯度才与大 batch 严格一致。符号说明:\(\mathcal{L}_{i}\) 是第 \(i\) 个 micro-batch 的均值损失;\(k\) 是累积步数;\(\nabla \mathcal{L}_{\text{大 batch}}\) 是把 k 份数据合成一个大 batch 算出的梯度;⇔ 右边是工程实现写法,两边数学等价。

  易错点:梯度累积忘了给 loss 除以 k,是真实高发的静默错误:不报错、loss 曲线照降,但每步实际梯度大了 k 倍。对 SGD 这类直接拿梯度乘学习率的优化器,这等效于学习率偷偷放大 k 倍,轻则收敛变差,重则训练发散;Adam 家族按梯度量级做归一化,对这种整体缩放近似免疫,但工程上没人会把训练押在「近似免疫」上。检查清单里永远要有这一项。

  叠上 DDP,等效全局 batch 的完整公式是三个数的连乘:

\[ B_{\text{global}} \;=\; B_{\text{micro}} \times k \times N \tag{5} \]
公式 (5):全局等效 batch = 单卡 micro-batch × 梯度累积步数 × 数据并行卡数。三个因子分别对应三根支柱的分工:\(B_{\text{micro}}\) 由单卡激活显存决定,\(k\) 用时间换空间,\(N\) 用卡数换吞吐。符号说明:\(B_{\text{micro}}\) 是每步每卡实际喂入的样本数;\(k\) 是累积步数;\(N\) 是卡数。

  以 minimind 的预训练默认配置为例:单卡 batch 32、累积 8 步,单卡等效 batch 就是 256 条;若铺到 64 卡 DDP,全局等效 batch 达 16384 条——而每张卡任一时刻只需为 32 条样本存激活值。要特别提醒一句边界:梯度累积省的是激活显存,模型状态(参数、梯度、优化器状态)一分不少,那块要找 ZeRO;两者解决的显存互不重叠,所以总是搭配使用。

  工程细节:梯度累积的中间 k−1 步,梯度只在本地攒着,并不需要跨卡同步,PyTorch 提供 model.no_sync() 上下文关掉这些步的 all-reduce,省下一截通信。minimind 没有做这层优化——它的每次 backward 都会触发 DDP 同步,结果完全正确,只是多通信了几趟,小模型上无伤大雅。

  三根支柱各管一摊、彼此正交:DDP 把数据摊到多卡(算力),ZeRO 把模型状态切到多卡(状态显存),梯度累积把 batch 摊到时间轴(激活显存)。真实的大模型训练永远是三者的组合,再叠上 7.1 的混合精度——比如「ZeRO-2 + bf16 + 累积 8 步 + 64 卡」。

🧭本节要点回顾
DDP 各卡吃不同的数据,为什么参数能始终保持一致?
初始参数一致,反向后梯度经 all-reduce 求平均变得一致,优化器状态历史也一致——三者一致推出更新后参数仍一致。数学上,平均梯度恰好等于 N 份数据拼成大 batch 的梯度,所以 DDP 就是大 batch 训练本体。
ZeRO 三级各切什么?通信代价分别是多少?
Stage 1 切优化器状态(12Ψ)、Stage 2 加切梯度(2Ψ)、Stage 3 连参数(2Ψ)也切,每卡模型状态从 16Ψ 降到 16Ψ/N;前两级的通信量与 DDP 相同(2Ψ,白赚),第三级升到 3Ψ(+50%)。
梯度累积为什么必须给 loss 除以 k?它省的是什么显存?
PyTorch 的梯度默认累加,k 步后 .grad 里是各 micro-batch 梯度之和,而大 batch 要的是平均,所以每步 loss 先除 k;它省的是激活显存(只占 micro-batch 一份),不省模型状态——等效全局 batch = micro-batch × k × 卡数。

参考来源

  • Rajbhandari, Rasley, Ruwase & He, 2020. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models(ZeRO 原始论文,arXiv:1910.02054,SC20;三级切分、16Ψ 显存账与通信量分析的出处)。
  • Li et al., 2020. PyTorch Distributed: Experiences on Accelerating Data Parallel Training(PyTorch DDP 设计与梯度分桶、计算通信重叠,arXiv:2006.15704,VLDB 2020)。
  • Gibiansky, 2017. Bringing HPC Techniques to Deep Learning(ring all-reduce 引入深度学习,arXiv:1702.08723)。
  • Sergeev & Del Balso, 2018. Horovod: fast and easy distributed deep learning in TensorFlow(ring all-reduce 的工程化普及,arXiv:1802.05799)。
  • Ren et al., 2021. ZeRO-Offload: Democratizing Billion-Scale Model Training(优化器状态与梯度卸载 CPU,arXiv:2101.06840)。
  • Rajbhandari et al., 2021. ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning(卸载延伸至 NVMe,arXiv:2104.07857)。
  • minimind 工程代码:trainer/train_pretrain.py(Apache 2.0 协议)。