# 第 9 章 为什么一张显卡不够

> 本章问题：为什么需要 GPU，为什么需要上万块？
> 来源：https://llm.weiborao.link/#ch9

**上一章留下的问题：**每一次思考、每一次工具调用都要消耗 Token，而每一个 Token 背后都是几千亿次乘法和加法。这些计算在哪里完成？为什么一张显卡远远不够，要用上万张？

从这一章开始，我们离开模型，走进承载它的物理世界。先回答两个“为什么”：为什么是 GPU，而不是普通电脑的 CPU？为什么是上万块，而不是一块？答案都可以用小学算术推出来。

### 9.1 先算账：一个 Token 要算多少次

第 2 章说过，模型就是几千亿个权重。生成一个 Token 时，输入要和每一个权重相乘一次、再加一次，所以**每个 Token 大约要做“2 × 参数个数”次运算**。一个 4050 亿参数的模型，生成一个 Token 约 8100 亿次运算。

训练更贵：除了“往前算”一遍，还要用反向传播“往回算”误差的责任，往回算的量大约是往前的两倍。于是有一个很好用的估算公式：

训练总运算量 ≈ 6 × N × DN = 参数个数，D = 训练 Token 数。Llama 3.1 405B：6 × 4050 亿 × 15.6 万亿 ≈ 3.8 × 10²⁵ 次，与论文给出的数字一致

类比：

“运算次数”和“每秒运算次数”的关系，就像“公里”和“公里每小时”。3.8 × 10²⁵ 是要走的总路程；GPU 的算力（比如每秒 989 万亿次）是车速。路程除以车速，就是要开多久。

### 9.2 为什么是 GPU

这几十亿亿次运算有一个特点：**几乎全是矩阵乘法，而且每一格可以独立计算**。算结果矩阵的第 1 格时，不需要等第 2 格算完。这种活最适合“人海战术”。

> 【图示】CPU 与 GPU 的对比：CPU 有几十个强大的核心，擅长复杂的逻辑和顺序任务；GPU 有上万个简单的计算单元和专门做矩阵乘法的张量核心，擅长同时做海量相同的简单运算。

**图 9-1** CPU 像几十位博士，每位都能处理复杂的逻辑；GPU 像上万名工人，每人只会简单的算术，但能同时开工，还配有专门做矩阵乘法的“张量核心”。

问：博士比工人聪明，为什么这种活要找工人？

答：因为活本身不需要聪明，需要的是“同时做很多份”。让 32 位博士算一百万道两位数乘法，不如让一万名工人一起算。

问：GPU 本来是给游戏画画面的，怎么就会算 AI 了？

答：画画面也是“给几百万个像素同时算颜色”，同一类活。2006 年 NVIDIA 推出 CUDA，让程序员能用普通的编程语言指挥 GPU 做任何并行计算；2012 年 AlexNet 用两块游戏显卡训练，从此 GPU 成了 AI 的主力（第 1 章）。

今天的数据中心 GPU 已经和游戏显卡分道扬镳。以 NVIDIA H100（SXM 版）为例：显存 80 GB，显存带宽 3.35 TB/s，BF16 稠密算力约 989 万亿次每秒（官网表格写的 1,979 是“稀疏”口径），功耗最高 700 W。

再看一眼新一代，能感到这条路走得有多快。NVIDIA 2025 年发布的 Blackwell Ultra GPU：用台积电 4NP 工艺，把两颗接近光刻极限的大芯片用 10 TB/s 的片间互联拼成一块，在软件看来是一个完整的 GPU，共 2080 亿个晶体管；显存是 8 叠 12 层堆叠的 HBM3E，共 288 GB、8 TB/s；它最主打的指标，是用一种新的 4 位浮点格式 NVFP4 计算时，稠密算力达到每秒 15 千万亿次（15 PFLOPS）。

**注意比较的口径**　15 PFLOPS 是 4 位精度，989 TFLOPS 是 H100 的 16 位精度，两者不能直接相除得出“快了多少倍”。精度越低，每次运算越便宜、同样的芯片能做的次数越多，代价是数字越粗糙（第 2 章的“尺子刻度”）。这也说明了一个趋势：AI 硬件的进步，很大一部分来自**敢用更少的位数**，再用算法把精度损失控制住。

### 9.3 一块 GPU 要算多久

现在可以做除法了。假设 GPU 能发挥 40% 的峰值（Llama 3 论文报告其大规模训练的 BF16 利用率为 38%–43%），一块 H100 每秒约做 4 × 10¹⁴ 次运算。

> 【图示】一块 GPU 要算多久：GPT-3 的训练量约 25 年；DeepSeek-V3 论文报告 278.8 万 H800 GPU 时，相当于一块卡约 320 年；Llama 3.1 405B 约 3000 年；换成 1.6 万块 H100 并行，约 70 天。按 H100 BF16 稠密算力 40% 利用率估算。

**图 9-2** 一块 GPU 要算多久（横轴是对数刻度，每格 10 倍）。训练一个 4050 亿参数的模型，一块 H100 要算约 3,000 年，差不多是从商周之际算到今天。把它分给 1.6 万块卡，才压到两个多月。

表 9-1 把训练量换算成“一块 GPU 要算多久”

| 模型 | 训练运算量 | 一块 H100（40%） | 相当于 |
| --- | --- | --- | --- |
| GPT-3（2020） | 3.14×10²³ | 约 25 年 | 一个人从出生到大学毕业再工作几年 |
| Llama 3.1 405B（2024） | 3.8×10²⁵ | 约 3,000 年 | 从商周之际算到今天 |
| 同上，用 1.6 万块 H100 | — | 约 70 天 | 一个季度不到 |

运算量取自论文；“一块 GPU 要算多久”为本书估算，推导见附录。闭源前沿模型的训练量未公开，一般认为更大。

这就是第一条理由：**算不完**。一块卡要几千年，只能让上万块卡同时算。

### 9.4 第二条理由：装不下

就算不在乎时间，一块卡也**装不下**。第 2 章算过，405B 模型的权重按 BF16 是 810 GB，而一块 H100 只有 80 GB。训练时更糟：除了权重，还要为每个参数存梯度和优化器的状态（比如“这个旋钮最近往哪边拧、拧得多快”），混合精度训练常见的粗算是每个参数约 16 字节，合计约 6.5 TB。

> 【图示】显存装不下：一块 H100 有 80 GB。405B 模型按 BF16 存权重要 810 GB，需要 11 块卡才放得下；训练时还要存梯度和优化器状态，约 6.5 TB，至少要 81 块卡，这还没算中间结果。

**图 9-3** 光是把训练状态放进显存，就需要至少 81 块 H100，这还没有算前向计算中产生的大量中间结果。模型必须被“大卸八块”，分到很多块卡上。

**停一下：为什么不干脆造一块有 10 TB 显存的 GPU？**

**参考答案：**

GPU 用的高带宽显存（HBM）是一层层堆叠在芯片旁边的，容量受到封装面积、散热和成本的限制，每一代只能增加一部分：H100 是 80 GB，H200 是 141 GB，Blackwell Ultra 最高 288 GB。而且就算装得下，算力也不够，还是要分给很多块卡。所以业界的思路是反过来的：**把很多块 GPU 连得足够紧，让它们像一块大 GPU 那样工作**。下一章就讲怎么连。

### 9.5 怎么拆：三种并行

把一个模型的训练分给上万块 GPU，有三种基本拆法，实际中会组合使用。

> 【图示】三种拆法：数据并行，每块 GPU 有完整模型，处理不同的数据，之后同步梯度；张量并行，把每一层的大矩阵切开，多块 GPU 同时算同一层；流水线并行，把不同的层分给不同的 GPU，像装配线一样接力。

**图 9-4** 三种拆法。数据并行拆“数据”，张量并行拆“每一层的矩阵”，流水线并行拆“层”。混合专家模型（如 DeepSeek-V3）还会把不同的“专家”放在不同的卡上，叫专家并行。

类比：

想象一家要在一天内做完十万份订单的餐厅集团。**数据并行**：开 100 家一模一样的分店，各做各的订单，每天打烊后开会，把各店摸索出的改进合成一份新菜谱。**张量并行**：一道巨型菜，八个厨师围着同一口锅，各切一部分，切完必须马上汇合。**流水线并行**：前厨备料、中厨烹炒、后厨装盘，一道菜在几站之间接力。

三种拆法的共同代价是：**拆开的人必须不停地交流**。数据并行每一步都要把所有卡的梯度汇总平均；张量并行每一层都要交换部分结果；流水线并行每一站都要把中间结果交给下一站。拆得越细，交流越频繁。

### 9.6 训练和推理，对 GPU 的要求不一样

表 9-2 训练与推理的 GPU 工作特征

|  | 训练 | 推理 |
| --- | --- | --- |
| 工作方式 | 离线批处理，持续几周到几个月 | 在线服务，实时响应用户 |
| 同步要求 | 高度同步：每一步所有卡都要对齐 | 请求之间相互独立；单个请求内多卡协作 |
| 典型规模 | 数千到数万块 GPU 一个作业 | 多数模型在一台 8 卡服务器内即可运行；超大模型或混合专家模型会跨多台 |
| 瓶颈 | 算力、卡间通信、故障恢复 | 显存容量与带宽（KV 缓存）、延迟 |
| 关键指标 | 作业完成时间（JCT）、扩展效率 | 首 Token 延迟、Token 间延迟、吞吐量、并发数 |

训练还有一个常被忽略的敌人：**故障**。Llama 3 论文记录了一段 54 天的预训练：期间作业被打断 466 次，其中 419 次是意外，近六成源于 GPU 问题。平均约 3 小时一次。上万块卡里，每天总有几块出问题，而任何一块卡出问题，整个同步训练都会停下来。所以训练系统要定期把全部状态存一份“存档”（检查点），出故障后从最近的存档恢复。存档动辄几 TB，这给存储带来了巨大压力（第 12、14 章）。

一块卡*算不完*，也*装不下*；  
拆开之后，就得不停地交流。

##### 本章带走

AI 的计算几乎全是可并行的矩阵乘法，所以用 GPU；训练量大到一块卡要算几千年、状态大到一块卡装不下，所以用上万块。

- 估算公式：生成一个 Token ≈ 2N 次运算；训练 ≈ 6ND 次。Llama 3.1 405B：3.8×10²⁵ 次 ≈ 一块 H100 算 3,000 年 ≈ 1.6 万块算 70 天。
- 三种拆法：数据并行、张量并行、流水线并行（外加专家并行），代价都是卡与卡之间要频繁交流。
- 训练高度同步、怕故障；推理重延迟、重显存。

**于是，下一个问题**：拆开之后，GPU 之间要不停地“对答案”。上万块卡怎样对答案，才不至于把大部分时间都花在等待上？