返回专栏
· 14 分钟阅读

什么是 Next Token Prediction?大语言模型如何学会预测下一个 Token?


一、什么是 Next Token Prediction?

Next Token Prediction,简称 NTP,中文通常称为下一个 Token 预测。

它是现代 Decoder-only 大语言模型最核心的训练目标之一。

核心思想非常简单:

给定一段已经出现的 Token 序列,让模型预测下一个最可能出现的 Token。

例如:

输入:
今天天气非常

模型预测:
好

再例如:

输入:
人工智能的发展离不开

模型预测:
数据

模型并不是直接学习完整句子的含义,也不是通过人工编写规则理解语言,而是通过大量文本样本,反复学习在给定上下文的情况下,下一个 Token 应该是什么。

这里需要注意:模型预测的单位是 Token,而不一定是汉字、单词或完整词语。

例如,一句话经过 Tokenizer 处理后,可能变成:

原始文本:
我喜欢人工智能。

Token 序列:
["我", "喜欢", "人工", "智能", "。"]

也可能根据具体 Tokenizer,被切分成其他形式。

因此,Next Token Prediction 实际上预测的是 Token ID 所对应的词表元素。

二、为什么预测下一个 Token 能训练出大语言模型?

这是理解大语言模型最重要的问题之一。

一个自然的疑问是:

如果模型只是在预测下一个 Token,为什么最后能够回答问题、写代码、翻译、总结,甚至进行复杂推理?

答案在于:准确预测下一个 Token,需要模型学习上下文中大量复杂的信息。

2.1 预测下一个 Token 不只是记忆词语搭配

假设模型看到:

牛顿提出了

可能预测:

万有引力定律

这看起来像是在记忆固定搭配。

但如果输入变成:

牛顿提出的经典力学理论主要研究

模型需要预测的内容就会发生变化。

它需要利用:

  • 前文的语义。
  • 词语之间的关系。
  • 句子的语法结构。
  • 相关知识。
  • 当前上下文的表达意图。

再看一个例子:

输入:
如果一个数能够被 2 整除,那么它是一个

模型可能预测:

偶数

要让预测结果合理,模型需要掌握一定的数学概念和语言表达规律。

这说明,下一个 Token 预测虽然是一个局部预测任务,但它对上下文建模提出了很高的要求。

2.2 预测目标简单,学习内容复杂

为了预测下一个 Token,模型需要逐渐学习不同层次的信息:

学习层次 需要掌握的内容
Token 层面 Token 之间的共现规律
词语层面 词汇含义与组合关系
句子层面 语法、句法和语义结构
段落层面 上下文连贯性与主题关系
知识层面 事实、概念和实体关联
任务层面 问答、翻译、总结、代码生成等模式

这些能力并不是通过单独设置多个明确的训练目标逐项获得的,而是在大量序列预测任务中逐渐形成的。

不过,需要强调:

Next Token Prediction 并不保证模型一定获得正确的事实知识或可靠的推理能力。

它优化的是训练数据分布下的 Token 预测表现。模型是否真正掌握某项能力,还受到数据质量、模型规模、训练方式和后续优化等因素影响。

三、Next Token Prediction 的数学原理

Next Token Prediction 的数学基础是条件概率。

3.1 从联合概率理解语言模型

假设一段 Token 序列为:

X=(x_1,x_2,\ldots,x_T)

其中:

  • x_t:第 t 个 Token。
  • T:序列长度。

根据概率论中的链式法则,整个序列的联合概率可以分解为:

\boxed{ P(x_1,x_2,\ldots,x_T) = \prod_{t=1}^{T} P(x_t|x_1,\ldots,x_{t-1}) }

简写为:

\boxed{ P(X)=\prod_{t=1}^{T}P(x_t|x_{<t}) }

其中:

x_{<t}=(x_1,x_2,\ldots,x_{t-1})

表示当前位置之前的所有 Token。

这就是自回归语言模型(Autoregressive Language Model)的基本概率分解形式。

它将整个序列的联合概率,分解为一系列条件概率。

例如:

Token 序列:
我 喜欢 学习 AI

对应的条件概率:
P(我)
P(喜欢 | 我)
P(学习 | 我, 喜欢)
P(AI | 我, 喜欢, 学习)

模型需要学习每一个位置的条件概率分布。

这里的 P(x_1) 可以理解为序列第一个 Token 的概率,实际训练中通常通过 BOS(Beginning of Sequence)等起始标记统一处理。

3.2 条件概率分布是什么?

假设模型已经看到:

我喜欢

接下来可能出现很多 Token:

候选 Token 预测概率
你 0.25
学习 0.20
人工 0.15
编程 0.10
其他 Token 0.30

这些概率构成一个条件概率分布:

P(x_t|x_{<t})

模型并不是直接输出一个确定答案,而是为词表中的每个 Token 计算一个分数,再将这些分数转换为概率。

因此,Next Token Prediction 的本质是:

根据已有上下文,估计词表中每个 Token 成为下一个 Token 的条件概率。

3.3 为什么叫自回归?

Autoregressive,中文称为自回归。

它的核心特点是:

当前预测依赖之前已经出现的内容,而新生成的结果又会成为后续预测的输入。

例如:

初始输入:
今天天气

第一次预测:
很好

第二次预测:
,适合

第三次预测:
出去

第四次预测:
散步。

生成过程中,每个新 Token 都会进入后续上下文。

flowchart TB
    A["输入已有 Token 序列"] --> B["计算上下文表示"]
    B --> C["预测下一个 Token"]
    C --> D["选择或采样 Token"]
    D --> E["追加到序列"]
    E --> F{"是否达到停止条件"}
    F -->|"否"| B
    F -->|"是"| G["生成结束"]
    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#E5F0E9,stroke:#83A995,color:#315D49

这就是自回归生成的基本机制。

四、模型如何计算下一个 Token 的概率?

理解 Next Token Prediction,需要进一步理解 Transformer 内部的计算过程。

一个典型 Decoder-only 大语言模型,会将输入 Token 转换为隐藏向量,再经过多层 Transformer Block,最终计算词表上的预测概率。

4.1 Token ID 转换为 Embedding

首先,文本经过 Tokenizer,得到 Token ID。

例如:

原始文本:
我喜欢 AI

Token:
["我", "喜欢", "AI"]

Token ID:
[1024, 2587, 912]

这里的 ID 仅为示意,不代表某个真实模型的词表编号。

模型通过 Embedding 矩阵将 Token ID 转换为向量:

e_t=Embedding(x_t)

假设模型隐藏维度为 4096,那么每个 Token 会映射为一个 4096 维向量。

输入序列可以表示为:

E\in\mathbb{R}^{B\times T\times d_{model}}

其中:

  • B:Batch Size。
  • T:序列长度。
  • d_{model}:隐藏层维度。

4.2 Transformer 提取上下文表示

Embedding 并不包含完整的上下文信息。

模型需要通过多层 Transformer Block,让不同 Token 之间建立联系。

一个典型 Decoder-only Block 包含:

  • Causal Self-Attention。
  • Feed Forward Network。
  • Residual Connection。
  • LayerNorm 或 RMSNorm。

其中,Causal Self-Attention 负责根据当前位置之前的 Token 计算上下文信息。

经过多层 Transformer 后,得到隐藏状态:

H=Transformer(E)

其中:

H\in\mathbb{R}^{B\times T\times d_{model}}

每个位置的隐藏状态都包含该位置能够访问的上下文信息。

例如,位置 3 的隐藏状态可以利用位置 1、2、3 的信息,但不能利用位置 4 及之后的内容。

4.3 隐藏状态映射为 Logits

Transformer 输出的隐藏状态还不是概率。

需要通过一个输出投影层,将隐藏维度映射到词表大小:

\boxed{ Z=HW_{vocab}+b }

其中:

  • H:Transformer 隐藏状态。
  • W_{vocab}:输出投影矩阵。
  • b:可选偏置项。
  • Z:Logits。

假设:

d_{model}=4096

词表大小:

V=100000

那么输出投影矩阵的形状通常为:

W_{vocab}\in\mathbb{R}^{4096\times100000}

每个位置会得到一个长度为 100000 的 Logits 向量。

它表示词表中每个 Token 对应的未归一化分数。

需要注意,部分模型会采用 Embedding 与输出投影权重共享(Weight Tying),此时输入 Embedding 和输出投影并不是两套完全独立的参数。

4.4 Softmax 将 Logits 转换为概率

Logits 不是概率,因为它们可以是任意实数。

通过 Softmax 函数,可以将其转换为概率分布:

\boxed{ P(x_t=i|x_{<t}) = \frac{e^{z_i}} {\sum_{j=1}^{V}e^{z_j}} }

其中:

  • z_i:第 i 个 Token 的 Logit。
  • V:词表大小。
  • P(x_t=i|x_{<t}):该 Token 成为下一个 Token 的预测概率。

Softmax 输出满足:

0\leq P(x_t=i|x_{<t})\leq1

并且:

\sum_{i=1}^{V}P(x_t=i|x_{<t})=1

例如:

Token Logit Softmax 概率
好 5.2 0.65
不错 4.1 0.20
很好 3.0 0.10
其他 — 0.05

上表为示意数据。

模型通过这个概率分布表达对不同候选 Token 的预测倾向。

4.5 完整计算流程

flowchart TB
    A["输入文本"] --> B["Tokenizer"]
    B --> C["Token ID"]
    C --> D["Token Embedding"]
    D --> E["Decoder-only Transformer"]
    E --> F["上下文隐藏状态"]
    F --> G["Linear 输出投影"]
    G --> H["Logits"]
    H --> I["Softmax"]
    I --> J["下一个 Token 概率分布"]
    J --> K["选择或采样 Token"]
    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#E5F0E9,stroke:#83A995,color:#315D49

五、训练阶段:模型如何学会预测下一个 Token?

推理阶段是模型根据上下文生成 Token。

训练阶段则是给模型大量文本,让它不断预测真实的下一个 Token,并根据预测误差调整参数。

5.1 训练样本如何构造?

假设训练文本为:

我 喜欢 学习 人工智能

经过 Tokenizer 后,得到:

X=[x_1,x_2,x_3,x_4]

训练时可以构造:

输入上下文 预测目标
我 喜欢
我 喜欢 学习
我 喜欢 学习 人工智能

模型需要在每个有效位置预测下一个 Token。

实际训练中通常不会为每个位置单独运行一次模型,而是将整段序列一次性输入,通过因果注意力 Mask 并行计算所有位置。

5.2 为什么训练时可以并行计算?

这是一个非常重要的工程问题。

自回归生成看起来是逐 Token 进行的,但训练并不需要逐 Token 地执行完整前向计算。

原因在于:

训练文本已经完整存在,所有 Token 都已知。

模型可以一次性输入整个序列,同时通过 Causal Mask 限制每个位置能够访问的信息。

例如,序列长度为 4:

Token:
A B C D

注意力可见范围:

1 0 0 0
1 1 0 0
1 1 1 0
1 1 1 1

虽然输入中包含完整序列,但:

  • 位置 A 只能访问 A。
  • 位置 B 只能访问 A、B。
  • 位置 C 只能访问 A、B、C。
  • 位置 D 可以访问 A、B、C、D。

因此,所有位置的预测可以在同一次前向传播中并行计算,同时不泄漏未来信息。

这也是 Transformer 训练效率较高的重要原因之一。

5.3 Teacher Forcing

在自回归语言模型训练中,通常采用 Teacher Forcing。

它的核心思想是:

训练每个位置时,使用数据集中的真实历史 Token,而不是模型刚刚预测出来的 Token。

例如:

完整序列:
<BOS> 我 喜欢 AI <EOS>

模型输入:
<BOS> 我 喜欢 AI

训练标签:
我 喜欢 AI <EOS>

模型在每个位置都根据真实历史上下文预测下一个 Token。

这种方式能够避免训练初期预测错误不断累积,使模型更稳定地学习条件概率分布。

需要区分:

  • Teacher Forcing:训练时使用真实历史 Token。
  • Autoregressive Generation:推理时使用模型已经生成的 Token。

两者的上下文来源不同。

六、损失函数:如何衡量预测是否正确?

Next Token Prediction 通常使用交叉熵损失(Cross Entropy Loss)。

模型预测的是一个概率分布,训练数据提供的是实际出现的下一个 Token。

损失函数衡量模型给真实 Token 分配的概率是否足够高。

6.1 单个 Token 的交叉熵损失

假设真实下一个 Token 是:

人工智能

模型预测概率:

Token 概率
人工智能 0.8
机器学习 0.1
深度学习 0.05
其他 0.05

真实 Token 对应的概率为:

P(y|context)=0.8

单个 Token 的交叉熵损失:

\boxed{ L=-\log P(y|context) }

因此:

L=-\log(0.8)\approx0.223

如果模型给真实 Token 的概率只有 0.01:

L=-\log(0.01)\approx4.605

真实 Token 的预测概率越低,损失越大。

6.2 为什么使用负对数?

对数函数具有以下性质:

  • 概率越接近 1,负对数越接近 0。
  • 概率越接近 0,负对数越大。
  • 可以将多个条件概率的乘积转化为对数求和。

根据联合概率:

P(X)=\prod_{t=1}^{T}P(x_t|x_{<t})

取负对数:

-\log P(X) = -\sum_{t=1}^{T} \log P(x_t|x_{<t})

因此,整个序列的负对数似然可以写成每个 Token 预测损失的累加。

6.3 整个序列的训练损失

对于长度为 T 的序列:

\boxed{ L_{NTP} = -\sum_{t=1}^{T} \log P(x_t|x_{<t}) }

实际训练中,通常会对有效 Token 的损失取平均:

\boxed{ L_{NTP} = -\frac{1}{N} \sum_{t\in\mathcal{V}} \log P(x_t|x_{<t}) }

其中:

  • \mathcal{V}:参与损失计算的有效位置集合。
  • N:有效 Token 数量。

对于 Padding Token 或不参与训练的位置,可以通过 Label Mask 排除。

6.4 从损失到模型参数更新

损失函数计算出预测误差之后,还需要通过反向传播计算模型参数的梯度。

优化器根据梯度更新参数,使模型逐渐提高真实 Token 的预测概率。

flowchart TB
    A["输入训练 Token 序列"] --> B["Transformer 前向传播"]
    B --> C["得到各位置 Logits"]
    C --> D["计算交叉熵损失"]
    D --> E["反向传播"]
    E --> F["计算模型参数梯度"]
    F --> G["优化器更新参数"]
    G --> H{"是否继续训练"}
    H -->|"是"| A
    H -->|"否"| I["得到训练后的模型"]
    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49

需要注意:

  • 反向传播负责计算梯度。
  • 优化器负责根据梯度更新参数。
  • 交叉熵负责衡量预测结果与真实标签之间的差异。

三者是训练流程中的不同环节。