返回专栏
· 30 分钟阅读

vLLM 推理架构与优化机制


一、什么是 vLLM?

vLLM 是一个面向大语言模型(LLM)的高性能推理与服务框架,核心目标是在有限 GPU 资源下,让更多请求并发执行,同时降低推理延迟、提高 Token 吞吐量。

传统推理方式通常采用相对静态的批处理策略。请求之间的输入长度、输出长度不同,导致 GPU 计算和显存资源难以充分利用。

例如:

  • 请求 A 需要生成 20 个 Token。
  • 请求 B 需要生成 200 个 Token。
  • 请求 C 需要生成 500 个 Token。

如果采用传统批处理,短请求完成后可能需要等待长请求,或者占据批次中的资源位置,造成 GPU 利用率下降。

vLLM 通过更灵活的请求调度和 KV Cache 管理解决这类问题。

1. vLLM 的核心能力

能力 作用 解决的问题
PagedAttention 分页管理 KV Cache 显存碎片与连续分配问题
Continuous Batching 动态调整执行批次 请求长度不同导致的资源浪费
KV Cache 管理 管理历史 Token 的 Key、Value 避免重复计算 Attention
Prefix Caching 复用相同前缀的 KV Cache 减少重复 Prompt 计算
Chunked Prefill 将长 Prompt 分块执行 降低长输入对 Decode 的阻塞
Scheduler 调度请求与 Token 预算 提高 GPU 资源利用率
Tensor Parallel 多 GPU 协同计算 支持更大模型部署
Speculative Decoding 借助草稿模型加速生成 降低自回归解码延迟

2. vLLM 与普通 Transformers 推理的区别

Transformers 更偏向模型加载、训练和通用推理接口,而 vLLM 更侧重高并发在线推理服务。

对比维度 Transformers 常规推理 vLLM
核心定位 通用模型框架 高性能推理引擎
批处理 常见方式为静态批处理 Continuous Batching
KV Cache 由模型推理逻辑管理 统一的 Block 管理机制
显存管理 通常采用常规张量分配 PagedAttention 分页管理
请求调度 通常需要外部服务层处理 内置 Scheduler
并发服务 需要额外构建服务逻辑 提供在线推理服务能力
适用场景 模型实验、训练、通用推理 高吞吐、多请求推理

需要注意,Transformers 本身也在持续支持更高效的缓存、批处理和推理能力。两者不是简单的性能高低关系,而是侧重点不同。

二、vLLM 整体架构

vLLM 的核心可以理解为四个相互协作的部分:

  1. 请求入口层:接收客户端请求,完成参数解析和请求管理。
  2. 调度层:决定哪些请求进入当前执行批次,以及分配多少计算预算。
  3. 执行层:调用模型计算逻辑,执行 Prefill 和 Decode。
  4. 缓存管理层:管理 KV Cache Block 的分配、复用和释放。

1. 整体架构图

flowchart TD
    A["客户端请求"] --> B["API Server"]
    B --> C["请求队列"]
    C --> D["Scheduler 调度器"]
    D --> E["Model Runner"]
    E --> F["GPU 模型执行"]
    F --> G["Prefill / Decode"]
    G --> H["PagedAttention"]
    H --> I["KV Cache Block Manager"]
    I --> J["GPU 显存"]
    G --> K["Token Sampler"]
    K --> L["输出处理"]
    L --> M["流式响应客户端"]

    D --> N["调度预算与请求状态"]
    N --> D
    I --> D

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

2. 核心模块职责

模块 核心职责
API Server 接收 HTTP 请求,处理接口协议
Engine 管理推理任务和整体执行生命周期
Scheduler 选择待执行请求,控制批次与 Token 预算
Model Runner 组织模型输入并执行 GPU 计算
Worker 管理 GPU 执行资源
Attention Backend 执行 Attention 算子
Block Manager 管理 KV Cache Block
Sampler 根据 Logits 采样生成 Token
Output Processor 整理结果并返回客户端

不同 vLLM 版本的内部模块名称和调用边界可能发生变化,但这些职责构成了理解其架构的核心抽象。

三、vLLM 的请求执行生命周期

一个请求从进入 vLLM 到生成最终结果,通常需要经过以下阶段:

  1. 接收请求并进行参数校验。
  2. 将请求加入等待队列。
  3. Scheduler 选择请求。
  4. 为请求分配 KV Cache Block。
  5. 执行 Prefill,处理输入 Prompt。
  6. 执行 Decode,逐步生成 Token。
  7. 根据停止条件判断是否结束。
  8. 释放 KV Cache 等资源。
  9. 返回最终结果。

1. 请求生命周期流程图

flowchart TD
    A["接收推理请求"] --> B["参数校验与 Tokenize"]
    B --> C["加入等待队列"]
    C --> D["Scheduler 选择请求"]
    D --> E{"资源是否充足"}
    E -->|"是"| F["分配 KV Cache Block"]
    E -->|"否"| G["等待或调整调度"]
    G --> D
    F --> H["Prefill 阶段"]
    H --> I["生成首个 Token"]
    I --> J["Decode 阶段"]
    J --> K{"是否满足停止条件"}
    K -->|"否"| L["更新 KV Cache"]
    L --> J
    K -->|"是"| M["释放缓存资源"]
    M --> N["整理输出结果"]
    N --> O["返回客户端"]

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

2. Prefill 阶段

Prefill 负责处理用户输入的 Prompt。

假设输入:

请解释一下 Transformer 的工作原理。

Tokenize 后得到 Token 序列:

[token_1, token_2, token_3, ..., token_n]

模型对输入 Token 进行前向计算,完成:

  • Embedding 查表。
  • Transformer Layer 计算。
  • Attention 计算。
  • FFN 计算。
  • 输出 Logits。
  • 构建每一层的 KV Cache。

Prefill 阶段通常能够并行处理多个输入 Token,因此具有较强的矩阵计算特征。

3. Decode 阶段

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

例如:

输入 Prompt
    ↓
Prefill
    ↓
生成 Token A
    ↓
生成 Token B
    ↓
生成 Token C
    ↓
直到满足停止条件

在 Decode 阶段,通常只需要将新 Token 输入模型,同时读取历史 KV Cache,而不需要重新计算所有历史 Token 的 Key 和 Value。

Decode 阶段通常具有更明显的显存带宽压力,并且受自回归依赖限制。

四、PagedAttention:vLLM 的核心技术

PagedAttention 是 vLLM 最具代表性的技术之一。

它借鉴操作系统虚拟内存分页管理的思想,将 KV Cache 切分为固定大小的 Block,不再要求每个请求使用一整块连续显存。

1. 传统 KV Cache 管理的问题

在常规连续分配方式中,每个请求需要为 KV Cache 预留连续的显存空间。

假设三个请求:

请求 预计 Token 数量 实际 Token 数量
A 1024 200
B 1024 600
C 1024 900

如果按照最大长度预分配,每个请求都需要预留 1024 个 Token 的缓存空间。

实际使用量远小于预留量,就会造成显存浪费。

另外,不同请求结束时间不同,释放显存后可能出现大量不连续的空闲区域。

这就是显存碎片问题。

2. PagedAttention 的分页思想

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

假设每个 Block 可以保存 16 个 Token 的 KV Cache:

请求 实际 Token 数量 所需 Block 数量
A 20 2
B 35 3
C 50 4

Block 数量按照向上取整计算:

N_{\text{blocks}}= \left\lceil \frac{N_{\text{tokens}}}{B} \right\rceil

其中:

  • N_{\text{tokens}}:请求当前需要缓存的 Token 数量。
  • B:每个 Block 容纳的 Token 数量。

每个请求通过 Block Table 记录逻辑 Block 与物理 Block 的对应关系。

例如:

请求 A:
逻辑 Block 0 → 物理 Block 3
逻辑 Block 1 → 物理 Block 8

请求 B:
逻辑 Block 0 → 物理 Block 1
逻辑 Block 1 → 物理 Block 5
逻辑 Block 2 → 物理 Block 9

物理 Block 不需要连续排列。

因此,KV Cache 可以从任意可用位置分配,降低连续内存分配的限制。

3. Block Table 的作用

Block Table 是 PagedAttention 访问 KV Cache 的重要映射结构。

它负责维护:

  • 请求逻辑 Block 编号。
  • 对应物理 Block 编号。
  • Block 使用状态。
  • Block 引用关系。
  • Block 的分配与释放信息。

逻辑上的 Token 位置需要通过 Block Table 找到对应的物理缓存位置。

例如:

逻辑 Token 位置
      ↓
计算逻辑 Block 编号
      ↓
查询 Block Table
      ↓
获取物理 Block 编号
      ↓
计算 Block 内偏移
      ↓
访问 KV Cache

4. PagedAttention 的执行原理

传统 Attention 需要读取历史 Token 的 Key 和 Value。

PagedAttention 将历史 KV Cache 分散存储在多个物理 Block 中,Attention Kernel 根据 Block Table 定位数据,并完成 Attention 计算。

它并不是将 Attention 的数学公式改变了,而是改变了 KV Cache 的物理组织和访问方式。

标准 Attention 计算仍然可以表示为:

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

其中:

  • Q:Query。
  • K:Key。
  • V:Value。
  • d_k:Key 向量维度。

5. PagedAttention 的优势

优势 说明
减少显存碎片 不要求请求缓存连续分配
提高显存利用率 按需分配 Block
支持动态扩展 Token 增加时可以继续分配 Block
支持缓存共享 相同前缀可通过引用关系共享 Block
提高并发能力 相同显存容量可以容纳更多请求

需要注意,分页管理本身也存在 Block 元数据、寻址和调度成本。实际性能取决于 GPU 架构、Attention Backend、Block 大小和工作负载。

五、KV Cache 管理机制

KV Cache 保存 Transformer 每一层历史 Token 的 Key 和 Value。

在自回归生成过程中,模型可以直接复用历史计算结果,避免每次生成新 Token 时重新计算完整历史序列。

1. KV Cache 的显存计算

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

M_{KV}= 2\times L\times B\times S\times H_{kv}\times D_h\times P

其中:

参数 含义
L Transformer 层数
B Batch 中的请求数量
S 每个请求的缓存 Token 数量
H_{kv} KV Head 数量
D_h 每个 Head 的维度
P 每个元素占用的字节数
2 分别保存 Key 和 Value

例如:

  • 32 层 Transformer。
  • 8 个 KV Head。
  • 每个 Head 维度为 128。
  • FP16,每个元素 2 字节。
  • 1000 个 Token。

单个请求的 KV Cache 占用:

2\times32\times1000\times8\times128\times2
=131072000\ bytes

约为 125 MiB。

如果同时处理 100 个相同长度的请求,KV Cache 就可能达到约 12.2 GiB。

这还没有计算模型权重、临时工作区和其他运行时开销。

2. GQA 与 MQA 对 KV Cache 的影响

不同 Attention 架构会影响 KV Cache 大小。

注意力结构 KV Head 数量 缓存特征
MHA 与 Query Head 数量相同 KV Cache 较大
GQA 少于 Query Head 数量 减少 KV Cache
MQA 通常为 1 KV Cache 更小

例如:

模型有 32 个 Query Head:

  • MHA:32 个 KV Head。
  • GQA:8 个 KV Head。
  • MQA:1 个 KV Head。

在其他参数相同的情况下,GQA 的 KV Cache 约为 MHA 的四分之一,MQA 约为 MHA 的三十二分之一。

3. Block 分配与释放

vLLM 不需要在请求开始时为整个最大上下文长度分配所有 Block。

随着 Decode 阶段生成新的 Token,缓存空间可以按需扩展。

当请求结束后,相关 Block 可以被释放,重新加入可用 Block 池。

flowchart TD
    A["请求进入"] --> B["计算所需初始 Block"]
    B --> C["从空闲池分配 Block"]
    C --> D["建立 Block Table"]
    D --> E["执行 Prefill"]
    E --> F["Decode 生成新 Token"]
    F --> G{"当前 Block 是否有剩余空间"}
    G -->|"是"| H["写入现有 Block"]
    G -->|"否"| I["申请新 Block"]
    I --> J{"是否有空闲 Block"}
    J -->|"是"| K["更新 Block Table"]
    J -->|"否"| L["等待、抢占或重计算"]
    K --> H
    H --> F
    L --> F
    F --> M["请求结束"]
    M --> N["释放或减少 Block 引用"]
    N --> O["Block 回到空闲池"]

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

4. 显存不足时的处理

当可用 Block 不足时,Scheduler 需要处理资源竞争。

常见策略包括:

  • 延迟调度:暂时不让新请求进入执行批次。
  • 请求抢占:释放某些请求当前占用的 KV Cache。
  • 重计算:在后续执行时重新计算被释放的部分历史状态。
  • 调整批次:降低当前批次的资源需求。

具体采用何种策略以及相关参数,取决于 vLLM 版本和调度配置。

六、Continuous Batching:连续批处理

Continuous Batching 是 vLLM 提升并发吞吐量的重要机制。

1. 传统静态批处理的问题

假设一个 Batch 中有三个请求:

请求 生成 Token 数量
A 10
B 100
C 200

传统静态批处理通常以整个批次为单位执行。

即使请求 A 已经生成完成,其他请求仍然可能继续占据批次位置。

这样会造成:

  • 已完成请求占用批次资源。
  • 新请求无法及时加入。
  • 长短请求互相影响。
  • GPU 资源利用率不稳定。

2. Continuous Batching 的基本思想

Continuous Batching 不再要求所有请求必须同时开始、同时结束。

每轮执行完成后,Scheduler 都可以重新组织执行批次:

  • 已完成请求退出。
  • 新请求加入。
  • 正在生成的请求继续执行。
  • 根据资源情况动态调整批次。

例如:

第 1 轮:A、B、C
第 2 轮:A、B、C
第 3 轮:A 完成,B、C 继续,D 加入
第 4 轮:B、C、D
第 5 轮:B 完成,C、D 继续,E 加入

这是一种简化示意,实际调度还会受到 Token 预算、KV Cache 容量、请求优先级和调度策略影响。

3. Continuous Batching 执行流程

flowchart TD
    A["等待队列"] --> B["Scheduler 选择请求"]
    B --> C["组成当前执行批次"]
    C --> D["执行模型计算"]
    D --> E["更新各请求状态"]
    E --> F{"是否存在已完成请求"}
    F -->|"是"| G["移除完成请求"]
    F -->|"否"| H["保留运行请求"]
    G --> I["释放对应资源"]
    I --> J["检查等待队列"]
    H --> J
    J --> K{"是否有可调度的新请求"}
    K -->|"是"| L["新请求加入批次"]
    K -->|"否"| M["继续现有批次"]
    L --> D
    M --> D

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

4. Continuous Batching 的优势

优势 说明
动态加入请求 不必等待整个 Batch 完成
动态移除请求 已完成请求及时释放资源
提高 GPU 利用率 减少空闲执行位置
改善请求吞吐 同一时间可以处理更多请求
适应不同输出长度 降低长短请求之间的相互影响

需要区分两个概念:

  • Static Batching:批次成员相对固定。
  • Continuous Batching:批次成员可以在执行过程中动态变化。

Continuous Batching 并不意味着每个请求都能获得相同的响应延迟。实际体验仍然取决于请求长度、排队时间和 GPU 负载。

七、Scheduler:推理调度器

Scheduler 是 vLLM 的重要控制模块,负责协调请求执行与 GPU 资源分配。

它需要解决的问题包括:

  1. 当前应该执行哪些请求?
  2. 每个请求应该处理多少 Token?
  3. 当前 KV Cache 是否充足?
  4. 新请求是否可以加入?
  5. 哪些请求需要等待或抢占?

1. Scheduler 的主要职责

职责 说明
请求选择 从等待队列中挑选待执行请求
批次构建 组织当前执行批次
Token 预算控制 限制单轮计算 Token 数量
缓存资源检查 确认 KV Cache 是否充足
请求状态管理 管理等待、运行、完成等状态
抢占处理 处理资源不足时的请求竞争

2. Token Budget

vLLM 的调度不只是控制请求数量,还会关注每轮需要处理多少 Token。

例如:

当前调度预算:4096 Tokens

请求 A:Prefill 1000 Tokens
请求 B:Decode 1 Token
请求 C:Prefill 2000 Tokens
请求 D:Decode 1 Token

如果当前调度策略允许这些请求进入同一轮执行,那么总 Token 预算使用量为 3002。

Token Budget 可以控制每轮计算规模,避免大量长 Prompt 一次性占用过多 GPU 计算资源。

需要注意,Token 数量不是显存占用的唯一指标。KV Cache、模型权重、激活值、Attention 工作区等也会影响调度可行性。

3. Prefill 与 Decode 的调度差异

Prefill 和 Decode 具有不同的计算特征:

阶段 主要工作 特征
Prefill 处理输入 Prompt 一次处理多个 Token
Decode 生成新 Token 通常每个请求每轮生成一个 Token

Prefill 计算量较大,容易占用 GPU 计算资源。

Decode 单轮 Token 数量较少,但需要频繁访问模型权重和 KV Cache。

如果一个长 Prompt 在某一轮占用过多计算资源,其他正在 Decode 的请求就可能等待更久。

因此,调度器需要在 Prefill 和 Decode 之间取得平衡。

八、Chunked Prefill:分块预填充

Chunked Prefill 是一种将长 Prompt 拆分为多个小块执行的优化机制。

1. 为什么需要 Chunked Prefill?

假设一个请求包含 16,000 个输入 Token。

如果一次性执行整个 Prefill,可能产生较大的计算负载。

与此同时,其他请求可能正处于 Decode 阶段,需要持续执行才能保持生成速度。

如果长 Prompt 一直占据 GPU 计算资源,就会影响其他请求的 Token 输出延迟。

2. 分块执行机制

假设将 16,000 个 Token 拆成 4 个 Chunk:

Chunk Token 范围 Token 数量
Chunk 1 1~4000 4000
Chunk 2 4001~8000 4000
Chunk 3 8001~12000 4000
Chunk 4 12001~16000 4000

每个 Chunk 执行完成后,调度器可以根据预算安排其他请求。

flowchart TD
    A["接收长 Prompt"] --> B["切分 Prompt"]
    B --> C["执行 Chunk 1"]
    C --> D["更新 KV Cache"]
    D --> E["检查调度预算"]
    E --> F{"是否存在 Decode 请求"}
    F -->|"是"| G["执行 Decode 请求"]
    F -->|"否"| H["继续 Prefill"]
    G --> I["返回 Scheduler"]
    H --> J["执行下一个 Chunk"]
    I --> J
    J --> K{"是否还有 Prompt Token"}
    K -->|"是"| E
    K -->|"否"| L["Prefill 完成"]
    L --> M["进入正常 Decode"]

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

3. Chunked Prefill 的收益

  • 避免长 Prompt 一次性占用过多计算预算。
  • 改善 Prefill 与 Decode 之间的调度公平性。
  • 降低长输入请求对其他请求生成延迟的影响。
  • 更灵活地控制单轮 GPU 工作量。

它并不一定减少模型完成 Prefill 所需的总计算量,主要改变的是计算任务的组织和执行时机。

九、Prefix Caching:前缀缓存复用

Prefix Caching 是另一项重要的推理优化机制。

在很多应用中,不同请求可能拥有相同的 Prompt 前缀。

例如:

请求 A:
你是一个专业的 Python 助手。
请解释列表推导式。

请求 B:
你是一个专业的 Python 助手。
请解释装饰器。

两个请求拥有相同的系统提示词。

如果每次都重新执行完整前缀的 Prefill,就会产生重复计算。

Prefix Caching 可以复用已经计算过的前缀 KV Cache。

1. 前缀复用原理

flowchart TD
    A["请求 A"] --> C["公共 Prompt 前缀"]
    B["请求 B"] --> C
    C --> D["计算前缀 KV Cache"]
    D --> E["缓存 Block"]
    E --> F["请求 A 复用"]
    E --> G["请求 B 复用"]
    F --> H["处理 A 的独有内容"]
    G --> I["处理 B 的独有内容"]
    H --> J["继续生成"]
    I --> K["继续生成"]

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

2. Prefix Caching 的关键条件

前缀缓存并不是简单地根据文本相似度复用。

通常需要满足:

  • Token 序列一致。
  • 模型与相关计算配置一致。
  • 缓存 Block 的计算状态匹配。
  • 多模态或其他特殊输入的处理信息一致。
  • 缓存仍然存在且可用。

具体缓存键和匹配策略由 vLLM 的实现决定。

3. Prefix Caching 的适用场景

场景 复用价值
固定系统提示词 高
多轮对话公共历史 视对话前缀是否一致而定
RAG 固定指令模板 高
Agent 固定角色配置 高
大量共享文档前缀 视 Token 化结果而定
完全不同的用户输入 低

Prefix Caching 主要减少重复 Prefill 计算,并不意味着不同请求的所有 KV Cache 都可以共享。

十、Speculative Decoding:投机解码

Speculative Decoding 是一种通过草稿模型辅助目标模型生成 Token 的加速技术。

传统自回归生成通常每轮生成一个 Token,需要多次执行目标模型。

Speculative Decoding 则先让一个较小的 Draft Model 快速提出多个候选 Token,再由 Target Model 进行验证。

1. 传统 Decode 的问题

假设需要生成:

Token A → Token B → Token C → Token D

传统方式通常需要多轮目标模型执行:

执行目标模型 → Token A
执行目标模型 → Token B
执行目标模型 → Token C
执行目标模型 → Token D

每一轮都需要等待前一个 Token 生成完成。

2. 投机解码的执行过程

假设 Draft Model 一次提出:

Token A、Token B、Token C、Token D

Target Model 对这些候选 Token 进行验证。

如果前几个 Token 符合目标模型的采样分布,就可以接受它们;遇到不符合验证条件的 Token 时,按照相应的接受与拒绝采样算法进行修正,并继续生成。

flowchart TD
    A["已有上下文"] --> B["Draft Model"]
    B --> C["生成多个候选 Token"]
    C --> D["Target Model 验证"]
    D --> E{"候选 Token 是否通过验证"}
    E -->|"通过"| F["接受候选 Token"]
    E -->|"未通过"| G["按采样规则修正"]
    F --> H{"是否还有候选 Token"}
    H -->|"是"| F
    H -->|"否"| I["继续下一轮投机"]
    G --> J["得到修正后的输出"]
    J --> I
    I --> B

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

3. 为什么能够加速?

Draft Model 通常规模较小,生成候选 Token 的成本较低。

Target Model 可以在一次验证计算中处理多个候选位置,从而减少逐 Token 执行目标模型的次数。

当候选 Token 的接受率较高时,整体生成速度可能明显提高。

4. 投机解码的局限

  • Draft Model 需要额外占用显存和计算资源。
  • 草稿模型与目标模型差异较大时,接受率可能较低。
  • 验证和调度也会产生额外开销。
  • 对部分 GPU 已经高度饱和的场景,加速效果可能有限。

投机解码的正确实现需要保证输出分布符合目标模型规定的采样分布,而不是简单地把草稿模型生成的 Token 全部接受。

十一、Tensor Parallel:张量并行

当单张 GPU 无法容纳完整模型,或者单卡计算能力不足时,可以通过多 GPU 协同执行。

Tensor Parallel(TP)将模型中的大型矩阵计算拆分到多个 GPU 上。

1. 张量并行的基本思想

假设模型中有一个大型权重矩阵:

Y=XW

可以将权重矩阵拆分为多个部分:

W=[W_1,W_2,\ldots,W_n]

每张 GPU 负责计算其中一部分。

输入 X
  │
  ├── GPU 0:X × W1
  ├── GPU 1:X × W2
  ├── GPU 2:X × W3
  └── GPU 3:X × W4
          │
          ↓
      结果合并
          │
          ↓
       输出 Y

以上是按列拆分矩阵的简化示意。实际 Transformer 中还存在行并行、列并行、Attention Head 切分等多种实现方式。

2. Tensor Parallel 的优点

  • 将模型权重分散到多张 GPU。
  • 降低单张 GPU 的权重显存压力。
  • 利用多 GPU 并行执行矩阵计算。
  • 支持更大规模模型部署。

3. Tensor Parallel 的成本

张量并行通常需要 GPU 之间进行通信。

例如:

  • AllReduce。
  • AllGather。
  • ReduceScatter。

如果 GPU 之间的通信带宽不足,通信开销可能抵消部分并行收益。

因此,Tensor Parallel 的配置需要结合 GPU 数量、显存容量、NVLink 拓扑和模型结构进行选择。

十二、vLLM 的其他性能优化机制

除 PagedAttention 和 Continuous Batching 外,vLLM 还可以结合多种技术提高推理性能。

1. FlashAttention

FlashAttention 是一种优化 Attention 计算与显存访问的算法。

传统 Attention 可能需要显式构造较大的 Attention Score 矩阵:

S=QK^T

当序列长度较长时,中间矩阵可能带来较大的显存访问开销。