# 下一个 Token：用第一性原理看懂大语言模型、AI Agent 与 AI 工厂
> 一本中文科普长文：从“AI 能拿奥数金牌线却数不清 strawberry 里有几个 r”的反差出发，用第一性原理讲清 Token、神经网络、Transformer、训练与对齐、推理、RAG、AI Agent，以及承载它们的 GPU、集合通信、AI 网络（RoCEv2、InfiniBand、超以太网）与 AI 工厂（含 NVIDIA 企业参考架构与 Cisco AI POD / Secure AI Factory）。资料截至 2026-10-08，全书事实均对照一手出处核查，出处见附录。
作者：Articulate 工作室｜网址：https://llm.weiborao.link/｜最后更新：2026-10-09
---
# 序章 金牌与草莓
> 本章问题：这到底是一种什么样的智能？
> 来源：https://llm.weiborao.link/#ch0
2025 年 7 月，国际数学奥林匹克竞赛（IMO）结束后不久，Google DeepMind 宣布：他们的 Gemini Deep Think 在 6 道题里完整解出 5 道，得 35 分（满分 42），达到金牌线。证明用自然语言写成，在 4.5 小时的比赛时限内完成，并由 IMO 的协调员按正式标准评分。几乎同一时间，OpenAI 也宣布自己的实验性推理模型达到了金牌水平。
IMO 是全世界最聪明的中学生之间的较量。按 DeepMind 在公告里的说明，奖牌只授予成绩排在前一半的选手，其中只有约 8% 能拿到金牌。
现在把时间往回拨一年。2024 年夏天，网上流行一个小测试：问 AI “strawberry 这个单词里有几个 r？”。正确答案是 3 个。据 TechCrunch 2024 年 8 月的报道，当时最流行的 GPT-4o 和 Claude 都曾回答 **2 个**。
> 【图示】左边：2025 年 7 月，AI 在国际数学奥林匹克竞赛中解出 6 题中的 5 题，得 35 分（满分 42），达到金牌线。右边：2024 年，同类模型被问 strawberry 里有几个 r，回答 2 个；因为它看到的不是 10 个字母，而是 straw 和 berry 两个 Token。
**图 0-1** 左边是 2025 年 7 月的奥赛成绩，右边是 2024 年的“草莓测试”。两者不是同一个模型，也不在同一年，但它们是同一类技术——大语言模型。右下角是这个反差的线索：模型看到的不是 10 个字母，而是两个编号。
公平地说，这两件事不是同一个模型在同一天做到的，模型也一直在改进。而且有一个办法能让模型数对：先把单词一个字母一个字母地写出来，再逐个数（第 3 章会解释为什么有效）。可是“需要先拼出来才能数”这件事本身就很说明问题：**一个能写竞赛级证明的系统，看单词的方式和我们完全不同**。
**停一下：先别往下读。凭你现在的直觉猜一猜：一个能写数学证明的系统，为什么会数错字母？**
**参考答案：**
常见的猜测有三种：“它太粗心”“它其实没理解，只是在背答案”“它故意的”。这三种都不对。真正的原因藏在它“看”文字的方式里：它看到的不是一个个字母，而是一块块被编了号的片段，这些片段叫 Token。straw 是一个编号，berry 是另一个编号，编号里没有“字母”这个概念。第 3 章会把这件事讲透。
### 0.1 一个反差，三个问题
这个反差背后，藏着本书要回答的三个问题。
问：它到底“懂”不懂？
答：先别急着下结论。我们得先知道它在做什么，再讨论它懂不懂。答案会在第 4 章出现，而且比“懂”或“不懂”都更有意思。
问：它是怎么学会解奥数题的？没有人把解法写进程序里吧？
答：没有。没有人给它写过一条数学规则。它的能力来自“读”了海量文字之后自己调出来的几千亿个数字。第 1、2 章讲这是怎么回事。
问：那这种能力要花多大代价？
答：很大。训练一个这样的模型，用一块顶级显卡要算上几千年，所以需要上万块显卡连在一起，组成一座“AI 工厂”。第 9 到 14 章会走进这座工厂，并拆开一份真实的“建厂图纸”。
### 0.2 一句话的答案
如果你只想带走一句话，那就是网页版封面上那台终端正在生成的那句：
大语言模型只做一件事它只做一件事：根据前面的文字，猜下一个词。
这句话本身也是按这个方式生成的：每个方块是一个 Token，模型每次只吐出一个，吐完把它接到前文后面，再猜下一个。你在聊天窗口里看到的“打字机效果”，并不是为了好看而故意放慢的动画，它就是模型真实的工作节奏。
听起来简单得过分。“猜下一个词”和“解奥数题”之间，隔着整整一本书的距离。这本书要做的，就是一块一块地把中间的台阶搭起来。
类比：
想象一个从小只靠**听**学会说话的人。他能讨论哲学、背诵诗歌、讲出漂亮的论证，却从没见过文字。你问他“草莓这个词有几个笔画”，他会愣住，因为他脑子里的“草莓”是一个整体的声音，不是一笔一画。大语言模型有点像他：它的基本单位是 Token，而不是字母。
这个类比在一个地方会失效：那个人至少还有眼睛和手，模型最初连这些都没有，只有文字。
##### 本书讨论的是
- 大语言模型怎样工作、怎样训练、为什么有效
- 它怎样变成会做事的 Agent
- 承载它的 GPU、网络、存储与软件
##### 本书不讨论
- AI 有没有意识、会不会毁灭人类
- 哪家公司的模型“最强”（排名每隔几周就变）
- 数学推导（需要的数学只有加法、乘法和“取对数”的直觉）
### 0.3 这本书怎么读
全书按“黄金圈”分成三段：先问**为什么**（这是一种什么智能、它从哪里来），再问**怎样做**（它怎样学、怎样回答、怎样查资料、怎样做事），最后问**是什么**（承载它的物理世界）。每一章只回答一个问题，而这个问题都由上一章的结论引出。
表 0-1 书里会反复出现的几种“积木”
| 标记 | 作用 | 建议读法 |
| --- | --- | --- |
| 问 / 答 | 苏格拉底式对话，让结论从问题里长出来 | 先自己回答“问”，再看“答” |
| 停一下 | 一个需要想一想的问题，答案折叠起来 | 真的停下来猜一次，猜错比猜对收获大 |
| 类比 | 给新概念一个熟悉的形状 | 同时留意类比在哪里失效 |
| 是 / 不是 | 划出概念的边界，防止误读 | “不是”那一栏往往最有用 |
| Token 方块 | 模型眼中的文字单位 | 看到方块，就是在用模型的眼睛看 |
| 网页版交互 | 拖动、单步、动画 | EPUB 读者看对应的静态图与表即可，信息不缺 |
数字方面，本书只用论文、官方模型卡和厂商规格页上的数字；自己推算的会标为估算，并把推导写在附录里。AI 领域变化很快，凡是“最新”的内容，都以资料截止日 2026 年 10 月 8 日为准。
### 0.4 一张认知地图
在出发之前，先看一眼全貌。今天的 AI 不是一个单独的程序，而是一摞层层依赖的技术：最上面是你直接用到的应用，最下面是 GPU 和网线。下面这张“认知地图”把它们分成七层，并标出了每一层在本书哪一章展开。
> 【图示】AI 认知地图：从上到下七层。应用层（聊天助手、编程 Agent、研究助手、物理 AI），认知引擎层（RAG 与评测），模型层（Transformer、训练、推理），数据表示层（Token、嵌入、向量数据库），软件调度层（Kubernetes、CUDA、NCCL），算力层（GPU、显存、NVLink），网络层（RoCEv2、InfiniBand、超以太网）。左侧地基是神经网络与学习，右侧贯穿全部层的是 AI 工厂。
**图 0-2** AI 认知地图。七层从上到下：应用、认知引擎、模型、数据表示、软件调度、算力、网络。左边的“地基”是神经网络与学习，右边贯穿所有层的是 AI 工厂。本书的问题链大致是从地基出发，自中间向上走到应用，再向下走到硅片与网络，最后把它们组装成工厂。
问：为什么要先看地图，而不是直接从第 1 章读起？
答：因为后面每一章都只盯着一层。有了地图，你随时知道自己站在哪一层、它依赖下面哪一层、又在为上面哪一层服务。读到第 11 章的网络细节时，不会忘了它最终是为了让应用层那句回答更快一点。
这张图是在作者此前发布的[“AI 认知地图”](https://weiborao.link/aicogmap.html)基础上更新的：层次和章节对应关系按本书重新组织，数字和说法则按本书的事实核查标准做了修订。
##### 本章带走
一个能拿奥数金牌线的系统，会数错 strawberry 里的 r。这不是粗心，而是线索。
- 大语言模型只做一件事：根据前文，一次一个 Token 地猜下一个词。
- 它看到的不是字母，而是被编了号的片段（Token）。
- 它的能力不是被人写进去的规则，而是从海量文字里“学”出来的。
**于是，下一个问题**：没有人把解题规则写进它的程序里，那它的能力从哪里来？机器是怎样从“被告诉规则”走到“自己学规则”的？
---
# 第 1 章 从写规则到学规则：AI 的七十年
> 本章问题：机器是怎样学会的？大语言模型从哪里来？
> 来源：https://llm.weiborao.link/#ch1
**上一章留下的问题：**没有人把解题规则写进它的程序里，那它的能力从哪里来？机器是怎样从“被告诉规则”走到“自己学规则”的？
让机器变聪明，只有两条路：要么由人把规则告诉它，要么让它自己从例子里找出规则。人工智能七十年的历史，几乎就是第二条路一步步赢过第一条路的历史。本章沿着这条主线走一遍，走到 ChatGPT 诞生的那一刻，再往前看一步。
### 1.1 教机器认一只猫
假设你要写一个程序，判断一张照片里有没有猫。最直接的办法是写规则。
问：猫有什么特征？
答：四条腿、有尾巴、有胡须、尖耳朵、毛茸茸。
问：狗也是四条腿、有尾巴、有胡须。那怎么区分？
答：加一条：猫的脸比较圆，鼻子比较短。
问：如果照片里的猫蜷成一团，看不到腿呢？只露出半个脑袋呢？是一只无毛猫呢？
答：……那就再加规则。可是规则会越加越多，永远加不完。
问：你三岁的时候，是怎么学会认猫的？
答：没人给我讲过规则。大人指着猫说了很多次“这是猫”，我看多了，自己就会了。
最后一个回答，就是机器学习的全部思想。我们不再告诉机器“猫是什么样的”，而是给它看大量标好了“是猫/不是猫”的照片，让它自己调整内部的判断方式，直到猜得越来越准。
> 【图示】两种让机器变聪明的办法。传统编程：人写规则，规则加数据，程序算出答案。机器学习：给出数据和答案，学习算法反过来算出规则，规则以参数的形式存下来。
**图 1-1** 两种范式的输入和输出正好倒过来。传统编程里，规则是输入；机器学习里，规则是输出，并且以一大堆数字（参数）的形式存下来，人往往读不懂。
类比：
传统编程像给新厨师一本**菜谱**：每一步写清楚，照做就行，但菜谱上没有的菜他就不会。机器学习像让学徒**尝一万道菜**，每次告诉他“好吃”或“难吃”，他自己慢慢摸索出火候和咸淡。学徒学到的东西写不成菜谱，但他能做出菜谱上没有的菜。
##### 机器学习是
- 从大量例子里自动调整内部参数，让预测越来越准
- 一种“把规则当输出”的编程方式
##### 机器学习不是
- 机器有了自我意识，自己想学什么就学什么
- 不需要人：数据、目标、评判标准仍由人来定
### 1.2 七十年的一条主线
“人工智能”这个词出现在 1955 年 8 月的一份研究提案里。提案人 McCarthy、Minsky、Rochester 和 Shannon 计划第二年夏天在达特茅斯学院用两个月时间研究“让机器使用语言、形成抽象和概念”。他们低估了难度，这个问题后来花了将近七十年。
> 【图示】AI 七十年时间线：1955 年提出人工智能，1958 年感知机，1969 年研究转冷，1986 年反向传播，1997 年深蓝，2012 年 AlexNet，2016 年 AlphaGo，2017 年 Transformer，2018 年 GPT-1 和 BERT，2020 年 GPT-3，2022 年 ChatGPT，2024 年推理模型 o1，2025 年编程 Agent 与奥赛金牌线，2026 年新一代模型。
**图 1-2** AI 的七十年，按主导方法分成四个时代。颜色从灰到品红，越往后，“从数据里学”的成分越重、规模越大。2017 年之后的事件密度明显变高。
这条时间线上有三个转折点值得停下来看。
**第一个转折：神经网络能训练了（1986）。**早在 1958 年，Rosenblatt 就做出了“感知机”，一个能从例子里学习的人工神经元。可是单层的感知机能力有限，1969 年 Minsky 和 Papert 的《感知机》一书分析了它的局限，常被看作神经网络研究转冷的原因之一。直到 1986 年，Rumelhart、Hinton 和 Williams 在《自然》上发表了反向传播算法，多层网络才有了一个可行的训练方法。第 2 章会讲这个算法在做什么。
**第二个转折：数据和显卡到位了（2012）。**反向传播有了，但当时的数据太少、计算机太慢，神经网络一直打不过其他方法。2012 年，一个叫 AlexNet 的网络参加 ImageNet 图像识别比赛，前五名错误率 15.3%，第二名是 26.2%。它的训练用了**两块 GTX 580 游戏显卡**，花了五六天。从这一年开始，“神经网络 + 大数据 + 显卡”成了主流。
**第三个转折：Transformer（2017）。**2017 年 6 月，Google 的八位研究者发表论文《Attention Is All You Need》，提出 Transformer 架构。它原本是为机器翻译设计的，最大的模型在一台装 8 块 P100 显卡的机器上训练了 3.5 天。今天几乎所有大语言模型，GPT、Claude、Gemini、Llama、DeepSeek，都是它的后代。第 4 章会拆开它。
**停一下：AlexNet 为什么偏偏用游戏显卡来训练，而不是用更贵的服务器 CPU？**
**参考答案：**
因为训练神经网络的计算几乎全是大量的乘法和加法，而且彼此独立，可以同时算。游戏显卡本来就是为“同时给几百万个像素算颜色”设计的，恰好擅长这种活。这件事在第 9 章会变成主角：为什么 AI 需要 GPU，而且需要上万块。
### 1.3 苦涩的教训
1997 年，IBM 的深蓝战胜了国际象棋世界冠军卡斯帕罗夫。深蓝依靠专用硬件做大规模的棋局搜索，评判局面好坏的规则则由人来设计。十九年后，AlphaGo 在围棋上以 4:1 战胜李世石，它的能力主要来自从棋局中学习，再配合搜索，而不是人写的围棋规则。
强化学习的奠基人之一 Richard Sutton 在 2019 年写了一篇短文，叫《苦涩的教训》（The Bitter Lesson）。他总结了七十年 AI 研究：
> 七十年 AI 研究能得出的最大教训是：利用计算的通用方法最终是最有效的，而且优势巨大。……能随计算无限扩展的方法似乎只有两种：搜索和学习。
>
> —— Richard Sutton，《The Bitter Lesson》，2019 年 3 月
为什么“苦涩”？因为研究者一次次把自己的专业知识精心地编进系统，短期内确实有效；可是一旦计算力涨上来，那些不依赖人类知识、只靠“学”和“搜”的笨办法总会反超。人类的知识写不了太多，算力却每隔几年就翻好几倍。
### 1.4 从 GPT-1 到 ChatGPT：把同一件事做大
Transformer 出现后的第二年，OpenAI 发布了 GPT-1（2018 年 6 月）。它的思路是：先让模型在海量文本上做一件简单的事——**读一段文字，猜下一个词**——这叫“预训练”；再用少量标注数据针对具体任务微调。同年 10 月，Google 发布了 BERT，走的是相近的“先预训练”路线。
此后几年，OpenAI 做的事情说起来很单调：同样的结构，同样的任务，把模型做大，把数据加多。
> 【图示】公开模型参数量的增长（对数刻度）：GPT-1 约 1.1 亿，GPT-2 15 亿，GPT-3 1750 亿，Llama 3.1 405B 4050 亿，DeepSeek-V3 总参数 6710 亿。六年增长约 6000 倍。
**图 1-3** 公开参数量的模型，横轴每一格是 10 倍。从 GPT-1 到 DeepSeek-V3，六年大约涨了 6000 倍。DeepSeek-V3 用的是“混合专家”结构，每个 Token 只激活 6710 亿参数中的 370 亿，第 9 章还会提到它。
规模涨上去之后，出现了一件谁也没完全预料到的事。2020 年 5 月发布的 GPT-3 有 1750 亿参数，训练用了 3000 亿个 Token。人们发现，**不用重新训练**，只要在提问时给它看几个例子，它就能学会一个新任务，比如：
在提示里给三个例子，模型自己接上第四个苹果→apple 香蕉→banana 葡萄→grape 草莓→strawberry
这叫“上下文学习”（in-context learning）。模型在训练时从没被要求做“中译英”，但它读过的文字里有足够多这样的模式，它学会了“看到这种格式就接着这种格式往下写”。
可是 GPT-3 还不太听话。你问它一个问题，它可能接着写出五个类似的问题，因为在它读过的网页里，问题后面常常跟着更多问题。2022 年 3 月，OpenAI 发表 InstructGPT：用人写的示范和人对回答的打分去微调模型。结果，一个 13 亿参数的 InstructGPT，回答比 1750 亿参数的 GPT-3 更受人喜欢——小了一百多倍，却更好用。第 5 章会讲清楚其中的道理。
2022 年 11 月 30 日，OpenAI 把这套方法用在对话上，发布了 ChatGPT。OpenAI 的发布文章说，ChatGPT 与 InstructGPT 是“兄弟模型”，用的是同样的人类反馈强化学习方法。到 2026 年 10 月，OpenAI 公布的数字是每周超过 12 亿人使用 ChatGPT。
表 1-1 通向 ChatGPT 的几块关键积木
| 年份 | 事件 | 它解决了什么 |
| --- | --- | --- |
| 1986 | 反向传播 | 多层神经网络有了训练方法 |
| 2012 | AlexNet | 证明“大数据 + GPU + 深层网络”能碾压旧方法 |
| 2017 | Transformer | 一种能高效并行、能处理长文本的网络结构 |
| 2018 | GPT-1、BERT | 先在海量无标注文本上预训练，再迁移到具体任务 |
| 2020 | 缩放定律、GPT-3 | 发现“做大”有规律可循；大模型能从几个例子里学新任务 |
| 2022 | InstructGPT、ChatGPT | 让模型听懂指令、按人喜欢的方式回答 |
| 2024–2026 | 推理模型、Agent | 先想再答；不只会说，还会调用工具去做（第 5、8 章） |
### 1.5 2024 年之后：会想，会做
ChatGPT 之后，主线仍然是“学”，但学的东西变了。2024 年 9 月，OpenAI 发布 o1，称它会在回答前“花更多时间思考”。2025 年 1 月，DeepSeek 发布 R1，论文的结论是：推理能力可以单靠强化学习激发出来，不需要人工写好的推理过程。半年后，就出现了序章里那块奥赛金牌。
与此同时，模型开始从“说”走向“做”。2025 年 2 月，Anthropic 推出 Claude Code，让模型在程序员的终端里读代码、改文件、跑测试；同年 4、5 月，OpenAI 先后推出开源的 Codex CLI 和云端的 Codex。到 2026 年，Meta 的超级智能实验室发布了 Muse Spark 系列模型和终端编程助手 Muse Code，各家的新模型几乎每隔几周就更新一次。这是第 8 章的主题。
不是人把规则教给机器，
而是机器从数据里*把规则调出来*。
##### 本章带走
AI 七十年的主线：从“人写规则”转向“机器从数据里学规则”，而“学”的效果随着数据和算力一起增长。
- 三个转折：1986 反向传播让神经网络能训练；2012 AlexNet 证明数据 + GPU 有效；2017 Transformer 提供了能做大的结构。
- Sutton 的“苦涩的教训”：利用计算的通用方法（学习与搜索）最终胜出。
- GPT 系列只做一件事——猜下一个词——然后不断做大；再加上指令微调，就有了 ChatGPT。
**于是，下一个问题**：我们一直在说机器“学”。可是“学”在机器里到底是什么动作？它从数据里调出来的“规则”存在哪里，长什么样？
---
# 第 2 章 几千亿个旋钮：神经元、参数与学习
> 本章问题：机器里的“学习”是什么？模型文件里装着什么？
> 来源：https://llm.weiborao.link/#ch2
**上一章留下的问题：**我们一直在说机器“学”。可是“学”在机器里到底是什么动作？它从数据里调出来的“规则”存在哪里，长什么样？
“神经元”“神经网络”“参数”“梯度下降”，这些词听起来像是要先学一学期生物和微积分。其实不用。本章只用加法、乘法和“往哪边拧”的直觉，带你一级一级爬上去。台阶是这样排的：
1. **名字从哪来：**大脑里的神经元做了一件什么事？
2. **一个人工神经元：**给几个条件打分，过了门槛就“是”。
3. **学习：**不让人定分数，让机器从例子里自己调。
4. **一个不够：**为什么要把很多神经元连成“网络”、叠成“层”？
5. **很多层怎么一起学：**把错误的责任一层层分下去。
6. **大语言模型与模型文件：**同样的东西，放大一百亿倍，存进硬盘。
### 2.1 名字从哪来：大脑里的神经元
你的大脑里有大量神经细胞，叫**神经元**。粗略地说，一个神经元做的事很简单：它从很多“上游”神经元那里接收信号；有的信号让它兴奋，有的让它平静；这些信号累积起来，**超过某个门槛，它就“放电”**，把信号传给下游；没到门槛，就保持安静。
上世纪中叶，研究者想：能不能用数学模仿这个“收信号、累加、过门槛就传下去”的动作？于是有了**人工神经元**（第 1 章的感知机就是最早的一种）。名字是从生物学借来的，但只借了这一个最粗的轮廓。
##### 人工神经元是
- 一个很小的数学公式：加权求和，再过一道门
- 受生物神经元“累加、过门槛”这一点启发的命名
##### 人工神经元不是
- 对大脑神经元的模拟（真实神经元复杂得多）
- 会“思考”的小单元：如果说有思考，也只存在于亿万个单元的整体配合里
### 2.2 一个人工神经元：打分，再过门槛
周末要不要去爬山？你大概会考虑三件事：天气好不好，朋友去不去，自己累不累。
**第一步，把条件变成数字。**计算机只认数字，所以先把每个条件写成一个数：天气好记 1，不好记 0；朋友去记 1，不去记 0；累的程度从 0 到 1，比如“有点累”记 0.8。这几个数叫**输入**。
**第二步，给每个条件定一个分量。**天气很重要，给 3 分；朋友有点重要，给 2 分；累是减分项，给 −4 分。这些分量叫**权重**：权重大，说明这个条件说话分量重；权重是负数，说明它在“拉后腿”。
**第三步，算总分。**每个输入乘上自己的权重，再加起来：3×1 + 2×1 + (−4)×0.8 = 1.8。这就是“加权求和”，和期末成绩按“平时 30%、期末 70%”算总评是同一回事。
**第四步，过门槛。**有的人很想出门，有的人很宅，所以还要加一个调节门槛高低的数，叫**偏置**。这里设为 −1（说明这人有点宅，总分要多 1 分才够）：1.8 − 1 = 0.8。最后一道“门”规定：结果大于 0 就输出“去”，否则“不去”。这道门叫**激活函数**，它就是生物神经元“过了门槛才放电”的数学版本。
> 【图示】一个人工神经元：三个输入分别乘以权重，加起来再加上偏置，经过激活函数得到输出。例子：天气好乘 3，朋友去乘 2，很累乘负 4，加权求和得 1.8，再加上偏置负 1 得 0.8，大于 0，所以输出“去爬山”。
**图 2-1** 一个人工神经元的全部动作：输入乘权重、加起来、加上偏置、过一道门。权重 3、2、−4 和偏置 −1 决定了它的“性格”：同样的输入，换一组权重，结论可能完全相反。
记住一个关键事实：**这个神经元的全部“判断力”，都装在那几个数里**——三个权重和一个偏置。换一个人，比如一个不怕累的户外爱好者，他的“累”的权重可能只有 −1，同样的输入就会得出“去”。权重和偏置合起来叫**参数**。这个词全书会反复出现，它指的就是这些决定判断的数字。
问：图里的权重 3、2、−4，是谁定的？
答：在这个例子里是我随手写的。
问：如果权重定得不好，比如把“累”的权重写成 +4，会怎样？
答：那它就会越累越想去爬山，判断全错。
问：那么，与其让人去猜权重，能不能拿一堆“过去的周末去没去”的记录，让机器自己把权重调对？
答：能。这就是“学习”。
### 2.3 学习：让机器自己调旋钮
把每个参数想象成调音台上的一个**旋钮**。“学习”就是从例子里把旋钮拧到合适的位置。先看一个只有两个旋钮的最小例子。
假设你开冰淇淋店，记录了 11 天的气温和销量。你想用一个神经元来预测：输入是气温，参数是一个权重 w 和一个偏置 b，输出是“销量 = w × 气温 + b”。这里不需要“门”，因为我们要的是一个数，而不是“是”或“否”。问题是：w 和 b 该是多少？
机器的办法分三步，一直循环：
1. **先猜。**随便设一组 w 和 b，用它把 11 天的销量都“预测”一遍。
2. **量误差。**把预测和真实销量比一比，差多少。把所有差距汇总成一个数（常用的是“差距的平方再求平均”），叫**损失**。损失越小，猜得越准。
3. **拧一点。**对每个旋钮问一句：“把你往上拧一丁点，损失会变大还是变小？变化有多快？”这个“方向加快慢”就叫**梯度**。然后每个旋钮都朝着让损失变小的方向拧一小步，回到第 1 步。
这个循环叫**梯度下降**。它没有任何“理解”的成分，只是在反复地“试一下、看误差、往好的方向挪一点”。可是重复足够多次之后，旋钮会停在一组让预测很准的位置上。
类比：
梯度下降像**在大雾里下山**。你看不见谷底在哪，但能感觉到脚下哪边是下坡、坡有多陡。于是你朝最陡的下坡方向迈一小步，再感觉一次，再迈一步。只要步子别太大（会冲过头）也别太小（会走到天黑），最后总能走到一个低处。“山的高度”就是损失，“你站的位置”就是旋钮的位置。
类比在这里失效：真实的“山”有几千亿个方向，不是三维的地形；而且走到的往往是一个“足够低”的地方，不一定是最低点。
> 【图示】梯度下降示意：横轴是一个参数 w，纵轴是损失（误差）。小球从左上方出发，每一步沿着坡度向下走一段，步子随坡度变缓而变小，最终停在谷底，此时 w 约为 2.07。
**图 2-2** 只看一个旋钮时的梯度下降。纵轴是损失，小球从一个随便猜的位置出发，每一步沿坡度往下挪；坡越陡步子越大，所以越靠近谷底走得越慢。
在这个两个旋钮的例子里，从“w = −0.5、b = 50”这个很差的起点出发，梯度下降大约走一百步，就会停在 w ≈ 2.07、b ≈ 6.2 附近（气温每高 1 度，大约多卖 2 份），平均平方误差从四百多降到 1.7 左右。大语言模型做的是同一件事，只是旋钮从 2 个变成了几千亿个。
### 2.4 一个神经元不够：为什么要“网络”
一个神经元会打分、会过门槛、还能自己学。那为什么不用一个就够了？看一个例子。
**停一下：你想让机器判断“今天的气温舒不舒服”：18 到 26 度之间舒服，太冷太热都不舒服。只用一个神经元（一个输入：气温），能做到吗？**
**参考答案：**
做不到。一个神经元的本事是“打分，再和一道门槛比”，所以它只能切一刀：要么“高于某个温度就舒服”，要么“低于某个温度就舒服”。可是“舒服”是中间的一段，两头都不舒服，需要切两刀。无论怎么调权重和偏置，一个神经元都圈不出中间那一段。
解决办法是**分工，再合并**：让第一个神经元只管“比 18 度暖吗”，第二个只管“比 26 度凉吗”，再让第三个神经元看前两个的结论，判断“两个都是吗”。三个各自只会切一刀的神经元，合起来就能圈出中间那一段。
> 【图示】一个神经元不够的例子：判断气温舒不舒服，18 到 26 度之间才舒服。一个神经元只能画一刀，比如“高于 18 度”，会把 35 度也判成舒服。用两个神经元，一个判断“比 18 度暖吗”，一个判断“比 26 度凉吗”，再用第三个神经元判断“两个都是吗”，就能圈出中间那一段。
**图 2-3** 一个神经元只能切一刀（左）；三个神经元分工合作，就能表达“中间那一段才对”（右）。第一排神经元的输出，成了下一个神经元的输入——这就是“网络”。
这个小例子里藏着神经网络的全部结构思想：
- **神经元的输出可以当作别的神经元的输入**，于是它们能连成一张网，这就是**神经网络**。
- 并排做同一级判断的一组神经元叫一**层**。直接接收原始数据的叫输入层，给出最终结论的叫输出层，中间的叫**隐藏层**（“隐藏”只是因为我们不直接看它们的输出）。
- 层数多的网络叫“深度”网络，**深度学习**的“深”就是这个意思。
判断越复杂，就需要越多的神经元和越多的层。比如认一张照片里有没有猫：第一层的神经元从像素里找出“这里有一条边”；后面的层把边组合成“圆形”“尖角”；再往后组合成“耳朵”“眼睛”；最后一层综合判断“是猫”。每一层只做简单的事，复杂的判断从层层组合里长出来。值得一提的是，这些中间特征并不是人规定的，而是训练时为了把最后的答案做对，被梯度下降自己调出来的。
> 【图示】一个小型神经网络：3 个输入，两层各 4 个神经元的隐藏层，2 个输出。每条连线是一个权重，每个神经元还有一个偏置，共 46 个参数。数据从左往右流动，每一层提取更抽象的特征。
**图 2-4** 一个只有 46 个参数的小网络：3 个输入，两个各有 4 个神经元的隐藏层，2 个输出。每条连线是一个权重，每个圆圈有一个偏置。前面的层学到简单的特征，后面的层把它们组合成更抽象的特征。
**停一下：每个神经元最后都要过一道“门”（激活函数）。如果把门全部拆掉，只做加权求和，叠 100 层会怎样？**
**参考答案：**
叠 100 层也等于 1 层。加权求和是“线性”运算，线性运算接线性运算，结果还是线性运算，就像连续打几次八折等于直接打一个折扣。图 2-3 里，第三个神经元之所以能表达“两个都是”，正是因为前两个神经元先各自过了门。激活函数引入了这种“弯折”（实际常用的门不是“是/否”两档，而是更平滑的版本，比如“小于 0 的一律变成 0”），层与层之间才不会坍缩成一层。有了它，足够大的网络在有界的范围内可以逼近几乎任何函数。
### 2.5 很多层怎么一起学：反向传播
回到“学习”。只有一个神经元时，“每个旋钮往哪边拧”很好算：拧一下，看损失怎么变。可是网络有很多层，最后一层的输出错了，前面每一层的每个旋钮各该负多少责任？比如图 2-3 把 30 度判成了“舒服”，是神经元 ② 的门槛设高了，还是神经元 ③ 的合并规则错了？
1986 年的**反向传播**算法解决的就是这个问题：从输出端的误差出发，**一层一层往回算**，把“责任”按各自对错误的贡献大小分摊给每个旋钮，每个旋钮就知道了自己的梯度。然后，所有旋钮一起按 2.3 节的办法拧一小步。
类比：
一家餐厅收到差评“菜太咸”。店长不会让所有人都罚一样的钱，而是往回追：上菜的没问题，炒菜的放多了酱油，配料的把盐和糖装反了。每个环节按自己对“咸”的贡献改进一点。反向传播就是这条追责链，只不过它用微积分的链式法则，把每一环的“贡献”算得很精确。
到这里，你已经爬完了前五级台阶：神经元是“打分加门槛”；参数是决定打分的数字；学习是用梯度下降调参数；网络是把神经元分工、组合、叠成层；反向传播让很多层能一起学。剩下的只是一个问题：**如果把这一切放大到极致，会怎样？**
### 2.6 大语言模型：一个巨大的神经网络
现在可以给大语言模型一个朴素的定义：**它是一个参数多到几十亿到几千亿的深度神经网络，被训练来预测下一个 Token**。2.2 节说过，“参数”就是所有权重和偏置；一个模型有多少参数，就是它有多少个旋钮。
参数越多，网络的“容量”越大，能记住和组合的规律就越细。图 2-4 的小网络有 46 个参数，Llama 3.1 405B 有 4050 亿个，多出约一百亿倍。
### 2.7 模型就是一个文件
听起来很玄的“大模型”，下载到硬盘上，就是几个文件。
> 【图示】一个模型文件的构成：一个很小的配置文件，描述网络怎么搭；一堆很大的权重文件，存放全部参数。以 Llama 3.1 405B 为例，配置只有几 KB，权重按 BF16 约 810 GB。
**图 2-5** 一个模型 = 一份“搭建说明”+ 一大堆数字。配置文件说明网络有几层、每层多宽；权重文件存放训练好的全部旋钮位置。
权重文件的大小，用一个乘法就能算出来：参数个数 × 每个参数占的字节数。训练时常用 16 位浮点数（BF16），每个参数 2 字节。所以一个 1200 亿参数的模型约 240 GB，一个 4050 亿参数的模型约 810 GB。
为了在显存更小的设备上运行，人们常把每个参数用更少的位数存，这叫**量化**。代价是精度会损失一点。
表 2-1 同一个模型，不同精度下的权重体积
| 精度 | 每参数字节 | 80 亿参数 | 1200 亿参数 | 4050 亿参数 |
| --- | --- | --- | --- | --- |
| FP32（32 位浮点） | 4 | 32 GB | 480 GB | 1,620 GB |
| BF16 / FP16（16 位） | 2 | 16 GB | 240 GB | 810 GB |
| FP8 / INT8（8 位） | 1 | 8 GB | 120 GB | 405 GB |
| INT4（4 位） | 0.5 | 4 GB | 60 GB | 约 203 GB |
只计权重本身；实际运行还需要额外显存存放中间结果（第 6 章的 KV Cache）。
类比：
量化像把一把**刻度精确到毫米的尺子**换成只刻到厘米的尺子。大多数量东西的场合，厘米尺子够用，而且轻便得多；只有在需要精细区分的地方，才会出错。
**停一下：模型文件里，有没有存着“巴黎是法国的首都”这句话？**
**参考答案：**
没有。文件里只有数字，没有任何一句话。“巴黎是法国首都”这个知识，分散地体现在亿万个旋钮的相互配合里：当前文是“法国的首都是”时，这些数字一起作用，让“巴黎”的概率最高。这也解释了为什么模型会“记错”：知识不是一条条存下来的，而是被压进了参数里，提取时可能变形。第 7 章会讲怎样弥补这一点。
学习，就是用误差去*调旋钮*；
模型，就是*调好的旋钮位置*。
##### 本章带走
神经元 = 打分（加权求和）+ 门槛（激活）；学习 = 用梯度下降调参数；网络 = 把只会切一刀的神经元分工、组合、叠成层；大语言模型 = 几千亿个参数组成的深度神经网络，存成一个文件。
- 一个神经元的判断力全装在参数（权重和偏置）里；换参数就换“性格”。
- 损失衡量“错了多少”，梯度告诉每个旋钮“往哪拧、拧多快”，反向传播把误差的责任一层层分下去。
- 一个神经元只能切一刀，圈不出“中间那一段”；多个神经元组成层、层叠成网络，复杂的判断从组合里长出来。
- 激活函数让层与层不会坍缩成一层，网络才有“深度”。
- 模型文件 = 配置 + 权重；体积 ≈ 参数数 × 每参数字节数，量化可以让它变小。
**于是，下一个问题**：神经网络只会对数字做加法和乘法。可是我们给它的是文字，“草莓”“strawberry”“你好”。文字是怎样变成它能算的数字的？
---
# 第 3 章 Token：模型眼中的世界
> 本章问题：文字是怎样变成模型能算的数字的？
> 来源：https://llm.weiborao.link/#ch3
**上一章留下的问题：**神经网络只会对数字做加法和乘法。可是我们给它的是文字，“草莓”“strawberry”“你好”。文字是怎样变成它能算的数字的？
这一章要走完文字进入模型的四站：**文本 → Token → 编号 → 向量**。走完之后，序章里的草莓之谜会自己揭开，你也会第一次看到“意思”在机器里长什么样。
> 【图示】文字进入模型的四站：原始文本“我爱吃草莓”；切成 Token：我、爱、吃、草莓；每个 Token 换成词表里的编号；每个编号再查表换成一个由几千个数字组成的向量。
**图 3-1** 文字进入模型的四站。前三站只是“换个写法”，信息没有增加；到了第四站，每个 Token 变成一个由几千个数字组成的向量，模型从这里开始“思考”。
### 3.1 切多碎才合适
第一步是把一段文字切成小块。小块叫 Token（中文常译“词元”）。问题是：切多碎？
问：最简单的办法，按单个字母或单个汉字切，行不行？
答：行，词表很小，什么字都能表示。但一句话会变得很长，而且单个字母几乎不带意思，模型要花大量力气才能把它们拼回有意义的单位。
问：那按整词切呢？“strawberry”就是一块。
答：每块都有意思了，可是英语有几十万个词，还有人名、新词、拼写错误、代码里的变量名。词表会大到装不下，遇到没见过的词就束手无策。
问：有没有中间路线？
答：有：常见的词整块保留，罕见的词拆成常见的小片段。这叫**子词**（subword）切分，今天几乎所有大模型都这么做。
表 3-1 三种切法的取舍
| 切法 | 词表大小 | 一句话的长度 | 遇到新词 |
| --- | --- | --- | --- |
| 按字符 | 很小（几百到几千） | 很长 | 不怕 |
| 按整词 | 极大（几十万以上） | 短 | 无法表示 |
| 按子词（今天的主流） | 5 万到 20 万 | 适中 | 拆成小片段，照样能表示 |
类比：
子词像**乐高**。常用的形状（“the”“模型”“ing”）直接做成整块，拿来就用；罕见的形状没有现成的整块，就用几块小积木拼出来。积木盒（词表）不必无限大，却什么都拼得出。
### 3.2 BPE：从字母开始，反复合并最常见的一对
词表里该放哪些片段？没有人一个个去挑，而是用一个简单的算法从语料里“统计”出来。最常用的叫 **BPE**（Byte Pair Encoding，字节对编码）。它的规则只有一句话：**数一数哪两个相邻的片段一起出现得最多，就把它们合并成一个新片段；重复，直到词表够大**。
> 【图示】BPE 分词算法的合并过程。语料里 low 出现 5 次，lower 2 次，newest 6 次，widest 3 次。从单个字母出发，每次把出现最多的相邻一对合并成一个新 Token：e 加 s，es 加 t，l 加 o，lo 加 w，n 加 e，ne 加 w。最后 low、est、new 都成了整块。
1. **起点：**每个词都拆成单个字母。
2. **e + s：**在 newest 和 widest 里共出现 9 次，最多，合并成 es。
3. **es + t：**同样 9 次，合并成 est。
4. **l + o：**在 low 和 lower 里共 7 次。
5. **lo + w：**low 成了一整块。
6. **n + e：**6 次。
7. **ne + w：**new 成了一整块。再合并一次，newest 也会成为整块。
**图 3-2** 在一个四个词的小语料上跑 BPE。品红色是本轮新合并出的片段。几轮之后，常见的 low、est、new 都成了整块，罕见的 widest 仍然由 w、i、d、est 拼成。网页版可以逐步播放。
真实的分词器在几 TB 的文本上跑这个过程，直到词表达到预定的大小。GPT-2 的词表有 50,257 个 Token；Llama 3 用了 12.8 万个；OpenAI 新一代分词器 o200k 有约 20 万个。词表越大，常见词越可能是一整块，一段话需要的 Token 越少。
BPE 不是唯一的造词表方法，但思路相通，都是“从小片段出发，按统计把常用组合并成整块”。2018 年的 BERT 用的是 **WordPiece**，词表 3 万；同年发表的 **SentencePiece** 工具可以直接在原始句子上训练，不需要先按空格把文本切成词，这对中文、日文这类词与词之间没有空格的语言格外方便。
OpenAI 给过一个经验值：**1 个 Token 约等于 3/4 个英文单词**，100 个 Token 约 75 个词。中文的比例取决于分词器：以英文为主的早期分词器常把一个不常见的汉字拆成好几个 Token（常用汉字在 UTF-8 编码里占 3 个字节，而 GPT 系列等采用的“字节级”BPE，最底层的单位就是字节）；新一代分词器收录了大量中文词，效率高得多。
### 3.3 草莓之谜揭晓
现在回到序章。当你输入 strawberry，模型收到的不是 s-t-r-a-w-b-e-r-r-y 十个字母，而是类似这样的几块：
你看到的strawberry
模型看到的（示意）straw berry
每一块对模型来说只是一个编号。编号里没有字母，就像“3 号楼”这个门牌号里看不出楼里住了几个姓王的人。要回答“有几个 r”，模型必须**间接地**知道 straw 里有一个 r、berry 里有两个 r。这种关于拼写的知识，它只能从训练文本里偶然出现的拼写讲解中零星地学到，很不牢靠。
**停一下：为什么“先把单词一个字母一个字母地写出来，再数”，就能数对？**
**参考答案：**
因为写出来之后，每个字母都变成了一个独立的 Token：str……这时“数 r”就变成了“数前文里有几个 r 这个 Token”，这正是模型擅长的事：它能直接“看到”前文的每一个 Token。换句话说，模型是用生成新 Token 的方式，把题目改写成了适合自己的形式。第 5 章讲推理模型时，你会发现“边写边想”是同一个道理。
同样的道理还能解释几种常见的“低级错误”：把一个单词倒过来写、比较 9.11 和 9.9 的大小、做多位数乘法。数字常被切成一到三位一块，模型看到的 9.11 和我们心里的小数并不是同一种东西。**这些错误不说明它笨，而说明它的“眼睛”和我们不同。**
### 3.4 从编号到向量：意思住在哪里
编号解决了“怎么表示”，没有解决“什么意思”。编号 40517 和 40518 在数值上挨着，意思可能毫不相干，就像学号相邻的两个同学不一定是朋友。
于是模型里有一张巨大的表，叫**嵌入表**（embedding table）：每个编号对应表里的一行，一行有几千个数字。查表得到的这一串数字，叫这个 Token 的**向量**（也叫嵌入，embedding）。这张表本身也是参数，和其他旋钮一起在训练中被调整。
训练结束后，奇妙的事情发生了：**意思相近的词，向量也相近**。没有人告诉模型“猫和狗都是动物”，但因为它们常出现在相似的上下文里（“我家的\_\_\_很可爱”），为了把下一个词猜准，模型自己把它们放在了向量空间里相邻的位置。
> 【图示】词向量空间示意（压缩到二维）：水果聚在一起，动物聚在一起，城市聚在一起。国王到王后的方向，与男人到女人的方向几乎平行，所以 国王 − 男人 + 女人 ≈ 王后。
**图 3-3** 压缩到二维的词向量示意。相似的词聚成团；更有意思的是方向：“男人→女人”和“国王→王后”几乎是同一个方向。这类例子因 2013 年的 word2vec 而广为人知：国王 − 男人 + 女人 ≈ 王后。
类比：
向量像**地图上的坐标**。北京和天津的坐标接近，因为它们地理上近；“猫”和“狗”的向量接近，因为它们在语言里“住得近”。不同的是，这张地图有几千个维度，每个方向编码着某种我们说不清的语义特征。
##### 词向量是
- 一个 Token 在“意思空间”里的坐标，由训练自动得到
- 可以计算的：相加、相减、比较远近
##### 词向量不是
- 字典里的定义，也不是人手工标注的特征
- 每一维都对应一个人能读懂的概念（多数维度没有简单的解释）
### 3.5 怎样量“意思有多近”
两个向量有多相似，最常用的量法是看它们的**夹角**：方向越一致，意思越近。夹角的余弦值叫**余弦相似度**，在 −1 到 1 之间。
> 【图示】用夹角衡量意思的远近：猫和狗的向量夹角小，余弦相似度约 0.8；猫和汽车的夹角接近直角，余弦相似度约 0.1。数值为示意。
**图 3-4** 余弦相似度只看方向、不看长短。真实计算是在几千维里做的，算法完全一样：对应位置相乘再相加，除以两个向量的长度。
记住这个工具。到了第 7 章，它会变成一种全新的“搜索”：不按关键字搜，而是按意思搜。把整段文档也变成向量存起来，用户提问时找夹角最小的那几段——这就是**向量数据库**和 RAG 的核心。
文字 → *Token* → 编号 → *向量*：
模型从最后一站开始思考。
##### 本章带走
模型眼中的世界是一串 Token，每个 Token 是一个编号，每个编号对应一个向量；意思就藏在向量的方向里。
- 子词切分在“词表大小”和“句子长度”之间取平衡；BPE 靠反复合并最常见的一对来造词表。
- 草莓之谜：模型看到的是 strawberry 两个编号，不是十个字母。
- 嵌入向量由训练自动得到，相近的意思方向相近，可以用余弦相似度来量。
**于是，下一个问题**：现在模型手里有了一串向量。它要怎样从这串向量里算出“下一个词”？而且，为什么只做“猜下一个词”这一件事，就能长出解奥数题的能力？
---
# 第 4 章 猜下一个词，为什么会长出智能
> 本章问题：为什么“预测下一个 Token”能产生智能？
> 来源：https://llm.weiborao.link/#ch4
**上一章留下的问题：**现在模型手里有了一串向量。它要怎样从这串向量里算出“下一个词”？而且，为什么只做“猜下一个词”这一件事，就能长出解奥数题的能力？
这是全书最核心的一章。我们先回答“为什么”，再回答“怎么算”。顺序不能反：如果不先明白“猜下一个词”为什么这么难，Transformer 的结构看起来就只是一堆方框。
### 4.1 玩一个游戏：猜下一个词
下面每一句话都缺了最后一个词。请你先猜，再想一想：**为了猜对，你用了哪一种知识？**
① 法国的首都是法国的首都是\_\_\_
② 他把杯子碰翻了，桌上全是他把杯子碰翻了，桌上全是\_\_\_
③ 2, 4, 8, 16, 32,2, 4, 8, 16, 32,\_\_\_
④ 一部 400 页的侦探小说，最后一句：“所以，凶手就是所以，凶手就是\_\_\_
**停一下：四道题各需要什么知识？哪一道最难？**
**参考答案：**
① 需要**事实知识**（巴黎）。② 需要**常识**：杯子里通常装着水，碰翻会洒出来。③ 需要发现**规律**，做一次乘法（64）。④ 最难：你得记住 400 页里每个人物的动机、时间线和不在场证明，排除错误线索，做一长串**推理**，才能写出那个名字。
四道题的形式完全一样，都是“猜下一个词”。可是要猜对，所需的能力从“记住一个事实”一直延伸到“完整地推理”。
这个游戏揭示了一件事：**“猜下一个词”不是一个简单的任务，而是一个可以无限变难的任务**。互联网上的文字里，有百科、对话、小说、论文、法庭记录、数学证明和程序代码。要在所有这些文字上都猜得准，模型就得掌握写下这些文字所需要的知识和推理。
表 4-1 同一个任务，不同的难度
| 要猜的位置 | 猜对需要什么 | 对应的能力 |
| --- | --- | --- |
| “……的首都是 \_\_\_” | 记住事实 | 知识 |
| “……碰翻了，桌上全是 \_\_\_” | 理解物理世界的常识 | 常识 |
| “……32, \_\_\_” | 识别模式并计算 | 归纳、算术 |
| 代码里 `return` 后面 | 理解程序要做什么 | 编程 |
| 证明的下一步 | 知道哪个引理能用 | 数学推理 |
| “凶手就是 \_\_\_” | 记住长文、排除干扰、多步推理 | 长程推理 |
### 4.2 预测就是压缩
还有一个更深的原因。看两个数字：Llama 3.1 405B 训练时读了 15.6 万亿个 Token，按每个 Token 约 4 个英文字符粗算，大约是 60 TB 的文本（估算）；而它的全部参数按 BF16 存下来只有 810 GB。**参数比数据小了七八十倍，根本装不下原文**。
问：如果装不下原文，模型怎样在这些文字上把下一个词猜准？
答：只能不去记每一句话，而是记“生成这些话的规律”：语法、事实之间的联系、推理的套路。
问：这和学生准备考试像不像？
答：像。题库有一万道题，脑子里装不下所有答案，就只能去理解公式和方法。理解了方法，没见过的题也会做。
问：所以，“猜下一个词”的压力加上“装不下”的限制，逼着模型做的事情是……
答：把世界的规律压缩进参数里。
这就是“预测即压缩”的意思：能把一段数据预测得越准，就越能用越少的信息把它描述出来；而最省信息的描述，就是找到产生这些数据的规律。
类比：
天文学家记录了几千年的行星位置。一种做法是把每天的坐标都抄进本子，本子越来越厚；另一种做法是找到牛顿定律，几行公式就能“预测”任何一天的位置。牛顿定律就是对那些观测数据最好的压缩。大语言模型的训练，是在人类文字上做同样的事，只是找到的“定律”以几千亿个数字的形式存在，我们读不懂它。
类比的边界：牛顿定律是精确的、可以写成公式的；模型学到的规律是近似的、统计的，所以会出错。
预测得*足够好*，
就必须理解得*足够深*。
### 4.3 它是怎么算的：Transformer
明白了“为什么要猜得准”，再看“怎么猜”。上一章结尾，每个 Token 都变成了一个向量。Transformer 要做的，是让这些向量一层一层地**互相交流、各自加工**，最后由最末尾那个位置的向量给出“下一个 Token 是谁”的概率。
#### 注意力：每个词回头看前文
“它”这个字本身没有意思，意思取决于它指代谁。为了理解一个词，模型需要回头看前文中与它相关的词。**注意力机制**做的就是这件事：每个位置都去问前文的每个位置“你跟我有多相关”，然后按相关程度把对方的信息加权混合进来。
> 【图示】注意力示意：处理到句末的“饿”时，模型回头看前文，最关注“小猫”，其次是“它”；把最后一个词换成“新鲜”，最关注的就变成了“鱼”。注意力只能看前文，不能看后文。权重为示意。
**图 4-1** 两句话只差最后一个词。处理到“饿”时，模型最关注“小猫”；处理到“新鲜”时，最关注“鱼”。于是“它”指的是谁，在这一层被确定下来。注意：模型只能回头看，不能偷看后文，因为它的任务就是预测后文。
类比：
注意力像**一场鸡尾酒会**。每个人（Token）胸前挂着一块名牌，写着“我是谁”（Key）；手里拿着一份想分享的信息（Value）；心里装着一个想找的人的特征（Query）。每个人扫一眼前面所有人的名牌，和自己要找的特征越匹配，就越认真听那个人说话，最后把听到的内容按认真程度混合起来，更新自己。
一层注意力里通常有几十到上百个“头”并行工作（Llama 3.1 405B 每层 128 个），每个头关注不同的关系：有的追踪指代，有的盯着语法搭配，有的看前后的数字。这叫**多头注意力**。
#### 前馈网络：每个词各自想一想
注意力负责“交流”，交流完之后，每个位置还要各自做一次加工，这一步由一个普通的神经网络完成，叫**前馈网络**。一些研究发现，模型的许多事实知识与这部分参数关系密切。
#### 叠很多层
“注意力 + 前馈网络”组成一个块，块叠很多层。Llama 3.1 405B 有 126 层。越往上，向量里装的信息越抽象：底层可能还在处理“这个词是什么”，高层已经在处理“这句话要说什么”“下一步推理该做什么”。
> 【图示】Transformer 解码器的结构：底部输入 Token 换成向量，加上位置信息；中间是许多个相同的块叠起来，每块包括注意力（Token 之间互相看）和前馈网络（每个 Token 各自加工）；顶部把最后一个位置的向量变成词表上每个词的概率，挑出下一个 Token。
**图 4-2** 今天主流大语言模型用的“只有解码器”（decoder-only）的 Transformer。整个结构从下往上读：Token 变向量，经过 N 层“交流 + 加工”，最后一个位置的向量被翻译成词表上每个词的概率。
Transformer 胜出的一个关键原因是工程上的：训练时，一段文字里所有位置的“猜下一个词”可以**同时计算**，非常适合 GPU 的并行能力（第 9 章）。它之前流行的循环神经网络必须一个词一个词地顺序处理，很难做大。
##### 注意力是
- 一种按“相关程度”加权混合信息的计算
- 每层、每个头各自学出来的，不是人设计的规则
##### 注意力不是
- 人类意义上的“专注”或“意识”
- 可以直接读懂的解释：权重高不一定意味着“模型因此做出了判断”
### 4.4 做大，有规律可循：缩放定律
2020 年 1 月，OpenAI 的 Kaplan 等人发表了一篇论文，结论是：模型的测试损失随模型大小、数据量和计算量呈**幂律**下降。翻译成白话就是：在双对数坐标上，“投入”和“效果”是一条直线。
> 【图示】缩放定律示意（双对数坐标）：横轴是训练算力，纵轴是测试损失。几条不同大小模型的学习曲线下沿连成一条直线：算力每增加 10 倍，损失按固定比例下降。
**图 4-3** 缩放定律的形状。每条蓝线是一个固定大小的模型，训练越久损失越低，但最终会饱和；所有曲线的下沿连成一条直线。这条直线让“花多少算力、能得到多好的模型”变得可以预测。
可预测，意味着可以投资。一家公司可以先用小模型做实验，画出这条线，再决定要不要花上亿美元训练一个大的。2022 年 3 月，DeepMind 的 Chinchilla 论文进一步指出，很多模型参数太多、数据太少：同样的算力，700 亿参数配 1.4 万亿 Token，胜过参数更多、数据更少的模型。按这组数字算，大约每个参数配 20 个 Token（本书推算）。
规模涨上去，还会出现一些小模型完全没有、大模型突然具备的能力，比如多位数加法、按步骤推理。2022 年 Wei 等人称之为**涌现能力**。不过 2023 年 Schaeffer 等人指出，有些“突然出现”是评价方式造成的：如果用“完全答对才得分”的指标，平滑的进步看起来就像一个台阶；换成更细的指标，曲线往往是连续的。
**怎样理解“涌现”** 稳妥的说法是：能力随规模持续增长，在某些任务的“及格线”附近，看起来像是突然出现。它不神秘，但也确实难以提前预料具体哪种能力会在哪个规模越过及格线。
### 4.5 回答核心问题：算力 + 数据 + 算法，为什么会输出智能
现在可以把读者最初的问题拆开回答了。先给“智能”一个可操作的定义：**在没见过的情况下，做出好的预测与决策的能力**。按这个定义，三样原料各自的角色是：
1. **数据是世界的投影。**人类写下的文字里，沉淀着事实、常识、推理过程和解决问题的方法。它是“规律”的原矿。
2. **算法是可塑的模具和打磨的方法。**Transformer 提供了一个足够大、足够灵活、能高效并行的函数家族；梯度下降提供了沿着误差一步步改进的办法；“预测下一个 Token”提供了一个不需要人工标注、可以无限扩展的目标。
3. **算力是打磨的次数。**每一次梯度下降都要做海量的乘法和加法。缩放定律说，打磨得越多，损失越低，而且有规律。
三者结合，训练过程把海量文字里的规律压缩进参数；推理时，参数再把这些规律展开成一个个 Token。
> 【图示】从原料到智能：数据、算力、算法三样输入，经过训练被压缩进模型参数；推理时，参数加上电力和你的提问，一个个生成 Token。
**图 4-4** 从原料到智能。训练是一次性的“压缩”，产物是一个参数文件；推理是每次提问时的“展开”，产物是 Token。第 12 到 14 章会看到，AI 工厂就是专门为这两个环节建造的工厂。
类比：
这像**炼油**：原油（数据）蕴含着能量，但不能直接加进汽车；炼油厂（算法）用一套工艺，消耗大量能源（算力），把原油提炼成汽油（参数）；汽油再在发动机里燃烧（推理），变成车轮的转动（Token）。
##### 这个解释说明了
- 为什么规模越大，能力越强，而且在一定范围内可预测
- 为什么模型能处理训练时没见过的问题
##### 这个解释没有说
- 模型学到的规律都是对的（统计规律会出错，第 7 章）
- 模型有意识、有目的或“真正理解”（这是哲学问题，本书不下结论）
- 规模可以无限换来能力（数据会用完，成本会封顶）
回到序章的反差。**奥数金牌**来自“猜下一步证明”的能力：互联网和教材里有大量数学推理的文字，模型从中压缩出了推理的套路，第 5 章还会讲推理训练怎样放大它。**草莓的 r** 则来自第 3 章的分词：字母信息在进入模型之前就被打包了，再强的推理能力也看不见包里的东西。两件事不矛盾，它们来自同一套机制的两个侧面。
##### 本章带走
预测得足够好，就必须理解得足够深。“猜下一个词”是一个可以无限变难的任务，参数又装不下原文，于是模型只能把规律压缩进参数。
- Transformer = 注意力（Token 之间回头看、交流）+ 前馈网络（各自加工）叠很多层；最后一个位置给出下一个 Token 的概率。
- 缩放定律：投入与效果在双对数坐标上是直线，让“做大”可以预测、可以投资。
- 数据是原矿，算法是模具与工艺，算力是打磨次数；训练压缩，推理展开。
**于是，下一个问题**：按这种方式训练出来的模型，只会接着前文往下写。你问它一个问题，它可能接着写出五个类似的问题。它是怎样变成一个会听话、会推理的助手的？
---
# 第 5 章 从会续写到会听话：训练的五个阶段
> 本章问题：基座模型怎样变成助手？推理模型又多了什么？
> 来源：https://llm.weiborao.link/#ch5
**上一章留下的问题：**按这种方式训练出来的模型，只会接着前文往下写。你问它一个问题，它可能接着写出五个类似的问题。它是怎样变成一个会听话、会推理的助手的？
第 4 章讲的“在海量文字上猜下一个词”，只是训练的第一大步。它造出来的模型叫**基座模型**：知识渊博，但还不会当助手。本章把一个基座模型变成 ChatGPT 这样的助手、再变成会“先想再答”的推理模型，一共要走五个阶段。
### 5.1 基座模型的“毛病”
基座模型只学过一件事：**像互联网那样续写**。于是它的行为也像互联网：
你输入怎样学好英语？
基座模型可能的续写（示意）怎样学好数学？怎样学好物理？……
在它读过的网页里，一个问句后面常常跟着另一个问句（比如论坛的帖子列表）。它没有错，它只是在做被训练去做的事。它还会模仿网上的偏见与恶意，会一本正经地编造，也不知道什么时候该拒绝。
问：基座模型已经“读遍图书馆”，知识都在。它缺的是什么？
答：缺“怎样当一个助手”的规矩：别人问问题时要回答，而不是出新题；回答要有用、要诚实，不能帮人干坏事。
问：这些规矩需要很多数据吗？
答：比起预训练少得多。能力已经在了，要教的是“格式”和“偏好”。
### 5.2 五个阶段
> 【图示】大语言模型训练的生命周期：一，数据准备：收集、去重、过滤、脱敏；二，预训练：在数万亿 Token 上猜下一个词，得到基座模型；三，监督微调：学人写的指令与回答示范；四，偏好对齐：用人的偏好打分来调整；五，推理强化学习：在有标准答案的题目上练习，学会先想再答。
**图 5-1** 一个大语言模型的训练生命周期。预训练用掉绝大部分算力，得到“知识”；后面三个阶段规模小得多，得到“好用”。右列是贯穿本节的类比。
类比：
把模型想成一个**医学生**。预训练是在图书馆里读完所有医学书和病历，知道得很多，但没见过病人；监督微调是跟着老医生学问诊，看老师怎样一句句回答病人；偏好对齐是听病人和导师的评价，知道哪种说法让人满意、哪种会伤人；推理强化学习是刷大量有标准答案的病例考题，学会先想清楚再下诊断。
#### ① 数据准备
从网页、书籍、百科、论文、代码中收集文本，再做大量清洗：去掉重复内容、过滤低质和有害内容、删除个人隐私信息。数据的质量往往比数量更重要，这一步是各家公司最不愿公开的“配方”之一。
#### ② 预训练：得到知识
也就是第 4 章讲的过程：在数万亿 Token 上猜下一个词。Llama 3.1 405B 用了 15.6 万亿 Token。这一步耗时几个月、用掉上万块 GPU，第 9 章会算一算它到底有多贵。产物是基座模型。
#### ③ 监督微调：学会格式
由人写出成千上万组“指令 → 好回答”的示范，比如“把这段话翻译成英文 → 译文”“解释量子纠缠 → 一段清楚的解释”，让模型在这些示范上继续做“猜下一个词”的训练。训练目标没有变，变的是数据：它现在模仿的是一个好助手，而不是整个互联网。这一步也叫**指令微调**。
#### ④ 偏好对齐：学会“什么是好”
示范总是有限的，而且很多时候“好”难以写出来，却容易比较出来：同一个问题的两个回答，人往往一眼就能看出哪个更好。**基于人类反馈的强化学习**（RLHF）利用的就是这一点。
> 【图示】基于人类反馈的强化学习：模型对同一个问题生成两个回答；标注员判断哪个更好；用大量这样的比较训练一个奖励模型；再让语言模型朝奖励更高的方向调整，循环往复。
**图 5-2** RLHF 的循环。人只需要做“比较”，奖励模型把成千上万次比较学成一个自动打分器，再用它去大规模地调整语言模型。
对齐的目标常被概括成三个词：**有用、诚实、无害**。2022 年 3 月的 InstructGPT 论文给出了一个出人意料的对比：经过这套训练的 13 亿参数模型，回答比 1750 亿参数的原版 GPT-3 更受人偏好。后来也出现了不需要单独训练奖励模型的简化方法（如 DPO），但思想相同：用人的偏好来塑造模型的行为。
**停一下：小了一百多倍的模型，为什么回答反而更受欢迎？**
**参考答案：**
因为对一般问题来说，GPT-3 缺的不是知识，而是“好好回答”的习惯。它可能答非所问、续写出无关内容。InstructGPT 的能力未必更强，但它把能力用在了你要的地方。对齐不是往模型里加知识，而是**把已有的能力对准人的意图**。
#### ⑤ 推理强化学习：学会先想再答
人的偏好打分有两个局限：贵，而且在难题上不可靠。一道竞赛数学题，标注员自己可能都看不出哪个证明是对的。但有一类问题天然自带“判卷老师”：数学题有标准答案，代码可以运行测试。在这类问题上，模型可以自己做题、自动判分、大量练习。
2024 年 9 月，OpenAI 发布 o1，称它会在回答前“花更多时间思考”。2025 年 1 月，DeepSeek 的 R1 论文公开了类似的做法，并指出：**推理能力可以单靠强化学习激发出来，不需要人工写好的推理过程**。论文还记录了一个作者称为“顿悟时刻”（aha moment）的现象：只用强化学习训练的 R1-Zero，在一个中间版本里学会了“重新思考”，回头重新审视自己前面的解法。
### 5.3 推理模型多了什么：一张草稿纸
推理模型的结构和普通模型一样，仍然是 Transformer，仍然在猜下一个 Token。区别在于，它在给出答案之前，**先生成一大段“思考”Token**：拆解问题、列出步骤、尝试、发现错误、回头修正。
> 【图示】推理模型的回答方式：先生成一段思考 Token（草稿），在里面拆解问题、尝试、检查、纠错，然后才给出最终答案。思考越长，消耗的 Token 越多，复杂问题的正确率通常越高。
**图 5-3** 推理模型先写草稿再作答。还记得第 3 章的草莓吗？把单词逐个字母写出来，每个字母就成了一个独立的 Token，“数 r”就变成了模型擅长的事。思考 Token 是同一个道理的推广。
问：多写几个字，为什么能变聪明？
答：你心算 37 × 48 很难，在纸上列竖式就容易。不是你变聪明了，而是草稿纸把一个大问题拆成了很多个小问题，每一步只需要做一件简单的事。
问：模型的“草稿纸”在哪里？
答：就是它自己生成的 Token。模型每生成一个 Token，都要完整地算一遍整个网络。写得越多，等于算得越多；写下来的中间结果，又成了下一步可以“回头看”的前文。
这带来了一个新的“缩放”方向：除了训练时投入更多算力，**回答时投入更多算力**（让它想得更久）也能换来更好的结果。这叫**测试时计算**。代价是 Token：一个难题的“思考”可能要消耗成千上万个 Token。这个事实对后面几章很关键，因为每一个 Token 都要在 GPU 上算出来。
一切都是 Token：
输入是 *Token*，思考是 *Token*，行动也是 Token。
“行动也是 Token”这一句，要到第 8 章讲 Agent 时才会兑现。
表 5-1 五个阶段对照
| 阶段 | 数据 | 学到什么 | 规模 |
| --- | --- | --- | --- |
| 数据准备 | 原始网页、书、代码 | （为后续准备原料） | 数十 TB 级文本 |
| 预训练 | 清洗后的海量文本 | 语言、知识、推理的规律 | 数万亿 Token，占算力的绝大部分 |
| 监督微调 | 人写的指令与回答示范 | 助手的格式与语气 | 小几个数量级 |
| 偏好对齐 | 人对回答的比较 | 什么样的回答更好、该拒绝什么 | 小几个数量级 |
| 推理强化学习 | 可自动判分的题目 | 先想再答、检查与纠错 | 增长很快，具体比例各家未公开 |
##### 对齐与推理训练能
- 让模型听懂指令、按人的偏好回答
- 让模型学会拆解问题、检查自己的步骤
##### 它们不能
- 保证模型说的都是真的（它仍然可能自信地编造）
- 凭空加入预训练里没有的知识，也不能更新知识的截止日期
##### 本章带走
预训练给模型知识，微调和对齐教它当助手，推理强化学习教它先想再答；每一步的训练目标，归根到底仍是“猜下一个 Token”。
- 基座模型像互联网一样续写；监督微调让它模仿好助手；RLHF 用人的比较来定义“好”。
- InstructGPT：13 亿参数对齐后的模型，比 1750 亿参数的 GPT-3 更受偏好。
- 推理模型用思考 Token 当草稿纸；回答时多花算力，也能换来更好的结果。
**于是，下一个问题**：训练好的模型是一个文件。当你在聊天框里按下回车，这个文件是怎样一个字一个字地把答案“吐”出来的？
---
# 第 6 章 按下回车之后：一次推理的旅程
> 本章问题：一次回答在机器里经历了什么？为什么是逐字蹦出来的？
> 来源：https://llm.weiborao.link/#ch6
**上一章留下的问题：**训练好的模型是一个文件。当你在聊天框里按下回车，这个文件是怎样一个字一个字地把答案“吐”出来的？
用训练好的模型回答问题，叫**推理**（inference）。注意这里的“推理”是工程术语，指“运行模型”，和第 5 章“推理模型”里那个“逻辑推理”的意思不同。本章跟着一个问题走完它在模型里的全过程，然后回答：为什么回答是一个字一个字蹦出来的。
### 6.1 一个问题的六站旅程
> 【图示】一次推理的旅程：一，分词，把问题切成 Token；二，预填充，一次性并行读完整个问题，同时生成 KV 缓存；三，计算下一个 Token 的概率；四，按温度采样选出一个 Token；五，把它发给用户，同时接回输入末尾，回到第三步；六，遇到结束符，停止。
1. **分词：**你的问题被切成 Token，换成编号（第 3 章）。
2. **预填充：**所有输入 Token 一起过一遍网络，顺便把每个 Token 的“名牌”记进 KV 缓存。
3. **算概率：**只用最新一个位置，回头查 KV 缓存，算出词表里每个词作为下一个 Token 的概率。
4. **采样：**按概率抽出一个 Token。
5. **发出并接回：**把它发给你，同时接到输入末尾，回到第 3 步。
6. **停止：**抽到“结束符”时，循环结束。
**图 6-1** 推理的六站。第 3、4、5 站组成一个循环，每转一圈产生一个 Token，这个循环叫**解码**。网页版可以逐站播放。
问：为什么不能一次把整个回答算出来？
答：因为第二个词取决于第一个词是什么。模型在第 4 章学会的就是“根据前文猜下一个”，前文没定，下一个就没法猜。
问：那你的问题呢？它有 12 个 Token，也要一个一个读吗？
答：不用。问题是已知的，12 个位置可以同时算，这就是预填充。只有“还没写出来的回答”必须一个一个来。
这个模式有个名字，叫**自回归**：模型的每一个输出，都会变成它下一步的输入。你在聊天窗口看到的“打字机效果”，就是这个循环的真实节奏：每转一圈，屏幕上多一个 Token。
### 6.2 两个阶段，两种瓶颈
> 【图示】一次回答的时间线：先是一段预填充，结束时出现第一个 Token，这段时间叫首 Token 延迟；之后每隔一小段时间吐出一个 Token，这个间隔叫 Token 间延迟。问题越长，预填充越久；回答越长，解码越久。
**图 6-2** 一次回答的时间线。从按下回车到看见第一个字的时间叫 TTFT（首 Token 延迟），之后相邻两个字的间隔叫 ITL（Token 间延迟）。
两个阶段累的地方不一样：
**预填充是“算力密集”的。**几千个输入 Token 同时参与大块的矩阵乘法，GPU 的计算单元被填满，瓶颈在“算得多快”。
**解码是“显存带宽密集”的。**每生成一个 Token，GPU 都要把全部权重从显存里读一遍，但只为一个位置做计算。算一次很快，读一遍却慢。粗算一下：405B 模型按 FP8 分到 8 块 H100 上，每块约 50 GB；H100 的显存带宽是 3.35 TB/s，读一遍要约 15 毫秒。所以只服务一个人时，每秒最多大约 60 多个 Token（估算，未计其他开销）。
类比：
解码像**公交车**：不管车上坐了 1 个人还是 50 个人，跑一趟的时间（把权重读一遍）差不多。所以推理服务会把很多用户的请求拼成一批，一趟拉走，这叫**批处理**。每个人等的时间稍长一点，整体的吞吐量却成倍上升。如何在“每个人等得短”和“一趟拉得多”之间取舍，是推理系统的核心难题。
表 6-1 衡量推理服务的四个指标
| 指标 | 含义 | 用户的感受 |
| --- | --- | --- |
| TTFT 首 Token 延迟 | 按下回车到第一个 Token 出现 | “它反应快不快” |
| ITL Token 间延迟 | 相邻两个 Token 的间隔 | “字蹦得顺不顺” |
| 吞吐量 | 整个系统每秒生成的 Token 总数 | （运营方关心）同样的机器能服务多少人 |
| 并发数 | 同时在服务的请求数 | 高峰期会不会排队 |
### 6.3 KV 缓存：不必每次重读全文
第 4 章说过，注意力要让每个位置“回头看”前文所有位置的名牌（Key）和内容（Value）。如果每生成一个新 Token，都要把前文所有 Token 的名牌重新算一遍，那么回答越长，每一步越慢。
解决办法很朴素：**算过的就存起来**。前文每个 Token 在每一层的 Key 和 Value 算一次后就留在显存里，这叫 **KV 缓存**。新 Token 只需要算自己的那一份，再和缓存比对。
类比：
KV 缓存像**读书时贴的便利贴**。读到第 300 页时要回想某个人物，你不会从第 1 页重读，而是翻看之前贴的便利贴。代价是便利贴会越贴越多，书越来越厚。
这些“便利贴”有多厚？以 Llama 3.1 405B 为例，用 BF16 存储时，每个 Token 的 KV 缓存约 516 KB。一个 12.8 万 Token 的长对话，光 KV 缓存就要约 68 GB，快赶上一整块 H100 的显存了。
> 【图示】显存账本示意：一台 8 卡 H100 服务器共 640 GB 显存。Llama 3.1 405B 按 FP8 存权重占 405 GB，剩下约 235 GB。一个 12.8 万 Token 长对话的 KV 缓存按 BF16 约 68 GB，只够同时放下三个这样的对话。
**图 6-3** 一台 8 卡服务器的显存账本（粗算）。权重占掉大半之后，剩下的空间只够放三个超长对话的 KV 缓存。长上下文推理的瓶颈，往往是显存而不是算力。
**停一下：为什么很多聊天产品对“上下文长度”收费更高，或者对很长的对话做截断与压缩？**
**参考答案：**
因为上下文越长，两件事越贵：预填充要算的量变大（TTFT 变长），KV 缓存占的显存变多（同一台机器能同时服务的人变少）。图 6-3 里，一个超长对话就占了一块 GPU 的大部分显存。这也是第 11 到 14 章里推理集群要精心设计显存、网络和存储的原因之一。
### 6.4 采样：同一个问题，为什么答案每次不同
第 3 站算出来的是一个概率分布，不是一个确定的词。第 4 站要从中抽一个。抽法由一个叫**温度**的参数控制：温度低，几乎总是选概率最高的词，回答稳定但刻板；温度高，冷门的词也有机会被选中，回答更多样，也更容易跑偏。
表 6-2 “今天天气真\_\_\_”：同一个分布，不同温度下的抽中概率
| 候选词 | 温度 0.2 | 温度 0.5 | 温度 1.0（原分布） | 温度 1.5 |
| --- | --- | --- | --- | --- |
| 好 | 98.3% | 77.5% | 50.0% | 38.0% |
| 不错 | 1.6% | 15.0% | 22.0% | 22.0% |
| 晴朗 | 0.1% | 4.5% | 12.0% | 14.7% |
| 冷 | ≈0 | 2.0% | 8.0% | 11.2% |
| 热 | ≈0 | 0.8% | 5.0% | 8.2% |
| 糟糕 | ≈0 | 0.3% | 3.0% | 5.8% |
原分布为示意；温度的算法是把每个概率开 1/T 次方后重新归一化。
网页版封面上的那台终端也有一个温度旋钮：把它调到 1.5 以上再重新生成，常常会在某一步抽中一个冷门的词，回答从那里走上另一条路。同一个机制，既是模型“有创造力”的来源，也是它“会跑偏”的来源。
##### 逐字输出是
- 自回归解码的真实节奏：生成一个，发出一个
- “流式”传输：不必等全部写完再显示
##### 逐字输出不是
- 为了显得像人在打字而加的动画
- 模型早已想好全文、再慢慢“念”出来：后面的字此刻还不存在
到这里，我们只看了“模型”这一层。真实的服务里，你的请求还要经过负载均衡、调度系统、多块 GPU 之间的通信，才能变成屏幕上的字。第 10 章会把这条流水线从头到尾再走一遍，那时你会认识 Kubernetes、CUDA 和 NCCL。
##### 本章带走
推理 = 一次并行的预填充 + 一个“生成一个、接回一个”的解码循环。打字机效果就是这个循环的真实节奏。
- 预填充算力密集，决定首 Token 延迟；解码显存带宽密集，决定字蹦得多快。批处理像公交车，一趟拉多人。
- KV 缓存避免重复计算，但会吃掉大量显存：405B 模型一个 12.8 万 Token 的对话约 68 GB。
- 温度控制采样：低温稳定，高温多样也更易跑偏。
**于是，下一个问题**：模型每一步都在挑“最像答案”的词。当它其实不知道答案时，它也会挑一个看起来最像答案的词。怎样让它少说错话、说真话？又怎样判断一个模型到底好不好？
---
# 第 7 章 一本正经地胡说：幻觉、RAG 与怎样考 AI
> 本章问题：怎样让模型少说错话？怎样评价 LLM 和 RAG？
> 来源：https://llm.weiborao.link/#ch7
**上一章留下的问题：**模型每一步都在挑“最像答案”的词。当它其实不知道答案时，它也会挑一个看起来最像答案的词。怎样让它少说错话、说真话？又怎样判断一个模型到底好不好？
这一章分两半。前一半解决“说真话”：先弄清幻觉从哪里来，再看一种让模型“开卷考试”的方法——检索增强生成（RAG），以及支撑它的向量数据库。后一半解决“怎么考”：怎样评价一个 RAG 系统，怎样评价一个大模型。
### 7.1 幻觉从哪里来
你问一个模型：“请列出 2019 年某某教授关于量子计算的三篇论文。”它可能给出三个格式完美、标题像模像样、期刊名真实存在的引用——而这三篇论文根本不存在。这种现象叫**幻觉**（hallucination）。
问：它为什么不直接说“我不知道”？
答：回想第 6 章：每一步它都在从概率分布里挑一个 Token。“论文标题”后面最像样的续写，是另一个像论文标题的东西，而不是“我不知道”。
问：可它读过那么多论文，怎么会记错？
答：回想第 2 章：知识不是一条条存下来的，而是被压缩进了参数。提取时，常见的知识清晰，罕见的知识模糊；模糊的地方，它会用“看起来合理”的内容补上。
问：还有别的原因吗？
答：有两个：训练数据有截止日期，之后发生的事它不知道；你公司内部的文档，它从没见过。
##### 幻觉是
- 流畅、自信、格式正确，但内容不实的输出
- “生成最像样的续写”这一机制的副作用
##### 幻觉不是
- 故意撒谎：模型没有骗你的意图
- 可以靠“调大模型”彻底消除的偶发错误：更大的模型错得更少，但不会归零
### 7.2 开卷考试：RAG
既然模型的记忆会模糊、会过期、会缺失，最直接的办法是：**答题前先把相关资料找出来，放到它眼前**。第 4 章讲过，模型非常擅长“读前文”；资料就在前文里，它就不必凭记忆去猜。
类比：
没有 RAG 的模型像**闭卷考试**的学生，只能凭记忆答，记不清时会硬着头皮编。RAG 让它变成**开卷考试**：先翻书找到相关的几页，再根据书上的内容作答，并注明“见第 37 页”。开卷不保证满分——如果翻错了页，或者书上本来就写错了，答案照样会错。
这个方法叫**检索增强生成**（Retrieval-Augmented Generation，RAG），这个名字来自 2020 年 Facebook AI 的 Lewis 等人的论文。今天它是企业落地大模型最常用的方案：模型本身不用重新训练，只要接上公司的知识库。
> 【图示】RAG 的工作流程。离线索引：文档切成小块，每块用嵌入模型变成向量，存进向量数据库。在线回答：用户的问题也变成向量，在数据库里找最相近的几块，必要时重排，再把问题和这几块资料拼成提示词交给大模型，生成带出处的回答。
1. **切块：**把文档切成几百字一块（模型一次能读的长度有限，而且小块更容易精确命中）。
2. **嵌入：**用嵌入模型把每一块变成一个向量（第 3 章）。
3. **入库：**向量和原文一起存进向量数据库。以上三步提前做好。
4. **问题变向量：**用户提问时，用同一个嵌入模型把问题也变成向量。
5. **检索：**在库里找夹角最小的 K 块。“怎么请年假”能找到“带薪休假申请流程”，尽管两者没有一个共同的词。
6. **拼提示词：**把找到的资料和问题拼在一起，并要求“只根据资料回答、注明出处”。
7. **生成：**大模型读资料、写回答。
**图 7-1** RAG 的两段流程：上面一行离线建索引，下面两行在线回答。整个过程里，大模型的参数一个都没有改。网页版可以逐步播放。
#### 向量数据库：按意思搜索
传统数据库擅长**精确匹配**：找出“部门 = 销售”的所有记录。搜索引擎擅长**关键字匹配**：找出包含“年假”二字的网页。**向量数据库**擅长的是第三种：按**意思**找。它存的是向量，查询时计算夹角，返回意思最接近的内容。
库里可能有上亿个向量，逐个比较太慢。向量数据库的核心技术是“近似最近邻”索引：事先把向量按相似程度组织好，查询时只看最有希望的那一小片区域，用一点点精度换来成百上千倍的速度。
**停一下：既然向量搜索这么聪明，为什么很多 RAG 系统还要同时保留关键字搜索？**
**参考答案：**
因为“意思相近”有时恰恰不是你要的。搜产品型号“C9300-48P”、搜人名、搜错误代码“0x80070005”时，你要的是一字不差的匹配，而向量搜索可能返回“意思差不多”的另一个型号。实践中常把两种搜索结合起来（混合检索），再用一个专门的“重排”模型把候选结果精排一遍。
### 7.3 从朴素 RAG 到 Agentic RAG
图 7-1 是最朴素的版本。它只适合“一问一查一答”的简单问题，常见的失败有：问题问得含糊，检索不到；检索到的块太碎，缺了上下文；答案要跨好几份文档拼起来，一次检索拿不全；找来的资料互相矛盾。于是 RAG 沿着“让检索更聪明、再让模型自己来检索”的方向演进了三代：
表 7-1 RAG 的三代
| | 朴素 RAG | 进阶 RAG | Agentic RAG |
| --- | --- | --- | --- |
| 流程 | 切块 → 嵌入 → 检索前 K 块 → 拼进提示词 → 生成 | 检索前改写问题；检索时混合关键字与向量；检索后用重排模型精选 | 模型自己拆解问题、决定查什么、去哪查、查几轮，查完自评“够不够”，不够再查 |
| 检索的“主人” | 固定流水线 | 更精细的固定流水线 | 模型本身（第 8 章的 Agent 循环） |
| 擅长 | 单跳事实问答 | 措辞含糊、需要精确匹配（型号、错误码）的问题 | 多跳、跨文档、需要综合研究的问题 |
| 代价 | 最便宜、最快 | 多一两次模型调用 | 多轮检索与推理，Token 消耗和延迟成倍增加 |
**Agentic RAG** 的关键变化是：检索不再是答题前的一个固定步骤，而是模型手里的一件**工具**。它可以用第 8 章的“思考 → 行动 → 观察”循环，先把大问题拆成几个子问题，分别去向量库、网页搜索、数据库甚至计算器里查，看到结果后判断信息是否完整，不完整就换个问法再查，最后综合作答。为了让 Agent 记住跨会话的上下文（比如“这个用户上周问过什么、偏好什么”），一些系统还会加一层专门的**记忆**，开源项目 Mem0 就是一个例子，它把自己定位为给 AI 助手和 Agent 用的“智能记忆层”。
类比：
朴素 RAG 像一位**只会按目录翻书**的助理：你问什么，他就去查对应的那几页念给你听。Agentic RAG 像一位**研究员**：他会先想清楚要回答这个问题需要哪些材料，分头去图书馆、网上和档案室查，发现缺一块就再去补，最后交给你一份带引用的报告。研究员更强，也更贵、更慢。
#### 一个产品化的例子：NotebookLM
Google 的 NotebookLM 是一个以“只根据你给的资料回答”为设计原则的产品：用户上传文档、网页、幻灯片等资料，它基于这些资料回答并给出出处。它也展示了 RAG 之上可以长出什么：2024 年 9 月加入的“音频概览”（Audio Overview），能一键把资料变成两位主持人之间的对话；2025 年 7 月加入的“视频概览”（Video Overviews），被 Google 形容为“带讲解的幻灯片”。底层的道理不变：先把可信的资料放到模型眼前，再让模型在资料范围内生成内容。
### 7.4 怎样评价一个 RAG 系统
RAG 的回答错了，可能是“没找对资料”，也可能是“找对了但没读对”。所以不能只看最终答案，要把检索和生成拆开来看。2023 年的 RAGAS 框架提出了三个核心分数，正好对应问题、资料、回答三者之间的三条边：
> 【图示】RAG 评价的三角：问题、检索到的资料、回答三者两两之间各有一个分数。问题与资料之间是上下文相关性，资料与回答之间是忠实度，问题与回答之间是回答相关性。
**图 7-2** RAG 评价三角。上下文相关性考检索；忠实度考生成是否“只说资料里有的”，是衡量幻觉最重要的一条；回答相关性考是否答在点子上。
后来的 RAGAS 工具把指标拆得更细，例如把“检索得好不好”分成两半：**上下文精确率**（找来的资料里有多少是真有用的，衡量噪声）和**上下文召回率**（回答需要的信息有多少被找回来了，衡量遗漏）；再加上忠实度、回答相关性和“噪声敏感度”等。
同年的 RGB 基准从另一个角度，测试 RAG 中的大模型在“资料不理想”时能否扛住压力：
表 7-2 RAG 的四项抗压能力（RGB 基准）
| 能力 | 考验的情形 | 好的表现 |
| --- | --- | --- |
| 噪声鲁棒性 | 找来的资料里混着相关但没用的内容 | 不被干扰，抓住真正有用的那句 |
| 拒答能力 | 找来的资料根本回答不了这个问题 | 承认“资料中没有答案”，而不是编一个 |
| 信息整合 | 答案分散在好几份资料里 | 把几处信息合起来回答 |
| 反事实鲁棒性 | 资料里有明显错误的信息 | 识别出矛盾，不盲从 |
#### 两份让人清醒的数据
RAG 并不是“接上知识库就万事大吉”。Meta 等机构 2024 年发布的 **CRAG** 基准包含 4,409 个问答对，覆盖五个领域，问题从热门到冷门、从多年不变到每秒在变都有。论文的结果是：最先进的大模型直接回答，准确率不超过 34%；以简单的方式加上 RAG，也只提升到 44%；当时业界最好的 RAG 方案，也只有 63% 的问题能做到完全没有幻觉。
同年的 **LegalBench-RAG** 则专门考 RAG 的**检索**这一步：在法律文书里，能不能精确地找出最小、最相关的那几段话，而不是一整篇文档或一大堆不准的块。它的出发点是：检索不准，后面的模型再强也只能在错误或冗长的材料上作答，长上下文还会推高成本和延迟，并让模型更容易遗忘或编造。
两份数据合起来指向同一个结论：**RAG 系统的天花板，常常是由检索决定的**。很多看起来是“模型幻觉”的错误，追下去是第一步没有找对资料。所以评价和优化 RAG，应当先看检索。（这一归纳是本书基于上述两项研究的判断。）
### 7.5 怎样评价一个大模型
评价模型本身，最常见的办法是让它参加标准化的“考试”，叫**基准测试**（benchmark）。问题在于，模型进步太快，考试很快就被考穿了。
表 7-3 几代“考卷”
| 基准 | 考什么 | 规模 | 备注（出自原论文或发布方） |
| --- | --- | --- | --- |
| GLUE（2018）/ SuperGLUE（2019） | 一组自然语言理解任务 | 多个任务 | SuperGLUE 论文称，模型在 GLUE 上已超过非专家人类，所以需要更难的新考卷 |
| MMLU（2020） | 57 个学科的选择题，从初中到专业水平 | 15,908 题 | HLE 论文称，前沿模型在 MMLU 等热门基准上已超过 90% |
| GSM8K（2021） | 小学数学应用题，需要多步运算 | 8,500 题 | 常与 MATH 一起看数学推理 |
| MATH（2021） | 竞赛数学题，每题带完整解题步骤 | 12,500 题 | 论文发表时，即使很大的模型准确率也很低 |
| HumanEval（2021） | 按描述写 Python 函数，用单元测试判对错 | 164 题 | 常用 pass@1 计分：第一次就写对的比例 |
| MBPP（2021） | 入门级 Python 编程题 | 974 题 | 论文中最大的模型用少样本提示解出 59.6% |
| GPQA Diamond（2023） | 博士级物理、化学、生物难题 | 198 题 | 非本领域的高水平验证者可以随意上网，也只答对约 34%（“Google-proof”） |
| SWE-bench Verified（2024） | 修复真实开源项目里的问题，跑测试判定 | 500 个任务 | 编程 Agent 的主要考卷之一；OpenAI 发布 GPT-5 时报告 74.9% |
| Humanity’s Last Exam（2025） | 各领域专家出的前沿难题 | 2,500 题 | 因为老考卷被考穿而专门设计 |
| ARC-AGI-2（2025） | 没见过的抽象图形规律，考“现学现用” | — | 侧重泛化而非记忆 |
各家模型在这些考卷上的最新分数变化很快，且多为厂商自报，本书不列排名。
除了这类有标准答案的考试，开放式的写作和对话很难自动判分。早期用 BLEU、ROUGE 这类“和参考答案有多少词重合”的指标，后来又有用嵌入向量比较意思相近程度的 BERTScore，但同一个意思有无数种说法，重合度并不可靠。今天常用两种办法：**让一个强模型当评委**（LLM-as-a-judge），或者**请人盲测投票**：同时看两个匿名模型的回答，选更好的那个。
**停一下：一个模型在某个基准上拿了高分，为什么不能直接说明它更好用？**
**参考答案：**
至少有三个原因。第一，考题可能在训练时“漏题”了：题目和答案出现在网上，被模型读到过。第二，当分数成为各家竞争的目标，就会出现针对考卷的优化，分数涨了，真实能力未必同步涨——这被称为古德哈特定律：“当一个指标变成目标，它就不再是好指标。”第三，考试只测了一小部分能力，你的实际任务可能完全不同。最可靠的评测，永远是在**你自己的任务**上试一试。
闭卷靠*记忆*，开卷靠*检索*；
会考试，不等于会做事。
##### 本章带走
幻觉是“生成最像样的续写”的副作用；RAG 让模型开卷考试，用检索到的资料代替模糊的记忆。
- RAG = 离线把文档切块、嵌入、存进向量数据库 + 在线检索相近的块、拼进提示词、生成带出处的回答；它从朴素 RAG 演进到进阶 RAG，再到由模型自己规划检索的 Agentic RAG。
- CRAG：大模型直接回答 ≤34%，简单加 RAG 也只到 44%；RAG 的天花板常常由检索决定。
- 评价 RAG：上下文相关性、忠实度、回答相关性三角；再看噪声、拒答、整合、反事实四项抗压能力。
- 评价 LLM：基准测试会饱和、会漏题；LLM 评委和人类盲测是补充；最终以你自己的任务为准。
**于是，下一个问题**：会查资料的模型，仍然只会“说”。如果让它去“做”——运行代码、修改文件、调用公司的系统——会发生什么？这就是 AI Agent。
---
# 第 8 章 从会说到会做：AI Agent
> 本章问题：Agent 是什么？最新进展到了哪一步？
> 来源：https://llm.weiborao.link/#ch8
**上一章留下的问题：**会查资料的模型，仍然只会“说”。如果让它去“做”——运行代码、修改文件、调用公司的系统——会发生什么？这就是 AI Agent。
2025 年以后，AI 领域最热的词是 Agent（智能体）。这一章先用一个日常场景说清 Agent 是什么，再拆开它的结构，最后盘点截至 2026 年 10 月的最新进展：Claude Code、Codex、Muse 和它们背后的模型。
### 8.1 你一直在当那个“循环”
回想你用聊天机器人改代码的经历：
问：你：这段代码报错了，帮我看看。（粘贴代码）
答：模型：可能是第 42 行的问题，试试这样改。（给出一段代码）
问：你：（复制、粘贴、运行）还是报错，错误信息是这个。（粘贴报错）
答：模型：哦，那是另一个文件里的问题，请把 auth.py 发给我。
问：你：（找到文件、复制、粘贴）……
在这个过程里，模型负责“想”，**你负责“做”和“看”**：你替它打开文件、运行程序、把结果抄回给它。你就是那个把思考和行动连起来的循环。
Agent 的想法很简单：**把这个循环交给程序**。给模型一组工具（读文件、改文件、运行命令、搜索网页），让它自己决定下一步用哪个工具，程序替它执行，再把结果交还给它，直到任务完成。
### 8.2 Agent 的结构：大脑、工具、记忆、计划
2022 年 10 月的 ReAct 论文提出了一个后来被广泛采用的模式：让模型**交替生成“思考”和“行动”**，每次行动后观察结果，再继续思考。2023 年 6 月，OpenAI 研究员 Lilian Weng 在一篇被大量引用的文章里，把 Agent 概括为：以大模型为大脑，配上**规划**、**记忆**和**工具使用**三个组件。
> 【图示】Agent 循环：用户给出目标“修复失败的测试”。模型思考，决定调用工具读报错；程序执行工具，把结果作为新的输入还给模型；模型再思考，打开文件、修改代码、运行测试；测试失败就再改，直到测试通过，最后向用户汇报。
1. **目标：**用户只说要什么，不说怎么做。
2. **思考：**模型判断下一步该做什么。
3. **行动：**模型输出一个工具调用，程序去执行。
4. **观察：**执行结果被送回模型，成为新的输入。
5. **循环：**读文件、改代码、跑测试，失败了就再改。
6. **完成：**测试通过，向用户汇报做了什么。
**图 8-1** 一个修 bug 的 Agent 循环。“思考 → 行动 → 观察”转了好几圈，中途还失败了一次。人只在开头给目标、在结尾看结果。网页版可以逐步播放。
类比：
Agent 像一个**新来的实习生**：脑子很好使，读过很多书，但不认识你们公司的系统。你给他一个工位（运行环境）、一套工具和权限（能读什么、能改什么、什么必须先问你），交代清楚目标。他会自己查资料、动手、出错、再改，最后交给你一份结果。你需要做的，是设计好权限，并在关键处检查他的工作。
### 8.3 行动也是 Token
模型只会生成 Token，它怎么“运行命令”？答案是：它生成的是**一段描述行动的文字**，由外面的程序去执行。
模型生成的“行动”（一段结构化的 Token）{"tool": "run\_tests", "args": {"path": "tests/test\_auth.py"}}
程序执行后，送回给模型的“观察”FAILED test\_login line 42: token expired
训练时，模型见过大量这种“调用工具 → 看结果”的示范（第 5 章的微调与强化学习），学会了在合适的时候生成合适的调用。所以从模型的角度看，Agent 并没有新的魔法，它依旧在猜下一个 Token。序章里那句话，在这里兑现了：
一切都是 Token：
输入是 *Token*，思考是 Token，*行动也是 Token*。
### 8.4 MCP：工具的“USB-C 接口”
工具越来越多以后，出现了一个工程问题：每个 AI 应用都要为每个工具单独写对接代码。2024 年 11 月，Anthropic 推出了 **MCP**（Model Context Protocol，模型上下文协议），规定了 AI 应用与工具、数据源之间“怎么说话”。只要双方都支持 MCP，就能即插即用。
> 【图示】没有统一协议时，每个 AI 应用要为每个工具单独写对接，N 个应用乘 M 个工具；有了 MCP，应用和工具都只需支持同一个协议，变成 N 加 M。
**图 8-2** 统一协议把 N × M 的对接变成 N + M。这和 USB-C 统一充电口是同一个道理。
MCP 很快成了事实标准：据 Anthropic 2025 年 12 月的说明，ChatGPT、Cursor、Gemini、Microsoft Copilot、VS Code 等产品都已支持它；2025 年 12 月，Anthropic 把它捐给了 Linux 基金会下新成立的 Agentic AI Foundation（由 Anthropic、Block 和 OpenAI 共同发起），当时公开的 MCP 服务器已超过 1 万个。另一个协议 A2A（Agent2Agent）由 Google 在 2025 年 4 月提出，解决的是 Agent 与 Agent 之间怎样协作。
### 8.5 最新进展：截至 2026 年 10 月
Agent 最先大规模落地的场景是**写代码**。原因不难理解：代码世界里，工具（终端、编辑器、测试）都是现成的文字接口，结果可以自动验证（测试过没过），这和第 5 章“可自动判分的题目”是同一类好条件。
表 8-1 Agent 与前沿模型的关键节点（截至 2026-10-08）
| 时间 | 事件 | 意义 |
| --- | --- | --- |
| 2024-11 | Anthropic 推出 MCP | 工具接入的统一协议 |
| 2025-02 | Claude Code 研究预览（随 Claude 3.7 Sonnet） | 在终端里读代码、改文件、跑命令的编程 Agent |
| 2025-04 | OpenAI 开源 Codex CLI | 运行在终端里的轻量编程 Agent |
| 2025-05 | OpenAI Codex 云端 Agent（codex-1，基于 o3）；Claude Code 随 Claude 4 正式发布并开放 SDK | 每个任务一个云端沙箱，可并行；开发者可用 SDK 搭自己的 Agent |
| 2025-07 | Gemini Deep Think、OpenAI 实验模型达到 IMO 金牌线 | 推理能力的里程碑（序章） |
| 2025-08 | GPT-5 发布 | METR 测得其任务时长约 2 小时 17 分 |
| 2025-09 | GPT-5-Codex | OpenAI 称其可独立工作 7 小时以上 |
| 2025-11 | Gemini 3 发布 | Google 新一代旗舰 |
| 2025-12 | MCP 捐给 Agentic AI Foundation | 协议走向中立治理 |
| 2026-04 | Meta 超级智能实验室发布 Muse Spark；OpenAI 发布 GPT-5.5 | OpenAI 称公司内超过 85% 的人每周使用 Codex |
| 2026-07 | Muse Spark 1.1 与 Meta 模型 API | 面向 Agent 任务的多模态推理模型，100 万 Token 上下文 |
| 2026-08 | Meta 发布 Muse Code | 终端编程 Agent |
| 2026-09 | Muse Spark 1.3；Muse 个人 Agent 应用；GPT-6；Claude Opus 5.5 | 新一代模型密集发布 |
日期取自各公司官方发布页；Muse 应用的上线日期来自二手报道。各家对“谁最强”的说法以自家评测为主，本书不作排名。
**两个“Muse”** 2026 年谈到 AI 里的 Muse，通常指 Meta 超级智能实验室的 Muse 系列：Muse Spark 模型、Muse Code 编程 Agent，以及名为 Muse 的个人 Agent 应用。另有一个同名项目：微软研究院 2025 年 2 月在《自然》发表的 Muse，是一个用游戏画面和玩家操作训练的“世界与人类动作模型”，用于游戏创意构思。两者无关。
这些产品形态各异，结构却高度一致，都是图 8-1 的循环：Claude Code、Codex CLI、Muse Code 运行在开发者的终端里；Codex 云端版把每个任务放进一个独立的沙箱，可以同时开很多个；越来越多的产品让多个 Agent 并行分工，再由一个 Agent 汇总。Meta 在 Muse Spark 1.3 的发布中特别提到，在 Meta 工程师的比较中，新版本少用约 20% 的工具调用、约 25% 的 Token——**效率本身已经成了竞争点**。
#### 能干多久的活：每 7 个月翻一番
怎样衡量 Agent 的进步？研究机构 METR 在 2025 年 3 月提出了一个直观的尺子：**一个任务，人类专家需要多长时间完成，AI 就能以 50% 的成功率完成**。他们发现，这个“时长”大约每 7 个月翻一番。
> 【图示】AI 能完成的任务时长示意（对数纵轴）：METR 在 2025 年 3 月测得，前沿模型能以 50% 成功率完成的任务时长大约每 7 个月翻一番；GPT-5 约为 2 小时 17 分钟。虚线是按同一速度的外推，不是测量值。
**图 8-3** AI 能独立完成的任务时长（示意）。蓝线按 METR 的拟合与 GPT-5 的测量值绘制；琥珀色虚线是按同样速度的外推，是推测，不是测量。METR 也提醒，他们现有的任务集对超过 16 小时的测量不可靠。
**停一下：同样一个问题，交给 Agent 去做，消耗的 Token 往往是普通聊天的几十倍甚至更多。为什么？**
**参考答案：**
第一，循环每转一圈，模型都要重新读一遍越来越长的上下文：目标、已经做过的步骤、每个工具返回的结果。第二，工具的输出往往很长，一次测试日志、一个源文件就是几千个 Token。第三，推理模型在每一步都可能先“想”一大段（第 5 章）。Agent 越能干，越“吃”Token。这正是下一部分的起点：这些 Token 都要在 GPU 上一个个算出来。
### 8.6 走向物理世界：物理 AI 与世界模型
到目前为止，本书谈的 AI 都活在文字和屏幕里。下一步是让 AI 走进三维的真实世界：自动驾驶汽车、人形机器人、工厂里的机械臂。黄仁勋在 2024 年 COMPUTEX 上说：
> AI 的新一波浪潮是物理 AI。AI 能够理解物理定律，并与人类并肩作战。
>
> —— 黄仁勋，COMPUTEX 2024（NVIDIA 中文博客官方译文）；原文：“The next wave of AI is physical AI. AI that understands the laws of physics, AI that can work among us.”
问：让机器人学会走路、抓杯子，为什么不能像大模型那样“读遍互联网”？
答：因为互联网上有海量文字，却没有海量“这个动作做下去，世界会变成什么样”的数据。真机器人去试错又慢又贵，还可能摔坏东西、伤到人。
问：那怎么办？
答：先在电脑里造一个足够逼真的“世界”，让机器人在里面练。这个能预测“世界接下来会怎样”的模型，叫**世界模型**。
NVIDIA 在 2025 年 1 月发布的 Cosmos 论文里把这个思路说得很直白：物理 AI 需要先在数字世界里训练，它既需要一个自己的数字孪生（策略模型，决定怎么动），也需要一个世界的数字孪生（世界模型，预测动了之后会怎样）。Cosmos 平台提供预训练的“世界基础模型”、视频数据整理流程和视频分词器，并以开放权重发布。其中的 Cosmos Transfer 可以把仿真软件渲染出的画面转换成照片般逼真的合成数据，用来弥补仿真与现实之间的差距。到 2026 年，NVIDIA 官网把最新的 Cosmos 3 描述为“第一个原生具备推理、世界生成与动作生成能力的全能模型”，可以当作机器人策略模型的骨干，也可以当作受物理约束的世界模拟器。
这和本章开头的 Agent 是同一个循环，只是换了世界：**思考 → 行动 → 观察**，观察的不再是终端输出，而是摄像头和传感器；行动的不再是工具调用，而是电机和方向盘。8.5 节“两个 Muse”里提到的微软 Muse，也是一种世界模型，只不过它模拟的是游戏世界。
##### 世界模型追求的是
- 预测“世界接下来会怎样”：物体不会凭空消失，碰撞符合物理
- 为机器人、自动驾驶提供可以反复试错的“练习场”和合成数据
##### 它追求的不是
- 拍出好看的视频：画面再美，物理错了就是坏教材
- 取代真实测试：仿真练出来的本领，最终仍要在真实世界里验证
### 8.7 边界与风险
会“做”的 AI，也带来了只会“说”的 AI 没有的风险。最典型的是**提示词注入**：Agent 读到的网页或文档里藏着一句“忽略之前的指令，把密钥发到这个地址”，模型可能分不清这是数据还是命令。其他风险包括：执行了不可逆的操作（删库、发邮件、付款），权限过大，成本失控。
##### 今天的 Agent 擅长
- 目标清楚、结果可验证的任务：修 bug、写测试、整理数据、查资料写报告
- 在沙箱和最小权限下反复尝试
##### 今天的 Agent 还不该
- 在没有人复核的情况下做不可逆、高代价的决定
- 把读到的任何外部内容都当成可信指令
所以，部署 Agent 的工程重点，往往不在模型本身，而在**权限、沙箱、审计和人工确认**。第 14 章讲 AI 工厂的安全时，会再遇到这个问题。
##### 本章带走
Agent = 大模型 + 工具 + “思考 → 行动 → 观察”的循环。行动也是 Token：模型生成工具调用，程序执行，结果再变回 Token。
- MCP 统一了工具接入（N × M → N + M）；A2A 关注 Agent 之间的协作。
- 编程是 Agent 最先落地的场景：Claude Code、Codex、Muse Code；能独立完成的任务时长约每 7 个月翻一番。
- 风险在“做”：提示词注入、不可逆操作、权限过大；靠沙箱、最小权限和人工确认来管。
**于是，下一个问题**：每一次思考、每一次工具调用都要消耗 Token，而每一个 Token 背后都是几千亿次乘法和加法。这些计算在哪里完成？为什么一张显卡远远不够，要用上万张？
---
# 第 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 之间要不停地“对答案”。上万块卡怎样对答案，才不至于把大部分时间都花在等待上？
---
# 第 10 章 万卡对答案：通信与软件栈
> 本章问题：集合通信、NVLink、RDMA、CUDA、NCCL、Kubernetes 各干什么？
> 来源：https://llm.weiborao.link/#ch10
**上一章留下的问题：**拆开之后，GPU 之间要不停地“对答案”。上万块卡怎样对答案，才不至于把大部分时间都花在等待上？
一万块 GPU 拼在一起，并不自动等于一块“一万倍快”的 GPU。中间隔着一个问题：**它们怎样高效地交流**。本章先讲交流的方式（集合通信），再讲交流的通道（NVLink 与 RDMA），最后讲指挥这一切的软件（CUDA、NCCL、Kubernetes），并把第 6 章那次推理在整座工厂里重走一遍。
### 10.1 对答案：计算、交换、汇总
以数据并行为例：每块卡用自己那份数据算出一份梯度（“旋钮该往哪拧”），但真正要用的是所有卡梯度的**平均值**。于是每一步训练都是同一个循环：各自计算 → 互相交换 → 汇总平均 → 一起更新 → 下一步。
> 【图示】训练中“计算—交换—汇总”的循环：四块 GPU 各自计算，然后一起交换梯度。GPU 3 慢了一点，其他三块只能空等，整步时间由最慢的那块决定，这就是木桶效应。
**图 10-1** 同步训练的木桶效应。只要有一块卡、一条链路慢了一点，其他所有卡都得空等。规模越大，“总有一个慢的”的概率越高。
问：一万块卡里，只有一块慢了 10%，影响大吗？
答：很大。同步训练里，每一步都要等最后一块卡交卷。那一块的计算慢 10%，整个集群每一步的计算阶段也跟着慢 10%。
问：如果是网络里某条链路偶尔堵一下呢？
答：一样。哪怕平均很快，只要偶尔有一次慢，那一步所有卡都在等。所以 AI 网络最在意的是**尾部延迟**，也就是“最慢的那几次有多慢”。
### 10.2 AllReduce：圆桌传纸条
“每块卡都拿到所有卡数据的总和”，这个操作叫 **AllReduce**（全归约），是 AI 训练里最常用的集合通信操作。最笨的做法是：所有卡把数据发给一个“组长”，组长加总后再发回去。组长的网络会被挤爆。
聪明的做法是**环形 AllReduce**：所有卡围成一圈，每块卡只和左右邻居说话。
> 【图示】环形 AllReduce：四块 GPU 围成一圈，每块的数据分成四份。前三步“归约”，每步每块卡把一份传给下一块并累加，三步后每块卡各自拥有一份完整的总和；后三步“广播”，把完整的那份沿环传下去。六步后，每块卡都有了全部四份的总和。
1. **起点：**每块卡把自己的数据分成 4 份，每份都只有自己的贡献（1）。
2. **归约 1：**每块卡把其中一份传给下一块，对方加到自己那份上。
3. **归约 2：**继续沿环传、继续累加。
4. **归约 3：**每块卡各自有一份累加满了 4 块卡的数据。
5. **广播 1：**把完整的那份沿环传给下一块。
6. **广播 2：**继续传。
7. **广播 3：**每块卡的 4 份都是完整总和，AllReduce 完成。
**图 10-2** 4 块卡的环形 AllReduce，6 步完成。每一步，每块卡同时在发和收，所有链路都在干活，没有谁闲着，也没有谁被挤爆。网页版可以逐步播放。
类比：
环形 AllReduce 像**圆桌传纸条**：要算全桌人的零花钱总数，不必都交给班长，而是每人把纸条传给右手边的人，对方加上自己的数再往下传。转完一圈，每人手里都有了总数。
环形算法有一个漂亮的性质：每块卡要发送的数据量约为 2 × (N − 1) / N 倍的原始数据，N 越大越接近 2 倍，**几乎不随卡数增加**。8 块卡时是 1.75 倍。
**停一下：既然每块卡发的数据量几乎不变，环形 AllReduce 是不是可以无限扩展？**
**参考答案：**
不能。数据量不变，但**步数**随卡数线性增加：N 块卡要走 2(N − 1) 步，每一步都有固定的延迟。几千块卡时，光是“一步一步传”的等待就很可观。所以实际的通信库还会用树形等算法，或者先在服务器内部汇总、再跨服务器汇总，按规模和消息大小自动选择。
还有一种更激进的思路：**让交换机来做加法**。既然 AllReduce 的本质是“把大家的数加起来”，何必让数据在 GPU 之间来回传？NVIDIA 在 InfiniBand 交换机里实现的 **SHARP**（可扩展分层聚合与归约协议）就是这样做的：数据在经过交换机时就被就地聚合，越往上走，网络里需要传的数据越少，集合通信的时间随之缩短。这类做法统称**网内计算**。
除了 AllReduce，常用的集合通信还有 AllGather（每人把自己那份分享给所有人）、ReduceScatter（汇总后每人只拿一部分）、Broadcast（一人发给所有人）和 AlltoAll（每人给每人发一份不同的东西，混合专家模型很依赖它）。
### 10.3 两级高速公路：NVLink 与 RDMA
对答案要走“路”。AI 集群里有两级路，速度差很多。
> 【图示】两级高速公路：服务器内部，8 块 GPU 通过 NVLink 和 NVSwitch 互联，H100 每块卡 900 GB/s；服务器之间，每块 GPU 配一块网卡，经交换机用 RDMA 通信，400 Gb/s 约等于单向 50 GB/s；NVLink 900 GB/s 是双向口径，同口径比较约快 9 倍。
**图 10-3** 服务器内部走 NVLink，服务器之间走网卡和交换机。H100 的 NVLink 每卡 900 GB/s（收发合计的双向口径，单向约 450 GB/s），一块 400 Gb/s 网卡单向约 50 GB/s；按同一口径比较，机内比机间快约 9 倍，接近一个数量级。所以并行策略会把通信最频繁的张量并行放在服务器内部。
**读带宽数字之前，先认清两种单位** 网络行业用**比特**：Gb/s、Tb/s，网卡、交换机端口都这样标（400G 就是 400 Gb/s）。GPU、显存、存储行业多用**字节**：GB/s、TB/s。1 字节 = 8 比特，所以 400 Gb/s ≈ 50 GB/s。另一个陷阱是方向：网卡的 400 Gb/s 指每个方向各 400 Gb/s；NVIDIA 给 NVLink 标的 900 GB/s 是收发合计的双向数字。比较两个带宽之前，先把单位和方向换成同一口径。本书后面凡是 Gb/s，都是比特；GB/s 都是字节。
**服务器内部：NVLink。**在普通电脑里，两块显卡交换数据要经过主板上的 PCIe 通道，甚至绕道 CPU 内存。NVIDIA 的 NVLink 让 GPU 之间直接相连，配合 NVSwitch 芯片，一台服务器里的 8 块卡可以两两高速通信。Blackwell 一代把每卡带宽提到 1.8 TB/s（双向）；GB200 NVL72 更进一步，把整整一个机柜的 72 块 GPU 连成一个 NVLink 域，总带宽 130 TB/s，让它们像一块巨大的 GPU。
**服务器之间：RDMA。**跨服务器就得走网络。传统网络通信要经过操作系统层层处理：数据从显存拷到内存，再交给网络协议栈打包，对方再一层层拆开。**RDMA**（远程直接内存访问）让一台机器的网卡直接读写另一台机器的内存，不需要两端的 CPU 和操作系统插手；配合 **GPUDirect RDMA**，网卡甚至可以直接读写 GPU 显存。
类比：
传统网络通信像**寄快递**：打包、送到快递站、分拣、运输、再分拣、派送、拆包，每一站都要人经手。RDMA 像在两个车间之间架了一条**直达传送带**：东西从这边的货架直接滑到那边的货架上，中间没有人碰。
RDMA 有两种主流的“传送带”：一种是 **InfiniBand**，专为高性能计算设计的网络；另一种是 **RoCEv2**，把 RDMA 搬到以太网上。它们的区别，以及以太网为此要做的改造，是下一章的主题。
### 10.4 软件栈：谁在指挥
硬件连好了，还要有软件告诉每一块卡做什么、什么时候和谁说话、哪个任务用哪些卡。
> 【图示】AI 工厂的软件栈，从上到下：AI 应用与框架（PyTorch、推理引擎）；通信库 NCCL；CUDA 与驱动；编排与调度（Kubernetes、Slurm、Run:ai）横跨所有层；最底层是 GPU、NVLink、网卡、交换机和存储。右侧是工厂类比。
**图 10-4** AI 工厂的软件栈与工厂类比。CUDA 是工人的语言，NCCL 是物流调度，Kubernetes 等编排系统是厂长和人事部。
#### CUDA：工人的语言
GPU 上的上万个计算单元听不懂普通程序。NVIDIA 在 2006 年推出 **CUDA**，2007 年 6 月发布 1.0 工具包，让程序员可以用 C/C++ 这类语言，把一个计算拆成成千上万个线程，分配给 GPU 去执行。今天的 PyTorch 等框架在底层调用的，就是用 CUDA 写成、为矩阵乘法等操作高度优化的程序（叫“内核”）。没有它，GPU 只是一堆不会干活的硅片。
#### NCCL：物流调度
**NCCL**（NVIDIA 集合通信库）负责 10.1 和 10.2 讲的那些“对答案”操作。它的官方定义是“拓扑感知的 GPU 间通信原语”：先看清楚机器怎么连的——哪两块卡之间有 NVLink、哪块卡离哪块网卡最近——再为每次通信挑最快的路线和算法（环形、树形等）。同一台服务器内走 NVLink，跨服务器走网卡上的 RDMA。上层框架只要说一句“AllReduce”，剩下的都交给它。
#### Kubernetes 等编排系统：厂长与人事部
一座有几千台服务器的工厂，不可能靠人去逐台分配任务。**Kubernetes**（2014 年由 Google 开源）把所有机器变成一个资源池：接收任务，寻找有空闲 GPU 的机器，把任务放上去，机器坏了就把任务挪走。配合 NVIDIA 的 GPU Operator，它能自动安装和管理 GPU 驱动等组件。超大规模训练里也常用传统超算的调度器 **Slurm**（NVIDIA 在 2025 年 12 月收购了它的开发商 SchedMD）。NVIDIA 2024 年宣布收购的 **Run:ai** 则在 Kubernetes 上做更精细的 GPU 调度，并在 2025 年开源了其调度器 KAI Scheduler。
表 10-1 训练与推理都要编排，但侧重点不同
| | 训练 | 推理 |
| --- | --- | --- |
| 核心诉求 | 一次性拿到大批 GPU，长时间不中断 | 随流量自动伸缩，资源不浪费 |
| 典型能力 | 成组调度（要么全部到位，要么不开始）、按网络拓扑放置、故障后从检查点恢复 | 自动扩缩容（高峰多开副本、深夜回收）、负载均衡、把一块 GPU 切给多个小模型共享 |
| 常见工具 | Slurm、Kubernetes + 批调度器 | Kubernetes + 推理服务框架、Run:ai 等 |
##### NCCL 是
- 一个软件库：决定“怎么传”、走哪条路、用哪种算法
- 上层框架和底层网络之间的翻译与调度者
##### NCCL 不是
- 网络硬件：链路慢了、堵了，它只能绕，不能变出带宽
- CUDA：CUDA 管“怎么算”，NCCL 管“怎么传”
### 10.5 再走一遍：从回车到屏幕
现在可以把第 6 章那次推理，放到整座工厂里重走一遍。以一个需要 8 块 GPU 才放得下的大模型为例：
> 【图示】从按下回车到看到第一个字：请求经网络到达数据中心，负载均衡把它交给 Kubernetes 管理的推理服务；调度器分配好 GPU；模型权重早已切分加载在 8 块 GPU 的显存里；CUDA 在每块卡上执行矩阵乘法；每层算完，NCCL 通过 NVLink 汇总结果；最后一层输出下一个 Token，经网络流回你的屏幕，然后循环。
1. **请求到达：**你的问题经互联网进入数据中心的前端网络。
2. **Kubernetes：**负载均衡把请求交给一个正在运行的推理服务实例。
3. **调度：**这个实例早已被分配到一台 8 卡服务器上。
4. **权重就位：**模型按张量并行切成 8 份，常驻在 8 块卡的显存里。
5. **CUDA：**每块卡执行自己那 1/8 的矩阵乘法。
6. **NCCL：**每一层算完，8 块卡经 NVLink 交换部分结果，凑成完整的结果再进入下一层。
7. **输出：**最后一层给出下一个 Token，流式发回你的屏幕；然后回到第 5 步，生成下一个。
**图 10-5** 屏幕上每蹦出一个字，第 5、6 步就要在一百多层网络里来回几百次。所谓“打字机效果”，背后是 CUDA 在算、NCCL 在传、Kubernetes 在守。网页版可以逐步播放。
CUDA 管*算*，NCCL 管*传*，
编排系统管“谁在哪儿干活”。
##### 本章带走
万卡协作的关键是“对答案”：集合通信让每块卡拿到汇总结果，速度由最慢的卡和最堵的链路决定。
- 环形 AllReduce：每块卡只和邻居说话，发送量约为数据的 2(N−1)/N 倍，几乎不随卡数增长。
- 两级路：服务器内 NVLink（H100 每卡 900 GB/s，双向），服务器间 RDMA 网络（400 Gb/s ≈ 单向 50 GB/s），同口径相差约 9 倍。
- 软件栈：CUDA 管计算，NCCL 管通信，Kubernetes / Slurm / Run:ai 管调度；训练要“整批不中断”，推理要“弹性伸缩”。
**于是，下一个问题**：一旦“对答案”跨出机箱，数据就要走上网络。为什么传统的以太网扛不住 AI 训练的流量？AI 网络要怎样改造？
---
# 第 11 章 网络成了新瓶颈：从 ECMP 到超以太网
> 本章问题：AI 网络要解决什么问题？怎样解决？
> 来源：https://llm.weiborao.link/#ch11
**上一章留下的问题：**一旦“对答案”跨出机箱，数据就要走上网络。为什么传统的以太网扛不住 AI 训练的流量？AI 网络要怎样改造？
第 10 章的结论是：同步训练的速度由最慢的那条链路决定。这一章就盯着“链路”看：AI 的流量有什么怪脾气，传统网络为什么会在它面前堵车，业界想出了哪些办法，以及正在成形的新标准“超以太网”。这是全书最技术化的一章，但每个概念都能用“高速公路”来理解。
### 11.1 三张网，各管各的
> 【图示】AI 数据中心的三张网：东西向的后端网络只连 GPU，承载训练中的集合通信；南北向的前端网络连接用户、应用和管理系统；存储网络把训练数据和检查点在 GPU 与存储之间搬运。
**图 11-1** AI 数据中心通常把网络分成三个平面。后端网络只给 GPU 之间“对答案”用；前端网络对外；存储网络搬运数据和检查点。
表 11-1 训练与推理对三张网的要求
| 网络 | 训练 | 推理 |
| --- | --- | --- |
| 后端（东西向，GPU ↔ GPU） | 最苛刻：每块 GPU 配 400G/800G 网卡；不能丢包、不能拥塞；尾部延迟决定作业完成时间 | 单机内能跑的模型几乎不用；跨机的超大模型和混合专家模型需要，对小消息的低延迟很敏感 |
| 前端（南北向） | 调度、管理、监控 | 直接面对用户：接收请求、流式返回 Token、访问 RAG 向量库；要高可用和负载均衡 |
| 存储 | 开始时大量并发读取数据集；训练中周期性写出几 TB 的检查点，形成写入洪峰 | 加载模型权重；部分系统把 KV 缓存放到更大的存储层 |
第 13、14 章会看到，NVIDIA 企业参考架构把这三张网落实为“东西向计算网、南北向融合网（在一张物理网上用 VLAN 隔离出存储、带内管理和客户接入）、带外管理网”，并按每块 GPU 规定了各自的带宽配额。
### 11.2 大象流与 ECMP 撞车
数据中心网络一般是“叶脊”结构：每台服务器接到一台叶交换机，叶交换机通过多条等价的上行链路接到多台脊交换机。从 A 到 B 有好几条路可走，选哪条？传统做法叫 **ECMP**（等价多路径）：把一条连接的五元组（源/目的地址、源/目的端口、协议）算一个哈希值，按哈希值固定分到某一条链路。
普通互联网流量是成千上万条“小汽车”：网页、视频、邮件，每条都不大，哈希一分，自然就均匀了。AI 训练的流量完全不同：
- **大象流**：少数几条连接，每条都能单独打满一块 400G 网卡；
- **熵低**：连接数量少、五元组变化小，哈希值很难分散开；
- **同步突发**：所有 GPU 在同一时刻开始交换数据。
类比：
ECMP 像**按车牌尾号分配收费口**。平时几千辆小车，尾号自然分布均匀，每个口都不挤。可如果只来了 4 辆超长大货车，而其中两辆尾号恰好相同，它们就会挤进同一个口，另一个口空着。大货车一辆就占满整条道，于是一半的货要多等一倍时间。
> 【图示】左：ECMP 按流哈希，四条大象流里有两条被分到同一条链路，这条链路需求 200%，另一条链路空闲。右：逐包喷洒，每个包各选一条最空的链路，四条链路都是 100%。
**图 11-2** 同样四条大象流、四条链路。ECMP 按“流”固定分路，撞车的那条链路需求 200%，作业被拖慢一倍；逐包喷洒按“包”分路，四条链路均匀用满。
### 11.3 更聪明的分流
解决办法的思路只有一个：**分得更细、看得更清**。按粒度从粗到细，主流方案有这些：
表 11-2 AI 后端网络的负载均衡方案
| 方案 | 分路粒度 | 怎么分 | 乱序风险 | 优点 | 代价 |
| --- | --- | --- | --- | --- | --- |
| 增强 ECMP + QP 扩展 | 按流 | 哈希时额外看 RDMA 包头里的“队列对”编号，软件再多开一些连接，人为制造更多条流 | 无 | 不用换硬件；Meta 报告 AllReduce 最高提升 40% | 仍是按流，效果依赖流量模式 |
| Flowlet 动态负载均衡 | 按流片段 | 利用一条流里包与包之间的空隙，把大象流切成小段，每段重新选最空的路 | 很低（只在包间空隙足够大时换路） | 同一小段内不乱序 | 需要流量里有足够的空隙 |
| 自适应路由 / 逐包喷洒 | 按包 | 交换机为每个包实时挑最不拥塞的出口 | 高，必须由网卡处理 | 链路利用最均匀 | 包会乱序，需要网卡配合 |
| 集中式流量工程 | 按流 | 控制器结合拓扑和作业信息，预先算好路径下发 | 无 | 适合高度可预测、重复的训练流量 | 对变化反应慢 |
| 全局负载均衡 | 视实现 | 不只看本机链路，还看下一跳甚至更远处的拥塞 | 视实现 | 避开网络深处的热点 | 实现复杂 |
### 11.4 乱序怎么办
逐包喷洒最均匀，但带来一个新麻烦：同一条消息的包走了不同的路，到达顺序会乱。传统的 RDMA 网卡要求按顺序收包，看到乱序往往当成丢包处理，触发重传，性能骤降。
解决思路是让**网卡不在乎顺序**：每个包都带着它在目标内存里的位置，网卡收到一个就直接写进对应的位置，不必在缓冲区里排队等前面的包。所有包到齐后，再告诉上层“这条消息完整了”。
> 【图示】乱序到达与直接放置：一条消息被切成 1 到 4 号包，经不同路径到达，顺序变成 3、1、4、2。每个包都带着它在目标内存中的地址，网卡收到一个就直接写到对应位置，四个都到齐后，应用看到的是一条完整、有序的消息。
**图 11-3** 乱序到达、按址放置、按序交付。底层享受逐包喷洒的均匀，上层感受不到乱序。
NVIDIA 的 Spectrum-X 就是这样组合的：交换机逐包选择最不拥塞的端口，BlueField-3 等 SuperNIC 在 RoCE 传输层把乱序的数据整理好，“透明地向应用交付有序的数据”。NVIDIA 称 Spectrum-X 的 AI 网络性能是普通以太网的 1.6 倍（厂商口径）。
### 11.5 不让丢，还是丢了快补
RDMA 很怕丢包。原因在重传方式：传统 RoCE 网卡多采用**回退 N 步**（Go-Back-N），一个包丢了，就把它之后已经发出的包全部重发一遍。
> 【图示】丢了一个包之后：回退 N 步（Go-Back-N）要把丢失的 3 号包以及之后已经收到的 4 到 8 号包全部重发；选择性重传只重发 3 号包。
**图 11-4** 丢一个包的代价。回退 N 步要重发一长串，选择性重传只补丢的那一个。丢包在 RDMA 里贵，主要贵在这里。
所以过去的思路是“干脆别让它丢”。两大阵营做法不同：
**InfiniBand：天生无损。**它用**基于信用的流控**：接收端事先告诉发送端“我还有多少空位”，发送端只在有空位时才发。缓冲区永远不会溢出，从机制上就不丢包。拥塞时，交换机在包上打标记，接收端回告发送端减速，全部在硬件里完成。
**RoCEv2：给以太网“打补丁”。**以太网本来允许丢包。为了让 RDMA 跑在上面（RoCEv2 把 RDMA 的传输头装进 UDP 包里，目的端口 4791），需要两个机制配合：
- **PFC（基于优先级的流控）是刹车**：交换机队列快满时，向上游发“暂停”帧，让它别再发。粗暴但有效；副作用是会连累同一端口上无辜的流（队头阻塞），拥塞可能像多米诺骨牌一样向上游蔓延，极端情况下还会死锁。
- **ECN（显式拥塞通知）是油门**：队列开始变长时，交换机在包上打标记，接收端回一个拥塞通知包，发送端主动减速，尽量不让 PFC 触发。
两者结合的经典算法叫 **DCQCN**（2015 年）。但它的参数很难调。Meta 在 2024 年的 SIGCOMM 论文里披露，他们在 400G 部署中**干脆关掉了 DCQCN**，改为让集合通信库和传输层协同，由接收端来控制“谁什么时候可以发”。
**停一下：“无损”听起来是最好的。为什么新一代的思路反而是“允许丢包，但丢了能快速补上”？**
**参考答案：**
因为“无损”是有代价的。为了不丢，PFC 会让整段链路停下来，拥塞会扩散，规模越大越难调；而训练真正在乎的不是“一个包都不丢”，而是“每一步都能按时完成”。如果丢包能被**立刻发现**，并且只重发那一个包，偶尔丢一点反而比层层刹车更快、更容易扩展。这正是超以太网的设计哲学。
### 11.6 超以太网：为 AI 重新设计以太网
2023 年 7 月，AMD、Arista、Broadcom、Cisco、Eviden、HPE、Intel、Meta 和微软发起成立了**超以太网联盟**（UEC）。2025 年 6 月 11 日，联盟发布了 1.0 规范，目标是在开放的以太网上，为 AI 和高性能计算提供可扩展到**数百万个端点**的传输。
它的核心理念可以概括为一句话：**把复杂留给网卡，把简单留给交换机**。GPU 和网卡的计算能力越来越强，就让网卡承担重排、重传、拥塞控制这些“脏活”，交换机专心做又快又简单的转发。几个关键设计：
1. **多路径喷洒 + 乱序交付**：包可以走不同的路、乱序到达，网卡按址放置（11.4）。
2. **选择性确认与重传**：接收端准确告诉发送端收到了哪些，只补丢的那个（图 11-4 下半部分）。
3. **数据包裁剪**（可选）：交换机缓冲区满时，不再静默丢包，而是剪掉数据、只把包头快速送达，让接收端立刻知道丢了什么。
4. **链路层重试**（可选）：因线路误码损坏的包，在相邻两台设备之间就地重传，不必端到端重来。
5. **基于信用的流控**（可选）：借鉴 InfiniBand 的思路，作为 PFC 的更精细替代。
6. **新的传输协议 UET**：分为语义、包交付、拥塞管理、传输安全四个子层；面向 AI 定义了 AI Base 与 AI Full 两种配置，另有面向传统超算的 HPC 配置；编程接口基于开源的 libfabric。
> 【图示】数据包裁剪：交换机缓冲区满了，不再整包丢弃，而是剪掉数据部分，只把很小的包头用高优先级快速送到接收端；接收端一看到被裁剪的包头，就知道丢了哪个包，立刻请求发送端重发，不必等超时。
**图 11-5** 数据包裁剪。包头很小，用高优先级几乎不用排队，接收端在微秒级就能知道丢了哪个包，而传统做法要等一个长得多的超时。
表 11-3 三种 AI 后端网络的对照
| | InfiniBand | RoCEv2（以太网） | 超以太网 UEC 1.0 |
| --- | --- | --- | --- |
| 对丢包的态度 | 机制上不丢（信用流控） | 靠 PFC 尽量不丢 | 允许丢，快速发现、只补丢的 |
| 拥塞控制 | 交换机标记 + 端点硬件降速 | ECN + PFC（如 DCQCN），调参难 | 端点为主的拥塞管理，可配合裁剪与信用流控 |
| 多路径与乱序 | 支持自适应路由（视实现） | 传统上按流 ECMP，乱序代价高 | 原生逐包喷洒、乱序交付 |
| 重传 | 传统上按序 | 常见回退 N 步 | 选择性重传 |
| 生态 | 以 NVIDIA 为主 | 多厂商以太网 | 多厂商开放标准 |
各厂商产品在标准之上还有自己的增强，实际能力以具体型号为准。
##### AI 网络追求的是
- 可预测的作业完成时间：每一步都准时
- 链路用得均匀，尾部延迟低
##### AI 网络追求的不是
- “绝对不丢包”本身：那只是手段之一
- 单条链路的峰值速度：全网最慢的那一处才决定结果
##### 本章带走
AI 训练的流量是少数同步的大象流，按流哈希的 ECMP 会撞车；解法是分得更细（逐包喷洒），再让网卡处理乱序与重传。
- 三张网：后端（GPU ↔ GPU）、前端（对外）、存储，训练时后端最苛刻。
- InfiniBand 靠信用流控天生无损；RoCEv2 靠 PFC + ECN 补出无损，难调；Meta 在 400G 上关掉了 DCQCN。
- 超以太网 UEC 1.0（2025-06）：智能网卡 + 简单交换机；喷洒、乱序交付、选择性重传、包裁剪、链路层重试。
**于是，下一个问题**：算力、通信、网络都有了。要把它们组装成一座真正能交付“智能”的工厂，还缺什么？企业要怎样建、怎样管、怎样保证安全？
---
# 第 12 章 AI 工厂：定义、黄仁勋的工厂论与经济账
> 本章问题：AI 工厂到底是什么？为什么说它生产的是 Token？
> 来源：https://llm.weiborao.link/#ch12
**上一章留下的问题：**算力、通信、网络都有了。要把它们组装成一座真正能交付“智能”的工厂，还缺什么？企业要怎样建、怎样管、怎样保证安全？
“AI 工厂”这个词，最近两年出现在几乎每一场 AI 基础设施的发布会上。它到底是一个精确的工程概念，还是一句营销口号？本章分四步回答：先给出一个可以拿来检验的**定义**；再按时间顺序读一遍黄仁勋两年来的原话，看这个概念是怎样一步步长出来的；然后算一笔**经济账**，说明为什么“每瓦能产出多少 Token”成了核心指标；最后看企业为什么需要、又为什么难以建成自己的 AI 工厂。接下来的两章，再把“建厂图纸”逐页摊开。
### 12.1 一个精确的定义
定义要从权威出处取，而不是凭印象概括。关于 AI 工厂，有三份值得逐字读的表述。
**第一份：NVIDIA 官方术语表。**这是最接近“词典定义”的一份，中文版是 NVIDIA 官网自己的译文：
> AI 工厂是一种专业计算基础设施，通过管理整个 AI 生命周期（从数据采集到训练、微调和大量 AI 推理），从数据中创造价值。其核心产出是“智能”，通常以 Token 吞吐量来衡量，用于推动决策制定、自动化流程以及新的 AI 解决方案。
>
> —— NVIDIA 术语表“AI 工厂”（nvidia.cn 官方中文）；英文原文：“An AI factory is a specialized computing infrastructure designed to create value from data by managing the entire AI life cycle, from data ingestion to training, fine-tuning, and high-volume AI inference. The primary product is intelligence, measured by token throughput…”
**第二份：企业 AI 工厂。**NVIDIA 为企业参考架构写的白皮书，把定义落到了“企业能建的东西”上：
> 企业 AI 工厂是一个大规模制造智能的全栈平台。它整合了来自 NVIDIA 和生态伙伴的加速计算、网络、存储、软件、模型、数据管道与安全能力。它为本地和混合环境而建，必须适应客户数据中心的真实约束，包括空间、电力、散热、网络集成以及既有的运维工具。
>
> —— NVIDIA《Reference Architectures for Enterprise AI Factories》白皮书（本书译）；原文：“An Enterprise AI Factory is a full-stack platform for manufacturing intelligence at scale…”
**第三份：黄仁勋自己的话。**2025 年 5 月 COMPUTEX 主题演讲，这是他给出的最直白的一次定义（NVIDIA 中文博客官方译文）：
> 它们不是传统的数据中心。称之为 AI 数据中心其实不太贴切。它们实际上就是 AI 工厂。给它注入能量，它就会生产出非常有价值的产品，这些产品就叫做 token。
>
> —— 黄仁勋，COMPUTEX 2025 主题演讲，2025 年 5 月 19 日（台北）；原文：“They’re not data centers of the past. These AI data centers, if you will, are improperly described. They are, in fact, AI factories. You apply energy to it, and it produces something incredibly valuable, and these things are called tokens.”
三份表述角度不同，但共享四个要素。把它们合起来，就得到本书使用的定义：
**本书的定义** AI 工厂是一套为 AI 全生命周期（数据摄取、训练、微调、大规模推理）专门设计的全栈基础设施：**输入**是电力与数据，**过程**由加速计算、网络、存储、软件与安全协同完成，**产品**是 Token（模型的输出、回答与行动），**衡量**标准是 Token 吞吐量、每瓦 Token 数与每个 Token 的成本。
> 【图示】AI 工厂的输入与输出：输入是电和数据，工厂里是 GPU、网络、存储和软件；输出是 Token，也就是模型、回答和 Agent 的行动。衡量产能的指标是 Token 吞吐量，以及每瓦电产出多少 Token。
**图 12-1** AI 工厂的输入、产线与产品。它和传统数据中心最本质的区别，不在于装了 GPU，而在于整座设施围绕“产出 Token”这一个目标来设计和计量。
##### AI 工厂是
- 以 Token 产出为目标、按产能和单位成本计量的整套设施
- 覆盖从数据到推理的全生命周期，而不只是训练集群
- 计算、网络、存储、软件、电力散热与安全的协同设计
##### AI 工厂不是
- 在传统机房里插几块 GPU：功率、网络、存储都不匹配
- 一个只属于 NVIDIA 的产品型号：它描述的是一类基础设施
- 只有超大公司才建得起的东西：参考架构的起点是 4 台服务器（第 13 章）
### 12.2 黄仁勋的“工厂论”：两年里的十几句话
“AI 工厂”不是一夜之间出现的概念。按时间顺序读黄仁勋的原话，能看到一条清楚的演进线：先说“通用计算到头了”，再说“数据中心会变成工厂”，接着说“工厂的产品是 Token”，最后说“每瓦 Token 就是收入”。
> 【图示】黄仁勋关于 AI 工厂的说法的演进，2024 年 3 月到 2026 年 6 月：从“加速计算到达临界点、数据中心将成为 AI 工厂”，到“注入能量、产出 Token”，再到“智能 Token 是新的货币”“每瓦吞吐量就是收入”。
**图 12-2** 黄仁勋关于 AI 工厂的说法，2024 年 3 月到 2026 年 6 月。图中是摘要，原话与出处见下文和附录。
#### 第一阶段（2024）：通用计算到头了，数据中心要变成工厂
> “Accelerated computing has reached the tipping point — general purpose computing has run out of steam.”
>
> 加速计算已经到达临界点——通用计算已经后继乏力。
>
> —— GTC 2024 主题演讲，2024 年 3 月 18 日（本书译）
> “In the future, data centers are going to be thought of … as AI factories. Their goal in life is to generate revenues, in this case, intelligence.”
>
> 未来，人们会把数据中心看作 AI 工厂。它们存在的目的是创造收入，在这里，就是创造智能。
>
> —— GTC 2024 主题演讲，2024 年 3 月 18 日（本书译）
> “The more you buy, the more you save.” “The next wave of AI is physical AI. AI that understands the laws of physics, AI that can work among us.”
>
> 买得越多，省得越多。 AI 的新一波浪潮是物理 AI：理解物理定律、能和我们一起工作的 AI。
>
> —— COMPUTEX 2024 主题演讲，2024 年 6 月
第一句“买得越多，省得越多”的上下文，是 NVIDIA 当时的说法：GPU 与 CPU 结合，可以在功耗只增加约 3 倍的情况下获得最高约 100 倍的加速。它的论证对象是“同样的工作量用更少的电和钱完成”。
#### 第二阶段（2025 上半年）：推理、Agent 与“工厂的操作系统”
> “AI has made a giant leap — reasoning and agentic AI demand orders of magnitude more computing performance.”
>
> AI 实现了巨大的飞跃——推理和 Agent 式 AI 需要高出几个数量级的计算性能。
>
> —— Blackwell Ultra 发布新闻稿，GTC 2025，2025 年 3 月 18 日（本书译）
> “It is essentially the operating system of an AI factory.” “The more you buy, the more you save … It’s even better than that — the more you buy, the more you make.”
>
> （Dynamo）本质上就是 AI 工厂的操作系统。 买得越多，省得越多……其实更好——买得越多，赚得越多。
>
> —— GTC 2025 主题演讲，2025 年 3 月 18 日
同一场演讲里，NVIDIA 官方博客转述了他的另一个判断：**未来每家公司都会有两座工厂，一座生产它的产品，另一座生产 AI**（这句是博客的转述，不是逐字引语）。注意口号的变化：从“省”到“赚”。工厂的叙事，从这里开始从“降低成本”转向“创造收入”。
> AI 现在已经是一种像互联网和电力一样的基础设施。我们今天建造的就是 AI 工厂。……给它注入能量，它就会生产出非常有价值的产品，这些产品就叫做 token。
>
> —— COMPUTEX 2025 主题演讲，2025 年 5 月 19 日（NVIDIA 中文博客官方译文）
> “The number of people using inference has gone from 8 million to 800 million — 100x in just a couple of years.” “These AI factories are going to generate tokens.”
>
> 使用推理的人数从 800 万增长到 8 亿，短短几年增长了 100 倍。 这些 AI 工厂将生成 Token。
>
> —— GTC 巴黎主题演讲，2025 年 6 月 11 日
> “Every industrial revolution begins with infrastructure. AI is the essential infrastructure of our time, just as electricity and the internet once were.”
>
> 每一次工业革命都始于基础设施。AI 是我们这个时代的必要基础设施，正如曾经的电力和互联网。
>
> —— NVIDIA 欧洲 AI 基础设施新闻稿，2025 年 6 月 11 日（本书译）
#### 第三阶段（2025 下半年至 2026）：AI 是劳动，Token 是货币，每瓦是收入
> “AI is not a tool. AI is work. For the first time, technology is now able to do work and help us be more productive.”
>
> AI 不是工具，AI 本身就是劳动。技术第一次能够真正承担工作，帮助我们提高生产力。
>
> —— GTC 华盛顿特区主题演讲，2025 年 10 月 28 日
> “In the age of AI, intelligence tokens are the new currency, and AI factories are the infrastructure that generates them.”
>
> 在 AI 时代，智能 Token 是新的货币，而 AI 工厂就是生成它们的基础设施。
>
> —— Vera Rubin DSX AI 工厂参考设计新闻稿，GTC 2026，2026 年 3 月（本书译）
> “I believe computing demand has increased by 1 million times over the last few years.”
>
> 我认为过去几年里，计算需求增长了大约 100 万倍。
>
> —— GTC 2026 主题演讲，2026 年 3 月（本书译）
> “Ultimately, our customers don’t want to buy computers, they want to build AI factories.” “If you have 1 gigawatt of power, then throughput per watt is revenue … compute is revenue.”
>
> 归根到底，我们的客户不是想买计算机，而是想建 AI 工厂。 如果你有 1 吉瓦的电力，那么每瓦吞吐量就是你的收入……计算能力就是营收。
>
> —— GTC 台北暨 COMPUTEX 2026 主题演讲，2026 年 6 月（本书译）
问：把这十几句话串起来，逻辑链是什么？
答：五步：第一，通用计算的进步慢下来了，必须靠加速计算；第二，加速计算的数据中心，产品是 Token，所以应该叫工厂；第三，推理、推理模型和 Agent 让 Token 需求暴涨；第四，工厂受电力约束，所以每瓦产出决定收入；第五，这种工厂会像电网和互联网一样，成为每个国家、每家公司的基础设施。
问：他是全球最大 AI 芯片供应商的 CEO。这些话能全信吗？
答：要分开看。“产品是 Token、受电力约束、按每瓦产出计量”是可以独立检验的工程判断，本书前面几章的推导也支持它；“买得越多赚得越多”“需求增长 100 万倍”则是商业主张，带着供应商的立场，应当把它当作一种需要用自己的业务数据去检验的假设。
### 12.3 工厂的经济账：为什么是“每瓦 Token”
传统数据中心的成本按“机柜、服务器、带宽”计；AI 工厂的产出按 Token 计。把黄仁勋 2026 年的那句话写成一个式子，就是：
> 【图示】AI 工厂的经济账（本书对黄仁勋表述的归纳）：收入约等于可用电力乘以每瓦的 Token 吞吐量，再乘以每个 Token 的价格。电力是硬约束，所以每瓦能产出多少 Token，直接决定收入上限。
**图 12-3** AI 工厂收入的上限，由三个因子相乘决定。这是本书对黄仁勋表述的归纳，用来理解结构，不是财务模型。
三个因子里，**电力最难改变**：一座数据中心能拿到多少兆瓦，取决于电网和园区，往往要提前好几年规划。于是能拉动的只剩后两个：每瓦能产出多少 Token，以及每个 Token 卖多少钱。前者正是第 9 到 11 章讨论的全部内容——GPU 的能效、NVLink 的带宽、网络会不会让 GPU 空等、推理软件能不能把批处理做满（第 6 章的“公交车”）。
NVIDIA 给 GB300 NVL72 的宣传数字，正好可以套进这个式子来读：与 Hopper 一代的平台相比，**每位用户每秒拿到的 Token**（响应速度）提升 10 倍，**每兆瓦每秒产出的 Token**（吞吐）提升 5 倍，两者相乘，NVIDIA 称之为“AI 工厂产出”提升 50 倍。前一项关乎 Token 的“质量”，即用户等得久不久（第 6 章）；后一项就是“每瓦 Token”。这些是厂商口径，比较条件以 NVIDIA 原页为准，但它说明了一件事：**厂商自己也已经在用“工厂产出”而不是“芯片算力”来描述产品了**。
类比：
这像一座**水电站**：水量（电力）是老天给的，你能决定的是涡轮机的效率（每瓦 Token）和电卖给谁（每个 Token 的价格）。在水量固定时，换一台效率高一倍的涡轮机，发电收入就翻一倍，哪怕它贵一些。黄仁勋说“选错架构省下的芯片钱不划算”，就是这个道理。
类比的边界：涡轮机的效率是物理定值；AI 工厂的“每瓦 Token”还取决于模型、批大小和延迟要求，同一台机器跑不同负载，差别可以很大。
**停一下：如果“每瓦 Token”越高越好，为什么不把批处理开到最大，让每块 GPU 一次服务几千人？**
**参考答案：**
因为 Token 也有“质量”：用户要的是快速、流畅的回答。批越大，总吞吐越高，但每个人等的首 Token 延迟和 Token 间延迟也越长（第 6 章）。所以真正的优化目标是“在满足延迟要求的前提下，每瓦 Token 最多”。这条吞吐与延迟的取舍曲线，是推理工厂调优的核心。
### 12.4 为什么企业要建自己的 AI 工厂
云上可以租到 GPU 和模型 API，为什么企业还要自建？NVIDIA 白皮书给出的理由可以归成三条：
1. **Token 需求在暴涨。**企业 AI 正从试验走向生产；推理模型在规划和评估时消耗更多 Token，自主 Agent 持续地检索上下文、调用工具、执行流程（第 5、8 章）。
2. **最有价值的场景离不开私有数据。**许多高价值用例依赖企业专有数据，需要直接掌控安全、治理、延迟和成本。
3. **不是替代云，而是互补。**当需要弹性、前沿服务或地理覆盖时，企业 AI 工厂也可以与云资源集成。
#### 为什么难
白皮书用了一整节讲“为什么企业 AI 工厂很难”。几处原话值得记住：
- “工作负载策略和基础设施策略必须一起解决。”选哪些 AI 项目、数据是否可用、算力多大、跑在哪里、计算网络存储软件安全运维怎样匹配，每个决定都牵动其他决定。
- “当网络喂不饱 GPU、存储路径撑不住检索或检查点流量、软件栈不适合客户的运维模式时，工期就会延误。”
- “许多数据中心的单机柜功率仍低于 20 kW，而且很多没有液冷条件。”对比第 9 章：一个 GB200 NVL72 机柜约 120 kW。这道物理门槛，决定了一家企业能选哪一类 AI 工厂（第 13 章的三个家族）。
- 企业的负载是混合的：推理、微调、RAG、Agent、视觉计算、仿真、分析同时在跑；还有预算、指定工具、安全策略和存量基础设施，AI 工厂必须与它们共存，而不是推倒重来。
> 目标不是一个理论上的理想设计，而是一个适合现有机房、适合工作负载、也适合商业论证的设计。
>
> —— NVIDIA 企业参考架构白皮书（本书译）
表 12-1 传统数据中心与 AI 工厂
| | 传统企业数据中心 | AI 工厂 |
| --- | --- | --- |
| 主要任务 | 运行大量互不相干的业务系统，存储与处理数据 | 围绕 AI 全生命周期，生产 Token |
| 衡量方式 | 可用性、容量、单位存储成本 | Token 吞吐量、每瓦 Token、每 Token 成本、作业完成时间 |
| 单机柜功率 | 许多仍低于 20 kW（白皮书） | 机柜级系统：GB200 NVL72 约 120 kW；GB300 NVL72 参考架构写整柜最高约 142 kW |
| 网络 | 以南北向为主，按流 ECMP 足够 | 独立的东西向后端网络，每块 GPU 400–800 Gb/s，追求尾部延迟 |
| 存储 | 事务与文件服务 | 万卡并发读数据集、突发写检查点、RAG 检索 |
| 设计方法 | 按业务逐台采购、逐步扩容 | 按参考架构的可扩展单元整体设计、成块扩展 |
### 12.5 把需求翻译成五个要素
用第一性原理想一想：要让大模型跑起来，物理上必须完成哪几件事？要**算**，要在 GPU 之间**传**，要把数据**喂**进来、把结果**存**下去，要有人**调度**谁在哪儿干活，还要能**看见**哪里出了问题；再往下是**电和散热**，再往外是贯穿一切的**安全**。
> 【图示】建成一个 AI 集群的关键要素：最底层是电力与散热；其上是五个要素：算力单元、网络、存储、软件栈与编排、管理与可观测性；安全贯穿所有层。每一层都可能成为整座工厂最慢的那一环。
**图 12-4** 建成一个 AI 集群的五个关键要素，加上电力散热的底座和贯穿各层的安全。任何一层都可能成为全厂的瓶颈。第 13 章会看到，NVIDIA 参考架构正是按这几层组织的。
表 12-2 训练工厂与推理工厂
| | 训练工厂 | 推理工厂 |
| --- | --- | --- |
| 产品 | 一个模型（参数文件） | 源源不断的 Token |
| 节奏 | 一次几周到几个月的大作业 | 7 × 24 小时，跟着用户流量起伏 |
| 最紧的瓶颈 | 后端网络、同步、故障恢复、检查点存储 | 显存与 KV 缓存、延迟、前端网络、弹性伸缩 |
| 衡量指标 | 作业完成时间、GPU 有效利用率 | 首 Token 延迟、每秒 Token 数、每个 Token 的成本 |
| 多数企业的现实 | 很少从头训练基座模型，更多是微调 | RAG、Agent、内部助手：需求增长最快的部分 |
**停一下：如果你负责为公司建一个 AI 平台，第一个要问的问题是什么？**
**参考答案：**
不是“买多少块 GPU”，而是“**跑什么工作负载**”：从头训练、微调、RAG 问答，还是 Agent？每秒要服务多少请求、上下文多长、数据能不能出公司、机房每柜能给多少千瓦？答案决定了选哪一类参考架构、要不要独立的东西向网络、存储要多快，以及安全要做到哪一层。先定负载与约束，再倒推架构——这正是白皮书说的“工作负载策略和基础设施策略一起解决”。
AI 工厂把*电*变成 *Token*，
速度由最慢的那一环决定。
##### 本章带走
AI 工厂是为 AI 全生命周期专门设计的全栈基础设施：输入电和数据，产出 Token，用 Token 吞吐量、每瓦 Token 与每 Token 成本来衡量。
- 三份权威表述：NVIDIA 术语表（全生命周期、产品是智能、以 Token 吞吐量衡量）、企业 AI 工厂白皮书（全栈平台、适应真实机房约束）、黄仁勋（注入能量，产出 Token）。
- 黄仁勋的工厂论两年三步：通用计算到头 → 数据中心变工厂、产品是 Token → 每瓦吞吐就是收入。工程判断可检验，商业主张需自证。
- 企业自建的理由是 Token 需求、私有数据与可控性；难点是负载与基础设施要一起设计，以及“许多机柜仍低于 20 kW”的物理门槛。
**于是，下一个问题**：定义和原则有了。可是真要动手建，第一台服务器该怎么配、几台算一个单元、网络怎么连、存储要多快？有没有一份现成的“建厂图纸”？
---
# 第 13 章 建厂图纸：NVIDIA 企业参考架构
> 本章问题：一座企业 AI 工厂该怎样配置、怎样扩展、怎样验证？
> 来源：https://llm.weiborao.link/#ch13
**上一章留下的问题：**定义和原则有了。可是真要动手建，第一台服务器该怎么配、几台算一个单元、网络怎么连、存储要多快？有没有一份现成的“建厂图纸”？
有。NVIDIA 为企业 AI 工厂发布了一套**参考架构**（Reference Architecture，简称 RA；面向企业的这一套常称 Enterprise RA）。本章不急着看具体型号，而是先学会“读图纸”：它为什么存在、分几层、用什么代号、按什么单元扩展、网络怎样分工。学会这套语言，第 14 章拆开一份真实的图纸时，每个数字都会有来处。
### 13.1 为什么需要图纸
第 12 章的白皮书说，企业 AI 工厂难在“每个决定都牵动其他决定”。参考架构的作用，就是把这些反复出现的决定提前做好、测好。白皮书写道：
> 这些参考架构建立在 NVIDIA 数十年加速计算经验之上，包括从超大规模云、超级计算、企业 AI 部署以及 NVIDIA 自己的 AI 工厂中学到的教训。……小的基础设施选择在规模化时可能变成大问题，比如线缆和光模块的选择会影响散热、交付周期和客户体验。系统平衡同样重要：CPU、GPU、存储和网络的配比，在几个节点或单一负载时看起来没问题，但不平衡的设计会在集群扩展时限制分布式推理、降低利用率或造成运维瓶颈。
>
> —— NVIDIA 企业参考架构白皮书（本书译）
类比：
参考架构像建筑行业的**标准图集**加**预制装配式构件**。你不必为每栋楼重新计算梁柱，而是从经过验证的户型和构件里选；施工队（合作伙伴）照图集施工，监理（设计评审）按图集验收。图集不替你决定盖几层、住几户，但能保证照着盖不会塌。
### 13.2 三个层级，四步上市
> 【图示】NVIDIA 参考架构体系：三个层级——NVIDIA 认证系统定义单台服务器，参考架构定义服务器怎样组成集群，软件参考设计与验证设计定义在上面跑什么；以及四步上市流程——自研验证、形成文档、设计评审委员会背书、由合作伙伴规模化交付。
**图 13-1** NVIDIA 参考架构的体系。认证系统管“一台服务器”，参考架构管“怎样组成集群”，软件参考设计管“上面跑什么”；合作伙伴的设计经过设计评审委员会（DRB）背书后公开发布。
白皮书把参考架构的上市过程概括为四步：**自研**（NVIDIA 先用 DGX 系统和自家 AI 工厂的经验验证系统、集群和软件的部署模式）、**成文**（写成三个层级的文档）、**背书**和**规模化**。其中“背书”这一步最值得企业留意：合作伙伴（服务器厂商）用 NVIDIA 认证节点和 RA 模式设计自己的集群方案，交给由 NVIDIA 工程师主导的**设计评审委员会**（Design Review Board，DRB）审查；通过的方案会公开在 NVIDIA 网站上，客户可以查到它用的是哪种配置、支持多大规模、拿到了哪些类别的背书。
表 13-1 设计评审委员会的背书类别
| 背书类别 | 要求 | 含义 |
| --- | --- | --- |
| 基础设施配置 | 必需（基线） | 系统与集群设计遵循对应的 RA 基础设施模式 |
| Spectrum-X 兼容 | 推荐（附加） | 东西向网络设计符合 AI 东西向网络的要求 |
| 网络逻辑架构 | 推荐（附加） | 南北向与东西向网络在对应规模下的逻辑拓扑经过审查 |
另据 NVIDIA 参考架构文档页，背书的最低条件包括：节点通过对应参考配置的 NVIDIA 认证；网络设计与拓扑符合 RA 设计点；服务器物料清单经 NVIDIA 审核；最大规模下的集群物料清单经 NVIDIA 审核。
### 13.3 读懂代号：C-G-N-B
翻开任何一份企业参考架构，最先看到的是一串像“2-8-9-800”的数字。它叫**参考配置**（reference configuration），描述一台服务器（节点）的“形状”。白皮书的定义是：四个字段依次表示**CPU 插槽数、GPU 数、网卡数、每块 GPU 的平均东西向网络带宽**（Gb/s）。
> 【图示】读懂参考配置代号 C-G-N-B：以 2-8-9-800 为例，2 表示每台服务器 2 个 CPU 插槽，8 表示 8 块 GPU，9 表示 9 块网卡（8 块东西向、1 块南北向），800 表示每块 GPU 平均 800 Gb/s 的东西向带宽。
**图 13-2** “2-8-9-800”的读法。一串数字就把节点的计算力、网卡配置和东西向带宽说清楚了，也让不同厂商的服务器可以在同一把尺子上比较。
表 13-2 常见参考配置（节选）
| 代号 | 家族 | 网卡构成 | 东西向带宽 / GPU | 典型 GPU |
| --- | --- | --- | --- | --- |
| 2-8-5-200 | RTX PRO | 1 南北向 + 4 东西向 | 200 Gb/s | RTX PRO 6000 / 4500 Blackwell 服务器版 |
| 2-4-3-200 | RTX PRO | 1 南北向 + 2 东西向 | 200 Gb/s | 同上 |
| 2-X-1-NA | RTX PRO | 仅 1 南北向 | 不适用 | 同上（每台 2、4 或 8 块） |
| 2-8-9-400 | HGX | 1 南北向 + 8 东西向 | 400 Gb/s | HGX H100 / H200 / B200 |
| 2-8-9-800 | HGX | 1 南北向 + 8 东西向 | 800 Gb/s | HGX B300 |
| 2-4-5-800 | NVL72（每个托盘） | 1 南北向 + 4 东西向 | 800 Gb/s | GB300 NVL72 |
来源：NVIDIA 企业参考架构白皮书表 2 与 HGX H100/H200/B200 参考架构。白皮书注明这只是部分配置的示例。
**停一下：HGX 节点为什么是“9 块网卡”，而不是 1 块大带宽网卡？**
**参考答案：**
因为 8 块 GPU 各配 1 块东西向网卡，正好 1:1，再加 1 块负责南北向的 DPU。1:1 的好处是：每块 GPU 通过自己附近的 PCIe 通道直接连到“自己的”网卡，用 GPUDirect RDMA 直接收发，不必和其他 GPU 抢一条路；同时每块网卡接到一条独立的“轨道”上（第 14 章）。HGX 参考架构的原话是：推荐合作伙伴按 1:1 的 GPU 与网卡比例来配置。
### 13.4 三个家族：按机房条件和负载来选
白皮书把企业 AI 工厂分成三个家族。它们不是“好、更好、最好”，而是对应不同的机房条件和负载。
表 13-3 企业 AI 工厂的三个家族
| | RTX PRO AI 工厂 | HGX AI 工厂 | NVL72 AI 工厂 |
| --- | --- | --- | --- |
| 基础 | RTX PRO 服务器（PCIe GPU） | 8 卡 HGX 服务器（当前一代为 HGX B300） | GB300 NVL72 机柜 |
| 机房条件 | 风冷、PCIe，适合空间、电力、散热受限的机房 | 高密度，风冷版本可用（H100/H200/B200 参考架构即为风冷外形） | 机柜级供电与先进散热是前提 |
| 擅长 | 生成式与 Agent 推理、视觉计算、数字孪生、数据分析 | 大模型训练与微调、大规模分布式推理、HPC | 万亿参数训练、超大混合专家模型、大规模实时推理 |
| 可扩展单元 | 4 台 | 4 台 | 1 个机柜（18 个托盘） |
| 规模范围 | 4–32 台，最多 256 GPU | 4–128 台，最多 1,024 GPU | 1–8 柜，72–576 GPU |
| 厂商口径的性能 | — | HGX B300 的 Token 吞吐量是 HGX H100 的 15 倍 | “AI 工厂产出”提升 50 倍 |
“15 倍”“50 倍”为 NVIDIA 白皮书原文中的厂商口径，比较条件以 NVIDIA 原始资料为准。
白皮书强调：实际部署可以组合多个家族，用不同配置承载不同负载。比如用 RTX PRO 承担大量单卡推理和视觉任务，用 HGX 承担微调和多机推理。选择的第一道门槛往往不是预算，而是第 12 章说的**每柜千瓦数和有没有液冷**。
上面是白皮书的概览。三个家族各有一份独立的参考架构文档，下面逐一打开，看它们在节点、网络、散热和适用负载上的具体差别。
> 【图示】三个家族的一个可扩展单元对比。RTX PRO：4 台 8 卡 PCIe 服务器，每台 4 块 400G SuperNIC，两块 GPU 共享一块，平均每 GPU 200 Gb/s，风冷。HGX B300：4 台 8 卡服务器，GPU 经 NVLink 全互联，每块 GPU 一块 800G SuperNIC，风冷。NVL72：一个液冷机柜，18 个托盘共 72 块 GPU 组成一个 NVLink 域，每块 GPU 800G 东西向，整柜最高 142 kW。
**图 13-3** 三个家族的一个可扩展单元。RTX PRO 和 HGX 都是“4 台 8 卡服务器”，差别在 GPU 之间怎么连、每块 GPU 配多少网络带宽；NVL72 则把 72 块 GPU 装进一个液冷机柜，用 NVLink 连成一个整体。
#### RTX PRO AI 工厂：2-8-5-200，给“现有机房”的方案
它的参考架构以 NVIDIA 认证的 RTX PRO 服务器为节点，每台 8 块 **RTX PRO 6000 Blackwell 服务器版** GPU。这是一块 PCIe 卡：每块 96 GB GDDR7 显存、最高 1.6 TB/s 带宽，8 卡合计 768 GB。文档的定位很明确：适合“需要风冷、高能效平台的企业数据中心”。
- **网卡是 2:1**：每台只有 4 块 400G 东西向 SuperNIC，两块 GPU 共享一块，所以平均每块 GPU 200 Gb/s，这就是代号里的“5”和“200”。文档建议合作伙伴按“最多 2:1”的 GPU 与网卡比例来配；如果做微调、图像和视频生成这类更吃东西向带宽的负载，建议提高到每 GPU 400 Gb/s。
- **CPU 和内存按 GPU 数来算**：每块 GPU 至少 7 个 CPU 物理核（用 MIG 切分时每个实例另需 2 核，跑 Spark 数据处理每 GPU 再加 1 核），每块 GPU 至少 128 GB 系统内存。
- **规模与网络**：设计点是 16 台（128 GPU）和 32 台（256 GPU）。16 台时，东西向和南北向合并成一张“压缩的叶脊网”以降低成本；超过 4 个单元后，东西向改为独立网络。一个单元的东西向接入是 4 台 × 4 × 400G = 16 个端口，共 6.4 Tb/s，是 HGX 单元的一半。
- **适合的负载**：Agent 推理（中小模型）、工业与物理 AI（数字孪生、视频分析、合成数据）、视觉计算与渲染、FP32 及以下精度的仿真与数据分析，以及虚拟工作站。
#### HGX AI 工厂：2-8-9-800，给“AI 重度用户”的方案
当前一代的 HGX 参考架构基于 **HGX B300**：每台 8 块 Blackwell Ultra GPU，每块 288 GB HBM3e，8 卡合计约 2.3 TB；机内第五代 NVLink 的总带宽 14.4 TB/s。它仍然是风冷外形。与第 14 章要拆的 H100/H200/B200 版相比，有三处关键变化：
- **网卡上了基板**：8 块 ConnectX-8 SuperNIC 直接集成在 HGX B300 基板上，仍保持 GPU 与网卡 1:1，每块 GPU 对外 800 Gb/s（2 × 400G）。
- **南北向升级**：推荐用 400G 的 BlueField-3 B3240 替代 B200 及以前常见的 2 × 200G 的 B3220。文档给出的理由很有前瞻性：未来的分布式推理可能把 KV 缓存卸载到高速网络存储上（第 6 章讲过 KV 缓存有多占显存），这时每块 GPU 需要更高的突发 I/O 能力。
- **双平面成为推荐**：每块 GPU 的 800G 拆成两个 400G 口，分别接到两张完全独立的东西向网络（13.5 节详述）；也支持只用一个 400G 口的单平面，作为降低网络成本的选项。这正是第 14 章 Cisco 方案表里“2-8-9-800 与 2-8-9-400”并列的原因：前者是双平面，后者是单平面。
文档说，B300 单块 GPU 大约能装下 1200 亿参数的模型，更大的模型仍可在一台服务器内用 NVLink 做模型并行，所以纯推理同样可以不建东西向计算网。
#### NVL72 AI 工厂：2-4-5-800，“一柜即一机”
NVL72 的参考架构基于 **GB300 NVL72**。它的基本单位不是服务器，而是一个机柜：
- **18 个计算托盘**，每个托盘 2 颗 Grace CPU（共 72 个 Arm 核、1 TB LPDDR5 内存）和 4 块 Blackwell Ultra GPU；一柜共 36 颗 CPU、72 块 GPU。每个托盘带 4 块 ConnectX-8 做东西向（与 GPU 1:1，每块 800 Gb/s）、1 块 BlueField-3 B3240 做南北向。
- **9 个 NVLink 交换托盘**，每个装 2 颗 NVSwitch 芯片。每块 GPU 有 18 条第五代 NVLink，经铜背板分别接到柜内每一颗 NVSwitch，于是 72 块 GPU 组成一个全互联的 NVLink 域，总带宽 130 TB/s。文档的说法是：这让 72 块 GPU 可以“作为一个多 GPU 计算单元”工作。NVIDIA 官网列出整柜“高速内存”37 TB，它是 20 TB GPU 显存与 17 TB CPU 内存（LPDDR5X）之和，两者速度差别很大，不宜理解为同质的一整块内存。
- **电力与散热**：液冷；8 个 33 kW 的电源架；**整柜最高约 142 kW**；托盘级和机柜级都有漏液检测。对照第 12 章白皮书说的“许多机柜仍低于 20 kW”，这道门槛的高度一目了然。
- **规模**：1 柜起步，按柜扩展，经过完整测试的规模是 8 柜（576 GPU）；东西向始终是双平面。管理面假设 12 台控制节点，并“强烈建议”用 NVIDIA Mission Control 来运营。
文档还给了一个直观的尺度：按 FP4 量化，超过约 1.92 万亿参数的模型，才需要跨出**单个托盘**（4 块 GPU），借助柜内的 NVLink 和 NVSwitch 做模型并行。粗算一下就能理解：1.92 万亿参数 × 每参数 0.5 字节 ≈ 960 GB，正好放得进一个托盘约 1.15 TB 的显存。作为对比，H100/H200/B200 版参考架构给出的单卡上限约 130 亿参数；两份文档的口径、精度和计量单位（单卡与单托盘）都不同，只能看量级。
表 13-4 三份参考架构的关键参数对照
| | RTX PRO | HGX B300 | GB300 NVL72 |
| --- | --- | --- | --- |
| 节点代号 | 2-8-5-200 | 2-8-9-800 | 2-4-5-800（每托盘） |
| GPU / 节点 | 8 × RTX PRO 6000（PCIe） | 8 × B300（SXM） | 4 × Blackwell Ultra |
| 每 GPU 显存 | 96 GB GDDR7 | 288 GB HBM3e | 最高 288 GB |
| GPU 之间 | PCIe | 机内 NVLink，14.4 TB/s | 整柜 NVLink 域，130 TB/s |
| 东西向网卡 | 4 × 400G（2 GPU 共享 1 块） | 8 × ConnectX-8（1:1） | 4 × ConnectX-8（1:1） |
| 南北向 | BlueField-3 B3220（2 × 200G） | BlueField-3 B3240（400G） | BlueField-3 B3240（400G） |
| 一个单元的东西向带宽 | 6.4 Tb/s（4 台） | 25.6 Tb/s（4 台，双平面） | 57.6 Tb/s（1 柜） |
| 文档给出的模型规模上限 | 单卡约 400 亿（FP16）；另一处写约 700 亿 | 单卡约 1200 亿 | 单托盘（4 卡）约 1.92 万亿（FP4） |
| 散热 | 风冷 | 风冷 | 液冷，整柜最高约 142 kW |
| 测试规模 | 16、32 台 | 32、64、128 台 | 1–8 柜 |
来源：NVIDIA RTX PRO AI Factory、HGX AI Factory（B300）、NVL72 AI Factory 三份企业参考架构。“一个单元的东西向带宽”由文档给出的网卡数与速率相乘得到（本书计算）。RTX PRO 文档对单 GPU 模型上限有两处写法，大致分别对应 FP16 与 8 位精度；NVL72 文档对托盘显存也有两处写法（4 卡合计 1,152 GB 与 720 GB），本表取与 Blackwell Ultra 规格一致的前者。
**停一下：一家机房每柜只能供 15 kW、没有液冷的企业，想做大量 Agent 推理和少量微调，应该看哪个家族？**
**参考答案：**
先看 RTX PRO：PCIe、风冷，Agent 推理正是它的主场；如果微调对东西向带宽要求更高，可以按文档建议把每 GPU 带宽从 200 提到 400 Gb/s。HGX 也是风冷外形，但一台 8 卡 HGX 服务器的功耗远高于 PCIe 服务器，每柜能放几台要按实际供电来算（参考架构的原话是“每柜服务器数量取决于可用的机柜功率”）。NVL72 需要液冷和每柜一百多千瓦，这家企业的机房目前上不了。当然，具体选型还要用自己的负载做容量测算。
### 13.5 可扩展单元：工厂按“块”长大
参考架构里最重要的一个概念，叫**可扩展单元**（Scalable Unit，SU）。白皮书专门强调：
> SU 不是随意的节点数量。它是一个增量单位，集群拓扑、东西向网络、电力、散热、机柜布局和部署规划都围绕它来组织。
>
> —— NVIDIA 企业参考架构白皮书（本书译）
> 【图示】HGX AI 工厂的扩展路径：最小 1 个可扩展单元，即 4 台服务器、32 块 GPU；每次加 4 台。规模小时南北向和东西向可以共用一张网；到 16 台时建议拆成独立的南北向和东西向网络；独立后东西向可选单平面或双平面；更大规模采用叶脊架构，最大 32 个单元、128 台、1024 块 GPU。
**图 13-4** HGX AI 工厂的扩展路径（横轴按 2 倍刻度）。最小 1 个 SU（4 台、32 GPU），每次加 4 台，最大 32 个 SU（128 台、1,024 GPU）。规模越大，网络越专门化。
扩展时，网络拓扑会跟着“换挡”：
- **小规模**：南北向和东西向可以合并在同一张物理网上（RTX PRO 家族最多到 16 台都可以合并）。
- **16 台起**：HGX 参考架构建议拆成独立的南北向网和东西向网，让 GPU 计算流量与客户、存储、管理流量各走各的路。
- **拆开之后**：东西向网可选**单平面**（部署简单）或**双平面**（更高的韧性和路径多样性）。
- **大规模**：南北向和东西向都采用叶脊（spine-leaf）结构；NVL72 则始终使用独立网络和双平面东西向网，不提供合并或单平面选项。
**双平面是怎么回事？**B300 和 NVL72 的参考架构解释得很清楚：每块 GPU 的 800G 网卡口被拆成两个 400G 口，分别接到两台属于**两张完全独立网络**的叶交换机上。GPU 并不知道有两张网，它只看到自己的网卡把 100% 的流量送了出去；每张网各承担一半，跟踪、负载均衡和故障切换由 SuperNIC 在硬件上完成，NCCL 也参与两个平面之间的均衡。一张网坏了，流量自动走另一张，性能按损失的带宽线性下降，而不是整体中断。文档特别指出，这种由端点负责的均衡比链路聚合（LAG）或静态哈希更适合 AI 流量，原因正是第 11 章讲过的“熵低”。双平面的另一个好处是：每个口的速率减半、口数翻倍，同样的交换机能接更多端点，网络可以少一层。
类比：
这像城市道路的演进：小镇上，货车和私家车走同一条街没问题；城市变大后，就得修专门的货运通道（东西向）和客运干道（南北向）；再大，货运通道还要修成双向分离、互为备份的两套（双平面）。
### 13.6 网络：五类流量，各有通道
第 11 章讲过三张网。参考架构把流量分得更细，按用途分成五类：
> 【图示】参考架构里一台 HGX 服务器的五类流量与每块 GPU 的带宽配额（2-8-9-400，32 节点设计）：东西向计算网每块 GPU 400 Gb/s；面向客户网络至少 25 Gb/s；存储至少 12.5 Gb/s；另有管理与支撑服务网络，以及 1 Gb/s 的带外管理网。
**图 13-5** 一台 HGX 服务器的五类流量与每块 GPU 的带宽配额（数字来自 HGX H100/H200/B200 参考架构的 32 节点设计）。东西向、客户、存储三者之比约为 32 : 2 : 1。
1. **东西向（计算）**：节点之间 GPU 与 GPU 的流量，分布式训练、微调和分布式推理的命脉，要高带宽、低延迟，并随 GPU 数量同步扩展。
2. **存储**：数据摄取、检索、检查点和结果输出的数据通路，要按负载来配，不能让数据搬运拖累 GPU 利用率。
3. **客户上行**：把 AI 工厂接到企业的应用、用户和上下游系统，按推理流量、数据流和安全边界来设计。
4. **管理与支撑服务**：部署、监控、编排和生命周期管理，要和高性能数据通路分开，以免计算流量增长时运维受影响。
5. **带外管理**：服务器、网卡和交换机的管理口，物理上与用户隔离。
目前的企业参考架构基于以太网：Spectrum-X 以太网平台、Spectrum 交换机、ConnectX SuperNIC 和 BlueField-3 DPU；白皮书说未来也可能加入 Quantum InfiniBand 选项。南北向推荐使用 **BlueField-3 DPU**——一种自带 Arm 处理器的网卡，可以把安全（零信任、微隔离、防火墙）、存储加速和基础设施管理从主机 CPU 上卸载下来，并且独立于主机运行。
### 13.7 存储、软件与服务
**存储。**白皮书把数据称为“AI 工厂的燃料”，它要贯穿从建模、训练、微调到推理的每个阶段，而每个阶段的存储需求都不同。参考架构为存储预留了专门的网络接入点，并通过 **NVIDIA 认证存储**计划验证合作伙伴的存储系统：不仅测峰值性能，还测不同负载模式、压力下的表现，以及与认证服务器、NVIDIA 网络和日常运维方式的配合。HGX H100/H200/B200 参考架构给出的经验值是**每块 GPU 约 12.5 Gb/s 的存储带宽**，随集群线性增长，例如 16 块 GPU 约需 200 Gb/s 的总存储带宽。
**注意：是 12.5 Gb/s（比特），不是 12.5 GB/s（字节）** 这个数字很容易被看成字节，因为存储厂商习惯用 GB/s 报吞吐。可以用三处原文交叉验证它是比特：第一，文档的例子“16 块 GPU 约需 200 Gb/s”，16 × 12.5 = 200，单位是 Gb/s；第二，32 节点设计为 256 块 GPU 配了 32 条 100G 存储链路，32 × 100 Gb/s ÷ 256 = 12.5 Gb/s；第三，每台服务器的南北向只有两个 200G 口，文档写存储吞吐“每节点最高约 40 GB/s”，如果每块 GPU 要 12.5 GB/s，8 块就是 100 GB/s，物理上接不进来。换算成字节，**每块 GPU 约 1.56 GB/s，每台 8 卡服务器约 12.5 GB/s**——“12.5 GB/s”这个数字确实存在，但它是每台服务器，不是每块 GPU。还要记住，这是参考架构为存储网络预留的**基线配额**，不是存储系统的性能上限；需要频繁写检查点或做 KV 缓存卸载的场景，可能要更高（B300 参考架构就以“未来的 KV 缓存卸载需要更高突发 I/O”为理由，推荐把南北向 DPU 升级到 400G）。
**软件。**参考架构配有部署软件栈的配套指南，把裸机集群接到编排、NVIDIA AI Enterprise 软件、可观测性、负载容量规划和运维实践上。主要组件包括：
- **编排**：支持 Kubernetes 和 Slurm；HGX 参考架构明确说“Kubernetes 是现代企业 AI 工作的基础”，整套设计按部署 Kubernetes 及其上的应用来构建。
- **NVIDIA AI Enterprise**：按每 GPU 订阅的企业软件套件，包含 AI 开发所需的微服务、框架和库，以及 GPU 编排与基础设施管理。
- **Run:ai**：按策略动态分配 GPU，把一块卡切给多个推理模型共享，提高利用率（第 10 章）。
- **Base Command Manager**：裸机集群的部署与管理工具；**NetQ**：实时观察、排查和验证网络；**可观测性指南**：用 Prometheus、Grafana 等开源工具监控 GPU、网络和应用。
- **上层参考设计**：企业 RAG 部署与容量规划指南、AI-Q 研究型 Agent 蓝图、安全的 Agent 工作空间、机密计算部署等。
**服务。**参考架构文档还单列了服务：路线图规划、首个项目实施、托管运维、技术支持和培训。图纸画得再好，也需要有人施工、验收和长期运维。
### 13.8 图纸的边界
##### 企业参考架构适合
- 本地或混合部署的单租户企业集群，32 到 1,024 块 GPU
- 微调、RAG、推理、模型训练和小规模 HPC 的混合负载
- 希望用经过验证、可支持、可复制的方式起步并按块扩展
##### 它不负责
- 替你决定工作负载与规模（那是第 12 章的“第一个问题”）
- 多租户云服务商或万卡以上的前沿训练（另有面向云合作伙伴的参考架构，企业版正是由它“按企业规模裁剪”而来）
- 保证厂商口径的性能在你的业务上原样复现
白皮书总结参考架构的价值时，列了业务和 IT 两组收益：更快的见效时间、更高的资源与成本效率（“改善 Token 经济”）、更低的风险；性能、可支持性、可扩展与可管理性、更低的复杂度与总拥有成本。归根到底一句话：**把从零设计变成从已验证的模式出发**。
##### 本章带走
企业参考架构是 AI 工厂的“标准图集”：认证节点 + 集群设计 + 软件设计三层，经设计评审委员会背书后由合作伙伴交付。
- C-G-N-B 代号：CPU 插槽-GPU 数-网卡数-每 GPU 东西向带宽，如 2-8-9-800。
- 三个家族：RTX PRO（PCIe、风冷、推理与视觉）、HGX（8 卡高密度、训练与分布式推理）、NVL72（机柜级、前沿规模）。
- 可扩展单元：RTX PRO 与 HGX 为 4 台，NVL72 为 1 柜；规模越大，网络从合并走向独立、单平面走向双平面。
- 五类流量分通道；存储按每 GPU 约 12.5 Gb/s 起步；软件以 Kubernetes、AI Enterprise、Run:ai 为核心。
**于是，下一个问题**：学会了读图纸，就拿一份真实的图纸来拆：一座 HGX AI 工厂，从一台服务器、一个 4 台的单元，到 128 台、1,024 块 GPU，每一根线、每一台交换机是怎样安排的？
---
# 第 14 章 拆开一座 HGX AI 工厂
> 本章问题：从一台服务器到 1,024 块 GPU，一座 AI 工厂的每一层是怎样设计的？
> 来源：https://llm.weiborao.link/#ch14
**上一章留下的问题：**学会了读图纸，就拿一份真实的图纸来拆：一座 HGX AI 工厂，从一台服务器、一个 4 台的单元，到 128 台、1,024 块 GPU，每一根线、每一台交换机是怎样安排的？
本章拆的图纸是 NVIDIA 公开的《HGX AI Factory（HGX H100、H200、B200）》企业参考架构。它的摘要只有一句话，却浓缩了整章的内容：
> 本参考架构是 NVIDIA HGX AI 工厂的实用设计指南，基于 2-8-9-400 基础设施配置（2 颗 CPU、8 块 GPU、9 块网卡、每块 GPU 400 Gb/s 带宽），采用每节点 8 块 GPU 的 HGX H100、H200 或 B200 服务器，配合 ConnectX SuperNIC、BlueField-3 DPU 与 Spectrum-X 以太网，覆盖 32、64、128 节点的设计点。
>
> —— NVIDIA HGX AI Factory 参考架构摘要（本书译）
我们按“由小到大”的顺序拆：一台服务器 → 两种网卡 → 一个 4 台的单元 → 128 台的集群 → 三张物理网与控制面 → 一个常被问到的问题（纯推理要不要建计算网）→ Cisco 的版本。读完后，第 9 到 11 章的 GPU、NVLink、RDMA、轨道和叶脊，会在一张图纸上各就各位。
### 14.1 一台服务器：2-8-9-400
> 【图示】一台 2-8-9-400 HGX 服务器的构成：8 块 SXM GPU 装在同一块 HGX 基板上，经 NVLink 与 NVSwitch 互联；每块 GPU 配一块 400G 的 BlueField-3 SuperNIC，接入东西向计算网的第 1 到第 8 条轨道；两颗 CPU 带至少 1.5 TB 内存；一块双口 200G 的 BlueField-3 DPU 负责南北向；BMC 接 1G 带外管理网；本地 NVMe 存储。
**图 14-1** 一台 2-8-9-400 服务器。8 块 GPU 在机内经 NVSwitch 全互联（第 10 章的“第一级高速公路”）；每块 GPU 配一块 400G SuperNIC，各自接到一条“轨道”上（第二级高速公路）；南北向流量走单独的 DPU。
表 14-1 三代 HGX 的 GPU 与节点规格（参考架构表 1、表 2）
| | H100 SXM | H200 SXM | B200 SXM |
| --- | --- | --- | --- |
| 每块 GPU 显存 | 80 GB HBM3 | 141 GB HBM3e | 180 GB HBM3e |
| 每台（8 卡）显存 | 640 GB | 约 1.1 TB | 1.44 TB |
| 每块 GPU 显存带宽 | 3.35 TB/s | 4.8 TB/s | 最高 8 TB/s |
| 每台显存总带宽 | 26.8 TB/s | 38.4 TB/s | 最高 64 TB/s |
| GPU 间 NVLink 带宽 | 900 GB/s | 900 GB/s | 1,800 GB/s |
| NVSwitch 总带宽 | 7.2 TB/s | 7.2 TB/s | 14.4 TB/s |
NVLink 带宽为 NVIDIA 常用的双向口径（收发合计），NVL72 参考架构写作“900 GB/s（双向 1,800 GB/s）”。参考架构另称 HGX H100/H200 基板提供 32 PFLOPS、HGX B200 基板提供 144 PFLOPS 的 AI 算力，B200 每块 GPU 功耗可配置到 1 kW；这些为厂商口径，精度与稀疏条件以 NVIDIA 规格页为准。
GPU 之外，参考架构对服务器的其余部分也有明确要求。它们看起来琐碎，却都对应着第 9 到 11 章里的某个瓶颈：
表 14-2 HGX 认证服务器的关键要求（节选）
| 部件 | 要求 | 为什么（对应章节） |
| --- | --- | --- |
| CPU | 至少 2 个插槽，基础频率 ≥ 2.1 GHz；每插槽至少 48 核，建议 56 核 | 数据预处理、调度和网络栈不能拖 GPU 后腿 |
| 系统内存 | 至少 1.5 TB，带宽至少 500 GB/s，各通道对称插满 | 加载模型、数据缓冲；不对称会让一颗 CPU 成为瓶颈 |
| PCIe | 每块 GPU、每块网卡各一条 Gen5 x16，均衡分布在两颗 CPU 的根端口 | GPUDirect RDMA 的短路径（第 10 章） |
| 东西向网卡 | 8 块 BlueField-3 SuperNIC，每块最高 400 Gb/s，GPU 与网卡 1:1 | 集合通信（第 10、11 章） |
| 南北向 | 1 块 BlueField-3 DPU | 存储、管理、客户接入与安全 |
| 本地存储 | 推理服务器每插槽 ≥ 1 TB NVMe；训练服务器每插槽 ≥ 2 TB；另加 1 TB 启动盘 | 数据缓存、检查点暂存 |
| 管理与安全 | BMC 带外管理；TPM 2.0 安全启动 | 可远程运维、可信启动 |
参考架构的“组件”一章写每插槽最少 48 核，“附录·节点配置”一章写最少 32 核，两处建议值均为 56 核；以对应版本文档为准。
### 14.2 两种网卡，两种分工：SuperNIC 与 DPU
一台服务器上有 9 块网卡，但它们不是同一种东西。
- **BlueField-3 B3140H SuperNIC（×8）**：单口 400 GbE，专门服务东西向计算网。它支持 RDMA/RoCE 加速和 GPUDirect，是 Spectrum-X 平台的端点：第 11 章讲的“交换机逐包喷洒、网卡把乱序整理回顺序”，就发生在这块卡上。
- **BlueField-3 B3220 DPU（×1）**：双口 200 GbE，服务南北向。参考架构列出了它的三项职责：**工作负载编排**（作为数据中心控制面的计算平台，实现自动部署与弹性）、**存储加速**（让远端存储像本地盘一样使用）、**安全基础设施**（以零信任模式独立于主机运行，提供防火墙与微隔离等安全服务）。它还内置 BMC，可以用 Redfish 等标准接口管理。
类比：
SuperNIC 像生产线之间的**专用传送带**，只管把半成品又快又准地送到下一道工序；DPU 像工厂大门口的**门卫兼收发室**：查证件、收发原料、记录进出，而且不归车间主任（主机 CPU）管，车间被攻破了，门卫照样能守住大门。
参考架构也允许变体：ConnectX-7 可用于各类网络；双口 400G 的 ConnectX-8 SuperNIC 可用于更高带宽的东西向网络，在只需要每卡 400G 时只启用一个口。
### 14.3 一个单元：4 台服务器与“轨道优化”
参考架构以 4 台服务器为一个可扩展单元（SU），并说 SU 的大小“取决于网络设备的端口数量”。一个 SU 提供的连接积木是：
**12.8 Tb/s**东西向：4 台 × 8 块 SuperNIC = 32 个 400G 连接
**1.6 Tb/s**南北向：4 台 × 1 块 DPU = 8 个 200G 连接
**48 × 1G**带外管理：每台 12 个 1G 管理口
东西向的连法叫**轨道优化**（rail-optimized）。所谓“轨道”，就是把所有服务器上同一个编号的 GPU 连到同一组叶交换机上：每台服务器的 1 号 GPU 都接到“轨道 1”，2 号都接到“轨道 2”，以此类推。
> 【图示】轨道优化的连接方式：一个可扩展单元有 4 台服务器，每台的第 k 块网卡都接到负责第 k 条轨道的叶交换机上。在 32 节点设计中，每个平面 4 台叶交换机，每台承载两条轨道：1 和 5、2 和 6、3 和 7、4 和 8。叶交换机再向上接到脊交换机。
**图 14-2** 轨道优化的接法（32 节点设计中，每个平面 4 台叶交换机，每台承载两条轨道：1+5、2+6、3+7、4+8）。为了清楚，只画了服务器 1 的连线；其余服务器按同样的编号规则接入。
问：为什么要按 GPU 编号来接，而不是把一台服务器的 8 根线都接到同一台交换机上？
答：因为分布式训练里最频繁的通信，往往发生在不同服务器上“同一位置”的 GPU 之间：比如张量并行把每层切成 8 份放在机内 8 块卡上，数据并行再在服务器之间同步，第 k 块卡要和别的服务器的第 k 块卡交换数据。按轨道接线，这些流量只经过一台叶交换机就到了。
问：那 1 号 GPU 要和另一台服务器的 2 号 GPU 通信呢？
答：先在机内经 NVLink 把数据交给本机的 2 号 GPU，再走轨道 2。机内的路按同一口径比网络快约 9 倍（第 10 章），这个“换道”很便宜。NCCL 知道这套拓扑，会自动这样安排。
参考架构对东西向网络的描述是：基于 Spectrum-X 交换机的**全无阻塞胖树**，支持 RDMA，“提供穿过网络的最短跳数”。无阻塞的意思是：叶交换机向上（到脊）的带宽不少于向下（到服务器）的带宽，任何两块 GPU 同时全速通信都不会在交换机里被卡住。这正是第 11 章说的“链路不能堵”在拓扑上的落实。
### 14.4 从 32 台到 128 台
参考架构发布了 32、64、128 台三个设计点，并给出了每个设计点需要的交换机、光模块和线缆数量。下表整理了其中最能说明“规模怎样增长”的数字：
表 14-3 HGX AI 工厂三个设计点的主要数量
| | 32 台 | 64 台 | 128 台 |
| --- | --- | --- | --- |
| GPU / 可扩展单元 | 256 / 8 SU | 512 / 16 SU | 1,024 / 32 SU |
| 东西向叶 / 脊交换机 | 4 / 2 | 8 / 4 | 16 / 8 |
| 东西向：服务器到叶交换机的连接 | 256 | 512 | 1,024 |
| 东西向：交换机之间的线缆 | 256 | 512 | 1,024 |
| 南北向融合网交换机（SN5600） | 2 | 2 | 10 |
| 带外管理交换机（SN2201） | 4 | 8 | 16 |
| 交换机间链路（ISL）用的 2×400G 光模块 | 274 | 544 | 1,408 |
来源：参考架构表 7（东西向计数）与附录表 10（交换机与线缆汇总）。东西向“服务器到叶交换机的连接”即 SuperNIC 数，等于 GPU 数。
这张表里藏着三个规律：
1. **东西向线缆与 GPU 一一对应**：每多一块 GPU，就多一根到叶交换机的线、多一根交换机之间的线。东西向网络的规模，和 GPU 数量同步增长。
2. **每块 GPU 的带宽配额差别很大**：东西向每块 GPU 400 Gb/s；32 节点设计中，客户网络至少 25 Gb/s、存储至少 12.5 Gb/s（第 13 章图 13-5），三者之比约 32 : 2 : 1。注意三个数字都是比特每秒：存储的 12.5 Gb/s 约合每块 GPU 1.56 GB/s、每台服务器 12.5 GB/s。
3. **光模块数量增长得比 GPU 快**：GPU 从 256 增加到 1,024（4 倍），交换机间光模块从 274 增加到 1,408（约 5 倍），因为更大的规模需要更多层级的交换。这就是白皮书说“线缆和光模块的选择会影响散热、交付周期和客户体验”的原因：在大集群里，光模块是不可忽视的成本和功耗项。
**停一下：128 台服务器的东西向网络有 16 台叶交换机和 8 台脊交换机。为什么不只用几台端口更多的大交换机？**
**参考答案：**
单台交换机的端口数是有限的（SN5600 是 64 个 800G 口，拆分后为 128 个 400G 口），1,024 块 GPU 的连接装不进一台。叶脊结构用“很多台中等交换机”拼出一张大网：任意两台服务器之间最多经过“叶—脊—叶”三跳，路径多、可以负载均衡，坏一台交换机只损失一部分带宽。代价是交换机之间要大量的线缆和光模块，正是表 14-3 最后一行的数字。
### 14.5 三张物理网与控制面
> 【图示】HGX AI 工厂的三张物理网与控制面：东西向计算网连接每台服务器的 8 块 SuperNIC；南北向融合网连接每台服务器的 DPU、控制面节点、存储、客户网络和支撑服务；带外管理网连接所有设备的 BMC 与管理口。三张网的交换机分别是 SN5600/SN5610 和 SN2201。
**图 14-3** 参考架构的三张物理网：东西向计算网、南北向融合网、带外管理网。融合网在一张物理网上用 VLAN 隔离出存储、带内管理、客户接入和支撑服务等多种用途。
- **东西向计算网**：只连 GPU 的 SuperNIC，轨道优化、无阻塞；参考架构说更大的设计点会采用“超级脊—脊—叶”三层结构。
- **南北向融合网**：每台计算节点和管理节点用两个 200GbE 端口分别接到两台交换机，既冗余又提供高存储吞吐，每台服务器最高可达约 40 GB/s；支持 RoCE；用于部署节点、搬运数据、访问互联网等用户可见的服务。
- **带外管理网**：连接所有服务器 BMC、DPU 和 SuperNIC 的管理口以及交换机管理口，用低成本的 1G 交换机，并与用户物理隔离。
除了计算节点，集群还需要**控制面节点**来做部署、调度和管理。参考架构举了一个例子：同时使用 Base Command Manager、Slurm 和 Kubernetes 时，共 7 台控制面节点——Base Command Manager 2 台（高可用）、Slurm 头节点 2 台、Kubernetes 控制面 3 台。每台控制面节点建议 2 颗 32 核 CPU、至少 256 GB 内存、一块 BlueField-3 DPU。这些服务器不跑模型，但它们停了，整座工厂就失去了“厂长”。
### 14.6 只做推理，要不要建计算网
这是企业最常问的问题之一。参考架构的回答是：**纯推理部署可以不建东西向计算网**。理由是，它所针对的常见模型能放进单块 GPU 或单台服务器，跨卡的并行仍在同一台服务器内（经 NVLink）完成；而且在推理中，用张量并行把一个模型拆到多块 GPU 上，每块 GPU 的效率往往不如让各块 GPU 各跑一个副本（数据并行）。文档同时指出了代价：没有计算网，就不能运行包括小模型训练在内的混合负载；但可以先不建，日后再补。
**读这条建议时要注意时间** 这份参考架构写道“每块 GPU 最多支持约 130 亿参数的模型”，这是一个保守的经验值（大致对应 BF16 权重加上推理所需的显存余量）。NVIDIA 后来的几份参考架构给出的单卡上限随硬件增长：RTX PRO 6000 约 400 亿（FP16），B300 约 1200 亿，GB300 NVL72 单托盘（4 卡）约 1.92 万亿（FP4）（第 13 章表 13-4）。今天企业常用的模型往往更大，但第 6、9 章的计算说明，即使是 4050 亿参数的模型，按 FP8 也能放进一台 8 卡服务器，所以“单机内完成推理、不需要计算网”的结论对多数场景仍然成立。例外是：超大的混合专家模型需要跨机的专家并行，或者采用把预填充与解码拆到不同机器上的分离式推理架构，这时跨节点的低延迟网络又变得重要（第 11 章）。（本段为本书的分析。）
### 14.7 Cisco 的版本：通过评审的设计与 Secure AI Factory
参考架构由服务器厂商落地。NVIDIA 在参考架构文档页公开了各厂商通过设计评审委员会的设计，Cisco 名下列出的方案包括：
表 14-4 NVIDIA 文档页列出的 Cisco 背书设计（截至资料日期）
| 方案 | 服务器 / GPU | 节点模式 | 规模（台） |
| --- | --- | --- | --- |
| Cisco AI POD Infrastructure for the NVIDIA 2-8-9-400 RA | UCS C885A M8 / HGX H200 | 2-8-9-400 | 4–16 |
| 基于 Cisco Nexus 的 Cisco 参考架构 | UCS C885A / HGX H200 | 2-8-9-400（调整为 2-8-10-400） | 4–128 |
| Cisco Nexus Hyperfabric AI 参考架构 | UCS C885A / HGX H200 | 2-8-9-400（调整为 2-8-10-400） | 4–128 |
| Cisco N9000 RA with NVIDIA HGX B300 | UCSC-880A-M8-B306 / HGX B300（单平面与双平面） | 2-8-9-800 与 2-8-9-400 | 16、32、64、128 |
| Cisco Nexus Hyperfabric RA with NVIDIA HGX B300 | 同上 | 2-8-9-800 与 2-8-9-400 | 16、32、64、128 |
| Cisco 2-8-5-200（文档即将发布） | UCS C845A M8 / RTX PRO 6000、H200 NVL | 2-8-5-200 | 4–32 |
各方案获得的背书类别（基础设施配置、Spectrum-X 兼容、网络逻辑架构）以 NVIDIA 文档页标注为准，部分标注“含 Spectrum-X 元素”。“调整为 2-8-10-400”为 NVIDIA 页面原文，多出的网卡用途以 Cisco 对应设计文档为准。B300 方案中的 2-8-9-800 与 2-8-9-400 分别对应双平面与单平面东西向网络（第 13 章 13.4、13.5 节）。
Cisco AI POD 于 2024 年 10 月发布，建立在 Cisco 验证设计（CVD）之上，把 UCS AI 服务器（如搭载 HGX H100/H200 的 C885A M8、支持 PCIe GPU 的 C845A M8）、Nexus 网络、合作伙伴存储和软件栈组合成预配置的模块。对照表 14-4 可以看到它在 NVIDIA 体系里的位置：一个按 2-8-9-400 模式、4 到 16 台规模、通过 NVIDIA 设计评审的模块；更大规模和 B300 一代，则由基于 Nexus 与 Hyperfabric 的参考架构覆盖。对企业来说，这意味着沿用熟悉的 Nexus 运维方式（如 VXLAN EVPN 和 Nexus Dashboard），同时仍处在 NVIDIA 参考架构的“图纸”之内。
#### Secure AI Factory：给工厂装上门禁与雷达
2025 年 3 月，Cisco 与 NVIDIA 发布了 **Cisco Secure AI Factory with NVIDIA**。它的定位是：在 NVIDIA 参考架构的性能基础上，补上企业生产环境刚需的三样东西。
> 【图示】Cisco Secure AI Factory 与 NVIDIA 的分层示意：应用与模型层由 AI Defense 做红队测试和运行时防护；工作负载与集群层用 Hypershield 等混合网格防火墙防止横向移动；网络层前端可用 Silicon One、后端可用基于 Spectrum-X 的交换机；计算层是 UCS AI 服务器，用 Intersight 管理；存储层与合作伙伴联合验证；Splunk 提供贯穿各层的全栈可观测性。
**图 14-4** 按层看 Secure AI Factory 的组成。左边是每一层要防、要管的问题，右边是 Cisco 官方发布中对应的组件。
1. **每一层的安全**：在应用与模型层，**Cisco AI Defense**（2025 年 1 月发布）用算法化的红队测试评估模型，并在运行时防护提示词注入、数据泄露等新型威胁（还记得第 8 章 Agent 的风险吗）；在工作负载层，**Hypershield** 等混合网格防火墙用来阻止攻击者在集群内部横向移动。它与 14.2 节 DPU 的零信任能力互为补充：一个在网卡上，一个在网络与工作负载层。
2. **全栈可观测性**：借助 Splunk，把 GPU 利用率、网络、能耗一直到应用延迟和 Token 成本放在同一个视图里，出问题时能更快定位到底卡在哪一层。
3. **网络的选择权**：2025 年 2 月，Cisco 与 NVIDIA 宣布 Cisco Silicon One 成为 Spectrum-X 中唯一的合作伙伴芯片，同时 Cisco 也推出基于 NVIDIA Spectrum-X 交换芯片的交换机（N9100，2025 年 10 月）。2026 年 8 月，Secure AI Factory 扩展到 Vera Rubin NVL72 等机柜级系统：前端可用基于 Silicon One 的交换机，后端可用基于 Spectrum-X 的交换机。
在芯片层面，Cisco 在 2025 年 10 月推出了用于跨数据中心互联的 51.2 Tbps 路由芯片 Silicon One P200，2026 年 2 月又发布了 102.4 Tbps 的交换芯片 Silicon One G300。这些都指向同一个趋势：**单个数据中心装不下的 AI 工厂，开始跨楼、跨园区相连**。
类比：
如果说 GPU 厂商的参考架构是一份**高性能发动机和传动系统的图纸**，追求的是把速度推到物理极限；那么企业要的是一辆能在城市里每天上路的车：除了发动机，还要有**门锁、防撞雷达和仪表盘**，还要能开进现有的车库。Secure AI Factory 想做的就是后者。
##### 参考架构与验证设计能
- 降低集成风险，缩短从采购到上线的时间
- 给出经过测试的性能、网络与安全基线
##### 它们不能
- 替你决定跑什么工作负载、要多大规模
- 保证厂商宣传的性能数字在你的业务上原样复现：仍需在自己的负载上验证
### 14.8 回到那个问题：工厂为什么能输出智能
现在，读者最初的问题可以完整地回答了。**智能来自规律**：第 4 章说，预测得足够好就必须理解得足够深，训练把海量数据里的规律压缩进参数，推理再把规律展开成 Token。**压缩和展开都是天文数字的矩阵乘法**：第 9 章算过，一个 4050 亿参数的模型，一块 GPU 要算 3,000 年。**AI 工厂的作用，是把这件“一块卡算不完、装不下”的事，组织成上万块卡同步完成的事**：GPU 负责算，NVLink 和轨道优化的 RDMA 网络负责传，认证存储负责喂和存，CUDA、NCCL、Kubernetes 负责指挥，DPU、可观测性和安全负责让它稳定、可信地跑下去。参考架构则把这些经验写成了可以复制的图纸。
所以，算力、数据、算法三样东西缺一不可，而工厂决定了它们能被多快、多便宜、多可靠地组合起来。**工厂里最慢的那一环，就是整个智能的产能上限**。
##### 本章带走
一份 HGX AI 工厂图纸 = 2-8-9-400 节点 × 4 台一个单元 × 最多 32 个单元，加上三张物理网、控制面、认证存储和软件栈。
- 节点：8 块 SXM GPU 经 NVSwitch 全互联；8 块 400G SuperNIC 与 GPU 1:1；1 块 DPU 负责南北向与安全。
- 东西向：轨道优化、无阻塞胖树；每个单元 12.8 Tb/s；128 台需要 16 台叶、8 台脊交换机，光模块增长快于 GPU。
- 带宽配额：东西向 400、客户 ≥25、存储 ≥12.5 Gb/s/GPU；纯推理可先不建计算网。
- Cisco AI POD 是通过 NVIDIA 设计评审的 2-8-9-400 方案；Secure AI Factory 在其上补安全、可观测性与网络选择权。
**于是，下一个问题**：回到起点：一个能拿奥数金牌线的系统，为什么会数错 strawberry 里的 r？走完这一路，你能自己解释了吗？
---
# 尾章 回到草莓
> 本章问题：我们得到了什么？还剩下什么问题？
> 来源：https://llm.weiborao.link/#ch15
**上一章留下的问题：**回到起点：一个能拿奥数金牌线的系统，为什么会数错 strawberry 里的 r？走完这一路，你能自己解释了吗？
序章里，这个反差像一个谜。现在请你先合上书，试着用自己的话解释一遍，再往下看。
**停一下：用三到五句话，解释“金牌与草莓”为什么同时成立。**
**参考答案：**
参考答案：大语言模型只做一件事——根据前文预测下一个 Token。为了在海量文字上把这件事做好，它被迫把语法、事实和推理的规律压缩进参数，这让它能一步步写出数学证明；推理强化学习和“先写草稿再作答”又放大了这种能力（金牌）。但它看文字的基本单位是 Token，不是字母：strawberry 是两个编号，编号里没有字母，所以数字母这种“看包裹里面”的任务，反而需要它先把单词一个字母一个字母地写出来（草莓）。两件事来自同一套机制的两个侧面。
如果你的答案和上面差不多，这本书就完成了它最重要的承诺。不妨翻回序章的图 0-2“AI 认知地图”：现在七层里的每一个词，你应该都能说出它是什么、为什么需要它。下面再用一张图把全书的因果链串起来。
> 【图示】全书一张图：文字切成 Token，变成向量，经 Transformer 预测下一个 Token；训练把规律压缩进参数，推理一个个展开成 Token；RAG 让它开卷，Agent 让它行动；这一切落到 GPU 上的矩阵乘法，靠集合通信和网络把上万块 GPU 连起来，最后组装成把电变成 Token 的 AI 工厂，并由参考架构写成可复制的建厂图纸。
**图 15-1** 全书的问题链压成一张图。从上往下，是从“一个 Token”到“一座工厂”；从下往上读，每一层都在为“把下一个 Token 猜得更好、更快、更便宜”服务。
### 15.1 三句话
全书反复出现过三句话。现在你应该能自己把它们推出来了：
预测得*足够好*，就必须理解得*足够深*。
因为“猜下一个词”是一个可以无限变难的任务，而参数装不下原文，模型只能去学规律（第 4 章）。
一切都是 Token：
输入是 *Token*，思考是 Token，*行动也是 Token*。
文字被切成 Token（第 3 章），推理模型用 Token 当草稿纸（第 5 章），Agent 用 Token 描述行动（第 8 章）。所以 Token 既是模型的语言，也是 AI 的计量单位和成本单位。
AI 工厂把*电*变成 *Token*，
速度由最慢的那一环决定。
每个 Token 都是矩阵乘法，一块卡算不完、装不下（第 9 章），上万块卡要不停地对答案（第 10 章），对答案的路不能堵（第 11 章），工厂的每一层都可能成为瓶颈（第 12 章），而参考架构把这些经验写成了可复制的图纸（第 13、14 章）。
### 15.2 本书的核心贡献
1. **一句话的 LLM。**大语言模型是一个用几千亿个参数、被训练来预测下一个 Token 的深度神经网络；模型下载下来就是一份配置加一堆数字。
2. **一条因果链。**文本 → Token → 向量 → 注意力与前馈 → 下一个 Token 的概率 → 采样 → 循环。
3. **一个解释。**“预测即压缩”：数据是原矿，算法是模具与工艺，算力是打磨次数；缩放定律让投入与效果可以预测。
4. **一张训练地图。**预训练给知识，微调给格式，对齐给偏好，推理强化学习给“先想再答”。
5. **一套推理直觉。**预填充算力密集、解码带宽密集；KV 缓存吃显存；温度决定稳与活。
6. **两把扩展的钥匙。**RAG 让模型开卷，靠向量检索和“忠实度”评价；Agent 让模型行动，靠工具、循环和权限管控。
7. **一把尺子。**“一块 GPU 要算多久”：Llama 3.1 405B 约 3,000 年，1.6 万块卡约 70 天。
8. **一个精确的定义。**AI 工厂是为 AI 全生命周期设计的全栈基础设施：输入电和数据，产出 Token，以 Token 吞吐量、每瓦 Token 和每 Token 成本衡量。黄仁勋的说法是：“给它注入能量，它就会生产出非常有价值的产品，这些产品就叫做 token。”
9. **一套建厂图纸。**NVIDIA 企业参考架构：认证节点、集群设计、软件设计三层；C‑G‑N‑B 代号（如 2-8-9-400）；4 台服务器一个可扩展单元；东西向轨道优化、南北向走 DPU；每 GPU 带宽配额东西向 400、客户 25、存储 12.5 Gb/s。
10. **一座工厂的瓶颈观。**算力、网络、存储、软件、管理五要素，加上电力散热与安全；训练重同步，推理重延迟与成本；网络从 ECMP 走向逐包喷洒与超以太网；许多机房每柜不到 20 kW，这道物理门槛决定了能建哪一种工厂。
### 15.3 留给你的问题
好的解释不应该在最后一页结束。下面几个问题没有标准答案，留给你在工作和生活里继续想：
1. 如果“预测得足够好就必须理解得足够深”，那么“理解”是什么？模型和人之间，哪些差别是程度上的，哪些是种类上的？
2. 你的工作里，有哪些部分本质上也是“根据前文猜下一步”？哪些不是？前者会怎样被 Agent 改变？
3. 如果高质量的人类文本快用完了，“规律的原矿”还能从哪里来：合成数据、真实世界的交互、还是可自动判分的任务？
4. 当 Agent 能独立工作几个小时、调用公司的系统时，“谁对结果负责”应该怎样设计？
5. 如果你今天要为团队建一个 AI 平台，你会先回答哪三个问题？按 C-G-N-B 写出你需要的节点，它属于哪个家族？最慢的那一环可能在哪里？
6. 黄仁勋说“计算能力就是营收”。在你的行业里，什么样的业务能让每个 Token 真正产生收入？如果不能，AI 工厂的投资回报从哪里来？
最后，请回到网页版封面上的那台终端（读 EPUB 的话，就在脑子里想象它），把温度调到 0，再调到 2，各生成一次。现在你知道，屏幕上每一个方块的背后，是一个概率分布、几千亿次乘法、几次跨越 GPU 的“对答案”，以及一座工厂里的电。
---
# 附录 术语、推算与出处
> 本章问题：书里的数字从哪里来？
> 来源：https://llm.weiborao.link/#appx
本附录收录三样东西：全书术语、本书自己做的推算及其推导，以及正文引用的主要出处。资料截至 2026 年 10 月 8 日。
### A.1 术语小词典
Token（词元）
: 模型处理文字的基本单位，可能是一个字、一个词或一个词的片段（第 3 章）。
分词 / BPE
: 把文本切成 Token 的过程；BPE 从字母出发反复合并最常见的一对来造词表。
向量 / 嵌入
: 一串数字，表示一个 Token 或一段文字在“意思空间”里的位置。
参数 / 权重
: 神经网络里所有可调的数字，训练调的就是它们（第 2 章）。
梯度下降 / 反向传播
: 按误差一步步调整参数的方法；反向传播负责把误差的责任分到每一层。
Transformer
: 2017 年提出的网络结构，由注意力和前馈网络层层堆叠而成（第 4 章）。
注意力
: 每个位置回头看前文、按相关程度混合信息的计算。
缩放定律
: 损失随模型、数据、算力规模按幂律下降的经验规律。
预训练 / 微调 / RLHF
: 在海量文本上学规律 / 在示范数据上学格式 / 用人的偏好学“什么是好”（第 5 章）。
推理模型
: 回答前先生成思考 Token 的模型，常用可自动判分的任务做强化学习训练。
推理（inference）
: 运行训练好的模型生成输出的过程（第 6 章）。
预填充 / 解码
: 并行读完输入 / 一次生成一个 Token 的循环。
KV 缓存
: 存下前文每个 Token 的 Key 和 Value，避免重复计算，代价是占显存。
TTFT / ITL
: 首 Token 延迟 / Token 间延迟。
温度
: 控制采样随机程度的参数。
幻觉
: 流畅自信但不实的输出（第 7 章）。
RAG
: 检索增强生成：先检索资料，再让模型根据资料回答。
Agentic RAG
: 由模型自己规划检索：拆解问题、决定查什么和查几轮、自评信息是否足够（第 7 章）。
CRAG / LegalBench-RAG
: 两个 RAG 基准：前者考综合问答的可信度，后者专考法律领域的精确检索。
向量数据库
: 存储向量、按意思（夹角）检索的数据库。
Agent（智能体）
: 大模型 + 工具 + “思考、行动、观察”循环（第 8 章）。
物理 AI / 世界模型
: 在三维真实世界中行动的 AI / 能预测“世界接下来会怎样”的模型，用于给机器人和自动驾驶提供练习场（第 8 章）。
MCP
: 模型上下文协议，AI 应用连接工具与数据源的统一接口。
GPU / 张量核心
: 擅长大规模并行计算的处理器 / 专做矩阵乘法的单元（第 9 章）。
数据 / 张量 / 流水线并行
: 把训练分给多块 GPU 的三种拆法。
集合通信 / AllReduce
: 多块 GPU 一起交换和汇总数据的操作（第 10 章）。
NVFP4
: NVIDIA 的 4 位浮点格式，Blackwell 一代主打的低精度计算格式（第 9 章）。
SHARP / 网内计算
: 在交换机里就地聚合数据，减少集合通信需要在网络上传输的数据量（第 10 章）。
NVLink / NVSwitch
: 服务器内 GPU 之间的高速互联。
RDMA / RoCEv2 / InfiniBand
: 绕过 CPU 和操作系统直接读写远端内存 / 跑在以太网上的 RDMA / 原生 RDMA 网络。
CUDA / NCCL
: 指挥 GPU 计算的平台 / 指挥 GPU 通信的库。
Kubernetes / Slurm
: 容器编排平台 / 超算作业调度器。
ECMP / 逐包喷洒
: 按流哈希分路 / 按包选最空的路（第 11 章）。
PFC / ECN / DCQCN
: 以太网的暂停帧 / 拥塞标记 / 两者结合的拥塞控制算法。
超以太网（UEC）
: 为 AI 和高性能计算重新设计以太网传输的开放标准，1.0 版于 2025 年发布。
AI 工厂
: 为 AI 全生命周期设计的全栈基础设施，输入电和数据，产出 Token，以 Token 吞吐量衡量（第 12 章）。
企业参考架构（Enterprise RA）
: NVIDIA 发布的企业 AI 工厂集群设计指南，覆盖计算、网络、存储与软件（第 13 章）。
C-G-N-B 参考配置
: 节点代号：CPU 插槽数-GPU 数-网卡数-每 GPU 平均东西向带宽，如 2-8-9-400。
可扩展单元（SU）
: AI 工厂扩展的基本积木：RTX PRO 与 HGX 为 4 台服务器，NVL72 为 1 个机柜。
设计评审委员会（DRB）
: NVIDIA 工程师主导的评审，审查合作伙伴的集群设计是否符合参考架构。
SuperNIC / DPU
: 为东西向 AI 网络优化的网卡 / 自带处理器、负责南北向、存储与安全卸载的网卡（第 14 章）。
轨道优化
: 把所有服务器上同一编号的 GPU 网卡接到同一组叶交换机上的东西向布线方式。
带外管理（OOB）
: 连接 BMC 与设备管理口、与业务网络物理隔离的管理网络。
### A.2 本书的推算
以下数字为本书估算，正文中已标注。推导用到的原始数字均来自 A.3 所列出处。
表 A-1 推算与推导
| 结论 | 推导 |
| --- | --- |
| 一块 H100 的有效算力约 4×10¹⁴ 次/秒 | BF16 稠密 989 TFLOPS（官网稀疏口径 1,979 的一半）× 40% 利用率 |
| GPT-3 训练 ≈ 一块 H100 算 25 年 | 3.14×10²³ ÷ (3.956×10¹⁴ × 3.156×10⁷ 秒/年) ≈ 25.2 年 |
| Llama 3.1 405B ≈ 一块 H100 算 3,000 年；1.6 万块约 70 天 | 3.8×10²⁵ ÷ 3.956×10¹⁴ ≈ 9.6×10¹⁰ 秒 ≈ 3,044 年；÷ 16,000 ≈ 69.5 天 |
| 6ND 与论文一致 | 6 × 4.05×10¹¹ × 1.56×10¹³ ≈ 3.79×10²⁵ |
| DeepSeek-V3 ≈ 一块 H800 算约 320 年 | 278.8 万 GPU 时 ÷ 24 ÷ 365.25 ≈ 318 年 |
| 405B 训练数据约 60 TB 文本 | 15.6 万亿 Token × 约 4 个英文字符/Token；粗略量级 |
| KV 缓存每 Token 约 516 KB；12.8 万 Token 约 68 GB | 2（K 和 V）× 126 层 × 8 个 KV 头 × 128 维 × 2 字节 = 516,096 字节；× 131,072 |
| 405B 解码单请求约每秒 60 多个 Token | FP8 权重 405 GB ÷ 8 卡 ≈ 50.6 GB/卡；÷ 3.35 TB/s ≈ 15 毫秒/Token；未计其他开销 |
| 405B 训练状态约 6.5 TB，至少 81 块 H100 | 4.05×10¹¹ 参数 × 约 16 字节（混合精度 Adam 的常见粗算）≈ 6.48 TB ÷ 80 GB |
| Llama 3 训练约 3 小时中断一次 | 54 天 × 24 小时 ÷ 419 次意外中断 ≈ 3.1 小时 |
| 环形 AllReduce，8 卡每卡发送 1.75 倍数据 | 2 × (8 − 1) ÷ 8 |
| Chinchilla 约 20 Token/参数 | 1.4 万亿 ÷ 700 亿 |
| 一个单元的东西向带宽：RTX PRO 6.4、HGX B300 25.6、NVL72 57.6 Tb/s | 4 台 × 4 × 400G；4 台 × 8 × 800G；18 托盘 × 3,200 Gb/s（网卡数与速率取自三份参考架构） |
| 存储配额 12.5 Gb/s/GPU ≈ 1.56 GB/s/GPU ≈ 12.5 GB/s/台 | 12.5 ÷ 8 = 1.5625 GB/s；× 8 块 GPU = 12.5 GB/s；交叉验证：16 × 12.5 = 200 Gb/s（原文例子），32 × 100 Gb/s ÷ 256 GPU = 12.5 Gb/s（32 节点设计） |
| NVLink 与网卡同口径相差约 9 倍 | H100 NVLink 900 GB/s 为双向，单向约 450 GB/s；400 Gb/s 网卡单向 50 GB/s；450 ÷ 50 = 9 |
| 每 GPU 带宽配额之比约 32 : 2 : 1 | 东西向 400 Gb/s : 客户 ≥ 25 Gb/s : 存储 ≥ 12.5 Gb/s（HGX 参考架构 32 节点设计） |
| 一个 SU 东西向 12.8 Tb/s、南北向 1.6 Tb/s | 4 台 × 8 × 400 Gb/s；4 台 × 2 × 200 Gb/s（参考架构原文给出） |
| 交换机间光模块增长约 5 倍，快于 GPU 的 4 倍 | 1,408 ÷ 274 ≈ 5.1；1,024 ÷ 256 = 4（参考架构附录表 10） |
| AI 工厂收入 ≈ 电力 × 每瓦 Token × 每 Token 价格 | 对黄仁勋 2026 年“每瓦吞吐量就是收入”表述的归纳，只表达结构，未计折旧、利用率与运营成本 |
### A.3 事实核查说明
全书的可核查陈述（日期、数字、引语、产品与规格）均对照一手出处核对过：论文以 arXiv 原文为准，产品与模型以发布方官网为准，硬件与参考架构以 NVIDIA 官方文档为准，引语以 NVIDIA 官方博客与新闻稿所载为准。资料截止日为 2026 年 10 月 8 日。核查中无法取得一手出处的说法已从正文删除（例如“ChatGPT 两个月 1 亿用户”）；与出处不符的说法已修正（例如 IMO 金牌比例、GPQA 的描述、R1 “顿悟时刻”的主体）；出处本身前后不一致的地方，正文已注明两种写法。厂商性能数字一律标注为厂商口径；本书自己的推算标注为“估算”，推导见 A.2。
### A.4 主要出处
黄仁勋的原话以 NVIDIA 官方博客与新闻稿所载为准，有官方中文的直接采用，其余为本书译文；厂商的性能数字均为厂商口径；各公司对新模型的评测以自家为主。Muse 个人 Agent 应用的上线日期来自二手报道。
#### AI 工厂定义与 NVIDIA 参考架构
- NVIDIA 术语表：AI 工厂（英文）：
- NVIDIA 术语表：AI 工厂（官方中文）：
- NVIDIA 参考架构文档总览（含合作伙伴背书设计表）：
- NVIDIA Enterprise Reference Architectures 产品页：
- NVIDIA RTX PRO AI Factory 参考架构：
- NVIDIA HGX AI Factory（HGX B300）参考架构：
- NVIDIA NVL72 AI Factory（GB300 NVL72）参考架构：
- NVIDIA HGX AI Factory（HGX H100、H200、B200）参考架构：
- NVIDIA Reference Architectures for Enterprise AI Factories 白皮书：
#### 黄仁勋原话出处
- GTC 2024 主题演讲回顾（2024-03）：
- COMPUTEX 2024 主题演讲回顾（2024-06）：
- GTC 2025 主题演讲实时回顾（2025-03）：
- Blackwell Ultra 新闻稿（2025-03）：
- COMPUTEX 2025 主题演讲回顾（英文）：
- COMPUTEX 2025 主题演讲回顾（官方中文）：
- GTC 巴黎主题演讲回顾（2025-06）：
- NVIDIA 欧洲 AI 基础设施新闻稿（2025-06）：
- GTC 华盛顿特区回顾（2025-10）：
- Vera Rubin DSX AI 工厂参考设计新闻稿（2026-03）：
- GTC 2026 主题演讲回顾（2026-03）：
- GTC 台北暨 COMPUTEX 2026 回顾（2026-06）：
#### 历史与模型
- Dartmouth 提案（1955）：
- Rumelhart, Hinton, Williams：反向传播（Nature, 1986）：
- IBM：深蓝：
- AlexNet（NIPS 2012）：
- word2vec（2013）：
- DeepMind：AlphaGo：
- Attention Is All You Need（2017）：
- BERT（2018）：
- OpenAI：GPT-2（2019）：
- GPT-3（2020）：
- Kaplan 等：缩放定律（2020）：
- Chinchilla（2022）：
- InstructGPT（2022）：
- Wei 等：涌现能力（2022）：
- Schaeffer 等：涌现是幻象吗（2023）：
- Sutton：The Bitter Lesson（2019）：
- The Llama 3 Herd of Models（2024）：
- DeepSeek-V3 技术报告（2024）：
- DeepSeek-R1（2025）：
- OpenAI：o1-preview（2024）：
- OpenAI：Understanding and counting tokens：
- tiktoken 编码定义：
- TechCrunch：Why AI can’t spell “strawberry”（2024-08-27）：
- DeepMind：Gemini Deep Think 达到 IMO 金牌水平（2025-07）：
- OpenAI IMO 2025 证明（GitHub）：
#### 评测与 RAG
- Lewis 等：RAG（2020）：
- RAGAS（2023）：
- RGB：Benchmarking LLMs in RAG（2023）：
- MMLU（2020）：
- GSM8K（2021）：
- HumanEval（2021）：
- GPQA（2023）：
- SWE-bench Verified（2024）：
- Humanity’s Last Exam（2025）：
- ARC-AGI-2（2025）：
#### Agent 与最新进展
- OpenAI：Introducing ChatGPT（2022-11-30）：
- OpenAI：Introducing GPT-5（2025-08-07）：
- Linux Foundation：A2A 项目新闻稿（2025-06-23）：
- GPQA（2023）：
- 作者的“AI 认知地图”（图 0-2 的底稿）：
- CRAG（2024）：
- LegalBench-RAG（2024）：
- RAGAS 指标文档：
- Mem0（GitHub）：
- Google：NotebookLM 音频概览（2024-09-11）：
- Google：NotebookLM 视频概览（2025-07-29）：
- GLUE（2018）：
- SuperGLUE（2019）：
- MATH（2021）：
- MBPP（2021）：
- SentencePiece（2018）：
- NVIDIA Cosmos 论文（2025-01）：
- NVIDIA Cosmos 产品页：
- NVIDIA GB300 NVL72 产品页：
- NVIDIA SHARP 文档：
- ReAct（2022）：
- Lilian Weng：LLM Powered Autonomous Agents（2023）：
- Anthropic：Claude 3.7 Sonnet 与 Claude Code（2025-02）：
- Anthropic：Claude 4（2025-05）：
- Anthropic：MCP 捐赠与 Agentic AI Foundation（2025-12）：
- Anthropic：Claude Opus 5.5（2026-09）：
- OpenAI：Introducing Codex（2025-05）：
- OpenAI：GPT-5-Codex（2025-09）：
- OpenAI：GPT-5.5（2026-04）：
- OpenAI：GPT-6 for everyone（2026-10）：
- Google：Gemini 3（2025-11）：
- Meta：Muse Spark 1.1 与 Meta Model API（2026-07）：
- Meta：Muse Spark 1.3（2026-09）：
- Microsoft Research：Muse（WHAM，2025-02）：
- METR：Measuring AI Ability to Complete Long Tasks（2025-03）：
- METR：Time horizons（持续更新）：
#### GPU、通信与网络
- NVIDIA H100：
- NVIDIA H200：
- NVIDIA GB200 NVL72：
- NVIDIA：Blackwell Ultra 技术博客：
- NVIDIA Vera Rubin NVL72：
- NVIDIA DGX GB200 用户指南（机柜功耗）：
- NVIDIA：800 V 直流供电架构：
- NVIDIA：What is an AI factory：
- NVIDIA：LLM 推理优化（预填充与解码、KV 缓存）：
- NCCL 文档：
- nccl-tests：带宽计算说明：
- NVIDIA：What is CUDA：
- GPUDirect RDMA：
- GPUDirect Storage：
- Kubernetes 的历史：
- NVIDIA GPU Operator：
- NVIDIA 开源 KAI Scheduler（2025-04）：
- NVIDIA 收购 SchedMD（2025-12）：
- NVIDIA：RoCE 文档（UDP 4791）：
- Microsoft Research：DCQCN（SIGCOMM 2015）：
- Meta：RoCE networks for distributed AI training at scale（2024）：
- NVIDIA Spectrum-X：
- NVIDIA：Spectrum-X 技术博客（逐包路由与乱序处理）：
- UEC 成立（2023-07）：
- UEC 规范 1.0 发布（2025-06）：
- UEC 1.0 规范：
#### Cisco
- Cisco AI POD 与 UCS C885A M8（2024-10）：
- Cisco AI POD 一览：
- Cisco 与 NVIDIA 扩展合作（2025-02）：
- Cisco Secure AI Factory with NVIDIA（2025-03）：
- Cisco AI Defense（2025-01）：
- Cisco Silicon One P200 与 Cisco 8223（2025-10）：
- Cisco N9100 等 AI 网络发布（2025-10）：
- Cisco Silicon One G300（2026-02）：
- Cisco Secure AI Factory 扩展到机柜级系统（2026-08）：
---