第 20 章 · 通往大模型

通往大模型:原理与训练

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

路线图 · 你在这一段的哪一站

上一站(第 19 章)你已亲手搭出迷你语言模型;本站把它放大一万倍——分词 / 词嵌入、规模定律与涌现、预训练 → SFT → RLHF → 蒸馏(全景图第 ⑦ 步);下一站(第 21 章)讲它靠什么硬件才跑得起来。

读完这一章,你会明白

真实大模型怎么分词(BPE / 子词),词表大小意味着什么;
1750 亿参数装在哪些层、每层约多少权重(GPT-3 举例);
“词嵌入”把词变成语义坐标,为什么向量夹角能表示“意思相近”;
规模定律(Scaling Law)和涌现能力,到底在说什么;
预训练与后训练(SFT、RLHF、蒸馏)的分工,以及“底座模型”和“对话模型”的区别;
推理模型、多模态(图像/语音怎么进 Transformer)、长上下文(窗口大小由什么决定、为何标称≠有效)等最近的新方向,大致是怎么回事;
常见“体感”问题:模型降智、对齐税、灾难性遗忘各自发生在训练链路的哪一环;
一串训练“黑话”:自监督、泛化、过拟合、epoch/batch/step、超参数;
大模型的本质与局限——它为什么会“一本正经地胡说八道”。

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

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

本书 mini LM几千参数 · 几句话语料 · CPU 几秒

→

GPT-31750 亿参数 · 数千亿 token · 上千 GPU 训数周

→

DeepSeek-V36710 亿参数(MoE)· 十几万亿 token

同一套机制(Embedding + Transformer + 预测下一个 token),规模相差上亿倍。

最重要的一句话

大模型不是用了什么你没学过的“黑魔法”。它就是把你已经理解的 注意力、Transformer Block、预测下一个 token 堆得更深、喂得更多、训得更久。这一章新增的每个概念,都只是围绕这个内核的“外围工程”。

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

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

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

词嵌入 EmbeddingV × d

→

× L 层 Block每层 ≈ 12d²

→

LM HeadV × d(常与嵌入共享)

GPT 类模型的参数主体 = 嵌入 + 很多层 Transformer Block + 输出头。下面用几个字母记形状——先别慌,含义见紧挨着的说明框。

这几个字母分别是什么

d — 模型宽度:每个 token 在模型里用多宽的一条向量表示(一串有多少个数)。从嵌入层出来是 d 维,进每一层 Block、层与层之间传递,宽度始终是 d。GPT-3 的 d=12 288;本书 mini LM 常见 d=64。
L — 层数:Transformer Block 纵向堆了几层。每层各自有一套 attention + FFN 权重,参数量大致随 L 线性涨。GPT-3 的 L=96。
V — 词表大小:分词后模型认识多少个不同的 token(每个 token 一个 id)。嵌入表有 V 行,LM Head 要给词表里每个 token 打一个分,所以这两块都是 [V×d] 的矩阵。GPT-3 的 V≈50 257。
f — FFN 中间层有多宽:每个 Block 里的前馈网络先把 d 维向量临时扩到 f 维,再压回 d 维。GPT 系惯例 f≈4d。对应两个矩阵 [d×f] 和 [f×d]。GPT-3 的 f=49 152。
h — 注意力头数:把 d 维切成 h 份并行算注意力,每头 d/h 维。只改变怎么切分计算,不改变四个投影矩阵的总参数量(仍是 4d²)。GPT-3 的 h=96,每头 128 维。

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

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

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

别把“注意力权重”当成参数

前向时算出来的注意力分数 / 注意力矩阵(谁该多看谁)是临时中间结果,随输入变、算完就丢,不算进 1750 亿。参数量只统计 W_Q, W_K, W_V, W_O 这类固定矩阵。

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 亿参数)

和本书 mini LM 比一比

若 L=2、d=64、V=几十(字符级词表),Block 部分只有 L×12d² ≈ 几万到十万量级,再加嵌入/LM Head 也就十万级参数——和 GPT-3 差将近九个数量级,但矩阵名字、乘法形状完全一样。想逐步看 [n×d]×[d×d] 怎么乘,可回第 19 章 §4.4。

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)。

BPE 的直觉:高频搭档就“焊”在一起

BPE 的规则很朴素:谁和谁经常挨在一起出现,就把它俩合并成一个新 token,反复合并。就像 “ing”“tion” 这种后缀在英文里到处出现,于是它们被合成一个整体;中文里“沙发”“葡萄”这种高频组合也会被当成一个词。这样常用的东西用一个 token 就能表示,既短又高效。 (类比一下:晚自习后你和她三番五次被班主任“偶遇”,久了大家就默认你俩是“一对儿”——高频共现,合并成一个整体。)

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

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

动手看一眼

OpenAI 提供了在线分词器 platform.openai.com/tokenizer,把一句中英文粘进去, 就能看到它被切成了哪些 token、各自的 id。你会直观感到:token 数 ≠ 字数,这也是 API 按 token 计费的原因。

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

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

用 RGB 颜色理解“向量”

怎么用几个数字表示一个复杂事物?你其实早就会了:屏幕上任何颜色都用 RGB 三个数表示, 比如橙色 ≈ (255, 165, 0)。相近的颜色,三个数也相近。词嵌入一模一样,只是维度更高 (几百到上万维),用一串数字表示一个词的“意思”。意思相近的词,向量也相近。

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

相似度 ≈ cos(夹角) = a · b|a| |b| 这叫“余弦相似度”:只看方向、不看长短。它就是把点积按长度归一化了一下

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

迁移学习:别人练好的,可以直接拿来用

词向量一开始是随机的,要靠海量训练才长出语义。好消息是:别人训好的向量可以直接下载来用 (比如经典的 GloVe 词向量),这叫迁移学习——站在别人的肩膀上,省掉从零训练的巨大成本。大模型时代更是如此:绝大多数人不会从头训一个,而是拿开源的“预训练模型”接着用。

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

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

注意:三样要一起涨,不能只堆参数

很关键但常被忽略:光把参数堆大、数据却不够,模型会“吃不饱”,反而学不好(后面会讲的过拟合)。研究(如 Chinchilla)发现:参数和数据要按比例一起增长才最划算。所以你会看到现代模型动辄用 十几万亿 token 训练——参数大,喂的数据也得跟上。

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

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

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

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

算力也能估:一个粗略但好用的公式

训练要烧多少算力(浮点运算次数 FLOPs),有个广为流传的估算:FLOPs ≈ 6 × 参数量 × 训练 token 数。它告诉你一件扎心的事:参数和数据任意一个翻倍,算力就翻倍——两个都想涨,成本是相乘着往上冲的。这也是为什么训一个前沿大模型动辄要上千张 GPU、烧数百万美元、跑好几周:不是钱多烧得慌,是这条曲线逼的 (硬件账细算见第 21 章)。

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

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

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

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

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

① 预训练海量文本上预测下一个词

→

② 微调 SFT用指令数据教它“听话”

→

③ RLHF按人类偏好对齐

→

④ 蒸馏(可选)把大模型能力压进小模型

从“会接话的语料模型”到“有用、能落地的助手”,通常要走这几步。

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

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

“底座模型”和“对话模型”的区别

开源社区里名字带 -base 的通常是只做过预训练的底座模型:博学,但只会顺着你的话往下接; 带 -chat / -instruct 的则是又做过后训练的版本,才会好好回答问题、听从指令。今天各家大模型拉开体验差距的,很大一部分就在后训练这一段的数据质量与工艺。

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

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

监督 vs 自监督:区别只在“目标从哪来”

监督学习:目标(答案)由人工标注,比如给一张图片标上“猫”。
自监督学习:目标从数据里自动抠出来,比如把“青海长云暗雪山,孤城遥望玉门关”里的 “玉门关”盖住,让模型猜——被盖的词就是现成的答案。两者都要有目标值,只是自监督省掉了人工。海量数据下人工标注不可能,所以预训练必须靠自监督。

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

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

一条 SFT 数据长什么样

就是一问一答的“范文”,比如:
指令:“用一句话解释什么是黑洞。” → 理想回答:“黑洞是引力强到连光都逃不出来的天体。”
成千上万条这样覆盖问答、翻译、写代码、总结的范文,教会模型看到指令就给出对应的回答, 而不是把指令当普通文本接着往下续。这里质量远比数量重要——几万条精挑细选的,常胜过几百万条粗制滥造的。

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

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

位置	内容	是否计入 loss	为什么
system / user	提示词 / 指令 / 题干	通常不计	它们负责告诉模型“题目是什么”,不是本轮想让模型去模仿的输出
assistant	理想回答	通常计	这是 SFT 真正想教模型学会的那段输出
结束符 `<eos>`	回答结束位置	常常计	让模型顺便学会“这里该停了”

一句最短的话: prompt 负责出题,assistant 负责得分。

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

[<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。它照样看了整道题,只是老师打分时主要看它的“答题区”。

SFT loss mask · 示意伪代码(帮助理解)

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

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

把完整 prompt + answer 拼成一条训练序列。
给每个位置配一个“计不计分”的开关。assistant 回答区域通常标 1,prompt 区通常标 0。
前向时模型整段都看,因为回答必须依赖题目。
算 loss 时只在标了 1 的位置上计分。所以 SFT 真正在优化的是 “给定这个 prompt,回答该怎么写”。

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

灾难性遗忘(catastrophic forgetting)

在预训练底座上继续 SFT/微调时,模型可能新任务学会了、旧本领丢了——比如微调成“只会写邮件”,通用推理变差。缓解办法包括:混一定比例的原预训练数据、用小学习率、只训少量参数(LoRA/PEFT——在权重旁加低秩小矩阵,只更新这部分), 以及控制微调轮次。这不是 bug,而是在旧分布与新任务之间抢参数的必然张力。

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

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

y = Wx W 是原来的大矩阵(比如 attention 里的 W_Q/W_K/W_V 或 FFN 的线性层权重)

LoRA 会把它改成:

y = Wx + (α/r)BAx W 冻结不动;只训练新增的小矩阵 A 与 B。其中 A ∈ R^r×d_in, B ∈ R^d_out×r, r 很小

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

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

做法	全量微调	LoRA
更新什么	直接更新整块大矩阵 `W`	冻结 `W`,只更新小矩阵 `A` / `B`
训练参数量	很大	很小(由 rank `r` 决定)
优化器状态	要给全部参数存 Adam 状态	只给 LoRA 参数存状态
底座权重显存	要放	也还得放,LoRA 省的是“可训练部分”,不是把底座凭空删掉

所以 LoRA 更准确的说法是: 省训练参数、优化器状态和微调成本,但底座模型本体仍然要在。

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

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

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

① 收集偏好同一问题多个答案,人来排序

→

② 训练奖励模型学会给答案打“人有多喜欢”的分

→

③ 强化学习把大模型朝高分方向推(+KL 约束)

把“人的口味”先蒸馏成一个会自动打分的裁判,再让模型去追这个裁判的高分。

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

对齐税(alignment tax)

RLHF/DPO 把模型调得更安全、听话、像助手,但往往要付一点能力代价——复杂推理、创造性、某些专业深度可能不如对齐前的底座。俗称“对齐税”:不是模型“坏了”,而是优化目标从“接话像互联网”变成了“人类更喜欢”。KL 惩罚、保守的奖励模型、过度拒绝有害内容, 都会让这种体感更明显。工程上常在能力评测与安全评测之间找平衡。

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

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

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

这里用上了第 19 章的温度

蒸馏时常把 softmax 的温度调高(第 19 章),让那些低概率但有意义的选项“显形”, 学生才学得到这些“隐藏知识”。DeepSeek 就曾用 R1 蒸馏出多个小模型(如 DeepSeek-R1-Distill-Qwen-14B,140 亿参数)开源给社区——学生虽小,却继承了老师不少本事。

蒸馏、小模型与“降智”的一种来源

蒸馏和直接做小模型,换的是体积与速度,付的是能力上限。学生很难 100% 复制教师的“暗知识”, 复杂推理、长尾知识、细腻概率偏好最容易丢——用起来就像“同款但没那么聪明”。这和量化、MoE 压 k导致的降智是不同环节, 但体感类似:不是不会,而是浅了、窄了。

训练黑话速查(这些词在哪都会遇到)

· epoch(轮次):把全部训练数据完整过一遍叫一个 epoch;要读好几遍(常读常新),但每遍会打乱顺序防“死记硬背”。
· batch(批):一次喂进去的一小撮样本(第 5 章)。
· step(步)/迭代:用一个 batch 更新一次参数,叫一步。
· 超参数:不是模型自己学的参数,而是你手动设定的旋钮——学习率、层数、batch 大小等(第 5、9 章)。“超”只是“在模型参数之外”的意思,不神秘。
· 泛化:在没见过的数据上也表现好,就叫泛化能力强(适应力强)。
· 过拟合 / 欠拟合:过拟合 = 训练集很好、测试集很差(“死记硬背”);欠拟合 = 训练集都学不好(模型太弱或没训够)。第 9 章讲过怎么缓解。

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

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

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

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

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

多模态:不只吃文字

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

① 各模态怎么切成 token

模态	切法	直觉
文字	BPE / 子词	本章 §2
图像	16×16 等 patch 小块	一张图 ≈ 一句由上百个“图块词”组成的句子(第 13 章局部块思想)
音频	频谱片段或神经 codec 码	声音也排成 token 序列
视频	抽帧后每帧走图像流程	序列更长,更吃算力

② 编码、投影、拼进 LLM

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

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

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

③ 训练通常分阶段

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

早融合 vs 双塔

名字不同,套路都是:编码 → 对齐维度 → 拼序列 → 注意力融合 → 预测下一个 token。 LLaVA、Qwen-VL 等主流属于 patch 向量直接与文字 token 早融合进一个 Transformer。

更长的上下文

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

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

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

关卡	决定什么	卡住会怎样
① 位置编码 (硬上限)	注意力本身对位置无感,全靠位置编码标记先后。方案决定了“最远能编到多远”	早期可学习绝对位置(如 GPT-2 的 1024)定死一张位置表,超出就没有对应向量,是一堵硬墙;现代 RoPE / ALiBi 等相对位置有一定外推能力,才谈得上做到 128K、1M
② 训练长度 (软上限)	位置编码“支持”到某长度,不等于模型“用得好”;得在长序列上真正训练/微调过,它才会用远处的信息	没在长序列上训过,远处信息就用不起来。常见做法:先用短序列(如 4K)便宜地预训练,再用长序列续训;或事后用位置插值 / NTK / YaRN 把 RoPE “拉伸”后再少量微调——这就是模型能“事后加长”的原因
③ 算力 / 显存 (现实约束)	注意力的计算与显存随长度平方增长,推理时 KV cache 又随长度线性膨胀吃显存	最卡脖子的一关:长度翻倍,注意力开销约 4 倍。FlashAttention、稀疏/滑窗注意力、PagedAttention(第 21 章)决定了厂商“愿意开多长”、你“用得起多长”

一句话:位置编码能编多远 × 训练时真喂过多长 × 推理时扛得住多长,取最紧的那个,就是窗口上限。

标称 ≠ 有效:128K 不等于 128K 都好用

模型标称支持 128K,不代表这 128K 里的信息都能被可靠利用。存在著名的 “迷失在中间(lost in the middle)”现象:开头和结尾的内容记得牢,正中间的容易被忽略。所以有效上下文常明显短于标称值——把最关键的材料放在开头或结尾,往往比一股脑塞满窗口更靠谱。

上下文不够长,也会像“降智”

若产品侧把输入截断(只保留最后几千 token),或你贴的代码/文档超出窗口被 silently 砍掉, 模型等于没看到关键前文——回答变短、变偏、变健忘,常被误以为是“模型变笨了”。长上下文能力取决于训练时的长度扩展与推理时的显存/KV cache(第 21 章),也取决于你有没有真的把材料完整送进去。

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

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

万变不离其宗

推理模型、多模态、长上下文、MoE……概念很唬人,但拆开都是你已经学过的东西: token 化 + Transformer + 预测下一个 token + (后)训练。抓住这个内核,追新会轻松很多。

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

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

大模型并不“无所不知”

幻觉(hallucination):它的目标是“预测最像样、最连贯的下一个词”,而不是“说真话”。当它对某事没有可靠依据时,照样会生成通顺合理、却是编造的内容。
知识截止:参数一旦训练完就固定,它的知识停在训练数据那一刻,不知道今天的新闻、天气、股价。
偏见:训练数据里的偏见会被它一并学进去。
不会真正“算”与“查”:它是在做极其复杂的模式延续,不是在执行精确计算或实时检索。

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

10. 你已经走通了主干

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

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

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

小结

大模型内核 = 第 19 章的“预测下一个 token + 自回归”,只是规模大上亿倍;参数主体是嵌入 + L 层 Block(每层约 12d²) + LM Head,GPT-3 约 175B。
真实分词用 BPE/子词:高频组合合并成一个 token,存进词表;词表大小是权衡。
词嵌入把词变成“语义坐标”,点积/余弦相似度衡量语义远近;词向量可迁移复用。
Scaling Law:参数、数据、算力一起放大,性能可预测提升;超过门槛会“涌现”新能力。
预训练(自监督)练出底座能力;后训练(SFT → RLHF/DPO → 蒸馏)把它调成好用的助手。SFT 常常仍是交叉熵训练,但通常只对 assistant/completion 部分计 loss,prompt 更多是作为条件输入。
最近方向:推理模型、多模态(patch→ViT→投影→拼序列)、长上下文、MoE——内核仍是 token + Transformer。上下文窗口由位置编码 × 训练长度 × 算力显存三关中最紧的一关决定,且标称长度≠有效长度。
降智/对齐税/遗忘等多半发生在后训练、蒸馏、量化、MoE 压 k、截断、产品护栏等环节,先定位链路再判断能力。
它本质是概率预测器,所以会幻觉、有知识截止和偏见——要理性使用,并靠 RAG/工具补救。

动手与思考

问题 1:GPT-3 的 1750 亿参数主要装在哪儿?单层 Block 量级怎么估?

主体在 L 层 Transformer Block(每层四套 [d×d] 注意力矩阵 + 两层 FFN),加上词嵌入和 LM Head(常为 [V×d],可与嵌入绑定)。单层主项约 12d²;GPT-3 用 L=96、d=12288 时,96 层合计约 1700 亿,再加嵌入约 6 亿,总数约 175B。详见 §2。

问题 2:为什么真实大模型用 BPE/子词,而不是像本书那样按字符分词?

字符级会让序列变得很长,而注意力计算量随长度平方增长,代价高。BPE 把高频组合合并成一个 token,序列更短、更高效,同时又比“整词”更灵活(能拼出没见过的词)。

问题 3:为什么用“向量夹角/点积”而不是“距离”来衡量词的语义相似度?

因为训练中向量会被整体拉伸或缩放,距离会“强烈波动”,不稳定;而方向(夹角)更能反映本质的语义关系。点积/余弦相似度只看方向,点积越大夹角越小、语义越近。

问题 4:预训练用的是“自监督”,它和“监督学习”的区别到底在哪?

两者都要有目标值(答案)。监督学习的目标靠人工标注;自监督的目标从数据本身自动产生,比如遮住一个词让模型预测,被遮的词就是答案。海量数据无法人工标注,所以预训练靠自监督。

问题 5:大模型为什么会“一本正经地胡说八道”?怎么缓解?

因为它的目标是预测“最像样、最连贯的下一个词”,而不是“说真话”;缺乏依据时也会编出通顺但错误的内容(幻觉)。缓解办法包括给它接实时检索(RAG)、外部工具/计算器(function calling),以及对关键事实自己核对。

问题 6:“预训练”和“后训练”分工是什么?为什么 -base 模型不好直接聊天?

预训练在海量文本上自监督地学到通用语言能力和世界知识,给出一个“博学但只会接话”的底座模型(base)。后训练(SFT → RLHF/DPO → 蒸馏)在底座之上加工,教它听指令、按人类偏好回答。-base 没做后训练,所以往往只会顺着你的话往下写,而不是好好回答——要 -chat/-instruct 那样做过后训练的版本才好用。

问题 7:SFT 为什么常常“只对 assistant 部分算 loss”,而把 prompt mask 掉?

因为 SFT 真正想教模型学的是“给定这道题,标准答案该怎么写”。prompt/system/user 主要负责提供条件上下文,assistant/completion 才是想让模型模仿的输出。所以训练时通常整段都喂给模型看,但只在回答区计分。注意: mask prompt 不等于没看 prompt——回答的 loss 仍会通过计算图逼模型学会理解题目。

问题 8:一个模型的上下文窗口(比如 128K)到底是由什么决定的?

由三道关卡里最紧的那个决定:①位置编码能表示多远(可学习绝对位置是硬墙,RoPE/ALiBi 才能外推);②训练时真的在多长的序列上练过(没练过就用不好远处信息,可用位置插值/YaRN 事后拉长);③推理时的算力与显存(注意力随长度平方增长,KV cache 随长度线性膨胀)。此外标称长度 ≠ 有效长度,存在“迷失在中间”,关键材料放开头或结尾更可靠。

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