LLM如何预测下一个Token？一文拆解Transformer核心流程

很多人第一次理解大语言模型时，都会听到一句话：LLM 的本质是在预测下一个词。

这句话方便入门，但并不完全准确。更严谨地说：LLM 是在根据已有上下文，预测下一个 Token 的概率分布。

本文从一次用户输入开始，拆解大语言模型内部大致经历了什么：文本如何变成数字，数字如何变成向量，模型如何理解顺序和上下文，最后又如何生成下一个 Token。

1. LLM 不是直接处理文字，而是处理 Token ID

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

中国的首都是

但模型并不能直接计算这段文字。文本进入模型之前，会先经过 tokenizer：

用户输入文本
  ↓
Tokenizer.encode()
  ↓
Token ID 序列
  ↓
大模型推理，预测后续 Token ID
  ↓
Tokenizer.decode()
  ↓
输出文本

也就是说，模型真正接收到的是一串整数 ID，而不是人类看到的文字。

例如一句中文可能被切成：

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

它可能被 tokenizer 切成类似下面的 Token：

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

不同模型使用的 tokenizer 不同，切分结果也可能不同。一个 Token 不一定等于一个完整的词，它可能是一个词、子词、单字、标点，甚至是空格和特殊符号。

所以，"预测下一个词"只是通俗说法；准确说法是：

LLM 根据当前上下文，预测下一个 Token ID。

2. 为什么要有 Token？

如果模型直接以"完整词"为单位，会遇到很大的词表问题。

比如英文单词：

unhappiness

它可以被拆成更小的子词单元，例如：

un + happi + ness

这样做的好处是，模型不需要为所有可能的英文单词、中文词语、专有名词都准备单独的完整词条，而是用一套相对有限的"基础积木"组合出更多文本。

Token 可以理解为 LLM 世界里的基础货币：

• 用户输入会被换算成 Token
• 模型推理时处理的是 Token ID
• 模型输出时也是一个个生成 Token
• 很多 API 的计费和上下文长度也按 Token 计算

3. Token ID 本身没有语义

经过 tokenizer 之后，每个 Token 会被映射成一个数字 ID。

例如：

"你" -> Token ID，例如 57668

这里的 57668 只是示意。具体数字取决于模型使用的 tokenizer 和词表，不同模型不一定相同。这个编号本身没有语义，也不能通过加减乘除直接得到"好""我""中国"这类相关含义。

模型真正能计算的是向量。

所以，Token ID 进入模型后的第一步，就是查表，把 ID 转成 embedding。

4. Embedding：把 Token 变成语义向量

模型内部有一个巨大的参数矩阵，通常叫：

Embedding Matrix

可以把它理解成一张查找表：

Token ID -> 高维向量

如果某个 Token ID 是 57668，模型就去 embedding matrix 的第 57668 行取出对应向量。这里的 57668 只是示意，真实 ID 要以具体模型的 tokenizer 为准。

这个向量不是一个普通数字，而是一个高维坐标点。它承载了模型在预训练过程中学到的统计关系和语义关系。

一个简化理解是：

• 语义相近的 Token，在向量空间里距离可能更近
• 语义差异很大的 Token，在向量空间里距离可能更远
• 向量之间可以参与矩阵计算，从而被后续网络层继续加工

经典的类比是：

国王 - 男性 + 女性 ≈ 王后

这个例子不能被理解成所有 embedding 都能稳定做出如此精确的线性推理，但它说明了一个重要直觉：模型会把语言中的某些关系编码到向量空间里。

5. 只有语义还不够，还需要位置信息

看下面两句话：

我咬了狗
狗咬了我

它们包含的字基本相同，但意思完全不同。

原因在于：顺序很重要。

Token embedding 主要表示"这个 Token 是什么"，但 Transformer 本身并不知道这个 Token 出现在第几个位置。因此，模型还需要引入位置信息。

早期 Transformer 使用绝对位置编码，后来的很多模型会使用 RoPE 等相对位置相关的方法。无论具体实现如何，核心目的都是一样的：

让模型知道每个 Token 在上下文里的位置关系。

最终，每个 Token 进入主干网络时，至少需要携带两类信息：

• 语义信息：它是什么
• 位置信息：它在哪里

6. Self-Attention：模型如何理解上下文

单个 Token 的向量并不足以理解一句话。很多词的含义依赖上下文。

例如：

The animal was exhausted, so it

这里的 it 指代谁？

通常我们会理解为 animal，因为前文已经出现了 animal，并且 exhausted 这个状态也更容易和动物关联。对于 GPT 这类自回归模型，这个例子只依赖 it 之前的上下文，不需要偷看后面的词。

Transformer 用 self-attention 机制来建模这种上下文关系。对于 GPT 这类自回归语言模型，它使用的是带因果 mask 的 self-attention：当前位置只能关注自己和它之前的 Token，不能偷看未来 Token。

在 self-attention 中，每个 Token 的表示会被线性变换成三类向量：

Q: Query，当前 Token 想找什么信息
K: Key，当前 Token 能被如何匹配
V: Value，当前 Token 能提供什么内容

对于某个 Token 来说，它会拿自己的 Query 去和允许关注的 Token 的 Key 做相似度计算。相似度越高，说明它越应该关注那个 Token。对自回归模型来说，"允许关注"通常指当前位置以及它之前的位置。

简化公式是：

score = Q · K

实际模型中还会有缩放、mask、softmax 等步骤：

Attention(Q, K, V) = softmax(QK^T / sqrt(d_k) + mask)V

这一步的直觉是：

1. 计算"我应该关注谁"
2. 把注意力分数变成权重
3. 用 mask 屏蔽不应该看到的位置
4. 按权重汇总各个 Token 的 Value
5. 得到融合上下文后的新表示

所以，it 的表示不再只是 it 本身，而是混入了上下文中相关 Token 的信息。

需要注意的是，attention 不等于人类意义上的"理解"，也不保证每次都能完美解决指代问题。它是一种可学习的上下文信息聚合机制。

7. Multi-Head Attention：从多个角度看上下文

真实模型不会只做一次 attention，而是会使用 multi-head attention。

可以把不同 head 理解成不同的观察角度：

• 有的 head 可能更关注语法关系
• 有的 head 可能更关注实体指代
• 有的 head 可能更关注局部搭配
• 有的 head 可能更关注长距离依赖

每个 head 都会独立计算一套 attention，再把结果拼接、投影，形成新的 Token 表示。

这让模型可以同时捕捉多种语言关系，而不是只用一种相似度标准理解上下文。

8. Transformer Block：一层不够，就堆很多层

一个典型的 Transformer Block 通常包含：

• self-attention
• feed-forward network
• residual connection
• layer normalization

输入 Token embedding 经过一层 Transformer 后，会变成融合了部分上下文的新表示。再经过下一层，又会进一步融合更复杂的信息。

大模型之所以"大"，一个重要原因就是：

• 参数多
• 层数深
• hidden size 大
• attention head 多
• 训练数据规模大

多层 Transformer 叠加之后，模型逐步把原始 Token 序列加工成更适合预测下一个 Token 的上下文表示。

9. 最后一步：输出下一个 Token 的概率分布

当模型处理完当前上下文后，每个位置都会得到一个新的隐藏状态。训练时，模型通常会让每个位置预测它的下一个 Token；推理生成时，我们主要取最后一个位置的隐藏状态，把它映射到词表大小的 logits。

假设词表有 100000 个 Token，那么模型会输出 100000 个分数：

北京: 12.7
上海: 8.1
北平: 6.3
长安: 4.8
...

这些原始分数叫 logits。经过 softmax 后，它们会变成概率分布：

北京: 92%
北平: 4%
长安: 2%
其他: 2%

对于输入：

中国的首都是

模型很可能会给 北京 一个很高的概率。

但它并不是从数据库里"查出答案"，而是根据训练过程中学到的语言统计规律和知识表示，计算出下一个 Token 的概率。

10. 生成文本：一次只生成一个 Token

LLM 的生成过程通常是自回归的。

也就是：

输入上下文
  ↓
预测下一个 Token
  ↓
把这个 Token 拼回上下文
  ↓
继续预测下一个 Token
  ↓
不断重复，直到结束

例如：

中国的首都是

模型先生成：

北京

新的上下文变成：

中国的首都是北京

然后继续预测下一个 Token，可能是：

。

最终得到完整输出：

中国的首都是北京。

11. 为什么同一个问题有时会输出不同答案？

因为模型输出的是概率分布，而不只是一个唯一答案。

如果每次都选择概率最高的 Token，输出会更稳定，但也可能更死板。实际应用中经常会使用一些采样策略：

• temperature：控制随机性
• top-k：只在概率最高的 k 个 Token 中采样
• top-p：只在累计概率达到 p 的候选集合中采样

temperature 越低，输出越确定；temperature 越高，输出越发散。

这也是为什么同一个 Prompt，在不同参数下可能生成不同文本。

12. 串起来看完整流程

把整个过程合在一起，可以得到一条完整链路：

自然语言输入
  ↓
Tokenizer 切分成 Token
  ↓
Token 映射成 Token ID
  ↓
Embedding Matrix 查表，得到语义向量
  ↓
加入位置信息
  ↓
经过多层 Transformer Block
  ↓
Self-Attention 融合上下文
  ↓
Feed-Forward Network 加工特征
  ↓
输出 logits
  ↓
Softmax 得到下一个 Token 的概率分布
  ↓
采样或选择一个 Token
  ↓
Decode 成人类可读文本

一句话总结：

LLM 不是直接"思考出一句话"，而是在每一步根据已有上下文计算下一个 Token 的概率，再通过自回归方式一个 Token 一个 Token 地生成最终文本。

结语

"预测下一个词"是理解 LLM 的入口，但真正的内部流程要更精确：

• 文本会先变成 Token ID
• Token ID 会通过 embedding 变成向量
• 位置编码让模型知道顺序
• self-attention 让模型聚合上下文
• 多层 Transformer 不断加工表示
• logits 和 softmax 给出下一个 Token 的概率
• 自回归生成把一个个 Token 连成完整回答

理解这条链路后，再去看上下文窗口、幻觉、temperature、RAG、微调、推理加速等概念，都会更容易建立清晰的技术直觉。