返回专栏
· 17 分钟阅读

Prefill 与 Decode 的执行机制:大模型推理的两个核心阶段


一、为什么要区分 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 主要完成以下任务:

  1. 将 Token ID 转换为 Embedding。
  2. 为输入序列添加位置信息,例如 RoPE。
  3. 通过 Transformer 各层的 Self-Attention 和 FFN。
  4. 在每一层计算并保存 Key、Value。
  5. 使用最后一个有效位置的隐藏状态预测第一个输出 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 实现,而不是通过串行执行实现。

其注意力矩阵可以表示为:

A = \operatorname{Softmax} \left( \frac{QK^T}{\sqrt{d_k}}+M \right)

其中:

  • 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:

O(BSd^2)

Self-Attention:

O(BS^2d)

因此,整体计算复杂度可近似表示为:

O\left(LB(Sd^2+S^2d)\right)

当序列长度 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 的核心任务是:

  1. 接收上一步生成的 Token。
  2. 计算该 Token 在各层的 Query、Key、Value。
  3. 使用历史 KV Cache 计算注意力。
  4. 将当前 Token 的 K、V 追加到缓存。
  5. 得到当前 Token 的隐藏状态。
  6. 通过 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 的形状可以简化为:

Q_{new}\in \mathbb{R}^{B\times 1\times d_k}

历史 Key 的形状为:

K_{cache}\in \mathbb{R}^{B\times T\times d_k}

当前 Token 的注意力分数:

Scores=\frac{Q_{new}K_{cache}^T}{\sqrt{d_k}}

注意力输出:

Attention(Q_{new},K_{cache},V_{cache}) = Softmax(Scores)V_{cache}

这里不需要重新计算历史 Token 的 K、V。

每一层只需要计算当前 Token 的 Q、K、V,并读取对应层的缓存。

这就是 KV Cache 能够显著减少重复计算的原因。

5. Decode 的计算复杂度

对于单个新 Token,假设当前上下文长度为 T,隐藏维度为 d。

当前 Token 的线性投影与 FFN 计算量约为:

O(d^2)

当前 Query 与历史 Key 的注意力计算量约为:

O(Td)

因此,单个 Token 在所有层的计算量可以近似表示为:

O\left(L(d^2+Td)\right)

如果连续生成 N 个 Token,且不考虑输入 Prompt 的 Prefill 成本,注意力部分的累计计算量约为:

O\left(Ld\sum_{t=1}^{N}(S+t)\right)

其中 S 是初始 Prompt 长度。

展开后:

O\left(Ld(NS+\frac{N(N+1)}{2})\right)

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. 两个阶段的计算特征

Prefill:序列维度并行

Token 1  Token 2  Token 3  Token 4  Token 5
   │        │        │        │        │
   └────────┴────────┴────────┴────────┘
                    │
              并行矩阵计算
                    │
              建立 KV Cache

Decode:单序列自回归生成

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 会计算:

Q=XW_Q
K=XW_K
V=XW_V

其中:

  • X:当前层输入隐藏状态。
  • W_Q:Query 投影矩阵。
  • W_K:Key 投影矩阵。
  • W_V:Value 投影矩阵。

推理时,历史 Token 的 K、V 会被保存起来。

KV Cache 的逻辑结构可以表示为:

KVCache= \{(K_1,V_1),(K_2,V_2),\ldots,(K_L,V_L)\}

其中 L 是 Transformer 层数。

每一层都维护自己的 K、V 缓存。

2. KV Cache 的增长规律

假设:

  • Transformer 层数:L
  • Batch Size:B
  • 当前上下文长度:T
  • KV Head 数量:H_{kv}
  • 每个 Head 的维度:D
  • 每个元素占用字节数:P

KV Cache 的显存占用约为:

M_{KV}=2L B T H_{kv} D P

其中系数 2 表示 Key 和 Value 两份缓存。

例如:

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

则:

M_{KV} = 2\times32\times1\times8192\times32\times128\times2
=4,294,967,296\ 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,还需要理解大模型推理服务的两个核心性能指标。