梯度下降早就有了，大模型为什么最近几年才出现

在《Transformer 是怎么训练的》里，我们手算过一个只有一个旋钮的机器：损失是 $L=(2w-6)^2$，每一步按下面这条规则拧一下旋钮。

w ← w − 学习率 × dL/dw

后面那个 10 个参数的 Transformer 用的也是这一行，只不过 $w$ 从一个数变成了十个数，损失换成了交叉熵，训练时屏幕上打出 0.615、0.594、0.572……。交叉熵这个数还有一个更朴素的读法：把对数的底换成 2，它就是模型每猜一个字，平均要花几个比特去纠正自己。花得越少，拿它去压缩文字就压得越小。所以训练一个语言模型，换个说法就是在训练一个压缩器。

顺着这个读法往前找，会碰到一句更大胆的话：压缩即智能。2006 年起有人专门悬赏，谁能把一份维基百科压得更小，谁就领奖，理由是压缩文字和人工智能本来就是同一个问题。

这样看，大模型像是几件旧东西拼起来的：梯度下降是 1847 年一位法国数学家为了算行星轨道写下的，“预测就是压缩”是香农在 1948 年说清楚的，求导的链式法则更是莱布尼茨在 1676 年就写出来了。既然这些都早就有了，为什么大模型直到最近几年才出现？之前的一百多年里，这些办法没被拿来做这件事吗？还是做过，没做成？ 一个压缩器，又凭什么看起来像有了智能？

我们顺着时间往下走，在每一个路口停下来看两件事：当时的人手里有什么工具，他们能把世界上的文字“压”到多小。

一、梯度下降的来历

最小二乘：用误差去调参数

1801 年元旦，意大利天文学家皮亚齐发现了一颗新的小行星，也就是后来的谷神星。他跟踪了 40 天，谷神星就转到太阳背后看不见了。要在半年后重新找到它，得从这 40 天的观测里反推出它的轨道。

一条椭圆轨道由 6 个数确定（轨道的大小、形状、倾角等，天文学上叫轨道根数）。观测有误差，6 个数怎么取都不可能让每一次观测都对上，所以问题变成：哪一组数让总误差最小？ 高斯的回答是把每次观测的误差平方、加起来，让这个和最小。他用这个办法算出的轨道，让天文学家在年底重新找到了谷神星。勒让德在 1805 年先发表了这个方法，高斯 1809 年发表时说自己 1795 年就在用，这就是最小二乘法¹。

这里已经出现了训练的全部要素：一组要调的参数（6 个轨道根数），一个衡量好坏的损失（误差平方和），还有一批数据（观测记录）。只是最小二乘的损失形状特别好，令导数等于零，解一组线性方程就能一步得到答案，用不着“一步步走”。

换个角度看，这也是一次压缩。40 天的观测记录被概括成了 6 个数，再加上一串很小的误差：只要记住这 6 个数和误差，就能把全部观测原样“解压”回来，规律找得越准，误差越小，要另外记的东西就越少。这种“规律 + 残差”的写法，在 30u30 那篇里叫两部分码，后面还会反复出现。

Cauchy：一步步往下走

方程不是线性的时候，就没有一步到位的公式了。1847 年 10 月，柯西（Cauchy）向法国科学院提交了一篇只有三页的短文，讨论的还是天文计算：要解一组复杂的方程，不妨把所有方程的误差平方加起来变成一个函数，然后沿着这个函数下降最快的方向，走一小步，再重新看方向，再走一小步²。这就是梯度下降。今天的优化教科书都把这个方法记在柯西名下，不过他在文中并没有认真分析这样走会不会收敛³。

一百年后的 1951 年，Robbins 和 Monro 又补上了一块：如果每次只能看到带噪声的测量，比如每次只抽一部分数据来算梯度，这样一步步走下去仍然能逼近答案⁴。这是今天“随机梯度下降”每次只取一小批样本的数学源头。

图 1把三个用了同一条规则的问题摆在一起。柯西的问题只有几个参数，手算几步就够了；GPT-3 有 1750 亿个参数，一共走了大约 9.4 万步，每一步要做的乘法是 $10^{18}$ 量级。公式本身一个字也没改。

所以，调参数的数学在 19 世纪就齐了。可是要把它用在文字上，还得先回答一个问题：对一个读文字的机器来说，什么叫“调好了”？损失应该衡量什么？

二、预测与压缩

香农：一个字值几个比特

1948 年，贝尔实验室的香农发表了《通信的数学理论》⁵，回答的是一个工程问题：一段消息最少要用几个比特才能传过去？

他的答案是，消息里每个符号的代价取决于它有多出人意料。一个出现概率是 $p$ 的符号，最少要用 $\log_2(1/p)$ 个比特来记：概率 1/2 的要 1 比特，概率 1/1024 的要 10 比特，必然出现的不花比特。所以压缩的关键不在怎么编码，而在能不能把下一个符号猜准。如果用来编码的概率是一个模型 $q$ 给的，而文字真实的规律是 $p$，平均每个符号要花的比特数就是两者的交叉熵。这正是今天训练语言模型时用的损失，只是对数的底一般取 $e$。损失每降一点，就是这个模型当压缩器时压得更小一点。

图 2是我们用本站文章训练的一个小模型（第七节还会用到它），给“每个参数减去学习率乘它的偏导数”这句话逐字报的码长。“参”后面跟“数”几乎是必然的，只花 0.2 比特；“减”“导”这几个字它没料到，各要十几比特。整句 15 个字合计 116 比特，而用 UTF-8 原样存要 360 比特。

1951 年，香农又做了一个实验：给人看一段英文的前半截，让人一个字母一个字母地猜后面，记下要猜几次才猜中⁶。由此估出来，对一个熟悉英语的人，每个字母平均只有 1 比特左右的信息量，而计算机存一个字母要 8 比特。一段文字里大部分内容都是可以猜出来的，猜得越像人，压得越小。

算术编码：预测器就是压缩器

香农的定理说的是“最少要多少比特”，并没有给出一个真能达到它的编码方法。七十年代，里萨宁（Rissanen）等人发明的算术编码补上了这一环⁷：只要有一个模型能对下一个符号给出概率，算术编码就能把整段文字压到和 $\sum\log_2(1/q)$ 只差几个比特的长度，解压时用同一个模型一边猜一边还原。

从此预测和压缩成了一回事的两面：任何一个预测器，配上算术编码就是一个压缩器；它压得多小，只看它猜得多准。

最短的描述

还剩一个问题：怎样才能猜得最准？六十年代，所罗门诺夫（Solomonoff）和柯尔莫哥洛夫（Kolmogorov）分别给出了同一个方向的答案⁸⁹。一段数据的复杂度，是能输出它的最短程序的长度；预测下一个符号时，越短的解释越可信。一串 0101……0101 再长，用一行“重复 01”就能写出来；一串真随机的比特，最短的写法就是把它原样抄一遍。

这套理论把“找到规律”和“压缩”画上了等号：能把数据压到最短的那个程序，就是找到了数据里全部规律的那个程序，用它来预测也最准。这就是“压缩即智能”的理论根源。后来胡特（Marcus Hutter）在此基础上构造了一个理论上最优的智能体，并在 2006 年设立了开头提到的那个压缩奖¹⁰。

问题是，最短程序是不可计算的，理论只指了方向，没有给出路。到六十年代为止，目标和工具其实都摆在桌上了：目标是把下一个字猜准，工具是梯度下降。缺的是一台能从数据里自己学出规律的机器。

三、会学习的机器：感知机

把神经元写成数学

1943 年，神经生理学家麦卡洛克和逻辑学家皮茨发表了一篇论文：把一个神经元简化成“把输入加权求和，超过阈值就输出 1，否则输出 0”，这样的单元连起来就能实现任何逻辑运算¹¹。这是人工神经网络的起点，但它里面的权重是人设计的，不会学习。

1958 年，康奈尔航空实验室的罗森布拉特（Rosenblatt）提出了感知机，让权重自己学¹²。规则很简单：拿一个样本，算出输出，如果答错了，就把权重往正确答案的方向挪一点；答对了就不动。他还把它造成了一台机器 Mark I：一块 20×20 共 400 个光电管的“视网膜”，接到 512 个关联单元上，权重存在电位器里，学习的时候由电机去拧电位器¹³。权重是实实在在的旋钮，学习就是电机在拧旋钮。

当时的反响非常热烈。《纽约时报》报道说，海军展示了一台电子计算机的“胚胎”，预计它将来能走路、说话、看东西、写字、复制自己，并意识到自己的存在¹⁴。

一道 XOR 题

1969 年，明斯基和派珀特出版了《感知机》一书¹⁵，书里用数学证明了单层感知机能做什么、不能做什么。最常被引用的例子是异或（XOR）：两个输入不同时输出 1，相同时输出 0。

为什么单层感知机做不了？单层感知机的判断就是“加权和是否超过阈值”，在平面上就是用一条直线把点分成两边。图 3左边画了 XOR 的四个点，输出 1 的两个点在对角线上，输出 0 的两个点在另一条对角线上，任何一条直线都没法把它们分开。我们用 1958 年的规则实际跑了 100 轮，权重一直在摆，每一轮仍然错 4 个。

多加一层就能表示 XOR：先用两个单元分别判断“x₁ 且非 x₂”“x₂ 且非 x₁”，再用一个单元把两者“或”起来。问题在于怎么训练中间那一层。感知机的规则是“看输出对不对，再改权重”，可中间层的单元没有自己的标准答案，它们答得对不对，只能间接从最后的输出上看出来。这叫作“功劳分配”问题：最后错了，该怪中间哪个单元？

第一次尝试：直接对阶跃网络求导

既然链式法则 1676 年就有了，我们自然会想：把误差对中间层的权重求导，不就知道该怪谁了吗？

这条路在感知机上走不通。感知机的开关是阶跃函数，输入过了阈值就是 1，没过就是 0，图 3中间上面那条线。它除了跳变的那一点，斜率处处是 0：把权重稍微拧一点，输出纹丝不动，损失也纹丝不动。我们给一个用阶跃开关的两层网络算了数值梯度，第一层四个权重的导数全是 0。导数没有提供任何“往哪边调”的信息。

解决：换一个平滑的开关

办法是把开关换成平滑的 sigmoid 函数 $\sigma(z)=1/(1+e^{-z})$，图 3中间下面那条 S 形曲线。它在 0 附近从 0 平滑地升到 1，每一处都有斜率，于是每个权重都能求出“拧一点，损失变多少”。同样两层的网络换上 sigmoid，用梯度下降训练，100 个随机起点里有 78 个学会了 XOR。

剩下的 22 个，后面还会再提到。这里先回到功劳分配：平滑开关让中间层的导数存在了，但网络一大，怎么把这么多导数算出来？

四、反向传播：求导的代价

现象：导数存在，不等于算得起

求一个参数的导数，最朴素的办法是数值差分：把这个参数加一点点，跑一遍网络算损失；再减一点点，再跑一遍；两个损失相减，除以改动量。我们在训练那篇文章里就用它来核对手算的梯度。

这个办法的问题在于，每个参数都要单独跑两遍。网络有 N 个参数，一次完整的梯度就要跑 2N 遍前向。下面是我们实测的一个三层小网络，参数从 84 个加到 106 万个。

表 4的最后一列就是问题所在：参数越多，数值差分比反向传播慢得越多，到一百万个参数时已经慢了几十万倍。照这个比例推到 GPT-3 的 1750 亿个参数，数值差分算一次梯度要跑 3500 亿遍前向，走完一步训练的时间够反向传播走完整个训练好多遍。

原因：链式法则里有大量重复计算

为什么反向传播的耗时和参数个数无关？在训练那篇文章的第五节，我们从损失往回算过 10 个偏导数：先算损失对输出的导数，再用它算出对上一层的导数，一层一层往回传，每一层的中间结果只算一次，被后面所有参数共享。数值差分没有这种共享，每推一个参数都从头算一遍。

所以反向传播并不是新的数学，它只是链式法则的一种算法安排：从输出往输入的方向套链式法则，代价大约是前向的两三倍，表 4里实测是 3 到 5 倍。这也是今天估算训练计算量时常说的“前向加反向约等于 3 倍前向”的来历。

它被发明了好几次

这个安排有好几个独立的发明者¹⁶。1970 年，芬兰的林纳因马（Linnainmaa）在硕士论文里写出了反向模式自动微分，用来估计程序里舍入误差的累积，跟神经网络没有关系。1974 年，沃博斯（Werbos）在哈佛的博士论文里把它用到了神经网络上，但没有引起注意。直到 1986 年，鲁梅尔哈特、辛顿和威廉姆斯在《自然》上发表论文，演示了用反向传播训练的多层网络能学出有意义的中间表示，这个方法才在神经网络圈子里流行起来¹⁷。

到 1986 年，训练一个多层网络需要的东西已经全部齐了：平滑的开关、反向传播、随机梯度下降，再加上第二节的目标，猜准下一个字。那为什么大模型又等了三十多年？

五、1986 年以后的二十年

它其实被用起来了

先回答开头那个问题：这些能力并不是没人用。1989 年，贝尔实验室的杨立昆（LeCun）用反向传播训练了一个卷积网络，识别美国邮政信件上的手写邮编，错误率约 1%¹⁸。这个网络有 9760 个参数，在一台 SUN-4/260 工作站上训练了 3 天。2022 年卡帕西（Karpathy）用 PyTorch 复现了它，在一台 M1 MacBook Air 的 CPU 上跑完只要 90 秒左右¹⁹，算法一样，快了约 3000 倍。后来这一系列网络被用来识别支票上的手写数字，进入了真实的银行业务。

用神经网络猜下一个词也有人做了。2003 年，本吉奥（Bengio）等人做出了第一个神经网络语言模型，猜下一个词比当时主流的统计方法更准²⁰。

所以 1986 年以后的问题不是“没人想到”，而是做出来的东西只在小问题上管用，一做深、做大就不灵了。

现象：网络一深，前面的层就学不动

1991 年，霍赫赖特（Hochreiter）在毕业论文里分析了一个现象²¹，1994 年本吉奥等人又从另一个角度证明了它²²：梯度从输出往回传的时候，每经过一层要乘一次这一层开关的斜率。sigmoid 的斜率最大只有 0.25，层数一多，梯度就按指数缩小。

我们搭了一个 20 层的网络，在刚初始化的时候量了每一层权重梯度的大小，结果画在图 5里。

用 sigmoid 时，最后一层的梯度是 2.1，第一层只剩 $1.7\times10^{-12}$，差了 12 个数量级；作为对照，$0.25^{19}\approx3.6\times10^{-12}$，几乎就是这个比例。梯度下降按梯度的大小调参数，第一层的参数等于根本没动。这叫作梯度消失。图里另一条线换成了 ReLU 开关 $\max(0,z)$，它在正半边的斜率恒为 1，各层梯度在同一个量级。

第一次尝试：绕开它

九十年代的人知道这个问题，也找到了一些绕开的办法。1997 年的 LSTM 给循环网络加了一条梯度能原样通过的“传送带”，让它能记住几十步以前的内容²³，这个结构后来用了二十年。但在大多数任务上，研究者干脆不用深网络。

同一时期，支持向量机（SVM）出现了²⁴。它的训练是一个凸优化问题，只有一个最低点，保证找得到，背后还有一套漂亮的统计学习理论。相比之下，神经网络的损失地形坑坑洼洼，可能卡在局部最低点里出不来，调参全靠经验。前面 XOR 实验里那 22 个没学会的起点，就是卡在了这样的地方。在当时的数据量下，SVM 的效果往往不比神经网络差，于是神经网络在主流学术界冷了大约十年。

压缩榜上的手写模型

压缩这条线上，情形也一样。这二十年里最会“猜下一个字节”的程序，都是人手写的统计模型。1984 年的 PPM 按前面几个字节出现过的次数，统计下一个字节的概率²⁵，第七节的小实验就是这一类。后来 Mahoney 的 PAQ 系列把几百个这样的手写模型放在一起，再用一个很小的神经网络，按各自最近猜得准不准来给它们加权。

2006 年，胡特设立了压缩奖：把 100MB 的英文维基百科（enwik8）压得更小，就按压小的比例发奖金，理由是压缩文字和人工智能是同一个问题¹⁰。从 2006 到 2017 年，每一次破纪录的都是在 PAQ 基础上改出来的手写混合模型。神经网络语言模型猜得更准，但慢到没法拿来压 100MB 的文字。“压缩即智能”这个想法有了，比赛也有了，赢的却是手工的统计。

回头看，这二十年里缺的算法其实不多。ReLU 就是 $\max(0,z)$，1990 年也写得出来；到 2011 年格洛罗（Glorot）等人系统地说明它在深层网络里好用²⁶，才普及开来。那段时间更大的问题在别处：XOR 实验里，隐藏层从 2 个单元加到 3 个，100 个起点里能学会的从 78 个变成 99 个，到 4 个单元就全部学会了。网络大一点反而更好训练，可那时的机器养不起大网络，数据也喂不饱它。下面我们分别看这两样差多少。

六、算力：差了多少个数量级

训练一次要多少次运算

一个大语言模型训练一次要多少次浮点运算，有一个很好用的估算：每个参数、每个 token，前向约 2 次运算，加上反向一共约 6 次。GPT-3 有 1750 亿个参数、看了 3000 亿个 token：

$6\times1.75\times10^{11}\times3\times10^{11}\approx3.1\times10^{23}$

GPT-3 论文附录给出的数字是 $3.14\times10^{23}$²⁷。这个数有多大？我们把历史上几台有代表性的机器拿来对比。

1976 年的 Cray-1 是当时最快的超级计算机，峰值每秒 1.6 亿次，售价约 800 万美元²⁸。用它训练 GPT-3 要 6000 多万年。1997 年的 ASCI Red 是第一台每秒过万亿次的计算机²⁹，也要 9000 多年。即使只看内存，GPT-3 的参数用半精度存要 350GB，训练时连同梯度和优化器状态要好几 TB；Cray-1 的内存是 8MB，AlexNet 用的 GTX 580 每张 3GB。

这张表的意思很清楚：就算 1986 年有人写出了 Transformer 和全部训练技巧，也不可能训练出 GPT-3。不是没想到，是做不到。

GPU：给游戏造的矩阵乘法机器

转机来自一个意想不到的地方。游戏画面要给几百万个像素各算一遍颜色，显卡因此被造成了成千上万个简单计算单元一起干活的样子，最擅长的恰好是大批量的乘加运算，也就是矩阵乘法。神经网络的前向和反向，绝大部分也是矩阵乘法。

2007 年英伟达推出 CUDA，显卡可以直接用 C 语言风格的代码编程了。2009 年，吴恩达的团队用 GPU 训练深度网络，比双核 CPU 快了最多约 70 倍³⁰。2006 年辛顿用逐层预训练让深层网络重新训得动³¹，再加上 ReLU、GPU，几条线开始汇合。

2012 年，克里热夫斯基、苏茨克维和辛顿用两张 GTX 580 游戏显卡，在 ImageNet 图像识别比赛上把错误率从 26% 降到了 15% 左右³²。这个网络叫 AlexNet，有 6000 万个参数，训练了五到六天，因为一张卡 3GB 显存放不下，模型被拆在两张卡上。算法上它没有什么 1990 年想不到的东西，卷积、反向传播、随机梯度下降都是老的，新的是 ReLU、Dropout 和两张显卡。

压缩榜的换手

压缩榜上的换手来得更晚一些。Mahoney 维护的大文本压缩榜比的是把 1GB 的英文维基百科（enwik9）压到多小，不限硬件³³。

2019 年，写过 QEMU 和 FFmpeg 的贝拉（Fabrice Bellard）发布了 nncp：一个神经网络一边读维基百科一边训练，一边给下一个字节报概率，再用算术编码写下来。第一版是 LSTM，在 CPU 上压 1GB 要好几天，成绩还不如手写模型最好的 cmix。2021 年他换成了约 2 亿参数的 Transformer，放到 GPU 上跑，登上了榜首，2023 年的版本压到 106.6MB，平均每个字节约 0.85 比特（表 7）。对照开头那句话：这台“压缩器”里装的，就是一个边读边学的小语言模型。

训练所需涨得比单卡更快

AlexNet 之后，训练用的算力增长得非常快。图 8把几个有代表性的模型的训练计算量，和同期一台机器满负荷跑一天的运算量画在一起。

LeNet 的训练量还在一台工作站几天的能力之内；AlexNet 大约等于两张 GTX 580 跑满两天（实际利用率不到一半，所以用了五六天）；到 GPT-3，实线已经比虚线高出三四个数量级，一张 H100 满负荷也要跑 10 年。这些差距只能靠把成千上万张卡连起来补：Megatron-LM 的作者估算，1024 张 A100 训练 GPT-3 大约要 34 天³⁴。怎么让一万张卡像一台机器一样干活，又是一整套工程：模型怎么切开放在不同的卡上，梯度怎么汇总，网络带宽够不够，一张卡坏了怎么续上。在显卡对比那篇里我们看过这些卡的价格和性能，单张 H100 就要几万美元。

算力在 2012 年前后够了，可是拿什么去喂它？

七、数据：标签是瓶颈

现象：数据集停在百万级

神经网络要从例子里学。在很长时间里，“例子”指的是带标签的例子：一张图配一个“猫”，一句话配一棵句法树。标签要人来打，这就把数据集的规模卡住了。

1961 年的 Brown 语料库有约 100 万词，是第一个计算机可读的大规模英语语料，每个词的词性都是人工标的³⁵。三十年后的 Penn Treebank 有约 450 万词，标了句法树³⁶，九十年代到 2010 年代的大量语言研究都在它上面做。1998 年的 MNIST 有 7 万张手写数字³⁷。

2009 年李飞飞团队发布的 ImageNet 是一个转折：约 1400 万张图片，标注靠亚马逊的众包平台 Mechanical Turk，约 4.9 万名来自 167 个国家的工人，从 2008 年 7 月一直标到 2010 年 4 月³⁸。AlexNet 正是在它的一个 120 万张图的子集上训练出来的。但这也几乎是人工标注能走到的上限了。

解决：把压缩当目标

语言模型绕开了这个瓶颈，靠的正是第二节的那个目标。它要做的是压缩文字，也就是猜下一个词，而下一个词就写在原文里：每一段人写的文字，本身就是成千上万个“题目 + 答案”，不用任何人来打标签。这种做法叫自监督。

标签不再需要人打，能用的数据就只受“人类写了多少字”的限制。2008 年开始，非营利组织 Common Crawl 定期抓取整个公开网页，把数据免费放出来³⁹。GPT-3 的训练数据有 3000 亿个 token，大部分来自过滤后的 Common Crawl；2024 年的 Llama 3 用了约 15 万亿个 token⁴⁰。和 Penn Treebank 比，大了几百万倍。

数据越多，压得越小

数据量对压缩有多大影响？我们拿本站的文章做了一个小实验：用其中 53 篇训练字符级的“k 阶模型”，也就是按前 k 个字的出现次数去猜下一个字（和 PPM 同类），再用它压缩另外 4 篇没见过的文章。

表 10里有两个现象。第一，训练文字从 3.8 万字加到 60 万字，最好的成绩从每字 7.32 比特降到 5.78 比特，已经比 bzip2 好，比 gzip 好得多：模型见过的文字越多，越能猜中没见过的文字。第二，模型越大越吃数据。只有 3.8 万字时，看前 1 个字的模型最好，看前 2 到 4 个字的反而更差，因为大部分“前 4 个字”的组合在训练集里根本没出现过，模型没有可以依据的统计；数据加到 15 万字以后，看前 2 个字的才追上来。60 万字对这样的模型来说仍然太少，4 阶始终没有翻身。

这正是大模型需要海量文字的原因：参数越多，能记下的规律越多，要把它们都学到，就要越多的文字。互联网把人类几十年写下的文字放到了同一个地方，自监督让这些文字不用标注就能直接用。算力有了，数据也有了，还差什么？

八、架构与规模：最后两块

现象：循环网络喂不饱 GPU

2017 年以前，处理文字的主力是循环网络（RNN 和 LSTM），nncp 的第一版用的也是它。它读一句话的方式和人一样，一个字一个字地读，每读一个字更新一次内部状态。问题在于，第 6 个字的计算要等前 5 个字算完，整句话的计算是一条串行的链。GPU 有上万个计算单元，却只能一步一步地等。

2014 年，巴达瑙（Bahdanau）等人在机器翻译里加入了注意力：翻译每个词时，直接回头看原文的所有位置，按相关程度加权取信息⁴¹。2017 年谷歌的《Attention Is All You Need》走到底，把循环结构整个拿掉，只留注意力，这就是 Transformer⁴²。

图 11是两者的区别。Transformer 里每个位置看其他位置的注意力分数，可以写成一次矩阵乘法 $QK^\top$ 一起算出来，句子再长也只是矩阵大一点。这正是 GPU 最擅长的形状。胡克（Sara Hooker）把这种现象叫作“硬件彩票”：一种算法能不能胜出，很大程度上取决于它是否碰巧适合当时的硬件⁴³。Transformer 中了这张彩票，nncp 从 LSTM 换成 Transformer 以后登上压缩榜首，也是同一个原因。

这一时期还补上了几块让深网络稳定训练的零件：Adam 优化器自动调整每个参数的步长⁴⁴，残差连接让梯度可以跳过若干层直接往回传，网络因此能叠到上百层⁴⁵。它们解决的都是第五节那种“网络一深就训不动”的问题。

规模定律：压缩率可以预算

到 2018 年前后，架构、算力、数据都有了，但还有一个现实的问题：训练一个大模型要花几百万美元，花了钱，模型会变好多少？ 如果事先不知道，没有人敢押这么大的注。

2020 年 1 月，OpenAI 的卡普兰（Kaplan）等人发表了规模定律：语言模型的测试损失随参数量、数据量和计算量按幂律平稳下降，可以用小模型的结果外推大模型的结果⁴⁶。按第二节的读法，这张图的纵轴就是每个 token 平均要花多少比特，规模定律画的是一条压缩率曲线：多投多少算力，能把人类的文字多压掉多少，事先就能算出来。这让“做大”从一场赌博变成了一笔可以预算的投资。同年 5 月，GPT-3 发布²⁷。2022 年 DeepMind 的 Chinchilla 进一步指出，在算力固定时参数和数据应该同比例增长，GPT-3 那一代模型其实数据给少了⁴⁷，这和表 10里“模型越大越吃数据”是同一回事。

压缩的视角在这几年被重新提了出来。2023 年苏茨克维（Ilya Sutskever）在伯克利的一次演讲里，用压缩来解释为什么只靠“猜下一个词”的无监督学习能学到有用的东西⁴⁸。同年 DeepMind 的论文《语言模型即压缩》把这件事做成了实验：主要用文字训练的 Chinchilla 70B，配上算术编码去压图片和音频，把 ImageNet 的图块压到原大小的 43.4%，把 LibriSpeech 的语音压到 16.4%，比专门的 PNG（58.5%）和 FLAC（30.3%）还小⁴⁹，前提是不把模型本身的体积算进去。

最后一块是让模型“听话”。只会预测下一个词的模型，你问它问题，它可能接着编出另一个问题。2022 年 3 月的 InstructGPT 用人类反馈做强化学习，把一个预测器调成了能按指令回答的助手⁵⁰。同年 11 月 30 日，ChatGPT 上线。

九、四条线的交汇

把前面几节放到一张图上，就能看出“为什么是最近几年”。

图 12有四条线。数学最早就绪：链式法则、最小二乘、梯度下降，以及香农把“预测”和“压缩”连在一起的信息论，在 1951 年以前全部齐了。算法在 1986 年反向传播流行时基本齐全，剩下的 ReLU、注意力、Transformer 都是小改动，却要等算力和数据到了，才知道哪种改动值得。算力和数据是最晚的两条：一直到 2010 年前后，单机算力和人工标注的数据集都还差着好几个数量级，而它们的转机，GPU 和互联网文本，都不是为人工智能准备的。

这四条线有一个顺序上的依赖：没有足够的算力和数据，就看不出大网络的好处；看不出好处，就没人去发明适合大网络的架构，也没人去建万卡集群。压缩榜就是一个缩影：同样是“猜下一个字节”，手写模型领先了十几年，神经网络要等到 GPU 和 Transformer 都到位才超过它。所以四条线不是各自独立地“到期”，而是在 2012 到 2022 年这十年里，一条带动另一条，先后就位。

萨顿（Rich Sutton）2019 年写过一篇短文《苦涩的教训》，总结 AI 研究七十年的经验：能随着算力增长而变好的通用方法，最终总是赢过精心设计的人类知识，而且赢得很多⁵¹。PAQ 和 cmix 里上千个手写模型，就是“精心设计的人类知识”；梯度下降简单到几乎没有可以加进去的知识，所以能一直扩展下去。

十、回到开头

回到开头那行规则：

w ← w − 学习率 × dL/dw

从柯西到 GPT-3，它一个字也没改，损失也一直是香农 1948 年定义的那个比特数。我们觉得从梯度到 Transformer“好像也没那么复杂”，这个感觉是对的：大模型的原理确实不复杂，复杂的是让这行规则在 1750 亿个参数上、在 3000 亿个 token 上走 9 万多步。

这一百多年里，规则一直都在被使用：1801 年算谷神星，1958 年拧感知机的电位器，1989 年识别邮编，2006 年在压缩奖上挤维基百科，2012 年认 ImageNet 里的猫。每一次都做到了当时的硬件和数据所允许的最大规模。大模型之所以等到最近几年，是因为直到最近，这个“最大规模”才大到让一个压缩器把人类的文字压得足够小。

那么，一个压缩器凭什么像有了智能？回到第二节：要把一本物理教科书的下一个字猜准，光记住常见的词搭配是不够的，迟早要“知道”能量守恒；要把一段代码的下一行猜准，迟早要“知道”这段代码在干什么。损失每往下压一点，模型就被逼着多掌握一条这样的规律。谷神星的 6 个轨道根数是 40 天观测的压缩，规律找对了，就能预言半年后它在哪里；语言模型的参数是人类文字的压缩，规律找得够多，就能接着写出一段从没见过、但说得通的文字。“压缩即智能”说的就是这件事。至于这样的压缩能不能算真正的理解，还是一个开放的问题。

这也和本站另外几篇文章连在一起。AdderBoard 那篇里，36 个参数的 Transformer 就能把十位数加法学对，因为加法的规律很小，压缩它用不了多少参数；语言的规律大得多，所以要大得多的模型。FPGA 那篇问过“为什么 FPGA 的四十年里没有涌现智能”，答案的一半就在第三节：比特像阶跃开关一样没有梯度，没法用这行规则去调；另一半在第六、七节：即使能调，当年也没有足够的算力和数据。

小结

1. 梯度下降多老？ 链式法则 1676 年，最小二乘 1805 年，梯度下降 1847 年，随机梯度 1951 年。调参数的数学在一百多年前就齐了。
2. 训练要优化的是什么？ 香农 1948 年说明，一个字的码长是它的概率取负对数，交叉熵损失就是压缩后的比特数；算术编码让任何预测器都成了压缩器；所罗门诺夫和柯尔莫哥洛夫把“找到规律”和“压到最短”画上等号。这就是“压缩即智能”。
3. 会学习的机器为什么停在 1969 年？ 单层感知机分不开 XOR；多层网络能分开，但阶跃开关的导数处处为 0，没法用梯度训练。换成 sigmoid 这样的平滑开关才行。
4. 反向传播解决了什么？ 求导的代价。数值差分要跑 2N 遍前向，反向传播只要前向的几倍，和参数个数无关。
5. 1986 年以后为什么又冷了二十年？ 深网络有梯度消失，小数据上 SVM 更稳；压缩榜上赢的是手写统计模型。让大网络好训练的规模，当时的机器和数据都给不起。
6. 算力差多少？ GPT-3 要 $3.14\times10^{23}$ 次运算，在 1976 年的 Cray-1 上要 6000 多万年，在一张 2010 年的显卡上也要 6000 多年。GPU 和万卡集群把它缩到一个月，压缩榜首也在 GPU 上换成了 Transformer。
7. 数据差多少？ 人工标注的数据集停在百万到千万级；把压缩当目标就不用人打标签，训练数据到了万亿 token。模型越大越吃数据。
8. 最后几块是什么？ 适合 GPU 并行的 Transformer，把压缩率变成可以预算的规模定律，以及把预测器调成助手的人类反馈。
9. 为什么是最近几年？ 数学、算法、算力、数据四条线要同时到位，最晚的算力和数据在 2010 年代才到，并且一条带动另一条，在 2012 到 2022 年间先后就位。

本文的四个小实验（数值差分与反向传播的耗时、20 层网络的梯度消失、XOR 的三种训练、用字符模型压缩本站文章）都是几十到一百来行的 Python 脚本，在笔记本上几分钟就能跑完。

参考资料