第 20 章 · 通往大模型

通往大模型:原理与训练

你已经亲手把一个完整的语言模型从一个神经元拆到了底。现在我们站远一点,看看把第 19 章那个小模型 放大上千万到上亿倍会发生什么。这一章讲清楚三件事:大模型怎么读懂文字(分词与词嵌入)、 为什么越大越强(规模定律与涌现)、以及是怎么“炼”出来的(预训练 → 微调 → 对齐 → 蒸馏)。 讲完训练链路后,我们还会把“为什么偏偏是这几年爆发”拆成数据、算法、算力、工程四个卡点来看。 至于它靠什么硬件跑起来、你又该怎么用好它,留给第 21、22 章。

1. 先看一个惊人的事实:内核没变

GPT、DeepSeek 这类模型,做的事和你第 19 章那个 mini LM 一模一样: 看着前文,预测下一个 token,然后自回归地一个个往下写。区别只在量级:

那么,“大”到底大在哪几个方面?

既然内核没变,“大模型”的大就不是某一处,而是同一套机制在好几个维度上同时被放大。 把它们拆开看,后面每一节其实都在讲“其中一个维度怎么被放大、放大后带来什么新问题”:

2. 参数地图:1750 亿个“旋钮”装在哪儿(GPT 举例)

上一节说 GPT-3 有 1750 亿参数。参数就是训练后要存进模型文件、推理时要加载进内存/显存的那些可学习权重 (以及少量偏置、LayerNorm 的缩放/平移系数)。它们和“层数、头数”这类结构超参不是一回事: 超参决定网络长什么样;参数是这张网里每一根“连线”上的具体数字。

以最常见的 GPT 系 decoder-only 为例——结构和你在 第 19 章搭的 mini LM、 第 18 章的 Transformer Block 是同一套,只是更深更宽。 从外到内,可训练的参数大致分这几块:

2.1 先分清:结构数字 vs 要存的权重

读模型卡时你会同时看到两类数字,别混:

• 结构超参(决定形状,本身不占多少存储):层数 L、宽度 d、注意力头数 h(每头维度 d/h)、FFN 宽度 f、词表 V、上下文长度上限等;
• 参数量(要落盘的权重个数):上面每一块矩阵/向量里所有元素的总和。

2.2 每一层 Block 里有哪些矩阵

一层 Transformer Block 里,和参数量相关的主要权重如下(偏置、LayerNorm 的 γ/β 也有,但相对很小,先略):

【自注意力】四个投影矩阵,每个都是 [d × d]
  W_Q, W_K, W_V, W_O
  → 小计 4d²

【前馈 FFN】两层全连接(中间维 f, GPT 系通常 f ≈ 4d)
  W1: [d × f]    W2: [f × d]
  → 小计约 2df ≈ 8d²(当 f=4d)

【一层合计(主项)】≈ 4d² + 8d² = 12d²

头数 h 改变的是怎么切分计算(多头并行),那四个 [d×d] 矩阵的总元素数不变。 堆 L 层,Block 部分就是 L × 12d² 量级。

2.3 嵌入层与 LM Head

【词嵌入】把 token id 变成 d 维向量
  Embedding 权重: [V × d]  →  Vd 个参数

【LM Head】把最后一层 d 维向量投影回词表,得到每个 token 的 logit
  权重: [V × d]  →  又是 Vd 个参数

【权重绑定(weight tying)】很多 GPT 实现让嵌入和 LM Head 共用同一张 [V×d] 表
  → 只算一份 Vd,不重复存

词表 V 越大,嵌入和输出头就越大——这也是 BPE 词表不能无限膨胀的原因之一(见下一节)。

2.4 用 GPT-3(175B) 对一下账

OpenAI 公布的 GPT-3 规模(以 1750 亿参数那一档为例)大致是:

• L = 96 层, d = 12 288, h = 96 头(每头 128 维), f = 49 152 ≈ 4d, V ≈ 50 257

单层 Block(主项):
  注意力 4d² = 4 × 12288² ≈ 6.0 × 10⁸
  FFN    2df = 2 × 12288 × 49152 ≈ 1.2 × 10⁹
  单层合计 ≈ 1.8 × 10⁹(约 18 亿)

96 层 Block:
  96 × 1.8×10⁹ ≈ 1.7 × 10¹¹(约 1700 亿)

嵌入(+ LM Head 若绑定则只算一份):
  Vd = 50257 × 12288 ≈ 6.2 × 10⁸(约 6 亿)

总计 ≈ 1.75 × 10¹¹  →  常说的 175B(1750 亿参数)

2.5 一眼估算总参数量

工程上常背一个近似式(FFN 取 f≈4d,嵌入与 LM Head 绑定):

参数量 ≈ L × 12d²  +  Vd
         ≈ 12Ld²      +  Vd        (主导项是 L 和 d²)

所以 Scaling Law 里“把参数量做大”,本质上就是加层(增大 L)或加宽(增大 d,且每层按 d² 涨)。 只加词表 V 也会涨,但通常不如加层/加宽猛。 若换成 MoE 架构,FFN 部分会变成“多份专家权重 + 路由器”,总参数量可再上一个台阶(但每步只激活其中少数专家)。

3. 第一步:把文字切成 token(分词与 BPE)

第 19 章我们用的是最简单的字符级分词——一个字一个 token。真实大模型嫌它太浪费: 英文一个单词能拆成好几个字符,序列变得很长,而注意力的计算量随长度平方增长(第 17 章),很不划算。 于是它们用子词(subword)分词,最常见的算法叫 BPE(Byte Pair Encoding)。

切出来的这些 token,会预先登记在一张词表(vocabulary)里,每个 token 配一个唯一 id。 训练和推理都查这张表来分词,不能临时换算法(否则会切出词表里查不到的“陌生” token)。 词表大小(vocab_size)是个权衡:

• 太小:像拿着一年级生字本读专业书,啥都得拆成一堆碎片,表达力不足;
• 太大:每个词见得太少、学不充分,还白白撑大输出层。主流模型的词表通常在几万到十几万之间。

只有 5 万词表,怎么支撑几十种语言?

这里有个一算就露馅的疑问:全世界的文字加起来远不止 5 万——光常用汉字就好几千,再加上日文、韩文、阿拉伯文、印地文、各种 emoji……几十万都打不住。 GPT-3 的词表才 V≈50 257,凭什么能读写这么多语言?答案藏在两个字里:碎片。

① 词表里装的不是“词”,是“子词碎片”。 BPE 的规矩是高频的合成整体、低频的拆成碎片(见上文)。 所以词表不必囊括所有词,只要能把任意文本拼出来就行:常用词 the 占 1 个 token,生僻词 antidisestablishment 会被拆成 anti+dis+establish+ment 几块;实在没见过的,就一路拆到最小粒度兜底。

② 最小粒度是“字节”,所以永远拼得出、永不失败。 GPT-2/3 用的是 字节级 BPE(byte-level BPE): 它不在“字符”上合并,而在 UTF-8 字节上合并。任何语言的任何字符,在计算机里都是 1~4 个 UTF-8 字节,而字节只有 256 种。 于是词表最底层永远躺着这 256 个“单字节 token”做兜底——任何字符都能用字节序列拼出来,再也不会遇到“词表里查不到”(即 OOV(out-of-vocabulary))的字。 所以 5 万 ≈ 256 个字节 + 约 5 万个“高频字节组合”,靠拆分与拼接覆盖一切语言。

4. 词嵌入:给每个词一个“语义坐标”

token 的 id 只是个编号(2 不比 1 “大”)。第 19 章讲过,词嵌入(embedding) 给每个 id 配一个可学习的多维向量。这里我们把这件事的“妙处”讲透,因为它是大模型能“懂语义”的地基。

那怎么用数学衡量“两个向量意思有多近”?一个直觉是算它们的距离,但训练中向量会被整体拉伸缩放, 距离不稳。更稳的是看方向(夹角):两个向量夹角越小,就认为语义越接近。而衡量夹角的工具, 正是你在第 17 章反复用的点积——点积越大,夹角越小,语义越相近。

于是训练会把语义相近的词“挤”到相近的方向上。一个经典的神奇现象:在训练好的词向量里, 向量(“国王”) − 向量(“男人”) + 向量(“女人”) ≈ 向量(“女王”)——语义关系居然变成了可以做加减法的几何关系。

5. 规模化(Scaling Law):大力真的出奇迹

研究者发现一个惊人规律——Scaling Law(规模定律):当你同时放大三样东西—— 参数量、数据量、算力——模型的损失会沿着一条平滑、可预测的曲线持续下降。 也就是说,“做得更大”能可靠地换来“做得更好”。这条规律是过去几年“军备竞赛”的底气:既然变大几乎稳赚,那就拼命变大。

顺便建立一个数量级直觉:参数量 ≈ 网络里连线(权重)的总数(§2已按层拆开)。 1750 亿参数,就是 1750 亿个 第 2 章那样的“权重旋钮”。它们全部存成小数,这也是为什么模型文件动辄几十上百 GB。

那到底该配多少数据、多少算力?

“三样一起放大”不是拍脑袋,业界有能上手估算的经验法则。DeepMind 的 Chinchilla 研究给了个著名结论: 在算力预算固定时,参数量和训练 token 数最好按大约 1 : 20 搭配——每 1 个参数,大约要配 20 个训练 token 才“吃得饱”。

• 照这个比例,一个 70 亿参数的模型,大约需要 1400 亿 token 才算喂到位;
• 早期不少模型“参数堆得很大、数据却没跟上”,其实是没训透:同样的算力,匀一部分去多喂数据,效果反而更好。这就是前面那句“不能只堆参数”的量化版。

数据从哪来,又怎么洗干净?

既然 Scaling Law 要求“参数、数据、算力一起涨”,下一个问题就很自然: 这些训练数据到底从哪里来? 真实训练集不是“把互联网打包下载下来直接喂给模型”。 更准确地说,训练数据是一条很长的数据工程流水线:先从许多来源收集原始文本和多模态材料, 再经过抽取、去重、过滤、分类、配比,最后才变成一批批 token 送进训练。

① 数据来源:不是只有网页

大模型底座的预训练语料通常会混合多个域。公开报告很少披露精确比例,但大方向很清楚: 网页是基本盘,代码和数学是高价值补给,授权/私有数据补可靠性,合成数据和人类反馈数据补稀缺能力。

② 清洗:把原始网页变成训练 token

原始网页离“可训练文本”很远。你打开一个网页看到的是正文,爬虫拿到的却可能是 HTML、菜单、广告、 cookie 弹窗、推荐列表、评论区、脚本和一堆重复模板。清洗流水线要做的事,就是把这些东西一层层剥掉:

这就是为什么同样来自 Common Crawl,不同团队清洗出的语料效果会差很多。模型不是只看“吃了多少 token”, 还看这些 token 的信息密度、重复率、领域配比、语言覆盖、污染程度。训练前常常会先用小模型做 ablation: 换一版过滤器、调一版 web:code:math 比例,看验证集和下游任务到底变好还是变差,再决定大模型要不要跟进。

③ 为什么说 GPT-4 之后“数据更难了”?

网上常说“GPT-4 把互联网吃完了”,这句话不严谨。GPT-4 技术报告没有公开完整数据组成, 也不能证明它真的消耗完了互联网。更准确的说法是: 从 GPT-4 时代开始,继续靠更多公开高质量自然文本来暴力 scaling,边际收益变差了。

这也解释了为什么现在的训练越来越依赖几类“高价值补给”:代码和数学因为可验证、逻辑密度高,价值很大; 多语种和多模态扩大了自然数据边界;授权/私有数据补可靠性和法律边界;合成数据负责补自然世界里很少出现的复杂题解、 工具调用轨迹和边界 case。它们不是替代网页,而是在公开网页边际收益下降后,继续给模型提供新的学习信号。

④ 合成数据:有用,但不是无限续命

合成数据(synthetic data)就是让已有强模型帮忙生产训练材料: 生成数学题和解析、把粗糙答案改写成高质量答案、模拟用户多轮追问、生成代码任务、产出工具调用轨迹。 这条路很重要,因为自然网页里“高质量多步推理 + 可执行验证 + 标准格式”的样本并不多。

但合成数据不能无脑循环。模型自己生成的内容里会有幻觉、重复套路和隐藏偏见;如果不筛就拿来训练, 等于把旧模型的错误再刻进新模型。靠谱做法通常是:

自然数据打底
→ 强模型生成 / 改写 / 补洞
→ verifier、单元测试、规则过滤、人工抽检
→ 只把通过验证的样本混回训练集
→ 用小规模实验确认真的提升,再扩大

所以“数据怎么来”这件事,已经从简单爬虫变成了完整的数据系统: 收集、清洗、分类、配比、验证、合成、再验证。Scaling Law 仍然告诉我们“更多高质量数据有用”, 但今天真正难的是把“更多”变成“更干净、更有信息量、更能提升能力”。

真正的竞争底座:有效数据 × 有效算力 × 转化效率

学到这里,很容易产生一种错觉:论文和新闻天天在讲新架构、新优化器、新注意力,算法似乎才是大模型竞争的主角。 但若把范围限定在今天主流的Transformer + 自回归预训练范式内,更接近现实的判断是: 高质量有效数据有多少、能投入多少有效算力,构成了能力竞争的资源底座;许多近期算法主要在提高这两种资源的转化效率。

这里的“有效数据”尤其不能只按数量算。一个 token 是否有效,取决于它是否正确、独特、信息密度高、覆盖当前能力缺口、配比合适,并且能被可靠验证。 一百万条换皮转载不等于一百万份新知识;一条带单元测试的代码任务、一份经过专家核对的推理轨迹, 可能比大量无法验证的流畅文本提供更强的训练信号。数据还决定模型不会什么:训练分布没有覆盖的语言、领域、边界 case 和行为规范, 很难靠多跑几轮优化器自动补出来。

为什么说许多近期算法是在弥补“算不起、存不下、数据不够好”?

在主范式没有改变的前提下,近年来很多创新都可以还原成一个现实问题:理想做法太贵,怎样少算、少存、少通信,又尽量保住能力?

这些算法绝不是“不重要”:转化效率提高 2 倍,相当于同样资源做出了更多有效计算,甚至让原本不可训练的规模变得可行。 但它们通常没有凭空创造新的知识来源或无限算力,而是在资源约束下重新分配计算、压缩表示、减少浪费、制造并筛选训练信号。 因而看一项新技术时,比“名字新不新”更有用的问题是: 它省了哪种资源?省下来的资源去了哪里?牺牲了什么?最终让多少高质量数据变成了多少可用能力?

这里讨论的是当前主流范式内部的竞争:团队间差距越来越取决于谁拥有更多高质量、低污染、可验证的数据, 谁能投入并稳定利用更多算力,以及谁能用算法和工程把这两者浪费得更少。Transformer、反向传播、自监督目标这类基础算法 曾经改变过可扩展的能力上限,未来的新范式也可能再次改写规则。

6. 涌现能力:量变到质变

涌现能力(emergent abilities)指的是:某些能力在小模型上几乎为零, 但当规模越过某个门槛后会突然出现。比如:

• 少样本学习(few-shot):在提示里给几个例子,它就能照着做新题,不用重新训练;
• 按步骤推理(chain-of-thought):让它“一步一步想”,复杂问题的正确率明显提高;
• 遵循复杂指令:听懂并完成多步骤任务。

这些能力没有被任何人“显式编程”进去,而是在“预测下一个 token”这个朴素目标 + 巨大规模下,自己长出来的。

为什么会“量变到质变”?

第 5 节说损失是平滑下降的,这里怎么又变成突然出现?这看似矛盾,其实不冲突。涌现的成因目前学界还没有定论,但有几条被广泛接受的解释,拼起来能说清大半:

① 复合任务是多个子技能的“连乘”,像木桶效应。 很多高级能力(如多步推理)要好几个子能力同时到位,错一环整件事就失败。假设某任务需要 5 个子技能都答对,每个子技能的正确率随规模从 60% 平滑升到 90%:

② 要越过一个“容量门槛”才够用。 有些能力需要模型内部长出足够精细的表征/电路;参数和数据不够时,模型根本腾不出“脑容量”去编码这些间接、罕见的模式,越过临界规模后才学得动。就像水一直加热(平滑),到 100°C 才沸腾(相变)。

③ 很可能有一部分是“度量方式”造成的错觉。 这是近年一个重要反驳:很多涌现是用“全对才算分”的严苛指标衡量的(比如多位数加法必须完全正确)——这种指标天生非线性,会把平滑进步放大成断崖式跳变。换成连续、宽容的指标(按 token 部分给分、看概率),同一批模型的曲线又变回平滑上升,拐点就消失了。

7. 大模型是怎么炼成的:预训练 + 后训练

这几步可以归成两大阶段,这也是你会反复听到的两个词:

• 预训练(pre-training) = 第 ① 步:在海量文本上自监督地学“通用语言能力 + 世界知识”。最烧钱、最耗时,决定了模型的“底子”。
• 后训练(post-training) = 第 ②③④ 步:在预训练好的底座模型(base model)之上做的所有加工——SFT 教它听话、RLHF/DPO 按人类偏好对齐、蒸馏压小。数据量比预训练小得多,却直接决定它好不好用。

测评:贯穿训练和上线的质检系统

大模型测评不是“随手问几个问题看看聪不聪明”,而是一套质量控制工作: 用固定题集、真实任务、自动脚本、人工规则和线上反馈,判断模型到底会什么、不会什么、有没有退步、能不能上线。 它本身通常不直接训练模型,但会反过来告诉训练团队该补什么数据、调哪段后训练、哪些版本不能发布。

放到训练和发布链路里看,测评几乎每一站都在场:

所以测评岗位的产出,通常不是一个孤零零的分数,而是一整套证据: 测评集、自动评测脚本、人工标注规范、模型对比报告、安全红队报告、badcase 分析、上线准入结论和回归看板。 最有价值的测评报告会说清楚:哪里变好了、哪里变差了、为什么变差、下一轮训练该补什么。

① 预训练(Pre-training):自监督地读遍互联网

在海量文本(互联网级别)上,做的就是第 19 章那件事:预测下一个词。它最妙的一点是 不需要人工标注——因为“下一个词是什么”文本里现成就有,把后文盖住让模型猜即可。 这种“答案自带、不用人工打标签”的方式叫自监督学习。这一步最烧钱、最耗时, 却是模型获得“通用语言能力 + 世界知识”的来源。

② 指令微调(SFT):把“博学”调教成“听话”

预训练完的模型“博学但不一定听话”——你问它问题,它可能只顾着把你的话接着往下写,而不是回答。 指令微调(SFT,Supervised Fine-Tuning)用一批“指令 + 理想回答”的高质量数据继续训练, 把它从“只会接话”调成“会回答你的问题、完成你的任务”。这一步数据量小得多,但作用关键。 注意:它用的还是第 19 章那套“预测下一个 token + 交叉熵 + 反向传播”,只是把训练数据从“互联网文本”换成了“标准问答范文”,并没有换算法。

为什么少量 SFT 数据,能把模型“掰”得这么明显?

这听起来反直觉:预训练吃了几万亿 token,SFT 可能只有几十万到几百万条样本,凭什么能让模型行为大变? 关键在于,SFT 不是从零教模型知识,而是在已经很会续写、很懂语言的底座上,重新校准它的“使用接口”。

预训练模型早就见过解释、教程、代码、问答、论文、论坛讨论,所以它并不是不会回答;问题是它的默认目标只是“把文本接得像”。 你输入“解释一下梯度下降”,底座可能续写成百科、课堂笔记、论坛回复,也可能只是顺着你的话往下编。 SFT 把训练分布集中改成:

还要记住一个训练顺序上的事实:后训练发生在预训练之后。同一批参数已经被预训练塑好大体能力, SFT 再用更小的学习率、更新更短的时间,把“指令区域”的输出往范文方向拉。 它不必重写整个模型,只要把常见 prompt 附近的行为调顺,用户体感就会非常明显。

训练时,哪部分 token 真正在计分?

很多人第一次听说 SFT 会困惑:既然还是“预测下一个 token”,那是不是整段 system / user / assistant 文本都拿去算 loss?真实实现里通常不是。 更常见的做法是:把整段对话都喂给模型看,但只对 assistant / completion 部分算 loss; 前面的 prompt(system/user) 主要是拿来当上下文条件,自己通常不直接计分。

比如一条样本被格式化成:

[<user> 解释牛顿第一定律 <assistant> 牛顿第一定律说 ... <eos>]

训练时模型会把这整串 token 都过一遍前向,但 loss mask 大致像这样:

token: [<user> 解 释 牛 顿 ... <assistant> 牛 顿 第 一 定 律 说 ... <eos>]
mask : [   0      0  0  0  0      ...      0         1  1  1 1  1  1  1 ...  1 ]

这里的 0/1 不是“看不看”,而是“计不计分”:0 表示这个位置不算 loss,1 表示这个位置要算 loss。 所以 mask 掉 prompt != 模型没看到 prompt。它照样看了整道题,只是老师打分时主要看它的“答题区”。

tokens = [prompt..., assistant..., <eos>];                    1
target_mask = [0, 0, 0, ..., 1, 1, 1, 1];                    2

logits = model(tokens[:-1]);                                 3
loss = Σ target_mask[t+1] * CrossEntropy(logits[t], tokens[t+1]) 4

这也是它和预训练在“训练感觉”上的一个关键区别:预训练更像对整段自然文本普遍计分; SFT 则更像拿 prompt 当题干、拿 assistant 当标准答案。底层依然常是交叉熵,但监督重点已经从 “文本通常怎么继续写”变成了“面对指令时,理想回答应该怎么写”。

LoRA / PEFT: “只训一小块参数”是怎么做到的?

PEFT(Parameter-Efficient Fine-Tuning)是“参数高效微调”的总称,LoRA 是其中最常见的一种。 它的关键不是换掉 SFT 的训练算法,而是不再直接改原来那块巨大的权重矩阵。假设某层原本前向是:

LoRA 会把它改成:

这里的核心思想叫低秩增量:不去学一整个巨大的 ΔW,而是假设“这次微调真正需要的改动,可以用一个很低秩的小补丁近似出来”。 于是训练时:

• 原权重 W 冻结:前向时照样参与计算,但不更新。
• 只训练 A、B:梯度只流到这两块新增矩阵,Adam 的状态也只为它们维护。
• 推理时可并回去:训练完后,把 (α/r)BA 加回 W,就又变回一层普通线性层。

到底省多少?拿具体数字算一遍。 设某层 d_in = d_out = 4096、取 rank r = 8:

这也是为什么很多开源项目会写“7B 模型 + LoRA 微调”——本体还是 70 亿参数,只是训练时不再硬拧这 70 亿个旋钮, 而是在若干层旁边外挂一些很小的“微调旋钮”。最常见的插入位置,就是 attention 里的 W_Q/W_K/W_V/W_O 和 FFN 的线性层。

那这些参数到底存在哪?

这是 LoRA 最容易被绕晕、也最实用的一点:底座和 LoRA 是两份完全分开的权重。

用的时候:加载底座 + 加载 adapter,前向按 y = Wx + (α/r)BAx 一起算(或先把 (α/r)BA 并回 W 再跑)。 正因为 adapter 这么小,你可以给同一个底座配好多套 LoRA——客服一套、写代码一套、翻译一套,每套才几 MB,要用哪个就挂哪个、随时热插拔,而不必为每个任务各存一份几十 GB 的完整模型。这也是开源社区能分享海量“XX 风格 LoRA”的原因。

③ RLHF:按人类的喜好“对齐”

SFT 已经能让模型“好好回答”,但“什么才是更好的回答”很难写成标准答案——语气、分寸、有没有真的帮上忙, 这些没法像“1+1=2”那样标注。这里有个关键的转念:让人“写出满分答案”很难,但让人“判断两个答案哪个更好”很容易。 RLHF(基于人类反馈的强化学习)就建立在这句话上,分三步走:

1. 收集偏好:同一个问题让模型给出多个回答,请人排序哪个更好。这种“比较题”标起来又快又稳。
2. 训练奖励模型:用这些排序,训练一个专门的打分模型(reward model),让它学会给任意回答打出一个“人类有多喜欢”的分数——相当于把“人的口味”蒸馏成一个可自动打分的裁判。
3. 用强化学习优化:让大模型不停生成回答、让裁判打分,再用强化学习(如 PPO)把它朝高分方向推。同时挂一个“别跑太偏”的约束(KL 惩罚),防止它为了讨好打分器而说出一堆通顺却怪异的废话。(PPO、策略梯度等 RL 基础见第 12 章。)

今天聊天助手那种得体的语气、拒绝有害请求的分寸,很多就来自这一步。近来也流行更简化的 DPO:跳过“单独训一个奖励模型”,直接拿人类偏好数据把模型“掰”过去,工程上更省事,思路完全一致。

④ 知识蒸馏:让小模型“拜大模型为师”

大模型效果好,但太重,难以塞进你的手机或个人电脑。知识蒸馏(distillation)让一个小的 学生模型去模仿大的教师模型:不只学“正确答案”,还学教师输出的整个概率分布 (即“软目标”)——因为“它觉得‘吃饭’概率 0.6、‘干饭’0.2、‘用膳’0.05”这种细微的偏好本身就是宝贵知识。

⑤ 为什么这几年才爆发:四个卡点同时解开

到这里,我们已经把大模型的核心训练流程拆开了。现在补一个更宏观、但很关键的问题: 神经网络、反向传播、GPU、互联网都不是今天才出现,为什么大模型偏偏在最近几年爆发? 答案不是某个单点突然神了,而是四个长期卡住的条件第一次同时接上:数据够喂、算法能学、算力能训、工程能用。

所以“大模型爆发”更像四道闸门同时打开:Web/Code/Feedback 提供可扩展的数据, Transformer + 规模定律给出可扩展的算法路线,GPU 集群提供可扩展的训练能力, 工程系统把训练和服务做成可持续迭代的流水线。只有其中一块成熟,最多产生漂亮 demo; 四块同时成熟,才会出现 ChatGPT 之后这种社会级应用扩散。

8. 模型是怎么一代代迭代升级的?

学会了“炼一个模型”,一个很自然的问题是:GPT-4 到 GPT-5,难道是重新训一个吗? 答案是——大版本升级,底座确实基本是从头重新训一个;但你平时感受到的大多数“变强”,并不是重训,而是更便宜、更频繁的后训练迭代。 迭代其实发生在好几个时间尺度上:

那 Flash / Pro 这种区别是什么?

很多产品还会在同一代模型里分出不同档位,名字可能叫 Pro、Flash、Mini、Lite、Turbo。这通常不是“GPT-4 → GPT-5”那种代际升级,而是同一产品线里按能力、速度、价格、上下文长度做的工程取舍。

所以选模型时不要只看名字像不像“新一代”。更实用的判断是:这件事是要一次答得最稳,还是要大量、便宜、低延迟地完成? 前者偏向 Pro,后者偏向 Flash / Mini。它们的关系更像“同一车系的性能版和省油版”,不是“上一代车和下一代车”。

为什么大版本非得“从头再来”?

既然后训练那么省,为什么大版本不能在旧模型上“接着训”?因为一次真正的代际提升,往往三样东西同时变了,旧权重根本接不上:

• 结构变了:参数规模、层数、上下文长度甚至架构(比如换 MoE、改注意力)都可能改,旧权重的形状对不上,没法续训。
• 数据变了:新一代会用更大、更新、更干净的数据重新配比;在旧模型上打补丁,改不动它已经“学歪”的底子。
• 要冷启动:想要能力发生质变,通常得从随机初始化重新走一遍完整预训练——几千上万张 GPU 跑几个月,烧掉的钱以千万美元计。所以大版本不会频繁出。

9. 最近的一些新方向(建立个印象就好)

大模型领域跑得飞快,新词层出不穷。但你会发现一个规律:再新的花样,也都长在前面这套地基上。 下面几个最常被提到的方向,不求精通,先混个脸熟。

推理模型:先“想很久”,再作答

以 OpenAI o1、DeepSeek-R1 为代表的推理模型(reasoning model),核心变化是: 在给出最终答案前,先自己生成一大段思维链(第 22 章会细讲),一步步推演,想清楚了再回答。 相当于把“一步一步想”从你来提示,变成了模型天生就会、而且能想很长。

• 测试时算力(test-time compute):让模型在回答时“多花时间思考”(生成更多中间推理),难题正确率明显提升——花的不再只是训练算力,还有推理时的算力。
• 怎么训出来的:很多用一种“可验证奖励”的强化学习(RLVR)——数学、代码这类有标准答案的任务,答对给正奖励、答错给负奖励,让模型自己摸索出好的推理套路。这是 RLHF 之后后训练的新玩法。

那模型推理时怎么知道该想多久?它不是凭空有个“自知之明”开关,而是三件事叠在一起:

• 外部预算:产品或 API 会给这次请求一个思考档位,比如 low / medium / high、reasoning_effort、thinking_budget 或最大 reasoning token 数。服务端再把它变成模型能感知的控制信号,例如特殊 token、系统指令、解码配置或内部路由策略。
• 模型策略:训练和强化学习会让模型见到“简单题短想、难题多想”的样本与奖励。久而久之,模型会学到一种停机策略:什么时候继续推演、什么时候检查、什么时候转入最终回答。
• 运行时截断:就算模型还想继续生成中间推理,一旦 reasoning token、总输出 token、工具调用轮数或超时达到上限,服务端也会强制停止或转入最终回答。

所以“思考深度”更准确地说是外部预算 + 模型学到的停机策略 + runtime 硬限制共同决定的。 调高它不会改变模型权重,只是允许同一个模型在推理阶段花更多 token、更多候选或更多验证轮次。简单题可能只是变慢变贵;难题才更可能因此做对。

真正难的是:推理长度本身不好直接监督。训练时通常不是教模型“这题必须想 137 个 token”, 而是让它学会在预算内判断继续想是否值得。

• SFT 给长度示范:数据里可以放“简单题 → 短推理”“难题 → 长推理 / 多次检查”的样本,让模型先模仿不同题型下的展开方式。
• RL 奖励正确性:数学、代码、逻辑题可以用最终答案、测试用例或 verifier 判断对错。模型如果靠更长推理把题做对,就会得到更高奖励。
• 成本项惩罚磨蹭:只奖励答对会鼓励模型无限展开,所以奖励里常会扣掉 reasoning token、工具调用或耗时成本,逼它学会“能短想就短想,难题才多想”。
• effort 条件控制:训练时把 low / medium / high 这类档位也作为条件喂给模型,让同一类题在低档更简短,高档更愿意检查和尝试。
• runtime 兜底:训练只能塑造倾向,不能保证每次都停得刚好;线上仍要靠 max reasoning tokens、超时和工具轮数上限兜住成本。

effort 条件控制可以理解成“给同一个模型装一个推理预算旋钮”。训练样本不只长这样:

题目 → 推理过程 → 答案

而是会把预算档位也放进条件里,像这样:

[effort=low]   题目 → 短推理 / 少检查 → 答案
[effort=high]  题目 → 更完整推理 / 多检查 / 可尝试备选解法 → 答案

这里的 [effort=high] 不一定真是用户能看到的文字,也可能是服务端插入的特殊 token、隐藏控制字段或路由配置。 关键是模型在训练时反复见到“同类问题 + 不同 effort 条件 → 不同长度和细致程度的推理轨迹”。 到推理时,产品 UI 里的“快速 / 深度思考”或 API 里的 reasoning_effort,就会被服务端翻译成类似的控制信号。

这不是精确控制“必须想 512 个 token”。它控制的是分布倾向: low 档更倾向于少展开、快给答案;high 档更倾向于拆步骤、做检查、必要时换一种解法。 最终长度仍由题目难度、模型停机策略和 runtime 上限共同决定。

所以 reasoning 模型学到的不是精确计时器,而是一种策略: 这道题继续推演带来的正确率收益,值不值得多花这些 token。 这也是为什么高 effort 往往更强但更慢、更贵,而且不是所有问题都会明显受益。

多模态:不只吃文字

多模态(multimodal)模型(GPT-4V、Gemini、Qwen-VL 等)能同时处理图、音、视频和文字。 内核不变:各模态都切成 token → 编成向量 → 拼成一条序列 → 送进同一个 Transformer → 往往仍自回归生成文字。

① 各模态怎么切成 token

② 编码、投影、拼进 LLM

图像经 ViT 等视觉编码器变成 patch 向量,再经投影层 MLP拉到与词嵌入相同维度; 文字照常 BPE + 嵌入。推理时典型序列:

[系统提示] [图开始] patch₁…patchₙ [图结束] [用户问题 tokens] [模型开始生成…]

自注意力让“猫”这类文字 token 直接关注猫所在的 patch——跨模态对齐靠统一注意力,不必硬接两套系统。

③ 训练通常分阶段

1. CLIP 式对齐:成对“图+配文”,用点积/余弦把配对拉近、非配对推远。
2. 接 LLM + 训投影:冻住或轻微微调语言模型,用“图→描述”学连接器。
3. 多模态指令微调:图+问答三元组(VQA 等),类似 SFT。
4. (可选) RLHF:按人类偏好再对齐(第 12 章)。

图片编码器: image → image vector
文本编码器: text  → text vector

配对图文:   拉近
不配对图文: 推远

反过来:文生图与文生视频(扩散模型)

上面多模态讲的是“图/音进来 → 出文字”(理解)。反方向——“文字进来 → 出图/视频”(生成)——今天主流用的是另一套和“预测下一个 token”完全不同的技术: 扩散模型(Diffusion Model)。它是这几年最漂亮的想法之一,先把它单独讲透,再看文生图 / 文生视频怎么用它。

① 扩散模型:先学“去噪”,再从噪声里“显影”

直接让模型“凭空画一张猫”太难——它要一次性决定几百万个像素,任何一步走偏都满盘皆输。扩散模型的聪明之处是把这件难事拆成很多步简单的事,而拆解的钥匙,是一个人人都懂的不对称现象:

它分成正反两个方向:

• 正向 · 加噪(只为造训练题,不用学):拿一张清晰图,分成很多步、每步掺一点高斯噪声,几百步后变成纯雪花。每一步的“加了多少噪”都是我们自己撒的,所以答案现成——这又是一种自监督,不需要人工标注。
• 反向 · 去噪(这才是要训练的网络):给网络一张带噪的图 + 当前是第几步 + 文字提示,让它预测“这一步掺进去的噪声长什么样”。预测对了,把噪声减掉,图就清晰了一点点。用第 6 章的反向传播 + 第 8 章的优化器,在海量图上把这个“去噪器”练出来。

生成时把这个去噪器反复用几十步就行:从一张纯随机噪声出发 → 去噪器减掉一点噪 → 再减一点 → …… 一张清晰图像照片显影一样慢慢浮现。

② 文生图:让文字给去噪“掌舵”

扩散本身只会“去出一张图”,可怎么保证去出来的正好是你要的那张?办法是在去噪的每一步都把文字提示喂进去,让它决定“噪声该往哪个方向减”。这一步靠的正是第 17 章的注意力:

• 文字编码:先用一个文本编码器(常见是 CLIP)把提示词变成向量;
• 交叉注意力掌舵:去噪网络的每一步,让正在生成的图像特征去“查询”这些文字向量,做交叉注意力,从而“词 → 像素”地对齐——“戴帽子的橘猫”里的“橘”“帽子”各自拉动对应区域。

还有个省算力的关键工程:主流的 Stable Diffusion 不在原始像素上去噪(几百万像素太贵),而是先用一个自编码器(一个先把图压小、再还原回去的网络)把图压进小得多的潜空间(latent)里去噪,最后再解码回像素——这就是名字里 “Latent” 的由来。

③ 文生视频:在文生图上再管住“时间”

视频无非是一连串图像帧。所以文生视频大体是文生图的“扩展版”,但多了一个致命难点:帧与帧之间要连贯——同一个人不能下一帧突然换脸,物体运动要顺滑。逐帧独立生成必然“鬼畜闪烁”,所以关键动作是让模型同时看多帧、把时间也纳入注意力:

• 时空注意力:去噪网络不只在一帧内做空间注意力,还在帧与帧之间做时间注意力,让相邻帧互相“对齐”,保证同一物体连贯、运动平滑。
• 3D 潜空间:把“一段视频”整体压进潜空间(多了时间这一维),对整段一起去噪,而不是一帧一帧各画各的。
• Diffusion + Transformer(DiT):Sora 这类模型把视频切成时空小块(spacetime patch)当 token,用 Transformer 主干做去噪——等于把第 18 章的 Transformer 和扩散缝在一起,既吃得下长序列,又能 scale up。

更长的上下文

早期模型一次只能读几千 token,如今动辄支持几十万甚至上百万——你能把一整本书、一个代码仓库丢进去让它一起看。 难点在第 17 章那句话:注意力计算量随长度平方增长,所以需要稀疏注意力等优化(第 21 章)才扛得住。

上下文窗口大小是怎么定出来的?

常有人问“为什么这个模型是 8K,那个是 128K”。答案是:窗口大小不是某一个因素拍板的,而是三道关卡里最紧的那个—— 任何一关卡住,窗口就到头了。

更省的架构、更强的“手脚”

• MoE(混合专家):每次只激活一部分“专家”子网络,用更少的实际计算撑起更大的参数量(第 21 章细讲)。DeepSeek-V3 就是典型。
• Agent(智能体):让模型学会调用工具、上网、写代码、多步做事,从“会聊天”变成“能办事”(第 22 章细讲)。

10. 它的本质与局限:清醒地看待它

把上面串起来,你会得到对大模型最准确的一句话概括: 它是一个被海量文本喂大的、极其强大的“下一个 token 概率预测器”。 理解这一点,它的“超能力”和“毛病”就都说得通了。

好消息是:这些局限大多有工程解法——给它接上实时检索(RAG)、外部工具(function calling)、 让它调用计算器或搜索引擎。这些正是第 22 章的主题。把它当成一个 强大但会犯错的概率文本生成器,而不是全知神谕,你就能用得又稳又好。

11. 你已经走通了主干

回头看看这一路搭起来的东西:

• 从一个神经元的加权求和 + 激活(第 2 章),
• 到堆成网络(MLP)、让数据前向流动(第 3 章),
• 用损失衡量错误、靠梯度下降和反向传播学习(第 4–6 章),
• 再用现代训练栈把它训稳(第 9 章),
• 用注意力处理序列、拼出Transformer(第 16–18 章),
• 做成会写字的语言模型(第 19 章),
• 最后放大成大模型,并学会它是怎么训练、为何有局限(本章)。

原理主干到此走完。但一个上千亿参数的模型,靠什么硬件才跑得起来?普通人又该怎么把它用好? 这两个非常实际的问题,我们用接下来两章回答。

动手与思考

原理清楚了,但“上千 GPU 训数周”到底是怎么回事?下一章我们钻进机房, 看看大模型靠什么硬件和并行技巧才跑得起来:GPU、显存、数据并行、张量并行、KV cache……