返回专栏
· 33 分钟阅读

模型推理引擎的工作原理


一、什么是模型推理引擎?

模型推理引擎(Inference Engine)是用于加载、执行和优化训练完成模型的软件系统。

它负责将用户输入转换为模型能够处理的张量,调度 GPU 完成计算,再将模型输出转换为用户可以使用的结果。

简单来说,模型负责回答问题,推理引擎负责高效地运行模型。

例如,用户向大模型发送一条请求:

请解释什么是 RAG,并给出一个简单示例。

推理引擎需要完成:

  1. 接收请求并解析输入。
  2. 使用 Tokenizer 将文本转换为 Token。
  3. 将 Token 转换为模型输入张量。
  4. 将输入提交给 GPU。
  5. 执行 Transformer 各层计算。
  6. 缓存历史 Token 对应的 Key 和 Value。
  7. 根据概率分布选择下一个 Token。
  8. 重复执行生成过程,直到满足停止条件。
  9. 将 Token 解码为文本并返回。

整体过程:

flowchart TD
    A["用户发送请求"] --> B["推理服务接收请求"]
    B --> C["Tokenizer 编码"]
    C --> D["构造模型输入"]
    D --> E["GPU 执行模型计算"]
    E --> F["生成下一个 Token"]
    F --> G{"是否满足停止条件"}
    G -->|"否"| E
    G -->|"是"| H["Tokenizer 解码"]
    H --> I["返回生成结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

1. 推理引擎与模型的区别

模型和推理引擎是两个不同的概念。

对比维度 模型 推理引擎
核心职责 学习和表达知识 执行模型计算
主要内容 网络结构、权重参数 调度、内存管理、算子执行
输入 Token、张量 请求、模型输入
输出 Logits、隐藏状态等 最终生成结果
关注重点 模型能力与质量 延迟、吞吐量、显存和稳定性
典型组成 Transformer、权重文件 Scheduler、Executor、KV Cache Manager

同一个模型可以通过不同推理引擎运行。

例如,同一个模型可以分别使用 Transformers、vLLM、SGLang 或 TensorRT-LLM 进行部署。

模型权重可能完全相同,但由于推理调度、算子实现和显存管理方式不同,最终性能可能存在明显差异。

2. 为什么需要专门的推理引擎?

直接使用深度学习框架运行模型虽然可行,但生产环境往往需要面对大量并发请求。

如果每个请求都独立执行模型计算,容易产生:

  • GPU 利用率不足。
  • 重复计算。
  • KV Cache 显存浪费。
  • 请求排队时间过长。
  • 多用户之间资源分配不合理。
  • 推理吞吐量不稳定。

推理引擎通过批处理、动态调度、缓存管理和算子优化,提高 GPU 资源利用率。

二、推理引擎的整体架构

一个完整的大模型推理引擎通常由多个模块组成。

1. 核心模块

模块 核心职责
API Server 接收外部请求
Request Manager 管理请求生命周期
Tokenizer 文本与 Token 转换
Scheduler 调度请求和计算任务
Model Loader 加载模型权重
Executor 执行模型计算
KV Cache Manager 管理 Key 和 Value 缓存
Memory Manager 管理 GPU 显存
Sampler 选择下一个 Token
Detokenizer 将 Token 转换为文本
Stream Handler 处理流式输出

2. 推理引擎架构图

flowchart TD
    A["Client / 用户请求"] --> B["API Server"]
    B --> C["Request Manager"]
    C --> D["Tokenizer"]
    D --> E["Scheduler"]
    E --> F["Model Executor"]
    F --> G["Transformer Model"]
    G --> H["GPU Kernels"]
    H --> I["GPU Hardware"]
    E --> J["KV Cache Manager"]
    J --> K["GPU Memory"]
    G --> L["Sampler"]
    L --> M["Detokenizer"]
    M --> N["Stream Handler"]
    N --> O["Client / 返回结果"]

    P["Model Loader"] --> G
    Q["Memory Manager"] --> J
    Q --> K

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49
    style N fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style O fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style P fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style Q fill:#F7F4E8,stroke:#C7B77A,color:#675A2D

不同推理框架的内部模块名称和实现方式可能不同,但整体职责基本相似。

3. 推理引擎的三层结构

从工程角度,可以将推理引擎划分为三个层次。

请求管理层

负责请求接入、排队、优先级管理、限流和响应输出。

推理调度层

负责 Prefill 与 Decode 调度、Batching、KV Cache 管理和资源分配。

模型执行层

负责模型权重加载、Transformer 前向计算、GPU Kernel 执行和多 GPU 通信。

这三层相互协作,决定整个推理服务的效率和稳定性。

三、模型加载:推理引擎如何准备模型?

推理请求到来之前,推理引擎必须先加载模型。

模型加载不仅是读取权重文件,还涉及模型结构初始化、参数映射、显存分配和算子准备。

1. 模型加载的主要内容

通常包括:

  • 读取模型配置。
  • 初始化模型结构。
  • 加载 Tokenizer。
  • 读取模型权重。
  • 将权重转换为目标数据精度。
  • 分配 GPU 显存。
  • 初始化推理算子。
  • 初始化 KV Cache 管理器。
  • 创建请求调度器。

模型权重通常保存在磁盘或远程存储中,推理引擎需要将其加载到 GPU 显存,或者根据部署策略进行分片和部分加载。

2. 模型权重加载方式

常见方式包括:

全量加载

将模型全部权重加载到 GPU 显存。

优点是执行时不需要频繁从 CPU 搬运权重。

分片加载

将模型权重切分到多个文件或多个 GPU。

常用于大模型和多 GPU 部署。

CPU Offload

部分模型权重保存在 CPU 内存,需要计算时再传输到 GPU。

这种方式可以降低 GPU 显存要求,但可能增加 PCIe 传输开销。

量化加载

将模型权重以 FP8、INT8、INT4 等低精度格式加载,减少显存占用。

3. 模型加载流程

flowchart TD
    A["启动推理引擎"] --> B["读取模型配置"]
    B --> C["初始化模型结构"]
    C --> D["加载 Tokenizer"]
    D --> E["读取模型权重"]
    E --> F["检查权重精度和格式"]
    F --> G["分配 GPU 显存"]
    G --> H["加载或切分权重"]
    H --> I["初始化推理算子"]
    I --> J["初始化 KV Cache"]
    J --> K["创建 Scheduler"]
    K --> L["模型服务就绪"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    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:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. 权重加载与显存规划

假设模型有 70B 参数,采用 FP16 存储:

M_{\text{weights}}=70\times 10^9\times 2

约需要 140GB 十进制存储空间。

但模型部署需要的显存并不止权重。

完整显存还需要容纳:

M_{\text{total}}= M_{\text{weights}}+ M_{\text{KV Cache}}+ M_{\text{activations}}+ M_{\text{workspace}}+ M_{\text{runtime}}

因此,模型加载成功并不代表已经具备足够的并发推理能力。

四、Prefill 与 Decode:推理的两个核心阶段

大模型采用自回归生成方式,一个 Token 接一个 Token 地生成结果。

推理过程通常分为 Prefill 和 Decode 两个阶段。

这是理解推理引擎工作原理最重要的知识点。

1. Prefill:输入处理阶段

Prefill 阶段负责处理用户输入的全部 Prompt Token。

例如:

用户输入:
请解释 CUDA 的工作原理,并给出一个简单示例。

Tokenizer 将文本转换为 Token:

[Token 1, Token 2, Token 3, ..., Token N]

Prefill 阶段会将这些 Token 一起输入 Transformer。

模型执行:

  1. Embedding。
  2. 计算 Query、Key、Value。
  3. 执行 Attention。
  4. 执行 FFN。
  5. 经过多个 Transformer 层。
  6. 生成首个输出位置对应的 Logits。
  7. 保存输入 Token 对应的 KV Cache。

Prefill 可以同时处理多个输入 Token,因此通常具有较高的计算并行度。

2. Decode:逐 Token 生成阶段

Decode 阶段负责逐个生成新的 Token。

例如:

输入 Prompt:
CUDA 是一种 GPU 并行计算平台。

模型生成:
CUDA
是一种
通用
并行
计算
平台
。

每次 Decode 通常只需要处理当前新增的 Token,并利用之前缓存的 Key 和 Value。

执行过程:

  1. 获取当前 Token。
  2. 计算当前 Token 的 Query、Key、Value。
  3. 读取历史 KV Cache。
  4. 执行 Attention。
  5. 执行 FFN。
  6. 得到下一个 Token 的 Logits。
  7. 通过 Sampler 选择下一个 Token。
  8. 更新 KV Cache。

随后继续执行,直到生成结束。

3. Prefill 与 Decode 的区别

对比维度 Prefill Decode
处理内容 完整输入 Prompt 新生成的 Token
输入 Token 数量 通常较多 通常每序列每步一个
计算并行度 较高 相对较低
主要瓶颈 计算能力、注意力计算 显存带宽、缓存访问
KV Cache 创建初始缓存 持续读取和更新
主要性能指标 TTFT TPOT

其中:

  • TTFT:Time To First Token,首 Token 延迟。
  • TPOT:Time Per Output Token,平均每个输出 Token 的生成耗时。

4. Prefill 与 Decode 的执行关系

flowchart TD
    A["接收 Prompt"] --> B["Tokenizer 编码"]
    B --> C["Prefill 阶段"]
    C --> D["处理全部输入 Token"]
    D --> E["计算 Q、K、V"]
    E --> F["执行 Attention 和 FFN"]
    F --> G["生成首个输出 Token"]
    G --> H["保存初始 KV Cache"]
    H --> I["Decode 阶段"]
    I --> J["输入当前 Token"]
    J --> K["读取历史 KV Cache"]
    K --> L["计算当前 Token"]
    L --> M["生成下一个 Token"]
    M --> N{"是否结束"}
    N -->|"否"| O["更新 KV Cache"]
    O --> I
    N -->|"是"| P["返回完整结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    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:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style N fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style O fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style P fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意,Prefill 计算完输入 Token 后,会产生用于生成后续 Token 的初始 Logits。第一个输出 Token 的采样和后续 Decode 的调度可能在实现上存在差异,但两阶段的核心计算关系不变。

五、KV Cache:推理引擎的核心内存机制

KV Cache 是大模型推理引擎最重要的优化技术之一。

如果没有 KV Cache,模型在每次生成新 Token 时,都需要重新计算之前所有 Token 的 Key 和 Value。

这会造成大量重复计算。

1. 为什么需要 KV Cache?

Transformer 的 Self-Attention 需要计算:

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

其中:

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

在自回归生成过程中,每生成一个新 Token,模型都需要关注之前已经生成的 Token。

假设已经生成了 100 个 Token,现在需要生成第 101 个 Token。

如果不使用 KV Cache,就需要重新计算前 100 个 Token 的 K 和 V。

使用 KV Cache 后,前 100 个 Token 的 K 和 V 已经保存,可以直接读取,只需要计算新 Token 对应的 K 和 V。

2. KV Cache 的工作机制

假设当前已经生成三个 Token:

Token 1 → Token 2 → Token 3

每个 Token 都会产生对应的 K 和 V。

KV Cache 保存:

K Cache = [K1, K2, K3]
V Cache = [V1, V2, V3]

生成 Token 4 时:

  • 计算 Q4。
  • 计算 K4 和 V4。
  • 读取 K1、K2、K3、K4。
  • 读取 V1、V2、V3、V4。
  • 执行 Attention。
  • 生成 Token 5。

随后更新缓存。

flowchart TD
    A["Token 1"] --> B["计算 K1、V1"]
    B --> C["写入 KV Cache"]
    C --> D["Token 2"]
    D --> E["计算 K2、V2"]
    E --> F["追加到 KV Cache"]
    F --> G["Token 3"]
    G --> H["计算 K3、V3"]
    H --> I["追加到 KV Cache"]
    I --> J["生成 Token 4"]
    J --> K["读取历史 K、V"]
    K --> L["执行 Attention"]
    L --> M["生成下一个 Token"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F

3. KV Cache 的显存计算

KV Cache 的显存占用可以近似表示为:

M_{\text{KV}}= 2\times L\times B\times S \times H_{\text{KV}}\times D \times \frac{b}{8}

其中:

  • L:Transformer 层数。
  • B:Batch Size。
  • S:缓存 Token 数量。
  • H_{\text{KV}}:KV Head 数量。
  • D:每个 Head 的维度。
  • b:缓存数据精度位数。
  • 2:分别表示 Key 和 Value。

假设:

  • 32 层 Transformer。
  • 8 个 KV Head。
  • Head Dimension 为 128。
  • 上下文长度 8192。
  • Batch Size 为 1。
  • FP16 缓存。

计算得到约 1GiB 的 KV Cache。

当并发请求增加时,KV Cache 显存也会随之增长。

因此,推理引擎必须具备高效的 KV Cache 管理能力。

4. PagedAttention:分页管理 KV Cache

传统 KV Cache 管理方式可能需要为每个请求分配连续的显存空间。

但不同请求的上下文长度和输出长度并不相同,容易造成显存碎片和空间浪费。

PagedAttention 将 KV Cache 切分为固定大小的 Block。

逻辑上的 Token 位置通过映射表对应到实际物理显存 Block。

例如:

逻辑 KV Block:
Block 0 → Block 1 → Block 2

物理显存 Block:
Block 7 → Block 2 → Block 9

逻辑顺序不要求与物理显存连续。

这样可以:

  • 提高显存利用率。
  • 减少外部碎片。
  • 支持动态扩展缓存。
  • 支持多个请求共享部分前缀缓存。
  • 更方便地回收请求占用的缓存。

5. KV Cache 的生命周期

推理引擎需要管理缓存从创建到释放的完整过程。

flowchart TD
    A["请求进入"] --> B["分配 KV Cache Block"]
    B --> C["Prefill 写入初始缓存"]
    C --> D["Decode 读取历史缓存"]
    D --> E["追加新 Token 的 K、V"]
    E --> F{"请求是否结束"}
    F -->|"否"| D
    F -->|"是"| G["释放或回收缓存 Block"]
    G --> H["更新空闲 Block 列表"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F

六、Scheduler:推理引擎如何调度请求?

Scheduler 是推理引擎的核心模块之一。

它决定哪些请求什么时候执行、哪些请求进入 Prefill、哪些请求继续 Decode,以及如何分配 GPU 计算和 KV Cache。

如果没有合理的调度策略,即使 GPU 性能很强,也可能出现资源利用率低、请求排队严重的问题。

1. 为什么需要 Scheduler?

假设同时有三个请求:

请求 输入 Token 预计输出 Token
A 100 500
B 2000 100
C 500 300

这些请求的计算特点不同:

  • A:输入短,输出长。
  • B:输入长,Prefill 计算量大。
  • C:输入和输出都处于中间水平。

如果简单地按照请求到达顺序执行,可能导致长 Prefill 请求占用 GPU 较长时间,影响其他请求的 Decode 延迟。

Scheduler 需要综合考虑请求状态、Token 数量、KV Cache 空间和服务优先级。

2. Scheduler 的核心职责

  • 接收待处理请求。
  • 维护请求队列。
  • 决定 Prefill 与 Decode 执行顺序。
  • 组织 Batch。
  • 分配 KV Cache。
  • 控制最大并发量。
  • 管理请求超时和取消。
  • 处理资源不足时的等待或抢占策略。

3. 请求状态管理

推理引擎通常需要维护请求状态。

常见状态包括:

状态 含义
WAITING 等待调度
PREFILL 正在处理输入
DECODE 正在生成 Token
PREEMPTED 暂时被抢占
FINISHED 生成完成
CANCELLED 请求被取消
FAILED 请求执行失败

请求状态变化:

flowchart TD
    A["WAITING"] --> B["PREFILL"]
    B --> C["DECODE"]
    C --> D{"是否生成结束"}
    D -->|"否"| C
    D -->|"是"| E["FINISHED"]
    B --> F["FAILED"]
    C --> F
    A --> G["CANCELLED"]
    B --> G
    C --> G
    C --> H["PREEMPTED"]
    H --> I["重新等待调度"]
    I --> C

    style A fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49

4. 调度策略

常见调度策略包括:

FIFO

按照请求进入队列的顺序执行。

优点是简单,缺点是容易受到长请求影响。

优先级调度

根据用户等级、请求类型或业务重要程度分配执行优先级。

Token Budget 调度

根据每轮允许处理的 Token 数量,决定当前调度批次的规模。

Prefill 与 Decode 混合调度

将不同请求的 Prefill 和 Decode 任务进行协调,避免某个阶段长期占用 GPU。

抢占式调度

当显存或计算资源不足时,暂时暂停部分请求,将资源分配给其他请求。

抢占可能涉及 KV Cache 释放、缓存换出和恢复,因此会带来额外开销。

七、Batching:如何提高 GPU 利用率?

Batching 是推理引擎提高吞吐量的重要技术。

它将多个请求组织成一个批次,利用 GPU 同时处理多个请求。

1. Static Batching:静态批处理

传统静态批处理会将多个请求组成固定 Batch。

例如:

Batch 1:
Request A
Request B
Request C
Request D

所有请求共同执行模型计算。

但生成式模型存在一个问题:不同请求的输出长度通常不同。

例如:

  • A 生成 100 Token。
  • B 生成 20 Token。
  • C 生成 200 Token。
  • D 生成 50 Token。

当 B 已经结束时,如果仍然需要等待其他请求完成,GPU 资源就可能被浪费。

2. Continuous Batching:连续批处理

Continuous Batching 允许请求在生成过程中动态加入和退出 Batch。

当一个请求完成后,推理引擎可以将新请求加入当前执行批次。

例如:

初始 Batch:
A、B、C

B 完成后:
A、C、D

A 完成后:
C、D、E

这样可以减少 GPU 空闲时间,提高整体吞吐量。

3. Static Batching 与 Continuous Batching 对比

对比维度 Static Batching Continuous Batching
请求加入 批次开始前 可以动态加入
请求退出 通常等待批次完成 单个请求完成即可退出
GPU 利用率 容易受长请求影响 通常更高
调度复杂度 较低 较高
显存管理 相对简单 需要动态管理
适用场景 固定长度批量推理 在线生成式推理

4. Continuous Batching 的工作流程

flowchart TD
    A["接收多个请求"] --> B["请求进入等待队列"]
    B --> C["Scheduler 选择请求"]
    C --> D["组成当前执行 Batch"]
    D --> E["执行 Prefill 或 Decode"]
    E --> F["检查各请求状态"]
    F --> G{"是否存在已完成请求"}
    G -->|"是"| H["移除已完成请求"]
    G -->|"否"| I["保留当前请求"]
    H --> J["释放对应 KV Cache"]
    J --> K["加入新的待执行请求"]
    I --> K
    K --> L{"是否还有待执行请求"}
    L -->|"是"| C
    L -->|"否"| M["等待新请求"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F

5. Chunked Prefill:分块 Prefill

当一个请求包含非常长的 Prompt 时,Prefill 可能占用大量 GPU 计算时间。

如果 Scheduler 一次性执行完整 Prefill,可能影响正在 Decode 的其他请求。

Chunked Prefill 将长 Prompt 拆分为多个 Token 块。

例如,一个 16K Token 的 Prompt 可以拆分成多个 1K 或 2K Token 的计算块。

Scheduler 可以在不同 Prefill 块之间安排 Decode 任务。

这样有助于平衡 Prefill 和 Decode 的资源竞争。

需要注意,Chunked Prefill 并不一定减少总计算量,它主要改善任务调度和延迟表现。

八、推理引擎如何执行 Transformer?

理解推理引擎,最终需要回到 Transformer 的计算过程。

一个典型 Decoder-only Transformer 包含多个重复的 Transformer Block。

每个 Block 通常包含:

  1. LayerNorm 或 RMSNorm。
  2. Self-Attention。
  3. Residual Connection。
  4. FFN 或 MoE。
  5. Residual Connection。

1. 模型计算结构

flowchart TD
    A["输入 Token IDs"] --> B["Embedding"]
    B --> C["Transformer Block 1"]
    C --> D["Transformer Block 2"]
    D --> E["Transformer Block ..."]
    E --> F["Transformer Block N"]
    F --> G["Final Norm"]
    G --> H["LM Head"]
    H --> I["Logits"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

2. Transformer Block 内部计算

以常见 Decoder-only Transformer 为例: