一、为什么要区分 Prefill 与 Decode?
大语言模型通常采用自回归生成方式,每次根据已有上下文预测下一个 Token。
假设用户输入:
解释一下 Transformer 的工作原理。
模型需要先处理整段输入,再开始生成回答。
这两个过程在计算方式上存在明显区别:
- Prefill(预填充阶段):处理完整 Prompt,计算各层的注意力和隐藏状态,并建立 KV Cache。
- Decode(解码阶段):基于已有 KV Cache,每次处理新生成的 Token,逐步生成后续内容。
二者虽然使用同一套模型参数,但执行方式、计算并行度、硬件资源需求和性能瓶颈并不相同。
二、Prefill 阶段:并行处理输入上下文
1. Prefill 的核心任务
Prefill 的主要工作是将用户输入的 Prompt 转换为模型能够处理的张量,并完成 Transformer 各层的前向计算。
假设输入经过 Tokenizer 后得到:
[101, 205, 318, 420, 512, 630]
输入序列长度为 6。
模型会一次性处理这 6 个 Token,而不是像 Decode 一样逐个处理。
Prefill 主要完成以下任务:
- 将 Token ID 转换为 Embedding。
- 为输入序列添加位置信息,例如 RoPE。
- 通过 Transformer 各层的 Self-Attention 和 FFN。
- 在每一层计算并保存 Key、Value。
- 使用最后一个有效位置的隐藏状态预测第一个输出 Token。
2. Prefill 的执行流程
flowchart TB
A["用户输入 Prompt"] --> B["Tokenizer 编码"]
B --> C["生成 Token IDs"]
C --> D["Embedding 与位置信息"]
D --> E["Transformer 第 1 层"]
E --> F["计算 Q、K、V"]
F --> G["Self-Attention 与 FFN"]
G --> H["保存本层 K、V 到 KV Cache"]
H --> I["继续执行后续 Transformer 层"]
I --> J["得到最后位置的隐藏状态"]
J --> K["LM Head 计算 Logits"]
K --> L["生成第一个输出 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:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style K fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style L fill:#E5F0E9,stroke:#83A995,color:#315D49
注意:每一层都会分别计算自己的 K、V,并将其写入对应层的 KV Cache。KV Cache 不是只在最后一层生成,而是贯穿整个 Transformer 网络。
3. 为什么 Prefill 可以并行计算?
这是理解 Prefill 与 Decode 差异的关键。
在 Prefill 阶段,输入序列中的所有 Token 都已经确定。
虽然 Decoder-only Transformer 使用因果注意力(Causal Attention),限制每个 Token 只能关注当前位置及之前的位置,但这并不意味着必须按 Token 顺序执行计算。
例如,输入序列:
Token 1: I
Token 2: love
Token 3: AI
Token 4: technology
因果注意力允许:
- Token 1 关注 Token 1。
- Token 2 关注 Token 1、Token 2。
- Token 3 关注 Token 1、Token 2、Token 3。
- Token 4 关注 Token 1、Token 2、Token 3、Token 4。
各位置的注意力计算可以通过矩阵运算并行完成。
因果约束通过 Attention Mask 实现,而不是通过串行执行实现。
其注意力矩阵可以表示为:
其中:
- Q:所有输入位置的 Query。
- K:所有输入位置的 Key。
- d_k:Key 向量维度。
- M:因果注意力掩码。
- A:注意力权重矩阵。
对于未来位置,掩码对应的值为负无穷,使 Softmax 后的权重为零。
因果 Mask 的结构示意:
flowchart TB
A["输入序列"] --> B["并行计算所有位置的 Q、K、V"]
B --> C["计算 QKᵀ 注意力分数"]
C --> D["应用 Causal Mask"]
D --> E["Softmax 得到注意力权重"]
E --> F["加权聚合 V"]
F --> G["得到各位置的输出"]
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:#F7F4E8,stroke:#C7B77A,color:#675A2D
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#E5F0E9,stroke:#83A995,color:#315D49
因此,Prefill 可以充分利用 GPU 的矩阵并行计算能力。
4. Prefill 的计算复杂度
设:
- B:Batch Size。
- S:输入序列长度。
- d:模型隐藏维度。
- L:Transformer 层数。
对于标准 Transformer,主要计算量可以粗略分为两部分:
线性投影与 FFN:
Self-Attention:
因此,整体计算复杂度可近似表示为:
当序列长度 S 增长时,注意力计算中的二次项会变得越来越重要。
需要注意:
- 这是标准稠密注意力的近似计算复杂度。
- FlashAttention 可以优化显存访问和中间结果存储,但不会改变标准全注意力的主要渐近计算复杂度。
- GQA、MQA、稀疏注意力等结构可能改变具体计算与存储开销。
5. Prefill 的性能特点
Prefill 通常具有较高的计算并行度。
它可以将大量 Token 的矩阵运算组织成较大的 GPU Kernel,充分利用 GPU 的计算单元和 Tensor Core。
但 Prefill 也存在明显的资源压力:
- 输入序列越长,Attention 计算量越大。
- Batch Size 越大,整体计算与激活内存需求越高。
- 每一层都需要生成并保存 K、V。
- 长上下文可能导致 KV Cache 占用大量显存。
因此,Prefill 阶段通常更容易受到计算能力和显存带宽等因素的影响,具体瓶颈取决于模型、序列长度、Batch Size 和硬件。
三、Decode 阶段:逐 Token 生成输出
1. Decode 的核心任务
Prefill 完成后,模型已经拥有输入 Prompt 对应的 KV Cache。
接下来进入 Decode 阶段。
Decode 的核心任务是:
- 接收上一步生成的 Token。
- 计算该 Token 在各层的 Query、Key、Value。
- 使用历史 KV Cache 计算注意力。
- 将当前 Token 的 K、V 追加到缓存。
- 得到当前 Token 的隐藏状态。
- 通过 LM Head 预测下一个 Token。
与 Prefill 最大的区别是:
Decode 通常每一步只处理一个新 Token,而不是重新计算整个历史序列。
2. Decode 的执行流程
flowchart TB
A["Prefill 完成"] --> B["已有历史 KV Cache"]
B --> C["输入当前 Token"]
C --> D["Embedding 与位置编码"]
D --> E["逐层执行 Transformer"]
E --> F["计算当前 Token 的 Q、K、V"]
F --> G["读取历史 KV Cache"]
G --> H["计算当前 Token 对历史上下文的注意力"]
H --> I["追加当前 Token 的 K、V"]
I --> J["得到当前 Token 的隐藏状态"]
J --> K["LM Head 计算 Logits"]
K --> L["采样或选择下一个 Token"]
L --> M{"是否满足停止条件"}
M -->|"否"| C
M -->|"是"| N["输出生成结果"]
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:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
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:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style K fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style L fill:#EAF3EC,stroke:#83A995,color:#315D49
style M fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style N fill:#E5F0E9,stroke:#83A995,color:#315D49
这里有一个容易混淆的地方:
Decode 阶段每生成一个 Token,都需要经过模型的所有 Transformer 层,而不是只经过最后一层。
每一层都会读取该层自己的历史 K、V,并计算当前 Token 的注意力结果。
3. Decode 为什么需要 KV Cache?
假设输入 Prompt 有 1000 个 Token,模型需要生成 100 个 Token。
如果不使用 KV Cache,每生成一个 Token,都需要重新处理此前的全部上下文。
其计算过程会重复计算大量历史 Token 的 Key 和 Value。
KV Cache 的核心作用就是保存历史 Token 在各层计算得到的 K、V,供后续生成直接复用。
假设当前已经生成:
Prompt: A B C D
Output: E F
下一步准备预测 G。
此时:
- A、B、C、D 的 K、V 已经保存在缓存中。
- E、F 的 K、V 也已经依次写入缓存。
- 当前输入是 F 对应的 Token 表示(实际执行时通常是上一步选出的最新 Token)。
- 模型计算当前 Token 的 Q、K、V。
- 当前 Query 与历史所有 Key 计算注意力。
- 当前 Value 被追加到缓存。
需要注意,生成第一个输出 Token 时,使用的是 Prefill 最后一个输入位置的隐藏状态。生成第二个输出 Token 时,才将第一个生成 Token 作为新的 Decode 输入。
4. Decode 的注意力计算
假设历史上下文长度为 T,当前只输入一个新 Token。
当前 Query 的形状可以简化为:
历史 Key 的形状为:
当前 Token 的注意力分数:
注意力输出:
这里不需要重新计算历史 Token 的 K、V。
每一层只需要计算当前 Token 的 Q、K、V,并读取对应层的缓存。
这就是 KV Cache 能够显著减少重复计算的原因。
5. Decode 的计算复杂度
对于单个新 Token,假设当前上下文长度为 T,隐藏维度为 d。
当前 Token 的线性投影与 FFN 计算量约为:
当前 Query 与历史 Key 的注意力计算量约为:
因此,单个 Token 在所有层的计算量可以近似表示为:
如果连续生成 N 个 Token,且不考虑输入 Prompt 的 Prefill 成本,注意力部分的累计计算量约为:
其中 S 是初始 Prompt 长度。
展开后:
KV Cache 避免了每一步重新计算历史 K、V,但并没有消除当前 Query 对历史 Key、Value 的注意力计算。
因此,随着上下文不断增长,Decode 每一步需要读取的 KV Cache 也会越来越大。
6. Decode 为什么容易受到显存带宽限制?
Decode 每一步通常只处理少量新 Token。
对于大模型而言,模型权重规模很大,但单步计算的数据量相对有限。
GPU 在执行 Decode 时,需要不断读取:
- 模型权重。
- 历史 KV Cache。
- 当前 Token 的中间激活。
- 其他推理所需的数据。
当计算单元等待数据从显存传输时,GPU 的计算能力可能无法得到充分利用。
这使 Decode 经常表现为显存带宽受限(Memory-Bound)。
尤其在 Batch Size 较小的情况下,单步矩阵计算规模有限,读取模型权重和 KV Cache 的成本可能占据较大比例。
但这并不是绝对规律:
- Batch Size 增大后,权重读取可以被多个请求共同利用,计算密度提高。
- 超长上下文会增加 KV Cache 读取量。
- 量化、GQA、MQA 和推理 Kernel 优化会改变计算与访存的平衡。
- 特定硬件和模型下,Decode 也可能受到计算能力限制。
四、Prefill 与 Decode 的核心区别
1. 执行机制对比
| 对比维度 | Prefill | Decode |
|---|---|---|
| 输入内容 | 完整 Prompt | 当前新 Token |
| 处理方式 | 多 Token 并行 | 通常逐 Token |
| Attention | 输入序列内部的因果注意力 | 当前 Token 对历史上下文注意力 |
| KV Cache | 创建并写入 Prompt 的 K、V | 读取历史缓存并追加新 K、V |
| 计算并行度 | 通常较高 | 单请求单步较低 |
| 主要压力 | 计算量、激活与显存 | 权重和 KV Cache 访存 |
| 输出 | 首个生成 Token 的预测结果 | 后续 Token 的预测结果 |
| 典型指标 | TTFT | TPOT |
这里的“逐 Token”是指单条自回归生成序列必须等待上一步 Token 确定后才能继续。推理服务仍然可以同时调度多个请求,也可以在一个 Batch 中处理多个序列。
2. 两个阶段的计算特征
Token 1 Token 2 Token 3 Token 4 Token 5
│ │ │ │ │
└────────┴────────┴────────┴────────┘
│
并行矩阵计算
│
建立 KV Cache
Token 1
│
▼
Token 2
│
▼
Token 3
│
▼
Token 4
│
▼
Token 5
实际生产推理系统中,多个请求的 Decode 可以通过 Continuous Batching 合并调度,因此不能将“单请求逐 Token”误解为“整个 GPU 一次只能处理一个 Token”。
3. 性能瓶颈对比
| 维度 | Prefill | Decode |
|---|---|---|
| 主要计算 | 大规模矩阵运算 | 小步增量计算 |
| GPU 利用率 | 通常较高 | 小 Batch 时可能较低 |
| 计算密度 | 通常较高 | 通常较低 |
| 显存带宽 | 重要 | 通常更加敏感 |
| 长上下文影响 | 注意力计算量增长明显 | KV Cache 读取量增长明显 |
| 优化方向 | 高效 Attention、批处理、分块计算 | KV Cache 管理、批处理、量化、访存优化 |
五、KV Cache:连接 Prefill 与 Decode 的关键机制
KV Cache 是两个阶段之间最重要的数据结构。
1. KV Cache 保存什么?
在 Transformer 的每一层中,Attention 会计算:
其中:
- X:当前层输入隐藏状态。
- W_Q:Query 投影矩阵。
- W_K:Key 投影矩阵。
- W_V:Value 投影矩阵。
推理时,历史 Token 的 K、V 会被保存起来。
KV Cache 的逻辑结构可以表示为:
其中 L 是 Transformer 层数。
每一层都维护自己的 K、V 缓存。
2. KV Cache 的增长规律
假设:
- Transformer 层数:L
- Batch Size:B
- 当前上下文长度:T
- KV Head 数量:H_{kv}
- 每个 Head 的维度:D
- 每个元素占用字节数:P
KV Cache 的显存占用约为:
其中系数 2 表示 Key 和 Value 两份缓存。
例如:
- 层数:32
- Batch Size:1
- 上下文长度:8192
- KV Head 数量:32
- Head Dimension:128
- 数据类型:FP16,每个元素 2 Bytes
则:
约为 4 GiB。
这意味着,仅一个请求的 KV Cache 就可能占用数 GiB 显存。
如果使用 GQA 或 MQA,KV Head 数量会减少,KV Cache 占用也会相应降低。
实际显存还会受到缓存分配策略、对齐、分页、批处理和框架实现影响。
3. Prefill 与 Decode 如何共享 KV Cache?
flowchart TB
A["输入 Prompt"] --> B["Prefill"]
B --> C["计算所有输入 Token 的 K、V"]
C --> D["写入各层 KV Cache"]
D --> E["Decode 开始"]
E --> F["读取历史 KV Cache"]
F --> G["计算当前 Token 的 Q、K、V"]
G --> H["追加当前 Token 的 K、V"]
H --> I["更新 KV Cache"]
I --> J["下一轮 Decode"]
J --> F
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:#DCEFE5,stroke:#4F8B70,color:#24563F
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
KV Cache 的生命周期通常与一次请求的生成过程绑定:
- Prefill 创建缓存。
- Decode 持续读取和追加缓存。
- 请求结束后,缓存可以释放或归还缓存池。
- 如果系统支持 Prefix Caching,部分共享前缀的 KV Cache 可以被复用,但必须保证模型、位置、注意力配置等条件兼容。
六、TTFT 与 TPOT:如何衡量两个阶段的性能?
理解 Prefill 与 Decode,还需要理解大模型推理服务的两个核心性能指标。