Transformer 入门¶

这篇用“跟着一条句子走一遍”的方式理解 Transformer。

先记住一句话：

Transformer 是一种让模型理解 token 之间关系的神经网络结构。

它是 ChatGPT、Claude、Gemini 等大语言模型背后的核心结构之一。

先看它解决什么问题¶

语言的难点在于：一个词的意思经常要看其他词。

例子：

小明把书放进书包，因为它太重了。

这里的“它”可能指：

小明
书
书包

人类会结合语义判断：“太重了”更可能和“书”或“书包”有关，而不是“小明”。

模型也要学会这种判断。

Transformer 的核心能力就是：

当它处理某个 token 时，可以同时参考句子里的其他 token，并判断谁更重要。

一句话如何进入模型¶

我们用这句话做例子：

小明喜欢苹果

它进入模型，大致会经过这些步骤：

文本
  ↓
切成 token
  ↓
token 变成编号
  ↓
编号变成向量
  ↓
加入位置信息
  ↓
Self-Attention 理解关系
  ↓
Feed Forward 加工信息
  ↓
多层重复
  ↓
输出结果

下面一步步拆开。

第一步：切成 Token¶

模型不能直接处理整句话。

它会先把文本切成 token。

简单理解，token 就是模型处理文本的小单位。

例子：

小明喜欢苹果

可能被切成：

["小明", "喜欢", "苹果"]

也可能切成：

["小", "明", "喜欢", "苹果"]

真实模型的切法由 tokenizer 决定，不一定等于中文分词。

再看英文：

unbelievable

可能被切成：

["un", "believ", "able"]

所以 token 不一定是一个完整单词。

为什么要切 token¶

因为模型最终做的事情是：

根据已有 token，预测下一个 token。

比如输入：

小明喜欢

模型可能预测下一个 token 是：

苹果

第二步：Token 变成编号¶

模型内部有一个词表。

每个 token 都有一个编号。

例如：

"小明" -> 1024
"喜欢" -> 315
"苹果" -> 876

所以句子：

小明 喜欢 苹果

会先变成：

[1024, 315, 876]

这些编号本身没有语义。

编号只是为了找到下一步的向量。

第三步：编号变成向量¶

模型不会直接用编号理解含义。

它会把每个编号查表，变成一个向量。

这个过程叫 embedding。

例子：

"小明" -> [0.20, -0.10, 0.73, ...]
"喜欢" -> [0.01, 0.88, -0.31, ...]
"苹果" -> [0.65, 0.12, 0.44, ...]

真实向量可能有几百或几千维。

为了好理解，我们用 3 维假装一下：

小明 = [0.2, 0.1, 0.7]
喜欢 = [0.0, 0.9, 0.2]
苹果 = [0.8, 0.3, 0.4]

向量的意义是：把文字放到一个数学空间里。

在这个空间里，语义相近的东西会更接近。

例如：

苹果   接近   香蕉、水果、梨
苹果   也可能接近   iPhone、Mac、公司
苹果   通常远离   火车、海浪、螺丝刀

模型训练越充分，这些向量越能表达语义关系。

第四步：加入位置信息¶

只知道 token 还不够。

模型还要知道顺序。

比较：

小明喜欢苹果
苹果喜欢小明

token 一样，但意思完全不同。

Transformer 本身处理 token 时很擅长并行，但并行会带来一个问题：它天然不知道谁在前、谁在后。

所以要加位置编码。

可以理解成给每个 token 贴一个位置标签：

位置 1：小明
位置 2：喜欢
位置 3：苹果

最终进入 Transformer 的不是纯 token 向量，而是：

token 向量 + 位置向量

这样模型既知道“苹果是什么”，也知道“苹果出现在第几个位置”。

第五步：Self-Attention¶

Self-Attention 是 Transformer 的核心。

它想回答：

当前 token 要理解自己，应该参考句子里的哪些 token？

继续看：

小明喜欢苹果

当模型处理“苹果”时，它可能会关注：

苹果 -> 小明：0.2
苹果 -> 喜欢：0.5
苹果 -> 苹果：0.3

这表示：

“苹果”需要知道是谁喜欢它。
“苹果”也需要知道动作是“喜欢”。
它也保留自己原本的信息。

再看一个更明显的例子：

小明把苹果放进书包，因为它很甜。

当处理“它”时，注意力可能是：

它 -> 苹果：0.7
它 -> 书包：0.2
它 -> 小明：0.1

因为“甜”更像是在描述苹果。

换一句：

小明把苹果放进书包，因为它很满。

注意力可能变成：

它 -> 书包：0.7
它 -> 苹果：0.2
它 -> 小明：0.1

因为“满”更像是在描述书包。

这就是注意力的直觉：同一个“它”，会根据后面的词改变关注对象。

Q、K、V 是什么¶

学习 Transformer 经常会遇到三个字母：

Q：Query
K：Key
V：Value

先不要被吓到。

可以用“查资料”来理解。

当模型处理一个 token 时，它会拿着一个问题去找相关信息。

Q：我现在想找什么？
K：我能提供什么线索？
V：如果你关注我，我能贡献什么内容？

例子：

小明把苹果放进书包，因为它很甜。

当处理“它”时：

“它”的 Q 可能在问：我指代谁？
“苹果”的 K 可能表示：我是一个可被描述为甜的东西。
“书包”的 K 可能表示：我是容器。
“苹果”的 V 里带着苹果的语义信息。

模型比较 Q 和每个 K，得到注意力权重。

然后用这些权重去加权求和对应的 V。

简化成一句话：

Q 和 K 决定“看谁”，V 决定“拿到什么信息”。

一个简化版注意力计算¶

假设处理“它”时，模型算出权重：

苹果：0.7
书包：0.2
小明：0.1

再假设它们的 V 是：

苹果 V = [1.0, 0.0]
书包 V = [0.0, 1.0]
小明 V = [0.5, 0.5]

那么“它”吸收上下文后的新表示大概是：

0.7 * 苹果V + 0.2 * 书包V + 0.1 * 小明V

也就是：

0.7 * [1.0, 0.0]
+ 0.2 * [0.0, 1.0]
+ 0.1 * [0.5, 0.5]
= [0.75, 0.25]

这个新向量就包含了“它更像苹果”的上下文信息。

真实模型里维度更高，计算用矩阵完成，但直觉就是这样。

Multi-Head Attention¶

一个注意力头只能从一种角度看关系。

但语言关系很多。

同一句话里可能同时有：

谁是主语。
谁是宾语。
代词指向谁。
情绪是正面还是负面。
哪些词组成一个短语。

所以 Transformer 会用多个 attention head。

每个 head 可以学一种观察角度。

例子：

小明把苹果放进书包，因为它很甜。

可能有：

Head 1：关注主谓宾关系
Head 2：关注“它”指代谁
Head 3：关注形容词“甜”描述哪个名词
Head 4：关注句子结构

这些 head 的结果会合并起来，形成更丰富的表示。

Feed Forward Network 是什么¶

Self-Attention 负责让 token 之间交换信息。

交换完以后，还需要对每个 token 自己的信息做进一步加工。

这就是 Feed Forward Network，简称 FFN。

可以这样理解：

Self-Attention：大家开会交流
Feed Forward：每个人回到座位整理自己的笔记

例子：

处理“苹果”时，Self-Attention 已经让它知道：

小明喜欢它。
它是句子的宾语。
后文可能还会描述它。

FFN 会进一步加工这个向量，让它更适合下一层继续使用。

Residual 和 Normalization¶

这两个概念第一遍不用深挖。

先记直觉：

Residual¶

Residual 是“保留原始信息”。

如果每一层都完全重写 token 表示，模型可能训练不稳定，也可能忘掉原来的信息。

所以它会把新信息和旧信息加在一起。

像这样：

新的表示 = 原来的表示 + 加工后的表示

Normalization¶

Normalization 是“把数值整理到稳定范围”。

这样训练更稳定。

可以理解成每层加工后做一次整理，避免数值太乱。

Transformer Block¶

一个 Transformer Block 可以简化成：

输入向量
  ↓
Self-Attention
  ↓
Residual + Normalization
  ↓
Feed Forward
  ↓
Residual + Normalization
  ↓
输出向量

很多个 block 堆起来，就是大模型的主体。

第一层可能学到比较浅的关系。

中间层可能学到语法和结构。

高层可能学到更抽象的语义和任务信息。

这不是绝对分工，但可以帮助理解。

GPT 如何生成文字¶

GPT 类模型的常见任务是：

根据前面的 token，预测下一个 token。

例子：

输入：

小明喜欢吃

模型会给候选 token 一个概率：

苹果：0.30
香蕉：0.20
米饭：0.15
篮球：0.01

然后模型选择一个 token 输出。

如果选了“苹果”，文本变成：

小明喜欢吃苹果

接着继续预测下一个 token：

。 ：0.40
， ：0.20
和 ：0.10

生成式模型就是这样一步一步生成文本。

为什么训练能让它变聪明¶

训练时，模型会看大量文本。

训练目标通常类似：

给定前文，猜下一个 token。

例子：

输入：小明喜欢吃
正确答案：苹果

如果模型猜错了，就调整内部参数。

看过海量例子后，它慢慢学会：

词语搭配。
语法结构。
常识关系。
推理模式。
写作风格。
代码结构。

注意：模型不是把每句话原样背下来，而是在参数里学到大量统计规律和抽象模式。

Encoder 和 Decoder¶

Transformer 最早的结构包含 Encoder 和 Decoder。

第一遍可以这样理解：

Encoder¶

Encoder 负责理解输入。

适合：

分类
检索
句子理解
文本表示

像 BERT 这类模型主要使用 Encoder 思路。

Decoder¶

Decoder 负责生成输出。

适合：

写文章
写代码
对话
续写

GPT 这类模型主要使用 Decoder 思路。

Encoder-Decoder¶

Encoder 先理解输入，Decoder 再生成输出。

适合：

翻译
摘要
输入输出结构差异明显的任务

例如机器翻译：

输入：I love apples.
输出：我喜欢苹果。

Mask 是什么¶

GPT 预测下一个 token 时，不能偷看未来。

如果训练时输入：

小明 喜欢 吃 苹果

当模型在“吃”的位置预测下一个 token 时，它不能提前看到“苹果”。

所以会用 mask 挡住未来 token。

这叫 causal mask。

可以理解成：

当前位置只能看自己和左边，不能看右边。

这让模型学会按顺序生成。

一个完整小例子¶

输入：

小明把苹果放进书包，因为它很甜。

Transformer 可能经历：

切 token：["小明", "把", "苹果", "放进", "书包", "，", "因为", "它", "很", "甜", "。"]
查 embedding：每个 token 变成向量。
加位置编码：模型知道 token 顺序。
Self-Attention：处理“它”时关注“苹果”。
Multi-Head：不同 head 同时看指代、语法、修饰关系。
FFN：加工每个 token 的上下文表示。
多层堆叠：表示越来越丰富。
输出：如果任务是理解，模型可判断“它”指苹果；如果任务是续写，模型预测后续 token。

换一句：

小明把苹果放进书包，因为它很满。

注意力可能更多指向“书包”。

这说明 Transformer 不是死记某个词，而是在上下文里判断关系。

从 token id 到 logits¶

前面说模型会预测下一个 token。

那它具体输出什么？

Transformer 最后一层不会直接输出一句中文。

它会输出一组分数，叫 logits。

假设当前输入是：

小明喜欢吃

模型可能给候选 token 打分：

苹果：8.1
香蕉：7.4
米饭：6.8
篮球：1.2

这些分数再经过采样策略，选出下一个 token。

如果选中“苹果”，上下文就变成：

小明喜欢吃苹果

然后模型继续预测下一个 token。

所以生成过程可以简化成：

token id
  ↓
Transformer
  ↓
logits
  ↓
sampling
  ↓
next token

后面 API 里的 temperature、top_p、max_tokens，影响的就是这条链路的后半段。

它如何连接到 HTTP API¶

当你调用一个 LLM HTTP API 时，表面上发的是 JSON：

{
  "messages": [
    {"role": "user", "content": "解释一下 attention"}
  ],
  "temperature": 0.3
}

但 Transformer 不认识 JSON。

服务端会先把它渲染成 prompt，再切成 token：

HTTP JSON
  ↓
chat template
  ↓
prompt text
  ↓
tokenizer
  ↓
token id
  ↓
Transformer
  ↓
logits
  ↓
sampling
  ↓
HTTP response

所以 Transformer 是底层发动机，API 服务是把外部请求翻译给发动机的系统。

和上下文窗口的关系¶

Transformer 一次只能处理一定长度的 token。

这个长度就是上下文窗口。

比如某个模型上下文窗口是 128k token，意思是一次最多能把这么多 token 放进去处理。

但能放进去，不代表都应该放进去。

上下文太多会带来问题：

成本更高。
速度更慢。
无关信息干扰注意力。
重要信息被淹没。

所以才需要上下文工程。

和上下文工程的关系¶

Transformer 负责：

在已有上下文里，计算 token 之间的关系。

上下文工程负责：

决定哪些 token 应该进入上下文。

可以这样分工：

问题	Transformer 负责	上下文工程负责
这句话里“它”指谁	通过 attention 理解关系	确保相关句子在上下文里
长任务如何不断片	在当前窗口内建模	压缩历史、保存记忆、恢复进度
工具结果怎么用	读懂工具输出	决定哪些工具结果进入上下文
提示词怎么生效	按 token 处理指令	选择何时注入哪些提示词

一句话：

Transformer 是发动机，上下文工程是驾驶和调度。

常见误区¶

误区 1：Transformer 就等于 ChatGPT¶

不是。

Transformer 是模型结构。

ChatGPT 是基于大模型、对话产品、工具系统、安全策略等组合出来的产品。

误区 2：Attention 就是人类注意力¶

不是。

它只是数学上的权重分配机制。

但用“注意力”类比有助于入门。

误区 3：上下文越长越好¶

不是。

上下文越长，越可能带来干扰、成本和延迟。

关键是高质量上下文，而不是无限塞信息。

误区 4：模型理解文本像人一样¶

不完全是。

模型通过大量数据训练出模式识别能力。

它表现得像理解，但内部是向量、矩阵、概率和参数在工作。

学习路线¶

建议按这个顺序继续学：

Tokenization：文本如何切 token。
Embedding：token 如何变向量。
Positional Encoding：模型如何知道顺序。
Self-Attention：token 如何互相看。
Q/K/V：注意力权重如何算出来。
Multi-Head Attention：为什么要多个观察角度。
Transformer Block：Attention、FFN、Residual、Normalization 如何组合。
Decoder-only GPT：如何预测下一个 token。
Context Window：为什么上下文长度有限。
Context Engineering：如何组织进入窗口的信息。

第一遍只需要抓住主线：

文本 -> token -> 向量 -> 注意力 -> 多层加工 -> 预测下一个 token

公式可以第二遍再学。

如果你接下来想理解模型为什么能在产品里跑得快、跑得便宜，可以继续读：