🏠 总目录📚 本教程 数据并行 ← →

AI基础设施 · 10

每张卡看不同数据,参数为什么不会越训越不一样?

各卡本地计算不同数据的梯度,再按约定同步并更新。同步方式、累积步骤和数据划分都影响是否得到预期训练行为。

读完能做到:把各卡梯度、AllReduce 与本地 step 连起来,手算 Ring 通信量,并判断慢卡和跨机链路为什么拖慢整步。

📑 本页目录(点开跳转)

10 · 数据并行与 AllReduce

⏱ 26 分钟 | ⭐ 最简单也最常用的并行


🎯 一句话

每张卡放一份完整的模型,各自吃不同的数据,算完梯度后求个平均。 复制式数据并行是常见起点;是否适合仍要看模型容量、负载和通信代价。

🧭 先把这一章放进路线里
数据并行、张量并行、流水线并行和专家并行不是四个同义词。本章只把数据并行讲透;其他切分方式在后续章节比较。

🔄 一、它怎么工作

数据并行(DP):每张卡一份完整模型副本 每张卡吃不同的数据分片,算出各自的梯度 数据分片0 GPU0 模型副本 梯度0 数据分片1 GPU1 模型副本 梯度1 数据分片2 GPU2 模型副本 梯度2 数据分片3 GPU3 模型副本 梯度3 AllReduce 求平均 所有卡拿到【相同的平均梯度】→ 各自 step() → 参数保持一致 ⭐
四条支路收束到 AllReduce 那一格 —— 它左边每张卡的梯度都不一样,它右边全部相同。参数之所以不会漂开,靠的就是这一个同步点。

🔑 为什么求平均而不是求和: 在每卡有效样本数相同、各卡 loss 按均值归约时,平均局部梯度对应全局均值梯度;本图按这个条件理解。 在这个条件下,若只把平均改成求和而不改 loss 缩放或学习率,梯度会大 N 倍。样本数不等时还要核对权重。

先分清名字:数据并行是一类“模型副本分摊数据”的方法;PyTorch 的 nn.DataParallel 和 DistributedDataParallel(DDP)是不同实现。上图按梯度归约型数据并行理解,下面代码用 DDP。先记住这一区分,就可以继续读原代码;具体机制放在下面。

深入:DP 实现与 DDP 怎样分工(可跳过)
比较什么nn.DataParallelDDP 常用每 GPU 一进程配置
进程与副本单进程多线程;每次 forward 在设备上复制模块。多个进程,各自持有模型副本;初始化后不按 DP 的方式每次重新复制。
输入与输出默认沿 batch 维 scatter 输入,各副本执行,再 gather 输出。不自动切分输入;调用方用采样器或其他数据分配方式喂各 rank,输出通常留在各进程。
反向与更新副本梯度归约回原模块;最终尺度还取决于输出上的 loss 归约。反向触发梯度桶 all-reduce,各 rank 依相同更新规则更新;已有分桶/重叠和 no_sync 见下一节。
使用范围常用于单机多 GPU。可单机多 GPU,也可多机;不是“只有多机才用 DDP”。PyTorch 通常推荐多 GPU 训练用 DDP。
比较前提两者都不自动分摊模型状态。对齐模型、精度、有效 batch、loss 缩放与数据后再测通信和端到端时间;不能预先承诺固定倍数加速。

只做数据划分手算:2 张卡、全局 batch=8。DP 的一个进程接 8 个样本再分成 4+4;DDP 的两个 rank 各喂 4 个,合计仍是 8,而不是每 rank 各喂 8 后继续称全局 batch=8。现有代码中的 DistributedSampler 和 set_epoch() 负责相应数据划分/顺序,no_sync() 的使用见下节。

不等量时,均值不能再随便平均:假设两个 rank 的有效样本数为 2、6,局部样本均值梯度分别为 1、3。简单平均是 2;按样本权重计算才是 (2×1+6×3)/8=2.5。真实任务还要对齐 token/mask 和 loss 分母;这只是标量手算,不是多卡训练结果。

已有选型速查见 Kaggle 04 · 分布式训练;包装后的存储键见 PyTorch 06 · state_dict 键,这里不重复那两章。

依据:DataParallel API、DDP API、DDP 设计说明。本段没有运行分布式训练或性能测试。

# PyTorch DDP:标准写法
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

dist.init_process_group("nccl")
model = DDP(model.to(local_rank), device_ids=[local_rank])

sampler = torch.utils.data.distributed.DistributedSampler(dataset)
loader = DataLoader(dataset, sampler=sampler, batch_size=micro_bs)

for epoch in range(E):
    sampler.set_epoch(epoch)      # ⭐ 必须!否则每轮的数据划分完全相同
    for batch in loader:
        loss = model(batch)
        loss.backward()           # ⭐ AllReduce 在这里自动发生
        opt.step(); opt.zero_grad(set_to_none=True)

⚠️ sampler.set_epoch(epoch) 是最常被漏掉的一行: 不加的话每个 epoch 的数据顺序和划分完全一样,等于没有 shuffle。


⚙️ 二、DDP 的两个关键优化

① 梯度桶(bucketing)+ 通信计算重叠

结果对照

❌ 朴素做法:等所有梯度算完,一次性 AllReduce
反向传播时 GPU 在算,网络完全闲置
AllReduce 时网络在传,GPU 完全闲置
✅ DDP 的做法:
反向传播是【从后往前】的
最后一层的梯度【最先】算出来
攒够一个"桶"(默认 25MB)就【立刻】开始 AllReduce
通信和后面层的计算【重叠】⭐

对照

时间轴:

计算 ████████████████████████

通信 ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ▓▓▓▓ ← 藏在计算后面

↑ 桶1 ↑桶2 ↑桶3 ↑桶4

💡 这就是为什么 DDP 比手写 AllReduce 快很多。 桶大小可调:DDP(model, bucket_cap_mb=25) —— 太小则通信次数多、开销大;太大则重叠机会少。

② 梯度累积时要关掉同步

# 🧩 骨架:`loader` 来自你自己的代码,这一段只看写法
from contextlib import nullcontext

# ❌ 每个 micro batch 都 AllReduce → 通信量翻 N 倍
for i, batch in enumerate(loader):
    loss = model(batch) / accum
    loss.backward()

# ✅ 每个累积窗口只在最后一步同步;尾批不足 accum 步也要更新
total_batches = len(loader)
for i, batch in enumerate(loader):
    window_start = (i // accum) * accum
    window_size = min(accum, total_batches - window_start)
    is_last = ((i + 1) % accum == 0
               or (i + 1) == total_batches)
    ctx = nullcontext() if is_last else model.no_sync()    # ⭐
    with ctx:
        (model(batch) / window_size).backward()
    if is_last:
        opt.step(); opt.zero_grad(set_to_none=True)

⚠️ 忘了 no_sync() 是一个隐蔽的性能杀手: 累积 8 步就意味着通信量是必要值的 8 倍,而代码看起来完全正常。

上面的正例假设每个 micro batch 的有效样本数相同,所以可按窗口中的 micro batch 数平均;若尾批样本数不同,还要按有效样本或 token 数加权,不能只按批次数平均。


🔁 三、Ring AllReduce(第 5 章的展开)

归约分散(Reduce-Scatter,RS)先把“相同位置的梯度相加”和“结果分片归属”一起完成;全收集(All-Gather,AG)再把各卡拥有的完整分片发给所有卡。两阶段合起来,才是这里的 Ring AllReduce。

结果对照

N 张卡排成环,梯度切成 N 份
阶段① ReduceScatter(转 N-1 步):
每一步,每张卡把手里的一份发给下家、从上家收一份并累加
结束时,第 i 张卡持有【第 i 份的完整求和】
阶段② AllGather(再转 N-1 步):
把各自那份完整结果传遍全环
结束时,所有卡都有完整的求和结果

先追踪一份:4 张卡怎样把 A 算成 10

把每张卡的梯度都切成 A、B、C、D 四份。只看 A:GPU0~GPU3 的 A 分别是 1、2、3、4,环方向是 0→1→2→3→0。下面的数字是教学用标量;真实分片是一段向量,并且 B、C、D 会在其他链路上同时流动。

阶段这一步发生什么A 的状态
RS 第 1 步GPU0 把 A=1 发给 GPU1;GPU1 与自己的 A=2 相加1+2=3
RS 第 2 步GPU1 把部分和 3 发给 GPU2;GPU2 再加自己的 33+3=6
RS 第 3 步GPU2 把部分和 6 发给 GPU3;GPU3 再加自己的 46+4=10
AG 第 1~3 步GPU3 持有完整 A=10,再沿环传给 GPU0、GPU1、GPU2四张卡最后都有 A=10

同一时刻,B、C、D 也在轮转,所以不是先花 3 步只算 A、再重新算 B。经过 $N-1=3$ 轮 RS,每张卡各持有一个完整求和分片;再经过 3 轮 AG,所有卡拿回全部四个分片。若训练需要平均梯度,最后再按约定除以 $N$;如果各卡有效样本数不同,则要使用前文的样本权重,不能只除以卡数。

先看精确式,再看近似

每张卡发送量:$V_{send}=2\times\frac{N-1}{N}\times D$

每张卡接收量与发送量相同,但不要再把收、发相加后仍称作“发送量”。

只有 $N$ 较大时,$2(N-1)D/N$ 才接近 $2D$。

📐 为什么是 2×(N−1)/N(想看再点)

设 $N$ 是参与 Ring 的卡数($N\ge 2$),$D$ 是每张卡上待归约梯度的总字节数,并假设能均匀切成 $N$ 份;每份大小就是 $D/N$。

两阶段相加得到 $V_{send}=2(N-1)D/N$。例如 $N=4$、$D=8\,\text{GB}$(十进制 GB),每卡发送:

$$2\times\frac{4-1}{4}\times 8=2\times 0.75\times 8=12\,\text{GB}$$

每卡也接收 12 GB。这里不能直接写成 $2D=16$ GB;16 GB 只是把 $(N-1)/N$ 近似成 1 后的上界式直觉。随着 $N$ 增大,发送量趋近 $2D$,但通信轮数是 $2(N-1)$,启动延迟会随轮数增加。

成立条件:这是平衡分片、标准双阶段 Ring 的每 rank 逻辑流量。实际时间还受拓扑、链路竞争、协议、并行通道和计算通信重叠影响,不能只用字节数承诺固定速度。

⭐ 分层 AllReduce:把快链路和慢链路分开用

以每机 8 卡为例

① 每台机器内部先做 Reduce-Scatter→每个本地 rank 拿到约 1/8 的归约分片
② 各机器“相同本地 rank”组成跨机组→8 个组分别归约自己的分片
③ 每台机器内部再 All-Gather→8 张卡都拿回完整结果

⚠️ 不是“随便派一张代表卡就自动省 1/8”。如果只让一个代表携带完整梯度,它仍要跨机传完整数据,还可能形成单点瓶颈。正确的分层实现会让多个本地 rank 分担不同分片;每个跨机参与者处理约 1/8 的分片,但整机聚合流量、网卡利用和最终时间仍取决于拓扑与算法。

💡 NCCL 可以根据消息大小和检测到的拓扑选择算法/协议,但“自动选择”不等于在所有机器上必然最优。先用 NCCL_DEBUG=INFO 确认拓扑和实际选择,再用端到端测量判断。


📉 四、扩展效率:为什么卡越多效率越低

先不要背“几张卡能加速几倍”。同步训练每一步都要等最慢的 rank,因此可以先用一个教学模型拆账:

$$T_{step}\approx \max_r(T_{compute,r})+T_{exposed\_comm}$$

$r$ 是 rank 编号;$T_{compute,r}$ 是第 $r$ 张卡完成本步计算的时间;$\max$ 表示取最慢者;$T_{exposed\_comm}$ 是没有被反向计算遮住、真正暴露在关键路径上的通信时间。若把总通信时间记作 $T_{comm}$、成功重叠的部分记作 $T_{overlap}$,可用 $T_{exposed\_comm}\approx\max(0,T_{comm}-T_{overlap})$ 做第一轮估算。

把“轮数”和“字节数”放进同一张账单

在忽略计算重叠、分片均匀且用一个有效带宽近似整条路径时,Ring 通信可粗略写成:

$$T_{ring}\approx 2(N-1)\alpha+\frac{2(N-1)D}{N\,B_{eff}}$$

完整代入:4 卡、8 GB 梯度

教学假设:$N=4$,$D=8$ GB,$\alpha=5$ 微秒/轮,$B_{eff}=100$ GB/s;这些是演示参数,不代表某款硬件。

发送量:$2\times(4-1)/4\times8=12$ GB

启动代价:$2\times(4-1)\times5=30$ 微秒 = 0.00003 秒

传输代价:$12/100=0.12$ 秒

所以 $T_{ring}\approx0.00003+0.12=0.12003$ 秒,即约 120.03 ms。

若其中 90 ms 能藏在反向计算后面,暴露通信约为 $120.03-90=30.03$ ms;若最慢 rank 计算 200 ms,则整步约 $200+30.03=230.03$ ms。

慢卡为什么让所有卡一起等

假设四个 rank 本步计算分别耗时 80、90、125、85 ms,且进入集合通信后还有 30 ms 暴露通信。AllReduce 必须有全部 rank 以相同顺序参与,因此整步不会在 110 ms 结束,而是约 $125+30=155$ ms。80 ms 完成的 rank 要先等慢卡约 45 ms,再一起完成通信。这个最慢者叫拖尾者(straggler)。

卡数增加时要同时观察

每卡计算量是否下降→取决于强扩展还是扩大全局 batch
通信字节数与轮数→Ring 字节数趋近 2D,但轮数增加
最慢 rank 与拓扑→数据、硬件或跨机链路不均衡都会拖慢全体

🔑 所以优化顺序是先测量,再选择手段:可以尝试梯度分桶与重叠、拓扑感知的分层集合通信、在验证收敛与精度后采用低精度/压缩通信,或在显存与切分需求变化时转向 ZeRO/FSDP、张量并行。这些手段解决的问题不同,不是卡数一多就全部必选。


⚠️ 五、五个真实的坑

坑 症状 解法
忘了 set_epoch 每轮数据顺序完全一样 加上它 ⭐
忘了 no_sync() 梯度累积时通信量翻 N 倍 见上面代码
collective 次序或次数不一致 某些 rank 已进入 AllReduce,另一些 rank 没有进入或进入了别的 collective 逐 rank 对照迭代数与 collective 序列;不等长输入可评估补齐或 join() ⭐
BatchNorm 各算各的 小 batch 时统计不准,精度掉 换 SyncBatchNorm 或用 LayerNorm
随机数策略不可追踪 重跑结果漂移,或各卡错误地重复同一份随机增强 记录 base seed,并按 rank、epoch 派生可追踪但不同的随机数流

💥 "AllReduce 挂死"描述的是现象,不是唯一根因:某张卡少一个 batch、条件分支让 collective 顺序不同、某个 rank 异常退出、数据加载阻塞、网络故障或 NCCL 错误,都可能让其他 rank 一直等待。监控有时仍显示 GPU 或通信内核忙碌,但“GPU 100%”不能单独定位原因。

按证据排查:

  1. 先记录每个 rank 的进程存活、当前 epoch/step、DataLoader 是否产出下一批,确认是计算慢、数据卡住,还是已经进入 collective。
  2. 给每个 collective 标记递增序号与类型,逐 rank 比对序列,例如 rank 0 在 #184 all_reduce,rank 3 却停在 #183 broadcast,就说明调用顺序不一致。
  3. 开启 TORCH_DISTRIBUTED_DEBUG=DETAIL、NCCL_DEBUG=INFO,必要时加 NCCL_DEBUG_SUBSYS=COLL,保留各 rank 日志。
  4. TORCH_NCCL_BLOCKING_WAIT=1 要与进程组 timeout 配合,目标是让超时暴露为可见错误;不同 PyTorch/NCCL 版本的报错与清理行为可能不同,不能把它当成自动修复。

🧭 六、它和其他并行方案的边界

方案设备上放什么主要通信解决的核心问题
DDP / AllReduce 数据并行每个 rank 都有完整参数、梯度和优化器状态;激活只对应本 rank 的 local microbatch同步归约梯度模型放得下时,提高训练吞吐;不分片三类模型状态
参数服务器(Parameter Server)worker 计算梯度;中心或分片 server 保存/更新参数worker push 梯度、pull 参数;可同步也可异步把更新职责放到 server;异步模式还要处理参数陈旧,不等同于 AllReduce
ZeRO / FSDP把优化器状态、梯度、参数中的部分或全部分片按阶段使用 reduce-scatter、all-gather 等集合通信减少每卡模型状态显存;它仍属于数据并行家族,但通信时机与内容更复杂
张量 / 流水线 / 专家并行把一层张量、不同层或不同专家分到设备激活、部分结果或 token 路由通信单卡放不下模型或需要改变单次前后向的计算切分;详见 12~14 章

训练目标和推理目标也不同:训练数据并行通常在每步反向后同步梯度,关注样本吞吐和收敛一致性;普通推理副本处理不同请求时没有梯度,不需要每个请求做 AllReduce。推理中的张量并行则可能为了让单个模型放得下或降低单请求延迟,在每层产生通信。不要把“训练用了 8 卡 DDP”直接当成“推理也必须 8 卡同步”。


🔗 和站内其他章的关系

相关的地方 这里的位置
第 5 章 Ring AllReduce 本章是它的展开
第 5 章 AllReduce=RS+AG 分层和 ZeRO 都基于它
第 3 章 显存四大块 DDP 不分片参数、梯度、优化器状态。激活是否下降要看比较口径:固定全局 batch 时,每 rank local microbatch 变小,激活通常随之下降;固定每 rank local microbatch 时,激活不会因加卡自动下降,而全局 batch 会增大。
第 11 章 ZeRO 仍在数据并行家族中,但进一步分片优化器状态、梯度或参数,具体取决于阶段/策略。
第 9 章 梯度累积 和 no_sync() 配合
《机器学习与深度学习基础》09 优化器与学习率 warmup 与学习率量级 等量 rank 下 $B_{global}=N\times B_{micro}\times A$,其中 $A$ 是梯度累积步数。只有保持每卡 batch 不变时,全局 batch 才随 $N$ 放大;学习率是否缩放必须结合优化器和验证实验,不能机械乘 $N$。
《Kaggle竞赛方法论》02 训练策略与正则化 梯度累加 那里它是"显存不够时模拟大 batch";在 DDP 里不配 no_sync(),每个累积步都会白同步一次 ⚠️

✅ 检查点

  1. 本章 DDP 例怎样同步梯度?把局部均值再平均需要什么样本权重条件?
  2. sampler.set_epoch() 不加会怎样?
  3. DDP 的梯度桶做了什么?为什么反向传播的顺序让它成为可能?
  4. 梯度累积时忘了 no_sync() 会怎样?
  5. Ring AllReduce 每卡的通信量是多少?它的软肋是什么?
  6. 4 卡、梯度总量 8 GB 时,每卡精确发送多少?为什么不能直接写 16 GB?
  7. 分层 AllReduce 为什么不能只理解成“派一张代表卡”?
  8. $T_{ring}$ 的启动项和传输项分别由什么决定?
  9. 为什么慢 rank 会让所有卡等待?
  10. DDP 对参数、梯度、优化器状态和激活显存分别有什么影响?
  11. "训练突然卡住、无报错、GPU 可能仍显示很忙"能否只凭现象认定少了一个 batch?应该怎样排查?
  12. 一般数据并行、nn.DataParallel 与 DDP 有何区别?DDP 会自动切输入吗?
  13. 每卡 batch=4、4 张卡、累积 2 步时,全局 batch 是多少?学习率必须乘 4 吗?
👀 答案
  1. 本章 DDP 例中各 rank 持副本、吃分片、归约梯度后按相同规则更新。各卡有效样本数相同且 loss 按均值归约时,平均局部梯度对应全局均值;若只改成求和而不改其他缩放,梯度大 N 倍。有效样本数或 mask 分母不同时需核对权重。
  2. 每个 epoch 的数据顺序和划分完全一样,等于没有 shuffle。
  3. 攒够一个桶(默认 25MB)就立刻开始 AllReduce,让通信和后面层的计算重叠。可能是因为反向传播是从后往前的,最后一层的梯度最先算出来,不用等全部算完。
  4. 通信量翻 N 倍(累积 8 步就是 8 倍必要通信量),而代码看起来完全正常——隐蔽的性能杀手。
  5. 每 rank 发送量是 $2(N-1)D/N$,接收量相同。$N$ 大时才接近 $2D$;软肋是通信轮数为 $2(N-1)$,启动延迟随轮数增加。
  6. $2\times(4-1)/4\times8=12$ GB。16 GB 是把 $(N-1)/N$ 近似为 1 后的 $2D$;4 卡时 0.75 不能忽略。
  7. 正确做法是机内先把梯度分成约 1/8 的归约分片,再让各机器相同本地 rank 分组跨机归约,最后机内收集。随便派一张代表携带完整梯度不会自动省流量,还可能形成瓶颈。
  8. 启动项 $2(N-1)\alpha$ 由轮数和每轮固定延迟决定;传输项 $2(N-1)D/(NB_{eff})$ 由每 rank 字节数和实测有效带宽决定。该式是忽略重叠、分片平衡的粗估。
  9. 同步集合通信要求所有 rank 以相同顺序参与;快 rank 到达后也要等最慢 rank。整步先受 $\max_r(T_{compute,r})$ 限制,再加暴露在关键路径上的通信。
  10. DDP 不分片参数、梯度和优化器状态,所以这三类模型状态每个 rank 都保留。激活只来自本 rank 的 local microbatch:固定全局 batch 并把它分到更多 rank 时,local microbatch 变小,激活通常下降;若固定 local microbatch,加卡只会扩大全局 batch,激活不会自动下降。
  11. 不能。少一个 batch 只是常见原因之一;collective 次序/次数不一致、rank 异常、DataLoader 阻塞、网络或 NCCL 故障也可能造成等待。先比对逐 rank 的 epoch/step、进程和数据加载状态,再比对 collective 序号/类型,并收集分布式与 NCCL 日志。TORCH_NCCL_BLOCKING_WAIT=1 需配合进程组 timeout,用来暴露超时,不是自动修复。
  12. 一般数据并行是范式;nn.DataParallel 常用单进程多线程、forward 复制/scatter/gather;DDP 常用每 GPU 一进程、保留副本并同步梯度。DDP 可用于单机或多机,但不自动切输入;调用方安排数据。比较速度前先对齐有效 batch 与 loss 口径。
  13. $B_{global}=4\times4\times2=32$。学习率不必机械乘 4;先看相对原实验的全局 batch 是否真的改变,再结合优化器、warmup 和验证指标实验。

本节回顾

⚡ 走神救援

先记住这几件事

下一节 👉 11-ZeRO与FSDP.md ⭐

条件与依据

Ring 的 $2(N-1)D/N$ 是每 rank 的发送量,接收量相同;不能把两者合计后仍称作发送量。$\alpha$-$B_{eff}$ 时间式是假设分片平衡、用单一有效带宽近似、暂不计重叠的教学模型,不是性能承诺。分层方案需各本地 rank 对应分片跨机归约;“只派一个代表”不会自动使整机网络流量降到 1/8。no_sync() 示例还需导入 contextlib.nullcontext 并处理不足一个累积窗口的尾批;各 rank 的 dropout 不同本身不是错误,复现需要可追踪的随机数流。

参考:PyTorch DistributedDataParallel、NCCL Collectives。本页未运行真实多卡训练或网络性能测试。

打卡记录保存在你的浏览器里,首页能看到总进度