Transformer：大模型真正的基础结构是什么？

如果继续往 GPT、Claude、Qwen、Llama 这些大语言模型的底层追，会反复碰到一个名字：Transformer。

Transformer 来自 Google 团队在 2017 年发表的论文《Attention Is All You Need》。它最初其实不是为了制造今天这种聊天机器人，而是为机器翻译设计的。但后来人们发现，这套架构非常适合扩大模型规模，于是 BERT、GPT 等模型相继出现，Transformer 也逐渐成为现代大语言模型最重要的基础架构之一。

Transformer 最值得理解的地方，不是它有多少层、多少参数，而是它解决了一个非常基础的问题：

一句话里的不同 Token，究竟应该如何互相交换信息？

Transformer 出现之前

在 Transformer 之前，NLP 中经常使用 RNN、LSTM 这类循环神经网络处理文本。

它们有一个很直观的特点：按顺序读取。

比如：

今天晚上一起吃饭

模型会先处理“今天”，再处理“晚上”，然后“一起”“吃饭”。

这跟人阅读一句话的顺序很像，但问题也很明显。

如果一段文字非常长，一个出现在开头的信息想影响后面的内容，就需要经过很长的信息传递路径。而且由于后一个位置的计算依赖前一个位置的结果，这种结构很难充分利用 GPU 做大规模并行训练。

Transformer 换了一种思路。

它不要求每个 Token 都只能从前一个 Token 获取信息，而是允许一个 Token 直接观察上下文中的其他 Token。

这里就出现了 Transformer 最核心的概念：

Attention。

Attention 到底是什么？

先看一句话：

小明把苹果给了小红，因为她很饿。

当我们看到“她”的时候，通常很容易判断它更可能指“小红”。

但计算机看到的并不是“小明”“小红”这些文字本身。

文本首先会经过 Tokenizer，被拆成一个个 Token，再转换为数字 ID，随后通过 Embedding 转换成向量。

于是 Transformer 真正处理的是一组向量。

问题变成了：

当模型处理“她”对应的向量时，它应该从前面的哪些 Token 中获取更多信息？

答案就是 Attention。

模型会计算当前 Token 与其他 Token 的相关程度。

如果“小红”和“她”的相关程度比较高，那么“小红”对应的信息就会更多地影响“她”的新表示。

所以 Attention 可以先粗略理解成：

让每个 Token 自己决定应该重点参考哪些上下文信息。

Self-Attention

Transformer 使用的核心机制叫 Self-Attention，自注意力。

这里的 Self 指的是：

同一段序列内部的 Token 互相计算 Attention。

例如：

The cat sat on the mat.

当模型处理 cat 时，它可以观察 The、sat、on、mat 等其他 Token。

处理 sat 时，同样可以重新观察整句话。

也就是说，每个 Token 都有机会从其他位置获取信息。

经过 Self-Attention 以后，cat 对应的向量已经不再单纯表达“猫”这个词，而会融合当前句子的上下文。

同样一个词出现在不同句子里，最终得到的表示也可能完全不同。

这也是现代语言模型能够理解上下文的重要基础。

Q、K、V 是什么？

理解 Self-Attention 时最容易碰到三个字母：

Q、K、V。

分别代表：

• Query
• Key
• Value

它们听起来比较抽象，但其实可以类比成搜索。

假设你正在搜索资料。

Query 是：

我现在想找什么？

Key 是：

每份资料描述的是什么？

Value 是：

这份资料真正包含的信息是什么？

Transformer 中，每一个 Token 都会产生自己的 Query、Key 和 Value。

假设某个 Token 原本的向量是 \(X\)，模型会通过三个不同的参数矩阵进行线性变换：

$ Q=XW_Q $

$ K=XW_K $

$ V=XW_V $

这里的 \(WQ\)、\(WK\)、\(W_V\) 都是模型在训练过程中学习出来的参数。

所以 Q、K、V 并不是人为提前定义好的规则。

它们都是模型自己学出来的。

Attention 是怎么算出来的？

Transformer 论文中最经典的公式就是：

$ Attention(Q,K,V) = softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V $

第一次看到可能会觉得很复杂，但拆开以后其实只有几个步骤。

先计算：

$ QK^T $

也就是让 Query 和 Key 做点积。

这个结果可以看成一种相关性分数。

如果某个 Key 和当前 Query 非常匹配，得到的分数就会比较高。

接下来除以：

$ \sqrt{d_k} $

这是一个缩放操作。

因为向量维度越来越大以后，点积结果也容易变得很大。如果直接送入 Softmax，概率分布可能变得过于极端，所以需要先做缩放。

然后经过 Softmax，把这些分数转换成一组权重。

比如当前 Token 对前面几个 Token 的注意力可能是：

| Token | Attention | | ----- | --------: | | 小明 | 0.08 | | 苹果 | 0.05 | | 给了 | 0.17 | | 小红 | 0.62 | | 因为 | 0.08 |

最后再使用这些权重，对各个 Token 的 Value 做加权求和。

结果就是当前 Token 新的向量表示。

所以整条逻辑其实就是：

先判断应该关注谁，再从这些 Token 中按不同权重获取信息。

为什么需要 Multi-Head Attention？

如果 Transformer 只计算一次 Attention，会有一个问题。

一句话里的关系远远不止一种。

模型可能需要同时关注：

语法结构、人物指代、上下文语义、时间关系、空间关系，甚至一些更难解释的抽象模式。

于是 Transformer 并不是只使用一组 Q、K、V，而是同时使用多组 Attention。

这就是：

Multi-Head Attention，多头注意力。

比如某一个 Attention Head 可能更加关注代词和人物之间的关系，另一个 Head 可能关注动词和主语之间的关系，还有一些 Head 会学习出我们很难直接用自然语言定义的模式。

每个 Head 会独立进行 Attention 计算。

最后再把多个 Head 的结果组合起来。

这样模型就可以从多个不同的角度理解同一段上下文。

需要注意的是，我们说“某个 Head 学习语法”“某个 Head 学习指代”更多是一种方便理解的描述，并不是开发者提前规定 Head 1 必须负责语法、Head 2 必须负责人物关系。

这些模式本质上仍然是模型训练出来的。

位置从哪里来？

Self-Attention 还有一个问题。

假设有两句话：

我喜欢你

和：

你喜欢我

包含的 Token 很相似，但顺序不同，意思完全不同。

然而 Attention 本身并没有天然的先后顺序概念。

因此 Transformer 必须额外告诉模型：

这个 Token 出现在什么位置。

原始 Transformer 使用 Positional Encoding，也就是位置编码，将位置信息加入 Token Embedding 中。

于是模型得到的不只是：

这是“喜欢”。

还可以知道：

这是出现在第几个位置的“喜欢”。

原论文使用正弦和余弦函数生成位置编码。

今天很多 LLM 则使用其他方案，例如 RoPE（Rotary Position Embedding）。它已经成为很多现代开源大模型中非常常见的位置编码方式。

Attention 不是 Transformer 的全部

很多人第一次学习 Transformer，很容易产生一个误解：

Transformer = Attention。

其实并不是。

Attention 是 Transformer 最核心的设计，但一个 Transformer Block 中还有另一个非常重要的部分：

Feed Forward Network，简称 FFN。

可以粗略把两者理解为：

Attention 负责 Token 之间交换信息，FFN 负责进一步处理每个 Token 自己的信息。

一个 Token 先通过 Attention 获取上下文，然后再经过 FFN 进行进一步变换。

而现代 LLM，就是把类似的 Transformer Block 堆叠几十层甚至更多。

随着层数不断增加，Token 的表示也会不断发生变化。

底层可能更多包含词汇、位置等信息，经过大量层以后，模型逐渐形成越来越复杂的上下文表示。

Residual Connection

Transformer 中还大量使用了 Residual Connection，也就是残差连接。

它的形式其实很简单。

假设某一层的输入是 \(x\)，经过某个模块得到：

$ F(x) $

残差连接并不是直接把 \(F(x)\) 交给下一层，而是：

$ x + F(x) $

也就是把原来的输入重新加回来。

这个设计最早因为 ResNet 而广为人知，在非常深的神经网络中尤其重要。

如果模型有几十层、上百层，每一层都完全重新修改输入，信息和梯度都很容易在传播过程中出现问题。

Residual Connection 给信息提供了一条更加直接的路径，使深层网络更加容易训练。

Layer Normalization

另一个经常和 Transformer 一起出现的词是：

LayerNorm。

神经网络的数据会经过很多层连续变换，数值分布很容易不断发生变化。

LayerNorm 会对隐藏状态做归一化，让训练过程更加稳定。

所以如果去阅读 Llama、Qwen 或其他 Transformer 模型的源码，经常会反复看到几类东西：

Attention、MLP / FFN、Residual、Normalization。

这些组件不断重复，就构成了大语言模型的主体。

Encoder 和 Decoder

2017 年最初的 Transformer 并不是今天 GPT 这种结构。

原始 Transformer 是一个标准的 Encoder-Decoder 架构。

Encoder 负责读取和理解输入。

Decoder 根据 Encoder 得到的信息生成输出。

比如机器翻译中，可以把中文交给 Encoder，再由 Decoder 逐步生成英文。

后来 Transformer 逐渐发展出了几个主要方向。

BERT 主要采用 Encoder-only 架构。

GPT 则采用 Decoder-only 架构。

而今天绝大多数我们熟悉的生成式大语言模型，都属于 Decoder-only Transformer。

这也是为什么理解 Decoder 会直接帮助理解 GPT 是怎么工作的。

GPT 为什么可以一直生成文字？

GPT 的训练目标其实比很多人想象得简单：

预测下一个 Token。

例如给模型：

今天天气很

模型要预测接下来最可能出现什么。

可能是：

好

于是上下文变成：

今天天气很好

模型再继续预测下一个 Token。

然后继续。

最终一句话就是这样一个 Token 一个 Token 生成出来的。

这叫做 Autoregressive Generation，自回归生成。

所以从最底层来看，你现在和一个大语言模型进行对话时，它并不是先在内部写好完整的一段回答再一次性交给你。

它是在不断执行：

根据已有上下文预测下一个 Token。

Causal Mask

但是这里马上会产生另一个问题。

假设训练样本是：

今天天气很好

模型现在正在训练预测“气”。

如果它在 Attention 中已经可以看到后面的“很好”，那就相当于考试的时候直接偷看答案。

因此 Decoder-only Transformer 会使用 Causal Mask，也叫因果掩码。

简单来说就是：

当前位置只能 Attention 到自己以及之前出现的 Token，不能看到未来。

比如第 5 个 Token 可以看到第 1～5 个 Token，但是看不到第 6、7、8 个 Token。

这样模型才真正是在学习：

根据已经出现的内容，预测后面可能出现什么。

这也是 GPT 自回归生成机制成立的基础。

Transformer 为什么取代了 RNN？

Transformer 的成功当然不只是因为 Attention 这个概念听起来很漂亮。

更关键的是它非常适合规模化。

首先是长距离的信息交互。

在传统 RNN 中，如果第一个位置的信息需要影响第一百个位置，它通常要经过一长串中间状态才能传过去。

但 Self-Attention 可以直接计算第一个 Token 和第一百个 Token 之间的关系。

信息传递路径短了很多。

另一个影响更大的优势是：

并行计算。

RNN 中后面的状态依赖前面的状态，因此很多操作必须按顺序执行。

Transformer 在训练时则可以同时计算一整段 Token 的表示，非常适合 GPU 和 TPU。

Transformer 原论文也特别强调了这种更强的并行能力。

而现代 LLM 的发展，本质上非常依赖一件事情：

Scale。

更多数据、更大模型、更多 GPU。

Transformer 恰好是一种非常适合 Scale 的架构。

这也是为什么后来模型可以一路从几亿参数增长到几十亿、几百亿甚至更大的规模。

Transformer 也不是没有代价

Transformer 最经典的问题就是 Attention 的计算开销。

标准 Self-Attention 需要计算 Token 两两之间的关系。

如果序列长度是 \(n\)，Attention Matrix 大小大约就是：

$ n \times n $

因此标准 Attention 的计算和显存开销会随着 Context Length 快速增长。

上下文从 4K 扩展到 128K，并不是简单增加一点显存那么容易。

这也是为什么现代 LLM 中出现了一系列优化技术，例如：

FlashAttention、Grouped Query Attention、Multi-Query Attention、Sliding Window Attention。

这些技术解决的问题不完全相同，但很多都和降低 Attention 的计算成本、显存成本或者 KV Cache 成本有关。

如果继续学习 LLM 底层，这些概念基本都会再次出现。

从 Transformer 到一个真正的 LLM

现在再回头看 GPT 这一类模型，整个过程就清楚很多了。

用户输入：

Transformer 是什么？

首先经过 Tokenizer，文本被转换成 Token。

Token 再经过 Embedding，从一个数字 ID 转换成神经网络可以处理的向量。

同时模型加入位置信息。

然后这些向量进入第一层 Transformer Block。

Self-Attention 让不同 Token 交换上下文信息，FFN 对隐藏状态继续加工，Residual Connection 和 Normalization 则帮助整个网络保持稳定。

然后进入下一层。

再下一层。

经过几十层 Transformer 以后，模型得到最终的隐藏状态。

最后通过输出层计算整个 Vocabulary 中不同 Token 成为“下一个 Token”的概率。

例如：

| Token | Probability | | ----------- | ----------: | | Transformer | 0.03 | | 是 | 0.56 | | 一种 | 0.21 | | 模型 | 0.07 |

模型根据概率分布选择一个 Token。

把这个 Token 加入上下文。

然后再次进行下一轮推理。

于是 Token 一个接一个出现，最后就变成了我们看到的一整段回答。

Transformer 之后还发生了什么？

理解 Transformer 并不意味着已经理解了整个 LLM。

Transformer 更像是大语言模型的“发动机结构”。

真正让今天的模型变成 ChatGPT、Claude 或 Qwen 这样的产品，还涉及很多其他技术：

Tokenizer、Pretraining、Scaling Law、Instruction Tuning、RLHF、RoPE、KV Cache、MoE、Quantization、RAG、Tool Calling……

但这些技术中的很多东西，最终仍然会回到 Transformer 上。

比如为什么 KV Cache 可以加速推理？

因为 Decoder 每次生成新 Token 时，不需要重新计算过去 Token 的全部 Key 和 Value。

为什么上下文窗口变长以后显存占用会增加？

仍然和 Attention、KV Cache 有关。

为什么一些模型开始使用 GQA？

同样是在优化 Transformer Attention 的推理成本。

所以 Transformer 并不是一个学完就可以扔掉的基础知识。

恰恰相反。

越往 LLM、RAG、Agent 和推理系统的底层走，越会重新遇到它。

推荐继续阅读

Transformer 最值得看的资料仍然是原始论文 《Attention Is All You Need》。论文并不算特别长，而且很多今天已经习以为常的设计，都可以在里面看到最初的形式。

如果觉得直接读论文比较难，Jay Alammar 的 The Illustrated Transformer 也非常值得看。它用大量可视化方式解释了 Encoder、Decoder、Self-Attention 和 Q/K/V，比单纯看公式直观很多。

理解 Transformer 以后，下一步就可以继续往下看：

Tokenizer → Embedding → Transformer → KV Cache → Prefill / Decode → Sampling

走完这一条链，基本就能从“会调用大模型 API”，进入真正理解 LLM 推理过程 的阶段。