一万六千块 GPU 训一个模型

128 ⁠份，每份 128 ⁠块

Meta 训练 Llama 3 ⁠系列里最大的模型时，最多同时用了 16 384 ⁠块 NVIDIA H100 GPU。这个模型有 4 050 ⁠亿个参数，读了 15.6 ⁠万⁠亿个词元，一共做了约 3.8 × 10²⁵ ⁠次浮点运算。论文写的是“最多 16K 块”，表里有 8 192 ⁠块和 16 384 ⁠块两种规模。

这些 GPU 装在 Meta 的服务器里，一台 8 ⁠块，一个机柜两台。台上是一排这样的机柜：8 ⁠个机柜，16 ⁠台服务器，128 ⁠块 GPU，排尾是网络机柜。按 Llama 3 ⁠的切法，一份模型正好摊在 128 ⁠块 GPU 上，16 384 ⁠块就是 128 ⁠份。一份的 128 ⁠块是不是挨着放，论文没有说；这一排是本页的画法。

并行不会让模型更聪明。要做的计算一样多，分给更多的 GPU，是为了在几个月而不是几千年里算完；代价是 GPU 之间要不停地传数据。

最多 16 384 ⁠块 H100 · 4 050 ⁠亿个参数 · 15.6 ⁠万⁠亿个词元 · 约 3.8 × 10²⁵ ⁠次运算

一块装不下

一块 H100 ⁠有 80 GB 显存，装在芯片两侧的显存堆栈（HBM3）里。光是 4 050 ⁠亿个参数，每个用 2 ⁠个字节存，就要 810 GB，十块多 GPU 才放得下。

训练还要存梯度和优化器的状态。按 ZeRO 论文对混合精度 Adam 的算法，每个参数 16 ⁠个字节：权重和梯度各 2 ⁠个，32 ⁠位的权重副本、动量和方差共 12 ⁠个。4 050 ⁠亿个参数就是 6.48 TB，至少要 81 ⁠块 GPU，还没算每一层算出的中间结果（激活值）。Meta 没有公布 Llama 3 ⁠每个参数用几个字节，这里用的是常用的算法（本页的计算）。

时间也不够。按论文里的实际速度，每块每秒约 400 ⁠万⁠亿⁠次，3.8 × 10²⁵ ⁠次运算一块 GPU 要算约 3 000 ⁠年；16 384 ⁠块一起算，约 67 ⁠天（只算计算，不算中断；本页的计算）。

权重 810 GB · 训练状态约 6.48 TB · 一块 80 GB · 一块要算约 3 000 ⁠年

一台八块

Meta 的服务器叫 Grand Teton：高 380 ⁠毫⁠米，宽 537 ⁠毫⁠米，深 805 ⁠毫⁠米，装满重 118.7 ⁠千⁠克。里面有三层托盘：最上面是两颗 CPU；中间是交换托盘，装着 8 ⁠张 400G 网卡，每块 GPU 一张；最下面是 GPU 托盘。台上最前面那台的 GPU 托盘拉了出来，它和下面那台都剖开了侧面。

GPU 托盘里是 NVIDIA 的 HGX 基板，上面有 8 ⁠块 H100 ⁠和 4 ⁠个 NVSwitch 交换芯片。每块 GPU 都连着全部 4 ⁠个 NVSwitch，每个 NVSwitch 也连着全部 8 ⁠块 GPU。每块 GPU 有 18 ⁠条 NVLink，每条每个方向每秒 25 GB，合起来每个方向每秒 450 GB；NVIDIA 写的 900 GB/s 是两个方向加起来。

Llama 3 ⁠用的 GPU 功耗上限每块 700 ⁠瓦，全靠风冷：每块 GPU 顶着一个高高的散热器，机箱后面是 16 ⁠个风扇，冷风从前面进，热风从后面出。一块 GPU 里面，数据怎样在显存和芯片之间搬，见图版“FlashAttention 与显存”。

8 ⁠块 H100 · 4 ⁠个 NVSwitch · 每个方向每秒 450 GB · 每块 700 ⁠瓦 · 风冷

机柜之间

每台服务器的 8 ⁠张网卡，用铜缆连到机柜顶上的交换机（Meta 用的是 Minipack2）。一个机柜两台服务器、16 ⁠块 GPU。从机柜交换机出去，换成单模光纤；台上，光纤顺着头顶的黄色线槽，走到排尾的集群交换机。每张网卡每秒 400 Gb，也就是每个方向每秒 50 GB，只有 NVLink 的九分之一。

Llama 3 ⁠的网络分三层。192 ⁠个机柜经集群交换机连成一个区，3 072 ⁠块 GPU，区里任意分成两半，两半之间都是满带宽；8 ⁠个区再经汇聚交换机连成 24 576 ⁠块 GPU 的集群，这一层的带宽只有满带宽的七分之一（1:7）。所以并行的切法和任务的安排，都尽量少跨区。

Google 用另一种办法把几千块 TPU 连起来：光路开关，见图版“TPU 与脉动阵列”。

每块 GPU 一张 400 Gb/s 网卡 · 一柜 16 ⁠块 · 一区 3 072 ⁠块 · 全集群 24 576 ⁠块 · 区之间 1:7

同一个模型，不同的数据

最简单的分法：每份模型完整地算一遍，但读的是不同的一批数据。反向传播算完，每份手里有一份自己的梯度；把所有份的梯度平均，每份用同一个平均值更新，下一步它们还是同一个模型。这叫数据并行。

Llama 3 ⁠在 16 384 ⁠块 GPU 上有 128 ⁠份，每一步共读约 1 678 ⁠万个词元，每份 131 072 ⁠个（16 ⁠条、每条 8 192 ⁠个⁠词⁠元的序列）。它用的是“全分片数据并行”（FSDP）：优化器的状态和梯度也分给各份去存，不必每份都存一整套。按 ZeRO 论文，光把优化器的状态分开，份数多时每块 GPU 存模型状态的显存就降到约四分之一，通信量不变。

128 ⁠份 · 每步约 1 678 ⁠万个词元 · 每份 131 072 ⁠个 · 每步平均一次梯度

绕一圈

平均梯度最常用的办法是环形全归约。N 块 GPU 排成一个圈，每块把自己的梯度切成 N 份。先走 N − 1 ⁠步：每步把一份传给下一块，下一块加上自己的那份，走完时每块手里有一份全部加好的；再走 N − 1 ⁠步，把加好的各份传遍全圈。

每块 GPU 一共发出梯度大小的 2(N − 1)/N 倍：8 ⁠块是 1.75 ⁠倍，128 ⁠块是 1.98 ⁠倍，几乎不随 N 增加。Patarasuk 和 Yuan 2009 ⁠年证明，不压缩数据的话，不管用什么算法，总有一块 GPU 至少要发这么多。随 N 增加的是步数：圈越大，等的延迟越多。

所以时间主要看链路多快。比如 10 GB 的梯度、128 ⁠块绕一圈，每块发出约 19.8 GB：网络每秒 50 GB，约要 0.4 ⁠秒；NVLink 每秒 450 GB，约要 0.044 ⁠秒（只算带宽，本页的计算）。实际训练里，这些通信尽量和计算同时进行。

每块发出 2(N − 1)/N 倍 · 8 ⁠块：1.75 ⁠倍 · 128 ⁠块：1.98 ⁠倍 · 步数 2(N − 1)

一层切成八份

模型的每一层，都是几个大的矩阵乘法。张量并行把一层的矩阵切开，分给几块 GPU 一起算。Megatron-LM 2019 ⁠年的切法：前馈层的第一个矩阵按列切，第二个按行切，中间不用通信；注意力按“头”分给各块 GPU。

这样每一层，前向要做 2 ⁠次全归约，反向再做 2 ⁠次：每算完一层，GPU 都要停下来对一次账。所以张量并行只在一台服务器的 8 ⁠块 GPU 里做，走 NVLink；Llama 3 ⁠的每一种布局都是 8 ⁠路。Llama 3 405B 的每一层宽 16 384，每块 GPU 拿每个矩阵的八分之一。

前向 2 ⁠次全归约，反向 2 ⁠次 · 留在一台服务器里 · Llama 3：8 ⁠路

一条流水线

流水线并行按层切：Llama 3 405B 的 126 ⁠层分成 16 ⁠段，每段约 8 ⁠层，各放在一组 GPU 上。台上这一排，每台服务器画成一段：第一段算完前几层，把结果（激活值）传给第二段，一直传到最后一段；反向传播时，梯度沿反方向传回来。

只有一批数据的话，同一时刻只有一段在干活。所以把一批数据再切成很多“微批次”，像流水线上的工件：第一个微批次到了第二段，第一段就接着算第二个。为了让各段一样忙，Llama 3 ⁠的第一段和最后一段各少放一层：它们还要做词嵌入和输出。

126 ⁠层 · 16 ⁠段 · 每段约 8 ⁠层 · 激活值向前传，梯度往回传

等出来的空当

流水线开头，后面的段在等第一个微批次；结尾，前面的段在等最后的梯度。这些空着的时间叫“气泡”。像台上这样，所有微批次先前向走完、再一起反向（GPipe 的排法），每块 GPU 空着的比例是 (p − 1)/(m + p − 1)，其中 p 是段数，m 是微批次数。

16 ⁠段、16 ⁠个⁠微⁠批⁠次，将近一半时间（48 %）在等；64 ⁠个⁠微⁠批⁠次是 19 %，128 ⁠个是 10.5 %。GPipe 的论文说，微批次至少是段数的 4 ⁠倍时，气泡可以忽略；可按公式，16 ⁠段、64 ⁠个仍有 19 %。微批次越多，每个就越小，而一批的总大小有上限。

Llama 3 ⁠用的是交错的排法，每块 GPU 放 V 段，于是气泡和计算时间之比降到 (p − 1)/(V·m)。它用的 V 和 m，论文没有给。

空着的比例 (p − 1)/(m + p − 1) · 16 ⁠段：m = 16 ⁠时 48 %，m = 64 ⁠时 19 %，m = 128 ⁠时 10.5 %

四种切法一起用

Llama 3 ⁠把这些切法叠在一起用，论文称为 4D 并行：张量并行（TP）、上下文并行（CP）、流水线并行（PP）、数据并行（DP）。16 384 ⁠块 GPU 是 8 × 1 × 16 × 128。训练最后要读 131 072 ⁠个⁠词⁠元的长序列，上下文并行开到 16 ⁠路，把一条序列切成几段分给不同的 GPU，数据并行就降到 8 ⁠份：8 × 16 × 16 × 8，还是 16 384 ⁠块。

它们按 [TP, CP, PP, DP] 的顺序一层套一层：越靠里，通信越多、越等不起，就放得越近。张量并行在一台服务器里；数据并行在最外面，要跨过好几级网络，因为它可以一边算一边预取权重、归约梯度，等得起。

混合专家模型还有第五种切法，把专家分放到不同的 GPU 上，见图版“混合专家”。Llama 3 ⁠是稠密模型，用不上。

TP 8 × CP 1 × PP 16 × DP 128 = 16 384 · 长序列：8 × 16 × 16 × 8

四成算力

衡量用得好不好，常看模型算力利用率（MFU）：每秒实际做完的模型计算，除以 GPU 的峰值。8 192 ⁠块 GPU 训练 Llama 3 ⁠时，利用率是 43 %，每块每秒做约 430 ⁠万⁠亿⁠次；16 384 ⁠块时是 41 %，读长序列时是 38 %。

没用上的部分，花在等通信、流水线的气泡，和那些受限于显存带宽、填不满计算单元的运算上。从 8 192 ⁠块到 16 384 ⁠块，利用率从 43 % ⁠降到 41 %：论文说，这是因为一批的总词元数不变，每份分到的数据少了一半。

NVIDIA 给的 H100 ⁠峰值，是每秒 1 979 ⁠万⁠亿⁠次 BF16 ⁠运算，那是按稀疏矩阵算的；稠密矩阵是一半，约 989 ⁠万⁠亿⁠次。论文没有写它用的是哪个峰值，表里的数字和约 989 ⁠万⁠亿⁠次相符。

43 %（8 192 ⁠块）· 41 %（16 384 ⁠块）· 38 %（长序列）· 峰值每秒约 989 ⁠万⁠亿⁠次

54 ⁠天，466 ⁠次

训练是同步的：每一步所有 GPU 都要交换数据，一块 GPU 出错，可能整个任务都得重来。论文取了预训练中的 54 ⁠天：任务中断了 466 ⁠次，其中 47 ⁠次是计划内的（升级固件、改配置），419 ⁠次是意料之外的。

意外里，坏掉的 GPU 148 ⁠次，GPU 的 HBM3 ⁠显存 72 ⁠次，软件错误 54 ⁠次，网络交换机和线缆 35 ⁠次，主机临时维护 32 ⁠次。论文说约 78 % ⁠归于硬件，包括确认的和怀疑的。只有 3 ⁠次要人动手处理，其余由自动化处理，有效训练时间在 90 % ⁠以上。

办法是隔一段时间存一次检查点：每块 GPU 把自己那份模型状态存下来，1 MB 到 4 GB 不等；出了故障，换掉坏的机器，从最近的检查点接着算。一天里的时间也有影响：中午热，GPU 自动降频，吞吐量差 1⁠–⁠2 %。所有 GPU 一起停下来等存档或通信时，整个机房的用电会瞬间变化几十兆瓦。

466 ⁠次中断 · 419 ⁠次意外 · 约 78 % ⁠归于硬件 · 人工处理 3 ⁠次 · 有效训练时间 90 % ⁠以上

拆开来看

GPU 托盘的零件一件件升起来：金顶的散热器、8 ⁠块 GPU、4 ⁠个 NVSwitch 和它们的散热器、HGX 基板，留下托盘本身。

指针停在哪一件上（手机上轻点一下），那一件便单独托起，标出名字，其余的淡去。