---
tags: [AI, LLM, 推理优化]
阶段: 05-Transformer与LLM原理
难度: ★★★
created: 2026-10-18
related: "[[因果注意力与多头注意力]], [[分组查询注意力GQA]], [[Llama-2架构复盘]]"
---

# KV缓存

## 定义

**KV 缓存**（KV cache）是自回归 Transformer 推理中的状态复用机制：逐层前向时把历史位置的键矩阵与值矩阵保存在显存中，使第 $t$ 步解码只需为最新位置计算查询、键、值，并从缓存读取全部历史键值完成注意力，而不对整个前缀重新前向。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $B$ | 批量大小 |
| $T$ | 位置总数，含提示词与已生成 token |
| $P$ | 提示词长度 |
| $L$ | Transformer 层数 |
| $H$ | 查询头数 |
| $H_{kv}$ | 键值头数，多头注意力中 $H_{kv}=H$ |
| $d_h$ | 每头维度 |
| $d$ | 模型维度，$d=H d_h$ |
| $t$ | 当前解码步的缓存长度，即已有键值的位置数 |
| $\mathbf{K}^{(\ell)},\mathbf{V}^{(\ell)}$ | 第 $\ell$ 层的键、值缓存，形状 $[B,H_{kv},t,d_h]$ |
| $b$ | 每个缓存元素的字节数，fp16 为 2，fp8 为 1 |
| $M$ | 缓存总字节数 |
| $A$ | 算术强度，每字节显存流量对应的浮点运算数 |
| $W_{\text{bw}}$ | 显存带宽，单位 B/s |

术语定义：**预填充**（prefill）指推理开始时对整段提示词做一次并行前向，并把各层键值写入缓存；**解码**（decode）指此后每次只输入一个 token、读取缓存并生成下一个 token 的阶段；**上下文长度**指当前参与注意力的位置数，等于提示词长度加已生成 token 数；**算术强度**（arithmetic intensity）指一段计算涉及的浮点运算数与所需显存字节数之比，单位 FLOP/byte；**页**（page 或 block）指分页缓存管理中固定大小的键值存储单元，通常容纳 16 个位置。

## 为什么重要

自回归语言模型把序列概率分解为逐位置条件概率的乘积，生成第 $t+1$ 个 token 必须先把前缀 $\mathbf{x}_{\le t}$ 送进模型。若不做缓存，第 $t$ 步要对长度 $t$ 的前缀完整前向一次，第 $t+1$ 步再对长度 $t+1$ 的前缀完整前向一次，其中前 $t$ 个位置的计算结果与上一步完全相同。这些重复计算的注意力部分累计为 $\sum_{t=1}^{T}4t^{2}d=\frac{4}{3}dT^{3}+O(dT^{2})$，即 $O(T^{3}d)$；投影与前馈部分的累计为 $12d^{2}T^{2}$。缓存把这两项分别降到 $O(T^{2}d)$ 与 $O(Td^{2})$，是推理可用性的前提：没有它，生成长文本的代价随长度成立方增长，交互式应用的延迟无法接受。

缓存的代价是显存。Llama-2 7B 在 $T=4096$、$B=1$、fp16 下需要 $2$ GiB，是模型权重 $12.6$ GiB 的 $16\%$；批量升到 $32$ 则为 $64$ GiB，超过权重本身。显存占用还决定可服务的并发请求数与最大上下文长度，因而直接进入服务成本。缓存带来的第二个后果是瓶颈转移：解码阶段每个 token 的计算量只有 $O(td)$，却要读取全部缓存与全部权重，算术强度约为 $1$ FLOP/byte，远低于 GPU 的算力带宽比，于是解码由显存带宽而非浮点算力决定。这一结论解释了后续一系列优化的动机：[[分组查询注意力GQA]] 减少键值头数，量化缓存减少每元素字节数，PagedAttention 减少分页浪费，[[超长上下文-无限注意力]] 用压缩状态替代线性增长的缓存。

在本库中的位置：本篇承接 [[因果注意力与多头注意力]] 的掩码与多头结构，把训练时的并行前向改写成推理时的两阶段前向；[[自回归生成与采样]] 讨论在得到 logits 后如何选择 token，本篇只处理得到 logits 之前的计算组织。对应学习目标：懂原理要求推出 $O(T^{3}d)$ 与 $O(T^{2}d)$ 两个复杂度并说明缓存为何不改变输出；能复现要求实现带缓存的注意力并核对有/无缓存的输出一致性；会评估要求能按公式估算给定模型与上下文长度的缓存显存，并判断解码处于算力受限还是带宽受限区间。

## 原理与推导

### 1 不使用缓存时的重复计算

设第 $t$ 步的输入为长度 $t$ 的前缀，模型共 $L$ 层，每层包含一次因果自注意力与一次前馈网络。先计一层注意力在一个解码步上的浮点运算数，约定一次乘加记 2 FLOPs。

查询与键的乘积 $\mathbf{Q}\mathbf{K}^{\top}$ 输出 $t\times t$ 个分数，每个分数是长度 $d_h$ 的点积，单个头需要 $2t^{2}d_h$，$H$ 个头合计

$$
2t^{2}d_h\cdot H=2t^{2}d .
$$

对分数矩阵做 softmax 需要 $O(t^{2})$ 次运算，相对矩阵乘法可忽略。加权求和 $\mathbf{A}\mathbf{V}$ 把 $t\times t$ 的权重矩阵与 $t\times d_h$ 的值矩阵相乘，单个头 $2t^{2}d_h$，合计 $2t^{2}d$。于是单层注意力的矩阵乘法代价为

$$
F_{\text{attn}}(t)=2t^{2}d+2t^{2}d=4t^{2}d .
$$

同一层还有四个投影矩阵，每个把 $t\times d$ 的激活乘以 $d\times d$ 的权重，代价 $2td^{2}$，合计 $8td^{2}$；前馈网络把维度升到 $4d$ 再降回 $d$，代价 $2\cdot t\cdot d\cdot 4d\cdot 2=16td^{2}$。单层单步总代价为

$$
F_{\text{layer}}(t)=4t^{2}d+24td^{2}.
$$

对整个生成过程求和。第 $t$ 步处理长度 $t$ 的前缀，$t$ 从 $1$ 到 $T$：

$$
F_{\text{nocache}}(T)=\sum_{t=1}^{T}\left(4t^{2}d+24td^{2}\right)
=\frac{4}{3}dT^{3}+12d^{2}T^{2}+O(dT^{2}).
$$

第一项来自注意力，复杂度 $O(T^{3}d)$；第二项来自被反复重算的投影与前馈，复杂度 $O(T^{2}d^{2})$。两项的相对大小为 $T/(9d)$：当 $T<9d$ 时重复的投影与前馈占主导，当 $T>9d$ 时注意力占主导。以 $d=4096$ 为例，交叉点在 $T\approx 36864$；在 $T=4096$ 时投影与前馈的重算量为 $3.38\times10^{15}$，注意力为 $3.75\times10^{14}$，前者约为后者的 9 倍。这说明「无缓存很慢」不只因为注意力是二次的，更因为每个历史 token 的整层计算被重复执行了 $O(T)$ 次。

### 2 键值可复用的依据

缓存之所以不改变输出，依赖一条结构性质：因果 Transformer 中位置 $j$ 的键与值只由前缀决定，与后续 token 无关。

设第 $\ell-1$ 层位置 $j$ 的表示为 $\mathbf{h}_{j}^{(\ell-1)}$，第 $\ell$ 层的键与值为

$$
\mathbf{k}_{j}^{(\ell)}=\mathrm{LN}\!\left(\mathbf{h}_{j}^{(\ell-1)}\right)\mathbf{W}_{K}^{(\ell)},\qquad
\mathbf{v}_{j}^{(\ell)}=\mathrm{LN}\!\left(\mathbf{h}_{j}^{(\ell-1)}\right)\mathbf{W}_{V}^{(\ell)},
$$

其中 $\mathrm{LN}$ 是逐位置归一化，$\mathbf{W}_{K}^{(\ell)},\mathbf{W}_{V}^{(\ell)}\in\mathbb{R}^{d\times d}$ 为该层参数。由 [[因果注意力与多头注意力]] 的归纳证明，$\mathbf{h}_{j}^{(\ell-1)}$ 只是 $\mathbf{x}_{\le j}$ 的函数。因此 $\mathbf{k}_{j}^{(\ell)}$ 与 $\mathbf{v}_{j}^{(\ell)}$ 也只是 $\mathbf{x}_{\le j}$ 的函数；当序列从长度 $t$ 延长到 $t+1$ 时，$j\le t$ 的这些向量逐元素不变。归纳到所有层，结论成立：缓存中保存的键值与重新计算得到的键值完全相同，差别只在浮点求和顺序。

由此还可得到两点推论。其一，查询不需要缓存：位置 $t$ 的查询只在该步使用一次，之后不再参与任何计算。其二，不能只缓存注意力分数：softmax 的分母随 $t$ 变化，第 $t+1$ 步的权重与第 $t$ 步不同，保存分数无法复用，必须保存未归一化的键与值。

### 3 缓存的形状与两阶段前向

每层保存两个张量，形状均为

$$
\mathbf{K}^{(\ell)},\mathbf{V}^{(\ell)}\in\mathbb{R}^{B\times H_{kv}\times t\times d_h},
$$

元素个数为 $B\cdot H_{kv}\cdot t\cdot d_h$。$B$ 是批量，$H_{kv}$ 是键值头数，多头注意力下 $H_{kv}=H$，分组查询注意力下 $H_{kv}<H$；$t$ 是已缓存的位置数，$d_h$ 是每头维度。全部 $L$ 层与键值两份合计 $2LH_{kv}Btd_h$ 个元素，乘以每元素字节数即显存占用。

前向过程分为两个阶段，结构如下。

```mermaid
flowchart LR
    A["提示词，形状 B×P"] --> B["prefill：整段并行前向，写入各层 K/V"]
    B --> C["decode：输入 1 个 token，位置为 t"]
    C --> D["读取长度 t 的 K/V，计算 1×t 注意力"]
    D --> E["采样下一个 token，位置 t+1"]
    E --> C
```

预填充阶段一次处理 $P$ 个位置，查询、键、值的长度都是 $P$，注意力分数矩阵为 $P\times P$ 并施加因果掩码，计算可以并行；该阶段把各层键值写入缓存，缓存长度变为 $P$。解码阶段每次输入 1 个位置，查询长度为 1，键与值的长度为 $t+1$（含新位置），分数矩阵为 $1\times(t+1)$，不需要因果掩码，因为唯一的查询位于最后一位，可以读取全部缓存。

带缓存的前向伪代码如下，其中 $\mathrm{concat}$ 沿位置维拼接。

```text
输入：新 token 的嵌入 x，形状 [B, 1, d]；位置偏移 t；各层缓存 K[l], V[l]
for l in 1..L:
    h  = LayerNorm(x)
    q  = h @ W_Q[l]                     # [B, 1, d] -> [B, H, 1, d_h]
    k  = h @ W_K[l]                     # [B, H_kv, 1, d_h]
    v  = h @ W_V[l]                     # [B, H_kv, 1, d_h]
    K[l] = concat(K[l], k, axis=2)      # [B, H_kv, t+1, d_h]
    V[l] = concat(V[l], v, axis=2)
    s  = q @ K[l]^T / sqrt(d_h)         # [B, H, 1, t+1]
    a  = softmax(s, axis=-1)
    o  = (a @ V[l]) -> [B, 1, d]
    x  = x + o @ W_O[l]
    x  = x + FFN(LayerNorm(x))
return LMHead(LayerNorm(x))
```

若把预填充与解码合并看待，可以把两者写成同一段代码，用查询长度 $T_q$ 与缓存长度 $T_k$ 区分：$T_q=T_k=P$ 且需要因果掩码时为预填充；$T_q=1$、$T_k=t+1$ 且无需掩码时为解码；$T_q>1$ 且 $T_k>T_q$ 时为分块预填充，此时掩码的偏移量必须等于 $T_k-T_q$，否则新块会看到本块中位于其后的位置。

### 4 计算量与缓存长度的量化对比

缓存的直接效果是把单步代价从 $4t^{2}d+24td^{2}$ 降到 $4td+24d^{2}$，即每个解码步的计算量降为原来的约 $1/t$。在 $t=4096$、$d=4096$ 时，单层单步从 $1.92\times10^{12}$ 降到 $4.70\times10^{8}$，比值恰为 4096。

对整个生成过程，设从空上下文生成 $T$ 个 token，缓存路径的总代价为

$$
F_{\text{cache}}(T)=\sum_{t=1}^{T}\left(4td+24d^{2}\right)=2dT^{2}+24d^{2}T,
$$

注意力部分为 $O(T^{2}d)$，比无缓存的 $O(T^{3}d)$ 低一个 $T$ 因子。下表给出 $d=4096$ 时单层前向的 FLOPs，由第 1 节与本节公式计算；总倍数为前两列之和与第四列之比。

| $T$ | 无缓存注意力 | 无缓存投影与前馈 | 有缓存注意力 | 有缓存总计 | 总倍数 | 注意力倍数 |
|---|---|---|---|---|---|---|
| 512 | $7.35\times10^{11}$ | $5.29\times10^{13}$ | $2.15\times10^{9}$ | $2.08\times10^{11}$ | 257 | 342 |
| 1024 | $5.87\times10^{12}$ | $2.11\times10^{14}$ | $8.60\times10^{9}$ | $4.21\times10^{11}$ | 516 | 683 |
| 2048 | $4.69\times10^{13}$ | $8.45\times10^{14}$ | $3.44\times10^{10}$ | $8.59\times10^{11}$ | 1038 | 1366 |
| 4096 | $3.75\times10^{14}$ | $3.38\times10^{15}$ | $1.37\times10^{11}$ | $1.79\times10^{12}$ | 2101 | 2731 |
| 8192 | $3.00\times10^{15}$ | $1.35\times10^{16}$ | $5.50\times10^{11}$ | $3.85\times10^{12}$ | 4292 | 5462 |

总倍数随 $T$ 近似线性增长，因为注意力与投影两部分的比值都含一个 $T$ 因子。表中「有缓存总计」同时包含解码的投影与前馈，即 $24d^{2}T$，它在 $T=4096$ 时为 $1.65\times10^{12}$，是缓存路径的主要项。这说明缓存虽然消除了重复计算，但每个解码步仍要完整读取一遍权重，权重读取成为固定成本；后文第 6 节将说明这一固定成本与缓存读取共同构成带宽瓶颈。

### 5 显存公式与算例

把第 3 节的元素个数乘以字节数，得到缓存显存公式：

$$
M=\underbrace{2}_{\text{K 与 V}}\cdot L\cdot \underbrace{H_{kv}\cdot d_h}_{\text{每位置每层元素数}}\cdot T\cdot B\cdot \underbrace{b}_{\text{每元素字节数}}.
$$

逐项说明：因子 2 对应键与值两份张量；$L$ 是层数，每层各有独立的投影与缓存；$H_{kv}d_h$ 是单个位置在单层中键的元素数，值同理，多头注意力下 $H_{kv}=H$，分组查询注意力下 $H_{kv}<H$；$T$ 是缓存的位数量，等于提示词长度加已生成 token 数；$B$ 是同时解码的序列数；$b$ 是元素字节数，fp16 为 2，bf16 为 2，fp8 与 int8 为 1。

以 Llama-2 7B 为例：$L=32$，$H_{kv}=H=32$，$d_h=128$，$T=4096$，$B=1$，fp16。先算单个位置在全部 32 层上的键值元素数：

$$
2\times32\times32\times128=262144 .
$$

乘以 4096 个位置得 $2^{30}$ 个元素，再乘以 2 字节得 $2^{31}$ 字节，恰为 $2$ GiB。另一种算法是先算每 token 字节数：$2\cdot 32\cdot 32\cdot 128\cdot 2=524288$ 字节 $=512$ KiB，再乘以 4096 得 $2$ GiB。每 token 512 KiB 这一数字便于心算任意上下文长度。

| 模型 | $L$ | $H_{kv}$ | 每 token 字节 | $T=4096,B=1$ | 权重（fp16） |
|---|---|---|---|---|---|
| Llama-2 7B | 32 | 32 | 512 KiB | 2.0 GiB | 12.6 GiB |
| Llama-2 13B | 40 | 40 | 800 KiB | 3.125 GiB | 24.2 GiB |
| Llama-2 70B（GQA-8） | 80 | 8 | 320 KiB | 1.25 GiB | 128.5 GiB |

批量与上下文对 7B 模型的影响如下表，数值为 $2\cdot32\cdot32\cdot128\cdot T\cdot B\cdot2$ 字节。

| $T$ \ $B$ | 1 | 8 | 16 | 32 |
|---|---|---|---|---|
| 1024 | 512 MiB | 4 GiB | 8 GiB | 16 GiB |
| 2048 | 1 GiB | 8 GiB | 16 GiB | 32 GiB |
| 4096 | 2 GiB | 16 GiB | 32 GiB | 64 GiB |
| 8192 | 4 GiB | 32 GiB | 64 GiB | 128 GiB |
| 32768 | 16 GiB | 128 GiB | 256 GiB | 512 GiB |

表中有两点值得注意。其一，缓存在 $T=32768$、$B=16$ 时达到 $256$ GiB，远超单卡容量，长上下文服务必须依靠分页、量化或键值头共享。其二，若实现按最大长度 $T_{\max}$ 预分配，而实际请求远短于 $T_{\max}$，则显存按最坏情况占用，浪费随请求长度分布恶化；这正是不按需分配的分页方案要解决的问题。

### 6 带宽瓶颈与算术强度

解码阶段每个 token 的计算量与访存量都可以逐层估计。设当前缓存长度 $t$，批量 $B$，单层注意力的计算量为 $4Btd$ FLOPs，需读取的缓存为 $4Btd$ 字节（fp16，$B\cdot 2td$ 个元素），读取的权重为 $24d^{2}$ 字节（$12d^{2}$ 个参数）。算术强度为

$$
A(B,t)=\frac{B\left(4td+24d^{2}\right)}{4Btd+24d^{2}}.
$$

分子是计算量，分母是字节数。当 $B\to\infty$ 时权重项被摊薄，$A\to (4td+24d^{2})/(4td)=1+6d/t$；当 $t$ 增大时该上限趋近 1。$d=4096$、$t=4096$ 时上限为 7 FLOP/byte，而 A100 的 fp16 张量算力约 312 TFLOPS、显存带宽约 2.0 TB/s，算力带宽比约 156 FLOP/byte。解码的算术强度比该阈值低数倍到两个数量级，因此处于带宽受限区：增加算力不能降低延迟，减少字节才能。

| 配置 | $B=1$ | $B=8$ | $B=32$ |
|---|---|---|---|
| 7B，$t=4096$，MHA | 1.00 | 4.00 | 5.89 |
| 7B，$t=4096$，GQA-8 | 1.14 | 8.00 | 22.40 |
| 70B，$t=4096$，MHA | 1.00 | 5.20 | 9.45 |
| 70B，$t=4096$，GQA-8 | 1.07 | 8.00 | 26.00 |

表中的单位是 FLOP/byte。批量增大提高算术强度，原因是权重读取被多个序列分摊；缓存的读取却随批量线性增长，所以算术强度存在上限。分组查询注意力把缓存读取按 $n_{\text{rep}}=H/H_{kv}$ 缩小，因而抬高了上限，详见 [[分组查询注意力GQA]]。

用带宽估计延迟下界。7B 模型在 $t=4096$、$B=1$ 时，单步需读取权重 $13.48$ GB 与缓存 $2.15$ GB，合计 $15.6$ GB；按 2.0 TB/s 计需 $7.8$ ms，对应约 128 token/s 的上界。$B=8$ 时缓存增至 $16$ GiB，单步流量 $30.7$ GB，耗时 $15.3$ ms，聚合吞吐上界约 522 token/s；$B=32$ 时缓存 $64$ GiB，单步流量 $82.2$ GB，耗时 $41.1$ ms，上界约 779 token/s，但此时权重与缓存合计已接近 80 GB 卡的容量上限，实际不可行。这些数字说明两点：小批量下权重读取占主导，缓存读取占比约 $1/7$；批量增大后缓存项占比上升，GQA 与量化的收益随之显现。真实系统的吞吐低于该上界，因为注意力核的访存不连续、批内长度不一导致填充、以及采样与调度开销。

### 7 PagedAttention 的分页思想

缓存按请求动态增长，而张量需要连续显存，直接按最大长度预分配会造成两类浪费：请求实际长度小于预留长度时的内部碎片；不同请求长度不一造成的分配器外部碎片。束搜索与并行采样还需要在同一提示词上复制多份缓存。

**分页注意力**（PagedAttention）把缓存划分为固定大小的页，每页容纳若干位置（常用 16），页在物理显存中不必连续；每个序列维护一张页表，把逻辑页号映射到物理页号。注意力核按页表逐页读取键值并计算，页表在序列增长时追加条目。由此得到三项性质。第一，内部碎片的上界是一页，因为只有最后一个未写满的页存在浪费。第二，不同序列可以共享物理页并在写入时复制，束搜索的多个分支与并行采样因此只需在分歧处复制，不必复制整份缓存。第三，显存按实际使用量分配，可服务的并发请求数由真实占用而非最坏情况决定。

代价是访存不再连续：注意力核需要按页表收集键值，单页内的块仍然连续，页间跳跃；实现上要把逻辑位置映射为页号与页内偏移，并处理跨页的查询。论文报告在相同延迟下吞吐相对当时的系统提升 2 至 4 倍，长序列与大模型的提升更明显。分页不改变第 5 节的显存总量下界，只消除分配浪费；它也不减少字节数，因此与 GQA、量化正交，可以叠加。

### 8 量化键值缓存

减少字节的另一条路径是降低 $b$。fp16 换成 fp8（E4M3 或 E5M2）或 int8 后，$b$ 从 2 降为 1，缓存显存与解码读取字节同时减半，延迟下界按比例下降。量化按作用范围分为三类：逐张量量化对整个缓存用一个缩放因子，实现最简单，误差最大；逐 token 量化对每个位置的整个向量用独立缩放因子，适合值向量；逐通道量化对每个特征维用独立缩放因子，适合键向量，因为键在某些通道上存在幅度远大于其余通道的离群值，逐 token 缩放会被这些通道支配。

量化-反量化在每层引入加性误差，误差随层数与上下文长度累积；键的误差改变注意力权重的分布，值的误差直接叠加到输出。实践中需要校准集确定缩放因子，并在长上下文任务上验证退化。计算量不变，收益全部来自带宽，因此量化与 GQA 叠加时收益按字节数相乘，而两者对质量的影响并不独立，需要分别评估。

## 关键直觉

> [!tip] 机制表述
> KV 缓存利用的是因果注意力的一条结构性质：位置 $j$ 的键与值只由前缀 $\mathbf{x}_{\le j}$ 决定，追加新 token 不会改变它们。缓存把「每步重算整个前缀」替换为「每步为 1 个新位置计算查询、键、值，再对长度为 $t$ 的键值表做一次加权聚合」。它不改变模型输出，只改变计算的组织方式，代价是把 $O(T^{2}d)$ 的计算换成 $O(LH_{kv}d_hT)$ 的显存占用与同量的读取流量。定义中的 $t$ 即缓存长度，$t$ 随时间线性增长，所以显存与每步读取字节都随时间线性增长，而每步计算量也线性增长，二者的比值即第 6 节的算术强度。

## 例子与代码

### 手算：3 个位置、单头、$d_h=2$

取一个注意力头，$d_h=2$，缩放因子 $1/\sqrt{2}$。3 个位置的查询、键、值如下。

| 位置 | $\mathbf{q}$ | $\mathbf{k}$ | $\mathbf{v}$ |
|---|---|---|---|
| 1 | — | $(1,0)$ | $(1,2)$ |
| 2 | — | $(0,1)$ | $(3,4)$ |
| 3 | $(1,0)$ | $(1,1)$ | $(5,6)$ |

位置 3 的分数为 $\mathbf{q}_3\cdot\mathbf{k}_1=1$、$\mathbf{q}_3\cdot\mathbf{k}_2=0$、$\mathbf{q}_3\cdot\mathbf{k}_3=1$，缩放后为 $0.7071,0,0.7071$。softmax 分母为 $e^{0.7071}+e^{0}+e^{0.7071}=2.0281+1+2.0281=5.0562$，权重为 $0.4011,0.1978,0.4011$。输出为

$$
0.4011(1,2)+0.1978(3,4)+0.4011(5,6)=(3.000,4.000).
$$

带缓存时，第 3 步只需用 $\mathbf{q}_3$ 与缓存中的 $\mathbf{k}_{1:2},\mathbf{v}_{1:2}$ 加上新算的 $\mathbf{k}_3,\mathbf{v}_3$；$\mathbf{k}_1,\mathbf{v}_1$ 在第 1 步算出后不再改变，$\mathbf{k}_2,\mathbf{v}_2$ 同理。无缓存时第 3 步会重算全部 3 个位置的键值，数值相同，只是多做了两次投影。

### PyTorch 实现与有/无缓存对照

下面的实现把缓存作为每层的一个元组传入传出，形状 $[B,H,T_{\text{cache}},d_h]$。为便于观察位置索引错误，模型使用可学习的绝对位置嵌入，位置由 `pos_offset` 显式给出。

```python
import math
import time

import torch
import torch.nn as nn
import torch.nn.functional as F


class CausalSelfAttention(nn.Module):
    """带可选 KV 缓存的因果自注意力；x 形状 [B, T, C]。"""

    def __init__(self, d_model: int, n_head: int):
        super().__init__()
        assert d_model % n_head == 0
        self.n_head = n_head
        self.head_dim = d_model // n_head
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.proj = nn.Linear(d_model, d_model, bias=False)

    def forward(self, x, past=None):
        B, T, C = x.shape
        q, k, v = self.qkv(x).split(C, dim=2)
        q = q.view(B, T, self.n_head, self.head_dim).transpose(1, 2)  # [B,H,T,dh]
        k = k.view(B, T, self.n_head, self.head_dim).transpose(1, 2)
        v = v.view(B, T, self.n_head, self.head_dim).transpose(1, 2)
        if past is not None:
            # 缓存必须与计算图断开，否则每步都会保留历史激活
            k = torch.cat([past[0].detach(), k], dim=2)
            v = torch.cat([past[1].detach(), v], dim=2)
        Tk = k.size(2)
        scores = (q @ k.transpose(-2, -1)) / math.sqrt(self.head_dim)  # [B,H,T,Tk]
        # 第 i 个查询的绝对位置是 Tk-T+i，屏蔽 j > Tk-T+i 的键
        mask = torch.triu(torch.ones(T, Tk, device=x.device), diagonal=Tk - T + 1).bool()
        scores = scores.masked_fill(mask, float("-inf"))
        out = (F.softmax(scores, dim=-1) @ v).transpose(1, 2).reshape(B, T, C)
        return self.proj(out), (k, v)


class Block(nn.Module):
    def __init__(self, d_model: int, n_head: int):
        super().__init__()
        self.ln1 = nn.LayerNorm(d_model)
        self.attn = CausalSelfAttention(d_model, n_head)
        self.ln2 = nn.LayerNorm(d_model)
        self.mlp = nn.Sequential(
            nn.Linear(d_model, 4 * d_model), nn.GELU(), nn.Linear(4 * d_model, d_model)
        )

    def forward(self, x, past=None):
        a, present = self.attn(self.ln1(x), past)
        x = x + a
        return x + self.mlp(self.ln2(x)), present


class TinyGPT(nn.Module):
    def __init__(self, vocab_size, d_model=128, n_layer=4, n_head=4, block_size=512):
        super().__init__()
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(block_size, d_model)  # 绝对位置，便于暴露位置索引错误
        self.blocks = nn.ModuleList([Block(d_model, n_head) for _ in range(n_layer)])
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size, bias=False)

    def forward(self, idx, pos_offset=0, past=None):
        B, T = idx.shape
        pos = torch.arange(pos_offset, pos_offset + T, device=idx.device)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        presents = []
        for i, blk in enumerate(self.blocks):
            x, present = blk(x, None if past is None else past[i])
            presents.append(present)
        return self.head(self.ln_f(x)), presents


@torch.no_grad()
def generate(model, idx, n_new, use_cache=True):
    """贪心解码；返回生成后的序列与每步的 logits。"""
    model.eval()
    pos, past, logits_all = 0, None, []
    for _ in range(n_new):
        if use_cache:
            cur = idx if pos == 0 else idx[:, -1:]  # 首步处理整段提示，之后只输入 1 个 token
            logits, past = model(cur, pos, past)
        else:
            cur = idx                               # 每步重算整个前缀
            logits, past = model(cur, 0, None)
        pos += cur.size(1)
        logits_all.append(logits[:, -1])
        nxt = logits[:, -1].argmax(dim=-1, keepdim=True)
        idx = torch.cat([idx, nxt], dim=1)
    return idx, torch.stack(logits_all, dim=1)
```

这段代码有三处关键设计。第一，`split(C, dim=2)` 把融合的 $\mathbf{Q}\mathbf{K}\mathbf{V}$ 投影拆开，形状变换 `view(...).transpose(1, 2)` 把头维放到批量维之后，这是后续所有计算的前提；去掉 `transpose` 会把头维当作位置维，注意力变成跨头求和，输出形状仍然正确但语义错误。第二，掩码用 `diagonal=Tk - T + 1` 计算偏移，使查询块的最后一行对齐缓存末尾；写成 `diagonal=1` 在解码时不会报错，因为 $T=1$ 时掩码全为零，但在分块预填充时会把新块内部的位置关系算错。第三，`past[0].detach()` 断开计算图；在 `torch.no_grad()` 下该操作是空操作，而一旦在需要梯度的上下文中调用带缓存的解码，不 detach 会让每步的缓存都携带历史计算图，显存随时间线性增长。

下面比较两种路径的耗时与输出。计时前需同步 GPU，CPU 上直接计时即可。

```python
torch.manual_seed(0)
model = TinyGPT(vocab_size=128, d_model=128, n_layer=4, n_head=4)
prompt = torch.randint(0, 128, (1, 64))


def bench(use_cache):
    t0 = time.perf_counter()
    out, logits = generate(model, prompt, 64, use_cache)
    return (time.perf_counter() - t0) / 64 * 1000, out, logits


ms_c, tok_c, logits_c = bench(True)
ms_n, tok_n, logits_n = bench(False)
print(f"有缓存 {ms_c:.2f} ms/token，无缓存 {ms_n:.2f} ms/token，加速 {ms_n / ms_c:.1f}x")
print("生成 token 一致:", torch.equal(tok_c, tok_n))
print("logits 最大绝对误差:", (logits_c - logits_n).abs().max().item())
```

预期结果是两次生成的 token 序列完全相同，logits 的最大绝对误差在 $10^{-6}$ 量级，差异只来自矩阵乘的求和顺序；有缓存的每 token 耗时显著低于无缓存，且两者的比值随提示词长度增大而增大，因为无缓存路径的代价与上下文长度成正比。计时数值依赖硬件与线程数，本节只使用其比较关系。

### 无 torch 时的 NumPy 版本

NumPy 没有自动微分与 GPU 张量，但可以逐行复现同一套前向过程。以下代码构建 2 层、4 头、$d=64$ 的随机模型，用正弦位置编码，比较两条解码路径的耗时与输出。

```python
import math
import time

import numpy as np

L, H, D, DH, V = 2, 4, 64, 16, 128
rng = np.random.default_rng(0)


def layer_norm(x, g, b, eps=1e-5):
    mu = x.mean(-1, keepdims=True)
    var = x.var(-1, keepdims=True)
    return (x - mu) / np.sqrt(var + eps) * g + b


def softmax(x):
    e = np.exp(x - x.max(-1, keepdims=True))
    return e / e.sum(-1, keepdims=True)


def gelu(x):
    return 0.5 * x * (1.0 + np.tanh(0.7978845608 * (x + 0.044715 * x ** 3)))


def sinusoidal(length, dim):
    pos = np.arange(length)[:, None]
    idx = np.arange(0, dim, 2)[None, :]
    ang = pos / 10000.0 ** (idx / dim)
    pe = np.zeros((length, dim))
    pe[:, 0::2] = np.sin(ang)
    pe[:, 1::2] = np.cos(ang)
    return pe


PE = sinusoidal(1024, D)
P = {"emb": rng.normal(0, 0.02, (V, D)), "head": rng.normal(0, 0.02, (D, V)), "blocks": []}
for _ in range(L):
    P["blocks"].append({
        "g1": np.ones(D), "b1n": np.zeros(D), "g2": np.ones(D), "b2n": np.zeros(D),
        "Wq": rng.normal(0, 0.02, (D, D)), "Wk": rng.normal(0, 0.02, (D, D)),
        "Wv": rng.normal(0, 0.02, (D, D)), "Wo": rng.normal(0, 0.02, (D, D)),
        "W1": rng.normal(0, 0.02, (D, 4 * D)), "b1": np.zeros(4 * D),
        "W2": rng.normal(0, 0.02, (4 * D, D)), "b2": np.zeros(D),
    })
P["gf"], P["bf"] = np.ones(D), np.zeros(D)


def forward(idx, pos0, cache=None):
    B, T = idx.shape
    x = P["emb"][idx] + PE[pos0:pos0 + T][None, :, :]
    for l, blk in enumerate(P["blocks"]):
        h = layer_norm(x, blk["g1"], blk["b1n"])
        q = (h @ blk["Wq"]).reshape(B, T, H, DH).transpose(0, 2, 1, 3)
        k = (h @ blk["Wk"]).reshape(B, T, H, DH).transpose(0, 2, 1, 3)
        v = (h @ blk["Wv"]).reshape(B, T, H, DH).transpose(0, 2, 1, 3)
        if cache is not None:
            k = np.concatenate([cache[l]["k"], k], axis=2)
            v = np.concatenate([cache[l]["v"], v], axis=2)
            cache[l]["k"], cache[l]["v"] = k, v
        Tk = k.shape[2]
        scores = q @ k.transpose(0, 1, 3, 2) / math.sqrt(DH)
        future = np.triu(np.ones((T, Tk), dtype=bool), k=Tk - T + 1)
        attn = softmax(np.where(future, -1e30, scores))
        out = (attn @ v).transpose(0, 2, 1, 3).reshape(B, T, D)
        x = x + out @ blk["Wo"]
        x = x + gelu(layer_norm(x, blk["g2"], blk["b2n"]) @ blk["W1"] + blk["b1"]) @ blk["W2"] + blk["b2"]
    return layer_norm(x, P["gf"], P["bf"]) @ P["head"]


def generate(prompt, n_new, use_cache):
    idx, cache = prompt.copy(), None
    if use_cache:
        cache = [{"k": np.zeros((prompt.shape[0], H, 0, DH)),
                  "v": np.zeros((prompt.shape[0], H, 0, DH))} for _ in range(L)]
    logits_all = []
    t0 = time.perf_counter()
    for _ in range(n_new):
        if use_cache:
            fresh = idx if cache[0]["k"].shape[2] == 0 else idx[:, -1:]
            logits = forward(fresh, idx.shape[1] - fresh.shape[1], cache)
        else:
            logits = forward(idx, 0, None)
        logits_all.append(logits[:, -1])
        idx = np.concatenate([idx, logits[:, -1].argmax(-1, keepdims=True)], axis=1)
    return idx, np.stack(logits_all, axis=1), (time.perf_counter() - t0) / n_new * 1000


prompt = rng.integers(0, V, (1, 48))
tok_c, logits_c, ms_c = generate(prompt, 48, True)
tok_n, logits_n, ms_n = generate(prompt, 48, False)
print("生成 token 一致:", np.array_equal(tok_c, tok_n))
print("logits 最大绝对误差:", np.abs(logits_c - logits_n).max())
print(f"有缓存 {ms_c:.2f} ms/token，无缓存 {ms_n:.2f} ms/token，加速 {ms_n / ms_c:.1f}x")
```

在 CPU（Python 3.12，NumPy 2.3）上运行上述代码，实测输出为

```text
生成 token 一致: True
logits 最大绝对误差: 4.440892098500626e-16
有缓存 0.22 ms/token，无缓存 2.05 ms/token，加速 9.2x
```

此处提示词 48 个位置、生成 48 个 token，平均上下文约 72，加速比约 9。把生成步数增大到 512 后，同一台机器上实测加速比升至约 127，因为无缓存路径每步重算的投影量随上下文线性增长，而有缓存路径每步只处理一个位置。把解码时的 `pos0` 写死为 0，其余不变，则 logits 与正确路径的最大偏差为 $0.73$，量级为 $10^{-1}$，而生成仍在继续，不会抛出异常。NumPy 版本的用途是验证语义与观察趋势；PyTorch 版本才是可部署实现，两者在相同输入下应当给出相同输出。

### 显存估算函数

下面的函数实现第 5 节公式，参数依次为层数、键值头数、每头维度、序列长度、批量与元素字节数。

```python
def kv_cache_bytes(n_layer, n_kv_head, head_dim, seq_len, batch=1, dtype_bytes=2):
    """返回 KV 缓存字节数：2 (K/V) × L × H_kv × d_h × T × B × bytes。"""
    return 2 * n_layer * n_kv_head * head_dim * seq_len * batch * dtype_bytes


LLAMA2 = {
    "7B": (32, 32, 128),      # (L, H_kv, d_h)，MHA
    "13B": (40, 40, 128),     # MHA
    "70B": (80, 8, 128),      # GQA，8 个键值头
}
for name, (n_layer, n_kv, dh) in LLAMA2.items():
    for seq_len in (2048, 4096):
        mib = kv_cache_bytes(n_layer, n_kv, dh, seq_len) / 2 ** 20
        print(f"Llama-2 {name}: T={seq_len}, B=1, fp16 -> {mib:.0f} MiB")
print("7B, T=4096, B=32:", kv_cache_bytes(32, 32, 128, 4096, batch=32) / 2 ** 30, "GiB")
print("7B, T=4096, B=1, fp8:", kv_cache_bytes(32, 32, 128, 4096, dtype_bytes=1) / 2 ** 20, "MiB")
```

输出为

```text
Llama-2 7B: T=2048, B=1, fp16 -> 1024 MiB
Llama-2 7B: T=4096, B=1, fp16 -> 2048 MiB
Llama-2 13B: T=2048, B=1, fp16 -> 1600 MiB
Llama-2 13B: T=4096, B=1, fp16 -> 3125 MiB
Llama-2 70B: T=2048, B=1, fp16 -> 640 MiB
Llama-2 70B: T=4096, B=1, fp16 -> 1280 MiB
7B, T=4096, B=32: 64.0 GiB
7B, T=4096, B=1, fp8: 1024 MiB
```

若把 70B 的 `n_kv` 改成 64，即假设它使用多头注意力，则 $T=4096$ 时结果为 $10240$ MiB，是 GQA 配置的 8 倍。这个替换是检验公式是否理解正确的最快方法。

## 易错点

> [!warning] 常见错误
> 1. 忘记 `detach` 缓存。在 `requires_grad=True` 的上下文中逐步解码时，若把上一步的缓存直接拼接到本步张量，缓存会携带完整计算图，显存随步数增长，反向传播也会穿过全部历史步。推理必须在 `torch.no_grad()` 下进行，并显式 `detach` 缓存。
> 2. 位置索引错位。解码时新 token 的绝对位置是缓存长度 $t$，不是 0，也不是 `t+1`。若每步把 `pos_offset` 重置为 0，RoPE 或绝对位置嵌入会把新 token 当作序列开头，输出与无缓存路径不一致，且不会抛出任何形状错误。本节 NumPy 版本中把 `pos0` 写死为 0 会使 logits 偏差达到 $10^{-1}$ 量级，可直接检出。
> 3. 批量内长度不一致时按最长序列对齐。左填充时缓存中会存入填充位置的键值，若解码时不提供 `attention_mask` 把填充位置屏蔽，注意力会读取这些无意义向量；右填充时新 token 的位置索引会落在填充之后，位置编码与训练分布不一致。正确做法是左填充、显式传入位置与掩码，并让缓存长度按真实长度记录，而不是按张量宽度记录。
> 4. 缓存与掩码的交互写错。解码时查询长度 $T_q=1$、缓存长度 $T_k=t$，掩码应为全零；若沿用训练时的 $T\times T$ 上三角掩码，形状不匹配会报错，尺寸凑巧匹配时会把有效键屏蔽掉。分块预填充时掩码偏移必须是 $T_k-T_q$，写成 1 会使新块内的位置互相看见。
> 5. 显存估算漏项。常见遗漏是只算 K 或只算 V、漏乘层数、漏乘批量、把 $d_h$ 写成 $d$。以 7B、$T=4096$、$B=1$、fp16 为例，正确答案是 $2$ GiB；漏乘 2 得 $1$ GiB，漏乘 $L$ 得 $64$ MiB，把 $d_h$ 写成 $d$ 得 $64$ GiB。
> 6. 把缓存当作可训练参数或跨请求复用。缓存是某次前向的中间状态，不参与梯度更新；不同请求的缓存不能共享，除非提示词前缀完全相同且实现支持页级共享。混淆这两点会导致跨请求的信息泄漏。

## 关联笔记

- 前置：[[因果注意力与多头注意力]]。缓存的正确性依赖因果掩码保证的逐位置依赖关系；该篇的掩码偏移实现是本节解码掩码的基础。
- 前置：[[自回归生成与采样]]。该篇处理拿到 logits 之后的 token 选择，本篇处理拿到 logits 之前的计算组织，两者合起来构成完整解码循环。
- 后续：[[分组查询注意力GQA]]。在缓存显存公式中把 $H_{kv}$ 从 $H$ 降为 $H/n_{\text{rep}}$，即得 GQA 的显存收益；该篇给出组内共享的实现与质量权衡。
- 后续：[[超长上下文-无限注意力]]。当 $T$ 增长使缓存显存超过容量时，压缩状态与线性注意力是替代线性增长缓存的路线。
- 对照：[[Transformer架构详解]]。该篇的参数量与计算量分析针对训练时的整段前向，本篇是其推理阶段的改写。

## 达标检测

- [ ] 不看笔记，写出无缓存解码第 $t$ 步单层注意力的 FLOPs 表达式，并对 $t=1..T$ 求和得到 $\frac{4}{3}dT^{3}+O(dT^{2})$。
- [ ] 说明为什么只需要缓存 K 与 V 而不缓存 Q，并给出「键值只依赖前缀」的归纳证明梗概。
- [ ] 用 $2\cdot L\cdot H_{kv}\cdot d_h\cdot T\cdot B\cdot b$ 手算 Llama-2 7B 在 $T=8192$、$B=4$、fp16 下的缓存显存，并与 $T=4096$、$B=1$ 的结果比较倍数。
- [ ] 在代码中把解码掩码的 `diagonal` 从 `Tk - T + 1` 改成 `1`，构造 $T_q=4$、$T_k=8$ 的分块预填充输入，说明输出为何改变以及如何用无缓存路径检出该错误。
- [ ] 运行带缓存的生成脚本，验证有/无缓存两条路径生成的 token 完全相同，并解释 logits 出现 $10^{-6}$ 量级差异的原因。
- [ ] 给定 $d=4096$、$t=4096$，计算解码的算术强度，判断其处于算力受限还是带宽受限区间，并说明把批量从 1 增到 8 时算术强度如何变化。
- [ ] 列举分页注意力解决的两类碎片，并说明它为何不减少缓存字节数、却能与 GQA 叠加使用。

## 参考来源

- Vaswani et al., *Attention Is All You Need*, arXiv:1706.03762, 2017 —— 对应本篇第 3 节的解码器结构与逐位置注意力定义。
- Kwon et al., *Efficient Memory Management for Large Language Model Serving with PagedAttention*, arXiv:2309.06180, SOSP 2023 —— 对应第 7 节的分页缓存、页表与吞吐结论。
- Touvron et al., *Llama 2: Open Foundation and Fine-Tuned Chat Models*, arXiv:2307.09288, 2023 —— 对应第 5 节 7B/13B/70B 的层数、头数与 GQA 配置。
- d2l.ai《动手学深度学习》，注意力机制与 Transformer 章 —— 对应缩放点积注意力与多头拆分的实现对照。
- PyTorch docs，`torch.nn.Linear`、`torch.triu`、`torch.nn.functional.softmax` —— 对应本节代码中投影、掩码与归一化的 API 语义。
