深度解读 📅 2026-11-13 ✍️ MagicNetWorld 编辑部

KV 缓存该存几个比特:通道级离群下,为什么 Key 要按通道量化、Value 要按 token 量化

在合成分布上的对照实验里,同一个量化算子只把「分组轴」从 token 换成通道,2-bit 下键缓存的相对重建误差就从 0.3552 降到 0.1586(本文 2026-11-13 自实现,d_h=64、n=128、组大小 32,非模型实测)。文章把 KV 缓存量化拆成三件事:在无截断、残差近似均匀的假设下期望误差约为 Δ²/12;键的误差经 |ε|≤‖q‖Δ/2 与 TV≤‖ε‖∞ 传导成 softmax 排名改变(头维度在分子分母抵消,不构成红利);以及当键的离群在通道上、值的离群在 token 上时,两条缓存的最优分组轴相反。后半段逐条解释 KVQuant 的四件低于 4-bit 的补丁(其中「按层敏感度加权的非均匀码点」是码点分布、不是位宽分配)、FP8 的相对精度模型,以及淘汰与降精度的取舍。全文不含真实模型推理评测,论文数字标注版本与口径,跨论文不做直接比较。

KV Cache量化低比特推理注意力机制推理系统显存优化

一、先给直觉:显存账本上其实有三个旋钮

把一个大模型跑起来,显存大致分三块:权重、KV 缓存、中间激活。权重是常数,一次加载完就不动了;中间激活随 batch 起伏,但一般能被算子融合吃掉一部分;真正会随着「用户变多、上下文变长」失控的,是 KV 缓存——它的大小和 batch、序列长度都是线性关系,两者一起涨就是乘法。

想让它变小,工程上只有三条路,而且这三条路互相正交,可以叠加:

第一条是改结构。多头注意力里让多个查询头共享一组键值头(MQA、GQA),或者干脆把键值压到低秩潜空间再按需投影回来(MLA)。这条路改的是「每个 token 要存多少个元素」,一次改架构、终身受益,代价是模型得按新结构训练。本站此前那篇《注意力的显存战争》讲的正是这条路线。

第二条是丢内容。只保留一部分 token 的键值,或者用稀疏/滑窗注意力把远距离的缓存扔掉。这条路改的是「存多少个 token」,收益立竿见影,但信息是不可逆丢掉的——后面第七节会看到,这一刀砍下去,有些能力就再也回不来。

第三条是降精度。元素数量不变、token 数量不变,但每个数从 16 位压到 8 位、4 位甚至 2 位。这条路最”无痛”:不动架构、不丢 token、不需要重训,只要在写入缓存时量化、读出来时反量化。代价是引入数值误差,而误差会不会毁掉模型,取决于你把误差放在哪里。

先给一个能立住直觉的数字:一个 32K 上下文的模型、8 路并发,KV 缓存按全 MHA 结构算要吃掉大约 128 GiB(这个数第八节会一步步算出来),比很多模型的权重还大。也就是说,长上下文服务最先撞到的墙不是”算不动”,而是”存不下”——这正是量化值得认真对待的原因。

换个说法:权重决定「能不能装下一个模型」,KV 缓存决定「能同时服务多少个人、每个人能聊多长」。后者的天花板比前者更早到,也更难靠换硬件解决——显存翻倍,并发只翻倍;而上下文长度每翻一倍,缓存也翻一倍,两件事乘起来就把硬件升级吃光了。

这一篇只讲第三条路,而且要讲清一件被很多工程实现含糊过去的事:KV 量化的关键不是”用几比特”,而是”沿哪个轴分组”。 同样是 2-bit,Key 缓存按通道分组比按 token 分组的相对误差低一倍多;Value 缓存则正好相反。这不是调参调出来的经验,有明确的机制,本篇会一步步推出来。

三条路还能叠加,但叠加的顺序有讲究,顺序错了会做无用功:先结构(在已有合适结构的模型上先核算它的基础容量)、再精度(对数值有损,但对架构无侵入)、最后淘汰(不可逆)。 结构改完,KV 的基础尺寸降下来了,可能压根不需要量化;量化的轴选对之后,剩下的显存缺口才轮到淘汰去填。反过来先淘汰、再量化,等于先在信息上开了个不可逆的口子,再去省那点字节,性价比最差。

本地小结:本节的判断顺序

一句话记住:先问「缺不缺」,再问「缺多少」,最后才问「用什么压」。 跳过前两步直接讨论 2-bit 还是 4-bit,是这类优化最常见的浪费。

二、符号与术语约定

先把后面要反复用的符号钉死,避免出现「同一个字母两种含义」。

符号含义一处说明
dhd_h每个键值头的维度常见取 128
LLTransformer 层数每层各有一份 KV
HkvH_{kv}键值头数MHA 时等于查询头数,GQA 时更少
nn已缓存的历史 token 数也就是上下文长度
K∈Rn×dhK\in\mathbb{R}^{n\times d_h}某一层、某个头的键缓存一行是一个 token
V∈Rn×dhV\in\mathbb{R}^{n\times d_h}某一层、某个头的值缓存一行是一个 token
bb码字位宽2 / 4 / 8
gg分组大小一组共用一个步长
Δ\Delta组内量化步长本文关心的误差来源
s,zs,z缩放因子与零点非对称均匀量化的两个参数
qiq_i量化后的整数码字与查询向量 qmq_m 靠下标区分
δn\delta_n第 nn 个键的误差向量与分数扰动 ε\varepsilon 分开
p, TVp,\ \mathrm{TV}注意力概率、总变差距离TV=12∥p−p^∥1\mathrm{TV}=\tfrac12\|p-\hat{p}\|_1

表 1 符号与术语约定(本文自用,避免同一字母两种含义)

三点必须先说清,否则后面的误差分析和 kernel 讨论会对不上。

其一,KK、VV 都指某一层、某一个键值头的缓存。真实服务的缓存是「层数 × 头数」份这样的张量堆起来的,本文在第八节算显存时才乘上 LL 与 HkvH_{kv}。把”单层单头”的符号直接当成整份缓存,是这类文章最常见的量纲错误。

其二,「组」是数学概念,「张量布局」是实现概念。说「键按通道分组」,准确的意思是:沿 token 维,把同一个通道的取值切成若干段,每段长度 gg,各段共用一个步长。不是”整列共用一个 scale”,也不是”每个元素一个 scale”——gg 的大小直接决定分辨率与元数据开销的平衡,下面给出式子。

其三,“比特”这个词本文严格区分三件事:码字位宽 bb(每个元素占几位)、含元数据的平均存储位数(记 bstoreb_{\text{store}},把 scale 与零点摊进去)、以及计算精度(kernel 用什么指令算,常见做法是反量化后按 16 位算)。三者可以不同,混着说必然得出错误结论——“我用了 4-bit”通常指第一个,而真正决定显存的是第二个。

bstore=b+32g(假设 scale 与零点各 16 位、每组各一份)b_{\text{store}}=b+\frac{32}{g}\quad(\text{假设 scale 与零点各 16 位、每组各一份})

g=32g=32 时元数据是 +1+1 位:8-bit 时约占总量 1/91/9,2-bit 时约占 1/31/3。压得越狠,元数据占比越高,所以”压缩比”会系统性地比标称值差一截,低位宽尤其明显。

一个五分钟就能做的检查

不用改代码,抽一层缓存就能判断你的模型该走哪个轴:

  1. 取一层键缓存(n×dhn\times d_h),对每个通道沿 token 维求标准差,得到长度 dhd_h 的向量;记下它的最大值与中位数之比。
  2. 对每条 token 沿通道维求标准差,得到长度 nn 的向量;同样记下最大值与中位数之比。
  3. 前者明显更大 → 离群结构在通道上,走按通道;后者明显更大 → 走按 token。

两步都是”先沿一个轴求标准差、再看这些标准差沿另一个轴的离散程度”,量纲一致、可以直接比。它只能当作筛查线索:真正的结论仍要在候选分组上实测误差与排名稳定性(第八节)。

三、一个统一算子:非对称均匀量化

不管按哪个轴分组,真正作用在数值上的算子只有一个。给定一组实数 x1,…,xgx_1,\dots,x_g,位宽 bb:

s=max⁡(x)−min⁡(x)2b−1,z=−min⁡(x)ss=\frac{\max(x)-\min(x)}{2^{b}-1},\qquad z=-\frac{\min(x)}{s}

qi=round ⁣(xis+z),x^i=(qi−z) sq_i=\mathrm{round}\!\left(\frac{x_i}{s}+z\right),\qquad \hat{x}_i=(q_i-z)\,s

其中 qiq_i 取整数、落在 [0,2b−1][0,2^b-1] 里。这一段就是全部:算范围、算步长、除一下、四舍五入、再乘回来。

为什么用非对称(带零点 zz)而不是对称量化(只用一个 scale、零点恒为 0)?因为对称量化要求范围关于 0 对称,实际取 max⁡(∣x∣)\max(|x|) 当半幅,于是当一组数整体偏向正侧(或负侧)时,另一侧的范围就白扔了。KV 缓存的分布恰恰不关于 0 对称:经过 RoPE 旋转后的键、以及值缓存,都可能有明显的均值偏移。非对称量化多存一个 zz(成本见第二节:低位宽时它并不可以忽略),换来的是步长能贴着真实范围走。

误差有多大?把量化噪声看成落在 [−Δ/2,Δ/2][-\Delta/2,\Delta/2] 上的均匀分布,直接算方差:

E[(x−x^)2]=1Δ∫−Δ/2Δ/2t2 dt=Δ212\mathbb{E}\left[(x-\hat{x})^2\right]=\frac{1}{\Delta}\int_{-\Delta/2}^{\Delta/2}t^2\,dt=\frac{\Delta^2}{12}

这个式子是整篇文章的地基,值得多看两眼。它的含义是:在上述假设下,重建误差的期望只取决于步长 Δ\Delta,与这组数的绝对大小无关(前提是:无截断、组内残差近似均匀、且步长远小于这组数的动态范围;少任何一条,这个式子都要重写)。 一组数如果整体是 100 上下浮动能被 2-bit 表示得很好,前提是组内波动小;反过来,一组数里混进一个量级大十倍的离群值,max⁡−min⁡\max-\min 被它撑大,步长跟着大十倍,剩下的所有元素就都被这一个点连累。

非对称到底省下多少,可以算一个具体例子。假设一组数落在 [−1, 10][-1,\,10]:非对称量化按真实范围做,b=4b=4 时步长是 11/15≈0.73311/15\approx0.733;对称量化必须先取 max⁡∣x∣=10\max|x|=10 当半幅,总幅变成 20,步长是 20/15≈1.33320/15\approx1.333。步长大 1.82 倍,误差方差按第三节的式子大 3.3 倍。

一个偏置明显的张量在对称量化下等于自愿放弃一半分辨率。这也是为什么本文讨论的 KV 量化实现多用非对称:它多存一个零点,换来的是步长能贴着真实范围走。

于是问题被彻底重写成一个纯几何问题:怎么分组,才能让每组的 max⁡−min⁡\max-\min 尽量小? 答案取决于离群值长在哪个轴上。

把这个式子写成解析形式,就能提前估出「轴选错」的代价。假设一组元素服从标准差 σ\sigma 的近似高斯分布,组里混进一个放大 ρ\rho 倍的离群元素,则组内极差约为 6ρσ6\rho\sigma(按 ±3σ\pm3\sigma 计),于是

Δ≈6ρσ2b−1\Delta\approx\frac{6\rho\sigma}{2^{b}-1}

同一批元素若按「同质」的方式分组(离群元素不与它们同组),等效于 ρ=1\rho=1,步长缩到约 1/ρ1/\rho,误差方差按第三节的式子降到 1/ρ21/\rho^2。也就是说:分组轴选错的代价,大致等于离群倍数的平方。 这正是「键按通道」在低比特下不是可选优化、而是生死线的原因——它把 ρ\rho 从十几拉回 1。

把它代入几组参数(本文自行计算,是解析近似、不是实测):

位宽 bb离群倍数 ρ=1\rho=1ρ=2.5\rho=2.5ρ=6\rho=6
2-bitΔ/σ=2.00\Delta/\sigma=2.005.0012.00
4-bit0.401.002.40
8-bit0.0240.0590.141

表 2 组内步长随位宽与离群倍数的解析估计(Δ/σ=6ρ/(2b−1)\Delta/\sigma=6\rho/(2^{b}-1),本文自算)

两行值得对照着看。8-bit 那一行即使离群 6 倍,步长也只有 0.14σ0.14\sigma——这个量级的扰动落进 softmax 几乎无感,所以「8-bit 量化怎么做都差不多」是真话。2-bit 那一行,离群 6 倍时步长到了 12σ12\sigma,比元素自身的波动还大一个数量级,量化后的值基本等于只报了个符号。

这里要给一个诚实的补充:这个解析式估的是「整组同质」时的量级,而第五节实测里键缓存两个轴的误差比只有 2.24 倍,远小于 ρ2\rho^2。原因不神秘——合成的离群通道自身被表示得很好,误差主要集中在被牵连的普通通道上,而相对误差是按全部元素能量归一的,离群通道的大能量把平均拉平了。这本身就是一条教训:聚合误差指标会稀释尾部,看平均 MSE 容易低估「普通通道全被压糊」这件事,所以第五节同时报了 top-5 重合率。

顺带说一句位宽的代价:把 bb 从 16 降到 4,步长大约放大 (216−1)/(24−1)≈4096(2^{16}-1)/(2^4-1)\approx 4096 倍,误差方差放大 409624096^2 倍——听起来骇人,但注意这个比较没有意义,因为 16 位本身相对真实值的误差可以忽略,我们比的是”降精度后误差还够不够小”,而够不够小要由下游任务判,不能由这个倍数判。

四、Key 的误差改写的不是数值,是「谁排第一」

量化误差从组内极值到分数误差、再到 softmax 排名改变的传导链
图 1 误差的传导链:步长决定误差,误差经分数进入 softmax(本文自绘)

这张图想说明的一件事:KV 量化最后影响的不是「值准不准」,而是「注意力把票投给了谁」——中间隔着一个指数。

Value 缓存的误差好理解:加权求和时每个值带一点噪声,输出也带一点噪声,量级大致线性。

Key 缓存的误差不一样,因为它进入的是 softmax 的指数。分数是

amn=⟨qm,kn⟩dha_{mn}=\frac{\langle q_m,k_n\rangle}{\sqrt{d_h}}

设第 nn 个 token 的键被量化成 k^n=kn+δn\hat{k}_n=k_n+\delta_n,则分数扰动是

εmn=Δamn=⟨qm,δn⟩dh\varepsilon_{mn}=\Delta a_{mn}=\frac{\langle q_m,\delta_n\rangle}{\sqrt{d_h}}

先给误差向量定一个界。每个坐标的误差绝对值不超过它所在组步长的一半,所以对 dhd_h 个坐标求和有

∥δn∥2≤12∑c=1dhΔn,c2≤12 Δmax⁡dh\|\delta_n\|_2\le\frac12\sqrt{\sum_{c=1}^{d_h}\Delta_{n,c}^{2}}\le\frac12\,\Delta_{\max}\sqrt{d_h}

最后一步在「所有组共用同一个上界 Δmax⁡\Delta_{\max}」时成立。代进柯西–施瓦茨不等式:

∣εmn∣≤∥qm∥2∥δn∥2dh≤∥qm∥2 Δmax⁡2|\varepsilon_{mn}|\le\frac{\|q_m\|_2\|\delta_n\|_2}{\sqrt{d_h}}\le\frac{\|q_m\|_2\,\Delta_{\max}}{2}

这个式子里 dh\sqrt{d_h} 在分子与分母抵消了,值得专门说一句:头维度对”逐元素误差换算成分数误差”这件事是中性的,既不给红利也不收税。误差真正由两项决定——查询的范数与步长。第一稿里我把界写成 Δg/(2dh)\Delta\sqrt{g}/(2\sqrt{d_h}),多带了一个 g\sqrt{g},那是把”单组内的 gg 个坐标”和”整条向量的 dhd_h 个坐标”混了;正确的做法是按每个坐标各属一个组求和(上式)。

组大小当然还是重要的,但它通过 Δ\Delta 起作用而不是作为独立因子:组越大,组内极差越大、Δ\Delta 越大。把第三节的极差估计代进来,就得到

∣εmn∣≲3 ρ σ ∥qm∥22b−1|\varepsilon_{mn}|\lesssim\frac{3\,\rho\,\sigma\,\|q_m\|_2}{2^{b}-1}

即误差同时随离群倍数 ρ\rho 与查询范数线性增长、随码点数量 2b−12^{b}-1 反比下降。这条链上没有额外的 g\sqrt{g} 或 dh\sqrt{d_h}。

接下来看误差怎么进到概率里。softmax 的雅可比是

∂pj∂ai=pj(1[i=j]−pi)\frac{\partial p_j}{\partial a_i}=p_j\left(\mathbf{1}[i=j]-p_i\right)

沿扰动方向做一阶展开(低比特时扰动不小,这一步是近似,界会偏松):

∣Δpj∣≤2pj∥ε∥∞⟹∥Δp∥1≤2∥ε∥∞⟹TV(p,p^)=12∥Δp∥1≤∥ε∥∞|\Delta p_j|\le 2p_j\|\varepsilon\|_\infty\quad\Longrightarrow\quad\|\Delta p\|_1\le2\|\varepsilon\|_\infty\quad\Longrightarrow\quad \mathrm{TV}(p,\hat{p})=\tfrac12\|\Delta p\|_1\le\|\varepsilon\|_\infty

合并前面的分数界,得到完整的传导链:

TV(p,p^)≤max⁡m∥qm∥2 Δmax⁡2\mathrm{TV}(p,\hat{p})\le\max_m\frac{\|q_m\|_2\,\Delta_{\max}}{2}

这条链就是 KV 量化的总纲。 它说:想让注意力分布不变形,只有两条路——降 Δ\Delta(升比特、缩小组、或把动态范围相近的元素放进同一组),或者接受只有小范数查询能保持精确。

还有一点必须说得比第一稿严格:只有”所有 logits 加同一个常数”是严格无害的,因为 softmax 对整体平移不变。但”各组各自的偏移”一般会改变注意力——组与组之间偏移不同,等于给不同键加了不同的分数修正。这个区别很关键:它解释了为什么”把动态范围相近的元素放进同一组”是对的,而不是”让每组自己带一个偏移就万事大吉”。

五、为什么 Key 按通道、Value 按 token:机制与本文自实现的数字

先说机制,两句话:

Key 缓存里,离群值长在固定的通道上,而且跨 token 稳定。 也就是说第 cc 维的数值普遍偏大,第 c′c' 维普遍偏小,这种”哪一维大”的结构不随 token 变。于是沿通道方向(同一列、跨若干 token)分组,组内元素的量级本来就是一致的,max⁡−min⁡\max-\min 由该维自身的波动决定,步长可以很小。反过来若按 token 分组(同一行、跨若干通道),就会把一个标准差大十倍的通道和一个标准差 1 的通道塞进同一组,后者被前者的尺子量,误差被放大了一个量级。

Value 缓存里,离群值长在个别 token 上,通道之间没有稳定的结构。 某些 token 的整行数值都偏大(常见于序列里语义特殊的位置),但这些”大 token”落在哪些通道上是随机的。此时按通道分组反而会把”大 token 在该通道的取值”和”小 token 在该通道的取值”混在一起,而按 token 分组则天然把同一条 token 的所有维度放在一组,组内一致性更好。

同一个量化算子沿通道或沿 token 分组,两条缓存各自的正确分组方向不同
图 2 算子相同,分组轴不同:Key 沿通道、Value 沿 token(本文自绘)

这张图想说明的一件事:正确与否不在算子,而在「谁和谁被放进同一组、共用一个步长」。

KIVI 系统研究了这件事(arXiv:2402.02750,本文采用 v2 2024-07-25 的口径):它先对主流模型的 KV 元素分布做了统计,得出「键缓存应按通道量化、值缓存应按 token 量化」的判断,再据此设计了一个免校准(tuning-free)的 2-bit 方案。按其摘要口径,该方案在 Llama、Falcon、Mistral 上”质量几乎不变”的前提下把峰值显存(含模型权重)降到约 1/2.6,支持最多 4 倍大的 batch,在真实推理负载上给出 2.35×~3.47× 的吞吐。注意这里的口径:2.6× 是含权重的峰值显存,不是”KV 缓存本身的压缩比”;吞吐是真实负载上的端到端数字,不是单算子微基准。这两个限定很重要,跨论文引用时必须带上。

那这个机制在数值上到底差多少?光看论文容易记成”经验规则”,所以我用一段纯 Python 做了个最小可复现的模拟,把”轴”这一个变量单独拎出来。

实验设定(参数完整、可复现):头维度 dh=64d_h=64、序列长度 n=128n=128、组大小 g=32g=32、随机种子固定(种子 20261113,基础分布为标准正态);键缓存按”每 16 维有一个标准差放大 13 倍的高斯通道”构造(模拟通道级离群),值缓存按”每 24 个 token 有一个整行放大 11 倍的 token”构造(模拟 token 级离群);量化器就是第三节那个非对称均匀量化,分组沿行(按 token)或沿列(按通道);评价三个量:相对重建误差 ∥K^−K∥F2/∥K∥F2\|\hat{K}-K\|_F^2/\|K\|_F^2、四个合成查询下 softmax 分布与原始分布的 TV 距离均值与最大值、以及 top-5 键集合与原始的重合率。

结果如表 3。

目标位宽分组轴相对重建误差TV 均值TV 最大top-5 重合
K2-bit按 token0.35520.63970.77070.400
K2-bit按通道0.15860.35690.47660.600
K4-bit按 token0.01350.14690.18710.800
K4-bit按通道0.00660.08570.12300.850
K2-bit整向量一组(g=dhg=d_h)0.67550.88160.99460.350
V2-bit按 token0.1569———
V2-bit按通道0.3215———
V4-bit按 token0.0060———
V4-bit按通道0.0126———

表 3 同位宽、同组大小下的分组轴对照(末行为整向量分组参考;合成分布、本文 2026-11-13 自实现、非模型实测)

这套模拟的可复现步骤很短,全部加起来不到五十行代码、跑一次不到一秒:

  1. 构造 K∈Rn×dhK\in\mathbb{R}^{n\times d_h} 与同形状的 VV,人为指定离群结构(通道级或 token 级)。
  2. 选定分组轴与组大小 gg,把张量切成若干组。
  3. 逐组求极值,按第三节算出 ss 与 zz。
  4. 逐元素做 round(x/s+z)\mathrm{round}(x/s+z),裁到 [0,2b−1][0,2^{b}-1],得到整数码字。
  5. 反量化回浮点,得到 K^\hat{K}、V^\hat{V}。
  6. 算三个评价量:相对重建误差、softmax 分布与原始分布的 TV\mathrm{TV} 距离、top-kk 键集合重合率。

刻意只用标准库、不调任何量化工具包,是为了让「轴」成为唯一的自变量——引入第三方实现就引入了它的分组策略、它的舍入方式、它的 kernel 假设,反而看不清机制。

这张表里有四个值得记住的读数:

第一,键缓存上”按通道”确实便宜。 2-bit 下相对误差从 0.3552 降到 0.1586,差 2.24 倍;折算到最终效果,top-5 键集合的重合率从 0.400 升到 0.600——后者更贴近工程关心的东西:模型”看哪几个 token”变了没有。

第二,值缓存上方向反过来,而且倍数几乎对称。 2-bit 下按 token 是 0.1569,按通道是 0.3215,差 2.05 倍。两个方向的优势倍数接近不是巧合:它反映的是”离群结构落在哪个轴”,而两组合成数据里的离群强度是分别设置的(键 13 倍、值 11 倍),并非严格对称。

第三,比特一升,轴的差距就缩小,但不会消失。 键缓存在 4-bit 下两个轴是 0.0135 对 0.0066,仍然是 2 倍;只是绝对误差已经小到下游感知不到。这解释了为什么”8-bit 量化怎么做都行”——轴的错误在 8-bit 下被分辨率掩盖了,等到压到 2-bit 才暴露。反过来说:如果你只做 8-bit,别指望这套轴的分析能给你额外收益;如果你打算做 2-bit,轴选错就是直接崩。

第四,整向量一组是灾难。 把 64 维全塞进一组、2-bit 量化,相对误差 0.6755,top-5 重合率 0.350。作为参照,在 128 个键里均匀随机挑 5 个的期望重合比例约 5/128≈0.039,所以 0.350 是「明显下降、但远非随机」——它说明排名已开始不可靠,而不是完全失效。这一行是用来打掉”分组只是实现细节”的错觉的:同样 2-bit、同样算子,只改组大小,本合成设置下的误差与排名稳定性就垮掉了。

最后提醒一句:本节的数字是「同一算子、只换轴」的对照,不是「某个方案能省多少」的产品性能预期。把仿真结论当成上线后的性能承诺,是这类文章最常被误用的地方。

必须声明这里的边界:这是合成分布上的模拟,不是真模型,Δ\Delta 和误差的绝对值不能外推成”某模型在 2-bit 下掉多少分”。它能证明的只有一件事——在离群结构已知的前提下,分组轴的选择对误差的影响是一阶的,量级在 2 倍以上。真模型上是否也是 2 倍,得按 KVQuant 那类方法在真实激活上量,本篇不冒充。

与结构化压缩衔接时,轴要重测一遍

把这篇与前一条路线(改结构)叠在一起时,有一个容易踩的坑:结构压缩之后,分组轴的正确选择可能翻过来。

以低秩潜空间缓存(MLA 那一类)为例,键和值先被投影到一个维度小得多的潜向量上再缓存,元素数按数量级下降。此时缓存里存的不再是”每个头的键/值”,而是”每条 token 的潜向量”,它的通道语义与原来的键通道完全不同——原来的”某些通道方差大”的结构可能被投影抹平,也可能被投影重组成新的结构。照着原来的结论把潜向量按通道切,没有任何理由认为它还是对的。

所以叠加两种压缩时,顺序上的建议是:先做结构压缩,再在压缩后的张量上重跑第五、六节的分布探针(逐维标准差、离群是否跨 token 稳定),再决定轴与位宽。反过来先按 KV 的经验定好量化参数、再换结构,通常会得到一组既不最优、也说不清为什么的配置。

顺带说一句,这也是一种”信息在哪”的问题:结构压缩赌的是”信息在低维子空间里”,数值压缩赌的是”低维子空间里的每个数用更少的比特也够用”。两个赌注的风险不叠加,但它们的前提必须在同一个张量上同时成立——这就是为什么必须重测,而不是把两份结论拼起来。

六、掉到 4-bit 以下,靠的不是一个技巧而是一组补丁

上面的分析只说清”轴”,但真正把 2-bit~3-bit 做到可用,靠的是几件叠加的补丁。KVQuant 是这一路线上机制讲得较全的一篇,它的四个机制各治一个病,可以当作诊断表用。

机制治什么病为什么有效
键缓存按通道量化通道级离群把组内步长撑大让每组只含同一通道的元素,动态范围由该通道自身决定
在 RoPE 之前量化键旋转把通道结构搅乱RoPE 是通道对的旋转,会把原本稳定的通道分布随位置变化打散
按层的敏感度加权学习非均匀码点均匀网格对偏斜分布不是最优固定码字位数,但让码点的位置按该层敏感度重新分布
逐向量的稠密 + 稀疏分离单条向量里的少数极端离群把离群值单独存(值 + 位置),密集部分用窄范围量化

第一条已经在第五节讲透。第二条值得单独展开,因为它是最容易被”想当然”漏掉的一条。

RoPE 做的事是把每一对通道 (2i, 2i+1)(2i,\,2i+1) 按位置旋转一个角度,作用在查询与键上、让内积带上相对位置信息:

(k2i′k2i+1′)=(cos⁡θ−sin⁡θsin⁡θcos⁡θ)(k2ik2i+1)\begin{pmatrix}k'_{2i}\\ k'_{2i+1}\end{pmatrix}=\begin{pmatrix}\cos\theta & -\sin\theta\\ \sin\theta & \cos\theta\end{pmatrix}\begin{pmatrix}k_{2i}\\ k_{2i+1}\end{pmatrix}

旋转保长度、但不保”哪一维大”。原本第 cc 维若有个稳定的大方差,旋转之后这份方差会被摊到配对的另一维上,摊多少随位置 θ\theta 变。于是”通道级离群、跨 token 稳定”这个前提被破坏——同一组的成员构成开始随位置漂移,组内极差跟着变大。

解法不是改算子,而是改量化发生的时点:在 RoPE 之前把键量化掉,缓存里存”未旋转的键 + 位置”,读出来先反量化再旋转。代价是每次注意力多一步反量化与旋转,收益是量化时的分布与位置无关。它与第一条是配套关系,不是可选项。

第三条要特别小心,我第一稿把它写宽了。KVQuant 摘要的原话是「按层敏感度加权的非均匀数据类型」——它指的是:码字位数固定(例如统一 X-bit),但每一层的量化码点位置按该层对误差的敏感度重新学习,而不是均匀等距的网格。这跟”敏感层多给几位、不敏感层少给几位”是两回事:后者是跨层的位宽分配,前者是同一码字宽度下的码点分布。两者都能省误差,但机制与实现完全不同,不能互相解释。本文后面那个”位宽预算的背包问题”是我自己的延伸推演,明确标注为独立探讨,不是 KVQuant 的机制。

第四条治的是最顽固的一类:单条向量内部的极端值。第三节那个式子说明,一个离群点就能把整组步长撑大。既然它只有一个(或几个),不如把它从密集表示里抠出来:记录它的位置和原值,剩下的元素用不含它的窄范围量化。存储上多了一点索引开销,但极差立刻收窄一个量级。

第四条的开销值得算清,因为它常被当成”免费”。以 2-bit、dh=128d_h=128 为例,每条向量压完的载荷是 128×2/8=32128\times2/8=32 字节;若单独抠出 2 个离群值,每个存 1 字节索引加 2 字节原值,共 6 字节,约占载荷的 19%。这个代价换来密集部分的极差收窄,通常划算;但离群点若有三五个以上,索引开销会迅速吃掉收益——“抠几个”要按分布定,不是常数。

三个结果不要捆成一个配置

KVQuant 摘要里并列了三组结果,必须拆开读,否则很容易被当成”同一套 3-bit 配置同时做到三件事”:

  1. 3-bit 量化在 Wikitext-2 与 C4 上困惑度退化小于 0.1——这是质量口径,且是困惑度的绝对变化量,不是百分比。
  2. LLaMA-7B 单张 A100-80GB 做到最高约 100 万上下文、8 卡系统最高 1000 万——这是容量口径,取决于当时那套位宽与硬件设定。
  3. 相对 fp16 矩阵向量乘最高约 1.7× 加速——这是单个算子的上限值,不是端到端吞吐。

摘要没有逐项写出每条结果各自用了几比特,所以本文也不替它补。要引用具体数字,就回到论文对应的小节,把位宽、模型、度量、版本一起写出来。

另一个视角:格式本身

前面都默认”均匀网格”,步长是常数、误差是绝对值。浮点格式不一样:指数决定量级、尾数决定相对精度。FP8 的两个编码——E4M3(4 位指数、3 位尾数)与 E5M2(5 位指数、2 位尾数)——就是按这个思路定的,其中 E4M3 通过不表示无穷、只保留一种 NaN 位型来换取更大的动态范围,论文报告在最高 175B 参数的模型上训练质量与 16 位相当。

这里也要把话说准。尾数 mm 位意味着:正规数区间内相邻表示值的相对间隔约为 2−m2^{-m},而最近舍入的相对误差上界约为它的一半。所以 E4M3(m=3m=3)的相邻间隔约 12.5%、舍入误差上界约 6.25%;E5M2(m=2m=2)分别是 25% 与 12.5%。这两个数是”上界/间隔”,不能直接和均匀量化的 RMS 误差 Δ/12\Delta/\sqrt{12} 相比——指标不同,比出来的倍数没有意义。

浮点格式的真实优势在于自动按量级分配精度:一个张量内部动态范围跨好几个数量级时,均匀量化的 Δ\Delta 会被最大值绑死、小的元素全被淹没,而浮点格式不需要额外的分组或离群分离就能跟上。但它不是免费的午餐:仍要缩放(把张量搬进可表示范围)、仍有有限动态范围与下溢,是否还需要分组或离群处理必须实测,不能假设。

顺带把”权重/激活侧”的低比特也放进来对照:Atom 走的是 4-bit 权重与激活量化,靠混合精度与细粒度量化保精度,摘要给出的数字是在同等延迟目标下相对 FP16 最高 7.7× 端到端吞吐、相对 INT8 2.5×。这条线的逻辑与 KV 量化一致——低比特的真正收益来自低比特算子(比如 4-bit 整数乘加),而不只是省显存;如果只是把数存窄、算的时候还是反量化回 16 位再做,那你买到的是带宽,不是算力。

位宽的边际收益

最后一个常被问的问题是「到底该压到几比特」。把前面几节拼起来,答案是一条曲线而不是一个点。固定组内极差 RR 时,步长是 Δ=R/(2b−1)\Delta=R/(2^{b}-1),所以从 2-bit 往上,每一步的收缩是

位宽步长相对 2-bit误差方差相对 2-bit备注
2-bit1×1×需要轴、RoPE 前量化、离群分离等机制配合
3-bit3/7≈0.433/7\approx0.43约 0.18多数公开报告里”退化可接受”的落点
4-bit3/15=0.203/15=0.200.04多数设置下机制需求明显降低
8-bit3/255≈0.0123/255\approx0.012约 1.4×10−41.4\times10^{-4}存储收益到顶,质量风险最低

表 4 固定极差下的位宽边际(按 Δ∝1/(2b−1)\Delta\propto1/(2^{b}-1) 推算,本文自算,非实测)

注意分子是常数 3(相对 2-bit 的 22−12^2-1),所以比值不是简单的”每多一位减半”——那位简化只在位宽较高时近似成立。表里 3-bit 相对 2-bit 只降到 0.43,而不是 0.5;8-bit 相对 2-bit 是 0.012,而不是 1/64。

这张表要表达的是边际收益递减与机制需求的关系,不是一张”位宽安全表”:8-bit 的存储收益到顶、质量风险最低,但”把轴选对”在这档几乎不带来额外收益;2-bit 的收益最大,代价是必须把分组、位置编码时点、离群处理都吃透。具体到某个模型、某个负载能不能用 2-bit,仍然要靠第八节的校准与验收,本文不给跨模型通用的门槛。

一个可探索的方向:键和值用不同位宽

还有一条常被忽略的自由度:键和值不一定要用同样的位宽。 第四节的推导给出了理由——键的误差经过分数的指数进入,改的是排名;值的误差只是加权求和里的加性噪声,改的是输出的幅度。两类误差对下游的放大方式不同,所以给它们分配同样的比特是最省事的选择,但未必最优。

从这个角度看,“4-bit KV 量化”这个说法本身就是粗的:它至少应该是 (bK,bV)(b_K,b_V) 一对数。实践中哪一侧更该省取决于负载——长上下文检索类任务对排名敏感,键该保精度;摘要类任务对幅度更宽容,值可以压得更狠。这个方向在公开材料里讨论得不多,我把它列为可探索项而不是推荐做法。

附:位宽预算的背包问题(本文的独立推演,非上述论文的机制)

如果各层敏感度差异很大,“位宽怎么分”可以形式化。设第 ll 层的误差贡献为 cl⋅4−blc_l\cdot4^{-b_l}(clc_l 是把该层误差放大到下游的系数,4−b4^{-b} 来自第三节的 Δ2∝(2b)−2\Delta^2\propto(2^b)^{-2}),预算为平均每层 bˉ\bar b 位:

min⁡{bl} ∑l=1Lcl 4−bls.t.∑l=1Lbl≤bˉ L\min_{\{b_l\}}\ \sum_{l=1}^{L}c_l\,4^{-b_l}\quad\text{s.t.}\quad\sum_{l=1}^{L}b_l\le\bar b\,L

目标对 blb_l 凸、约束线性,所以贪心近似最优:每轮把”下一个比特”给边际收益最大的层,最终把各层的 cl4−blc_l4^{-b_l} 拉平,直觉上就是”别让任何一层成为短板”。

这段推演与 KVQuant 的”非均匀码点”不是一回事:前者换的是每层的位宽,后者换的是同一位宽下的码点位置。两者可以叠加,但不要混为一谈——尤其是不能拿它去解释论文里”3-bit”的含义。若各层 clc_l 大致相等,贪心解退化成均匀分配;所以问题不在均匀分配本身错了,而在于默认它是对的。

七、淘汰与降精度:一刀切下去和旋钮拧一格的区别

到这里必须处理一个容易被混进同一句话里的对照:既然显存不够,为什么不直接把远处的 KV 扔掉?

因为”扔”和”压”在信息论上不是一回事。淘汰(eviction)是离散动作:某条 KV 要么在、要么不在,一旦不在,后续任何一步都无法再恢复它携带的信息。降精度是连续动作:每个元素都还在,只是分辨变粗,模型仍能”看见”它、只是看得糊。

MiKV(arXiv:2402.18096,v1 2024-02-28)把这件事问得很直接:它先检查了淘汰对生成过程的影响,观察到被丢掉的信息会带来意料之外的风险——包括安全边界被突破、幻觉、以及上下文丢失;接着给出一个反直觉的发现:把被淘汰的那些 KV 用极低精度保留下来,就能大幅挽回退化;同时,重要的 KV 必须维持相对较高的精度。

这两条合起来,给出一张比”全 4-bit”或”全淘汰”都更好的折中表:按重要性分配比特,而不是按存在与否做二元决策。 重要的少压、不重要的往死里压但不丢。工程上这通常比淘汰更容易调,因为它的退化更多表现为”分辨率下降”而不是”整段信息消失”;但这不等于”平滑无害”——量化同样可能让某几步突然读错,失效形态要靠实测确认。

代价也实打实:混合精度意味着缓存不再是一块规整的、可以按统一 stride 读的张量,访存和 kernel 都要为”同一层里存在多种位宽”付代价。这也是为什么”平均 bit 数相同”的两个方案,在真实吞吐上可能差很多——纸面上的比特数只有在 kernel 能高效消费它时才是真的。

混合精度里绕不开的一个问题是:重要性信号从哪来?最自然的是注意力分数本身——某个 KV 被很多查询高分命中,就该多留精度。但这里有个鸡生蛋:要算分数就得先把该 KV 读出来,而它已经被压糊了。工程上的折中是用历史窗口的分数统计当代理量:过去若干步里这条 KV 的平均注意力权重,用它来定下一段窗口的比特分配。

这类做法有一个共同的软肋:重要性是时变的。某个 token 在前 20 步里无人问津、在第 21 步突然变成关键(多跳推理里常见),而它的精度已经在前面被压掉了。目前没有任何方案能同时满足「不预读」「不错判」「不额外存一份」——这也解释了为什么混合精度方案往往要配合一个「最近窗口保留高精度」的兜底。

(顺带一句自我约束:上面这段的因果是用 MiKV 的摘要口径转述的,我没有复现它的实验;“混合精度更安全”在本篇是文献观察 + 机制推理,不是我的实测结论。)

需要分清的是,淘汰本身也有两种形态,而它们与量化是正交的、可以叠加:按位置(滑窗、只看最近 N 个 token)与按分数(保留历史注意力权重高的那些)。前者实现简单、对局部一致性友好,但会整齐地砍掉远古信息;后者能保住关键证据,却要维护一份分数统计,且被保留下来的 token 分布很不均匀——但被保留下来的 token 在序列上高度不均匀,这会影响跨 token 的分组:按通道量化时,一组的成员是同一通道上连续的一段 token,淘汰之后这段变稀疏,组内极差反而可能变大。

所以”先淘汰、再量化”和”先量化、再淘汰”不是同一条路的两端,而是两种不同的误差形状:两者丢失的信息量并不因此改变——最终保留的集合是一样的;改变的是量化时看到的分布:先量化则组内统计基于完整上下文,先淘汰则基于被稀疏化之后的上下文。哪种更好取决于分组轴与淘汰比例,本文不给普适结论。

八、工程落地:先算账,再选轴,最后才轮到 kernel

量化方案讨论到最后总会滑向”用什么 kernel”,但顺序应该反过来。第一步是把账算清:你到底缺不缺 KV 的显存?缺多少? 不回答这个,压到 2-bit 也可能毫无收益。

单序列、跨全部 LL 层、每个 token 的键值码字载荷(只计码字,不含 scale 与零点等元数据,也不含权重、激活与工作区):

bytes/token=2⋅L⋅Hkv⋅dh⋅b8\mathrm{bytes/token}=2\cdot L\cdot H_{kv}\cdot d_h\cdot\frac{b}{8}

前面的 2 是”键和值各一份”。代入一组具体结构(L=32L=32、Hkv=32H_{kv}=32、dh=128d_h=128,即全 MHA 的 7B 级配置),每个 token 是 2×32×32×128=262,1442\times32\times32\times128=262{,}144 个元素:

位宽每 token 字节相对 fp16100 万 token 合计
16-bit524,288(512 KiB)1×约 488.28 GiB
8-bit262,144(256 KiB)2×约 244.14 GiB
4-bit131,072(128 KiB)4×约 122.07 GiB
2-bit65,536(64 KiB)8×约 61.04 GiB

表 5 单序列 100 万 token 的 KV 码字载荷(本文按上式实算:只计码字,不含元数据,也不含权重、激活与工作区)

最该被记住的是量级:全 MHA 结构下,100 万 token 的 fp16 码字载荷约 488 GiB。 这个数字远超单卡容量,所以”长上下文”从来不是”模型能不能算”,而是”缓存放不放得下”。8× 那一栏(2-bit,61 GiB)说明:只从码字看,单卡百万上下文的算术是成立的;但能否真的跑起来,还要加上权重、激活、元数据与工作区——表里的数字不能直接当成”单卡可运行”的证明。

把账算到一个真实规模上看看。取 n=32768n=32768(32K 上下文)、并发 B=8B=8,用表 5 的结构(L=32L=32、Hkv=32H_{kv}=32、dh=128d_h=128,全 MHA),八条序列各占 32K:

524,288 B×32,768×8=128 GiB524{,}288\ \text{B}\times32{,}768\times8=128\ \text{GiB}

也就是说,一个 32K 上下文、8 路并发的服务,光 KV 码字就要吃掉 128 GiB——比权重还大。同样规模压到 4-bit 是 32 GiB,2-bit 是 16 GiB。这就是为什么”长上下文”在工程上最先撞到的墙不是算力而是缓存:算力可以靠扩大 batch 摊薄,缓存只会随 batch 和长度相乘增长。

给定显存预算,能同时服务多少 token 也可直接解出来。设可用于缓存的显存为 MkvM_{kv}(总显存减去权重与激活峰值),则

Bmax⁡=⌊Mkvbytes/token⋅n⌋B_{\max}=\left\lfloor\frac{M_{kv}}{\mathrm{bytes/token}\cdot n}\right\rfloor

这是一个理想上限:只受 KV 载荷约束,忽略元数据、显存碎片与残留的高精度块。实际并发要按真实占用再打折,尤其低位宽时元数据占比重(第二节:2-bit、g=32g=32 时约 1/3)。

这个式子也解释了一个常见的工程现象:量化的收益在长上下文、大并发时才兑现。 nn 只有 2K、batch 只有 1 时,KV 可能只占几百 MB,压到 2-bit 省下的显存换不来可感知收益,却引入了完整的误差风险。但反过来说,“短上下文就不用量化”也不是可以拍脑袋的结论——先按上式算一遍自己的实际预算,再决定。判断”该不该压”的第一条永远是”MkvM_{kv} 是不是瓶颈”,不是上下文长度的经验阈值。

关于 KVQuant 的百万上下文:它的量级与表 5 那一栏相近,但相近不等于复现。本文按十进制 100 万 token、单序列、只计码字算;论文的结论取决于它当时的位宽设定、附加存储与”可用显存”的定义,而能不能真跑起来还要算权重、激活与工作区。所以这里不用自己的数字去反推它的结论,两者的口径必须各自说明。

第二步是选轴,这一步在第五、六节已经讲完:键按通道、值按 token,低位宽时再叠 RoPE 前量化与离群分离。

第三步才是 kernel,而这里有一个容易被忽略的净收益条件。设显存带宽 BW\mathrm{BW}、反量化的算力开销为每元素 cc 次操作、有效算力 TOPS\mathrm{TOPS}、实际压缩率 rr(理想 2-bit 载荷时 r=8r=8,含元数据后更小),则读进一个键向量并参与点积的耗时为

t16=bytes16BW,tq=bytes16/rBW+c dhTOPSt_{16}=\frac{\mathrm{bytes}_{16}}{\mathrm{BW}},\qquad t_{q}=\frac{\mathrm{bytes}_{16}/r}{\mathrm{BW}}+\frac{c\,d_h}{\mathrm{TOPS}}

只有

c dhTOPS<(1−1r)bytes16BW\frac{c\,d_h}{\mathrm{TOPS}}<\left(1-\frac1r\right)\frac{\mathrm{bytes}_{16}}{\mathrm{BW}}

时量化才真的更快。左边是”多做的那点活”,右边是”少搬的那部分字节换来的时间”。这个模型只比较载荷与反量化开销,忽略了共同计算、元数据读取与流水重叠——它给的是必要条件,不是性能预测。不等式在解码阶段(矩阵向量乘、带宽受限)通常成立,在预填充阶段(大矩阵乘、算力受限)就不一定;那里的正确做法是不要把缓存反量化回 16 位再算,而是让 kernel 直接消费低比特数据。

落到实现上,有三个坑在论文里一般不写,但决定方案能不能上线:

  1. 低位宽的整数指令并不总是存在。 2-bit / 4-bit 没有通用的乘加指令,很多硬件上只能「解包 → 转回 16 位 → 再做点积」,那这条路的收益就退化成纯带宽优化(上面那个不等式仍然成立,但只覆盖带宽那一侧)。想吃到算力那一侧,需要硬件或 kernel 提供真正的低比特点积——Atom 报的 7.7× 属于这一类,而纯粹的”存得窄、算得宽”拿不到。
  2. 打包与未对齐访存。 把 4 个 2-bit 塞进一个字节,取第 kk 个元素要做位运算;如果组的边界与访存宽度不对齐(例如 g=32g=32 而一次读取跨 128 字节),每次取数都可能跨两组,两个 scale 都要载入,带宽优势当场被吃掉一半。这就是为什么工程上的组大小几乎总是 16 / 32 / 64 这类 2 的幂。
  3. scale 的广播开销。 按固定组大小 gg 切分时,两种轴产生的 scale 总数其实相同:按通道是 dh⋅(n/g)d_h\cdot(n/g) 个,按 token 是 n⋅(dh/g)n\cdot(d_h/g) 个,都是 n⋅dh/gn\cdot d_h/g。差别在访存方向——按通道时同一组的成员沿 token 方向连续,按 token 时沿通道方向连续,后者的取数更接近 gather。是访存步进而不是字节数决定这一项的成本。

第四步是校准与验收,这一步最容易被跳过,也最容易埋雷。 这里要先把一个常见误解拆开:分组轴、统计窗口、参数更新时间是三件不同的事。 按通道量化并不天然等于”离线静态校准”——KIVI 那类方案是在写入时对新到的 token 分块量化(在线,按 token 块统计),KVQuant 那类方案是用一小批校准数据预先定参数(离线)。两者都可能在各自的分组轴上工作,区别只在统计窗口与更新时机。

由此还带出一个必须处理的工程问题:运行极值会变。如果用运行最大值维护 scale,那么”新数据用新 scale、旧数据用旧 scale”——一旦重新估参,旧数据要么重编码,要么按块保留各自的参数。这解释了为什么不少实现在缓存里按块存参数,而不是全局一套。

一套能复现的验收流程大致五步,每一步都说清”看什么”,而不是”信什么”:

  1. 取真实激活,不要用随机张量。 从目标模型、目标负载(同样的上下文长度分布、同样的语言与代码比例)跑一批前向,把每层的 KK、VV dump 下来。合成数据只能验证机制,不能替代校准。
  2. 按维统计,先看结构再看数值。 用第二节那个五分钟检查:逐维标准差的离散程度,与逐 token 标准差的离散程度,哪个更大。
  3. 算有效分辨率,而不是报位宽。 对每个候选的(bb、gg、轴)组合,直接在真实激活上算 Δ\Delta 分布与重建误差,不要拿”我用了 4-bit”当结论。
  4. 把误差翻译成下游指标。 重建误差本身不说明问题,要算”注意力排名变了多少”——用第五节的 top-k 重合率或 TV\mathrm{TV} 距离,在真实查询上量。
  5. 端到端兜底,且分能力看。 最后才跑评测集与业务样本,检索、长链推理、格式遵循分开报,因为聚合指标会把尾部的崩塌平均掉。
验收项看什么为什么不能省
通道结构逐维标准差的离散程度决定通道轴值不值得做
实际步长真实激活上的 Δ\Delta 分布位宽不等于分辨率
排名稳定性top-k 重合率 / TV\mathrm{TV}对应「模型还看得见该看的东西吗」
分能力评测按任务类型拆开的指标聚合口径掩盖尾部失效
真实吞吐端到端 token/s,含反量化开销纸面比特数不等于上线收益

表 6 校准与验收的五项(本文提出的流程建议;具体阈值须按业务定,本篇不给「通过线」)

刻意不给通过线(比如”TV 必须小于 0.05”),因为这类阈值高度依赖任务:摘要服务能容忍的排名抖动,放在法规检索上就是事故。方法可以通用,阈值不能通用。

还有一个与调度层的耦合值得点一句。量化直接改变”每条序列占多少缓存”,于是改变单卡可并发数;而并发数一变,前缀缓存的命中率、队列结构与准入判断都跟着变。也就是说,量化不只是一个内存优化,它同时是一个吞吐参数:同一个模型、同一批请求,4-bit 缓存下的理想并发上限是 fp16 的两倍(理想载荷口径),但每条序列的注意力质量略降——这两件事必须放在同一个决策里权衡。

本站此前那篇讲前缀缓存准入的分析,讨论的是”新请求要不要为已缓存的重复前缀让路”;把精度维度加进来之后,问题会变成”让路时要不要顺带把被让的那部分压一档”。这类联合优化目前缺少系统研究(就我所见的公开材料而言,截至本文写作时),属于工程上的空白地带。

九、边界、未解与本文没有做的事

诚实交代边界比给结论更重要,尤其在这个题目上。

第一条边界:本篇文章的实验是合成分布上的小规模模拟,不是模型实测。 第五节的表 3 里那些数字(0.3552 / 0.1586 / 0.6755 等)来自一段固定种子的纯 Python 代码,构造的是”人为制造通道级离群”和”人为制造 token 级离群”的高斯张量。它能做的是隔离变量:在其他条件完全相同时只改分组轴,看误差怎么变。它不能回答”某个真实模型在 2-bit 下掉多少分”——那需要真实激活、真实评测集、真实的 kernel。本篇没有跑任何模型推理,所有涉及模型效果的数字都是论文口径的转述。

第二条边界:跨论文的数字不可直接比较。 本文引到的几组数字,口径各不相同:KIVI 的 2.6× 是含模型权重的峰值显存、2.35×~3.47× 是真实负载吞吐;KVQuant 的”退化小于 0.1”是 3-bit 下 Wikitext-2 与 C4 的困惑度;Atom 的 7.7× 是同等延迟目标下的端到端吞吐、且量化对象是权重与激活而非 KV。把它们排在一张表里说”某某更好”是错的,本篇刻意没有这么做。

第三条边界:几个真正没解决的问题。

其一,静态 scale 与分布漂移。按通道量化用运行最大值定 scale,前提是”这一维的分布跨 token 稳定”。但当上下文发生主题切换(比如从代码切到自然语言)、或者系统提示换了一套格式时,某一维的量级可能整体位移,运行最大值要么跟不上(截断)、要么涨上去再也不肯降(分辨率白白浪费)。这是所有静态校准方案的共同软肋,目前工程上靠”周期性重估 + 截断率监控”缓解,没有一个干净的答案。

其二,2-bit 下的能力分解。论文给的多是困惑度或”质量几乎不变”这类聚合口径。但第五节那个 TV\mathrm{TV} 与 top-5 重合率的读数提示了一件事:量化主要伤的是”排名”,而排名在不同任务上的重要性天差地别——摘要、闲聊可能无感,而精确检索、多跳推理、长链计算的失败模式恰恰是”看错了该看的 token”。这一层在现有公开材料里还没有被逐能力拆开。

其三,与其它缓存机制的交互。前缀缓存复用(把相同前缀的 KV 直接搬过来用)与投机解码(一次验证多个候选 token)都会改变”缓存何时被写、何时被读”的模式。量化后的缓存在被复用时,误差是照旧累积还是因为”同一份缓存被读很多次”而被放大,目前缺少系统性的证据。本站此前对前缀缓存调度的那篇分析关注的是准入与排队,没有触及精度维度,这两件事合起来才是完整的”缓存经济学”。

其四,反量化的数值稳定性。均匀量化里 round\mathrm{round} 与除零(max⁡=min⁡\max=\min 的退化组)需要显式处理;浮点格式里溢出与 NaN 的位型约定会直接影响 kernel 的正确性——E4M3 之所以要”不表示无穷、只留一种 NaN”,就是为了把指数空间全部用于有限值。这些是实现细节,但它们决定了”纸面误差分析”能不能在硅片上成立。

最后给一张自测用的判断表,按情形对号入座,比记结论实用:

你的情形建议理由
上下文短、并发低先用第八节的公式算出实际预算再决定缓存可能不是瓶颈,收益换不来风险
8-bit 就能装下停在 8-bit轴错误会被分辨率掩盖,进一步压缩边际很小
需要 4-bit先把轴选对4-bit 下选对轴基本无需其它补丁
需要 2-bit轴 + RoPE 前量化 + 离群分离,并做真实激活校准误差已超过元素自身波动
聚合指标通过但业务样本退化按能力重跑评测平均值会掩盖尾部的崩塌

表里最容易被忽略的是第一行。量化的收益与「MkvM_{kv} 是不是瓶颈」强绑定,而这个判断只能从自己的负载里算出来,不能从别人的成功案例里抄。

为什么「困惑度几乎不掉」不能当作上线依据

困惑度是平均负对数似然的指数:

PPL=exp⁡(−1N∑t=1Nln⁡p(xt∣x<t))\mathrm{PPL}=\exp\left(-\frac{1}{N}\sum_{t=1}^{N}\ln p(x_t\mid x_{<t})\right)

这个定义决定了它对尾部不敏感。举个数:假设 1% 的 token 的负对数似然突然增加 10 nat(这些 token 基本等同于”看不懂了”),其余 99% 不变,则平均只增加 0.01×10=0.10.01\times10=0.1 nat,困惑度变成原来的 e0.1≈1.105e^{0.1}\approx1.105 倍,也就是涨 10.5%。而如果全部 token 均匀恶化 0.1 nat,困惑度同样涨 10.5%。两种完全不同的失效模式,在困惑度上是同一个数字。

这就是为什么”退化小于 0.1”这类结论必须带着评测集与模型一起读:它说明的是”没有大面积崩”,不是”没有局部崩”。对 KV 量化尤其要小心,因为第四节的推导已经指出误差主要伤的是排名(谁排第一),而排名失效恰好会表现为”少数 token 突然读不懂”——正是被平均值摊薄的那一类。

替代口径至少要加两个:一是分位数(比如负对数似然的 P95、P99),二是任务级指标(检索命中、格式遵循、多跳准确率)。前者能看见尾部,后者能看见”能力”,两者都不是平均值能替代的。

最后一条容易被忽视的评测纪律:比较两种量化方案时,解码设定必须钉死(温度、top-p、随机种子、批内顺序)。原因很直接——量化伤的是排名,而排名恰好是采样最敏感的环节;温度一变,同一份误差会表现为完全不同的文本。一个具体的形态是:同一份误差,温度取 0 时表现为”每次都选同一个错词”,温度取 1 时表现为”偶尔跑题”,两种表现的严重性判断完全不同。结论是,困惑度本身是基于固定测试文本、用模型原始预测分布算出来的,不涉及采样;一旦进入生成比较,温度与 top-p 就必须钉死。

这也解释了为什么本篇通篇不给一个”最佳位宽”的结论:它不存在,存在的只有”你的负载 + 你的硬件 + 你的验收口径”三者共同决定的一个点。能给的是判据,不是数值。

三条判据,按成本从低到高:其一,一维标准差分布的离散程度(决定通道轴是否值得做);其二,真实激活上的步长分布与排名稳定性(决定某组参数能不能用);其三,分能力的端到端指标(决定能不能上线)。前两条几分钟到几小时就能出结论,第三条可能要一两天。跳过前两条直接做第三条,是这类项目最常见的时间浪费——因为在参数还没选对的时候跑评测,得到的只是”这一组参数不行”,而不是”这条路不行”。

在进入最后一节之前,给三道自测题。能不看前文答出来,说明机制是真进脑子了,而不是记住了几个结论:

第一题:把 8-bit 量化改成 4-bit,码字载荷降到二分之一(相对 16-bit 才是四分之一),注意力质量会掉多少? 答案是不能只看位宽——显存线性降,误差按第三节是 Δ2\Delta^2 关系,而 Δ\Delta 又由组内动态范围决定。如果轴选错了,4-bit 就可能比”轴选对的 2-bit”更差。

第二题:两个方案都报「平均 3-bit」,A 是全体 3-bit,B 是一半 2-bit 一半 4-bit,哪个质量更好? 没有普适答案,取决于误差是否集中被压的那一半。如果 B 把 2-bit 只给了不敏感层(按层敏感度分配),它可能明显更好;如果它把 2-bit 给了离群最重的键通道,它可能更差。“平均”这个词把最关键的信息藏起来了。

第三题:把键的量化从「RoPE 之后」挪到「RoPE 之前」,比特数不变,为什么质量会变好? 因为旋转会随位置改动通道分布,把”通道级离群、跨 token 稳定”这个前提破坏掉;提前量化等于在分布还稳定的时候动手。代价是每次注意力都要多一步反量化加旋转。

十、五个常见误判

这一节把前面埋着的反直觉点集中收一下,每条都标出它对应哪一节,方便回查论据。

误判一:「4-bit 就够用,2-bit 不现实。」(对应第六节)更准确的说法是:4-bit 的分辨率较宽,足以掩盖一些设计缺陷;2-bit 才会把”轴选错""RoPE 后量化”这类问题暴露出来。所以”4-bit 就够”在一个还没解决轴问题的实现里其实是危险的好消息——它让你以为问题解决了。反过来,2-bit 也不是”必须上”的目标,它只在你的预算确实需要那一档时才有意义。

误判二:「量化只影响精度,不影响速度。」(对应第八节)反量化要花算力,净收益取决于带宽侧与算力侧的比较。在预填充这种算力受限的阶段,把数据反量化回 16 位再算完全可能更慢。

误判三:「困惑度没掉就说明安全。」(对应第九节)困惑度是平均量,第九节那个例子里,1% 的 token 崩塌与全部 token 均匀小幅恶化会给出同一个数字。量化主要伤的是排名,而排名在摘要任务里可以被平均掉,在精确检索与多跳推理上就是灾难。

误判四:「注意力本来就稀疏,远处的 KV 直接扔掉无所谓。」(对应第七节)MiKV 的观察已经把这条打掉一半:淘汰不可逆,被丢掉的上下文会以安全边界突破、幻觉、上下文丢失的形式回来;把要淘汰的用极低精度留着,能挽回大部分退化。比特是旋钮,淘汰是开关。

误判五:「校准是一次性工程,做完就不用管了」,等价地,「平均比特数相同就是同一个方案」。(对应第八、九节)校准出的 scale、敏感度系数、离群名单,都是某个模型在某个负载分布下的快照。换模型版本、换主要语言、甚至换提示模板,都可能让它们悄悄失效——失效的表现不是报错,而是悄悄地退化。可行的做法是把校准产物当配置做版本管理,并配两条监控:截断率(被裁到量化上下界的元素比例)与 top-k 重合率的周期性抽查;前者涨说明范围不够,后者跌说明分辨率不够。而”平均 3-bit”这类说法本身不构成方案等价:位数分布、误差贡献分布、访存模式三者都可能完全不同。

十一、小结:五件值得带走的事

一、在无截断、残差近似均匀等假设下,期望误差约为 Δ2/12\Delta^2/12。所以”该用几比特”不是一个独立问题,“怎么分组”才是——组内混进一个离群值,等于把整组的分辨率按离群倍数除以一遍。

二、Key 的误差进入 softmax 的指数,经 ∣ε∣≤∥q∥Δmax⁡/2|\varepsilon|\le\|q\|\Delta_{\max}/2 与 TV≤∥ε∥∞\mathrm{TV}\le\|\varepsilon\|_\infty 传导成”排名改变”;Value 的误差只是加权求和里的一点噪声。两者病理不同,处理方式不该一样。

三、在”键存在稳定通道级离群、值更适合逐 token 分组”的分布下,Key 按通道、Value 按 token 是更优的选择。 本文自实现里,同样 2-bit 的合成数据上,键缓存按通道比按 token 的相对误差低 2.24 倍,值缓存按 token 比按通道低 2.05 倍;而把整条向量塞进一组,把整条向量塞进一组时 top-5 重合率只有 0.35(2-bit),而按通道是 0.60。这是本合成设置的对比结果,不是所有模型的普遍规律——Value 也可能出现通道级离群,轴要按实测定。

四、低于 4-bit 靠的是一组补丁的叠加:通道轴、RoPE 前量化、按层学习非均匀码点、逐向量离群分离。其中”RoPE 前量化”最容易被漏掉,因为它破坏的是第三节那个前提(通道分布跨 token 稳定),不看旋转的公式想不到。

五、淘汰与降精度不是同一个旋钮的两档。淘汰是不可逆的二元决策,降精度是连续的分辨率损失;MiKV 的观察是”把要淘汰的留下极低精度”能挽回大部分退化。但混合精度要付访存与 kernel 的代价,纸面比特数不等于真实吞吐。同时要记住:量化本身也是有损的,它的失效模式可以是渐变,也可以是某几步突然读错——“连续”不保证”平滑”。

如果只能记一句:KV 量化不是在”存得多准”上做取舍,而是在”把精度花在哪个轴上”做取舍。

如果只能在自己的系统上先做一件事,我推荐用第二节那个五分钟检查:量一维标准差的离散程度。它成本极低、不需要改代码、不需要跑评测,却能先把”通道轴值不值得做”这个最贵的问题回答掉。它只是筛查线索,不直接判定最优轴,也不判定 2-bit 是否可用——那两步仍要在候选分组上实测误差与排名稳定性,最后用分能力评测兜底。

写这篇的动机很朴素:KV 量化的公开讨论常常停在「几比特」,而真正决定成败的是分组轴与误差传播路径——这两件事一旦讲清,「用几比特」就从一个要抄别人结论的问题,变成一个能自己算的问题。

这套推理还可迁移:「轴 → 步长 → 下游指标」这条链对权重量化、激活量化同样成立,只是每一环的具体形状不同。看到任何一篇量化论文,都可以用这三个问题去问它:分组轴选在哪个维度、组内动态范围有没有被离群值撑大、误差最后落到哪个下游指标上被验证。三个问题都答得清楚的方案,通常能在自己的系统上复现;答不清的,多半只在论文的设定里成立。

📋 来源与核验记录

以下每条 URL 均为本篇写作当日(2026-11-13,北京时间)实际打开并逐段核读的 arXiv 摘要页,链接指向的是论文原始页面,不是二手解读。

一、KIVI:A Tuning-Free Asymmetric 2bit Quantization for KV Cache,arXiv:2402.02750,原文 https://arxiv.org/abs/2402.02750 (v1 2024-02-05 / v2 2024-07-25)。核验内容:键缓存应按通道量化、值缓存应按 token 量化的分布结论;免校准 2-bit 方案;含模型权重的峰值显存约 1/2.6;最多 4 倍 batch;真实负载 2.35×~3.47× 吞吐。本篇第 5、6 节引用,全部标注口径。

二、KVQuant:Towards 10 Million Context Length LLM Inference with KV Cache Quantization,arXiv:2401.18079,原文 https://arxiv.org/abs/2401.18079 (v1 2024-01-31 / v6 2025-05-28)。核验内容:四个机制(通道级键量化、RoPE 前量化、按层敏感度的非均匀数据类型、逐向量稠密 + 稀疏分离);3-bit 下 Wikitext-2 与 C4 困惑度退化小于 0.1;单张 A100-80GB 上 LLaMA-7B 百万上下文、8 卡千万上下文;自研 kernel 约 1.7× 于 fp16 矩阵向量乘。本篇第 6 节引用。

三、Atom:Low-bit Quantization for Efficient and Accurate LLM Serving,arXiv:2310.19102,原文 https://arxiv.org/abs/2310.19102 (v1 2023-10-29 / v3 2024-04-16)。核验内容:4-bit 权重与激活量化 + 混合精度细粒度方案;同等延迟目标下相对 FP16 最高 7.7×、相对 INT8 2.5× 端到端吞吐。本篇第 6、8 节引用,明确标注该文的量化对象不是 KV 缓存。

四、FP8 Formats for Deep Learning,arXiv:2209.05433,原文 https://arxiv.org/abs/2209.05433 (v1 2022-09-12 / v2 2022-09-29)。核验内容:E4M3 与 E5M2 两种编码的尾数/指数位分配;E4M3 不表示无穷、只保留单一 NaN 位型以扩展动态范围;最高 175B 参数模型的训练质量与 16 位相当;对扛不住定点 int8 的模型做了训练后量化。本篇第 6、9 节引用,其中”相对分辨率约 2−(m+1)2^{-(m+1)}“是本文按尾数位数的自行推算,非论文原句;按尾数位数推算:E4M3 相邻表示值的相对间隔约 12.5%、最近舍入误差上界约 6.25%,E5M2 分别约 25% 与 12.5%(本文自算,与 Δ/√12 属不同指标,不可直接比较)。

五、No Token Left Behind: Reliable KV Cache Compression via Importance-Aware Mixed Precision Quantization(MiKV),arXiv:2402.18096(本文采用 v1,提交日 2024-02-28),原文 https://arxiv.org/abs/2402.18096 。核验内容:淘汰 KV 对生成过程的风险(安全边界、幻觉、上下文丢失);“用低精度保留被淘汰的 KV 可大幅挽回退化”;重要 KV 需维持较高精度。本篇第 7 节引用,属文献观察转述,未复现其实验。

本文自行推导 / 自实现部分(与上述论文数字分列,不可混引):

其一,第 5 节的表 3 全部数字来自本文自写的一段纯 Python 模拟(2026-11-13 运行,固定随机种子 20261113;dh=64d_h=64、n=128n=128、组大小 32、4 个合成查询;键缓存构造为每 16 维有一个标准差放大 13 倍的高斯通道,值缓存构造为每 24 个 token 有一个整行放大 11 倍的 token;量化器为非对称均匀量化,评价量为相对 Frobenius 重建误差、softmax 分布与原始分布的 TV 距离、top-5 键集合重合率)。这是合成分布上的隔离变量实验,不是模型实测,不能外推为模型的精度损失预测。

其二,第 8 节的表 5 是按 bytes/token=2⋅L⋅Hkv⋅dh⋅b/8\mathrm{bytes/token}=2\cdot L\cdot H_{kv}\cdot d_h\cdot b/8 直接代入 L=32L=32、Hkv=32H_{kv}=32、dh=128d_h=128 得到的算术结果,与任何具体模型无关;100 万 token 的合计值按 1 GiB =230=2^{30} 字节换算。

其三,第 4 节的误差上界 ∣ε∣≤∥q∥2Δmax⁡/2|\varepsilon|\le\|q\|_2\Delta_{\max}/2 与 TV≤∥ε∥∞\mathrm{TV}\le\|\varepsilon\|_\infty、第 4 节的 ∥Δp∥1≤2∥ε∥∞\|\Delta p\|_1\le2\|\varepsilon\|_\infty、第 8 节的净收益不等式,均为本文基于柯西–施瓦茨不等式与 softmax 雅可比的自写推导,不是论文原式;推导过程已在正文给出,读者可逐步复核。

本篇自算的示例数字(表中数字与正文中按公式手算的示例,均属本文自算,仅作机制说明):第 9 节困惑度例子里「1% 的 token 恶化 10 nat、其余 99% 不变 → PPL 涨 10.5%」为本文自算(e0.1≈1.105e^{0.1}\approx1.105);第 6 节「E4M3 相邻间隔约 12.5%、舍入误差上界约 6.25%,E5M2 分别约 25% 与 12.5%」为按尾数位数推算(与 Δ/√12 属不同指标,不可直接比较);第 6 节离群分离开销「约 19%」为按 32 字节/向量与 6 字节附加量算得。

本篇未做的事(明确声明):未运行任何真实模型的推理或评测,未复现 KIVI / KVQuant / Atom / MiKV 的任何实验,未做端到端吞吐或显存实测,未做 kernel 级性能剖析。所有”论文口径”数字都保留在论文自身的设定内,跨论文不做直接比较。