w wyl123ly 的博客
MD

KV缓存

37 KB 2026.10.18 原文件

KV缓存

定义

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

本篇符号约定如下。

符号含义
批量大小
位置总数,含提示词与已生成 token
提示词长度
Transformer 层数
查询头数
键值头数,多头注意力中
每头维度
模型维度,
当前解码步的缓存长度,即已有键值的位置数
第 层的键、值缓存,形状
每个缓存元素的字节数,fp16 为 2,fp8 为 1
缓存总字节数
算术强度,每字节显存流量对应的浮点运算数
显存带宽,单位 B/s

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

为什么重要

自回归语言模型把序列概率分解为逐位置条件概率的乘积,生成第 个 token 必须先把前缀 送进模型。若不做缓存,第 步要对长度 的前缀完整前向一次,第 步再对长度 的前缀完整前向一次,其中前 个位置的计算结果与上一步完全相同。这些重复计算的注意力部分累计为 ,即 ;投影与前馈部分的累计为 。缓存把这两项分别降到 与 ,是推理可用性的前提:没有它,生成长文本的代价随长度成立方增长,交互式应用的延迟无法接受。

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

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

原理与推导

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

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

查询与键的乘积 输出 个分数,每个分数是长度 的点积,单个头需要 , 个头合计

对分数矩阵做 softmax 需要 次运算,相对矩阵乘法可忽略。加权求和 把 的权重矩阵与 的值矩阵相乘,单个头 ,合计 。于是单层注意力的矩阵乘法代价为

同一层还有四个投影矩阵,每个把 的激活乘以 的权重,代价 ,合计 ;前馈网络把维度升到 再降回 ,代价 。单层单步总代价为

对整个生成过程求和。第 步处理长度 的前缀, 从 到 :

第一项来自注意力,复杂度 ;第二项来自被反复重算的投影与前馈,复杂度 。两项的相对大小为 :当 时重复的投影与前馈占主导,当 时注意力占主导。以 为例,交叉点在 ;在 时投影与前馈的重算量为 ,注意力为 ,前者约为后者的 9 倍。这说明「无缓存很慢」不只因为注意力是二次的,更因为每个历史 token 的整层计算被重复执行了 次。

2 键值可复用的依据

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

设第 层位置 的表示为 ,第 层的键与值为

其中 是逐位置归一化, 为该层参数。由 因果注意力与多头注意力 的归纳证明, 只是 的函数。因此 与 也只是 的函数;当序列从长度 延长到 时, 的这些向量逐元素不变。归纳到所有层,结论成立:缓存中保存的键值与重新计算得到的键值完全相同,差别只在浮点求和顺序。

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

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

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

元素个数为 。 是批量, 是键值头数,多头注意力下 ,分组查询注意力下 ; 是已缓存的位置数, 是每头维度。全部 层与键值两份合计 个元素,乘以每元素字节数即显存占用。

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

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

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

带缓存的前向伪代码如下,其中 沿位置维拼接。

输入:新 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))

若把预填充与解码合并看待,可以把两者写成同一段代码,用查询长度 与缓存长度 区分: 且需要因果掩码时为预填充;、 且无需掩码时为解码; 且 时为分块预填充,此时掩码的偏移量必须等于 ,否则新块会看到本块中位于其后的位置。

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

缓存的直接效果是把单步代价从 降到 ,即每个解码步的计算量降为原来的约 。在 、 时,单层单步从 降到 ,比值恰为 4096。

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

注意力部分为 ,比无缓存的 低一个 因子。下表给出 时单层前向的 FLOPs,由第 1 节与本节公式计算;总倍数为前两列之和与第四列之比。

无缓存注意力无缓存投影与前馈有缓存注意力有缓存总计总倍数注意力倍数
512257342
1024516683
204810381366
409621012731
819242925462

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

5 显存公式与算例

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

逐项说明:因子 2 对应键与值两份张量; 是层数,每层各有独立的投影与缓存; 是单个位置在单层中键的元素数,值同理,多头注意力下 ,分组查询注意力下 ; 是缓存的位数量,等于提示词长度加已生成 token 数; 是同时解码的序列数; 是元素字节数,fp16 为 2,bf16 为 2,fp8 与 int8 为 1。

以 Llama-2 7B 为例:,,,,,fp16。先算单个位置在全部 32 层上的键值元素数:

乘以 4096 个位置得 个元素,再乘以 2 字节得 字节,恰为 GiB。另一种算法是先算每 token 字节数: 字节 KiB,再乘以 4096 得 GiB。每 token 512 KiB 这一数字便于心算任意上下文长度。

模型每 token 字节权重(fp16)
Llama-2 7B3232512 KiB2.0 GiB12.6 GiB
Llama-2 13B4040800 KiB3.125 GiB24.2 GiB
Llama-2 70B(GQA-8)808320 KiB1.25 GiB128.5 GiB

批量与上下文对 7B 模型的影响如下表,数值为 字节。

\ 181632
1024512 MiB4 GiB8 GiB16 GiB
20481 GiB8 GiB16 GiB32 GiB
40962 GiB16 GiB32 GiB64 GiB
81924 GiB32 GiB64 GiB128 GiB
3276816 GiB128 GiB256 GiB512 GiB

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

6 带宽瓶颈与算术强度

解码阶段每个 token 的计算量与访存量都可以逐层估计。设当前缓存长度 ,批量 ,单层注意力的计算量为 FLOPs,需读取的缓存为 字节(fp16, 个元素),读取的权重为 字节( 个参数)。算术强度为

分子是计算量,分母是字节数。当 时权重项被摊薄,;当 增大时该上限趋近 1。、 时上限为 7 FLOP/byte,而 A100 的 fp16 张量算力约 312 TFLOPS、显存带宽约 2.0 TB/s,算力带宽比约 156 FLOP/byte。解码的算术强度比该阈值低数倍到两个数量级,因此处于带宽受限区:增加算力不能降低延迟,减少字节才能。

配置
7B,,MHA1.004.005.89
7B,,GQA-81.148.0022.40
70B,,MHA1.005.209.45
70B,,GQA-81.078.0026.00

表中的单位是 FLOP/byte。批量增大提高算术强度,原因是权重读取被多个序列分摊;缓存的读取却随批量线性增长,所以算术强度存在上限。分组查询注意力把缓存读取按 缩小,因而抬高了上限,详见 分组查询注意力GQA。

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

7 PagedAttention 的分页思想

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

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

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

8 量化键值缓存

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

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

关键直觉

机制表述

KV 缓存利用的是因果注意力的一条结构性质:位置 的键与值只由前缀 决定,追加新 token 不会改变它们。缓存把「每步重算整个前缀」替换为「每步为 1 个新位置计算查询、键、值,再对长度为 的键值表做一次加权聚合」。它不改变模型输出,只改变计算的组织方式,代价是把 的计算换成 的显存占用与同量的读取流量。定义中的 即缓存长度, 随时间线性增长,所以显存与每步读取字节都随时间线性增长,而每步计算量也线性增长,二者的比值即第 6 节的算术强度。

例子与代码

手算:3 个位置、单头、

取一个注意力头,,缩放因子 。3 个位置的查询、键、值如下。

位置
1—
2—
3

位置 3 的分数为 、、,缩放后为 。softmax 分母为 ,权重为 。输出为

带缓存时,第 3 步只需用 与缓存中的 加上新算的 ; 在第 1 步算出后不再改变, 同理。无缓存时第 3 步会重算全部 3 个位置的键值,数值相同,只是多做了两次投影。

PyTorch 实现与有/无缓存对照

下面的实现把缓存作为每层的一个元组传入传出,形状 。为便于观察位置索引错误,模型使用可学习的绝对位置嵌入,位置由 pos_offset 显式给出。

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

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

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 的最大绝对误差在 量级,差异只来自矩阵乘的求和顺序;有缓存的每 token 耗时显著低于无缓存,且两者的比值随提示词长度增大而增大,因为无缓存路径的代价与上下文长度成正比。计时数值依赖硬件与线程数,本节只使用其比较关系。

无 torch 时的 NumPy 版本

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

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)上运行上述代码,实测输出为

生成 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 与正确路径的最大偏差为 ,量级为 ,而生成仍在继续,不会抛出异常。NumPy 版本的用途是验证语义与观察趋势;PyTorch 版本才是可部署实现,两者在相同输入下应当给出相同输出。

显存估算函数

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

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")

输出为

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,即假设它使用多头注意力,则 时结果为 MiB,是 GQA 配置的 8 倍。这个替换是检验公式是否理解正确的最快方法。

易错点

常见错误

1. 忘记 detach 缓存。在 requires_grad=True 的上下文中逐步解码时,若把上一步的缓存直接拼接到本步张量,缓存会携带完整计算图,显存随步数增长,反向传播也会穿过全部历史步。推理必须在 torch.no_grad() 下进行,并显式 detach 缓存。

2. 位置索引错位。解码时新 token 的绝对位置是缓存长度 ,不是 0,也不是 t+1。若每步把 pos_offset 重置为 0,RoPE 或绝对位置嵌入会把新 token 当作序列开头,输出与无缓存路径不一致,且不会抛出任何形状错误。本节 NumPy 版本中把 pos0 写死为 0 会使 logits 偏差达到 量级,可直接检出。

3. 批量内长度不一致时按最长序列对齐。左填充时缓存中会存入填充位置的键值,若解码时不提供 attention_mask 把填充位置屏蔽,注意力会读取这些无意义向量;右填充时新 token 的位置索引会落在填充之后,位置编码与训练分布不一致。正确做法是左填充、显式传入位置与掩码,并让缓存长度按真实长度记录,而不是按张量宽度记录。

4. 缓存与掩码的交互写错。解码时查询长度 、缓存长度 ,掩码应为全零;若沿用训练时的 上三角掩码,形状不匹配会报错,尺寸凑巧匹配时会把有效键屏蔽掉。分块预填充时掩码偏移必须是 ,写成 1 会使新块内的位置互相看见。

5. 显存估算漏项。常见遗漏是只算 K 或只算 V、漏乘层数、漏乘批量、把 写成 。以 7B、、、fp16 为例,正确答案是 GiB;漏乘 2 得 GiB,漏乘 得 MiB,把 写成 得 GiB。

6. 把缓存当作可训练参数或跨请求复用。缓存是某次前向的中间状态,不参与梯度更新;不同请求的缓存不能共享,除非提示词前缀完全相同且实现支持页级共享。混淆这两点会导致跨请求的信息泄漏。

关联笔记

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

达标检测

  • [ ] 不看笔记,写出无缓存解码第 步单层注意力的 FLOPs 表达式,并对 求和得到 。
  • [ ] 说明为什么只需要缓存 K 与 V 而不缓存 Q,并给出「键值只依赖前缀」的归纳证明梗概。
  • [ ] 用 手算 Llama-2 7B 在 、、fp16 下的缓存显存,并与 、 的结果比较倍数。
  • [ ] 在代码中把解码掩码的 diagonal 从 Tk - T + 1 改成 1,构造 、 的分块预填充输入,说明输出为何改变以及如何用无缓存路径检出该错误。
  • [ ] 运行带缓存的生成脚本,验证有/无缓存两条路径生成的 token 完全相同,并解释 logits 出现 量级差异的原因。
  • [ ] 给定 、,计算解码的算术强度,判断其处于算力受限还是带宽受限区间,并说明把批量从 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 语义。