跳转至

为模型前向传播准备输入

目的

执行模型前向传播所需的信息：

  • 输入
  • 输入对应的注意力元数据

下图展示了模型推理需要准备的内容。

              +---------------+
  inputs  --> |               |
              |     model     |  --> output
attn_meta --> |               |
              +---------------+

因此，只要有了上述两条信息，我们就可以执行模型的前向传播。

本文档将解释**如何获取输入及其对应的注意力元数据**。

概述

1.获取输入

获取输入的工作流程：

  1. 获取 token positions：每个 token 在其请求序列中的相对位置。

  2. 获取 token indices：每个调度 token 在 token 表中的索引。

  3. 获取 Token IDs：使用 token indices 从 token id table 中检索 Token ID。

最后，需要将这些 Token IDs 输入模型，同时 positions 也应传入模型以创建 RoPE（旋转位置编码）。这两者都是模型的输入。

注意：Token IDs 是模型的输入，因此我们也称之为 Input IDs。

2.构建输入的注意力元数据

模型在前向传播过程中需要以下注意力元数据：

  • query start location：每个请求对应调度 token 的起始和结束位置。
  • sequence length：每个请求的长度，包括已计算的 token 和新调度的 token。
  • number of computed tokens：每个请求已计算的 token 数量。
  • number of requests：此批次中的请求数量。
  • number of tokens：此批次中调度的 token 总数。
  • block table：将每个块的逻辑地址（在其序列内）转换为设备内存中的全局物理地址。
  • max query len：此请求批次中最长的调度 token 长度。
  • slot mapping：每个输入 token 将被存储到的索引位置。
  • attention mask：在 softmax 之前应用于注意力分数的掩码矩阵，用于控制哪些 token 可以相互关注（通常是因果注意力）。

开始之前

主要有三种类型的变量。

  • token 级别：表示每个调度 token 对应的一个属性，因此该变量的长度等于调度 token 的数量。
  • request 级别：表示每个调度请求的一个属性，其长度通常等于调度请求的数量。（query start location 是特殊情况，多一个元素。）
  • 系统级别：
  • Token IDs table：存储每个请求的 token ID（即模型的输入）。该表的形状为 (max num request, max model len)。其中，max num request 是前向批次中允许的最大并发请求数，max model len 是该模型中单个请求序列能处理的最大 token 数量。
  • Block table：将每个块的逻辑地址（在其序列内）转换为设备内存中的全局物理地址。该表的形状为 (max num request, max model len / block size)

注意：这两个表都来自**准备输入**之前的 _update_states 方法。如果需要更多灵感，可以查看一下。

提示

Simply put, a token ID is an integer (usually int32), which represents a token. Example of Token ID:

| Token ID     | Token         | 
|--------------|---------------|
| 0            | [PAD]         |
| 1            | <|endoftext|> |
| 2            | <|start|>     |
| 3            | [SEP]         |
| 4            | I             |
| 5            | the           |
| 6            | be            |
| 7            | of            |
| 8            | and           |     
| ...          | ...           |     
| ...          | ...           |
| vocab_size-1 | <|im_end|>    |

详细说明

假设条件：

  • 单次最多可调度的 token 数量：10
  • block size：2
  • 总共调度 3 个请求。它们的 prompt 长度分别为 3、2 和 8。
  • max model length：12（模型中单个请求序列能处理的最大 token 数量）。

这些假设条件在启动 vLLM 时配置。它们不是固定的，可以手动设置。

步骤 1：所有请求处于预填充阶段

获取输入

由于单次最多可调度的 token 数量为 10，每个请求的调度 token 可表示为 {'0': 3, '1': 2, '2': 5}。注意，request_2 使用了分块预填充，剩余 3 个 prompt token 未被调度。

1.获取 token positions

首先，确定每个 token 属于哪个请求：token 0–2 分配给 request_0，token 3–4 分配给 request_1，token 5–9 分配给 request_2。为了表示这种映射关系，我们使用 request indices，例如 request indices：[0, 0, 0, 1, 1, 2, 2, 2, 2, 2]。

对于每个请求，使用**已计算的 token 数量** + 当前调度 token 的相对位置（request_0: [0 + 0, 0 + 1, 0 + 2]，request_1: [0 + 0, 0 + 1]，request_2: [0 + 0, 0 + 1,..., 0 + 4]），然后将它们连接在一起（[0, 1, 2, 0, 1, 0, 1, 2, 3, 4]）。

注意：在实际代码中，有一种更高效的方法（使用 request indices）来创建 positions。

最终，token positions 为 [0, 1, 2, 0, 1, 0, 1, 2, 3, 4]。该变量是 **token 级别**的。

2.获取 token indices

当前 Token IDs table 的形状为 (max num request, max model len)。

为什么表中的 T_3_5、T_3_6、T_3_7 没有被调度？

  • 我们一次性将某个请求序列中的所有 Token ID 填入表中，但只检索本次调度的 token。剩余的 Token ID 将在下次检索。
| T_0_0 | T_0_1 | T_0_2 |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |
| T_1_0 | T_1_1 |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |
| T_2_0 | T_2_1 | T_3_2 | T_3_3 | T_3_4 | T_3_5 | T_3_6 | T_3_7 |   ?   |   ?   |   ?   |   ?   |
|   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |
......
......
......

注意，T_x_x 是 int32 类型。

设 M = max model len。然后我们可以使用 token positions 和每个 token 的 request indices 来构造 token indices。

因此 token indices = [0 + 0 * M, 1 + 0 * M, 2 + 0 * M, 0 + 1 * M, 1 + 1 * M, 0 + 2 * M, 1 + 2 * M, 2 + 2 * M, 3 + 2 * M, 4 + 2 * M] = [0, 1, 2, 12, 13, 24, 25, 26, 27, 28]

3.检索 Token IDs

我们使用 token indices 从 token 表中选出对应的 Input IDs。伪代码如下：

input_ids = token_table[token_indices]

如前所述，我们将这些 Token IDs 称为 Input IDs。

  • Input IDs = [T_0_0, T_0_1, T_0_2, T_1_0, T_1_1, T_2_0, T_2_1, T_3_2, T_3_3, T_3_4]

构建输入的注意力元数据

在当前 Block Table 中，我们使用第一个块（即 block_0）来标记未使用的块。该表的形状为 (max num request, max model len / block size)，其中 max model len / block size = 12 / 2 = 6。

| 1  | 2  | 0  | 0  | 0  | 0  |
| 3  | 0  | 0  | 0  | 0  | 0  |
| 4  | 5  | 6  | 0  | 0  | 0  |
| 0  | 0  | 0  | 0  | 0  | 0  |
......
......
......

设备内存中的 KV 缓存块如下所示：

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ......

设 K = max model len / block size = 6，然后我们可以获取 token 的 device block number。

获取 slot mapping 的工作流程：

  1. 使用 block table indices、K 和 positions 获取 request indices。

目的：对于每个 token，用于从 device block number 中选择 block table。

  1. 使用 device block number 获取 block table indices。

目的：device block number 表示每个 token 属于哪个设备块。

  1. 使用 block offsets 和 positions 获取 block size。

目的：block offsets 表示每个 token 在块内的偏移量。

  1. 使用 slot mapping 和 device block number 构建 block offsets。

目的：我们可以使用 slot mapping 将 Token ID 存储到 token 槽位中。

详细步骤：

  1. （Token 级别）使用简单公式计算 block table indices：request indices * K + positions / block size。因此等于 [0 * 6 + 0 / 2, 0 * 6 + 1 / 2, 0 * 6 + 2 / 2, 1 * 6 + 0 / 2, 1 * 6 + 1 / 2, 2 * 6 + 0 / 2, 2 * 6 + 1 / 2, 2 * 6 + 2 / 2, 2 * 6 + 3 / 2, 2 * 6 + 4 / 2] = [0, 0, 1, 6, 6, 12, 12, 13, 13, 14]。这可用于从 device block number 中选择 block table。
  2. （Token 级别）使用 block table indices 为每个调度 token 选出 device block number。伪代码为 block_numbers = block_table[block_table_indices]。因此 device block number=[1, 1, 2, 3, 3, 4, 4, 5, 5, 6]
  3. （Token 级别）block offsets 可通过 block offsets = positions % block size = [0, 1, 0, 0, 1, 0, 1, 0, 1, 0] 计算。
  4. 最后，使用 block offsets 和 device block number 创建 slot mapping：device block number * block size + block_offsets = [2, 3, 4, 6, 7, 8, 9, 10, 11, 12]

（Request 级别）已知调度 token 数量为 [3, 2, 5]：

  • （Request 级别）使用前缀和计算 query start location：[0, 3, 5, 10]。
  • （Request 级别）步骤 1 中的所有 token 都处于预填充阶段，已计算的 token 数量为 0；因此 sequence length = [3, 2, 5]。
  • （Request 级别）如上所述，number of computed tokens 全为 0：[0, 0, 0]。
  • number of requests：3
  • （Request 级别）number of tokens：[3, 2, 5]
  • max query len：5
  • （Token 级别）slot mapping：[2, 3, 4, 6, 7, 8, 9, 10, 11, 12]
  • attention mask：对于所有启动预填充过程的请求，我们只创建一个掩码矩阵，供不同请求复用。该掩码矩阵的形状为 5 * 5：

步骤 2：分块预填充

在步骤 2 中，我们不再提供解释或进行计算，而是直接给出最终结果。

获取输入

每个请求的调度 token：{'0': 1, '1': 1, '2': 3}

  1. request indices：[0, 1, 2, 2, 2]

  2. token positions：[3, 2, 5, 6, 7]

    当前 Token IDs table：

    | T_0_0 | T_0_1 | T_0_2 | T_0_3 |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |
| T_1_0 | T_1_1 | T_1_2 |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |
| T_2_0 | T_2_1 | T_3_2 | T_3_3 | T_3_4 | T_3_5 | T_3_6 | T_3_7 |   ?   |   ?   |   ?   |   ?   |
|   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |   ?   |
......
......
......

    Note: T_0_3, T_1_2 are new Token IDs of request_0 and request_1 respectively. They are sampled from the output of the model.

  3. token indices: [3, 14, 29, 30, 31]

  4. Input IDs: [T_0_3, T_1_2, T_3_5, T_3_6, T_3_7]

Build inputs attention metadata

We allocate the blocks 7 and 8 to request_1 and request_2，因为在 token 生成或分块预填充之后，它们需要更多设备空间来存储 KV 缓存。

当前 Block Table：

| 1  | 2  | 0  | 0  | 0  | 0  |
| 3  | 7  | 0  | 0  | 0  | 0  |
| 4  | 5  | 6  | 8  | 0  | 0  |
| 0  | 0  | 0  | 0  | 0  | 0  |
......
......
......

设备内存中的 KV 缓存块：

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ......
  1. （Token 级别）block table indices：[1, 7, 14, 15, 15]
  2. （Token 级别）device block number：[2, 7, 6, 8, 8]
  3. （Token 级别）block offsets：[1, 0, 1, 0, 1]
  4. （Token 级别）slot mapping：[5, 14, 13, 16, 17]

调度 token 数量：[1, 1, 3]

  • query start location：[0, 1, 2, 5]

  • sequence length：[4, 3, 8]

  • number of computed tokens：[3, 2, 5]

  • number of requests：3

  • max query len：3

  • slot mapping：[5, 14, 13, 16, 17]

  • attention mask：5 * 8

每个 token 有一个 1 * 8 的向量，共有 5 个调度 token。

最后

如果你理解了步骤 1 和步骤 2，那么后续的所有步骤你都会明白。

希望本文档能帮助你更好地理解 vLLM 如何为模型前向传播准备输入。如果你有任何好的想法，欢迎向我们贡献。