Skip to content

KV Cache 极限压缩专题

系统剖析架构、量化(KIVI)、驱逐(H2O/SnapKV/PyramidKV)与跨层共享(YOCO/CLA)四条路线。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是 KV Cache 压缩?

当上下文扩展到 128K 甚至 1M、同时在线服务成百上千用户时,动辄几十上百 GB 的 KV Cache 会成为推理部署最昂贵的显存黑洞。

KV Cache 压缩 是一套从四个正交维度给缓存“瘦身”的技术组合拳:架构上用 GQA/MLA 从源头变瘦、精度上把 KV 压到 INT4/INT2(如 KIVI)、内容上丢掉不重要的冗余历史词(如 H2O / SnapKV),甚至让相邻网络层直接复用同一份 KV 缓存(YOCO / CLA)。

01 问题从何而来:模型瘦身成功了,读书笔记却把显存撑爆了 ​

当我们把大模型的上下文窗口一路拉到 128K 甚至 100 万字,一个让人哭笑不得的反转出现了:原本最占地方的模型权重成了小弟,反倒是推理时随写随存的 KV Cache 膨胀成了巨无霸!

算笔直白账:哪怕模型用了 GQA、精度也是主流的 BF16,单条 128K 对话的 KV Cache 也要吃掉 40 GB 显存。一张昂贵的 80 GB 显卡,模型权重占一半,剩下的显存居然连两个长文本并发用户都塞不下!更惨的是,每吐一个新字,GPU 都得把这几十 GB 的笔记从头搬运一遍,吐字速度直接被显存带宽按在地上摩擦。

类比 · 行李箱超重的四套打包大法

假设你要出远门,行李箱(GPU 显存)已经塞爆了,因为你带了整整一书架 80 本厚厚的精装书(80 层 Transformer 的 KV Cache)。想把体积砍掉 90%,有四套完全互不冲突、可以同时叠加的打包秘籍:

  1. 换速记版(架构层):印书时就改用极简速记符号,页数一样但字占面积少八成(GQA / MLA);
  2. 改超薄草稿纸(量化层):把 16 位铜版纸换成 2-bit 超薄纸,同样内容厚度瞬间缩到八分之一(KIVI);
  3. 只撕重点页(驱逐层):整本书九成是废话过场,只撕下目录和关键段落带走,其余直接扔掉(H2O / SnapKV / PyramidKV);
  4. 多册共用附录(跨层共享):别在每一本书后面都重复印一模一样的参考表,相邻几本书乃至全套书只印一份总附录(CLA / YOCO)。
核心设问

在不让模型“失忆”或变傻的前提下,如何把 KV Cache 的物理体积压缩 4 倍到 16 倍以上,甚至让极致的 2-bit 量化和 90% Token 驱逐都能稳如泰山?

02 核心直觉与生活类比 ​

这四条路线里,最有巧思、也是免训练推理最常用的,莫过于量化层(KIVI) 与驱逐层(SnapKV / PyramidKV) 的神奇发现。

类比 · 为什么 KIVI 敢把 KV 压到 2-bit(总共只有 4 个刻度)还不崩?

过去大家把 KV 往 4-bit 以下压,模型瞬间变疯。2024 年的 KIVI(arXiv:2402.02750 ↗)拿显微镜把 Key 和 Value 矩阵一照,发现了一件极其反直觉的事:

  • Key 矩阵像“竖着长的摩天大楼”:某几个固定的特征列(Channel),不管遇到什么词,数值都奇大无比(离群值),其余列都很小。如果你横着(按词) 用同一把尺子量,为了量下那座摩天大楼,旁边的小平房在 2-bit 尺子上全被压扁成了 0!正确做法是竖着(Per-Channel) 量——摩天大楼用大楼专用尺,小平房用小平房尺,互不干扰!
  • Value 矩阵像“横着铺的起伏山丘”:没有固定的奇高列,反而是不同词之间差别大,所以要反过来横着(Per-Token) 各自用尺子量!

再加上一个小巧的“FP16 临时写字板(Residual Buffer)”专门兜住刚生成的最近几十个词,等写字板凑满一批再一起竖着压缩成 2-bit 归档,硬是在不重新训练模型的情况下,把 KV 体积砍掉 5 倍以上,准确率几乎毫发无损!

类比 · 考试前划重点:SnapKV 与 PyramidKV 的“漏斗直觉”

读完一篇 10 万字的小说后回答末尾的一个问题,人类真会把每个标点符号都背下来吗?不会,大家只盯着和问题相关的那几十句关键证据!

  • StreamingLLM(arXiv:2309.17453 ↗)首先发现一个怪现象:哪怕文章开头的头 4 个词毫无意义,也千万不能扔!它们就像水池的“下水口(Attention Sinks)”,负责吸收模型多余的注意力分数,一旦删掉,整个 Softmax 分布当场炸锅。
  • SnapKV(arXiv:2404.14469 ↗)聪明地发现:看一眼提示词最后那十几个词(也就是用户真正问的问题,叫观察窗口)给前文各处打的注意力分数,再顺手用 1D 池化把相邻几个词连成完整短语,就能精准锁定整篇文章的 Top-K 核心段落,剩下九成废话直接删光!
  • PyramidKV(arXiv:2406.02069 ↗)更进一步看穿了大模型的“分层阅读习惯”:浅层像在扫读全文抓素材,视线撒得很开;越往深层走,模型心里越有数,目光死死钉在少数几个答案锚点上。所以别把宝贵的显存预算每层平分,要修成一座下宽上窄的金字塔——浅层多留点笔记,深层极简压缩,同样的总显存下,记忆力凭空暴涨一大截!

而第四条路线的 YOCO(arXiv:2405.05254 ↗)与 CLA(arXiv:2405.12981 ↗)则干脆从造模型时就彻底省事:既然 80 层 Transformer 每层算出来的 KV 高度相似,干脆前一半层用轻量结构读完文章,只存全模型唯一一份共享 KV Cache,后一半层全都去查这同一份笔记,显存直接除以层数 L!

03 把关键公式读成人话 ​

一切 KV 压缩术的“总地图”,其实就藏在这条显存乘法公式里:

MKV=2⋅B⋅S⏟驱逐⋅L⏟跨层共享⋅(nkv⋅dh)⏟架构⋅bdtype⏟量化

把公式读成直觉:这四个带括号的乘数彼此完全独立,你可以像搭乐高一样乘法叠加:

  • 用 MLA 把 (nkv⋅dh) 砍到原来的 1/10;
  • 用 KIVI / FP8 把 bdtype 从 2 字节砍到 0.25–1 字节;
  • 用 PyramidKV 把有效保留长度 S 砍到 1/4;
  • 用 CLA / YOCO 把需要存缓存的层数 L 砍掉一半以上。 哪怕每条线只温和地压 2 倍,四条线乘起来也是惊人的 16× 显存瘦身!

再看 PyramidKV 的金字塔每层配额公式:

kl=kmax−kmax−kminL−1⋅l

把公式读成直觉:- l 是层号(从第 0 层底层一路到第 L−1 层顶层)。

  • 第 0 层拿满最大配额 kmax,之后每往上一层就均匀少分一点名额,到了最顶层只留最精简的 kmin 个核心词。总显存账单和“每层平均分”一模一样,但把好钢全用在了信息最容易丢失的浅层刀刃上!
  • 再搭配 KIVI 2-bit 把保留下来的那一点点笔记再从 16 位压到 2 位,一条原本吃掉 40 GB 显存的 128K 对话,硬生生能瘦身到 2–3 GB,普通消费级显卡都能轻松装下!

04 它在模型里怎么工作 & 与上下游的关系 ​

KV Cache 压缩是连接算法架构与底层推理系统的枢纽:

  • 与 PagedAttention 和 FlashDecoding 联手:压缩不仅省下了显存容量(让你同时接纳更多并发用户),更在 Decode 阶段直接砍掉了 HBM 带宽搬运量。配合 FlashDecoding 的片上寄存器实时反量化,吐字速度可以和显存压缩比一起翻倍!
  • 与 推理服务调度系统 联动:在 PD 分离架构里,Prefill 节点算完 KV 要通过高速网络发给 Decode 节点;KV 压缩得越小,跨机传输延迟越低,全集群的 Goodput 越高。
  • 赋能 超长上下文模型:端侧手机、单卡工作站想流畅跑 128K 长文档,几乎离不开量化与驱逐技术的保驾护航;而像 DeepSeek 系列 更是靠 MLA 把原生压缩直接刻进了模型基因里。

05 选型对比与避坑备忘 ​

压缩方案改哪里?(说人话)要重训吗?真实工程建议
GQA / MLA模型天生自带小笔记需要首选底座,选模型时直接看单 Token KV 体积
FP8 KV Cache16 位直接压 8 位不用线上标配,几乎零掉点、并发立刻翻倍
KIVI 2-bit (arXiv ↗)Key 竖量、Value 横量 + 残差板不用极限显存受限 / 端侧长文神器,需配融合算子
SnapKV / PyramidKV (arXiv ↗)看末尾问题划重点 + 金字塔分配不用单轮超长文档总结/检索极强,多轮对话慎用
YOCO / CLA (arXiv ↗)全模型或多层共享一份笔记需要下一代原生超长上下文大模型的主流设计方向

给自己的推理引擎加 KV 压缩,有三个血泪暗坑必须提前绕开:

  1. 多轮对话千万别直接上硬驱逐(SnapKV / H2O):SnapKV 是看着“当前这一轮的问题”把无关段落撕掉的。万一用户在第二轮突然追问:“诶,那前面第三段里提到的小配角叫什么来着?”——糟糕,那段笔记上一轮已经被你亲手扔进垃圾桶了!多轮对话要么用无损/低比特量化,要么把被驱逐的页先搬到便宜的 CPU 内存冷存着,别真删干净。
  2. 给 Key 量化千万别偷懒横着(Per-Token)量:Key 矩阵里那几根高耸入云的离群通道专治偷懒。如果不按通道(Per-Channel)量化、或者量化前不做通道平滑/旋转,4-bit 以下模型立刻开始胡言乱语。
  3. 写驱逐算法忘了保“开头 4 个词”:无论你的打分公式有多高明,永远给序列最开头的 4 个词(Attention Sinks)发一张“免死金牌”。把它们误删,模型长文输出分分钟彻底崩盘。
  4. H2O 与 FlashAttention 并不天然兼容:传统 H2O 要求把整张 N×N 注意力分数表读出来累加排名,这恰恰违背了 FlashAttention 绝不落盘中间表的初衷;实际工程更推荐用只需末尾极短观察窗的 SnapKV / PyramidKV 或原生 FP8 KV Cache。

想查阅 KIVI 非对称量化公式、SnapKV 1D 池化与金字塔分配细节、四路线全景架构图以及可运行的 PyTorch KIVICacheSimulator + snapkv_evict 完整代码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

尽管 PagedAttention 几乎消除了显存碎片,但随着 长上下文建模 迈向 128K 乃至 1M Token,KV Cache 本身的物理体积仍会迅速超过模型权重,成为制约并发上限与 Decode 带宽的绝对瓶颈。回看单请求的 KV Cache 显存公式:

MKV=2⋅B⋅S⏟驱逐⋅L⏟跨层共享⋅(nkv⋅dh)⏟架构⋅bdtype⏟量化

现代研究精准锚定了公式中的四个乘数因子,演化出四条相互正交、可乘性叠加的极限压缩路线:架构层(GQA / MLA)、量化层(KIVI 2-bit)、驱逐层(H2O / SnapKV / PyramidKV) 以及跨层共享(CLA / YOCO)。

直观理解

如果把 KV Cache 想象成一本越来越厚的读书笔记,压缩它有四种完全互不冲突的绝招:① 架构层是改用更精炼的速记符号(GQA/MLA,每行字数少八成);② 量化层是把精装铜版纸换成超薄草稿纸(KIVI 2-bit,每个数从 16 位压到 2 位);③ 驱逐层是只撕下核心摘要页保留、扔掉废话过场(H2O/SnapKV/PyramidKV);④ 跨层共享是让相邻几个章节共用同一份参考附录,不再每层重复抄写(CLA/YOCO)。

起源背景与演进脉络 ​

在自回归解码中,每生成一个新 Token 均须将整份 MKV 从 HBM 读取一遍。以 70B 级模型为例,即便采用 GQA-8 与 BF16,单条 128K 上下文请求的 KV Cache 仍高达 40 GB,单张 80 GB 显卡连两条并发都塞不下,且每次吐字单单搬运 KV 就需耗费十余毫秒。为了同时击破容量墙与带宽墙,社区沿两条时间线并行推进:

  • 训练期原生减负(Architecture & Cross-Layer):从 MQA、GQA 到 DeepSeek-V2/V3 的 MLA,以及 CLA、YOCO 等跨层键值复用架构,在预训练阶段即把 KV 体积压低一个数量级;
  • 推理期免训练压缩(Post-Training Quantization & Eviction):针对已经训练好的任意闭源或开源权重,利用键值张量的统计离群规律(如 KIVI)与注意力权重的极端幂律稀疏性(如 StreamingLLM、H2O、SnapKV、PyramidKV),在几乎无损的前提下再挤出 4×–8× 空间。

核心原理与数学推导 ​

1. 架构层压缩:降低 nkv⋅dh ​

  • GQA(Grouped-Query Attention):将 Hq 个查询头划分为 Hkv 组共享键值投影,KV 显存直接缩减 Hq/Hkv 倍(如 Llama-3 压缩 8×)。
  • MLA(Multi-Head Latent Attention):将每步的 kt,vt 联合投影至单个极低秩潜向量 ctKV∈Rdc(dc=512),配合解耦位置向量 ktR∈R64,通过权重矩阵吸收在推理期仅缓存 ctKV 与 ktR,相比标准 MHA 削减 93.3% KV 体积,且无损于多头表达能力。

2. 量化层压缩:KIVI 的非对称 2-bit 量化(降低 bdtype) ​

传统 权重量化 若直接套用于 KV Cache,在 4-bit 以下往往引发严重的精度崩塌。KIVI(Liu et al., 2024,arXiv:2402.02750 ↗)与 KVQuant(arXiv:2401.18079 ↗)揭示了 Key 与 Value 分布的根本结构性差异:

  • Key Cache 存在显著的固定通道离群值(Per-Channel Outliers):某些特定特征通道 c 在几乎所有 Token 位置上幅值都远大于其他通道;若按 Token 维度(跨通道)统一量化,离群通道会撑爆量化区间,导致其余正常通道在 2-bit 下全部坍缩为同一个离散值;
  • Value Cache 无固定通道离群模式:幅值分布主要随 Token 变化,且注意力加权汇总 PV 是沿 Token 维做线性组合,因此应按 Token 维度量化以保持各 Token 自身相对精度。

基于此洞察,KIVI 设计了免微调、分方向非对称 2-bit 量化方案:

  1. Key 按通道分组量化(Per-Channel Quantization):沿序列维每 G 个连续 Token 组成一组,对每个通道 c 独立计算零点 zK,c=mintKt,c 与缩放因子 sK,c=(maxtKt,c−mintKt,c)/(2b−1);
  2. Value 按 Token 分组量化(Per-Token Quantization):对每个 Token t 沿通道维每 G 个元素计算独立的 zV,t 与 sV,t;
  3. 残差高精度缓冲(Residual Buffer):Decode 阶段每次仅新产生 1 个 Token,无法立即凑齐 G 个 Token 对 Key 做 Per-Channel 量化。KIVI 维护一个长度为 R(如 R=32 或 128)的 FP16 残差缓冲存放最新 Token;每当缓冲满 R 个时,整体打包刷入 2-bit 量化主缓存,并在算子内将量化主缓存与 FP16 残差缓冲拼接计算:
x^=s⋅clamp(round(x−zs),0,2b−1)+z,b=2

搭配融合反量化算子,KIVI 在仅保留约 2.6×–4× 吞吐提升的同时,在 GSM8K、LongBench 等评测上几乎与 FP16 持平。

3. 驱逐层压缩:利用注意力稀疏性缩减有效序列长 S ​

实证研究表明,LLM 的注意力矩阵呈现高度幂律稀疏——通常超过 90% 的概率质量集中在不足 5%–10% 的关键 Token 上。驱逐策略据此演化出四代核心算法:

  1. StreamingLLM(Attention Sinks,arXiv:2309.17453 ↗):发现序列最开头的 1–4 个初始 Token(即使语义无关)承担了吸收多余 Softmax 概率质量的“注意力汇点(Attention Sink)”作用。一旦滑窗丢弃它们,分布立刻崩溃;保留 Sink (4 tokens) + Recent Sliding Window 即可实现无限长度流式生成,但会遗忘中段远距信息。
  2. H2O(Heavy-Hitter Oracle,arXiv:2306.14048 ↗):在 Decode 过程中持续累加每个历史位置获得的注意力权重 ajcum=∑tPt,j,动态维护固定预算 Bkv=Brecent+BHH,每步淘汰累计得分最低的历史 Token,保留近期窗口与高频“重击手(Heavy Hitters)”。
  3. SnapKV(arXiv:2404.14469 ↗):揭示了每个注意力头在生成阶段关注的提示词位置高度稳定且可由提示词末尾提前预测!在 Prefill 结束时,取提示词最后 Wobs 个 Token 作为观察窗口(Observation Window),计算其对前缀所有位置的注意力权重并沿时间维求和,再施加 1D 平均/最大池化(1D Pooling) 保护局部词组完整性:
sh=AvgPool1D(∑i=L−Wobs+1LPh,i,1:L−Wobs)∈RL−Wobs

对每个头 h 各自选取 Top-k 位置连同观察窗口保留,瞬间将 Prefill 后的 KV 体积压至固定预算,在大海捞针(NIAH)评测中召回率远超 H2O。 4. PyramidKV(arXiv:2406.02069 ↗):进一步发现跨层注意力熵呈现金字塔漏斗分布——浅层注意力分散(广泛聚合词法上下文),深层注意力极度聚焦(汇聚在少数关键语义锚点上)。因此打破各层均分预算的做法,按层号 l∈{0,…,L−1} 线性递减分配每层保留预算:

kl=kmax−kmax−kminL−1⋅l,∑l=0L−1kl=L⋅k¯

在同等总显存预算下,PyramidKV 将更多容量倾斜给信息更分散的浅层,在极低保留率(如仅留 128–512 Token)下依然保持优异的长文理解精度。

4. 跨层共享压缩:降低有效缓存层数 L ​

  • CLA(Cross-Layer Attention,arXiv:2405.12981 ↗):将相邻的 m 层绑定为一个共享组,仅由首层计算并写入 KV Cache,其余 m−1 层直接复用首层的 KV 仅独立计算自身 Query,实现 m×(通常 2×–4×)无痛 KV 缩减。
  • YOCO(You Only Cache Once,arXiv:2405.05254 ↗):从宏观架构重构 Decoder-Only 模型——前 L/2 层为 Self-Decoder(采用滑动窗口或 线性注意力,常数级 O(1) 状态显存),仅在其输出端生成全模型唯一一份全局 KV Cache;后 L/2 层为 Cross-Decoder,全部通过交叉注意力共享这份单一 KV,将全模型 KV 显存由 O(L⋅S) 彻底降至 O(S)。

架构与数据流图 ​

以下架构图全景展示了四条正交压缩路线如何精准对应并逐项削减 KV Cache 显存公式中的四个核心乘数因子:

图表加载中...

相关优化模式与横向对比表 ​

压缩路线与代表方法压缩目标因子典型压缩倍率是否需重训精度保持与大海捞针表现硬件/服务工程兼容性
GQA / MLAnkv⋅dh4×–15×预训练 / 微调极佳(原生表达无损)完美兼容 PagedAttention 与 FlashMLA
FP8 KV Cachebdtype2×免训练近乎无损(工业标配)Hopper/Ada 原生硬件指令,vLLM/SGLang 开箱即用
KIVI (2-bit)bdtype5×–7×免训练优秀(保残差窗口下误差极低)需定制 Per-Channel/Per-Token 融合反量化 Kernel
H2O / StreamingLLMS4×–10×免训练StreamingLLM 忘中段;H2O 中等需显式访问注意力权重,与 FlashAttention 存在冲突
SnapKV / PyramidKVS4×–16×免训练极佳(单轮长文检索近无损)仅需末尾 Wobs 步打分,极易与 FA2 兼容;多轮对话易误删
CLA / YOCOL2×–32×预训练极佳(同算力下甚至支持更长上下文)极度友好,可直接大幅削减 PD 分离跨机 KV 传输量

核心 PyTorch 参考实现 ​

以下 PyTorch 实现完整复现了两条最常用的免训练压缩算法:KIVI 非对称 2-bit 量化(Per-Channel K + Per-Token V + Residual Buffer) 与 SnapKV 观察窗 1D 池化驱逐,并验证压缩误差与预算控制效果:

python
import math
import torch
import torch.nn.functional as F


def asym_quantize_dequantize(x: torch.Tensor, bits: int = 2, dim: int = -1) -> torch.Tensor:
    """分组非对称低比特伪量化(模拟 KIVI 2-bit 量化与片上反量化)"""
    qmax = (1 << bits) - 1
    x_min = x.amin(dim=dim, keepdim=True)
    x_max = x.amax(dim=dim, keepdim=True)
    scale = (x_max - x_min).clamp(min=1e-6) / qmax
    q = torch.round((x - x_min) / scale).clamp(0, qmax)
    return q * scale + x_min


class KIVICacheSimulator:
    """
    KIVI 核心机制演示:
    - Key Cache: 沿序列维分组做 Per-Channel 2-bit 量化
    - Value Cache: 沿特征维分组做 Per-Token 2-bit 量化
    - Residual Buffer: 最新 R 个 Token 保持全精度,凑满 group_size 后统一刷入 2-bit 区
    """
    def __init__(self, bits: int = 2, group_size: int = 32, residual_len: int = 32):
        self.bits = bits
        self.group_size = group_size
        self.residual_len = residual_len
        self.k_quant_blocks, self.v_quant_blocks = [], []
        self.k_res, self.v_res = None, None

    def update(self, k_new: torch.Tensor, v_new: torch.Tensor):
        # k_new, v_new: (B, H, T_new, D)
        self.k_res = k_new if self.k_res is None else torch.cat([self.k_res, k_new], dim=2)
        self.v_res = v_new if self.v_res is None else torch.cat([self.v_res, v_new], dim=2)

        # 当残差缓冲超过 residual_len 时,将头部整组刷入 2-bit 量化区
        while self.k_res.size(2) >= self.residual_len + self.group_size:
            k_chunk = self.k_res[:, :, : self.group_size, :]
            v_chunk = self.v_res[:, :, : self.group_size, :]
            self.k_res = self.k_res[:, :, self.group_size :, :]
            self.v_res = self.v_res[:, :, self.group_size :, :]

            # 关键:Key 沿序列维 (dim=2) 做 Per-Channel 量化;Value 沿通道维 (dim=-1) 做 Per-Token 量化
            self.k_quant_blocks.append(asym_quantize_dequantize(k_chunk, self.bits, dim=2))
            self.v_quant_blocks.append(asym_quantize_dequantize(v_chunk, self.bits, dim=-1))

    def get_kv(self):
        K_all = torch.cat(self.k_quant_blocks + [self.k_res], dim=2) if self.k_quant_blocks else self.k_res
        V_all = torch.cat(self.v_quant_blocks + [self.v_res], dim=2) if self.v_quant_blocks else self.v_res
        return K_all, V_all


def snapkv_evict(
    Q_obs: torch.Tensor,      # 观察窗口 Query: (B, H, W_obs, D)
    K_prompt: torch.Tensor,   # 完整 Prompt Key: (B, H, L, D)
    V_prompt: torch.Tensor,   # 完整 Prompt Value: (B, H, L, D)
    keep_budget: int = 128,   # 每头最终保留总 Token 数 (含观察窗)
    kernel_size: int = 5,     # 1D 池化核宽,保留局部短语连续性
):
    """SnapKV Prefill 阶段按头驱逐:观察窗投票 + 1D 池化 + Top-K 筛选"""
    B, H, L, D = K_prompt.shape
    W_obs = Q_obs.size(2)
    prefix_len = L - W_obs
    k_select = max(1, keep_budget - W_obs)
    if prefix_len <= k_select:
        return K_prompt, V_prompt

    # 1. 仅用最后 W_obs 个观察窗 Query 计算对前缀的注意力权重(O(W_obs * L),极低开销)
    K_prefix, V_prefix = K_prompt[:, :, :prefix_len, :], V_prompt[:, :, :prefix_len, :]
    scores = torch.matmul(Q_obs, K_prefix.transpose(-1, -2)) / math.sqrt(D)  # (B, H, W_obs, prefix_len)
    attn_weights = F.softmax(scores, dim=-1).sum(dim=2)                      # 沿观察窗聚合: (B, H, prefix_len)

    # 2. 1D 平均池化平滑打分,避免把完整实体名词割裂
    pooled = F.avg_pool1d(
        attn_weights.view(B * H, 1, prefix_len),
        kernel_size=kernel_size,
        stride=1,
        padding=kernel_size // 2,
    ).view(B, H, prefix_len)

    # 3. 每头独立选取 Top-K 重要历史索引(按原顺序排列后拼接观察窗口)
    topk_idx = pooled.topk(k_select, dim=-1).indices.sort(dim=-1).values     # (B, H, k_select)
    gather_idx = topk_idx.unsqueeze(-1).expand(-1, -1, -1, D)
    K_kept = torch.cat([torch.gather(K_prefix, 2, gather_idx), K_prompt[:, :, prefix_len:, :]], dim=2)
    V_kept = torch.cat([torch.gather(V_prefix, 2, gather_idx), V_prompt[:, :, prefix_len:, :]], dim=2)
    return K_kept, V_kept


if __name__ == "__main__":
    torch.manual_seed(0)
    B, H, L, D = 1, 4, 256, 64
    # 构造含典型通道离群值的 Key 分布
    K = torch.randn(B, H, L, D)
    K[:, :, :, 0] *= 15.0  # 模拟显著 Key 通道离群值
    V = torch.randn(B, H, L, D)
    Q = torch.randn(B, H, 16, D)

    # 1) 验证 KIVI 2-bit 量化(Per-Channel K 显著优于 Per-Token K)
    kivi = KIVICacheSimulator(bits=2, group_size=32, residual_len=32)
    kivi.update(K, V)
    K_q, V_q = kivi.get_kv()
    out_ref = F.scaled_dot_product_attention(Q, K, V)
    out_kivi = F.scaled_dot_product_attention(Q, K_q, V_q)
    print(f"KIVI 2-bit mean abs output diff: {(out_kivi - out_ref).abs().mean().item():.4f}")

    # 2) 验证 SnapKV 驱逐至 64 Token 预算
    K_snap, V_snap = snapkv_evict(Q, K, V, keep_budget=64)
    print(f"SnapKV compressed shape: {tuple(K.shape)} -> {tuple(K_snap.shape)}")

工程实践与常见陷阱 ​

工程实践

  1. 生产级压缩优先级梯度:线上服务应按“无损优先、有损兜底”顺序叠加压缩手段:首选模型自带的 GQA / MLA,其次无缝开启 FP8 KV Cache(在 H100/Ada 上几乎零精度损失且直接翻倍并发);仅在单机极限长上下文或端侧内存严苛场景下,再引入 KIVI INT4/INT2 与 PyramidKV。
  2. Per-Channel Key 量化与 PagedAttention 内存布局对齐:在 PagedAttention 中,若将物理页大小 block_size 设置为 KIVI 的分组大小 group_size(如 32 或 64 Token),即可在一个完整物理页写满时就地执行 Per-Channel 量化并释放原 FP16 页,消除复杂的跨页量化边界管理。
  3. SnapKV 与 FlashAttention 无缝共存:H2O 等传统驱逐算法需要完整的 N×N 注意力权重矩阵才能累加得分,这直接破坏了 FlashAttention 不实化权重矩阵的核心优势;而 SnapKV 仅需用最后 Wobs=16 个 Token 的 Query 单独算一次极轻量的 (16×L) 打分,几乎零额外显存开销即可完美兼容 FlashAttention。

常见陷阱

  1. 多轮对话与检索任务中的驱逐不可逆风险:SnapKV 与 PyramidKV 的核心假设是“当前问题出现在提示词末尾,后续生成只关注当前问题相关的上下文”。在多轮对话场景中,第一轮提问时被驱逐的历史文档段落,可能在第二轮用户换话题追问时变成唯一答案!多轮场景若使用驱逐,必须在 CPU 内存保留完整压缩冷备份(如 Quest/ShadowKV 风格按需召回)或改用无损量化。
  2. 对 Key 误用 Per-Token 低比特量化:工程实现中若图省事对 Key 和 Value 统一采用 Per-Token INT4/INT2 量化,RoPE 施加前后存在于特定维度的巨大 Key 通道离群值会瞬间摧毁量化精度,造成长文本复读机或事实幻觉。务必区分 Key(Per-Channel)与 Value(Per-Token),或在量化前对 Key 施加平滑缩放 / 旋转变换(如 Hadamard 变换)。
  3. 遗忘 Attention Sinks 导致分布雪崩:编写任何自定义滑动窗口或 Top-K 驱逐逻辑时,务必强制白名单锁定序列前 4 个初始 Token(Attention Sinks)永不被淘汰,否则 Softmax 缺乏概率泄洪口,长序列生成会在瞬间退化为乱码。

参考文献 ​

  • Zhang, Z., Sheng, Y., Zhou, T., et al. (2023). H2O: Heavy-Hitter Oracle for Efficient Generative Inference of Large Language Models. NeurIPS 2023. arXiv:2306.14048 ↗(提出基于累计注意力得分的重击手动态驱逐)
  • Xiao, G., Tian, Y., Chen, B., Han, S., & Lewis, M. (2023). Efficient Streaming Language Models with Attention Sinks. ICLR 2024. arXiv:2309.17453 ↗(揭示 Attention Sinks 机制并提出 StreamingLLM)
  • Hooper, C., Kim, S., Mohammadzadeh, H., et al. (2024). KVQuant: Towards 10 Million Context Length LLM Inference with KV Cache Quantization. NeurIPS 2024. arXiv:2401.18079 ↗(系统分析 RoPE 前后 Key 离群分布与非均匀低比特量化)
  • Liu, Z., Yuan, J., Jin, H., et al. (2024). KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache. ICML 2024. arXiv:2402.02750 ↗(提出 Per-Channel K / Per-Token V 2-bit 量化与残差缓冲)
  • Li, Y., Huang, Y., Yang, B., et al. (2024). SnapKV: LLM Knows What You are Looking for Before Generation. NeurIPS 2024. arXiv:2404.14469 ↗(观察窗投票与 1D 池化提示词驱逐)
  • Sun, Y., Dong, L., Zhu, Y., et al. (2024). You Only Cache Once: Decoder-Decoder Architectures for Language Models. NeurIPS 2024. arXiv:2405.05254 ↗(YOCO 全模型单份共享 KV 缓存架构)
  • Brandon, W., Mishra, M., Nrusimha, A., Panda, R., & Ragan-Kelley, J. (2024). Reducing Transformer Key-Value Cache Size with Cross-Layer Attention. NeurIPS 2024. arXiv:2405.12981 ↗(CLA 跨层 KV 共享机制)
  • Cai, Z., Zhang, Y., Gao, B., et al. (2024). PyramidKV: Dynamic KV Cache Compression based on Pyramidal Information Funneling. arXiv:2406.02069 ↗(揭示跨层注意力漏斗效应并提出金字塔预算分配)