矩阵是
一个动作

回想一下大学的线性代数考试。

你能在草稿纸上把两个 3×3 的矩阵乘出来：左边取一行，右边取一列，对应相乘再相加，一格一格填满。步骤熟练，结果正确，分数不低。

可如果监考老师在你交卷时多问一句：“你刚才算出来的这个矩阵，代表什么？”——大多数人会愣住。

这不怪你。我们学的是“怎么算”，很少有人讲“为什么要这样算”“算出来是什么东西”。这就像背熟了一本菜谱的每一个步骤，却从来没尝过这道菜。

0.1一个被放大的空白

在考场上，这个空白无关紧要。可今天，它被放大了。

新闻里说，某个大模型有“数千亿参数”；某块 GPU“每秒能做一千万亿次运算”；训练一个前沿模型“要用十万块 GPU、耗资数亿美元”。向量数据库、Transformer、Token、注意力机制……这些词每天都在你眼前经过。

如果顺着这些词一路往下挖，会发现它们最后都落在同一个地方：矩阵乘法。

于是，当年那个空白变成了今天的迷雾：你知道 AI 很重要，也知道它“本质上是矩阵运算”，但这句话对你来说是一句正确的废话——因为你不知道矩阵乘法本身意味着什么。

0.2从最朴素的事实出发

要驱散这团迷雾，我们不从定义开始，而从最朴素的事实开始。这就是第一性原理：先找到那个不能再拆的最小事实，再一步步往上搭。

那么，AI 到底在做什么？我们用一连串问题把它逼出来。

这就是全书的地基：

人工智能 = 从数据里学一个函数：一串数进，一串数出

“函数”这个词听上去很数学，其实它就是一台机器：喂进去一样东西，吐出来另一样东西。自动售货机是函数：投币加按钮，出来一罐饮料。

而本书要讲的矩阵，正是“把一串数变成另一串数”的机器里最简单、最好组合、最适合大规模计算的那一种。它简单到可以写在一张纸上；一层层叠起来，再在层与层之间加上一点点“折痕”，就能写诗、能编程。这不是巧合，后面八章会一步步说明为什么。

0.3本书怎样展开：一个黄金圈

全书按“为什么 → 怎么做 → 是什么”的顺序展开，也就是黄金圈：先理解为什么偏偏是矩阵，再看它怎样变成智能、怎样被算得飞快，最后落到具体的数字：一块 GPU 有多快，训练一个大模型要多少算力和数据。

更重要的是，章与章之间不是并列的知识点，而是一条问题链：每一章回答一个问题，而这个问题恰好是上一章的结论引出来的。

如果某一章让你觉得突兀，回头看看它的第一段：那里写着它接住的是上一章的哪个问题。

0.4读完之后，你能做到什么

先把承诺说清楚。读完这本书，你将能够：

1. 用一句话说清矩阵是什么，并且这句话能解释为什么它的乘法要“行乘列”；
2. 解释为什么 AI 几乎全是矩阵乘法，从图片滤镜一路讲到大语言模型的每一个环节；
3. 看懂一张 GPU 规格表，知道哪个数字是天花板、哪个数字是营销口径、哪个数字才决定你的模型跑多快；
4. 在餐巾纸上估算训练一个大模型需要多少次运算、多少块 GPU、多少天、多少度电。

第四条听上去最难，其实它只需要一个乘法公式和几个你到第 8 章时已经熟悉的数字。

0.5怎样读这本书

这本书用了三个小工具，提前介绍一下，读的时候会轻松些。

第一，“停一下”

你会不时遇到标着“停一下”的问题框。请真的停下来，想十几秒，再展开答案。自己先想过的结论，比读到的结论牢靠得多。

第二，类比和它的边界

复杂的东西，我们会用面包店、调色盘、厨房、装配线来类比。但每个类比都有失效的地方，所以你还会看到“它是 / 它不是”的对照框，把概念的边界画清楚，免得类比把你带偏。

第三，三句反复出现的话

全书的核心可以浓缩成三句话。它们会在不同章节、从不同角度反复出现。第一次读到时你未必认同，读到第三次时，希望你已经能自己推出来：

1. 矩阵是一个动作。
2. 乘法就是加权混合。
3. 每一格互不等待，所以能并行；真正的瓶颈常常不是算，而是搬。

上一章留下的问题：如果 AI 的核心是“把一串数变成另一串数”，而矩阵是做这件事的机器，那么矩阵到底是什么？它和那张“数字排成的表格”是什么关系？

教科书上的定义是这样的：由 m × n 个数排成的矩形阵列，叫作矩阵。

这句话完全正确，也几乎完全没用。它就像把汽车定义成“四个轮子加一个铁壳”——你看得出它长什么样，却看不出它能把你从家里带到公司。

本章要换一个角度：不问矩阵长什么样，而问矩阵做什么。为此，我们要先退一步，看清楚矩阵加工的原料是什么。

1.1先问向量：一串数能表示什么

上一章说，照片、句子、答案进了计算机都是“一串数”。这串数有个正式名字，叫向量。先别急着回忆“有大小有方向的量”这种物理课定义，我们从例子开始。

所以，向量最朴素的定义是：用一串有顺序的数，描述一个东西。数的个数叫作维度。颜色是 3 维，平面上的点是 2 维。到第 5 章你会看到，大语言模型里的一个词，是一个几千维的向量。

两维的向量可以画成一根从原点出发的箭头：往东 3 格、往北 2 格。三维的也能想象成空间里的箭头。几千维的画不出来，但没关系，计算机不需要“看见”它，只需要按同样的规则去算。

原料清楚了。接下来的问题就是：矩阵拿这些向量做什么？

1.2矩阵的三张脸

同一个矩阵，在不同场合会被读成三种完全不同的东西。多数人的困惑，来自只认识了其中一张脸。

第一张脸最直观，所以大家最先记住它：数字照片存在电脑里，确实就是一张（或三张叠在一起的）巨大数字表格。但这只是矩阵的存法，不是它的意义。

1.3动作：一个 2×2 矩阵能对平面做什么

现在把注意力放到第二张脸上。我们从最小的情况出发：一台机器，输入一个平面上的点 (x, y)，输出另一个点 (x′, y′)。

这台机器的规则可以千奇百怪。但如果要求它最简单——只准做乘法和加法，不准平方、不准开根号、不准查表——那么每个输出只能是输入的“加权和”：

x′ = a·x + b·y　　y′ = c·x + d·y每个输出，都是输入按某种权重加起来

整台机器由四个数 a、b、c、d 决定。把它们按位置排成一个方块：

这就是一个矩阵。请注意刚才发生了什么：那张“数字表格”，本来就是这台机器的说明书。第一张脸和第二张脸在这里接上了：表格里的每个数，是机器的一个旋钮。

可是，看着 a、b、c、d 四个数，你能想象出这台机器对平面做了什么吗？很难。我们需要一个更好的看法。

这是本章最重要的一个发现，值得单独写出来：

矩阵的第一列，是 î 的新家；第二列，是 ĵ 的新家

平面上任何一个点，都是“若干个 î 加若干个 ĵ”。所以两根基向量搬到哪里，整张平面就被带到哪里。我们用一个具体的矩阵看一眼：

现在再看教科书上“矩阵乘向量”的算法——第一行点乘向量得第一个数，第二行点乘向量得第二个数——你会发现它和“按列拼接”算出来的结果一模一样：

第一行：2×1 + (−1)×2 = 0　　第二行：1×1 + 1×2 = 3按行算和按列拼，是同一件事的两种读法（第 2 章会细讲）

区别在于：按行算，你得到一个数字；按列看，你看到一个动作。这就是那个缺失的“意义”。

1.4什么样的动作算“线性”

刚才我们给机器加了一条限制：只准做加权和。这条限制有一个名字，叫线性。它在几何上表现为三条规矩：

1. 原点不动。输入 (0, 0)，加权和还是 (0, 0)。
2. 直线还是直线。格线可以被拉斜、拉长，但不会被弄弯。
3. 平行等距的格线，依然平行等距。方格可以变成平行四边形，但所有格子变得一样。

满足这三条的动作，都能用一个矩阵写出来；不满足的，任何矩阵都做不到。

你可能已经起了疑心：真实世界到处是曲线，只会“拉直线”的矩阵能有多大用处？这个问题会在后面得到两次回答。第 3 章会告诉你，任何光滑的曲线，放大到足够近看都是直的；第 4 章会告诉你，在矩阵之间加一道小小的“折痕”，就能拼出任意复杂的形状。

一个顺手的收获：面积放大了几倍

既然所有格子都变得一样，那就可以问：每个小方格的面积被放大了几倍？答案藏在四个数里：

面积倍数 = |a·d − b·c|a·d − b·c 叫作行列式；负号表示平面被翻了个面

对图 1-3 里的 M，2×1 − (−1)×1 = 3，每个方格都变成了原来的 3 倍大。网页版封面实验室里实时显示的“面积 ×”，就是这个数。

最要紧的是它等于 0 的时候，比如图 1-4 里的“压扁”。整张平面被压成一条线，面积归零。这意味着许多不同的点被压到了同一个位置，信息丢了，而且再也找不回来。

1.5更高维：画不出来，但道理一样

平面上的一切，都能原样搬到更高的维度：

• 一个 3×3 矩阵，是对三维空间的动作。它有三列，分别记录三根基向量（东、北、上）的新家。
• 一个 4096×4096 的矩阵，是对 4096 维空间的动作。你画不出来，但它照样是“4096 根基向量各自搬去哪里”，每个输出照样是输入的加权和。

矩阵也不一定是方的。一个 3 行 2 列的矩阵，吃进 2 个数、吐出 3 个数，它把平面“放进”三维空间；一个 2 行 3 列的矩阵反过来，把三维空间压成平面，就像相机把立体世界拍成照片。

m 行 n 列的矩阵 ＝ 一台“吃进 n 个数、吐出 m 个数”的机器列数 = 输入的维度；行数 = 输出的维度

这一条对 AI 很重要。神经网络的每一层，本质上就是一台这样的机器：比如吃进 4096 个数，吐出 14336 个数，或者反过来。维度的升降，就是信息被展开、被压缩的过程。

1.6第三张脸：关系

最后简单认识一下第三张脸。假设有 3 个人：甲、乙、丙。做一张 3×3 的表格，第 i 行第 j 列写“i 和 j 是不是朋友”，是就写 1，不是就写 0。这张表也是一个矩阵，它记录的是关系。

关系矩阵无处不在：社交网络里谁关注了谁，互联网上哪个网页链接到哪个网页，城市之间两两的距离。第 3 章你会看到，Google 早年正是把整个网络的链接写成一个巨大的关系矩阵，才算出了网页的排名。

到了第 5 章，这张脸会以一个更重要的身份回来：大语言模型读一句话时，会为句子里的每两个词打一个“相关度”分数，排成一张 n×n 的关系表。那就是著名的注意力。

上一章留下的问题：如果一个矩阵是一个动作，那两个矩阵相乘又是什么？“一行乘一列、对应相乘再相加”究竟在算什么？为什么偏偏是乘法最常见？

上一章我们从几何出发，看到矩阵是一个动作。这一章换一个完全生活化的起点：一家面包店的账本。你会发现，同一个“行乘列”，在面包店里、在推荐系统里、在几何里，讲的是同一件事。

本章的结论先放在这里，读完再回头看：

乘法就是加权混合

2.1从一家面包店开始

你开了一家小面包店，卖三样东西：面包、蛋糕、饼干。每样东西用到三种原料：面粉、黄油、鸡蛋。配方是这样的：

今天的原料价格是：面粉 6 元/kg，黄油 80 元/kg，鸡蛋 1.5 元/个。问：每样点心的原料成本是多少？

“一行乘一列”在这里的意义一目了然：用一组数当权重，把另一组数加起来。蛋糕的配方，就是给三种原料价格分配的权重：黄油的权重 0.2 看着小，但黄油贵，它贡献了 16 元，是成本的大头。

这种“按权重加起来”的计算叫作加权求和，它有一个专门的名字：点积。矩阵乘以向量，就是一口气做很多次点积：每一行和向量做一次，得到一个结果。

2.2点积：一种打分方式

点积不只能算钱。换一个场景，它还能衡量两样东西有多“对味”。

假设我们只用两个数描述口味：甜的程度、辣的程度。你是 (1, 3)：不太爱甜，很爱辣。三道菜分别是：火锅 (0.5, 3.5)，提拉米苏蛋糕 (3.5, 0.2)，白粥 (0.5, 0.3)。你会更喜欢哪道菜？

用点积打分：你的每个口味维度乘以菜在这个维度上的程度，再加起来。

图上能看出点积的几何意义：两根箭头方向越一致、长度越长，点积越大；方向垂直时点积为 0，表示“毫不相干”；方向相反时点积为负，表示“正好相反”。

这个看起来很朴素的打分方式，是整个 AI 世界最常用的“相似度尺子”：

• 视频网站给你推荐节目：你的兴趣向量和节目的特征向量做点积，分高的排前面；
• 搜索引擎和向量数据库找相关文档：问题向量和文档向量做点积（第 5 章）；
• 大语言模型的“注意力”：每个词和其他所有词做点积，看谁跟自己最相关（第 5 章）。

2.3矩阵乘向量的两种读法

现在回到上一章的几何。同一个“矩阵乘向量”，其实可以从两个方向去读，而这两种读法对应着两种直觉。

用一个 3 行 2 列的矩阵 A 乘以向量 x = (3, 2)：

读法一：按行读——打分

每一行和 x 做一次点积，得到一个输出：2×3 + 1×2 = 8，1×3 + 3×2 = 9，0×3 + 1×2 = 2。就像三位评委，各自拿着自己的评分标准（一行），给同一个选手（x）打分。面包店算成本，用的就是这种读法。

读法二：按列读——调配

把 x 里的数当作“用量”：取 3 份第一列，加 2 份第二列。3×(2, 1, 0) + 2×(1, 3, 1) = (6, 3, 0) + (2, 6, 2) = (8, 9, 2)。结果完全一样。上一章“î 去哪、ĵ 去哪”用的就是这种读法。

两种读法各有用处：想知道“某个输出是怎么来的”，按行读；想知道“整个动作把空间变成什么样”，按列读。它们算出的数永远一样，因为每一格都是同样的乘法与加法，只是加的顺序不同。

无论哪种读法，核心都是同一件事：把一组东西按权重混合起来。本章开头的口号，在这里第一次有了完整的含义。

2.4矩阵乘矩阵：两个动作连着做

现在可以回答“两个矩阵相乘是什么”了。我们不背规则，而是问一个问题，让规则自己冒出来。

这就是“行乘列”的来历。它不是数学家随手定的规矩，而是为了让“两个动作连着做”能写成一个矩阵，被逼出来的唯一答案。

矩阵 × 矩阵 ＝ 两个动作连着做

这也解释了一个曾让很多人困惑的性质：矩阵乘法不能随便交换顺序，AB 一般不等于 BA。因为动作的顺序本来就重要。

再看一个完整的例子，体会“每一格 = 一行 · 一列”：

例如右上角的 2 = 第一行 (2, 1) · 第二列 (1, 0) = 2×1 + 1×0。网页版在下方提供了一个可以点选格子的演示，会高亮对应的行和列。

2.5为什么最常见的是乘法

矩阵有加法、有减法、有转置、有求逆，为什么在 AI 和科学计算里，出场最多的偏偏是乘法？

先看加法做了什么。两个矩阵相加，是对应位置的数各自相加：第 1 行第 1 列只和第 1 行第 1 列相遇。加法里，每个数只和它的“同位置邻居”打交道。

再看乘法。输出的每一个数，都是一整行和一整列的加权混合：每个输入都有机会影响每个输出。

这就是乘法无处不在的根本原因：乘法是“接线”。凡是需要让信息彼此混合、相互影响的地方，就需要乘法。加法只能把两份信息叠在一起，乘法才能把信息重新组合。第 4 章你会看到，神经网络的“一层”，就是这样一张接线图。

乘法常见还有一个更“物质”的原因：它贵。把两个 n×n 的矩阵相加，只需要 n² 次加法；相乘，则每一格要做 n 次乘法和 n 次加法，总计约 2n³ 次运算。

4096、16384 是大语言模型里常见的矩阵边长。乘法与加法的运算量之比恰好是 2n，矩阵越大，差距越悬殊。

所以，“AI 的算力都花在矩阵乘法上”这句话，背后是简单的算术：其他运算（加法、激活函数、归一化）的运算量只和 n² 成正比，而矩阵乘法和 n³ 成正比。n 一大，乘法就压倒一切。这也是为什么 GPU 厂商拼命优化的，就是矩阵乘法这一件事（第 6、7 章）。

上一章留下的问题：面包店、口味、几何，都能写成“加权混合”。这是巧合吗？为什么物理、经济、图像、搜索……这么多毫不相干的问题，都能写成矩阵乘法？

先给出答案，再逐条论证：不是巧合。矩阵之所以无处不在，有三个层层递进的原因。

1. 很多现象本来就是线性的：原因叠加，效果也叠加。
2. 不是线性的现象，放大看也是线性的：光滑的世界，局部都是直的。
3. 一旦写成矩阵，就能交给机器：矩阵是问题和计算机之间的通用接口。

第一条解释“为什么能写”，第二条解释“为什么到处都能写”，第三条解释“为什么大家都愿意这么写”。

3.1叠加：可以拆开算的世界

这个性质叫叠加原理，它就是第 1 章那个“线性”的物理版本。第 1 章说，矩阵能做的动作只有线性动作；这里反过来：凡是满足叠加原理的系统，都可以用矩阵来描述。

叠加原理珍贵在哪里？它让复杂的问题可以拆开。一段复杂的声音，拆成许多简单的纯音分别处理，再加回去；一座桥上的许多辆车，每辆车引起的形变分别算，再叠加。人类处理复杂问题的基本策略是“分而治之”，而线性系统是唯一一种保证能分、分了还能合回去的系统。

3.2光滑的世界，局部是直的

可是，真实世界大多不是线性的。弹簧拉得太长会变形，病毒传播越来越快，天气更是出了名的复杂。第 1 章留下的那个疑问又冒出来了：只会“拉直线”的矩阵，凭什么描述一个弯弯曲曲的世界？

答案藏在一个你每天都在经历的事实里：地球是圆的，但你脚下是平的。

站在操场上，你完全感觉不到地面的弧度，因为你只看到了很小的一块。任何一条光滑的曲线也是这样：放得足够大，它就和一条直线分不出来。

那条在局部“代替”曲线的直线，就是中学学过的切线，它的斜率就是导数。这是微积分最核心的思想：在一点附近，用线性近似非线性。

一条曲线只有一个输入、一个输出，它的局部近似是一个数（斜率）。那一个有很多输入、很多输出的复杂系统呢？比如一架飞机，输入是几十个舵面角度，输出是几十个姿态参数。它在某个状态附近的“局部近似”，就是一张表：每个输入变一点点，每个输出各变多少。这张表是一个矩阵，有个专门的名字，叫雅可比矩阵。

于是，科学计算有了一个通用套路：

1. 在当前状态附近，把复杂系统近似成一个矩阵；
2. 用矩阵算出下一小步；
3. 走到新状态，重新近似，再走一步。

天气预报、飞行控制、桥梁受力、芯片散热的仿真，背后都在反复做这件事：把大问题切成很多小块，每一小块在局部当作线性处理，最后变成一个巨大的矩阵方程，交给计算机去解。

3.3图片处理：四种加权混合

现在来看你最熟悉的例子：图片。一张照片存进电脑，是一张（彩色的话是三张叠在一起的）数字表格，这是矩阵的第一张脸。而对照片做的几乎所有处理，都是矩阵的第二张脸：动作。

第一种：彩色变黑白

把一个彩色像素 (R, G, B) 变成一个灰度值，常用的公式（来自电视标准 ITU-R BT.601）是：

Y = 0.299·R + 0.587·G + 0.114·B一个 1 行 3 列的矩阵：吃进 3 个数，吐出 1 个数

这是一次点积，和面包店算成本一模一样。绿色的权重最大，因为人眼对绿光最敏感。

第二种：调色滤镜

手机里的“怀旧”“冷色调”滤镜，很多就是一个 3×3 的矩阵：新的红 = 原来的红、绿、蓝按某种比例混合，新的绿和新的蓝也一样。第 2 章的“调鸡尾酒”，在这里是字面意思：把三种颜色重新调配。

第三种：旋转与缩放

把照片旋转 30°、放大 2 倍，是对每个像素的坐标做一次 2×2 矩阵变换——正是第 1 章图 1-4 里的动作。

第四种：模糊、锐化、找边缘

这一种最有意思。它不再只看一个像素，而是看一个像素和它的邻居。用一个 3×3 的小权重表（叫卷积核）对准图片上的一个窗口，九个像素和九个权重对应相乘再相加，得到一个新像素；然后窗口滑到下一个位置，再算一次。

换一组权重，同一个过程就变成了别的效果：九个权重都是 1/9，结果是周围九个像素的平均值，图片变模糊；中间权重大、四周为负，差异被放大，图片变锐利。

你可能会问：卷积是“滑动窗口”，看起来不像矩阵乘法啊？其实可以把它改写成矩阵乘法：把每个 3×3 窗口的 9 个数摊平成一行，所有窗口叠成一个大矩阵，再乘以摊平成 9 个数的卷积核，一次就算出所有输出。这个技巧有个名字叫 im2col。它看起来多占了内存，却让卷积可以直接调用高度优化的矩阵乘法，反而更快。

这件事本身就是一个信号：人们宁可多花内存，也要把问题改写成矩阵乘法。为什么？3.5 节会回答。

3.4秩：一张图里有多少“独立的花样”

矩阵还有一个性质，初学线代时常被一带而过，在 AI 时代却变得很重要：秩。

先看一个最简单的矩阵：用一列数 (1, 2, 3) 乘以一行数 (1, 1, 2)，得到一个 3×3 的表：第一行 (1, 1, 2)，第二行 (2, 2, 4)，第三行 (3, 3, 6)。九个数，但每一行都只是同一行的倍数，真正的信息只有“一列加一行”共 6 个数。这种“一列乘一行”拼出来的矩阵，秩是 1。

任何一个矩阵，都可以拆成若干个“秩 1 的花样”叠加起来，而且可以按重要程度排好序。这个拆法叫奇异值分解（SVD）。只保留最重要的前几个花样，就能用很少的数字，近似还原一个大矩阵。

秩的含义可以一句话说清：一个矩阵的秩，是它里面真正独立的“花样”有几种。一个 4096×4096 的矩阵有 1600 多万个数，但如果它的秩只有 16，那它真正携带的信息，只相当于 16 列加 16 行。

这个概念在大模型时代格外有用。微调一个大模型时，一种流行的方法叫 LoRA：不去改动原来那个 4096×4096 的大矩阵，而是在旁边加一个秩只有 16 的“修正项”，也就是一个 4096×16 的瘦矩阵乘以一个 16×4096 的瘦矩阵。需要训练的数从 1600 多万个降到约 13 万个，不到百分之一。它能奏效，背后的假设正是：针对一项具体任务的调整，真正独立的花样并不多。

3.5更远的地方：矩阵是一种通用接口

把视线从图片移开，矩阵在许多领域都扮演着同样的角色：

• 经济学：经济学家列昂惕夫把整个国民经济写成一张投入产出表：生产 1 元钢铁需要多少煤、多少电、多少运输。每个行业既是买家又是卖家，要满足最终需求，各行业该生产多少？这变成一个矩阵方程。他因此获得了 1973 年的诺贝尔经济学奖。
• 网页搜索：Google 早期的 PageRank，把整个互联网写成一个巨大的“关系”矩阵：网页 j 链接到网页 i，就把 j 的一部分重要性分给 i。一个网页的重要性，是链接到它的网页的重要性的加权和。反复用这个矩阵去乘重要性向量，直到数值稳定下来，就得到了排名。第 1 章的第三张脸（关系），在这里变成了第二张脸（动作）。
• 推荐系统：用户 × 商品的评分表是一个巨大而稀疏的矩阵。假设它的秩很低（人的口味只有少数几种“花样”），就能补全那些空格，猜出你可能喜欢什么。
• 物理学：在量子力学里，一个粒子的状态是一个向量，测量和演化都是矩阵。

这第二点可能比第一点更重要。早在 1979 年，科学计算界就发布了一套标准的线性代数子程序接口，叫 BLAS；80 年代末，它又增加了专门处理“矩阵乘矩阵”的第三级接口（1990 年正式发表），其中最核心的一个函数叫 GEMM（通用矩阵乘法）。此后几十年，每一代处理器的厂商，都会花大力气为自己的芯片写一版极致优化的 GEMM。

这意味着：任何问题，只要能改写成矩阵乘法，就能立刻享受到几十年积累下来的算法优化和硬件加速。这就是 3.3 节里人们宁可多花内存、也要把卷积改写成矩阵乘法的原因。

矩阵是问题与机器之间的通用接口

到这里，第 2 章结尾的问题有了完整的回答：很多现象天然满足叠加原理；不满足的，在局部也可以线性近似；而一旦写成矩阵，就接上了人类几十年打磨的计算基础设施。三个理由互相加强，让矩阵成了科学和工程的“普通话”。

上一章留下的问题：找边缘的卷积核、调色的矩阵，都是人精心设计的。可识别一只猫、理解一句话，需要什么样的权重？没人设计得出来。能不能让机器自己从数据里把权重“找”出来？

先想想人是怎么设计那个找边缘的卷积核的：我们知道“边缘就是左右亮度差很大的地方”，于是写下“右减左”的权重。设计的前提，是我们能用语言说清楚规则。

可“猫”的规则是什么？尖耳朵？有些猫耳朵是折的。有胡须？老虎也有。你一眼就能认出猫，却说不清自己是怎么认出来的。说不清的规则，就写不成权重。

机器学习的思路是反过来的：先定好机器的形状，再让数据来决定里面的数。形状是什么？就是我们前三章一直在讲的东西：矩阵。

4.1一个神经元，一层矩阵

神经网络里最小的零件叫神经元。别被名字吓到，它做的事情你已经很熟悉了：

1. 把几个输入按权重加起来（一次点积，和面包店算成本一样）；
2. 结果经过一道“门槛”：小于 0 就输出 0，大于 0 就原样输出。

第二步那道门槛，最常用的一种叫 ReLU。它简单得近乎可笑，却是本章的主角之一，4.2 节会解释为什么缺了它不行。

一个神经元只能打一种分。把很多个神经元并排放在一起，让它们看同一组输入、各打各的分，就组成了一层。每个神经元有自己的一组权重，把这些权重一行一行摞起来，就是一个矩阵。

于是，一层神经网络的全部计算可以写成一行：

y = ReLU(W · x)先做一次矩阵乘法（加权混合），再对每个数单独过一道门槛

第 2 章说“乘法是接线”，这里就是字面意思：矩阵的第 i 行第 j 列，是第 j 个输入连到第 i 个神经元的那根线的粗细。

4.2为什么需要一道“折痕”

第 2 章的“停一下”留了一个问题：三个矩阵连乘，结果还是一个矩阵，那三层和一层有什么区别？现在来回答它。

ReLU 就是那一点点。它把负数变成 0、正数保持不变，在 0 那里有一个拐角。单看一个 ReLU，毫不起眼；但把它夹在矩阵之间，每一层都能在空间里“折”一下。

数学上有一个定理（万能逼近定理）说：只要神经元足够多，“矩阵加折痕”这种结构可以在有限的输入范围内，任意精确地逼近任何连续的输入输出关系。换句话说，形状本身不是限制，难的是找到那些合适的数。

神经网络 ＝ 矩阵乘法 × 折痕 × 反复调整

4.3学习，就是调矩阵里的数

机器的形状定下来了：一层矩阵、一道折痕、再一层矩阵、再一道折痕……一开始，矩阵里的数都是随机填的，这台机器什么都不会，看到猫的照片，可能说“是猫的可能性 30%”。怎么让它变好？

第一步：量一量错了多少

我们手里有标好答案的照片：这张是猫（100%）。机器说 30%，差了一截。把“差多少”写成一个数，叫损失。损失越小，机器越准。学习的目标，就是找到一组矩阵里的数，让所有训练照片上的总损失尽可能小。

第二步：往损失变小的方向挪一点

矩阵里有成千上万个数，每个数稍微变一点，损失都会跟着变一点。如果知道“每个数往哪边挪，损失会下降”，就可以把所有数一起往那个方向挪一小步。这个“往哪边挪”的方向，叫梯度；整个过程叫梯度下降。

第 3 章说过“光滑的世界，局部是直的”。梯度正是损失在当前位置的局部线性近似。它只在附近有效，所以只能一小步一小步地走，每走一步都要重新量一次坡度。

第三步：把“错”沿原路分摊回去

问题来了：一个网络有很多层，最后的损失是所有层共同造成的。每一层的每个数，各自该负多少责任？

办法叫反向传播：从输出端的误差出发，沿着计算的原路一层层往回推，把“责任”分摊到每一层。有意思的是，往回推的每一步，用的还是矩阵乘法：前向时乘以 W，反向时乘以 W 的转置（把行和列对调）。

请记住这个 6N。对大语言模型来说，“输入单位”是 Token（可以先理解为“词块”，第 5 章细讲）。训练数据有 D 个 Token，整个训练的运算量就是大约 6·N·D。第 8 章估算一个大模型要多少算力，全靠这个公式。

一次看一批，而不是一张

实际训练时，机器不是一张一张地看照片，而是一次看一批（比如几百张）。一批照片的向量并排摆在一起，本身就是一个矩阵。于是“矩阵乘向量”变成了“矩阵乘矩阵”。这看似只是换了个写法，却让计算效率大幅提高，原因在第 6 章揭晓。

4.4“参数”到底是什么

现在可以回答一个常见的疑问了：新闻里说 GPT-3 有“1750 亿参数”，参数是什么？

参数，就是网络里所有矩阵中所有可调的数的总个数（外加少量别的可调数字）。1750 亿个参数，就是 1750 亿个旋钮。训练，就是把这 1750 亿个旋钮一点点拧到合适的位置。

这些数要存起来。常用的 BF16 格式（一种 16 位的数字格式），每个数占 2 个字节；更省空间的 FP8 格式，每个数只占 1 个字节。这些格式的来龙去脉，第 7 章细讲。

训练时还要额外存梯度和优化器的中间状态，总显存需求通常是权重本身的好几倍。这也是一块 GPU 装不下、必须多卡协作的原因之一（第 6 章）。

350 GB 是什么概念？以 NVIDIA H100 为例，一块卡的显存是 80 GB（更新一代的产品在 180 到 288 GB 之间）。光是把 GPT-3 的权重放进 H100，就需要好几块卡。第 7 章讲 GPU 的“显存容量”指标时，这些数字会再次出现。

4.5机器学到的，是什么

最后画一道围栏。“学习”这个词很容易让人误会。

这里值得停下来想一想。人类花了几千年总结规则、写成教科书；神经网络却不写规则，只是把海量的例子“压”进一组数里。它做对的时候，我们往往说不清它为什么对；做错的时候，也很难指出是哪个数错了。这既是它强大的地方，也是它让人不安的地方。

上一章留下的问题：照片天然是一张数字表格，可以直接喂给矩阵。可是语言呢？“我爱你”要怎么变成一串数？大语言模型从读进一句话到吐出下一个字，中间经过了哪些矩阵？

先把大语言模型做的事情说到最朴素：给它一段文字，它预测下一个词是什么。仅此而已。你看到的长篇回答，是它一个词一个词接出来的：预测一个，接到末尾，再预测下一个。

所以本章只需要回答一个问题：预测下一个词这件事，是怎样一步步变成矩阵乘法的？我们沿着一句话在模型里走过的路线，分五站来看：切词、查表、互相打量、各自加工、给出答案。最后再看看，搜索和向量数据库又是怎么搭上这条路线的。

5.1第一站：把文字切成 Token

计算机不认识字，只认识数。第一步，要把文字切成一块一块，每一块换成一个编号。这些小块叫 Token，可以理解为“词块”。

现代大模型的词表通常有 10 万到 20 万个 Token。大致的换算：英文里 1 个 Token 约等于 0.75 个单词；中文里 1 个 Token 大约对应 1 到 1.5 个汉字（因分词器而异）。模型按 Token 计费、按 Token 计算长度，说的就是这些小块。

5.2第二站：查表，得到一个向量

编号本身没有意义。48213 和 48214 挨着，并不代表两个词意思相近。我们需要的是第 1 章说的那种“地址”：意思相近的词，地址也相近。

办法很直接：准备一张大表，词表里的每个 Token 占一行，每行是几千个数（Llama 3.1 405B 是 16384 个，70B 是 8192 个）。拿到编号，就去取对应的那一行。这张表叫嵌入矩阵，取出来的那一行，就是这个词的嵌入向量。

嵌入矩阵里的数一开始是随机的。训练过程中，它们和网络的其他参数一起被反复调整。调整的结果是：经常出现在相似上下文里的词，向量会被推到相近的位置。

这就是第 2 章那把“相似度尺子”派上用场的地方：两个词向量的点积越大，意思越接近。经典的例子是“国王 − 男人 + 女人 ≈ 王后”：意思变成了方向，关系变成了可以加减的箭头。这个现象最早是在 word2vec 这类早期词向量中被观察到的；大模型内部的向量更复杂，但“相近的意思、相近的方向”这一原则不变。

5.3第三站：注意力，词与词互相打量

现在每个词都有了自己的向量。但问题来了：一个词的意思，常常取决于它周围的词。

看这句话：“小明把苹果给了小红，因为她饿了。”这里的“她”指谁？你一眼就知道是小红，因为“饿了”和“给了苹果”连在一起才说得通。可是“她”这个词的嵌入向量，是从表里查出来的固定一行，它根本不知道自己在这句话里指的是谁。

这就是注意力机制，Transformer 的核心。它的具体做法是，让每个词的向量分别乘以三个不同的矩阵，得到三个新向量：

• Q（查询）：我在找什么样的词？
• K（键）：我身上贴着什么标签，能被谁找到？
• V（值）：如果有人找到我，我能提供什么内容？

然后分三步：

1. 打分：每个词的 Q 和所有词的 K 做点积。n 个词两两打分，得到一张 n×n 的分数表。把所有 Q 排成矩阵、所有 K 排成矩阵，这一步就是一次矩阵乘法：Q·Kᵀ。（实际还会除以一个与向量维度有关的缩放系数，防止分数过大。）
2. 归一：用一个叫 softmax 的函数，把每一行分数变成加起来等于 1 的权重。
3. 混合：用这些权重，把所有词的 V 加权混合起来。这又是一次矩阵乘法：权重表 × V。

注意力 = softmax(Q·Kᵀ) · V打分（矩阵乘法）→ 归一（softmax）→ 混合（矩阵乘法）

还记得第 1 章矩阵的第三张脸吗？“第 i 行第 j 列 = i 和 j 的关系”。注意力的那张 n×n 权重表，就是一个关系矩阵。不同的是，它不是事先写好的，而是模型读每句话时现场算出来的。

注意力有一个重要的代价：n 个词两两打分，要算 n² 个分数。句子长度翻一倍，这一步的计算量翻两番。这就是为什么“长上下文”一直是昂贵的功能。一段 10 万 Token 的文档，光一张分数表就有 100 亿个格子，而每一层的每个注意力“头”都要算一张（实际实现会分块计算，不会一次存下整张表）。

5.4第四站：前馈网络，每个词各自加工

注意力让词与词交换了信息。接下来，每个词要各自“消化”一下收到的信息。这一步叫前馈网络（FFN），它就是第 4 章那个最标准的结构：

y = W₂ · 折痕(W₁ · x)先把向量展开到更高维（通常是原来的 3 到 4 倍），过一道折痕，再压回原来的维度

先升维再降维，就像把一件事“展开想一想，再收拢成结论”。展开的那个高维空间里，每一维都可以对应某种模式。研究者普遍认为，模型记住的大量事实性知识，就存在前馈网络的这些矩阵里。它们也是参数的大头：在一个典型的 Transformer 里，前馈网络约占三分之二甚至更多的参数。（现代模型常用一种叫 SwiGLU 的变体，用三个矩阵代替两个，但“展开、折痕、收拢”的结构不变。）

一层注意力加一层前馈网络，组成一个 Transformer 层。大模型把这样的层叠很多次：Llama 3.1 70B 有 80 层，405B 有 126 层。每经过一层，每个词的向量都被改写一次，吸收更多上下文，含义越来越具体。为了让这么深的网络训练得动，每一层的输出还会加回它的输入（叫“残差连接”），相当于每层只负责“补充修改”，而不是“推倒重来”。

5.5第五站：给出下一个词

经过所有层之后，取出最后一个词的向量。它已经吸收了整段话的信息。现在要把它变成“下一个词是什么”的答案。

办法还是矩阵乘法：用这个向量去乘一个“词表矩阵”，词表里的每个 Token 对应一列。结果是一个很长的向量，每个候选 Token 一个分数。这其实是拿当前的向量，和词表里每个词做了一次点积，看谁最“对味”。

分数再经过 softmax 变成概率，比如“动作”0.41、“过程”0.12……从中选出一个，接到文字末尾。然后，整个流程再来一遍。

从 Token 到回答，每一步都是查表、打分、混合

5.6算一笔账：说一个字要算多少次

第 4 章算过，一个有 N 个参数的模型，处理一个输入单位的前向计算约 2N 次运算。对大语言模型，这个单位就是 Token：每生成一个 Token，约 2N 次运算。

最后一行值得解释。DeepSeek-V3 用了一种叫混合专家（MoE）的结构：前馈网络不是一个，而是很多个“专家”，每个 Token 只被路由给其中少数几个。于是模型总共有 6710 亿参数（知识容量大），但每个 Token 只动用其中 370 亿（计算量小）。

即便如此，每说一个字，也要做几百亿到上千亿次乘法和加法。一个上千字的回答，就是上百万亿次运算。这个量级引出了下一章的问题。不过在那之前，先看一个和大模型关系密切的邻居。

5.7向量数据库：用点积找资料

大模型的知识停留在训练结束的那一刻，也不知道你们公司内部的文档。常见的补救办法叫 RAG（检索增强生成）：先从资料库里找出和问题相关的几段文字，塞进提示词里，再让模型回答。

怎么“找出相关的”？用的正是本章第二站的思路：

1. 用一个嵌入模型，把每篇文档（或每一段）变成一个向量，存起来。这就是向量数据库。
2. 用户提问时，把问题也变成一个向量。
3. 问题向量和所有文档向量做点积，分数最高的几篇就是最相关的。

把所有文档向量排成一个矩阵，第 3 步就是一次“矩阵乘向量”。

文档少的时候，挨个算点积就行。文档多到上亿篇时，挨个算太慢，就要用 HNSW 这类“近似最近邻”索引：先把向量组织成一张多层的邻居网络，查询时顺着网络快速跳到相关区域，只和一小部分文档做比较。它用一点点精度的损失，换来了成百上千倍的速度。

上一章留下的问题：每说一个字，要做几百亿到上千亿次乘加。可是 ChatGPT 的回答几乎不用等。这么大的计算量，是怎么在一眨眼间完成的？矩阵乘法有什么特别的性质，让它能被算得这么快？

假设你要在一小时内批改一万份小学数学试卷。你有两个选择：请一位数学教授，或者请一万个五年级的小学生，每人改一份。

教授当然更聪明，改一份可能只要十秒，但一万份要改一天多。一万个小学生每人改一份，哪怕慢一点、要一分钟，一分钟后也全部改完了。

这个选择成立，有一个前提：这一万份试卷可以分开改，谁也不用等谁。如果第二份试卷的答案要依赖第一份的批改结果，那一万个小学生也只能排队，还不如教授快。

本章要说明的是：矩阵乘法恰好是“一万份可以分开改的试卷”；而 GPU，恰好是那“一万个小学生”。

6.1每一格互不等待

这就是矩阵乘法能够并行的根本原因。用计算机的话说，它是一种数据并行的任务：同样的操作（点积），作用在大量互不相关的数据（不同的行列组合）上。

而且，这种“不等待”在神经网络里无处不在：

• 一层里的几千个神经元，各打各的分，互不等待；
• 一批里的几百个样本，各算各的，互不等待；
• 训练时，一段文本里的几千个 Token，可以同时算完所有层（注意力的遮罩保证了每个词只看前面，但计算可以一起做）。

最后一栏很重要。你看到 ChatGPT 的回答是一个词一个词“冒”出来的，正是因为生成过程在词与词之间是串行的。每一个词内部那上千亿次乘加，才是被并行“瞬间”完成的部分。

6.2CPU 和 GPU：两种不同的聪明

现在来看硬件。电脑里的 CPU 和 GPU，是两种不同设计思路的产物。

CPU 像几位博士。每个核心都很强：能处理复杂的分支判断（“如果……就……否则……”），能预测接下来要执行什么，配有大容量的缓存。它的设计目标是延迟：让每一件事尽快做完。操作系统、网页浏览器、数据库，这类充满判断和依赖的任务，是 CPU 的主场。

GPU 像上万个小学生。每个核心都很简单，不擅长复杂判断，但数量极多。以 NVIDIA H100 为例，它有 132 个“流式多处理器”（可以理解为 132 个班级），合计 16,896 个 CUDA 核心。它的设计目标是吞吐：单位时间里做完尽可能多的事。

GPU 最初是为画游戏画面设计的：屏幕上几百万个像素，每个像素的颜色计算方式相同、互不依赖。这和矩阵乘法“每一格互不等待”的性质如出一辙。于是，当深度学习需要海量矩阵乘法时，GPU 成了现成的最佳选择。

6.3Tensor Core：一次盖一个印章

后来，GPU 厂商发现，AI 的计算实在太集中在矩阵乘法上了，干脆为它造了专用的电路：Tensor Core（张量核心）。H100 有 528 个。

普通核心一次做一个乘法加一个加法。Tensor Core 一次直接完成一个小矩阵块的乘加：最早一代是把两个 4×4 的小块相乘再加到结果上，后来的型号块越来越大，一条指令就是成百上千次运算。

大矩阵怎么交给这些“印章”？办法叫分块：把 C 切成许多小块，每个班级（流式多处理器）领一块。班级把需要的那几行、几列从显存搬到身边的高速小仓库里，然后用 Tensor Core 一块一块地盖章，盖完再写回去。第 2 章说过矩阵乘法是 2n³ 次运算，这些运算最终几乎都由 Tensor Core 完成。

一块 H100 的 Tensor Core，按 BF16 格式、稠密计算，理论峰值是每秒 989 万亿次运算（989 TFLOPS）。这个数字第 7 章会细讲，这里先记住它的量级。

6.4内存墙：真正的瓶颈常常是“搬”

每秒 989 万亿次运算，听上去足以瞬间完成一切。可是第 5 章说，一个 700 亿参数的模型每个词只要 1400 亿次运算。按峰值算（先不管模型装不装得下一块卡），H100 一秒能生成好几千个词。实际上单用户使用时，一秒只有几十个词。差距在哪里？

数据是这样的：H100 的显存带宽是每秒 3.35 TB，算力是每秒 989 万亿次。两者一除：

989 × 10¹² ÷ 3.35 × 10¹² ≈ 295每从显存搬来 1 个字节，要做约 295 次运算，才能让计算单元不闲着

这个“每字节做多少次运算”，叫算术强度。逐字生成时，每个参数占 2 个字节（BF16），只做 2 次运算，算术强度约为 1。离 295 差了近 300 倍。于是计算单元绝大多数时间都在等数据，算力利用率不到 1%。

怎样提高算术强度？最直接的办法：批处理。同时为 32 个用户生成下一个词，搬来的每个参数就可以用 32 次，算术强度升到约 32，实际算力一下子提高 30 多倍。这就是云服务商总是把很多用户的请求打包一起算的原因。

而训练时的大矩阵乘法，情况完全不同。两个 n×n 的矩阵相乘，运算是 2n³ 次，数据只有约 3n² 个数（BF16 下约 6n² 字节），算术强度约为 n/3。n = 4096 时约 1365，远远超过 295，算力可以被吃满。

这个图解释了硬件发展的很多选择。GPU 为什么要用昂贵的 HBM（高带宽内存，把内存芯片堆叠起来，紧挨着 GPU 封装）？因为带宽是生成速度的命门。为什么新一代 GPU 的带宽增长总是备受关注？因为算力涨得比带宽快：据 Epoch AI（一家专门追踪 AI 算力、硬件与模型规模趋势的研究机构）统计，GPU 显存带宽每年只增长约 28%，慢于算力的增长；如果算上 FP8、FP4 这类低精度格式带来的算力跃升，差距更大。这道越来越高的“内存墙”，是整个行业的共同难题。

每一格互不等待，所以能并行；
真正的瓶颈常常不是算，而是搬

6.5一张卡不够：让网络成为计算机的一部分

最后一个问题。第 4 章算过，GPT-3 的权重就要约 350 GB，训练时加上梯度和优化器状态还要多好几倍，而一块 H100 只有 80 GB 显存。更何况，训练一个前沿模型的运算量，一块卡要算上几千年（第 8 章会算）。所以必须多卡协作。

怎么把工作分给几千、几万块卡？有四种基本方式：

1. 数据并行：每张卡都有完整的模型，各自处理不同的数据。算完一步后，大家把各自的梯度求个平均，再同步更新。这个“求平均”的通信操作叫 All-Reduce。
2. 张量并行：一个矩阵太大，按行或列切成几块，分给几张卡各算一部分。这正是 6.1 节“每一格互不等待”的直接应用，只是这次分工的对象从核心变成了整张卡。代价是每一层都要交换结果，通信非常频繁。
3. 流水线并行：第 1 到 32 层放在第一组卡上，第 33 到 64 层放在第二组……数据像装配线上的零件一样依次流过。
4. 专家并行：MoE 模型的几百个专家分布在不同的卡上，每个 Token 被发送到它需要的专家所在的那张卡。

这四种方式有一个共同点：卡与卡之间要不停地交换数据。张量并行每一层都要交换，数据并行每一步都要 All-Reduce，专家并行要把 Token 在卡之间来回发送。计算被切得越碎，通信就越频繁。

于是，GPU 之间的连接变得和 GPU 本身一样重要：

• 卡与卡之间（同一台服务器内）：NVIDIA 的 NVLink，H100 每张卡约 900 GB/s，比普通的 PCIe 快好几倍。张量并行这种高频通信，通常只在 NVLink 连着的卡之间进行。
• 机器与机器之间：InfiniBand，或者支持 RDMA（让一台机器直接读写另一台机器的内存，绕开操作系统）的以太网（RoCE）。成千上万台服务器组成一张专门的高速网络，拓扑、拥塞控制、丢包处理的任何一点瑕疵，都会让几万块 GPU 一起停下来等待。

对网络工程师来说，这是一个值得停下来想一想的转变：在 AI 训练集群里，网络不再只是连接计算机的管道，它本身就是计算机的一部分。一次 All-Reduce 的时延，直接体现为训练时间；一条链路的拥塞，可能让整个集群的利用率下降。第 7 章的规格表里，你会看到“互联带宽”和“算力”被并列为同等重要的指标。

上一章留下的问题：989 TFLOPS、3.35 TB/s、80 GB、900 GB/s，再加上 FP8、FP4、“稀疏”……到底哪个数字才代表“快”？怎样读懂一张 GPU 规格表，不被营销口径带偏？

打开任何一家 GPU 厂商的产品页，迎面而来的是一张密密麻麻的表：十几行指标，每一行后面跟着一个很大的数字，单位从 TFLOPS 到 PFLOPS，从 GB 到 TB/s。发布会上，新一代产品总是比上一代“快几倍”甚至“快几十倍”。

这些数字都是真的，但每一个都有它的口径。不懂口径，就像比较两辆车的“最高时速”，却不知道一个是在平路上测的，一个是在下坡时测的。

本章的目标很具体：读完之后，你拿到任何一张 GPU 规格表，都能问出五个正确的问题。

7.1先分清两个词：FLOP 和 FLOP/s

GPU 的“算力”用浮点运算来衡量。浮点运算就是带小数点的数字之间的一次加法或乘法，英文缩写是 FLOP。这里有一个极易混淆的地方：

• FLOP（或 FLOPs）：运算的次数，是一个总量。比如“训练 GPT-3 用了 3.14×10²³ FLOP”。这种数大到读不出感觉，第 8 章会把它换算成“一块 GPU 要算多少年”。
• FLOP/s（常写成 FLOPS）：每秒的运算次数，是一个速度。比如“H100 的算力是 989 TFLOPS”。

两者的关系和“公里”与“公里每小时”一样：总量 ÷ 速度 = 时间。第 8 章的估算，全靠这一个除法。

这些数字很大，所以要用前缀：

第 8 章会出现 10²⁵ 这样的数，它已经超出了常用前缀，直接用科学计数法。

7.2精度：一把尺子的长度和刻度

规格表上的算力，总是和一个数字格式绑在一起：FP32、BF16、FP8、FP4……同一块 GPU，格式不同，算力可以相差十几倍。先弄懂这些格式是什么。

计算机存储一个小数，用的是类似“科学计数法”的方式：一个符号（正或负），一个指数（10 的几次方，决定数的大小范围），一段尾数（有效数字，决定精细程度）。格式名里的数字，就是总共用几个比特（二进制位）。

低精度为什么快？两个原因。第一，每个数占的字节少了，同样的带宽能搬更多数，第 6 章的“搬”压力直接减轻。第二，Tensor Core 里做一次 8 位乘法的电路，比 16 位的小得多，同样的芯片面积可以塞进更多乘法器。所以在规格表上，精度每减半，算力大致翻一倍。

读表提醒比较两块 GPU 的算力时，必须在同一种精度下比较。用新卡的 FP4 算力去比旧卡的 FP16 算力，“快几倍”里有一大半来自格式变了，而不是芯片变强了。

7.3稀疏：规格表上最常见的“×2”

规格表上还有一个更隐蔽的口径：稀疏（sparse）与稠密（dense）。

NVIDIA 的 Tensor Core 支持一种叫“2:4 结构化稀疏”的模式：如果矩阵里每 4 个数中恰好有 2 个是 0，硬件可以跳过这些 0，速度翻倍。规格表上的算力，常常印的是这种稀疏模式下的数字，并在脚注里小字注明。

以 H100 为例：官方标称的 BF16 算力是 1979 TFLOPS，但那是稀疏口径；按普通的稠密矩阵计算，是 989 TFLOPS。本书用的一律是稠密口径。

问题在于，绝大多数模型在训练和推理时并不满足这种严格的“每 4 个里有 2 个 0”的结构。所以在估算真实性能时，应该先把稀疏数字除以 2。

7.4五个指标，五个问题

现在可以系统地读规格表了。对 AI 来说，真正重要的指标只有五个，每个回答一个问题：

1. 算力（FLOPS）：它最多能算多快？——先看精度、再看稠密还是稀疏。
2. 显存容量（GB）：模型装不装得下？——第 4 章算过，70B 模型在 BF16 下光权重就要约 140 GB。
3. 显存带宽（TB/s）：数据能搬多快？——第 6 章说过，逐字生成时它才是决定速度的因素。
4. 互联带宽（NVLink，GB/s 或 TB/s）：多卡之间交流多快？——决定了张量并行等多卡协作的效率。
5. 功耗（W）：它要吃多少电、散多少热？——决定了一个机房能放多少张卡，也决定了电费。

B200 的稠密算力由官方 8 卡 HGX 平台的稀疏数据折算（÷8 ÷2），显存与带宽由 DGX B200 整机数据 ÷8 得出。* Rubin 数字来自 NVIDIA HGX 页面，官方脚注注明为稠密口径、属初步信息且可能变更；发布会常引用的“NVFP4 推理 50 PFLOPS”是稀疏口径。† 官方页面只给出 DGX B200 整机最大功耗约 14.3 kW（8 卡加 CPU 等）。“—”表示此处不引用。各项出处见附录。

看这张表，可以读出几个趋势：

• 低精度算力涨得最快：新格式（FP8、FP4）本身就带来了成倍的数字增长。发布会上“快几十倍”的说法，多半来自这里。
• 同一精度下看，带宽追得并不慢：从 H100 到 Rubin，BF16 稠密算力增长约 4 倍（989 TFLOPS → 4 PFLOPS），带宽则增长约 6.6 倍（3.35 → 22 TB/s）。这一代厂商显然在全力补“内存墙”。但放到更长的时间里，据 Epoch AI 统计，显存带宽每年只增长约 28%，仍是被持续追赶的那一方。
• 显存容量持续增长，让单卡能装下更大的模型，减少多卡拆分的麻烦。
• 互联带宽每代翻倍，说明厂商把卡间通信看得和算力一样重要。

7.5两道例题：从规格到体验

例题一：一个人和大模型聊天，每秒能出几个字？

假设一个 700 亿参数的模型，用 FP8 格式（每个参数 1 字节），权重共 70 GB，一块 80 GB 的 H100 装得下（剩下的空间留给第 6 章说的 KV 缓存）。只有你一个人在用。

同样的计算：B200 带宽约 8 TB/s，上限约 114 个 Token/秒；按 Rubin 公布的 22 TB/s，上限约 314 个。注意，这里完全没用到算力数字。一个人用的时候，决定速度的是带宽。这是理论上限，实际还要读 KV 缓存、有各种开销，会更低一些。

如果同时服务很多人，情况就变了：搬一次权重可以为很多人各算一个 Token，总吞吐大幅上升，瓶颈逐渐移向算力。这就是第 6 章屋顶线的实际含义。

例题二：标称算力和实际算力差多少？

训练时的大矩阵乘法能吃满算力吗？看一个公开的真实数据：Meta 训练 Llama 3.1 405B 时，用了最多 16,384 块 H100，报告的模型算力利用率（MFU，实际用于模型计算的算力 ÷ 标称峰值）是 38% 到 43%。

也就是说，即便是世界上最有经验的团队、在最适合并行的训练任务上，也只用到了标称算力的四成左右。剩下的六成去哪了？等数据搬运、等卡间通信、注意力之类不那么高效的计算、故障恢复……

标称是天花板，不是日常

7.6一张可以随身带的清单

把本章浓缩成拿到任何一张 GPU 规格表时要问的五个问题：

上一章留下的问题：我们有了尺子：一块 H100 按 BF16 稠密每秒 989 万亿次，实际能用四成左右。那么，训练一个前沿大模型，到底需要多少次运算、多少数据、多少块 GPU、多少天、多少电？

这是很多人最想知道、也最容易被夸大或误解的问题。本章会给出答案，但先说一句必须说在前面的话：

数据口径OpenAI、Anthropic、Google 都没有公开其旗舰模型的参数量、训练数据量和训练算力。“ChatGPT”是一个产品名，背后是 GPT-5 系列等模型，还会不断更新。本章关于闭源模型的所有数字，都来自外部研究机构（主要是 Epoch AI）的估算，或本书按公开方法做的推测，都会明确标注。有公开数据的模型，我们用公开数据。每一条的核查结果和出处，见书末附录。

好消息是，你并不需要内部数据，也能自己估出量级。方法只有一个公式，而这个公式你在第 4、5 章已经见过了。

8.1一个公式：C ≈ 6ND

C ≈ 6 · N · DC = 训练总运算量（FLOP）；N = 参数量（MoE 模型用每个 Token 激活的参数）；D = 训练 Token 数

这个公式忽略了注意力的额外开销等细节，但对大模型来说，误差通常在可接受范围内。它的好处是简单：知道参数量和数据量，就能算出训练总量。

先学会读这么大的数

用这个公式算出来的数，会大到失去意义。前沿模型的训练量在 10²⁶ 左右：1 后面跟 26 个零，读作“一百亿亿亿”次。人对“一亿”还有点感觉，对“亿亿亿”就只剩下“很大”两个字。

所以本章换一把尺子：不数“多少次”，而问一块 GPU 要算多久。第 7 章说过，一块 H100 按 BF16 稠密口径，实际每秒大约能做 4×10¹⁴ 次（989 TFLOPS × 40% 利用率）。用它当单位：

从 10²³ 那一行起，每往下一行，指数加 1，时间乘以 10。计算：训练算力 ÷（989×10¹² × 40%）÷ 每年约 3,156 万秒。

只需要记住一个锚点：10²⁶ ≈ 一块顶级 GPU 不停地算 8,000 年。其余的数都可以从它推出来：多一个数量级，就乘以 10。

这把尺子也顺便解释了为什么训练要用十万块 GPU：8,000 年的活，分给 10 万块卡同时干，就是 8,000 × 365 ÷ 100,000 ≈ 29 天。第 6 章讲的“每一格互不等待”，在这里变成了把几千年压缩到一个月的能力。

10²⁶ ≈ 一块 GPU 算 8,000 年 ≈ 10 万块 GPU 算 一个月

8.2用公开数据验算

先拿三个公开了训练细节的模型来检验这个公式。

来源：GPT-3 论文；Meta《The Llama 3 Herd of Models》及模型卡；DeepSeek-V3 技术报告。DeepSeek-V3 按每 GPU·时 2 美元折算，正式训练约 557.6 万美元，不含此前的研究与试验。

公式和公布值几乎完全吻合。再用第 7 章的尺子验算一下 Llama 3.1 的 GPU·小时：

3.8×10²⁵ ÷ (989×10¹² × 40%) ÷ 3600 ≈ 2,670 万 GPU·时公布值约 3,084 万：实际利用率 38%–43%，外加故障重启等开销

量级对上了。这说明，只要知道“算多少”（6ND）和“算多快”（卡数 × 峰值 × 利用率），就能估出“算多久”。

表里还有一个有意思的对比。DeepSeek-V3 的总参数比 Llama 3.1 405B 多，训练数据相近，但训练算力只有后者的十分之一左右。原因是它的 MoE 结构：每个 Token 只激活 370 亿参数（第 5 章），6ND 里的 N 小了十倍。此外，它在训练中大量使用了 FP8 这种更低的精度（第 7 章）：这不会减少运算的次数，却让每次运算更便宜，于是需要的 GPU·时更少。这个例子说明，算法和工程上的改进，可以让同样的能力便宜得多。

8.3闭源旗舰：我们能知道什么

现在回到你最关心的问题：GPT-5、GPT-6 这样的模型。我们能诚实地说出什么？

截至 2025 年 6 月，Epoch AI 已识别出 30 多个训练算力超过 10²⁵ FLOP 的模型。

GPT-5 那一行值得多说几句。按照过去的规律，OpenAI 每一代整数版本，训练算力大约增长 100 倍。但 Epoch AI 在 2025 年 9 月的分析认为，GPT-5 的训练算力很可能少于 GPT-4.5。原因是新出现的“推理模型”训练方法：在预训练之后，用强化学习大规模地“后训练”，教模型一步步思考。这种方法效果很好，同样的表现所需的预训练算力可以降到约十分之一。于是 OpenAI 把资源集中在一个较小的模型上做大量后训练，而不是继续放大预训练。

同一份分析也预计：当后训练的方法成熟、可以在更大规模上使用时，训练算力会回到增长的轨道上，GPT-6 的训练算力很可能超过 GPT-4.5。

那么，如果你问“训练 GPT-6 要多大算力”，最诚实的回答是一个量级区间，而不是一个假装精确的数字：

• 训练算力：10²⁶ 到 10²⁷ FLOP 以上，也就是一块 H100 要不停地算 8,000 年到 8 万年以上。依据：GPT-4.5 已在 10²⁶ 量级，Grok 3 约 4.6×10²⁶；从 GPT-4 的约 2×10²⁵ 按“每代约 100 倍”外推，是 2×10²⁷；前沿训练算力每年约增长 5 倍。
• 训练数据：数十万亿 Token。Meta 的官方模型卡显示，Llama 4 Scout 预训练约 40 万亿 Token、Maverick 约 22 万亿 Token（多模态数据）；再加上大量合成数据和后训练数据。
• 硬件：十万块以上 H100 等效的 GPU，训练数月。已知最大的 AI 数据中心，计算能力约相当于 110 万块 H100。
• 成本：仅最终一次训练就在数亿美元量级。作为参照，Epoch AI 估计 Grok 4 的训练成本约 5 亿美元。

8.4自己动手：餐巾纸估算

现在用本书的全部工具，自己估算一次。目标：训练算力 10²⁶ FLOP，大致是当前前沿水平，也就是那块“要算 8,000 年”的 GPU 的工作量。

粗算，只计最终一次训练。每卡 1.4 kW、每小时 2 美元、每户每年约 2,500 度都是简化假设（依据见附录）；真实项目还有大量试验、失败重跑、数据处理和后训练的开销。

如果目标是 10²⁷ FLOP 呢？运算量乘以 10。换成 B200（BF16 稠密约 2.25 PFLOPS），同样按 40% 利用率：约 3.1 亿 GPU·时，10 万块卡要四个多月，按每小时 2 美元计约 6 亿美元。换成一个 100 万块 H100 等效的超大集群，大约一个月。

这些数字到底有多大？换一种体感：

• 人力：假如地球上 80 亿人每人每秒做一次乘法或加法，不吃不睡，算完 10²⁶ 次需要约 4 亿年；算完 Llama 3.1 405B 的 3.8×10²⁵ 次，也要约 1.5 亿年。
• 阅读：15 万亿个 Token 约合 11 万亿个英文单词。一个人每分钟读 250 个词、每天读 8 小时，要读约 25 万年。

下面是几组参考结果（均按 H100、利用率 40%）。网页版还提供一个估算器，可以换成你感兴趣的参数试试。

6ND ÷（卡数 × 峰值 × 利用率）＝ 你自己的估算器

8.5不只是“最后那一次”

餐巾纸估算只算了最终一次预训练。真实的前沿模型开发，还有几块同样巨大的开销：

1. 试验：在正式训练之前，要用小模型反复试验数据配比、网络结构、超参数。研发阶段消耗的算力，往往远大于最后一次训练。
2. 后训练：指令微调、人类反馈强化学习、推理能力的强化学习。8.3 节说过，它正在成为算力的新重点。
3. 推理：模型上线后，每天为海量用户生成回答。据 Epoch AI 估计，2024 年 OpenAI 的算力支出中约 30% 用于推理，其余主要用于研发和训练。随着用户增长，推理的比重还在上升。

数据墙

算力可以靠造更多的数据中心来增加，数据呢？

DeepMind 在 2022 年的 Chinchilla 研究发现，在固定算力下，训练效果最好的配比大约是每个参数配 20 个 Token。按这个配比，10²⁶ FLOP 对应约 9000 亿参数、18 万亿 Token；10²⁷ FLOP 对应约 2.9 万亿参数、58 万亿 Token。实际上，现代模型为了让推理更便宜，常常把较小的模型训练得远超这个配比，比如 Llama 3 的 80 亿参数版本用了 15 万亿 Token，相当于每个参数近 1,900 个 Token。

问题是，人类写下的高质量文本是有限的。Epoch AI 估计，可用的高质量公开人类文本约在 300 万亿 Token 的量级，可能在 2026 到 2032 年之间被用尽（这一估算有争议）。这就是所谓的“数据墙”。应对的方向包括：用模型生成的合成数据、让模型在强化学习中通过“做题”自己产生训练信号、加入图像视频等多模态数据。

另一条曲线：算法在变便宜

最后，别忘了一个经常被忽视的趋势：据 Epoch AI 统计，达到同样的效果，所需的算力每年大约降到三分之一。DeepSeek-V3 就是一个例子。这意味着：今天需要 10²⁶ FLOP 才能训练出来的能力，几年后可能只需要十分之一甚至百分之一。

所以前沿模型的算力在以每年约 5 倍的速度增长，而“同样的能力”在以每年约 3 倍的速度变便宜。两条曲线叠加，是这几年 AI 能力进展如此之快的根本原因。

上一章留下的问题：从“一串数”出发，我们一路走到了十万块 GPU 和上亿度电。回过头看，这条路上真正的基石是什么？矩阵运算能解释智能的全部吗？

序章里，我请你用一句话回答“矩阵是什么”，并把答案记在手边。现在可以拿出来对照了。

如果你当时写的是“一张由数字排成的表格”，这句话并没有错。但现在你知道了，那只是矩阵的“存法”。它更本质的身份是：一个动作，一台把一串数变成另一串数的机器。表格里的每个数，都是这台机器的一个旋钮。

∞.1兑现四个承诺

序章做过四个承诺。逐条检查一下。

承诺一：用一句话说清矩阵是什么

矩阵是一个动作：它的每一列记录一根基向量被搬到了哪里，任何向量都跟着这些基向量走。这句话同时解释了“行乘列”：两个动作连着做，要写成一个矩阵，唯一的规则就是行乘列。（第 1、2 章）

承诺二：解释为什么 AI 几乎全是矩阵乘法

AI 是从数据里学一个函数；最简单、最好组合的函数是加权混合，也就是矩阵乘法；加一道折痕就能弯出任何形状；而 Transformer 的每一步，查表、打分、混合，都是矩阵乘法。再加上一条算术事实：矩阵乘法的运算量随 n³ 增长，其他运算只随 n² 增长，所以算力几乎都花在它身上。（第 2 到 5 章）

承诺三：看懂一张 GPU 规格表

看算力先问精度和稀疏口径；看单用户速度先看显存带宽；看多卡规模先看互联；最后记住，标称是天花板，大规模训练的实际利用率常在四成左右。（第 6、7 章）

承诺四：在餐巾纸上估算训练一个大模型

C ≈ 6ND，除以“卡数 × 峰值 × 利用率”，就是时间；乘以每卡功耗，就是电；乘以每小时租金，就是钱。10²⁶ FLOP 这个读不出感觉的数，换算过来就是一块 H100 不停地算 8,000 年，或者 10 万块 H100 算一个月。（第 8 章）

∞.2三句话，第三次

序章预告过，有三句话会从不同角度反复出现。现在，它们应该不再是需要记住的口号，而是你能自己推出来的结论：

1. 矩阵是一个动作。第 1 章从几何推出它，第 4 章在“一层神经网络”里再见到它，第 5 章在“旋转位置编码”里又见到它。
2. 乘法就是加权混合。第 2 章在面包店里推出它，第 3 章在滤镜和卷积核里见到它，第 5 章在注意力里再见到它。
3. 每一格互不等待，所以能并行；真正的瓶颈常常不是算，而是搬。第 6 章推出它，第 7 章在规格表的带宽一栏见到它，第 8 章在卡间网络和利用率里再见到它。

∞.3本书的核心贡献

1. 从“表格”到“动作”
   矩阵最本质的身份是一台加工向量的机器；列 = 基向量的去向。
2. “行乘列”不是规定，是推论
   它是让“两个动作连着做”成立的唯一规则，所以顺序不能交换。
3. 乘法是接线
   加法只让同位置的数相遇，乘法让每个输入影响每个输出；它也最贵，运算量随 n³ 增长。
4. 矩阵是通用接口
   叠加原理、局部线性、几十年打磨的 GEMM 与硬件，让各领域的问题都愿意写成矩阵。
5. 智能 = 矩阵 × 折痕 × 梯度
   没有折痕，多少层都等于一层；学习就是把矩阵里的数一点点调对。
6. 并行来自独立，瓶颈在于搬运
   每格互不等待，所以能交给上万个核心；算术强度决定了算力能用上几成。
7. 规模可以估算
   6ND 加上一把正确读懂的尺子，就能在餐巾纸上算出前沿模型的量级。

∞.4最后一道围栏

写到这里，必须防止一种误读：既然 AI“全是矩阵乘法”，那智能就“只不过是”矩阵乘法吗？

这道围栏也适用于我们自己。大学时，我们学会了“怎么算”，却没人告诉我们“在算什么”。今天的大模型，某种意义上把这个处境放大到了极致：它能流畅地“算”出答案，却不一定“懂”这个答案。

∞.5留给你的五个问题

最后，没有总结陈词，只有五个问题。它们没有标准答案，值得你在合上书之后再想一想。

1. 如果一台机器仅靠海量的“加权混合”就能写诗、编程、解题，那么你自己的思考里，有多少其实也是某种加权混合？又有哪些部分不是？
2. 当“生成答案”变得几乎免费，什么会变得更稀缺：一个好问题、一份高质量的数据，还是一个可靠的判断？
3. 你的工作里，哪些环节是“每格互不等待”、可以被大规模并行的？哪些环节天生是“斐波那契式”的、必须一步等一步？
4. 本书反复强调“标称是天花板，不是日常”。在你评估任何新技术、新产品时，你会问哪些“口径”问题？
5. 前沿模型的算力每年增长约 5 倍，同样能力的成本每年降到约三分之一。五年后，今天的哪些“不可能”会变得平常？你准备好了吗？

∞.6延伸阅读

书中每一个数字的出处和核查结果，见书末附录：事实核查与出处。

• 3Blue1Brown：《线性代数的本质》系列视频（本书第 1、2 章的几何直觉，与它一脉相承）
• Gilbert Strang：MIT 18.06《线性代数》课程
• Vaswani 等：《Attention Is All You Need》（2017，Transformer 的原始论文）
• Kaplan 等：《Scaling Laws for Neural Language Models》（2020）
• Hoffmann 等：《Training Compute-Optimal Large Language Models》（2022，Chinchilla）
• Meta：《The Llama 3 Herd of Models》（2024）
• DeepSeek-AI：《DeepSeek-V3 Technical Report》（2024）
• Epoch AI：“Trends in AI”数据与分析

∞.7术语速查

向量

一串有顺序的数，用来描述一个东西；数的个数叫维度。（第 1 章）

矩阵

一个动作：把向量变成向量；m×n 的矩阵吃进 n 个数，吐出 m 个数。（第 1 章）

线性变换

原点不动、直线不弯、格子一样的变换；恰好是矩阵能做的全部动作。（第 1 章）

点积

对应位置相乘再相加，即加权求和；也是衡量两个向量有多“对味”的打分。（第 2 章）

行列式

2×2 矩阵的 ad − bc，表示面积放大的倍数；为 0 时信息被压扁丢失。（第 1 章）

秩

矩阵中真正独立的“花样”数量；低秩近似可以大幅压缩数据。（第 3 章）

参数

模型各矩阵里所有可调的数；训练就是调它们。（第 4 章）

损失

模型输出与正确答案差多少的一个数；训练的目标是让它变小。（第 4 章）

梯度

损失在当前位置往哪个方向增长最快；沿反方向迈一小步就是梯度下降。（第 4 章）

Token

大语言模型处理文字的基本单位，即词块；中文约 1–1.5 字一个。（第 5 章）

嵌入

把 Token 编号变成向量：到嵌入矩阵里取对应的一行。（第 5 章）

注意力

softmax(Q·Kᵀ)·V：每个词给其他词打分，再按权重混合它们的信息。（第 5 章）

FFN（前馈网络）

Transformer 每层里“矩阵、折痕、矩阵”的部分，每个词各自加工，占参数的大头。（第 5 章）

MoE（混合专家）

很多个前馈网络“专家”，每个 Token 只路由给少数几个；总参数大、每次计算量小。（第 5 章）

KV 缓存

生成时把前面每个词的 K、V 存起来复用，省计算但增加显存读取。（第 6 章）

RAG

检索增强生成：先找相关资料塞进提示词，再让模型回答。（第 5 章）

向量数据库

存放文档向量、用点积（或近似索引）快速找相似内容的数据库。（第 5 章）

FLOP

一次浮点运算；也指运算的总次数。（第 7 章）

FLOP/s

每秒浮点运算次数，衡量速度；常写作 FLOPS。（第 7 章）

BF16 / FP8 / FP4

16、8、4 位的数字格式；位数越少越快越省，但量程或精度越有限。（第 7 章）

HBM

高带宽内存：堆叠在 GPU 旁边的显存，带宽决定逐字生成的速度。（第 6、7 章）

算术强度

每搬 1 字节数据做多少次运算；H100 需约 295 才能吃满算力。（第 6 章）

MFU

模型算力利用率：实际用于模型计算的算力 ÷ 标称峰值。（第 7 章）

NVLink

NVIDIA GPU 之间的高速互联，用于同一台服务器内的卡间通信。（第 6、7 章）

All-Reduce

多张卡把各自的数据（如梯度）汇总求和或求平均、再分发回每张卡的通信操作。（第 6 章）

这本书用了大量数字。为了让你可以自己核对，我们把书中所有可以核查的陈述整理成 40 条，于2026 年 9 月 30 日逐条联网回到原始出处核实：论文原文（arXiv PDF）、厂商官方规格页、官方模型卡、研究机构原文，以及少量百科条目。无法联网核实的，明确标为“假设”。

核查的原则有三条：第一，只认原始出处，不转引二手报道；第二，出处页面上的原话或原表格必须能直接支持书中的说法；第三，书中自己算出来的数，用脚本重新算一遍。

A.1这次核查改了什么

• Llama 4 训练数据（第 8 章）：原文“超过 30 万亿 Token”出自 Meta 博客，本次无法抓取核实；改用官方模型卡：Llama 4 Scout 约 40 万亿、Maverick 约 22 万亿 Token（多模态数据）。
• B200 规格（第 7 章）：HGX B200（8 卡）：FP16/BF16 36 PFLOPS、FP8 72 PFLOPS 为稀疏口径（“Dense is ½ sparse spec shown”），FP4 为 144|72 PFLOPS（稀疏|稠密）→ 单卡稠密约 2.25 / 4.5 / 9 PFLOPS；DGX B200 显存 1,440 GB、带宽 64 TB/s → 单卡 180 GB、8 TB/s；NVLink 单卡 1.8 TB/s。所抓取的官方页面未给出单卡功耗（仅 DGX B200 整机最大约 14.3 kW），原文“约 1000 W”改为注明此口径。
• Rubin 算力口径（第 7 章）：HGX Rubin 页单卡规格：FP16/BF16 4 PFLOPS 注“Dense specification”（稠密）；NVFP4 推理 50 PFLOPS 注“specification is sparse”（稀疏）；NVFP4 训练 35、FP8 训练 17.5 PFLOPS（稠密）；288 GB HBM4、22 TB/s；NVLink 3.6 TB/s；全部为“Preliminary information… subject to change”。据此，H100→Rubin 的 BF16 稠密算力增长约 4 倍（原文写作 2–4 倍）。
• GPT-4.5 估算的表述（第 8 章）：Epoch AI：GPT-4 2.1e25（推测级）；GPT-4.5 在同一页面分别给出 2.1e26（模型表）与 6.4e25（说明表）；Grok-3 4.6e26（Confident）；截至 2025 年 6 月识别出 30 多个超过 10²⁵ FLOP 的公开模型。原文“先后给出”改为“同一页面给出两个估计”。
• BLAS 第三级的年代（第 3 章）：BLAS 于 1979 年 9 月发布（Lawson 等）。第三级 BLAS（矩阵乘矩阵，含 GEMM）于 1987–1988 年提出，1990 年由 Dongarra 等正式发表于 ACM TOMS。原文“1990 年扩展出”改为“80 年代末提出、1990 年正式发表”。
• “8 万年”的参照物（第 8 章）：现代人走出非洲约在 7 万–5 万年前，“8 万年 = 从现代人走出非洲算起”不准确，改为“比现代人走出非洲（约 7 万–5 万年前）还要久”；新石器时代约公元前 10000–2000 年（8,000 年前在其中）；南宋 1127–1279 年（800 年前在其中）。

仍需留意闭源模型（GPT-4、GPT-4.5、GPT-5、Grok 3/4）的训练算力，出处本身就是外部研究机构的估算，“一致”只表示书中如实转述了这些估算，不表示估算本身已被官方证实。Rubin 的规格是官方初步信息，量产时可能变化。

A.2模型与训练数据

A.3方法与论文

A.4GPU 规格

A.5算力趋势与外部估算

A.6历史与领域知识

A.7常识与参照物

A.8本书采用的假设

A.9本书自行推导的数字