🧠 交互式讲解 · 9 章 · 全部可动手玩

大模型是怎么"想"的

一句话进去,一句话出来。中间到底发生了什么?
把这个黑箱拆成零件,一个一个给你看。

本质上,大模型就是一个把 「猜下一个词」 练到极致的数学函数。
你给它一段上文,它给你全词表的概率分布 —— 然后挑一个,接上去,再猜下一个。
LIVE · 模型此刻正在做的事情
今天天气真好
,52.0%
。18.0%
,适合12.0%
,想9.0%
哇5.0%
!4.0%
↑ 每 2 秒重新计算一次:十几万个候选词,每个给一个概率
00 / 全景

一条数据流的完整旅程

你敲下的那行字,会在模型内部走过这么一条链路。注意最后那个回环箭头 —— 这是大模型和所有传统程序最不一样的地方:它一次只吐一个词,然后把自己吐出来的东西当输入,再来一遍。

⌨️你的文字"今天天气真"
→
✂️分词→ token
→
🧭向量化→ 向量
→
👁️注意力× N 层
→
📊概率分布全词表
→
🎲采样挑一个
↺ 吐出的词拼回输入,重跑整条链路 —— 循环直到吐出「结束符」
1750亿
GPT-3 参数量
96 层
堆叠的 Transformer
~10万
词表大小(token 种类)
1 词/次
每次前向计算的产出
先记住这个反直觉的点:模型内部没有一个"句子"的整体表示。它有的是一串数字、一堆矩阵乘法,以及一个永远只在回答同一个问题的输出层 —— 下一个词最可能是什么?
01 / TOKENIZE

分词:把文字切成"积木块"

模型不认识汉字、也不认识英文字母。它只认识编号。所以第一步,是把你的句子切成一堆小块(token),每块查一个编号(ID)。下面这个输入框可以直接改,实时看切分结果。

今天天气真好 中华人民共和国的首都是北京 attention is all you need 人工智能AI技术2026
中华人民共和国21649的43677首都24156是23166北京29038
13
字符数
5
Token 数
2.60
字符 / Token
为什么要切成碎片?如果按"字"切,词表要覆盖所有字符,英文单词会变得极长且缺乏意义;如果按"词"切,词表会爆炸到几百万,还认不出没见过的词。现代模型用 BPE 子词算法折中:常见词整块留(如 the),罕见词拆开(如 token → tok + en)。
中文更"贵":一个汉字通常要 1~2 个 token,而一个英文单词平均约 1.3 个 token。这直接决定了 API 计费 —— 同样一段内容,中文的 token 消耗往往更高。
02 / EMBEDDING

向量化:给每个 token 一个"意义坐标"

编号本身毫无意义 —— 编号 37 不比编号 12 更接近编号 9。所以模型给每个 token 配了一串长长的数字(词向量,通常 768~12288 维)。这串数字就是它在"语义空间"里的坐标。

一个 token 在内部长什么样

下面是 token「猫」的向量前 24 维(真实模型有几千维,这里截取开头)。点下面的词切换。

猫 狗 汽车 苹果 计算机
dim 0→ 每一根柱子的高度 = 一个浮点数dim 23
关键理解:单个数字没意义,整串数字的"方向"才有意义。训练完成后,「猫」和「狗」的向量方向会天然靠近;「猫」和「汽车」则远远分开。模型从来没见过"动物"这个词,却能在空间里学出"动物"这个区域。

语义空间长什么样

把几千维压成 2 维看一眼(示意)。点任意一个点,看它跟谁最亲。

降维后的 2 个主成分方向(示意)猫狗老虎宠物汽车火车飞机苹果香蕉米饭计算机算法网络
「火车」最近的是 汽车(距离 0.18);最远的是 宠物(距离 1.56)  |  同语义簇共 3 个点

同一个 token,两个完全不同的向量

注意:下面两张图里的「苹果」是同一个 token、同一个 ID。但读完句子之后,它在模型内部的向量已经变成了两副样子 —— 因为注意力把上下文的含义加进了它自己。

句 A · 水果义
我把苹果洗干净吃了
语义方向被拉向 食物 / 可食用 / 甜的
句 B · 公司义
苹果发布了新款手机
语义方向被拉向 公司 / 品牌 / 科技
水果义公司义66°原点
两者余弦相似度 0.41

两串数字的夹角约 66° —— 明显相关,但已经分开了。

夹角越小 = 方向越接近 = 语义越相似。两个「苹果」既没有完全重合(毕竟语境差太多),也没有彼此垂直(它们终究还是同一个词), 而是落在中间某个位置 —— 这就是"一词多义"在向量空间里的样子。

推一步想:如果模型没有注意力机制,每个 token 只能有一个固定的向量,「苹果」就永远停在"水果"和"公司"的中间地带 —— 也就是两个都不像。 是上下文动态改写这一步,才让同一个词在不同句子里有了不同的含义。这也解释了为什么早年那种"查词典式"的词向量(word2vec)做不了真正的语言理解。
03 / SELF-ATTENTION

自注意力:每个词都回头看一眼上下文

这是 Transformer 的心脏。核心动作只有一句话:每个词都去问其他所有词 ——「你跟我有多大关系?」 关系大的,信息就多拿一点。
① 点下面的任意一个词看它把注意力分给了谁;② 再点 H1~H8 切换不同的注意力头,看同一句话被拆解成多少种关系。全部可交互。

H1主谓H2动宾H3相邻H4修饰H5均匀H6句首H7自身H8后视
头 2 · 动宾搭配 —— 动作作用于谁。「追着」几乎只盯着「毛线球」—— 换成"追着公交车",它的注意力就会转向另一个词。
小猫
追着
毛线球
跑
得
飞快
头 2(动宾搭配)中,「小猫」把注意力分给了谁
追着26.0%
毛线球24.0%
跑12.0%
得10.0%
飞快8.0%
换个头,看到的就是完全不同的关系网。同一个句子里,头 1 在追主谓、头 2 在追动宾、头 7 几乎只看自己、头 5 全员盯着句首。 这就是为什么模型要并行几十上百个头 —— 它没法事先知道该看哪种关系,所以干脆全都看一遍,再让下一层去挑有用的。

拆开看:Q / K / V 三个角色

每个 token 会通过三次线性变换,变成三个不同的身份。这就是注意力的全部机关。

Q · Query我在找什么?
发出询问。比如「跑」在问:是谁在跑?跑的是什么?
K · Key我是什么?
挂牌招标。比如「小猫」挂出:名词、动物、主语。
V · Value我能给你什么?
实际内容。匹配成功后,把自己的信息按权重交出去。
Attention(Q, K, V) = softmax( Q·Kᵀ / √d ) · V

Q·Kᵀ → 算两两相关度  |  ÷√d → 防止数值爆炸  |  softmax → 变成加起来等于 1 的权重  |  ×V → 按权重加权求和

多头注意力(Multi-Head):上面这套动作会被并行做几十上百次,每套参数独立训练。所以同一个句子里,有的头在算主谓、有的头在算动宾、有的头只看位置关系 —— 你上面点过的 H1~H8,就是真实模型里确实存在的头类型(其中"首词锚点"和"自身保留"这两类,是研究者用探针工具从真模型里挖出来的典型现象)。最后把所有头的输出拼起来,再压回原维度。GPT-3 每层有 96 个头。

最后一步:8 个头到底是怎么拼回去的

这一步最常被跳过,但它是"多头"真正成立的关键。8 个头各算各的,每个只输出 64 维 —— 它们必须先拼接(concat)回 512 维, 再经过一个线性层 WO 做跨头混合,才得到这一层真正的输出。点按钮逐步看。

① 输入向量 · 512 维(8 个头的维度还混在一起)
H1
H2
H3
H4
H5
H6
H7
H8
↓ 按维度均分成 8 份 · 每份 64 维 · 各自独立算注意力,彼此看不见
H1
主谓
64 维
H2
动宾
64 维
H3
相邻
64 维
H4
修饰
64 维
H5
均匀
64 维
H6
句首
64 维
H7
自身
64 维
H8
后视
64 维
↓ 拼接 concat · 8 × 64 = 512 维 · 首尾相接,不做任何混合
② 拼接结果 · 512 维(每一段来自一个头,颜色即来源)
H1
H2
H3
H4
H5
H6
H7
H8
↓ 线性层 WO · 512 × 512 · 全层唯一一次跨头通信
③ 本层最终输出 · 512 维(各头信息已被彻底搅匀)
阶段 5/5 · 输出 512 维
这是全篇最容易被忽略的一个事实:8 个头在拆开的状态下完全不知道彼此在算什么。 头 1 在算主谓、头 2 在算动宾,它们之间没有任何连接。是 WO 这个矩阵把 8 份结果真正搅在一起, 才让"主谓关系"和"动宾关系"有机会组合出更高层的含义(比如"谁对谁做了什么")。 换句话说:注意力负责"看",WO 才负责"合"。少了这一步,多头就只是 8 个互不相干的单头。
真实规模:GPT-3 每层 d_model = 12288,96 个头,每个头 128 维。 那一层的 WO 是 12288×12288,单这一个矩阵就有 1.5 亿个参数。 而 Q/K/V/O 四个矩阵加起来约 6 亿,占了整层参数量的三分之一 —— 剩下三分之二全在前馈网络里。

剩下那三分之二参数在哪:前馈网络(FFN)

注意力做完之后,每个词的向量还要单独穿过一个两层的前馈网络:先升维 4 倍,过一遍非线性激活,再压回原维度。 它占了单层参数的三分之二,而且有一个很反直觉的性质 —— 它完全不看别的词。

① 6 个位置同时开工,各自独立、互不通信
小猫
追着
毛线球
跑
得
飞快
↑ 点任意一个词,看它自己经历了什么。注意:6 个位置共用同一套 W₁ / W₂ 权重(不像注意力那样权重随内容变化), 但它们在整条通路里从头到尾见不到彼此 —— 位置之间的信息交换,全部交给前面的注意力层。
输入向量512 维 · 每柱代表 16 维隐藏层 2048 维灰 = 激活前 · 彩 = GELU 后输出向量512 维 · 压回原维度W₁升维 4×W₂压回
「飞快」的 2048 个隐藏神经元里,有 1,056 个的输出被 GELU 压到不足原来的一半(51.6%)。它们的输入全是负值 —— 非线性把这一半直接摁了下去,只有另一半继续往后传。
205 万本页演示规模 · 每层 FFN(512×2048×2)
12.08 亿GPT-3 规模 · 每层 FFN(12288×49152×2)
576 倍真实模型比演示大出的倍数
为什么非得先升维再降维?在 512 维空间里,"苹果"和"电脑"这类概念挤得很难分开。先把它拉到 2048 维 —— 相当于把一团打结的线摊到一张更大的桌面上 —— 高维空间才有足够余地让非线性激活把纠缠的模式切开,切完再压回来。 关键在中间那个非线性:如果没有它,W₁ 乘 W₂ 可以直接合并成一个矩阵,堆再多层也等价于一层。是 GELU 打断了这种可合并性,深度才有了意义。
它其实是一本"查得到的字典"。研究者把 W₁ 的每一行看作一个模式探测器,W₂ 里对应的那一列看作一段可写入的内容: 输入一旦跟某个模式对上,那一行就被点亮,对应内容随即加进输出。模型记住的"法国的首都是巴黎"这类事实性知识,很大一部分就存在这些矩阵里 —— 这也是它不查数据库就能答对事实题的原因。
和注意力的分工:注意力负责词与词之间横向通信(谁该看谁),FFN 负责每个词自己纵向深加工(把信息嚼碎、提特征)。 一个管交流,一个管消化,在 96 层里严格交替进行。
04 / DEEP STACK

层层堆叠:96 层在干什么

一个 Transformer 块 = 多头注意力 + 前馈网络 + 残差连接。这种块被复制堆叠几十到上百层。信号从下往上穿过,每一层都在上一层的理解之上,再抽象一层。

00输入:Token 向量 + 位置编码
01第 1 层 · 多头注意力
02第 1 层 · 前馈网络
03第 2 层 · 多头注意力
04第 2 层 · 前馈网络
05…
06第 47 层 · 多头注意力
07第 47 层 · 前馈网络
08第 48 层 · 前馈网络
09输出:取最后一个位置的向量
经验规律:浅层(前 1/3)偏向处理语法和词形(词性、搭配);中层处理句法结构(谁修饰谁、指代关系);深层(后 1/3)才开始形成抽象语义和任务意图。所以"让模型先思考再回答"(思维链)确实有效 —— 它让深层网络多跑几轮。
残差连接(图中 + 号):每块的输出 = 输入 + 变换结果 —— 就是上面那条绕开计算的 + 通道。它是能把网络堆到上百层的关键,下面单独拆开讲。

为什么能堆到 96 层:残差连接 + LayerNorm

上一节那两个计算(注意力、FFN)并不是首尾直接串起来的,中间夹着一条旁路。这条旁路叫残差连接, 它让每一层的输出变成 输入 + 变换结果,而不是替换输入。没有它,96 层根本训不起来。

x子层 · 注意力 / FFNLayerNorm输出旁路:原样通过,不做任何计算
信号传到第 75 层
10⁻⁶10⁻⁴10⁻²110²信号强度124487296层数 L —— 信号从第 1 层传到第 L 层
无残差 只有残差(无 LayerNorm) 残差 + LayerNorm
无残差
3.7×10⁻⁴
只剩原信号的 0.0370%
只有残差 · 无 LN
25.00
数值膨胀到 25.0 倍
残差 + LayerNorm
1.00
稳定在 1 附近,不涨不消
残差真正改变了什么:每层从"重写"变成"微调"。没有残差,第 40 层必须把前 39 层的成果全部重算一遍才有用 —— 中途任何一层没学好,前面的全白费。 有了残差,第 40 层只需要输出一个增量(Δ),原始信息始终原样躺在主通道里。 更要紧的是反向传播:梯度回传时那条旁路提供了一条恒等通路,梯度可以几乎无损耗地直达第 1 层,不会被 96 个矩阵连乘衰减成 0。 拖动上面的滑块,红线的下坠就是这种衰减。
那为什么必须配 LayerNorm?看曲线里那条橙色线 —— 残差是"加法",每层都往上加一点,数值尺度会随层数一路漂移膨胀。 LayerNorm 每层都把数值拉回标准尺度(均值归零、方差归一),这才把累加摁住,曲线变成绿色那条稳稳的直线。
分工很清楚:残差解决"梯度能不能传下去",LayerNorm 解决"传下去会不会失控"。两者缺一不可 —— 只加残差,深层数值会飘;只加 LayerNorm,梯度照样消失。
顺带一提:LayerNorm 放在子层之前还是之后(Pre-LN / Post-LN)差别很大,GPT-3 用的是 Pre-LN,这也是它能堆到 96 层还稳定训练的原因之一。
05 / LOGITS → SAMPLING

概率与采样:到底挑哪个词

最后一层输出是全词表每个词的"原始得分"(logits)。经过 softmax 变成概率后,就要做决定了。拖动下面的温度滑块 —— 概率分布会实时重算(真算,不是假的)。

温度 T =
1.00
0.1 死板 ←→ 2.0 放飞

上文:今天天气真 _

好66.7%
不错20.1%
热9.0%
冷3.0%
糟0.8%
啊0.3%
常规:按模型学到的真实分布采样
p(word) = exp(logit / T) / Σ exp(logit / T)

T → 0

永远选概率最高的那个(贪心)。稳定、可复现,但容易死板、复读、创造力差。

T ≈ 1

按模型学到的真实分布采样。日常对话、通用写作的默认档位。

T → 2

低概率词也被大幅抬升。更有创意,但也更容易跑偏、胡说。

另外两把剪刀:Top-k 与 Top-p

温度决定"分布多平",这两者决定"留几个候选"。

策略做法效果
Top-k只保留概率最高的 k 个(如 k=50),其余归零后重新归一化简单粗暴地砍掉长尾垃圾词,但 k 固定,不适合"有时候只有 3 个合理候选"的场景
Top-p(核采样)按概率从高到低累加,攒到 0.9(或 0.95)就停,只在这堆词里抽候选池动态伸缩 —— 模型越确定,池子越小。目前最主流
重复惩罚已出现过的词,logit 打折压制复读机倾向,代价是可能回避必要的重复词
06 / AUTOREGRESSIVE LOOP

自回归:一句话是怎么长出来的

模型没有"先想好整句再吐出来"的能力。它一次只能决定一个 token,然后把刚吐的这个词接回输入末尾,重跑一遍整个网络,再决定下一个。

人工智能正在深刻改变我们理解世界的方式。[EOS] 生成结束
step 01  输入长度 1 token  →  输出 人工智能
step 02  输入长度 2 token  →  输出 正在
step 03  输入长度 3 token  →  输出 深刻
step 04  输入长度 4 token  →  输出 改变
step 05  输入长度 5 token  →  输出 我们
step 06  输入长度 6 token  →  输出 理解
step 07  输入长度 7 token  →  输出 世界
step 08  输入长度 8 token  →  输出 的
step 09  输入长度 9 token  →  输出 方式
step 10  输入长度 10 token  →  输出 。
✓ 完成 —— 共 10 步前向计算,每步都重跑了整条网络
所以,为什么它慢?生成第 500 个 token 时,前面 499 个 token 全都要重新参与注意力计算 —— 计算量随长度平方级增长。工程上的救命稻草是 KV Cache:把历史 token 算过的 Key 和 Value 缓存下来,每步只算新词那一份,把平方复杂度压回线性。这是所有推理框架的头号优化。
另一个副产品:因为是逐词"接龙",模型无法回头修改已经吐出的内容。开头选错一个词,后面只能沿着这个错误继续圆场 —— 这是很多逻辑崩坏和"越描越错"的根源。
07 / TRAINING

训练三阶段:它怎么学会这一切

前面讲的都是"推理"(模型已训练完,在回答你)。而这些能力,是靠三个阶段一步步喂出来的。

① 预训练 Pre-training 读万卷书

拿互联网级别的海量文本(数万亿 token),做一件极简单的事:遮住下一个词,让它猜,猜错了调参数。这个动作重复几个月、几万张显卡。

目标函数预测下一个 token(交叉熵)
学到的东西语法 + 事实 + 推理模式 + 世界常识
产物一个"续写能力极强"的基座模型(Base Model)

② 监督微调 SFT 学规矩

基座模型只会"续写",你跟它说话它会继续编你的话。所以要拿几万到几十万条人类写好的(提问 → 优质回答)示范数据去教它:被问到时,该以助手的身份作答。

数据量万~十万量级(远小于预训练)
学到的东西对话格式、指令遵循、拒绝有害请求

③ 对齐 RLHF / DPO 对齐偏好

同一问题让模型生成多个回答,人类排序(A 比 B 好)。用这些偏好数据训练一个"奖励模型",再用强化学习(或更简单的 DPO 直接优化)让模型倾向于产出人类更喜欢的回答。

学到的东西有用、诚实、无害;语气、详略、安全性
副作用可能出现"谄媚"(顺着用户说)和过度拒绝
回到那个反直觉的点:模型从未被直接教过"什么是猫""什么是因果"。它只是被逼着把"下一个词猜得更准",而这些能力,是从海量文本的统计规律里自己长出来的。这也解释了为什么它能举一反三,却也会一本正经地胡说。
08 / LIMITS

幻觉与边界:为什么会一本正经地胡说

理解了前面的机制,幻觉就不再神秘 —— 它不是"故障",而是这套机制的必然副产品。

📚 搜索引擎 / 数据库

存的是事实条目。找到就返回,找不到就明说"没有结果"。
不会编造,因为它根本没有"生成"这个动作。

🧠 大语言模型

存的是语言的统计规律。它永远会输出一个"最像答案的文本",
哪怕正确答案并不存在 —— 因为它必须给一个概率分布。

VS

三大成因

① 概率本质目标是"像真的",不是"是真的"
② 数据质量训练语料里本身就有错误、过时、矛盾的信息
③ 对齐偏差RLHF 奖励"自信流畅的回答",惩罚"我不知道"

工程上怎么压制

手段思路
RAG 检索增强先从可信文档里查出相关段落,塞进上下文,让模型"照着材料答"。把闭卷考试变成开卷考试 —— 目前性价比最高的方案
工具调用算数交给计算器,查实时信息交给搜索 API。让模型只负责"决定调用什么"和"组织语言"
思维链 CoT强制先输出推理过程再给结论。让深层网络多跑几轮,显著降低推理类错误
降低温度事实类任务把 T 调到 0.1~0.3,牺牲多样性换稳定性
引用与校验要求标注出处,再用另一个流程验证引用是否真实存在
一条实用心法:把大模型当成一位阅读量极大、反应极快、但从不查证、且永远不承认自己不知道的实习生。它的产出是草稿,不是结论。事实、数字、法条、引用 —— 一律要回到一手来源核对。
总结 / CHEAT SHEET

一页速查

环节在干什么一句话类比
分词文字 → token ID 序列把整句话拆成乐高积木
向量化token ID → 高维向量给每块积木标上三维坐标
位置编码注入顺序信息给积木贴上"第几块"的标签
自注意力每个词按相关度吸收上下文开会时每个人听谁的发言
前馈网络逐位置做非线性变换每个人私下消化笔记
残差连接输出 = 输入 + 变换保证原始信息不会中途丢失
堆叠 N 层反复抽象,层层深入从认字 → 懂语法 → 悟意图
输出层全词表 → logits → 概率开出十几万个候选的赔率表
采样温度 / Top-k / Top-p 挑一个按赔率下注,未必押最热的
自回归吐出的词接回输入,循环写填空题,一次只填一格
预训练海量文本上练"猜下一个词"读了整个图书馆
SFT + RLHF学对话格式 + 对齐人类偏好上岗培训 + 价值观校准