LLM 如何预测下一个词？从 Token 到 Transformer 的完整过程

很多人在初次接触大语言模型时，会感觉它似乎能够“理解人类语言”。向其提问便能获得回答，指令其编写代码亦可补全，要求其撰写文章也能继续。然而从模型内部运作的视角审视，LLM 所执行的任务可以先精炼为一句话：依据已有上下文，预测下一个最可能出现的 Token。

需要注意的是，这里并非简单预测“下一个词”，而是精准预测“下一个 Token”。Token 可以是一个完整的词语，也可能是一个子词、一个单字、一个标点符号，甚至是一个词的部分片段。

比如当你输入：

中国的首都是

模型内部会展开计算：

北京：92% 北平：4% 长安：2% 上海：0.5% ……

随后依据概率挑选出一个 Token，例如“北京”。接着模型会将“北京”追加到原始输入之后，再继续预测下一个 Token。

这就是所谓的：

自回归生成：一个 Token 接一个 Token 地往后生成。

一、用户输入不是直接进入模型的

用户输入的是自然语言，比如：

我爱人工智能，自然语言处理很有趣

然而模型不能直接处理中文、英文或标点符号。它首先需要把文本切分成 Token。

这个过程被称为：

Tokenization

也就是分词，或者更确切地说，叫词元化。

大模型所处理的最小单位通常并非语言学意义上的“词”，而是 Token。

例如英文：

unhappiness

可能不会被当作一个完整单词，而是拆解为：

un + happy + ness

再比如：

tokenization

可能拆分为：

token + ization

中文的处理方式也类似。

例如：

我爱人工智能，自然语言处理很有趣

在某些 tokenizer 里可能被切割成：

["我", "爱", "人工智能", "，", "自然语言处理", "很", "有趣"]

不同模型的 tokenizer 各有差异，切割方式也可能不同。例如 OpenAI 拥有自己的 tokenizer，Qwen、LLaMA、Claude 等模型也各自具备独特的 tokenizer。

二、为什么不直接按完整的词来处理？

因为完整的词数量过于庞大。

如果模型只认识完整的英文单词，它需要记住几十万个单词。若再涵盖中文、日文、韩文、代码、符号、表情以及专业术语，词表会变得异常庞大。

这会引发几个问题：

第一，词表过大，查找表随之膨胀。

第二，模型参数增多，训练和推理成本自然上升。

第三，遭遇新词、拼写变化或专业词汇时，模型难以妥善处理。

因此，更为合理的做法是将词拆解成更小的“基础积木”。

例如：

unhappiness = un + happy + ness

这样，模型无需单独记忆每一个复杂词汇，只需掌握一批常见子词，便能灵活组合出多种表达。

你可以将 Token 理解为 LLM 世界中的“货币单位”。

我们平时依据字、词、句子来理解语言，而模型则按照 Token 进行计算、传输和计费。

三、Token 会被转换成 Token ID

切分出 Token 之后，模型会将每个 Token 转化成一个数字编号，即 Token ID。

例如：

"你" -> 57668"好" -> 53901

这些数字本身并不包含语义。

57668 并不代表“你”的意义，也无法通过数学计算直接推导出“好”的编号。

它仅仅是一个索引。

你可以将 Token ID 视为字典中的页码：

Token: 你Token ID: 57668

这意味着：“你”这个 Token 在词表中的编号是 57668。

然而，这个编号本身并不能让模型理解其含义。真正使模型获得语义的是下一步操作：Embedding。

四、Embedding：把 Token ID 变成语义向量

Token ID 仅仅是数字编号，无法直接表达语义。

因此，模型会通过一个庞大的查找表，将 Token ID 转换成一个高维向量。

这个查找表被称为：

Embedding Matrix

例如：

Token ID 57668 -> [0.12, -0.44, 0.87, ..., 0.03]

这个向量的维度可能是 768、1024、4096，甚至更高。具体维度取决于模型架构。

这个过程被称为：

Embedding

也就是嵌入。

简而言之：

Embedding 就是将离散的 Token 编号，转化为连续的高维语义坐标。

你可以想象一个广阔的语义空间。每个 Token 都是这个空间中的一个点。

语义相近的 Token，它们的向量距离通常也较为接近。

例如：

国王、王后、男人、女人

在向量空间中可能存在某种方向关系：

国王 - 男性 + 女性 ≈ 王后

这并非模型人为写入的规则，而是模型在大量文本训练过程中逐渐习得的几何结构。

再比如：

猫、狗、动物

它们之间的距离可能更近。

而：

国王、苹果

之间的距离则可能相当远。

五、Embedding 只知道“是什么”，不知道“在哪里”

获得语义向量之后，模型了解了每个 Token 的大致含义。

但这还不够。

因为一句话的含义不仅取决于词汇本身，还受顺序影响。

例如：

我咬了狗狗咬了我

这两句话所用的 Token 基本相同，但意义却截然相反。

如果模型仅仅查看 Token 的语义向量，就无法知晓哪个词在前，哪个词在后。

因此，我们需要加入位置信息。

这就是：

Position Encoding

亦称为位置编码。

模型会为每个 Token 的 Embedding 添加位置信息，使其明确该 Token 在序列中所处的具体位置。

因此，在进入 Transformer 之前，每个 Token 的表示大致包含两类信息：

语义信息：这个 Token 是什么位置信息：这个 Token 在哪里

可以理解为：

最终输入向量 = Token Embedding + Position Encoding

当然，现代模型的位置编码实现有多种变体，例如绝对位置编码、相对位置编码、RoPE 旋转位置编码等。但对于初学者而言，理解“模型需要知道顺序”这一点就已足够。

六、Transformer 真正开始处理上下文

至此，输入已经从文字转变为一系列向量。

例如：

中国 的 首都 是

会变成：

[x1, x2, x3, x4]

每个 x 都是一个高维向量，且包含语义和位置信息。

接下来，这些向量会进入 Transformer Block。

一个大语言模型通常不止一层 Transformer，而是由许多层堆叠而成。

例如：

第 1 层 Transformer Block 第 2 层 Transformer Block 第 3 层 Transformer Block ……第 N 层 Transformer Block

每一层都会继续加工 Token 的表示。

Transformer Block 内部最核心的两部分是：

Self-Attention Feed-Forward Network

可以先这样理解：

Self-Attention：让每个 Token 观察上下文，判断自己应关注谁 Feed-Forward：对每个 Token 的表示做进一步加工

七、Self-Attention：模型如何理解上下文关系

Self-Attention 是 Transformer 的核心。

它所要解决的问题是：

当前的 Token 应该重点关注上下文中的哪些 Token？

比如这句话：

The animal didn’t cross the street because it was too tired.

这里的 it 指的是哪个？

是 animal，还是 street？

人类很容易做出判断：

it = animal

因为“疲惫”的通常是动物，而非街道。

但模型要如何计算出来呢？

这就要依靠 Self-Attention。

八、Q、K、V：自注意力的三个角色

在 Self-Attention 中，每个 Token 的向量会被转换为三个向量：

Q = Query K = Key V = Value

你可以用生活化的方式来理解：

Query：我在寻找什么？Key：我能被什么问题匹配到？Value：如果别人关注我，我能提供什么信息？

例如对于 it 而言，它的 Query 可能正在寻找：

这个代词所指代的对象是谁？

对于 animal 而言，它的 Key 可能包含：

我是一个可行动、可疲惫的实体

对于 street 而言，它的 Key 可能包含：

我是一个地点

接着，模型会用 it 的 Query 和上下文中每个 Token 的 Key 进行相似度计算。

这个相似度通常通过点积来实现：

score = Q · K

例如：

score(it, animal) = Q_it · K_animal score(it, street) = Q_it · K_street

如果出现：

score(it, animal) > score(it, street)

模型就会更多地关注 animal。

然后，模型会根据这些注意力分数，对所有 Token 的 Value 进行加权求和。

也就是说，it 的新表示会吸收更多来自 animal 的信息。

这就是 Self-Attention 能让模型处理指代、上下文和长距离依赖的原因。

九、一个更直观的例子：苹果手机和我吃了苹果

同一个词语，在不同的上下文里，含义可能完全不同。

例如：

苹果手机很好用我吃了苹果

第一个“苹果”更接近公司或品牌。

第二个“苹果”则更接近水果。

单独看“苹果”这个 Token，它的初始 Embedding 可能是固定的。

但经过 Self-Attention 之后，它会结合上下文来改变自己的表示。

在：

苹果手机很好用

这句话中，“苹果”会关注“手机”“好用”等词汇，因此它的表示更偏向品牌和产品。

在：

我吃了苹果

这句话中，“苹果”会关注“吃了”，因此它的表示更偏向于水果。

这就是上下文建模。

模型并非仅仅查询一个固定字典，而是在上下文中动态更新每个 Token 的含义。

十、多头注意力：不是只用一种角度看句子

真实的 Transformer 内部通常不只包含一个 Attention，而是多个 Attention 并行工作。

这被称为：

Multi-Head Attention

也就是多头注意力。

为什么需要多个头？

因为一句话里蕴含着多种关系。

有的注意力头可能关注语法关系：

主语和谓语

有的注意力头可能关注指代关系：

it 指向 animal

有的注意力头可能关注位置关系：

前一个词、后一个词

有的注意力头可能关注语义类别：

地点、人物、动作、物体

因此，多头注意力可以理解为：

模型从多个角度同时观察上下文关系。

最后，这些不同注意力头的结果会被拼接、融合，从而形成新的 Token 表示。

十一、Feed-Forward：对每个 Token 做更深层加工

Self-Attention 完成之后，每个 Token 已经吸纳了上下文信息。

接下来会进入 Feed-Forward Network。

它通常是一个小型的神经网络，对每个位置的 Token 向量进行单独处理。

你可以粗略理解为：

Self-Attention：负责与上下文交流 Feed-Forward：负责对当前信息进行深度加工

比如经过 Self-Attention 后，it 已经吸收了 animal 的信息。

Feed-Forward 会继续处理这个表示，使其成为更适合下一层使用的语义特征。

Transformer Block 会反复执行类似的过程：

观察上下文 加工自身 再观察上下文 再加工自身 ……

层数越深，Token 的表示就越抽象、越丰富。

十二、经过很多层 Transformer 后，模型开始预测下一个 Token

假设输入是：

中国的首都是

经过 Tokenizer、Embedding、位置编码以及多层 Transformer 之后，模型会得到最后一个位置的隐藏向量。

这个隐藏向量包含了前方上下文的信息。

它大致表达了：

根据“中国的首都是”这个上下文，后面应该接一个表示首都名称的 Token。

但此刻它还不是文字。

模型还需要将这个隐藏向量转换为对整个词表的评分。

这一步通常通过一个线性层来完成。

十三、Logits：给词表里的每个 Token 打分

假设模型词表大小是 50,000。

那么模型会输出一个 50,000 维的向量。

每一维对应一个 Token 的原始分数。

这个分数被称为：

logit

例如：

北京：12.8 北平：8.1 上海：3.2 长安：2.9 苹果：-1.4 ……

请注意，logit 还不是概率。

它只是模型给每个候选 Token 的原始评分。

分数越高，表示模型认为这个 Token 越适合出现在下一个位置。

十四、Softmax：把分数变成概率

为了从这些候选 Token 中做出选择，模型需要将 logits 转换为概率。

这一步用到的操作是：

Softmax

Softmax 会将所有分数转换为概率分布，并且所有概率之和等于 1。

例如：

北京：92% 北平：4% 长安：2% 上海：0.5% 其他：1.5%

至此模型便知：

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

十五、采样策略：为什么模型不是永远选概率最高的词？

最为简单的方式是：

永远选择概率最高的 Token

这被称为贪心解码。

例如：

北京：92% 北平：4% 长安：2%

那就直接选择“北京”。

这种方式虽然稳定，但有时会使输出显得刻板。

因此，很多模型会采用采样策略。

常见的参数有：

temperature top-k top-p

简单理解：

temperature 低：更保守、更确定 temperature 高：更随机、更具创造性

例如编写代码、做数学题时，通常希望 temperature 低一些。

而写小说、进行头脑风暴、创作广告文案时，temperature 可以高一些。

十六、Decode：把 Token ID 变回文字

模型选出下一个 Token 后，得到的可能仍然是 Token ID。

例如：

Token ID: 12345

随后，tokenizer 的 decode 过程会将其转换回文字：

12345 -> 北京

于是输出变为：

中国的首都是北京

接着，模型会把“北京”追加到上下文后面，再继续预测下一个 Token。

也就是：

中国的首都是北京

再次送回模型，预测下一个：

。

于是形成：

中国的首都是北京。

这个过程不断重复，直到模型生成结束符，或达到最大输出长度。

十七、完整流程总结

现在我们将整个过程串联起来。

用户输入：

中国的首都是

第一步，Tokenizer 将其切分为 Token：

["中国", "的", "首都", "是"]

第二步，Token 转换为 Token ID：

[101, 234, 8976, 322]

第三步，Token ID 查询 Embedding Matrix，获得语义向量：

[向量1, 向量2, 向量3, 向量4]

第四步，加入位置编码：

[语义 + 位置]

第五步，进入多层 Transformer Block：

Self-Attention：建模上下文关系 Feed-Forward：深度加工语义表示

第六步，最后一层输出隐藏状态。

第七步，线性层映射到整个词表：

50000 个 Token 的 logits

第八步，Softmax 转换为概率：

北京 92%，北平 4%，长安 2%……

第九步，根据采样策略选出下一个 Token：

北京

第十步，Decode 为文字，追加到上下文：

中国的首都是北京

然后循环继续。

十八、给新手的一句话版本

LLM 的工作流程可以概括为：

文字输入 ↓ 切成 Token ↓ Token 变成编号 ↓ 编号查表变成语义向量 ↓ 加入位置信息 ↓ Transformer 通过 Self-Attention 理解上下文 ↓ 预测下一个 Token 的概率 ↓ 选出一个 Token ↓ 解码成文字 ↓ 追加到上下文，继续预测

也可以更简洁地表达：

LLM 并非一次性写出完整答案，而是不断依据前文预测下一个 Token。

十九、给有基础读者的技术版总结

从技术角度看，一个 Decoder-only Transformer 的推理过程大致如下：

input text → tokenizer → token ids → token embeddings + positional encoding → stacked decoder transformer blocks → final hidden states → linear projection to vocab size → logits → softmax / sampling → next token id → decode → append and repeat

在每一层 Transformer 中，核心计算包括：

Q = XWq K = XWk V = XWv Attention(Q, K, V) = softmax(QKᵀ / √d_k) V

其中：

Q：当前 Token 想找什么信息 K：每个 Token 能被怎样匹配 V：每个 Token 真正提供的信息内容

Self-Attention 让每个 Token 都能根据上下文重新更新自己的表示。

经过多层堆叠之后，模型的隐藏状态中包含了丰富的上下文语义信息。

最后通过输出层映射到词表维度，得到每个候选 Token 的 logit，再经过 softmax 或采样策略选出下一个 Token。

二十、容易误解的几个点

1. LLM 不是直接“理解文字”

它处理的是 Token ID 和向量。

自然语言仅仅是输入输出层面的形式。

模型内部主要进行矩阵计算、向量变换和概率预测。

2. Token 不等于词

Token 可能是：

一个字 一个词 一个子词 一个标点 一个空格 一段代码片段

因此，“预测下一个词”只是方便理解的说法，更准确的表述是：

预测下一个 Token。

3. Token ID 本身没有语义

例如：

"你" -> 57668

这个 57668 仅仅是编号，并不代表“你”的含义。

真正包含语义的是：

Embedding 向量

4. Embedding 不是人工写好的字典解释

Embedding 并非人类手动定义的：

苹果 = 水果 / 公司

而是模型通过大量文本训练所习得的高维空间结构。

5. Self-Attention 不是“注意力集中”这么简单

它并非人类视觉意义上的注意力，而是一种向量匹配机制。

其本质是：

用 Query 和 Key 计算相关性，再用相关性加权 Value

结尾：LLM 的核心是上下文概率预测机器

从外部看来，LLM 似乎在进行聊天、写作、推理和编程。但从内部运行机制来看，其基本操作高度统一：将上下文转化为向量表示，然后预测下一个 Token 的概率分布。它之所以表现得像在“理解语言”，是因为在规模庞大的训练过程中，它掌握了语言、知识、语法、语义、代码及推理模式之间复杂的统计关系。因此，LLM 的核心并非简单记忆答案，而是在巨大的参数空间内，将上下文压缩为语义表示，再逐步生成下一个 Token。概括而言，Token 是输入单位，Embedding 是语义坐标，Position Encoding 提供顺序信息，Self-Attention 建立上下文关联，Transformer 加工信息，Softmax 输出概率，采样策略选出下一个 Token，最终通过循环生成完整的回答。