LLM 运行机制概论

LLM 在做什么

LLM 是一个 下一个 token 预测器

给定一段文本,也就是 token 序列,模型输出词表中每个 token 作为下一个词的概率分布。然后从中采样出一个 token,拼接到输入末尾,再重复这个过程,这就是自回归生成,你看到的所有智能表现,本质上都是这个简单机制在超大规模下的涌现结果。

其中,输入,意思就是,文本被表示成 token 序列,这里面涉及到分词的问题

模型不直接处理”字”或”词”,而是处理 token。token 是词表里的一个编号,一句话先被分词器切成若干 token,再映射成整数 ID 序列。例如,输入 “我爱LLM” 可能被切成 ["我", "爱", "LL", "M"] 四个 token,对应 ID 如 [235, 1024, 8821, 77]。模型看到的只是这串数字。

所以说,token 不等于字,也不等于词。英文常用子词,中文可能一个字一个 token 也可能多字合并,数字和代码的切分往往很反直觉。这一步直接决定了后面的成本和效果,因此,token 数就是现代 LLM 的计费单位

然后,计算,意思是,模型输出 词表中每个 token 的概率分布

模型接收这串 ID,经过嵌入层和 Transformer 各层,最后在输出层对词表中每一个 token 都算一个分数(logit),再经 softmax 归一化成概率。

输出是一个长度等于词表大小的向量,例如 [0.0001, 0.02, ..., 0.35, ...]。这个分布的含义是,给定前面这些 token,下一个 token 是词表中每个词的概率分别是多少。所有概率之和为 1。例如,输入 “今天天气真” 之后,模型可能输出:"好" 0.42、"不错" 0.18、"热" 0.09……

然后,采样,意思是,从分布里挑一个 token

因为在上面,计算中我们得到了概率分布,LLM 还要决定选哪个,这一步就是解码/采样策略,直接决定输出的风格

  • 贪婪(greedy):永远选概率最高的,确定、但可能呆板、重复。
  • 温度(temperature):调整分布的 尖锐/平缓 程度。温度低→更确定;温度高→更随机、更有创造性也更易出错。
  • Top-k / Top-p(nucleus):只在概率最高的一批 token 里采样,砍掉长尾垃圾。
  • Beam Search:保留多条候选路径,追求整体最优

然后,这就完成了吗?实际上,我们就得到了一个 Token,因此,这个过程需要不断循环,拼接、重复,这就是自回归

采样出一个 token 后,把它追加到输入序列末尾,形成新的输入,再跑一次前向传播,得到下一个 token 的分布,再采样……如此循环,直到结束

这个 用自己上一步的输出作为下一步输入 的过程,就叫 自回归生成(autoregressive generation)。

这里有个重要后果,每生成一个 token 都要重新跑一次前向传播,而且输入越来越长。如果每次都从头算注意力,代价是平方级增长。这就是为什么需要 KV-Cache,来缓存已算过的 K/V,避免重复计算,它是让自回归在工程上可行的关键优化

智能表现是这一简单机制的涌现,因为,机制本身很简单,目标函数只有一个:给定前文,最大化下一个正确 token 的概率。剩下的所有能力都必须从这个预测目标里长出来。当参数量、数据量、训练算力达到某个量级,模型开始表现出训练目标里没有显式要求的能力,这些能力不是被单独编程进去的,而是在为了预测下一个 token 而压缩海量文本规律,这个过程中副产品式地出现的。

了解Transformer架构

Transformer 是现代 LLM 的基础骨架,这个 2017 年 Google 在论文 《Attention Is All You Need》 中提出的架构,彻底改变了序列建模的范式,只不过中间隔了 7 年的工程积累,海量的预训练数据、几亿到几千亿参数的规模、RLHF/DPO 等对齐技术、KV-Cache 等推理优化。

RNN(旧范式) Transformer(新范式)
处理方式 一个字一个字串行读 所有位置并行看
任意两词的关系 要一步步传递,隔得远就衰减 直接交互,一步到位
能否大规模并行训练 难 天然适合 GPU

Transformer 把串行递推换成了全局并行注意力,这才让用海量数据加上超大参数训练在工程上变得可行,而这正是今日 LLM 如此宏大的前提。

架构大约如下

1
2
3
4
5
6
7
8
9
文本 → token 序列 → 词嵌入 + 位置编码
↓
┌─ 重复 N 层 ─────────────┐
│ ① 多头自注意力 │ ← 让 token 之间交换信息
│ ② 前馈网络 FFN │ ← 对每个位置做非线性加工
│ (每层配残差 + 归一化) │ ← 让深层网络能训得动
└─────────────────────────┘
↓
输出层 → 词表上的概率分布 → (接回上一节的"采样")
  • 词嵌入:把 token ID 变成向量,语义相近的向量也相近。
  • 位置编码:自注意力本身不认顺序,得额外告诉模型谁在前谁在后。
  • 多头自注意力:让序列里任意两个 token 直接对话,互相参考信息。多头是指同时从多个角度并行地看。
  • 因果掩码:因为要预测下一个词,必须保证只能看前文、不能偷看后文
  • 前馈网络 FFN:对每个位置的信息单独做加工,常被理解为模型的知识库
  • 残差 + 归一化:让几十层堆叠还能稳定训练。
  • 输出层:把结果投影到词表大小,得到概率分布

整个 LLM 预测下一个 token 的循环,就是靠这个结构一次次跑出来的。

为什么 Transformer 能成为主流的架构

  • 能并行:所有位置同时算,训练效率高。
  • 擅长长距离:任意两个 token 直接交互,不像 RNN 要一步步传递、越远丢失的越多。
  • 好扩展:加层、加宽就能变大,适配现代LLM的大规模堆叠的路线。

所以说,语言模型是自然语言处理的核心任务之一,而 Transformer 之所以成为现代语言模型乃至 LLM 的骨架,正是因为它同时满足了”能并行、擅长长距离、好扩展”这三个规模化训练的前提。

从输入到输出是一次前向传播的流程

前向传播是一次 LLM 完成的运行,从输入文本到输出概率分布,依次经过这些阶段:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
输入文本 "今天天气真"
│ ① 分词 Tokenization
▼
token ID 序列 [1024, 235, 77, ...]
│ ② 词嵌入 Embedding
▼
向量序列(每个 token 一个向量)
│ ③ 位置编码 Positional Encoding
▼
带位置信息的向量序列
│ ④ N 层 Transformer Block(每层:多头注意力 → FFN,各带残差+归一化)
▼
最后一层的隐藏状态(每个位置一个向量)
│ ⑤ 取最后一个位置的向量(因果 LM)
▼
│ ⑥ 输出层投影到词表 → logits
▼
│ ⑦ softmax 归一化
▼
词表上的概率分布 →

分词,就是原始文本字符串,分词器按词表把文本切成 token,再把每个 token 映射成整数 ID,就得到了一个整数序列。因为模型只认数字,不认字符。分词粒度直接决定序列长度,也就决定了成本和效果。

  • 这一步在模型外部完成,分词器是独立组件,不在神经网络前向传播里,但它是整条流水线的入口

词嵌入,这一步是上文 Token ID 到 向量 的转换,输入的 token ID 序列,被用一个可学习的嵌入矩阵(大小 = 词表大小 × 隐藏维度),每个 ID 查表,换成稠密向量,输出了一个形状为 [序列长度, 隐藏维度] 的矩阵,每个 token 对应一行向量。

  • 因为,神经网络运算的是连续向量。嵌入让语义相近的 token 在向量空间里也相近,这是模型能够具有理解的起点。
  • 隐藏维度是模型的核心宽度,后续所有计算都在这个维度上进行。

位置编码,注入顺序信息,这一步为嵌入中产生的 token 向量序列,进行顺序信息注入,给每个位置的向量加上位置信息,输出是形状不变,带位置信息的向量序列。

  • 因为,自注意力本身是无序的,它只看 token 之间的相关性,不看谁在前谁在后。“猫追狗”和”狗追猫”在纯注意力眼里一样。所以说必须显式告诉模型顺序,否则文本的乱序会造成后面的生成破坏
  • 现代 LLM 多用 RoPE(旋转位置编码),把位置编码进 Q/K 的相对关系,对长上下文更友好。细节留给位置编码章节

N 层 Transformer Block,进行核心计算,带位置信息的向量序列作为输入,依次通过 N 个结构相同的 Block。每个 Block 内:

  • 多头自注意力:每个 token 用它的 Q 去和所有 token 的 K 匹配,得到注意力权重,再对 V 加权求和,让 token 之间交换信息。因为是因果语言模型,有一个因果掩码,保证每个位置只能看到自己和前面的位置。
    • Q = Query(查询),K = Key(键),V = Value(值),合称 QKV,是自注意力机制(Self-Attention)里的三个向量。
      • Q(Query):这个 token 想找什么——它的提问。
      • K(Key):这个 token 能被怎样匹配——它的标签/索引。
      • V(Value):这个 token 实际携带的信息——它的内容。
  • 残差 + 归一化:稳定深层训练。
  • 前馈网络 FFN:对每个位置的向量独立做非线性变换,加工信息,承载知识

这样,经过 N 层后,得到每个位置一个 高度抽象 的隐藏状态向量,形状仍是 [序列长度, 隐藏维度]。

这是模型真正思考的地方,注意力负责位置间信息流动,FFN 负责逐位置加工,层层堆叠实现从浅层语法到深层语义的抽象。

然后取最后一个位置的向量,也就是输入为最后一层输出的 [序列长度, 隐藏维度]。因为任务是 预测下一个 token,只需要序列最后一个位置的隐藏状态,因为,它已经通过注意力机制看过了前面所有 token。输出为一个长度为隐藏维度的向量。

  • 这是因果模型最关键的一步,同时这也是 Decoder-only 因果语言模型的标准做法。前面每个位置的输出在训练时也有用(并行算每个位置的预测),但推理生成下一个 token 时,只用最后一个位置。
  • 自注意力要算每对 token 的关系,复杂度 O(n²)。序列越长,一次前向传播越贵。这解释了为什么长上下文昂贵。这里引出了 KV-Cache,既然每步只用最后一个位置,前面位置的 K/V 其实可以缓存复用,这就是后面推理优化

输出层投影,输入最后一个位置的隐藏向量,经过一个线性层,投影到词表大小的维度。这个线性层常与词嵌入矩阵共享权重,然后,输出一个长度等于词表大小的向量,每个向量对应一个 token 的分数(logit)

最后是 softmax,把 logits 变成 概率分布,输入 logits 向量,进行 softmax 归一化,把所有分数变成 0–1 之间、总和为 1 的概率。这样就得到了词表上的概率分布

所以说,整条链路是这样的

文本先被分词成 token ID,查嵌入表变成向量,加上位置信息,送进 N 层 Transformer Block。每一层里,自注意力让 token 互相交换信息(且只能看前文),FFN 对每个位置加工,残差和归一化保证深层稳定。走完 N 层后,取最后一个位置的隐藏向量,经输出层投影到词表、softmax 成概率分布,这就是”下一个 token 的概率分布”。然后按采样策略选一个 token,拼回输入,再跑一次同样的前向传播,如此循环,就是自回归生成。

因此,一次前向传播是生成一个 token 的完整计算。所谓生成一整段话,就是把这条流水线跑很多遍。

分词

Token 和字、词没有固定一一对应

Tokenizer 接到文本后,会把它拆成大小不等的片段。比如 你好,我是小 G。 可以得到这样一组示意结果:

  • 原文:你好,我是小 G。
  • 切分:[你好] [,] [我是] [小 G] [。]
  • 统计:原文 9 字符 → Token 数 5 个 → 压缩比约 1.8 倍

实际结果取决于目标模型的 Tokenizer,同一段文本换一个供应商或模型版本,Token 序列就可能改变。OpenAI 也提供了可直接查看切分结果的 Tokenizer 工具

上文我们知道,大模型生成回答的方式是自回归生成,每一步都依赖前面所有内容,逐步补出完整回答。

  • 你打“今天天气真”,大模型看到前面一大段文本,预测下一个最可能的 Token;
  • 生成一个 Token 后,把它追加到上下文末尾,再预测下一个;
  • 循环直到遇到结束标记或达到 Max Tokens。

所以说,Token 就是模型每一步补的文本碎片,上下文窗口就是一次调用可处理的总 Token 上限

那么 Token 很明显,不是一个字也不是一个词,它是一个更抽象的单位,Tokenizer 把文本拆成大小不等的片段,我们确定不了一个 Token 的具体长度,Token 和字、词没有固定一一对应,英文单词可能占多个 Token,中文也可能一词多 Token,或多字合成一个 Token。但是容量规划可以先用经验值估算,DeepSeek 官方数据给出的换算是 1 个英文字符约消耗 0.3 Token、1 个中文字符约消耗 0.6 Token,也就是每个 Token 约为 3.3 个英文字符或 1.7 个中文字符。“趋近 1 字 1 Token”只可能出现在部分高频词上。

Token 的切分会涉及到一些问题,如果固定按字切,词表小,但序列变长,成本高、模型要处理更长的依赖;如果固定按词切,序列短,但中文词组数量巨大,词表会爆炸;

所以现代的 Token 切分会使用 BPE、Unigram 等子词算法,这是一个折中,这些算法高频片段整体保留,低频词继续拆小。这是目前主流做法。

特殊 Token:除了文本内容对应的 Token,模型内部还会使用一些特殊标记,这些也会计入 Token 总数:

特殊 Token 用途 示例
BOS(Beginning of Sequence) 标记序列开始 <s>
EOS(End of Sequence) 标记序列结束 </s>
PAD(Padding) 批处理时填充短序列 <pad>
工具调用标记 Function Calling 边界 <tool_call/>

这些特殊 Token 通常对用户不可见,但会占用上下文窗口。

然后,多模态的内容,图片,音视频,其他内容,它们的 Token 机会会更加复杂,而且进入多模态 RAG 后,还会变的更加复杂。

Token 是什么

Token 是大语言模型处理序列信息时使用的基本离散单位,也是连接原始文本与神经网络计算过程的基础表示。

从自然语言处理(NLP)的角度来看,Token 可以理解为文本经过分词器(Tokenizer)编码后得到的离散符号。上文也说了,它不必对应一个完整的单词或汉字,而是由模型使用的词表和分词规则共同定义的基本序列元素。

而且,Token 本身并不是向量,因为此时 Token 还是一个比较抽象的文本内容,还没到把 Token 转换成模型直接进行数学运算的数值特征——也就是向量,这一步呢,它只是词表中的一个离散符号

在实际计算过程中,每个 Token 会通过词表映射为唯一的整数标识,即 Token ID,再通过嵌入层(Embedding)转换为连续的向量表示,才能参与 Transformer 内部的矩阵运算。

因此,Token、Token ID 和 Token Embedding 是三个不同层次的概念::

概念 定义 作用
Token 文本经过 Tokenizer 切分或编码后形成的离散符号 定义模型处理的基本序列单位
Token ID Token 在模型词表中的唯一整数标识 将离散符号转换成模型可索引的数字形式
Token Embedding Token ID 经过嵌入矩阵映射得到的稠密向量 将离散符号转换为神经网络能够计算的连续特征

一段文本经过 Tokenizer 处理后,可能得到以下结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
原始文本:
"今天天气很好"

↓ Tokenization

Token 序列:
["今天", "天气", "很", "好"]

↓ Vocabulary Lookup

Token ID 序列:
[1024, 2356, 781, 942]

↓ Embedding Lookup

Token Embedding:
[
[0.12, -0.35, 0.81, ...],
[0.42, 0.16, 0.27, ...],
[-0.18, 0.63, 0.14, ...],
[0.35, -0.21, 0.92, ...]
]

↓

Transformer 模型计算

在这个过程中,Token ID 只是词表中的索引,而且它不存在数值大小上的语义关系,模型使用的是通过嵌入矩阵得到的向量表示,而不是 Token ID,而且 Token Embedding 也没法等于 Token 在具体上下文中的语义表示, 同一个 Token 在嵌入层通常具有相同的初始向量,但经过注意力机制和多层 Transformer 计算后,会根据上下文形成不同的隐藏状态,这个后面细说,因为这是大语言模型能够在不同语境下处理同一个词中不同含义的重要基础。

Token 为什么是语言模型的基本单位?

因为大语言模型本质上是在离散 Token 序列上建立条件概率分布的模型。对于自回归语言模型,上面也提到了,其核心任务是根据已有的 Token 序列,预测下一个 Token 的条件概率分布。模型并不是直接预测下一个汉字、英文单词或者完整句子,而是预测词表中哪个 Token 最可能出现在当前位置。

而此时,由于模型词表是有限的,假设词表大小为 V,那么每次预测都可以表示为对 V 个候选 Token 的概率估计。模型从概率分布中选择一个 Token 后,将其追加到当前序列,再继续预测下一个 Token。这个过程不断重复,就构成了自回归文本生成。

因此,Token 在大语言模型中同时具有三种重要意义:

  • 输入表示单位:原始文本被处理为 Token 序列,作为输入。
  • 概率预测单位:模型输出的是词表中各个候选 Token 的概率分布
  • 序列长度计量单位:上下文窗口、输入输出长度以及推理资源消耗,都与 Token 数量密切相关

这就是 Token

分词带来的典型问题

前面我们已经知道,现代大语言模型通常使用 BPE、Unigram、WordPiece 等子词分词算法,将原始文本转换为 Token 序列。这种方式在词表规模和序列长度之间取得了较好的平衡,但同时也引入了一些问题。

这些问题的根源在于:Tokenizer 主要按照预先学习的词表和切分规则处理文本,而不是根据当前语境实时进行语义分词。

说白了,可能把一段挺好的话,分词器就给切碎了,它的意思改变了

因此,Token 的边界和单词边界、字符边界、语义边界,完全不是一回事

首先,不同语言的 Token 使用效率存在差异,影响主要体现在

  • 不同语言下,同样数量的信息可能占用不同长度的 Token 序列。
  • 在固定上下文窗口下,不同语言能够容纳的实际文本量可能不同。

相同含义的文本,在不同语言下可能被切分成不同数量的 Token。即使信息量相近,进入模型后的序列长度也未必相同。这是客观存在的。因为,模型词表里有没有把某些片段收为独立 Token,不同语言在训练语料的分布情况,子词分词如何拆分低频片段等等问题,都会导致不同语言之间的 Token 使用效率。这也就是为什么一开始的大模型,使用英文回复会比使用小众宝藏语言回复来的好得多。

对于 BPE、Unigram 这类子词分词的关键逻辑是,训练语料中频繁出现的文本片段,更有机会被保留为独立 Token。出现频率低的片段,通常需要进一步拆分成更小的 Token。所以,词表覆盖率高的语言,同样内容可能用更少 Token;覆盖率低的语言,可能需要更多 Token。

这也是因此,为什么,上下文窗口规定的是 Token 数量,128K Token 的窗口,能装多少中文、多少英文、多少日文,取决于各语言被切分成多少 Token。

但是吧,现代模型下,通常会针对不同语言优化词表,这个问题在现在越来越小了

然后,Token 边界与自然语言的语义边界不一致

我们上面也说了,Tokenizer 并不需要按照人类理解的词语边界进行切分,因为这种切分方式具有明显优势,即使遇到词表中不存在的完整单词,模型仍然可以利用已有的子词进行组合,从而处理大量未直接收录的词汇。

但它也带来一个问题:某个语义完整的概念,可能需要由多个 Token 共同表示。

例如一个低频的专业术语或者人物名称,被拆分为多个片段后,模型需要结合上下文及已学习的知识,识别这些片段共同对应的概念。

一个词被拆开之后,模型就无法理解它了吗?很明显没有,Transformer 的注意力机制能够建模不同 Token 之间的关系,形成上下文相关的语义表示。

但是,这还是会带来各种问题的,就离我们最近的,就是,低频术语、罕见名称等小众内容,模型回复不好,识别和生成更加不稳定。

然后,Token 不等于字符,而且数字切分不一定遵循数学结构,因此模型不擅长某些精确字符和计算操作

我们知道,模型看到的是 Token 序列,而不是直接以字符为基本单位处理的字符串。因此,一个 Token 可能对应多个字符,一个字符也可能涉及多个 Token。

以英文单词 strawberry 为例,如果要求模型回答:

strawberry 中有几个字母 r?

这个问题对于传统程序来说非常简单,只需要逐字符遍历并计数即可。

但对于语言模型来说,它需要根据已有的 Token 表示和上下文信息推断字符组成,或者在生成过程中显式地拆解、检查字符。如果一个单词作为整体 Token 或少量子词出现,模型的基础表示通常非常不直观。因此,模型在字符计数、字母位置判断、字符串反转等任务中,可能表现得不如常规字符串处理程序稳定。

对于中文、Emoji 和其他 Unicode 文本,问题可能更复杂。因为一个用户可见字符不一定等于一个 Unicode 码点,而一个 Unicode 码点在 UTF-8 中又可能由多个字节组成。

而且数字也是 Tokenizer 处理过程中比较特殊的一类数据。例如:123456789,在不同模型中,可能被切分为:

1
2
3
["123", "456", "789"]
["12", "345", "678", "9"]
["1", "23", "456", "789"]

所以说,Tokenization 并不提供数学运算语义,它本身很难将这些数字解析成具有数学意义的整数对象,所以语言模型需要另外学习数值关系与计算过程,而现在这个一般是调用工具来处理。而且对于数字的处理,一个仅依靠语言模型参数和自回归生成的系统,需要通过学习到的计算规律来生成结果,难以保证每一步中间运算都是准确的。

这也就是为什么,大模型在进行统计,计算,emoji 表情理解上等等内容,存在很严重的问题,直到今天的大模型才能很好的处理这些内容。

然后,代码与结构化数据对 Token 切分更加敏感

Tokenization 对编程语言、JSON、XML 和 SQL 等结构化文本,这种内容

例如:

1
private final String userName;

这里包含 Java 关键字、标识符、空格以及分隔符。Tokenizer 可能将这些内容拆成多个 Token,而不会天然理解 Java 的词法结构。这是很要命的。

虽然,LLM 可以通过训练学习代码结构,并生成符合语法的程序,这也就是为什么早期的大模型即使能够生成看起来合理的代码,输出通常很难符合目标语言的规则和目的的原因。

这也是结构化输出约束(Structured Output)、JSON Schema 校验、语法约束解码(Constrained Decoding)等技术的重要应用场景。这些机制并不是改变 Token 的定义,而是在 Token 生成过程中施加额外约束,或者在生成完成后进行校验,以提高输出的结构正确性。

类似地,长文本分块可能破坏完整的语义上下文

在 RAG、文档分析和长文本处理场景中,Tokenization 还会影响文本切分策略,为了把一份很长的文档送入向量模型或者大语言模型,通常需要按照一定长度将其拆分成多个 Chunk。

假设每个 Chunk 最多允许包含 500 个 Token,如果只是简单按照 Token 数量进行截断,不难想象语义拆分会有多碎,因此,在实际 RAG 系统中,通常需要综合使用各种切分策略,

Token 和上下文为什么决定成本与效果?

模型标注的 128K、200K 或 1M 等上下文窗口,指一次调用能够容纳的 Token 上限。

而且,多数供应商会分别计算输入、缓存输入和输出 Token,推理模型还可能单列 reasoning tokens。

窗口越大,单次可传入的文档和对话历史越多,但这部分容量还要分给系统提示词、工具定义和模型输出。而且大多数模型将输入与输出合并计算。这些内容共同构成模型的上下文。标称窗口减掉这些内容,剩下的才是业务数据实际可用的空间,也就是你的输出空间。

上下文窗口(Context Window)= LLM 的「工作记忆」

Token 数量决定模型需要处理多少信息,上下文窗口决定这些信息能否被同时纳入模型计算,而模型对上下文的利用能力则进一步影响最终回答质量。那么,上下文越长越好?肯定不少,长上下文背后是存在计算约束的

模型处理的 Token 越多,通常意味着需要执行更多计算,并占用更多显存资源。对于采用 Decoder-only Transformer 架构的自回归语言模型,一次文本生成通常可以分为两个阶段

  • Prefill(预填充阶段):模型对已有的输入 Token 序列进行计算,建立上下文表示,并生成后续推理需要的 KV-Cache。
  • Decode(解码阶段):模型基于已有上下文,每次生成一个新的 Token,并逐步更新 KV-Cache。

自注意力机制需要计算序列中不同 Token 之间的关联。输入序列越长,需要处理的注意力关系就越多。这意味着,上下文越长,单个输出 Token 所需处理的历史信息通常也越多。

而且,上下文窗口大,并不等于模型能够同等准确地利用窗口内的全部信息。上下文容量并不等于上下文利用能力。在长上下文研究中,一个典型现象是 Lost in the Middle,即模型对位于长文本中间位置的信息,可能不如对开头或末尾信息的利用效果稳定。长上下文处理不仅是一个容量问题,也是信息检索、注意力分配和上下文理解的问题。

之前非常火爆的上下文工程(Context Engineering),核心内容不是尽可能填满上下文窗口,而是让有限的 Token 承载更高价值的信息,通常需要通过检索过滤、状态摘要、重排序、外部记忆、按需加载、上下文压缩等等步骤。这些都是很有必要的。

将需要长期保存的信息放入外部存储,将当前任务真正需要的信息放入模型上下文

对于商业 LLM API,Token 通常也是主要计费单位。通常情况下,输出 Token 往往比输入 Token 更贵

因为,输入阶段可以利用 GPU 对序列进行并行计算,而输出阶段具有自回归依赖,需要依次生成 Token,通常更难充分利用大规模并行计算能力。

Token 和上下文窗口分别从两个层面影响大语言模型:

  • 在资源层面,Token 数量会影响注意力计算量、KV-Cache 占用、推理延迟、服务并发能力以及 API 调用成本。
  • 在能力层面,上下文窗口决定模型能够同时处理的信息范围,但实际回答效果还取决于上下文的相关性、信息密度以及模型的长上下文利用能力。

所以说,从工程角度来看,Token 管理主要围绕三个目标展开:控制成本、降低延迟以及提高上下文信息质量。

模型内部机制

词嵌入与位置编码

在完成 Tokenization 后,模型已经得到一组 Token ID,我们都知道此时这些整数只是词表中的索引,本身并不包含可以直接用于神经网络计算的语义特征,需要进一步转换为向量。

因此,在真正进入 Transformer Block 那一堆堆循环之前,还需要解决两个问题:

  1. 词嵌入(Token Embedding):如何将离散的 Token 转换为能够参与神经网络计算的连续向量,并让模型从中学习语言的语义特征?
  2. 位置编码(Positional Encoding):如何让模型知道 Token 在序列中的位置,以及不同 Token 之间的先后顺序和距离关系?

它们是 Transformer 建立语言表示的基础

词嵌入:如何让 Token 具有可学习的语义表示?

为什么通过嵌入矩阵查到的一个向量,就能用来表示一个词的语义?这些向量中的数值又是从哪里来的?

首先,Embedding Layer 这个嵌入层本质上是一个可训练的参数矩阵,是模型参数的一部分。

设:

  • 词表大小为 V(vocabulary size)
  • 隐藏维度为 d(hidden dimension)

则嵌入矩阵为: \[ E \in \mathbb{R}^{V \times d} \] 也就是说,

  • 矩阵有 V 行、d 列;
  • 每一行对应一个 Token 的初始向量表示;
  • 第 i 个 Token 的 Embedding 嵌入向量就是 E 的第 i 行。

用公式表示 取第 ii 个 Token 的向量 :(e_i = E_{i,:} ^{d})

例如,假设某个简化模型的隐藏维度只有 4,那么不同 Token 的 Embedding 可能是:

1
2
3
4
5
Token       Embedding
------------------------------------
"猫" [0.21, 0.75, -0.32, 0.48]
"狗" [0.19, 0.71, -0.28, 0.52]
"汽车" [-0.63, 0.12, 0.84, -0.16]

这里的数值只是例子,但可以发现,猫 和 狗 的向量比较接近,而 汽车 的向量与它们存在较大差异。

所以说,模型可以在连续的向量空间中学习词汇之间的关系和语义联系,每个 Token 之间不是孤立的符号。

这些向量并不是人工编写的,不是 Tokenizer 根据词义生成的,而是在模型训练过程中逐渐学习出来的。

在模型预训练时,Embedding 矩阵通常会被初始化,然后与 Transformer 的其他参数一起,通过反向传播和梯度优化不断更新。

所以说,模型为了更准确地预测下一个 Token,需要学习不同词汇在大量上下文中的使用规律。

例如还是上文的例子,在大量类似语料中,猫 和 狗 经常出现在具有相似语法结构或语义关系的上下文里,用法类似,而 汽车 的使用环境有所不同。模型可以逐渐学习这些统计规律,并将它们反映到向量表示中。

当然,Embedding 的真实结构远比上述四维向量复杂。现代模型通常使用数千维的隐藏表示,而且向量的某一个维度一般不能单独解释。Embedding 的关键不在于单个向量数值有什么含义,而在于整个向量空间中能够学习并表示什么样的特征和关系

那么,为什么有了 Embedding 嵌入向量,还需要 Transformer 模型?

很明显,词嵌入有局限,Embedding 提供的是 Token 的初始表示,而不是它在当前语境下的完整含义。

例如经典案例:

1
2
"他在银行办理贷款。"
"他坐在河岸边休息。"

这里的“银行”和“河岸”本身不同,但如果考虑英文 bank,它既可以表示金融机构,也可以表示河岸。虽然银行也可以休息

这个例子要表达的含义是,对于同一个 Token ID,普通 Embedding 查表得到的初始向量通常是相同的。但它在不同上下文中所表达的意义却可能完全不同。所以,Embedding 本身无法独立完成完整的上下文理解。进入 Transformer 后,每个 Token 的向量会通过自注意力机制与其他 Token 进行信息交互,再经过前馈网络等结构处理,逐渐形成具有上下文信息的隐藏状态(Hidden State)。

因此

  • 词嵌入:同一个 Token 通常具有相同的初始向量,是模型学习得到的基础特征表示。
  • 上下文表示:经过 Transformer 计算后,Token 的隐藏状态融合了上下文信息,因此同一个 Token 在不同语境下可以具有不同的表示。

词嵌入是起点,而后续的注意力机制和深层网络,才是模型形成复杂上下文表示的关键。

位置编码:为什么 Transformer 必须知道 Token 的顺序?

词嵌入解决了 Token 如何表示的问题,但还缺少一个重要信息:序列顺序。

例如:

1
2
"猫追狗"
"狗追猫"

两句话包含相同的 Token,但顺序不同,语义也完全不同。如果只考虑 Token Embedding,那么相同 Token 不管出现在什么位置,查表得到的初始向量都是一样的。

普通自注意力计算是没有显式位置信息的,主要根据 Token 的向量内容建立关联,并不能像 RNN 那样通过顺序递推过程自然保留位置的信息,因此,Transformer 需要一种机制,将 Token 的位置信息引入计算。这就是位置编码(Positional Encoding)。

位置编码需要帮助模型识别两类重要关系:

  • 绝对位置(Absolute Position):一个 Token 位于序列中的哪个位置,例如第 1、5、10 个位置。
  • 相对位置(Relative Position):两个 Token 之间相隔多远、谁位于前面、谁位于后面。

对于语言理解来说,相对位置尤其重要。例如,在一句很长的文本中,某个代词和它所指代的名词之间可能相隔多个 Token。模型需要结合内容和位置关系,才能建立正确的关联。

虽然提的有点早,但是需要注意,位置编码与因果掩码(Causal Mask)并不是同一个概念。

位置编码负责提供顺序和距离信息,而因果掩码负责限制当前位置能够访问哪些 Token。后面讲解自注意力机制时再详细讨论。

Transformer 的位置编码经历了不同的技术发展路线,比较有代表性的包括可学习位置编码、正弦余弦位置编码,以及现代 LLM 广泛使用的旋转位置编码 RoPE。

  • 可学习位置编码(Learned Positional Embedding)

    它的实现思路和 Token Embedding 比较类似。模型为不同的位置维护一组可训练的向量参数,例如:

    1
    2
    3
    Position 0 → [0.12, 0.35, ...]
    Position 1 → [0.42, 0.18, ...]
    Position 2 → [0.16, 0.73, ...]

    对于位于第 (i) 个位置的 Token,将其 Token Embedding 与位置向量相加:\(h_i=x_i+p_i\),其中:

    • \(x_i\) 是 Token Embedding。
    • \(p_i\) 是对应位置的位置向量。
    • \(h_i\) 是融合位置信息后的初始表示。

    这种方式实现简单,位置向量可以通过训练学习,但如果采用固定大小的位置嵌入表,就需要考虑超出已定义位置范围时如何处理。

  • 正弦余弦位置编码(Sinusoidal Positional Encoding)

    这是 2017 年原始 Transformer 论文《Attention Is All You Need》中采用的方法。

    它不需要为每个位置单独学习一个向量,而是使用不同频率的正弦和余弦函数,计算位置对应的编码。

    其经典形式为: \[ PE(pos,2i)=\sin\left(\frac{pos}{10000^{2i/d}}\right) \\ PE(pos,2i+1)=\cos\left(\frac{pos}{10000^{2i/d}}\right) \] 其中 \(pos\) 表示序列位置,\(i\) 表示向量中的维度索引,\(d\) 表示模型隐藏维度。

    抛开公式来说,大概就是,每个位置都会根据不同频率的周期函数生成一组独特的数值,使模型能够利用这些变化识别位置及位置之间的关系。

    这种方式的特点是位置编码由数学函数计算得到,不需要单独训练每个位置的参数。

  • 旋转位置编码(Rotary Position Embedding,RoPE)

    RoPE 是现代 Decoder-only LLM 中非常常见的位置编码方案。

    它与前面两种方式最大的区别是:RoPE 通常不是直接将位置向量加到 Token Embedding 上,而是在注意力计算过程中,对 Query 和 Key 向量进行与位置相关的旋转变换。这样可以让模型在计算不同 Token 的注意力分数时,自然包含它们之间的相对位置关系。位置信息在算注意力分数那一步才体现。

RoPE

RoPE 的基本思路,就是让不同位置的向量按照不同角度进行旋转。

注意力里每个 Token 会产生三个向量:

  • Query(Q):我在找什么
  • Key(K):我能提供什么
  • Value(V):我实际的内容

注意力分数靠 Q 和 K 的点积算出来: 分数 = Q · K

RoPE 的做法是:根据 Token 的位置,把 Q 和 K 向量旋转一个角度,再算点积。位置越靠后,旋转角度越大。

于是,Q 转一个角度,K 转一个角度,点积结果自然带上了 两者位置差 的信息,两个经过不同角度旋转的向量,在计算点积时,其位置关系能够体现为旋转角度之差。

为什么这样就能包含相对位置呢?

因为,两个向量都旋转后,点积只取决于它们旋转角度的差

用公式就是,\(\langle R(\theta_i) q_i,\ R(\theta_j) k_j \rangle\),其中 \(R(\theta)\) 是旋转矩阵,\(\theta_i\)和\(\theta_j\) 由位置决定。

旋转有个性质:\(R(\theta_i)^{\top} R(\theta_j) = R(\theta_j - \theta_i)\)

所以点积变成:\(q_i^{\top} R(\theta_j - \theta_i) k_j\)

看出来了吗?结果只依赖 \(\theta_i-\theta_j\),也就是两个 Token 的位置差,而不是各自的绝对位置。这就自然包含相对位置关系了

实际模型中的 Query Key Value 并不是二维向量,因此 RoPE 会将参与旋转的维度按二维子空间分组,并使用不同频率进行旋转。最后,RoPE 使模型能够在不同维度上表达不同尺度的位置变化。

其主要优势在于:

  • 自然引入相对位置信息:注意力分数能够体现 Token 之间的位置差。
  • 不需要独立学习每个位置的向量:旋转角度由位置和预设频率计算得到。
  • 适合自回归推理:能够结合位置索引和 KV-Cache 处理不断增长的序列。
  • 具有较好的长上下文扩展基础:可以结合位置插值、频率缩放等方法扩展模型支持的上下文长度。

词嵌入和位置编码在 Transformer 中如何配合

对于采用传统加性位置编码的 Transformer,输入处理过程可以表示为::

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Token ID 序列
│
▼
Token Embedding
│
├───────────────┐
│ │
▼ ▼
Token 向量 位置编码向量
│ │
└───────┬───────┘
▼
向量相加
│
▼
Transformer Block

而对于使用 RoPE 的现代 Decoder-only Transformer,更典型的流程是:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Token ID 序列
│
▼
Token Embedding
│
▼
初始隐藏状态
│
▼
Transformer Block
│
├── Q 投影 ── RoPE ──┐
│ │
├── K 投影 ── RoPE ──┤
│ ▼
│ Attention
└── V 投影 ──────────┘
│
▼
后续网络计算

这里的 Q、K、V 是通过可学习的线性投影从当前隐藏状态中得到的,后续会在自注意力章节详细解释。

因此,在采用 RoPE 的模型中,位置编码并不是简单地在输入端执行一次向量相加,而是通常在每一层注意力计算中作用于 Q 和 K。

需要特别注意的是,Embedding 与位置编码共同影响模型的表示,但它们并不能直接完成上下文理解,还少了不少内容呢

Embedding 嵌入向量提供 Token 的初始内容特征,位置编码使模型能够利用序列中的位置和距离信息,而 Transformer 的注意力机制则在这些基础上建立 Token 之间的上下文关系。

  • 词嵌入(Embedding) 将离散符号转换为可训练的连续向量,使模型能够在向量空间中学习语言的统计规律和语义特征,但初始 Embedding 本身不具备完整的上下文理解能力。
  • 位置编码(Positional Encoding) 将序列的顺序和距离关系引入模型计算,使 Transformer 能够区分相同 Token 在不同位置所形成的不同语言结构。

理解了这两个机制,剩下的内容就可以深入研究,包括 Transformer 究竟如何通过 Q、K、V 和注意力权重,让不同 Token 之间交换信息,并逐步形成上下文相关的语义表示的。

自注意力机制

自注意力为什么能够形成上下文表示

自注意力机制(Self-Attention)是 Transformer 最核心的计算机制之一,其主要作用是:让序列中的每个 Token 根据当前上下文,动态地从其他 Token 中提取相关信息,并更新自身的向量表示。

前面我们讲过,词嵌入向量只能提供 Token 的初始表示,而无法直接确定它在某个具体上下文中的含义。那么,自注意力机制就是解决这个问题的关键。

例如:

1
二狗  追逐  苺氷

对于人类来说,很容易理解“二狗”是动作的发出者,“苺氷”是动作的对象。

但对于模型而言,这些 Token 最初变成了各自独立的向量。但是要理解它们之间的关系,就需要让不同位置的信息进行交互。只有向量是说明不了更多内容的

自注意力机制能够让“追逐”这个位置,结合“苺氷”等相关信息,也能够让“苺氷”这个位置,参考前面出现的“二狗”和“追逐”,从而逐渐形成包含上下文关系的表示。而这里的实现并不是直接将几个 Token 的向量相加,是通过一套可学习的计算过程,决定不同 Token 的信息应该如何参与当前位置的表示更新。

然后,我们从整个模型的角度理解注意力机制,自注意力的计算过程,其实就是一套可以通过训练学习的信息匹配与聚合机制:

  • Q、K、V 的投影矩阵是可训练参数。
  • 注意力分数决定不同位置之间的匹配关系。
  • Softmax 将匹配分数转换为信息聚合权重。
  • Value 加权求和形成融合上下文信息的新向量。

这都是我们下面要说的内容

要记住,模型并不是通过人工定义的规则,事先知道哪些 Token 应该互相关注,而是在训练过程中,通过不断优化预测目标,逐渐学习哪些特征关系有利于完成语言建模任务。不过,单次注意力计算得到的只是一个聚合后的特征向量。实际 Transformer 还会结合输出投影、残差连接、归一化以及前馈网络等结构,对这些信息进行进一步处理,这都是更下面再说的了,此时,当多个 Transformer Block 不断堆叠时,后续层接收到的已经不再是原始 Embedding,而是前面各层处理后的隐藏状态。因此,同一个 Token 可以在不同层中不断融合、加工上下文信息,逐渐形成更加复杂的特征表示。

Q、K、V 是怎样产生的?

前面在介绍 RoPE 时,我们已经简单了解了 Q、K、V 分别代表什么,在这里说说它们是如何得到的。首先,Q、K、V 并不是原始 Token 向量的三个固定部分,也不是通过人工规则划分出来的,它们是对同一个输入 X 做线性投影得到的:

假设当前 Transformer 层接收到的隐藏状态矩阵为: \[ X\in\mathbb{R}^{n\times d_{\mathrm{model}}} \] 其中,\(n\) 表示序列长度(有多少个 Token),\(d_{\mathrm{model}}\) 表示隐藏维度每个 Token 的向量有多少维)。

自注意力机制首先通过三个不同的可学习权重矩阵,对输入进行线性投影

  • \(Q=XW_Q\),\(K=XW_K\),\(V=XW_V\)

其中,\(W_Q\)、\(W_K\)、\(W_V\) 是在模型训练过程中学习得到的参数。

对于单个注意力头,可以将它们的形状表示为 \[ W_Q,W_K\in\mathbb{R}^{d_{\mathrm{model}}\times d_k} \\ W_V\in\mathbb{R}^{d_{\mathrm{model}}\times d_v} \] 所以投影后:(Q ^{n d_k}),(K ^{n d_k}),(V ^{n d_v})

因此得到:

  • Query(Q):当前位置希望从上下文中获取什么信息。也就是,我在找什么
  • Key(K):当前位置可以通过哪些特征与其他位置进行匹配。也就是,我有什么内容能被匹配
  • Value(V):当前位置能够向其他位置提供哪些特征信息。也就是,我实际能提供什么内容

设计三组不同的向量的原因是,寻找信息和提供信息,本来就是两个不同的计算任务。

在数据库中,我们可能通过某个索引字段查找记录,但真正需要读取的内容并不一定就是索引字段本身。

自注意力机制采用了类似的思路,Q 和 K 决定从哪里获取信息,V 决定获取什么信息。Q 和 K 负责匹配,算注意力分数,决定每个位置该关注谁,V 负责内容传递,被关注的位置把什么信息传过来。

用公式表达注意力: \[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^{\top}}{\sqrt{d_k}}\right) V \] 通过这种分离,模型能够学习更加灵活的 Token 关系,而不必使用同一套特征同时完成匹配和内容传递。分开后,怎么匹配 和 传递什么内容,被分离了,那么,三组参数各自优化,表达更灵活。

注意力分数

注意力分数决定模型如何判断应该关注哪些 Token

因此,得到 Q、K、V 后,第一步是计算注意力分数

对于序列中第 (i) 个 Token,使用它的 Query 与其他 Token 的 Key 计算点积: \[ s_{ij}=q_i\cdot k_j \] 其中:

  • (q_i):第 (i) 个 Token 的 Query。
  • (k_j):第 (j) 个 Token 的 Key。
  • (s_{ij}):位置 (i) 对位置 (j) 的原始匹配分数。

点积在这里可以理解为一种向量匹配操作,因为当 Query 与 Key 在向量空间中具有较强的匹配关系时,计算结果可能更大。

例如,对于:

1
2
3
位置 1:小猫
位置 2:追逐
位置 3:小球

假设我们正在计算位置 3,也就是“小球”的新表示。

模型会使用“小球”对应的 Query,分别与各个位置的 Key 进行计算:

1
2
3
4
5
6
7
Query("小球")
│
├── Key("小猫") → Score 1
│
├── Key("追逐") → Score 2
│
└── Key("小球") → Score 3

这样便得到三个分数,用来描述当前 Query 与不同 Key 的匹配程度。

首先,注意力分数不是人为定义的语义相似度,也不是简单判断两个词的意思是否接近。因为 Q、K 来自模型训练得到的投影参数,所以说,这个特征的匹配是站在模型视角的,是模型通过\(W_Q\)、\(W_K\)学出来的一套匹配信号,它反映的是模型为降低预测损失而学到的关系,可能对应句法、指代、共现、位置等多种模式,但不保证可解释为人类可命名的语义关系,不同注意力头可以学到不同类型的匹配关系,具有不同形式。

也就是说,注意力分数是模型训练学出来的匹配信号,不是人定义的语义相似度;不同头可学到不同匹配模式,但不保证可解释。

其次,注意力关系具有方向性,这个就很好理解了

位置 (i) 对位置 (j) 的注意力分数,与位置 (j) 对位置 (i) 的注意力分数不一定相同。

因为两次计算使用的 Query 和 Key 是不同的,这使模型能够学习非对称的上下文关系,而不只是判断两个 Token 是否相似。

注意力权重

实际 Transformer 不会直接使用普通点积,而是采用缩放点积注意力。 \[ s_{ij}=\frac{q_i\cdot k_j}{\sqrt{d_k}} \]

  • 这里的 (d_k) 是 Query 和 Key 的向量维度。

那么,为什么要对注意力分数进行缩放呢?也就是说,为什么要除以 ()?

这个其实就没那么复杂了,因为随着向量维度增加,点积结果的数值幅度可能越来越大,如果未经缩放就直接送入 Softmax,可能使输出的概率分布过度集中。

例如:

1
2
3
4
5
Softmax([2, 1, 0])
≈ [0.665, 0.245, 0.090]

Softmax([20, 10, 0])
≈ [0.99995, 0.00005, 0.00000]

可以看到,当分数之间的差距变得很大时,Softmax 的输出会越来越接近极端分布。这可能导致梯度变小,影响模型训练的稳定性。因此,Transformer 使用 () 对点积进行缩放,控制注意力分数的数值尺度。

从统计学来说,如果 Q、K 的各维分量具有相近的方差并满足一定的独立性假设,点积的方差会随着维度 (d_k) 增大。除以 (),能够使分数保持在更合适的尺度。

经过缩放后,我们得到的是一组原始注意力分数,但它们还不能直接作为各个 Token 的信息贡献比例

因此,需要通过 Softmax 归一化,将这些分数转换为注意力权重

对于当前位置 (i),其对位置 (j) 的注意力权重 \(\alpha_{ij}\) 为: \[ \alpha_{ij} = \frac{\exp(s_{ij})} {\sum_{t}\exp(s_{it})} \] 权重越大,该位置的 Value 在输出里占的比重越大。这样,每个权重都位于 0 到 1 之间,并且当前位置能够关注的所有 Token 的注意力权重之和为 1。

例如,假设“苺氷”对三个位置计算出的注意力权重如下:

Token 注意力权重
二狗 0.40
追逐 0.35
苺氷 0.25

所以“苺氷”的新表示是: \[ o_{\text{苺氷}} = 0.40\, v_{\text{二狗}} + 0.35\, v_{\text{追逐}} + 0.25\, v_{\text{苺氷}} \] 从这个结果可以看到,“苺氷”在更新自身表示时,可以更多地参考“二狗”和“追逐”所提供的特征信息。

注意力机制中的 Softmax,是对序列中可访问的 Token 位置进行归一化,而不是对整个词表进行概率预测。

我们前面介绍模型输出层时,也提到过 Softmax。但二者的作用完全不同:

  • 注意力中的 Softmax:决定当前位置如何分配对其他位置的注意力权重。
  • 模型输出层中的 Softmax:将词表上的 Logits 转换为下一个 Token 的概率分布。这个后面会细说

因此,注意力权重并不表示某个 Token 是正确答案的概率,而是当前注意力计算中的信息聚合系数。

Value 加权求和

到这里,我们已经知道了如何计算各个 Token 的注意力权重。

接下来才是自注意力机制真正完成信息聚合的地方。

对于当前位置 \(i\),使用刚刚得到的注意力权重,对各个位置的 Value 进行加权求和: \[ z_i=\sum_j\alpha_{ij}v_j \] 其中:

  • (_{ij}):当前位置 (i) 对位置 (j) 的注意力权重。
  • (v_j):位置 (j) 对应的 Value 向量。
  • (z_i):当前位置经过注意力聚合后的输出向量

例如,我们假设三个位置的 Value 为:

1
2
3
V("二狗") = [1, 0]
V("追逐") = [0, 2]
V("苺氷") = [1, 1]

而“苺氷”对它们的注意力权重分别为:

1
[0.40, 0.35, 0.25]

那么“苺氷”的注意力输出就是:\(z_3 = 0.40[1,0]+0.35[0,2]+0.25[1,1] = [0.65,0.95]\)

这个新向量不再只是“苺氷”自身的特征,而是融合了其他位置 Value 信息的计算结果。这就是自注意力机制最核心的能力:让一个 Token 的表示,不再只依赖自身,而是根据当前上下文动态地融合其他 Token 的特征。

而且,这种注意力权重并不是固定的。

同一个 Token 出现在不同句子中时,由于输入上下文不同,其 Query、Key 和对应的注意力权重也可能发生变化。

例如,bank 在金融语境和河流语境中,可以通过不同的注意力模式聚合不同的上下文信息,进一步形成具有不同语义特征的隐藏状态。

所以说,Transformer 能够处理一词多义、语法关联、指代关系等语言现象,很大程度上依赖这种动态的上下文信息交互机制。

自注意力过程

上面的过程是从单个 Token 的角度理解的,但在实际 Transformer 中,GPU 并不是依次遍历每个 Token,再逐个计算注意力。

对于整个序列,可以使用矩阵运算一次性计算所有位置的注意力分数和聚合结果。

首先,计算 Q、K、V: \[ Q=XW_Q,\quad K=XW_K,\quad V=XW_V \] 然后计算注意力分数矩阵: \[ S=\frac{QK^T}{\sqrt{d_k}} \] 假设序列长度为 (n),那么: \[ QK^T\in\mathbb{R}^{n\times n} \] 也就是说,对于长度为 n 的序列,标准全注意力会形成一个 n×n 的注意力分数矩阵。

这对于线代好的人很好理解,无非就是把一个个计算转换为一个多维矩阵上的操作

对于我们上面的例子,这个矩阵可以直观理解为:

1
2
3
4
5
6
7
                   Key
二狗 追逐 苺氷
┌────────────────────┐
Query 二狗│ s11 s12 s13 │
追逐│ s21 s22 s23 │
苺氷│ s31 s32 s33 │
└────────────────────┘

矩阵的每一行,表示某个 Query 对不同 Key 的匹配分数。

随后,对每一行执行 Softmax,得到注意力权重矩阵: \[ A=\operatorname{softmax}(S) \] 最后,通过矩阵乘法完成 Value 的加权聚合: \[ Z=AV \] 将这些步骤合并,就得到 Transformer 中最经典的注意力计算公式: \[ \operatorname{softmax} \left( \frac{QK^T}{\sqrt{d_k}} \right)V \] 这就是 Scaled Dot-Product Attention 的完整数学表达式。也就是 Scaled 自注意力 公式

对于我们正在研究的自注意力机制,Q、K、V 都来自同一份输入序列,因此称为 Self-Attention,自注意力

如果 Q 来自一个序列,而 K、V 来自另外一个序列,那么对应的通常就是交叉注意力(Cross-Attention)。不过现代主流 Decoder-only LLM 的基础结构主要使用自注意力机制。

而且你认为这计算就完了吗?实际上对于实际的自回归 LLM,还需要通过因果掩码限制当前位置能够访问的 Token,避免在预测过程中读取未来信息。具体的 Mask 掩码计算方式,放到下一节「多头注意力与因果掩码」中进一步讨论。

多头注意力与因果掩码

为什么 Transformer 需要同时执行多组注意力计算,而不是只使用一组 Q、K、V?以及,自回归模型如何保证每个位置只能读取自己和之前的 Token,同时又能并行训练?

总之,问题很多是正常的。。。。。这里就提一下多头注意力。因为实际的 Transformer 并不只使用一组 Q、K、V,而是通常采用多头注意力 MHA,因为语言中的关系显然非常复杂,同时,对于我们研究的 Decoder-only 自回归语言模型,还需要通过因果掩码(Causal Mask)限制每个 Token 能够访问的信息范围。

这两个机制解决的是不同的问题:

  • 多头注意力:让模型能够在不同的特征子空间中,并行学习不同类型的 Token 关联。
  • 因果掩码:限制注意力的信息流动方向,保证当前位置不能使用后续 Token 的信息。

多头注意力

对于多头注意力,为什么需要?例如:

1
二狗因为天气太热,所以打开了空调。

对于这句话,模型可能需要同时处理不同类型的关联:

  • “二狗”和“打开”之间的动作执行关系。
  • “天气太热”和“打开空调”之间的因果关系。
  • “空调”和“打开”之间的动作对象关系。
  • 不同 Token 之间的位置和语法依赖关系。

之前中,我们使用单个注意力头,所有关系都需要由同一组 QKV 参数和同一套注意力权重进行建模。那么,在上述复杂语言情况下,让模型使用多套不同的参数,分别从不同的特征空间中计算注意力,是很有必要的。这就是多头注意力的核心思路。

MHA 不是简单地重复执行多次相同的注意力计算,而是让多个注意力头使用各自的参数投影,在不同的特征子空间中并行计算,再将结果融合起来。

因为不同注意力头具有不同的投影参数,所以它们可以学习不同的匹配模式。例如某些头可能更关注局部语法关系,某些头可能更关注长距离关联。当然,这些分工也不是人工规定的。。。很神奇吧,大模型

多头注意力的计算过程:

  • 假设输入的隐藏状态为 \[ X\in\mathbb{R}^{n\times d_{\mathrm{model}}} \] 前面单头注意力通过三组参数计算 Q、K、V。而在多头注意力中,假设存在 \(h\) 个 Attention Head,那么每个注意力头都有自己的投影参数: \[ Q_i=XW_Q^{(i)},\quad K_i=XW_K^{(i)},\quad V_i=XW_V^{(i)} \] 其中 \(i\) 表示第几个注意力头。每个头独立完成一次注意力计算: \[ head_i=\operatorname{Attention}(Q_i,K_i,V_i) \] 也就是说,多头注意力相当于让同一份输入 X,经过多组不同的参数投影,得到多组 QKV,然后分别进行注意力计算。

例如,假设某个模型具有,隐藏维度 \(d_{\mathrm{model}}=4096\),注意力头数量 \(h=32\),在经典 MHA 的均匀维度设计中,每个头的维度可以是:\(d_k=d_v=\frac{4096}{32}=128\)

于是,每个注意力头在 128 维的特征空间中进行注意力计算,而不是让每个头都使用完整的 4096 维。

这里也解释了一个容易产生的疑问:多头注意力是不是意味着头数增加多少倍,计算量就增加多少倍?只能说并不是

那么,多个注意力头的结果如何合并,现在每个 Head 都已经独立完成了注意力计算,但模型最终需要的是一个统一的隐藏状态表示。

所以,MHA 还有两个重要操作:Concat(拼接)与 Output Projection(输出投影)。

  • 首先,将所有头的输出沿特征维度拼接: \[ H=\operatorname{Concat}(head_1,head_2,\ldots,head_h) \]

  • 然后,通过一个可训练的输出投影矩阵 \(W_O\),将多头结果重新映射到模型的隐藏维度: \[ \operatorname{MultiHead}(X)=HW_O \]

因此,经典 MHA 的完整公式可以写成 \[ \begin{aligned} head_i&=\operatorname{Attention}(XW_Q^{(i)},XW_K^{(i)},XW_V^{(i)})\ \operatorname{MultiHead}(X) &=\operatorname{Concat}(head_1,\ldots,head_h)W_O \end{aligned} \] 其计算流程大致如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
         输入隐藏状态 X
│
┌───────────┼───────────┐
▼ ▼ ▼
Head 1 Head 2 Head N
│ │ │
Q1 K1 V1 Q2 K2 V2 QN KN VN
│ │ │
▼ ▼ ▼
Attention Attention Attention
│ │ │
└───────────┼───────────┘
▼
Concat 拼接
│
▼
输出投影 W_O
│
▼
MHA 最终输出

这里的 \(W_O\) 同样是模型训练得到的参数,它并不是简单地对各个 Head 求平均,而是将不同头的特征重新进行线性组合。

所以,多头注意力的本质,是使用多套独立的特征匹配机制提取上下文信息,再通过输出投影,将这些信息融合为统一的隐藏状态表示。

最后补充一点实际大模型架构中的技术发展

经典 MHA 虽然具有较好的表达能力,但每个 Attention Head 都有独立的 K、V 表示。在推理过程中,这些 K/V 通常需要被缓存起来,因此会带来较大的 KV-Cache 存储开销。

为了提高推理效率,现代 LLM 还采用了 MQA、GQA 等变体。

注意力结构 Q Head 与 KV Head 的关系 主要特点
MHA(Multi-Head Attention) 每个 Q Head 对应独立的 K/V Head 经典多头注意力
MQA(Multi-Query Attention) 所有 Q Head 共享一组 K/V Head 显著降低 KV-Cache 占用
GQA(Grouped-Query Attention) 多个 Q Head 分组共享 K/V Head 在表达能力与推理效率之间取得平衡

MHA 决定模型如何从不同特征空间提取信息

因果掩码

前面介绍自注意力时,我们使用 \(QK^T\) 计算整个序列的注意力分数。这意味着,在没有其他限制的情况下,每个位置都可以对序列中的其他位置计算注意力。

但对于 Decoder-only 自回归语言模型,这会产生一个严重问题:在预测下一个 Token 时,模型不能提前读取未来的 Token。

例如:

1
2
3
位置 1:二狗
位置 2:追逐
位置 3:苺氷

当模型处理位置 2 的“追逐”时,只能访问“二狗”和“追逐”自身,不能提前获取位置 3 的“苺氷”。

而在处理位置 3 的“苺氷”时,就可以访问前面所有的 Token。

因此,在因果语言模型中,不同位置能够访问的上下文范围是不同的:

1
2
3
4
5
6
7
8
位置 1:二狗
可以访问:二狗

位置 2:追逐
可以访问:二狗、追逐

位置 3:苺氷
可以访问:二狗、追逐、苺氷

这个约束就是因果掩码要实现的事情。

因果掩码并不是在 Tokenization 阶段删除未来 Token,也不是修改 QKV 的参数,而是直接作用于注意力分数矩阵。

我们前面已经得到了注意力分数矩阵: \[ S=\frac{QK^T}{\sqrt{d_k}} \] 对于包含三个 Token 的序列:

1
2
3
4
5
6
7
                   Key
二狗 追逐 苺氷
┌──────────────────┐
Query 二狗 │ s11 s12 s13 │
追逐 │ s21 s22 s23 │
苺氷 │ s31 s32 s33 │
└──────────────────┘

如果不加限制,第一行的“二狗”就能关注后面的“追逐”和“苺氷”,造成未来信息泄露。

因此,我们构造一个下三角结构的 Mask 矩阵: \[ M = \begin{bmatrix} 0 & -\infty & -\infty \\ 0 & 0 & -\infty \\ 0 & 0 & 0 \end{bmatrix} \] 其中:

  • \(0\):表示允许关注,不改变原始分数。
  • \(-\infty\):表示禁止关注,使对应位置在 Softmax 后的权重变为 0。

将 Mask 加入注意力分数,然后再执行 Softmax,经过这一步,未来位置的注意力权重就被强制设置为 0。

用矩阵表示,最终的注意力权重会具有下面的结构: \[ A= \begin{bmatrix} 1&0&0\\ a_{21}&a_{22}&0\\ a_{31}&a_{32}&a_{33} \end{bmatrix} \] 其中,每一行允许访问的位置,其权重之和为 1。会发现,第一行只能关注位置 1,第二行只能关注位置 1 和 2,第三行才能关注全部三个位置。这就从数学层面保证了自回归模型的信息访问规则。

因此,对于带因果掩码的 Scaled Dot-Product Attention,完整公式就变成了: \[ \boxed{ \operatorname{CausalAttention}(Q,K,V)= \operatorname{softmax} \left( \frac{QK^T}{\sqrt{d_k}}+M \right)V } \] 这里的 \(M\) 就是因果掩码矩阵。

但是实际工程中,肯定没有这么激烈的进行没几把啥用的构造,并不一定真的构造一个填满 \(-\infty\) 的完整矩阵才能进行因果处理。现代注意力计算内核可以直接利用因果约束,在计算过程中跳过不允许访问的位置。但是从数学原理来看,效果是一样的。

前面我们讲过,LLM 是自回归模型,每个 Token 的预测都依赖之前的 Token。按这个话说,它线程不安全啊,那么,既然存在这样的顺序依赖,为什么 Transformer 又能够在 GPU 上并行训练呢?

因为因果掩码,训练阶段可以一次性提供完整的目标序列,再利用因果掩码,保证每个位置只依赖允许访问的前文。

例如,训练文本为:

1
二狗 追逐 苺氷

对于下一 Token 预测任务,可以理解为:

模型看到的上下文 预测目标
二狗 追逐
二狗、追逐 苺氷
二狗、追逐、苺氷 后续 Token

如果采用传统的逐步处理方式,就需要依次完成不同位置的计算。但 Transformer 可以一次性将整个输入序列送入模型,通过因果掩码限制每个位置的注意力范围,并同时计算各个位置的预测结果。这样,模型能够在训练时并行处理多个位置,同时保持自回归预测所要求的信息约束

这也是 Transformer 相比传统循环神经网络的重要优势之一。

在推理阶段,初始输入上下文同样可以进行并行的 Prefill 计算,而后续生成新 Token 时,就需要逐步执行 Decode。

所以说,因果掩码(Causal Mask) 通过限制注意力矩阵中的可访问位置,确保每个 Token 只能利用当前及之前的信息,满足自回归语言建模的要求。

而这些注意力输出还不是一个完整 Transformer Block 的最终结果,后续仍然需要经过残差连接、归一化和前馈网络等结构进行进一步加工,这就进入下一节的内容了。

前馈网络(FFN)与残差、归一化

多头注意力机制能够让不同位置的 Token 交换信息,并得到融合上下文信息的新向量。

但是,Attention 主要负责不同 Token 之间的信息交互,而这些信息还需要进一步进行特征变换和非线性加工,这就是前馈网络(Feed-Forward Network,FFN)的工作。

此外,Transformer 并不是只有一层 Attention 和 FFN,而是需要将大量 Transformer Block 不断堆叠。而这些如果就是简单的堆叠,随着模型层数增加,就可能出现梯度传播困难、训练不稳定等问题。

因此,Transformer 还需要两个重要机制:

  • 残差连接(Residual Connection):为信息和梯度提供直接的传递路径,使深层网络更容易优化。
  • 归一化(Normalization):控制隐藏状态的数值尺度,改善训练过程中的稳定性。

这三个组件共同构成了 Transformer Block 中非常重要的计算结构。

FNN

前面已经知道,Attention 的主要工作是根据不同 Token 之间的匹配关系,对其他位置的 Value 进行加权聚合,也就是从上下文中寻找、选择并整合相关信息。但这种操作更偏向于信息的选择与聚合,所有复杂的非线性特征变换还需要 FNN 来处理,FNN 能进一步加工当前位置已有的信息,形成新的特征表示。

什么意思呢?假设某个 Token 经过 Attention 后,已经融合了前文中的人物、动作、时间等信息。那么模型还需要进一步处理这些信息之间的特征组合,例如某些特征是否应该被增强,哪些特征组合能够帮助后续预测。FFN 就是为每个位置提供这样的非线性加工能力,对每个位置聚合后的特征进行非线性变换,负责逐位置的特征加工。

它通常由两个线性变换和一个非线性激活函数组成,经典形式为: \[ \operatorname{FFN}(x)=W_2\sigma(W_1x+b_1)+b_2 \] 其中:

  • \(W_1\)、\(W_2\) 是两组可学习的权重矩阵。
  • \(b_1\)、\(b_2\) 是偏置参数。
  • \(\sigma\) 是非线性激活函数,例如 ReLU、GELU。
  • \(x\) 是某个位置输入的隐藏状态向量。

这里的计算逻辑其实不复杂:

1
2
3
4
5
6
7
8
9
10
11
12
13
输入隐藏状态 x
│
▼
第一次线性变换 W1
│
▼
非线性激活函数
│
▼
第二次线性变换 W2
│
▼
FFN 输出

这里非线性激活函数非常非常的复杂,我查了查论文,需要它的原因大概是,如果只有连续两次线性变换,忽略偏置后,它们本质上仍然可以合并为一次线性变换,这就没有意义了,加入激活函数之后,FFN 才能够学习更加复杂的特征组合与非线性变换。

经典 Transformer 的 FFN 通常不会一直在原始隐藏维度下计算,而是先将向量映射到更高维度,经过激活函数处理,再映射回原来的维度。

假设:

  • 模型隐藏维度为 \(d_{\mathrm{model}}\)。
  • FFN 中间维度为 \(d_{\mathrm{ff}}\)。

通常有: \[ d_{\mathrm{ff}}>d_{\mathrm{model}} \] 以经典的四倍扩展设计为例:\(d_{\mathrm{model}}=4096,d_{\mathrm{ff}}=16384\),那么,输入向量 4096 维,它会先升维到16384,再降维,回到 4096维。因为升维能够提供更宽的中间特征空间,使 FFN 可以在更多特征通道上执行非线性变换;而降维则是为了恢复 Transformer 的隐藏维度,方便后续的残差连接和网络堆叠。

还有一个很重要的特性:FFN 是 Position-wise 的,也就是对每个 Token 位置独立应用同一套网络参数。

假设输入序列包含 \(n\) 个 Token: \[ X\in\mathbb{R}^{n\times d_{\mathrm{model}}} \] 那么: \[ Y_i=\operatorname{FFN}(X_i) \] 其中每个位置使用相同的 FFN 权重,但独立计算。

这意味着 FFN 本身不会像 Attention 那样直接跨 Token 交换信息。不过,由于输入已经经过注意力机制,每个位置的隐藏状态实际上已经包含了上下文特征。因此,FFN 虽然逐位置计算,但仍然能够加工来自上下文的信息。而且,各个 Token 的 FFN 计算彼此独立,所以能够利用 GPU 高效并行执行。

经典 Transformer 的 FFN 使用 ReLU 作为激活函数: \[ \operatorname{ReLU}(x)=\max(0,x) \] 这个函数非常简单:负数变成 0,正数保持不变。

但随着模型发展,GELU 和 SwiGLU 等激活结构逐渐成为主流选择。对于 GELU,公式就是类似正态分布,主要是,可以简单理解为,GELU 对不同数值的特征进行更加平滑的调节,而 SwiGLU 是在此基础上引入了动态调节

现在对于 FNN,我们可以理解为,模型不仅学习生成什么特征,还学习如何根据输入调节这些特征的强度。

残差连接

前面讲过,现代大语言模型通常包含大量 Transformer Block,模型需要将信息连续传递经过几十甚至更多层网络。但网络越深,训练就越容易遇到优化困难。一个重要原因是,反向传播时,梯度需要经过多层连续变换,可能出现梯度消失、梯度爆炸或者训练退化等问题。

你正在修改一篇文章,需要连续修改 30 遍。如果每修改一遍,都必须完全重写上一遍的内容,那肯定是极其不理想的,那么 Transformer 也是类似,保留上一版本的内容,同时叠加这一轮产生的修改。

很明显,如果每一层都直接将输入转换为输出\(y=F(x)\),那么梯度传播就必须经过 \(F\) 对应的变换。

而残差连接的核心思路是,在网络原有输出上,直接加回输入:\(\boxed{y=x+F(x)}\)

其中:

  • \(x\):输入隐藏状态。
  • \(F(x)\):当前子层计算得到的特征变换结果。
  • \(y\):残差连接后的输出。

为什么要把原始输入直接加回来?

  • 因为这样,当前网络只需要学习在已有表示的基础上增加什么变化,而不必重新构造整个内容。

假设某一层暂时没有学习到有价值的特征变换,只要 \(F(x)\) 接近 0,那么:\(y\approx x\),至少在这种情况下,输入信息仍然能够直接传递到后续网络。

更重要的是,它改善了梯度传播。

对 \(y=x+F(x)\) 求导,\(I+\frac{\partial F(x)}{\partial x}\),其中 \(I\) 是恒等映射的雅可比矩阵。

这意味着梯度除了可以经过 \(F(x)\) 的计算路径,还存在一条来自恒等映射的直接路径。

所以说,残差连接并不是让梯度永远不会消失,而是为深层网络提供了更直接的梯度传播通道,使优化过程更加容易。

残差连接不仅有利于保存和更新已有特征,也是在深层 Transformer 中维持训练可行性的重要机制。

归一化

有了残差连接,网络已经具备比较好的信息和梯度传递路径,但还需要解决另一个问题。我们已经知道,每个 Token 在模型内部都对应一个高维向量。模型经过一层层矩阵运算后,向量数值可能发生明显变化。当模型有几十层甚至上百层时,如果隐藏状态的尺度变化没有得到适当控制,可能会使后续计算和参数优化更加困难。

因为每一层都在对隐藏状态进行线性变换、非线性激活和残差相加,随着网络不断堆叠,中间特征的数值分布可能发生变化,增加训练难度。归一化就是为了解决这类数值尺度问题。归一化不是负责理解 Token 的语义,而是负责让进入某些计算模块的数值保持更容易处理的尺度。

因此,Transformer 通常会使用归一化(Normalization)机制。

这里最有代表性的就是 LayerNorm 和 RMSNorm。

  • LayerNorm 层归一化:对每个 Token 的隐藏维度进行归一化

    对于某个 Token 的隐藏状态向量 \[ x=[x_1,x_2,\ldots,x_d] \] LayerNorm 会计算该向量在特征维度上的均值和方差: \[ \mu=\frac{1}{d}\sum_{i=1}^{d}x_i\\ \sigma^2=\frac{1}{d}\sum_{i=1}^{d}(x_i-\mu)^2 \] 然后完成归一化,并进行可学习的缩放和平移: \[ \operatorname{LayerNorm}(x)= \gamma\odot \frac{x-\mu}{\sqrt{\sigma^2+\epsilon}} +\beta \] 其中:

    • \(\mu\)、\(\sigma^2\):当前 Token 向量的均值与方差。
    • \(\epsilon\):用于保证数值稳定的小常数。
    • \(\gamma\)、\(\beta\):可学习的缩放和平移参数。

    因为层归一化操作的是每个 Token 的隐藏维度,因此,它不会破坏前面因果掩码对信息访问范围的约束。

  • RMSNorm:Root Mean Square Normalization

    RMSNorm 可以理解为 LayerNorm 的一种简化方案,它不再计算均值并进行中心化,而是直接利用向量的均方根来控制数值尺度。 \[ \operatorname{RMSNorm}(x)= \gamma\odot \frac{x}{ \sqrt{\frac{1}{d}\sum_{i=1}^{d}x_i^2+\epsilon} } \] 可以看到,相比 LayerNorm,RMSNorm 主要省去了均值中心化以及相应的方差计算,通常也不使用单独的平移参数 \(\beta\)。归一化的依据使用了均方根,计算相对简单一些,能够在保持较好训练稳定性的同时减少部分归一化开销,是主流现代 Decoder-only LLM 采用的方式。

最后,还有一个很重要的架构设计问题。我们已经知道,Transformer 子层需要残差连接和归一化,但这两个操作的先后顺序并不是固定不变的。比较典型的设计有两种:

  • Post-Norm:先执行子层计算和残差相加,再归一化。
    • 将残差相加后的结果进行归一化。但是,对于很深的 Transformer,每个残差分支的输出都会继续经过归一化变换,梯度传播的优化难度可能更高。
  • Pre-Norm:先对输入归一化,再执行子层计算和残差相加。
    • 现代大语言模型采用 Pre-Norm。先归一化,这样残差连接的直接路径不再需要经过当前子层末尾的归一化变换。能够为深层 Transformer 提供更加直接的梯度传播路径,在大规模训练中具有较好的稳定性。

Transformer Block 的堆叠与深层结构

对于现代采用 Pre-Norm 的 Decoder-only Transformer,一个常见的 Block 可以表示为:

\[ H=X+\operatorname{Attention}(\operatorname{Norm}(X)) \]

\[ Y=H+\operatorname{FFN}(\operatorname{Norm}(H)) \]

也就是说,一个 Transformer Block 的完整计算流程

image-20261113102958829
  • 先归一化,再通过 Attention 交换不同 Token 的信息,最后通过残差相加保留输入路径。
  • 再次归一化,再通过 FFN 对各个 Token 的隐藏状态进行非线性加工,最后通过第二次残差相加保留输入路径。

这样就完成了一个 Transformer Block。而现代 LLM 会将大量这样的 Block 堆叠起来,使隐藏状态不断被更新和加工,形成一个深层神经网络

假设整个模型包含 \(L\) 层 Transformer Block,使用 \(X^{(l)}\) 表示第 \(l\) 层的输入隐藏状态,\(B_l\) 表示这一层的计算过程,那么: \[ X^{(l+1)}=B_l(X^{(l)}) \] 整个深层网络可以表示为: \[ X^{(L)}=B_{L-1}\circ B_{L-2}\circ\cdots\circ B_0(X^{(0)}) \] 每个 Block 的整体结构通常相同,但它们一般拥有各自独立的可训练参数,并不是使用同一组权重反复执行计算。

也就是说,第 1 层与第 20 层虽然都包含 Attention 和 FFN,但各自的 QKV 投影矩阵、FFN 权重等参数不同,因此能够学习不同的特征变换。而且,随着每一层的输出不断传递给下一层,Token 的隐藏状态也在持续更新。Transformer 的深度让模型可以在已有计算结果的基础上,继续进行多轮上下文信息交互与非线性特征加工。

这也就是为什么,多层堆叠为什么能够形成更复杂的特征

经过一层 Attention 和 FFN 后,各个 Token 已经得到了一次加工后的上下文表示。而下一层处理的并不是原始 Embedding,而是上一层得到的隐藏状态。因此,后续层可以继续利用前面已经提取出来的特征,形成更加复杂的组合关系。不同层的功能可能相互重叠,具体形成什么样的特征,是模型训练的结果。

Transformer 的规模通常受到几个核心架构参数的影响:

  • Depth(深度):Transformer Block 的层数。
  • Width(宽度):隐藏维度 \(d_{\mathrm{model}}\)。
  • FFN Dimension:前馈网络的中间特征维度。
  • Attention Heads:注意力头的数量及对应维度。

其中,增加 Block 层数最直接的影响,就是增加模型可以连续执行的特征变换次数。同时,由于不同 Block 通常具有独立参数,层数增加也会增加模型参数量和计算量。例如,一个模型从 32 层扩展到 64 层,在其他架构参数保持不变的情况下,Transformer 主体的参数量与每次前向传播所需的计算量通常都会近似翻倍。更深的网络意味着更大的表示和计算容量,但不等于层数越多,模型就一定越聪明。

当输入序列经过全部 \(L\) 层 Transformer Block 后,就得到了最终的隐藏状态矩阵: \[ X^{(L)}\in\mathbb{R}^{n\times d_{\mathrm{model}}}\ \] 可以发现,在典型 Transformer 架构中,虽然隐藏状态经过了很多层复杂计算,但序列长度和隐藏维度通常仍然保持不变。变化的是每个 Token 对应的向量内容,而不是 Token 的数量。

对于现代 Decoder-only LLM,经过全部 Transformer Block 后,模型通常还会执行一次最终归一化,再通过输出层将隐藏状态映射到词表空间。

在生成下一个 Token 时,模型主要使用最后一个位置的最终隐藏状态,计算对应的词表 Logits。

这也就完成了从初始 Token 表示,到深层上下文特征,再到下一 Token 预测所需表示的整个过程。

到这里,我们就基本了解了 Transformer 内部的主要计算结构。

多个 Transformer Block 的堆叠,本质上是让隐藏状态经过连续的、具有独立参数的上下文建模与特征变换,逐步形成能够支持语言预测的复杂表示。

接下来,就可以进入模型的输出与生成阶段,具体研究这些最终隐藏状态如何被投影到词表空间,得到 Logits、概率分布,并通过采样策略生成下一个 Token。

具体之后的生成、推理、训练等内容,下一篇再说