跳到主要内容

数据并行

数据并行是所有并行策略里最好想的一种。我们先从一个最朴素的想法出发,然后看它一步步是怎么演化成今天大家在用的 DDP、ZeRO、FSDP 的。这个演化的过程本身就很有意思——每一步都是被上一步的问题逼出来的。

1. 一个最直觉的做法​

假设我们有一批数据,一个 mini-batch 一共 128 条样本,想在 4 张 GPU 上训练。最简单的想法是什么?

把 128 条数据平均分成 4 份,每张卡各拿 32 条。每张卡上都放一份完整的模型,各自算前向、算 loss、算反向,得到梯度。

到这里为止都很顺——不同卡之间彼此独立,各干各的。但下一步就出问题了:每张卡算出来的梯度不一样(因为数据不一样),如果直接各自更新自己的模型参数,四张卡的模型就会分道扬镳,越训越不一样。

所以我们必须让 4 张卡在更新之前统一梯度。最自然的做法就是:把 4 份梯度加起来(或者平均一下),然后每张卡都拿这个"总梯度"去更新参数。这样每张卡上的模型永远保持一致。

这一步"把梯度统一",就是我们上一章讲的 All-Reduce。

一次数据并行迭代的完整流程就是:切数据 → 各自算前向和反向 → All-Reduce 梯度 → 各自更新参数。

2. 朴素实现的问题:PyTorch 的 DP​

PyTorch 早期提供了一个 torch.nn.DataParallel(DP),实现的就是上面这个思路。但它做得不好,主要有几个原因:

第一,它是单进程多线程的。也就是说,一个 Python 进程内起多个线程,每个线程负责一张卡。但 Python 有 GIL——多线程实际上是轮流跑的,很难榨干多卡的算力。

第二,它把主卡当作聚合中心。每次迭代主卡要收集所有卡的输出算 loss、发梯度、聚合梯度……主卡的通信量是别人的好几倍,显存也吃得多。

第三,它不能跨机。只支持单机多卡。

结论就是:DP 你可以当没有它。现代代码用 DDP。

3. DDP:把 DP 做正确​

DDP(DistributedDataParallel)就是把上面这几个坑一个个填掉的版本。

每张卡一个进程,绕开 GIL;没有主卡,梯度同步用 Ring All-Reduce,所有卡地位平等;跨机也行,多机多卡的启动方式和单机没什么本质区别。

DDP 里有一个特别值得讲的实现细节,叫做梯度分桶(bucket)。

先想一下朴素的做法:反向传播算完,得到全部梯度,再统一做一次 All-Reduce。这样虽然对,但反向计算和通信是串行的——反向的时候通信空闲,通信的时候计算空闲,太亏了。

DDP 的做法是这样的:不等所有梯度都算完再通信。把参数按顺序分成若干个"桶"(默认每桶 25MB)。反向传播是从后往前的,某个桶里的所有参数一旦全部算完梯度,就立即启动这个桶的 All-Reduce,同时继续往前算别的层的梯度。通信和计算就重叠起来了。

到了最后一层反向算完,绝大多数桶的通信也早就完成了,我们只需要等最后几个还没通信完的桶收尾。整体时间从"计算 + 通信"变成了"max(计算, 通信)"。这是一个非常漂亮的工程优化。

还有一个容易踩坑的点:DDP 同步的是梯度,不是参数。它靠三件事保证各卡参数始终一致——初始参数一开始就广播过一次、每一步梯度全部相同(通过 All-Reduce)、每张卡跑同一个优化器。三者叠加,参数就不会飘。

4. 一个显而易见的浪费​

DDP 跑起来很好,但如果我们仔细看它的显存开销,会发现一个巨大的冗余。

假设我们有 8 张 GPU,都在训练同一个模型。上一章讲过,Adam 训练下每个参数要 16 字节(参数 2 + 梯度 2 + 优化器状态 8 + master weights 4)。DDP 下,这 16 字节在每张卡上都完整存了一份。8 张卡就是 8 份,其中 7 份完全是冗余。

一个 7B 的模型静态显存开销大约 112GB。8 张卡加起来就是快 900GB 显存,但其实我们只有一份"独立的信息",剩下的都是重复的。这非常浪费。

有没有办法把这些冗余去掉?

有的。如果每张卡只存 1/8 的东西,需要用别的部分的时候再从其他卡上拿过来——不就能省 8 倍显存吗?

这个想法就是 ZeRO 的核心。

5. ZeRO:把冗余一层层扒掉​

ZeRO(Zero Redundancy Optimizer)是 DeepSpeed 团队提出的一系列显存优化,分成三个阶段,一层比一层激进。

ZeRO-1:切分优化器状态​

我们从最"安全"的开始。

前面说过,Adam 的优化器状态占 12N 字节(一阶矩 4 + 二阶矩 4 + master weights 4),是显存的大头。先切它:8 张卡的话,每张卡只保存 1/8 的优化器状态,只负责更新这 1/8 的参数。

流程稍微改一下:反向照常算,梯度 All-Reduce 照常做。然后每张卡只更新自己那 1/8 的参数——因为它只有那 1/8 的优化器状态。更新完之后,做一次 All-Gather:让所有卡都拿到完整的新参数,为下一次迭代做准备。

这样一算:显存里"优化器状态"这个 12N 变成了 12N/8。通信量呢?多了一次 All-Gather,但巧的是我们本来的 All-Reduce 可以拆成 Reduce-Scatter + All-Gather——第一步已经用 Reduce-Scatter 顺便把梯度切好了,第二步的 All-Gather 变成参数的 All-Gather。总通信量和 DDP 一样。

这就是 ZeRO-1:几乎白送的显存节省。

ZeRO-2:连梯度也切​

优化器状态只在更新那一瞬间需要"全的",梯度呢?其实也一样。反向传播算完某个参数的梯度,然后就是拿去更新;如果这个参数是别人负责更新的,我根本不需要保留完整的梯度。

梯度也切开。每张卡只保留自己负责的那 1/8 参数对应的梯度。反向的时候把梯度做 Reduce-Scatter 到对应的卡上,其他部分就可以丢掉了。

ZeRO-2 相比 ZeRO-1,再省一份 2N 字节的梯度,通信量基本不变。

ZeRO-3:参数也切​

现在最激进的一步:连参数本身也切开。

这一步为什么问题最大?因为前向计算需要用参数啊。每一层都要用一次,你要是切开了,怎么算前向?

ZeRO-3 的答案是:用的时候临时 All-Gather 拼回来,用完就丢。

具体来说:进入某一层前向计算前,做一次 All-Gather,让所有卡都拿到这一层的完整参数;算完这一层就把它释放掉;下一层再 All-Gather 一次。反向传播时也一样。

代价是明显的:前向多了一次 All-Gather,反向多了一次 All-Gather,通信量差不多是 DDP 的 3 倍。收益也明显:优化器状态、梯度、参数全部切开,理论上你可以训"世界上任何大小的模型",只要卡够多。

三个阶段合起来看:

  • ZeRO-1:切优化器状态,通信不变,省 4× 显存(对 Adam)
  • ZeRO-2:+ 切梯度,通信不变,再省一份
  • ZeRO-3:+ 切参数,通信 3×,能训任意规模

大部分实际项目会停在 ZeRO-2——性价比最好;只有真的装不下才上 ZeRO-3。

6. FSDP:PyTorch 版的 ZeRO-3​

FSDP(Fully Sharded Data Parallel)是 PyTorch 自己实现的 ZeRO-3 等价物,做的事情概念上一样。

它有一个"包裹粒度"的问题。FSDP 是以某个"单元"为粒度切分和 All-Gather 的。如果切得太细,比如每一层都单独一个单元,那通信次数太多,一直在 All-Gather;如果切得太粗,比如整个模型一个单元,那 All-Gather 一次就 OOM 了。

实践中大家一般以 Transformer block 为单位包裹——每个 block 一个 FSDP 单元。这个粒度既让每次 All-Gather 的量不至于太大,也让通信次数可控。

FSDP 还有几个常用的优化选项:

backward prefetch:反向计算某一层的时候,提前把下一层的参数 All-Gather 起来,让通信和计算重叠。开这个是没什么代价的,一般默认开着。

CPU offload:连 CPU 的内存也算上,把优化器状态或参数扔到 CPU 上,需要时再传回 GPU。牺牲一些带宽换更多显存。

mixed precision:FSDP 内部对精度的控制比较细,可以指定"参数用什么精度存、通信用什么精度、梯度用什么精度累加"。

7. 到底选哪个​

我给一个简单的决策方式:

能塞进单卡就用 DDP。不要一上来就 FSDP——FSDP 的通信量差不多是 DDP 的两倍,实现和调试都更复杂,能不用尽量不用。

塞不下就试 ZeRO-2 或者 FSDP 默认档。这一步能满足大部分微调场景。

再塞不下就上 ZeRO-3 / FSDP full shard。已经准备接受较大的通信开销了。

再塞不下——说明数据并行这条路走到尽头了,你需要引入别的并行策略。这就是下一章要讲的张量并行。

8. 一些容易踩的坑​

BatchNorm 的统计。DDP 下每张卡看到的 batch 不同,BN 的 running mean/var 会有偏差。要么换成 SyncBatchNorm(会跨卡同步统计量),要么改用 LayerNorm、GroupNorm 这类不依赖 batch 统计的归一化。Transformer 里用 LayerNorm,天然没这个问题。

梯度累加时别忘了 no_sync()。如果你显存不够、想用梯度累加模拟大 batch,中间那些 micro-step 不应该做 All-Reduce(浪费带宽),只有最后一步累加完才通信。用 model.no_sync() 上下文管理器可以关掉中间步的通信。

loss 是否要除以 world size。DDP 内部做的是"梯度平均"(Reduce 之后除以 world size),如果你的 loss 已经在 batch 内做过 mean,那梯度自然就是平均的——不要再手动除一次。

DataLoader 的种子。每个 rank 上的 DataLoader worker 要用不同种子,不然各 rank 的数据顺序就退化成一样的了。PyTorch 现在的 DistributedSampler 会帮你处理这件事,但自定义 sampler 时要注意。