一堂课解剖大型语言模型：从 Token 到 Transformer，看懂 ChatGPT 内部到底在干什么

前文回顾

1.草履虫也能看懂的生成式人工智能导论（1）
2.草履虫也能看懂的生成式人工智能导论（2）

先叠甲，这篇文章内容来自对于国立台湾大学李宏毅老师开设的【生成式人工智慧與機器學習導論2025】这门课。笔者认为老师讲的十分生动有趣，所以想把自己所学到的东西在这里分享给大家。

如果各位想更进一步进行学习，可以去看李宏毅老师的原视频，链接已经给你们附在下面了

课程视频网址：https://youtu.be/TigfpYPJk1s?si=0Ntc1xMS-arLSHsG
课程网站网址：https://speech.ee.ntu.edu.tw/~hylee/GenAI-ML/2025-fall.php

前言

在前两讲中，我们已经知道了一个非常重要的观念：

语言模型本质上是在做“文字接龙”。

也就是说，给模型一段输入，它会预测下一个 Token；
再把这个 Token 接回去，继续预测下一个；
如此反复，最后生成一整段回答。

那问题来了：

它到底是怎么预测下一个 Token 的？

它看到一句话以后，里面发生了什么？
为什么同一个词放在不同句子里，模型会知道它有不同意思？
为什么 Transformer 可以理解上下文？
所谓 Attention 到底在“注意”什么？
语言模型里面有没有类似“想法”的东西？

这一讲，我们要做一件很有意思的事：

不训练模型，只观察一个已经训练好的语言模型内部到底怎么运作。

换句话说，这一讲不是教你“怎么训练一只大模型”，而是带你打开模型的脑袋，看一看它从输入 Prompt 到输出下一个 Token，中间到底经历了什么。

这一讲的主要内容就是让大家明白：

大型语言模型不是一个黑箱魔法，而是一条“Token → 向量 → 多层变换 → 概率分布 → 下一个 Token”的流水线。

---

一、从一句 Prompt 开始：模型看到的不是文字，而是 Token

我们先假设输入一句话：

今天天气真好！

我们看到的是一串自然语言。

但是语言模型不直接处理“文字”。
它第一步要做的是：

把文字切成 Token。

为了方便理解，我们先假设每个中文字都是一个 Token。
真实模型不一定这样切，但这样更容易建立直觉。

于是：

今 天 天 气 真 好 ！

会被转换成一串 Token。

接下来，每个 Token 又会被转换成一个编号，比如：

今 → 540
天 → 123
天 → 123
气 → 729
真 → 938
好 → 432
！ → 0

这一步可以理解为：

文字先变成模型可以处理的数字编号。

就像你去餐厅点菜，服务员不会把“宫保鸡丁”四个字直接交给后厨，而是会在系统里输入一个菜品编号。
语言模型也是一样，它不直接吃文字，它吃 Token ID。

---

二、Tokenizer：把文字切成模型能吃的小块

负责把文字切成 Token 的工具，叫做：

Tokenizer

可以把 Tokenizer 想象成一个“切菜师傅”。

人类给它一句完整的话，它把这句话切成一小块一小块，让模型可以处理。

比如英文：

I love machine learning.

可能会被切成：

I
love
machine
learning
.

中文也会被切成 Token，例如：

我喜欢人工智能

可能会被切成：

我
喜欢
人工
智能

不同模型的 Tokenizer 可能不同，所以切出来的结果也可能不一样。

但是核心思想是一样的：

模型不是直接看句子，而是看 Token 序列。

---

三、Embedding Table：把 Token 编号变成向量

Token ID 只是一个编号。

比如：

540
123
729

这些数字本身并没有语义。

模型不能只靠数字大小判断哪个词和哪个词更接近。
所以接下来要做一件事：

把 Token ID 查表，变成一个向量。

这个表叫：

Embedding Table

可以把它理解成一本“模型专用词典”。

普通词典里，一个词对应一段解释。
Embedding Table 里，一个 Token ID 对应一个向量。

例如：

Token 540 → [1.2, -3.5, ..., 7.2]
Token 123 → [-0.8, 2.1, ..., 0.5]

于是，模型看到的句子就不再是文字，而是一排向量：

今    天    天    气    真    好    ！
↓     ↓     ↓     ↓     ↓     ↓     ↓
向量  向量  向量  向量  向量  向量  向量

可以画成这样：

输入文字：
今 天 天 气 真 好 ！

Token ID：
540 123 123 729 938 432 0

Embedding：
v1  v2  v3  v4  v5  v6  v7

这里有一个很重要的观念：

意思相近的 Token，通常会有比较接近的 Embedding。

比如“苹果”和“香蕉”可能比较接近（都是水果）；
“猫”和“狗”可能比较接近（都是宠物）；
“冷”和“热”虽然意思相反，但因为常常出现在类似语境中，也可能存在某种可学习的关系。

Embedding 就像是把语言放进了一个高维地图里。
每个 Token 都在地图上有自己的位置。

---

四、Token Embedding 和 Contextualized Embedding

这里要区分两个概念：

Token Embedding
Contextualized Embedding

1. Token Embedding

Token Embedding 是查表得到的初始向量。

同一个 Token，只要编号相同，查出来的初始向量就一样。

比如“苹果”这个 Token，不管它出现在什么句子里，一开始查出来的 Token Embedding 都是同一个。

2. Contextualized Embedding

但是问题来了：

我今天吃了一个苹果
我买了一台苹果电脑

这两个“苹果”意思一样吗？

当然不一样。

第一个是水果。
第二个是品牌。

如果只靠 Token Embedding，同一个“苹果”的向量一开始是一样的。
那模型怎么知道它在不同句子里含义不同？

答案是：

经过模型一层一层处理以后，同一个 Token 的表示会结合上下文，变成 Contextualized Embedding。

也就是说，模型一开始看到的“苹果”是同一个初始向量；
但是经过第一层、第二层、第三层……之后，它会逐渐吸收周围文字的信息。

例如：

来吃苹果

这里“苹果”会更像水果。

使用苹果电脑

这里“苹果”会更像品牌。

可以这样理解：

Token Embedding 是这个词的“身份证照片”；
Contextualized Embedding 是这个词在当前句子里的“现场状态”。

身份证照片不会变，但人在不同场景下表现出来的身份会变。

---

五、很多层叠起来，就是深度学习

语言模型不是只处理一次向量就结束了。

它会经过很多层：

Layer 1
Layer 2
Layer 3
...
Layer L

每一层都会对前一层的表示做一次变换。

可以把模型想象成一条“理解流水线”：

原始 Token
↓
Token Embedding
↓
第 1 层：初步看上下文
↓
第 2 层：组合更复杂的信息
↓
第 3 层：抽象出更高层语义
↓
...
↓
最后一层表示

越往后，表示通常越抽象。

前几层可能更多处理局部信息，比如词形、位置、简单搭配。
后面层可能逐渐处理更复杂的语义、任务、风格、意图。
这里和其他的神经网络的模型并无太大差别

这就有点像人读文章。

第一眼先看到字。
然后知道词。
再知道句子。
再知道段落意思。
最后知道作者想表达什么。

---

六、LM Head：把最后的向量变成下一个 Token 的分数

经过很多层之后，模型会得到最后一层的表示。

但是这个表示仍然是向量。

它还不是文字，也不是 Token 概率。

所以模型还需要一个东西：

LM Head

LM Head 的作用是：

把最后的表示转换成每个 Token 的分数。

假设词表里有 128000 个 Token，那么 LM Head 就会给每个 Token 一个分数：

Token 0      score = ...
Token 1      score = ...
Token 2      score = ...
...
Token 127999 score = ...

这些分数叫：

Logits

注意，这些分数还不是概率。

它们可能是任意实数，有正有负，没有归一化。

所以还要经过下一步：

Softmax

---

七、Softmax：把分数变成概率

Softmax 的作用是：

把一堆任意分数，转换成 0 到 1 之间、总和为 1 的概率分布。

比如 LM Head 输出：

北京：8.2
上海：3.1
苹果：-2.0
天气：1.7

这些只是分数。

经过 Softmax 后，可能变成：

北京：0.91
上海：0.05
天气：0.03
苹果：0.01

这样模型就知道：

下一个 Token 最有可能是“北京”。

所以从输入到输出，可以画成一张总流程图：

Prompt
  ↓
Tokenization
  ↓
Token ID
  ↓
Embedding Table
  ↓
Token Embedding
  ↓
Layer 1
  ↓
Layer 2
  ↓
...
  ↓
Layer L
  ↓
LM Head
  ↓
Logits
  ↓
Softmax
  ↓
下一个 Token 的概率分布

这就是语言模型“文字接龙”背后的基本流水线。

---

八、Temperature：模型的创意旋钮

讲语言模型生成时，还有一个很常见的参数：

Temperature

可以把它理解成模型的“创意旋钮”。

1. Temperature低

Temperature低的时候，模型更保守。

它会更倾向于选择概率最高的 Token。

也就是：

概率最高的是谁，我就选谁。

适合：

• 写严谨答案
• 写代码
• 做事实性回答
• 做格式固定的任务

2. Temperature高

Temperature高的时候，概率分布会变得更平均。

一些原本概率没那么高的 Token，也有机会被抽到。

适合：

• 写故事
• 写诗
• 做创意发想
• 生成多样化方案

可以类比成学生考试：

• 低温：稳稳答标准答案
• 高温：脑洞大开，可能有惊喜，也可能翻车

所以 Temperature 不是越高越好，也不是越低越好。

关键要看任务。

---

九、Embedding 里面真的有“意义”吗？

一个很有趣的问题是：

这些向量真的有语义吗？还是只是数学符号？

研究发现，向量空间中确实可能存在一些有意义的方向。

比如某些方向可能代表：

英文 → 中文
男性 → 女性
国家 → 首都
形容词 → 反义词

我们可以把 Embedding 空间想象成一个巨大的地图。

每个 Token 都是地图上的一个点。

意思相近的词，会住得比较近。
某些方向可能代表某种变化。

当然，真实情况比这个比喻复杂得多。

但这个比喻能帮助我们理解：

king（国王）减去queue（女王）＝female（女人）
或者写成向量的加法的形式就是king + female = queue（各位在这里请联想向量的加法，因为对于ai来讲，每个词的语义实际上就是一个高维的向量）

---

十、Representation Engineering：能不能直接动模型脑中的向量？

既然每一层都有内部表示，那么一个很自然的问题是：

如果我们直接修改某一层的表示，会发生什么？

这就引出一些研究方向：

Representation Engineering
Activation Engineering
Activation Steering

这些方法大致是在研究：

模型内部有没有某些方向，可以影响模型的行为？

比如研究者可以尝试找出某种“拒绝回答”的向量成分。

大致思路是：

1. 收集一些模型会拒绝的输入；
2. 收集一些模型不会拒绝的输入；
3. 观察某一层的内部表示；
4. 找出两类表示之间的差异；
5. 得到一个类似“拒绝方向”的向量；
6. 把这个向量加到其他输入上，看模型是否更倾向拒绝。

这听起来有点像神经科学。

如果把语言模型当成一个大脑，那这些方法就像是在问：

模型脑中有没有一个方向，代表“我要拒绝”？
有没有一个方向，代表“我同意用户”？
有没有某些神经元，负责某种语义或行为？

当然，真实情况远比一句话复杂。

但这个方向非常重要，因为它让我们不再只是看模型输入输出，而是开始研究模型内部状态。

---

十一、Logit Lens：偷看模型每一层在想什么

语言模型有很多层。

正常情况下，只有最后一层会接 LM Head，输出下一个 Token 的概率。

但有一个很有意思的方法叫：

Logit Lens

它的想法是：

既然最后一层可以接 LM Head，那中间层能不能也接一下 LM Head，看看它“目前像是想输出什么”？

比如一个翻译任务：

Français: "fleur" - 中文: "

最后模型可能输出：

花

但通过 Logit Lens，我们可以观察：

• 第 1 层还看不出结果；
• 中间层逐渐出现相关语义；
• 后面层越来越明确地指向“花”。

可以把它想象成看学生解题草稿。

学生最后交卷只写答案。
但我们想知道他中间到底怎么算的。

Logit Lens 就是在模型每一层旁边放一个小探头，看看它进行到哪一步了。

---

十二、Patchscopes：让模型自己解释内部表示

另一个有趣方法叫：

Patchscopes

它的想法更像是：

把某个内部表示拿出来，放进另一个提示模板里，让模型用自然语言解释它代表什么。

比如我们设计一个模板：

请简单介绍：[X]

然后把模型某一层内部的表示放到 [X] 的位置，让模型继续生成。

它可能会输出类似：

台湾大学老师

这有点像我们问模型：

你脑中这个向量到底是什么意思？你自己说说看。

当然，这不是完美读心术。
但它提供了一种很有趣的工具：让模型内部表示变得更可解释。

---

十三、Transformer：语言模型内部的主干结构

讲完每一层的输出后，接下来要看：

每一层内部到底怎么运作？

现代大型语言模型大多基于 Transformer 架构。

一个 Transformer Layer 大致包含两大部分：

Self-Attention Layer
Feed-Forward Layer

可以画成：

输入表示
  ↓
Self-Attention
  ↓
Feed-Forward
  ↓
输出表示

如果说 Embedding 是把字变成向量，
那 Transformer Layer 就是在不断“加工”这些向量。

---

十四、Attention 到底在注意什么？

Attention 这个词听起来很玄。

但其实可以用很直观的方式理解。

Attention Layer 做两件事：

第一，寻找输入中哪些 Token 会影响当前 Token 的意思；
第二，把这些 Token 的信息加进来。

我们看一个例子：

两 颗 青 苹 果

当模型处理“果”时，它不能只看“果”自己。

因为“果”的意思受到前面词的影响：

青 → 告诉它颜色
苹 → 告诉它这是苹果
两颗 → 告诉它数量

所以 Attention 就像是在问：

对当前这个 Token 来说，前面哪些 Token 比较重要？

---

十五、Query、Key、Value：Attention 的三件套

Attention 里面有三个经典概念：

Query
Key
Value

可以这样理解：

• Query：我现在想找什么信息？
• Key：每个 Token 提供什么索引？
• Value：每个 Token 真正携带的信息内容。

当模型处理“果”时，它会产生一个 Query。

其他 Token 会产生 Key。

模型会用 Query 和每个 Key 做点积，算出相关程度。

例如：

果 的 Query 和 青 的 Key 做点积 → 2.5
果 的 Query 和 颗 的 Key 做点积 → -0.5

分数越高，说明这个 Token 对当前 Token 越重要。
（请各位回顾向量点积的值越大，一定程度上也能反映两个向量夹角越小的这一特征，顺带一提对于大模型来讲两个token的语义越接近那那两个向量的夹角就应该越小）

---

十六、Softmax 再次登场：Attention Weight

刚刚算出来的相关分数还不是权重。

它们还要经过 Softmax，变成一组加起来等于 1 的权重：

两：0.03
颗：0.02
青：0.33
苹：0.55
果：0.07

然后模型会按照这些权重，把各个 Token 的 Value 加权加起来。

也就是说：

新的“果”表示 =
0.03 * 两的信息
+ 0.02 * 颗的信息
+ 0.33 * 青的信息
+ 0.55 * 苹的信息
+ 0.07 * 果自己的信息

于是“果”这个 Token 的表示，就不再只是“果”自己，而是混入了上下文信息。

这就是为什么 Transformer 可以理解上下文。

---

十七、Positional Embedding：模型还需要知道词的位置

Attention 有一个问题：

它本身不天然知道 Token 之间的距离。

比如：

两颗青苹果

和：

青山绿水红苹果

里面都有“青”和“苹果”，但距离和语境不同。

如果模型完全不知道位置，就很容易混乱。

所以需要加入：

Positional Embedding

也就是位置信息。

可以理解为：

Token Embedding 告诉模型“这个词是什么”；
Positional Embedding 告诉模型“这个词站在哪里”。

两者加起来，模型才知道：

谁在前，谁在后，谁离谁近。

---

十八、Multi-Head Attention：不是只有一种“注意方式”

一个词受上下文影响，可能有很多不同面向。

比如：

两颗青苹果

处理“果”时，模型可能需要注意：

• “青”：颜色
• “两颗”：数量
• “苹果”：词组结构

如果只有一个 Attention Head，就像只有一双眼睛，只能从一个角度看世界。

所以 Transformer 使用：

Multi-Head Attention

也就是多个 Attention Head。

可以这样理解：

一个 Attention Head 是一个观察角度；
Multi-Head Attention 就是让模型同时戴上很多副眼镜。

一副眼镜看颜色。
一副眼镜看数量。
一副眼镜看语法关系。
一副眼镜看语义关系。

最后再把这些角度整合起来。

---

十九、Causal Attention：生成时只能看左边

语言模型是在生成下一个 Token。

当它生成当前位置时，不能偷看未来答案。

所以在实际语言模型中，Attention 通常只看左边，也就是前面的 Token。

这叫：

Causal Attention

比如模型生成：

今天的天气很

它只能看：

今天的天气很

不能提前看到后面会接“好”。

否则训练就作弊了。

这就像考试时只能看题目，不能看标准答案。

---

二十、为什么输入不能无限长？

Attention 需要比较 Token 和 Token 之间的关系。

输入越长，关系越多，计算量越大。

如果一句话有 10 个 Token，需要考虑的关系还不多。
如果有 10000 个 Token，模型要考虑的关系就非常庞大。

所以长上下文虽然很有用，但不是免费的。

它会带来：

• 计算量变大
• 显存消耗变大
• 速度变慢
• 注意力分散

这也是为什么后来会有各种 Transformer 改良架构，试图处理更长输入。

---

二十一、Feed-Forward Layer：每个位置上的“小脑袋”

Attention 负责让 Token 之间互相交流。

那 Feed-Forward Layer 做什么？

它更像是对每个 Token 的表示单独做一次加工。

可以粗略理解成：

ReLU(Wx + b)

然后再经过另一层线性变换。

更形象一点说：

Attention：大家开会，互相交换信息
Feed-Forward：每个人回到座位，自己消化一下

Attention 让每个 Token 看见上下文。
Feed-Forward 负责把得到的信息进一步加工、变形、提取特征。

这两部分交替堆叠很多次，就构成了 Transformer 的主要计算过程。

---

二十二、一张总图总结 Transformer Layer

可以把一个 Transformer Layer 画成这样：

上一层表示
    ↓
Self-Attention
    ↓
融合上下文后的表示
    ↓
Feed-Forward
    ↓
下一层表示

很多层连起来：

Embedding
   ↓
Transformer Layer 1
   ↓
Transformer Layer 2
   ↓
Transformer Layer 3
   ↓
...
   ↓
Transformer Layer L
   ↓
LM Head
   ↓
下一个 Token 概率

所以语言模型不是“神秘地想了一下”。

它是在重复执行：

看上下文
加工表示
再看上下文
再加工表示
...
最后预测下一个 Token

---

二十三、这一讲最核心的几个问题

1. 模型到底看到什么？

不是文字，而是 Token ID。
Token ID 会通过 Embedding Table 变成向量。

2. 模型怎么知道上下文？

通过 Self-Attention。
每个 Token 会去看其他 Token 对自己有多重要。

3. 同一个词为什么不同句子意思不同？

因为经过层层处理后，Token Embedding 会变成 Contextualized Embedding。
同一个 Token 在不同上下文中会有不同表示。

4. 模型怎么输出下一个 Token？

最后一层表示经过 LM Head 得到 Logits，再经过 Softmax 得到概率分布。

5. 模型内部能不能被解释？

可以尝试。
比如 Logit Lens、Patchscopes、Representation Engineering 等方法，都是在尝试解读或操控模型内部表示。

---

二十四、结合前文

如果第一讲告诉我们：

语言模型在做文字接龙。

那么第三讲就是继续追问：

它接龙时，脑袋里面到底发生了什么？

答案是：

文字先变成 Token，
Token 变成向量，
向量经过很多层 Transformer，
每一层都通过 Attention 吸收上下文，
再通过 Feed-Forward 加工，
最后用 LM Head 和 Softmax 变成下一个 Token 的概率。

这就是大型语言模型内部运作的大致流程。

---

二十五、全文总结

最后把本篇内容压缩成几句话。

1. 语言模型不直接处理文字，而是先把文字切成 Token。

2. Token 会通过 Embedding Table 变成向量。

3. 同一个 Token 初始 Embedding 相同，但经过上下文处理后会变成不同的 Contextualized Embedding。

4. 语言模型由很多层组成，层层加工 Token 表示，这就是 Deep Learning。

5. LM Head 把最后一层表示转换成每个 Token 的 Logit。

6. Softmax 把 Logit 转成概率分布。

7. Temperature 可以控制生成的保守程度或创意程度。

8. Self-Attention 的核心是：找出哪些 Token 会影响当前 Token，并把它们的信息融合进来。

9. Multi-Head Attention 让模型从多个角度理解上下文。

10. Causal Attention 保证模型生成时只能看前文，不能偷看未来。

11. Feed-Forward Layer 负责对每个位置的表示进一步加工。

12. Logit Lens、Patchscopes、Activation Steering 等方法让我们有机会窥探模型内部表示。

---

二十六、结语

大型语言模型看起来像魔法，但如果把它拆开，其实是一套非常精密的工程流程。

它不是直接“理解一句话”，而是：

把文字变成 Token，
把 Token 变成向量，
让向量在一层层 Transformer 里吸收上下文，
最后把结果变成下一个 Token 的概率。

所以，ChatGPT 的回答并不是凭空冒出来的。

它更像是一台超级复杂的接龙机器。

只不过这台机器在接龙之前，会把每个词放进一个高维空间里转一圈，让每个词和上下文充分“开会”，最后再决定：

接下来，最应该说什么。

---