返回专栏
· 20 分钟阅读

大模型如何进行推理?从 Prompt 输入到 Token 生成的完整过程


一、什么是大模型推理?

大语言模型推理(Inference),是指使用已经训练完成的模型,根据用户提供的输入,计算输出结果的过程。

例如,用户输入:

请解释什么是 Transformer。

模型需要根据输入内容,生成一段合理的回答。

从计算角度看,大模型并不是直接理解问题后一次性写出完整答案,而是通过神经网络计算下一个 Token 的概率分布,再根据解码策略选择一个 Token,不断重复这个过程。

核心过程:

flowchart TB
    A["用户输入 Prompt"]
    B["Tokenizer 编码"]
    C["模型前向计算"]
    D["计算下一个 Token 的概率"]
    E["解码策略选择 Token"]
    F["追加到上下文"]
    G{"是否结束生成"}
    H["Tokenizer 解码"]
    I["返回完整回答"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G -->|"否"| C
    G -->|"是"| H
    H --> I

    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这里需要区分两个概念:

  • Training(训练):通过数据和优化算法更新模型参数。
  • Inference(推理):使用已经训练好的参数执行前向计算,生成预测结果。

常规推理不会更新模型权重。

不过,推理过程可能涉及 KV Cache、临时激活值、路由状态等运行时数据的创建和更新。这些变化不等于模型参数训练。


二、大模型推理的整体架构

以 Decoder-only Transformer 为例,一次推理主要经过以下几个部分:

  1. 输入处理:将文本转换为 Token ID。
  2. Embedding:将 Token ID 映射为向量。
  3. Transformer:通过多层 Attention 和 FFN 计算上下文表示。
  4. LM Head:将隐藏状态投影到词表维度,得到 Logits。
  5. Sampling / Decoding:根据概率分布选择下一个 Token。
  6. 循环生成:将新 Token 追加到上下文,继续计算。

整体结构:

flowchart TB
    A["输入文本 Prompt"]
    B["Tokenizer"]
    C["Token IDs"]
    D["Token Embedding"]
    E["Transformer Layers"]
    F["Final Normalization"]
    G["LM Head"]
    H["Logits"]
    I["Softmax"]
    J["Decoding / Sampling"]
    K["Next Token"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    H --> I
    I --> J
    J --> K

    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意:

  • Tokenizer 不属于 Transformer 神经网络主体。
  • Embedding 负责将离散 Token ID 转换为连续向量。
  • Transformer 负责上下文信息计算。
  • LM Head 将隐藏状态映射为词表上的预测分数。
  • Softmax 将 Logits 转换为概率分布。
  • 解码策略负责从概率分布中选择实际输出的 Token。

接下来逐步拆解。


三、第一步:Prompt 如何进入模型?

1. 文本经过 Tokenizer

模型不能直接处理原始字符串,需要先通过 Tokenizer 将文本切分为 Token,再映射为整数 ID。

例如:

输入:
人工智能正在改变世界

可能被编码为:

Token:
["人工", "智能", "正在", "改变", "世界"]

Token ID:
[1024, 5832, 219, 4381, 765]

以上仅为示意,实际 Token 切分和 ID 取决于模型使用的词表。

Token ID 是词表中的索引,不代表 Token 的语义大小关系。

2. Token ID 转换为 Embedding

假设:

  • 词表大小为 V。
  • 隐藏维度为 d。
  • 输入 Token 数量为 T。

Embedding 矩阵:

E\in\mathbb{R}^{V\times d}

输入 Token ID:

X=[x_1,x_2,\ldots,x_T]

模型通过 Embedding 查表,得到:

H_0=E[X]

最终:

H_0\in\mathbb{R}^{T\times d}

如果采用 RoPE 等位置编码机制,位置信息会在后续 Attention 计算中注入;其他模型也可能采用不同的位置表示方式。

3. Batch 维度

实际推理通常不是只处理一条输入,而是将多条请求组织成 Batch。

假设:

  • Batch Size:B。
  • 序列长度:T。
  • Hidden Size:d。

那么输入隐藏状态的形状通常是:

H_0\in\mathbb{R}^{B\times T\times d}

其中:

维度 含义
B Batch 中的请求数量
T Token 序列长度
d 每个 Token 的隐藏向量维度

在实际推理系统中,不同请求的输入长度可能不同,因此还需要处理 Padding、序列长度管理和动态批处理等问题。


四、第二步:Transformer 如何计算上下文信息?

Token Embedding 进入 Transformer 后,需要经过多层神经网络计算。

以典型 Decoder-only Transformer 为例,每层主要包含:

  • Causal Self-Attention。
  • FFN 或 MoE。
  • 残差连接。
  • LayerNorm 或 RMSNorm。

1. Self-Attention

Self-Attention 负责让当前 Token 获取上下文中其他 Token 的信息。

输入隐藏状态:

H\in\mathbb{R}^{T\times d}

通过三个线性投影得到:

Q=HW_Q
K=HW_K
V=HW_V

其中:

  • Q(Query):查询向量。
  • K(Key):键向量。
  • V(Value):值向量。

注意力计算:

Attention(Q,K,V) = Softmax\left( \frac{QK^T}{\sqrt{d_k}}+M \right)V

其中:

  • d_k:Key 的维度。
  • M:因果注意力掩码。
  • QK^T:计算 Token 之间的相关性分数。

因果掩码保证当前位置只能访问自己及之前的位置,不能访问未来 Token。

例如:

Token 序列:

我    喜欢    人工智能    技术

每个位置可访问的信息:

当前 Token 可以访问的 Token
我 我
喜欢 我、喜欢
人工智能 我、喜欢、人工智能
技术 我、喜欢、人工智能、技术

这就是 Decoder-only 模型的 Causal Attention。

2. FFN 前馈网络

Attention 负责 Token 之间的信息交互,FFN 则负责对每个位置的隐藏表示进行非线性变换。

典型 FFN:

FFN(x)=W_2\sigma(W_1x+b_1)+b_2

它通常由升维投影、激活函数和降维投影组成。

例如:

4096\rightarrow14336\rightarrow4096

实际模型可能采用 SwiGLU 等门控前馈结构,而不一定使用简单的两层 FFN。

3. 多层 Transformer 计算

一个 Transformer 层的计算结果会传递给下一层。

flowchart TB
    A["输入隐藏状态"]
    B["归一化"]
    C["Causal Self-Attention"]
    D["残差连接"]
    E["归一化"]
    F["FFN / MoE"]
    G["残差连接"]
    H["输出隐藏状态"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49

假设模型有 32 层 Transformer,那么输入隐藏状态会经过 32 层计算。

最终得到:

H_{final}\in\mathbb{R}^{B\times T\times d}

其中包含每个 Token 在当前上下文下的最终隐藏表示。


五、第三步:LM Head 如何预测下一个 Token?

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

模型需要通过 LM Head 将隐藏向量映射到词表空间。

1. 隐藏状态映射到 Logits

假设:

  • 隐藏维度为 d。
  • 词表大小为 V。

LM Head 的权重矩阵:

W_{lm}\in\mathbb{R}^{d\times V}

对于最后一个位置的隐藏状态:

h_T\in\mathbb{R}^{d}

计算:

z=h_TW_{lm}+b

得到:

z\in\mathbb{R}^{V}

这个向量称为 Logits。

Logits 表示模型对词表中每个 Token 的未归一化预测分数。

例如,词表有 100000 个 Token,那么 Logits 就包含 100000 个分数。

2. Softmax 转换为概率

Logits 本身不是概率,需要经过 Softmax:

P(x_{T+1}=i|x_{\leq T}) = \frac{e^{z_i}}{\sum_{j=1}^{V}e^{z_j}}

得到下一个 Token 的概率分布。

示例:

候选 Token Logits(示意) 概率(示意)
是 3.2 45%
的 2.4 20%
一个 1.8 12%
模型 1.2 7%
其他 Token — 16%

实际概率需要由完整词表的 Logits 计算,这里仅展示部分候选项。

3. 为什么模型不是直接输出最高概率 Token?

如果每次都选择概率最高的 Token,就属于 Greedy Decoding。

但实际推理可以采用不同的解码策略,例如:

  • Greedy Search。
  • Temperature Sampling。
  • Top-K Sampling。
  • Top-P Sampling。
  • Beam Search。

这些策略会影响最终生成结果的确定性、多样性和计算开销。


六、第四步:解码策略如何决定生成内容?

模型完成前向计算后,会得到一个 Token 概率分布。

接下来需要根据解码策略选择下一个 Token。

1. Greedy Decoding

贪心解码每次选择概率最大的 Token:

x_{t+1}=\arg\max_i P(x_i|x_{\leq t})

优点:

  • 实现简单。
  • 生成结果确定。
  • 不需要随机采样。

缺点:

  • 容易产生重复或局部最优结果。
  • 生成多样性不足。
  • 不保证整体序列概率最优。

2. Temperature Sampling

Temperature 用于调整概率分布的平滑程度。

公式:

P_i= \frac{\exp(z_i/T)}

其中:

  • z_i:原始 Logit。
  • T:Temperature。

不同 Temperature 的影响:

Temperature 影响
T<1 概率分布更加尖锐
T=1 保持原始 Softmax 分布
T>1 概率分布更加平滑

一般来说:

  • 较低 Temperature:输出更稳定、更保守。
  • 较高 Temperature:输出更随机、多样性更高。

但 Temperature 不会增加模型知识,也不能保证回答更准确。

3. Top-K Sampling

Top-K 只保留概率最高的 K 个 Token,再对它们重新归一化并采样。

例如:

原始候选:

Token A:40%
Token B:25%
Token C:15%
Token D:10%
Token E:10%

如果:

K=3

则只保留:

  • Token A。
  • Token B。
  • Token C。

其余候选被排除,剩余概率重新归一化。

4. Top-P Sampling

Top-P 也叫 Nucleus Sampling。

它按照概率从高到低排列 Token,选择累计概率达到阈值 P 的最小候选集合。

例如:

Token A:40%
Token B:25%
Token C:15%
Token D:10%
Token E:10%

如果:

P=0.8

则候选集合为:

  • Token A:40%。
  • Token B:25%。
  • Token C:15%。

累计概率达到 80%,后续 Token 不再参与采样。

5. 不同解码策略的比较

策略 核心机制 主要特点
Greedy 选择最高概率 Token 确定性强
Temperature 调整概率分布 控制随机性
Top-K 保留前 K 个候选 限制候选范围
Top-P 保留累计概率达到阈值的候选 动态调整候选数量
Beam Search 保留多个候选序列 进行序列级搜索

需要注意:

  • Temperature 可以与 Top-K、Top-P 组合使用。
  • Top-K 和 Top-P 也可以组合使用。
  • Beam Search 与常见随机采样策略的目标和实现不同。

七、第五步:为什么大模型需要 KV Cache?

如果每生成一个 Token,都重新计算整个历史序列的 Attention,那么推理成本会非常高。

这就是 KV Cache 需要解决的问题。

1. 没有 KV Cache 会发生什么?

假设输入 Prompt 有 1000 个 Token。

模型生成第一个 Token 时,需要处理这 1000 个 Token。

生成第二个 Token 时,历史长度变成 1001。

如果没有缓存机制,模型需要重新计算历史 Token 对应的 Key 和 Value。

随着生成长度增加,历史计算会被反复执行。

这会产生大量重复计算。

2. KV Cache 的核心思想

在 Transformer 的 Self-Attention 中,每个 Token 都会计算:

Q_t,\quad K_t,\quad V_t

其中:

  • Q:Query。
  • K:Key。
  • V:Value。

在自回归生成过程中,历史 Token 的 K 和 V 不会因为新 Token 的加入而改变,前提是模型参数、历史 Token 和位置等计算条件保持不变。

因此,可以缓存已经计算过的 K 和 V。

生成新 Token 时,只需要计算当前 Token 的 Q、K、V,并将新 K、V 追加到缓存中。

3. KV Cache 工作流程

flowchart TB
    A["输入 Prompt"]
    B["Prefill 计算"]
    C["生成历史 K / V"]
    D["保存 KV Cache"]
    E["输入最新 Token"]
    F["计算当前 Q / K / V"]
    G["读取历史 KV Cache"]
    H["执行 Attention"]
    I["生成下一个 Token"]
    J["追加当前 K / V"]
    K{"是否继续生成"}

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    H --> I
    I --> J
    J --> K
    K -->|"是"| E
    K -->|"否"| L["结束推理"]

    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49
    style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. KV Cache 的显存开销

KV Cache 能减少重复计算,但需要额外显存保存历史 K 和 V。

一个简化的显存估算公式:

M_{KV} = 2\times L\times B\times T\times H_{KV}\times D_{head}\times S

其中:

  • L:Transformer 层数。
  • B:Batch Size。
  • T:缓存序列长度。
  • H_{KV}:Key/Value Head 数量。
  • D_{head}:每个 KV Head 的维度。
  • S:每个元素占用的字节数。
  • 2:分别表示 Key 和 Value。

例如:

  • 层数:32。
  • Batch Size:1。
  • 上下文长度:8192。
  • KV Head 数量:32。
  • Head Dimension:128。
  • 数据类型:FP16,每个元素 2 字节。

那么:

M_{KV} = 2\times32\times1\times8192 \times32\times128\times2

约为:

4\text{ GiB}

这是单个请求、完整 KV Cache 的理论估算值,未包含框架管理开销、内存对齐和其他缓存。

如果采用 GQA 或 MQA,KV Head 数量会减少,KV Cache 通常也会显著降低。

5. KV Cache 的局限

KV Cache 不是没有成本。

它会:

  • 占用额外 GPU 显存。
  • 随上下文长度增长。
  • 随并发请求数量增加。
  • 增加缓存分配和管理复杂度。

因此,大模型推理框架通常需要结合:

  • PagedAttention。
  • Continuous Batching。
  • KV Cache 量化。
  • GQA / MQA。
  • Prefix Caching。

这些技术进一步优化推理系统。


八、第六步:Prefill 与 Decode 是什么?

大模型推理通常分成两个主要阶段:

  1. Prefill(预填充)。
  2. Decode(逐 Token 解码)。

两者的计算特征有明显区别。

1. Prefill 阶段

Prefill 负责处理完整的输入 Prompt。

例如:

请解释 Transformer 的注意力机制,并说明它为什么能够处理长距离依赖。

Tokenizer 将其转换成一组 Token ID。

模型对整段 Prompt 进行前向计算,得到每个位置的隐藏状态,并生成各层对应的 K、V 缓存。

Prefill 阶段的特点:

  • 一次处理多个输入 Token。
  • 可以并行计算序列中不同位置的表示。
  • 需要执行大量矩阵运算。
  • Attention 计算与输入序列长度密切相关。
  • 为后续 Decode 阶段建立 KV Cache。

虽然 Causal Mask 限制了每个位置能够访问的上下文,但不同位置的计算仍然可以通过矩阵运算并行执行。

2. Decode 阶段

Prefill 完成后,模型开始逐步生成 Token。

例如:

Prompt:
Transformer 是一种

生成:
神经
网络
架构
。

每次 Decode 通常只需要处理最新生成的 Token。

模型利用 KV Cache 读取历史 K、V,完成当前 Token 的 Attention 计算,然后预测下一个 Token。

Decode 阶段的特点:

  • 自回归生成。
  • 通常逐 Token 执行。
  • 依赖前一步生成结果。
  • 使用 KV Cache 避免重复计算历史 K、V。
  • 对内存带宽、缓存访问和单步延迟较为敏感。

3. Prefill 与 Decode 对比

对比维度 Prefill Decode
输入 完整 Prompt 最新 Token
计算方式 多 Token 并行 逐步生成
主要目标 处理输入上下文 生成后续 Token
KV Cache 建立缓存 读取并追加缓存
计算特征 大规模矩阵计算 小批量增量计算
性能关注 Prompt 处理吞吐量 Token 生成延迟与吞吐量

4. 两个阶段的完整关系

flowchart TB
    A["用户提交 Prompt"]
    B["Tokenizer 编码"]
    C["Prefill 阶段"]
    D["计算 Prompt 全部 Token"]
    E["建立 KV Cache"]
    F["Decode 阶段"]
    G["读取 KV Cache"]
    H["生成下一个 Token"]
    I["更新 KV Cache"]
    J{"是否达到结束条件"}
    K["返回最终文本"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    H --> I
    I --> J
    J -->|"否"| F
    J -->|"是"| K

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意,Prefill 和 Decode 是计算阶段的划分,不是两个不同的模型。

它们使用同一套模型参数,只是输入形态和计算方式不同。


九、第七步:大模型什么时候停止生成?

模型不是无限生成 Token,需要有明确的停止条件。

常见停止方式包括:

1. EOS Token

EOS(End of Sequence)是序列结束标记。

当模型生成 EOS Token 时,推理系统可以判断当前生成任务结束。

不同模型可能使用不同的结束 Token 或特殊 Token。

2. 最大生成长度

推理接口通常支持:

max_new_tokens = 1024

表示最多生成 1024 个新 Token。

即使模型没有生成 EOS,也会在达到长度限制后停止。

3. Stop Sequences

部分推理接口支持自定义停止字符串。

例如:

<END>

当输出满足停止条件时,系统终止当前生成。

具体实现可能在 Token 级别或文本解码后检查停止条件。

4. 其他停止条件

还可能包括:

  • 请求取消。
  • 超时。
  • 服务端资源限制。
  • 特定结构化输出的结束标记。

5. 完整停止判断

flowchart TB
    A["生成一个 Token"]
    B{"是否生成 EOS"}
    C{"是否达到 max_new_tokens"}
    D{"是否匹配 Stop Sequence"}
    E{"请求是否取消"}
    F["继续生成"]
    G["结束生成"]

    A --> B
    B -->|"是"| G
    B -->|"否"| C
    C -->|"是"| G
    C -->|"否"| D
    D -->|"是"| G
    D -->|"否"| E
    E -->|"是"| G
    E -->|"否"| F
    F --> A

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#E5F0E9,stroke:#83A995,color:#315D49