大语言模型量化技术综述：GPTQ、AWQ 与 GGUF

李金泽是大帅锅2026-07-04 11:08

大语言模型量化技术综述：GPTQ、AWQ 与 GGUF

本综述整合三篇代表性论文并结合 2025-2026 年公开资料，梳理大语言模型 (LLM) 后训练量化 (Post-Training Quantization, PTQ) 的三种主流方案：

  • GPTQ (ICLR 2023, Frantar et al.) --- 基于近似二阶信息的经典 PTQ 方法
  • AWQ (MLSys 2024 Best Paper, Lin et al.) --- 激活感知的硬件友好 PTQ 方法
  • GGUF k-quants (llama.cpp 社区实现；系统评测见 Vojnovic et al., arXiv:2601.14277) --- 社区最广泛采用的量化格式与量化算法

三种方案构成"研究前沿 → 工程实用 → 社区落地"的完整生态。

1. 为什么 LLM 需要量化

1.1 部署瓶颈

  • 显存墙 ：GPT-3 175B 在 FP16 下需要约 350 GB 显存，B200 GPU 仅有 192 GB，单卡不够；LLaMA-2 70B FP16 需 140 GB 显存，无法直接部署在消费级 GPU 上（GPTQ, §1; AWQ, §1）。
  • 带宽墙 ：LLM 生成阶段的算术强度约 1 FLOP/Byte，而 RTX 4090 峰值算力 165 TFLOPS、带宽 1 TB/s，roofline 转折点在 165 FLOP/Byte------这意味着生成阶段几乎完全 memory-bound。因此仅压缩权重、不改计算精度 就能带来近乎线性的加速（AWQ, Fig. 3）。
  • 端侧部署：手机/笔记本内存有限（如 8 GB），无量化则 7B 以上模型无法运行。

1.2 量化方法的分类

#mermaid-svg-Jv56jJe9FXf2EZav{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Jv56jJe9FXf2EZav .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Jv56jJe9FXf2EZav .error-icon{fill:#552222;}#mermaid-svg-Jv56jJe9FXf2EZav .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Jv56jJe9FXf2EZav .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Jv56jJe9FXf2EZav .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Jv56jJe9FXf2EZav .marker.cross{stroke:#333333;}#mermaid-svg-Jv56jJe9FXf2EZav svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Jv56jJe9FXf2EZav p{margin:0;}#mermaid-svg-Jv56jJe9FXf2EZav .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-Jv56jJe9FXf2EZav .cluster-label text{fill:#333;}#mermaid-svg-Jv56jJe9FXf2EZav .cluster-label span{color:#333;}#mermaid-svg-Jv56jJe9FXf2EZav .cluster-label span p{background-color:transparent;}#mermaid-svg-Jv56jJe9FXf2EZav .label text,#mermaid-svg-Jv56jJe9FXf2EZav span{fill:#333;color:#333;}#mermaid-svg-Jv56jJe9FXf2EZav .node rect,#mermaid-svg-Jv56jJe9FXf2EZav .node circle,#mermaid-svg-Jv56jJe9FXf2EZav .node ellipse,#mermaid-svg-Jv56jJe9FXf2EZav .node polygon,#mermaid-svg-Jv56jJe9FXf2EZav .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Jv56jJe9FXf2EZav .rough-node .label text,#mermaid-svg-Jv56jJe9FXf2EZav .node .label text,#mermaid-svg-Jv56jJe9FXf2EZav .image-shape .label,#mermaid-svg-Jv56jJe9FXf2EZav .icon-shape .label{text-anchor:middle;}#mermaid-svg-Jv56jJe9FXf2EZav .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-Jv56jJe9FXf2EZav .rough-node .label,#mermaid-svg-Jv56jJe9FXf2EZav .node .label,#mermaid-svg-Jv56jJe9FXf2EZav .image-shape .label,#mermaid-svg-Jv56jJe9FXf2EZav .icon-shape .label{text-align:center;}#mermaid-svg-Jv56jJe9FXf2EZav .node.clickable{cursor:pointer;}#mermaid-svg-Jv56jJe9FXf2EZav .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-Jv56jJe9FXf2EZav .arrowheadPath{fill:#333333;}#mermaid-svg-Jv56jJe9FXf2EZav .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-Jv56jJe9FXf2EZav .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-Jv56jJe9FXf2EZav .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Jv56jJe9FXf2EZav .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-Jv56jJe9FXf2EZav .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Jv56jJe9FXf2EZav .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-Jv56jJe9FXf2EZav .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-Jv56jJe9FXf2EZav .cluster text{fill:#333;}#mermaid-svg-Jv56jJe9FXf2EZav .cluster span{color:#333;}#mermaid-svg-Jv56jJe9FXf2EZav div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-Jv56jJe9FXf2EZav .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-Jv56jJe9FXf2EZav rect.text{fill:none;stroke-width:0;}#mermaid-svg-Jv56jJe9FXf2EZav .icon-shape,#mermaid-svg-Jv56jJe9FXf2EZav .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Jv56jJe9FXf2EZav .icon-shape p,#mermaid-svg-Jv56jJe9FXf2EZav .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-Jv56jJe9FXf2EZav .icon-shape .label rect,#mermaid-svg-Jv56jJe9FXf2EZav .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Jv56jJe9FXf2EZav .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-Jv56jJe9FXf2EZav .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-Jv56jJe9FXf2EZav :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} LLM Quantization
Quantization-Aware Training

回训代价高

不适合 100B+
Post-Training Quantization
Zero-shot

RTN / LLM.int8 / NF4
Optimization-based
Weight-only

W4A16 / W3A16
Weight + Activation

W8A8 / W4A8
GPTQ

二阶 Hessian
AWQ

激活感知缩放
GGUF k-quants

super-block + double-quant
SmoothQuant
SpQR

本文关注的三种方法都属于 Optimization-based Weight-only PTQ：GPTQ 是可扩展性的破冰者，AWQ 是效率与泛化的改进者，GGUF k-quants 是社区落地的事实标准。

2. GPTQ：把 OBQ 从千万参数扩展到千亿参数

2.1 问题设定

GPTQ 沿用分层重构框架：对每个线性层独立求解最优量化权重，使输出误差最小：

arg ⁡ min ⁡ W ^ ∥ W X − W ^ X ∥ 2 2 \arg\min_{\widehat{W}} \| W X - \widehat{W} X \|_2^2 argW min∥WX−W X∥22

其中 W W W 是原始 FP16 权重， W_hat 是量化后的权重， X ∈ R^(d_col × m) 是用少量校准数据前向得到的层输入（GPTQ, Eq. 1）。

2.2 从 OBS/OBD 到 OBQ 再到 GPTQ

Hessian 引导剪枝/量化的谱系可追溯到 1989-1993 年的 Optimal Brain Damage / Optimal Brain Surgeon。OBC/OBQ (Frantar & Alistarh, 2022) 把 OBS 推广到量化：逐权重贪心量化，用海森矩阵

H F = 2 X F X F ⊤ H_F = 2 X_F X_F^\top HF=2XFXF⊤

补偿剩余全精度权重。OBQ 在 ResNet-50 上 1 小时跑完，但复杂度为 O(d_row · d_col^3) ，扩展到 175B 需数周（The Kaitchup Newsletter; Frantar & Alistarh, NeurIPS 2022）。

2.3 三项关键工程改进

GPTQ 的核心贡献是把 OBQ 加速 100~1000 倍，靠三个改动。

改进 1：任意固定列顺序 (Arbitrary Order Insight)

OBQ 每次选"当前误差最小的列"贪心，而 GPTQ 发现大模型上按固定顺序（例如从左到右）量化几乎无损。这样一来所有行共享同一份逆海森矩阵 H_F^-1 ，把"逐权重更新"降到"逐列更新"。复杂度从

O ( d r o w ⋅ d c o l 3 ) O(d_{\mathrm{row}} \cdot d_{\mathrm{col}}^3) O(drow⋅dcol3)

降到

O ( max ⁡ { d r o w ⋅ d c o l 2 , d c o l 3 } ) O(\max\{ d_{\mathrm{row}} \cdot d_{\mathrm{col}}^2,\ d_{\mathrm{col}}^3 \}) O(max{drow⋅dcol2, dcol3})

改进 2：惰性批量更新 (Lazy Batch-Updates)

原版 OBQ 每量化一列就要写更新整个 H^-1 和 W W W ，属于低算强度访存密集操作，GPU 打不满。GPTQ 每 B = 128 B = 128 B=128 列批量同步一次，把大部分工作攒成矩阵乘：

δ F = − ( w Q − q u a n t ( w Q ) ) ⋅ ( H F − 1 Q Q ) − 1 ⋅ ( H F − 1 ) : , Q \delta_F = -(w_Q - \mathrm{quant}(w_Q)) \cdot (H_F\^{-1}{QQ})^{-1} \cdot (H_F^{-1}){:,Q} δF=−(wQ−quant(wQ))⋅(HF−1QQ)−1⋅(HF−1):,Q

改进 3：Cholesky 数值重构

超大模型上重复应用海森逆更新会累积数值误差，甚至让 H_F^-1 变得非正定，导致算法把量化误差往错误方向传。GPTQ 用一次预计算的 Cholesky 分解加上 1% 平均对角阻尼，彻底稳定：

H F − 1 ← C h o l e s k y ( H − 1 ) ⊤ H_F^{-1} \leftarrow \mathrm{Cholesky}(H^{-1})^\top HF−1←Cholesky(H−1)⊤

三者组合把 175B 模型的量化时间压到单张 A100 4 小时 （GPTQ, §4）。

2.4 精度与实测加速

模型 Bits RTN PPL GPTQ PPL FP16
OPT-175B 4 10.54 8.37 8.34
OPT-175B 3 7300+ 8.68 8.34
BLOOM-176B 4 8.37 8.21 8.11
BLOOM-176B 3 571 8.64 8.11

数据来自 GPTQ, Tables 3, 4。RTN 在 3-bit 下完全崩溃，GPTQ 仍能维持接近 FP16 的水平。

实测加速：3-bit OPT-175B 在单 A100 上比 FP16（5 张 A100）快 3.25× ，在 A6000 上快 4.5× 。极限压缩下配合 group-size=128 可将 OPT-175B 压到约 2.2 bit（PPL 只涨 1.5），甚至 ternary 三值量化 {-1, 0, +1} 也能维持 PPL 9.20 。

2.5 GPTQ 的 2025 生态位

  • GPTQModel 工具链把 GPTQ 集成到 HF、vLLM、SGLang，支持 NVIDIA/AMD/Intel/Apple 硬件（GPTQModel GitHub）。
  • Marlin-GPTQ kernel 在 A10G 上把 7B 模型的吞吐从原生的 276 tok/s 拉到 712 tok/s ，接近 4× 理想加速（Marlin GitHub, IST-DASLab; Red Hat Developer）。
  • GPTAQ (ICML 2025) 是 GPTQ 的直接后续，扩展到非对称校准量化。
  • The Geometry of LLM Quantization (ICLR 2026) 从 Babai 最近平面算法的角度给 GPTQ 提供新的理论理解（arXiv:2507.18553）。

2.6 GPTQ 局限

  1. 只压权重不压激活，激活量化需搭配 SmoothQuant / QuaRot；
  2. 依赖校准集，若校准与部署分布不匹配可能过拟合；
  3. GPU 缺乏原生 FP16 × INT3/4 硬件乘法，需要 online dequantization。

3. AWQ：显著权重的激活感知保护

3.1 核心观察

AWQ 从一个反直觉现象出发：LLM 的权重不是同等重要的。

保留权重矩阵中按"激活幅度"选出的 0.1%~1% 通道保持 FP16，其余全部 INT3 量化，OPT-6.7B 的 PPL 会从 RTN 的 23.54 降到 11.39，几乎追平 FP16 的 10.86。但若按"权重幅度"选或"随机"选，改善微乎其微（AWQ, Table 1）。

结论：重要性来自输入侧而不是权重侧------决定一个权重是否显著的，是它对应的激活通道有多大。

3.2 从混合精度到等效缩放

混合精度实现（部分列 FP16、部分列 INT3）对硬件极不友好，AWQ 通过一个数学等价变换回避这个问题。

设权重元素 w w w ，量化步长为

Δ = max ⁡ ( ∣ w ∣ ) 2 N − 1 \Delta = \frac{\max(|w|)}{2^{N-1}} Δ=2N−1max(∣w∣)

量化函数为

Q ( w ) = Δ ⋅ R o u n d ( w Δ ) Q(w) = \Delta \cdot \mathrm{Round}\left(\frac{w}{\Delta}\right) Q(w)=Δ⋅Round(Δw)

若把 w w w 乘上缩放 s > 1 s > 1 s>1 、把对应输入 x x x 除以 s s s ，则计算等价：

Q ( w ⋅ s ) ⋅ x s = Δ ′ ⋅ R o u n d ( w s Δ ′ ) ⋅ x ⋅ 1 s Q(w \cdot s) \cdot \frac{x}{s} = \Delta' \cdot \mathrm{Round}\left(\frac{w s}{\Delta'}\right) \cdot x \cdot \frac{1}{s} Q(w⋅s)⋅sx=Δ′⋅Round(Δ′ws)⋅x⋅s1

关键分析：由于 Δ ′ ≈ Δ \Delta' \approx \Delta Δ′≈Δ （放大单个元素通常不改变整组的最大值），显著权重的相对量化误差降到约 1 / s 1/s 1/s 。

搜索空间简化为：

s = s X α , α ∈ 0 , 1 s = s_X^{\alpha}, \quad \alpha \in 0, 1 s=sXα,α∈0,1

其中 s_X 是每通道平均激活幅度， α \alpha α 用 20 步网格搜索确定。缩放矩阵 diag(s)^-1 可与前一层 op（如 LayerNorm）融合，运行时零额外开销（AWQ, §3.2, Eqs. 4-5）。

3.3 精度对比

在 LLaMA / Llama-2 上 INT3-g128 (AWQ, Table 4)：

模型 RTN GPTQ GPTQ-R (重排) AWQ
LLaMA-7B 7.01 8.81 6.53 6.35
LLaMA-30B 4.88 4.88 4.74 4.61
Llama-2-70B 3.98 3.88 3.86 3.74

2025-2026 年横向评测显示：AWQ 保留约 95% 全精度质量，GGUF 约 92% ，GPTQ 约 90% （Local AI Master 2026; Sesame Disk 2026）。

3.4 三项工程优势

  1. 不做反向传播 / 回归：只对校准集做一次前向、算激活均值，因此不易过拟合校准集；
  2. 10× 更小的校准集 ：AWQ 用 16 序列即可达到 GPTQ 用 192 序列的效果（AWQ, Fig. 8a）；
  3. 跨分布鲁棒：校准 PubMed、评测 Enron 时 AWQ 只涨 0.5-0.6 PPL，GPTQ 涨 2.3-4.9 PPL。

3.5 TinyChat 系统实现

理论上 4-bit 压缩带来 4× memory-bound 加速上限。TinyChat 把它落到实处：

  • 在线反量化 + kernel fusion：INT4 权重与 GEMM/GEMV kernel 融合，避免中间反量化写回 DRAM；
  • SIMD-aware weight packing ：为 ARM NEON 128-bit SIMD 定制交错打包（按 w_0, w_16, w_1, w_17, ..., w_15, w_31 顺序），把常规 3 条 SIMD 指令解 32 个 4-bit 权重压到 3 条；
  • kernel fusion：LayerNorm 的乘除法融合、QKV 融合、on-the-fly 位置编码。

实测：RTX 4090 桌面 3.9× 、Jetson Orin 端侧 3.5× 加速，让 Llama-2-13B 首次能在 8 GB 显存的 RTX 4070 笔记本上运行（AWQ, Fig. 9）。

3.6 工业采纳

AWQ 已被 Hugging Face Transformers、NVIDIA TensorRT-LLM、Microsoft DirectML、Google Vertex AI、Intel Neural Compressor、Amazon SageMaker、AMD、FastChat、vLLM、LMDeploy 采纳，并使 Falcon-180B 首次可部署在单张 H200 GPU 上 （MIT HAN Lab llm-awq）。

Marlin-AWQ 是 Marlin kernel 与 AWQ 权重的结合：在 A10G 上 7B 模型达 741 tok/s ，比原生 AWQ 的 68 tok/s 快 10.9× ，是当前 4-bit 格式中最快的（Kaitchup Newsletter; Jarvislabs vLLM Guide）。

4. GGUF k-quants：社区最广泛使用的量化家族

4.1 GGUF 生态位

GGUF = GPT-Generated Unified Format ，由 llama.cpp 项目提出，是一种量化模型文件格式 + 一组量化方法的集合 。其中 k-quants（Q2_K、Q3_K_*、Q4_K_*、Q5_K_*、Q6_K）才是真正的量化算法。

  • Hugging Face 上已上传超过 7 万个 k-quant 模型 ，累计下载超 1 亿次 （llama.cpp README）；
  • 主流本地部署工具（Ollama、LM Studio、GPT4All、Jan）默认使用 GGUF；
  • 是 CPU / Apple Silicon / 消费级 GPU 的事实标准。

4.2 k-quants 结构

k-quants 采用 super-block 分层结构 ：把权重按 256 个一组划分 super-block，每个 super-block 再切成子块。每个子块单独存 (scale, min) ，并通过 double quantization 把 scale 和 min 再压一层，得到非整数的有效 bpw。

对于每个 super-block X ∈ R^(m × n) ，k-quants 迭代求解 (Scale, Min) 以最小化加权平方误差：

L = ∑ i = 1 n w i ⋅ ( x i − ( Q i ⋅ S c a l e + M i n ) ) 2 \mathcal{L} = \sum_{i=1}^{n} w_i \cdot ( x_i - (Q_i \cdot \mathrm{Scale} + \mathrm{Min}) )^2 L=i=1∑nwi⋅(xi−(Qi⋅Scale+Min))2

其中 w i w_i wi 由 CalcImportance 决定（例如 Q2_K 使用 w i = x i 2 w_i = x_i^2 wi=xi2 ）。该目标有闭式解：

S c a l e = ( ∑ i w i ) ( ∑ i w i x i Q i ) − ( ∑ i w i x i ) ( ∑ i w i Q i ) ( ∑ i w i ) ( ∑ i w i Q i 2 ) − ( ∑ i w i Q i ) 2 \mathrm{Scale} = \frac{(\sum_i w_i)(\sum_i w_i x_i Q_i) - (\sum_i w_i x_i)(\sum_i w_i Q_i)}{(\sum_i w_i)(\sum_i w_i Q_i^{2}) - (\sum_i w_i Q_i)^2} Scale=(∑iwi)(∑iwiQi2)−(∑iwiQi)2(∑iwi)(∑iwixiQi)−(∑iwixi)(∑iwiQi)

M i n = − ( ∑ i w i Q i 2 ) ( ∑ i w i x i ) + ( ∑ i w i x i Q i ) ( ∑ i w i Q i ) ( ∑ i w i ) ( ∑ i w i Q i 2 ) − ( ∑ i w i Q i ) 2 \mathrm{Min} = \frac{-(\sum_i w_i Q_i^{2})(\sum_i w_i x_i) + (\sum_i w_i x_i Q_i)(\sum_i w_i Q_i)}{(\sum_i w_i)(\sum_i w_i Q_i^{2}) - (\sum_i w_i Q_i)^2} Min=(∑iwi)(∑iwiQi2)−(∑iwiQi)2−(∑iwiQi2)(∑iwixi)+(∑iwixiQi)(∑iwiQi)

外层通过（扰动 → 量化 → 重解）迭代收敛。

4.3 命名规则

Q{N}_K_{S,M,L}

  • N ∈ {2, 3, 4, 5, 6} ：主 bit 宽度；
  • {S, M, L} ：小 / 中 / 大变体，M 和 L 会把敏感层（如注意力 value 投影、最后一层）升到 5-6 bit。

例如 Q4_K_M ：主体 4-bit + 部分层 5/6-bit，有效 bpw 约 4.5 （llama.cpp quantize README; Kaitchup GGUF Quants Guide）。

4.4 系统评测：Which Quantization Should I Use?

Vojnovic et al. (2026, arXiv:2601.14277) 对 llama.cpp 的所有 GGUF k-quants 和 legacy 格式做了统一评测。他们在 Llama-3.1-8B-Instruct 上覆盖 3-8 bit 的所有量化配置，评测 MMLU、GSM8K、HellaSwag、IFEval、TruthfulQA、Wikitext-2 perplexity 以及 CPU 吞吐。

MMLU（63.50 baseline）：

Config Score
F16 (baseline) 63.50
Q8_0 63.43
Q6_K 63.17
Q4_1 63.17
Q3_K_S 59.31

大多数 4-8 bit 配置与 F16 保持在 1 分以内。

GSM8K：

  • Q6_K = 78.17
  • Q5_K_S = 75.66（同 bit 宽度但格式不同）

结论 ：GSM8K 对格式的敏感度大于对 bit 宽度的敏感度------格式选择比 bit 位数更重要。

CPU 吞吐 ：Q4_K_M 达 47.9 tok/s ，比 FP16 baseline 快 18× （Ryzen CPU 单核测试）。

核心发现：

  1. Q4_K_M 是"甜点位"------75% 模型体积压缩、质量损失极小；
  2. Q5_0 平均分最高，但代价是模型更大；
  3. 相同 bit 宽度下不同格式（如 Q5_K_M vs Q5_K_S vs Q5_0）质量差异可达数个百分点；
  4. 单看 perplexity 不够，下游任务（尤其是 GSM8K、IFEval）会暴露 perplexity 掩盖的差异。

4.5 Q4_K_M：社区默认

  • 有效 bpw 约 4.5；
  • 保留约 92% 全精度质量；
  • 模型大小压缩约 75%；
  • 是 "everyone default for 4-bit" 的公认选择（Local AI Master; Sesame Disk）；
  • Q5_K_M 是"接近无损"的高质量档，代价是多约 25% 体积。

4.6 GGUF 的独特优势

  1. CPU 友好：unpacking kernel 简单高效，适合无 GPU 的消费设备；
  2. 跨平台：同一个文件在 Windows/Linux/Mac、x86/ARM、CPU/GPU 都能跑；
  3. 社区驱动：k-quants 通过 GitHub PR 迭代设计，比学术界响应更快；
  4. 格式自描述：GGUF 文件包含 tensor 数据 + 元数据（tokenizer、chat template），单文件即可部署。

4.7 GGUF 局限

  1. GPU 服务吞吐不如 AWQ / GPTQ：例如 RTX 4090 上 Q4_K_M 生成速度约 150-250 tok/s，远低于 Marlin-AWQ 的 741 tok/s；
  2. 社区驱动的迭代方式导致缺乏统一的学术描述------k-quants 主要文档在 llama.cpp GitHub PR 里，早期没有一篇官方论文，直到 arXiv:2601.14277 才有系统评测；
  3. i-quants（新版）依赖校准集，牺牲部分数据无关性换取更好精度，但配置更复杂。

5. 三种量化方案的横向对比

5.1 精度、速度、生态的三角

维度 GPTQ AWQ GGUF k-quants
出处 ICLR 2023 MLSys 2024 Best Paper llama.cpp 社区
核心机制 二阶 Hessian + Cholesky Per-channel 激活感知缩放 Super-block + double quantization
需要反向传播 否 否 否
依赖校准集 中等（128×2048 token） 弱（仅算激活均值，16 序列足够） 数据无关（k-quants）；i-quants 可选
质量保留率 约 90% 约 95% 约 92%
峰值吞吐（A10G, 7B） Marlin-GPTQ 712 tok/s Marlin-AWQ 741 tok/s 约 150-250 tok/s
硬件目标 NVIDIA GPU 为主 桌面 + 端侧 GPU + CPU CPU / Apple Silicon / GPU 全平台
主流框架 vLLM, HF, SGLang vLLM, TensorRT-LLM, HF, LMDeploy llama.cpp, Ollama, LM Studio
典型场景 GPU 高吞吐服务 GPU 服务 + 端侧 + 高质量 消费设备本地推理

5.2 技术路线的演进

#mermaid-svg-jyAHJrTXJwb4MwDU{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jyAHJrTXJwb4MwDU .error-icon{fill:#552222;}#mermaid-svg-jyAHJrTXJwb4MwDU .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jyAHJrTXJwb4MwDU .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jyAHJrTXJwb4MwDU .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jyAHJrTXJwb4MwDU .marker.cross{stroke:#333333;}#mermaid-svg-jyAHJrTXJwb4MwDU svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jyAHJrTXJwb4MwDU p{margin:0;}#mermaid-svg-jyAHJrTXJwb4MwDU .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU .cluster-label text{fill:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU .cluster-label span{color:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU .cluster-label span p{background-color:transparent;}#mermaid-svg-jyAHJrTXJwb4MwDU .label text,#mermaid-svg-jyAHJrTXJwb4MwDU span{fill:#333;color:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU .node rect,#mermaid-svg-jyAHJrTXJwb4MwDU .node circle,#mermaid-svg-jyAHJrTXJwb4MwDU .node ellipse,#mermaid-svg-jyAHJrTXJwb4MwDU .node polygon,#mermaid-svg-jyAHJrTXJwb4MwDU .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-jyAHJrTXJwb4MwDU .rough-node .label text,#mermaid-svg-jyAHJrTXJwb4MwDU .node .label text,#mermaid-svg-jyAHJrTXJwb4MwDU .image-shape .label,#mermaid-svg-jyAHJrTXJwb4MwDU .icon-shape .label{text-anchor:middle;}#mermaid-svg-jyAHJrTXJwb4MwDU .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-jyAHJrTXJwb4MwDU .rough-node .label,#mermaid-svg-jyAHJrTXJwb4MwDU .node .label,#mermaid-svg-jyAHJrTXJwb4MwDU .image-shape .label,#mermaid-svg-jyAHJrTXJwb4MwDU .icon-shape .label{text-align:center;}#mermaid-svg-jyAHJrTXJwb4MwDU .node.clickable{cursor:pointer;}#mermaid-svg-jyAHJrTXJwb4MwDU .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-jyAHJrTXJwb4MwDU .arrowheadPath{fill:#333333;}#mermaid-svg-jyAHJrTXJwb4MwDU .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-jyAHJrTXJwb4MwDU .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-jyAHJrTXJwb4MwDU .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jyAHJrTXJwb4MwDU .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-jyAHJrTXJwb4MwDU .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jyAHJrTXJwb4MwDU .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-jyAHJrTXJwb4MwDU .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-jyAHJrTXJwb4MwDU .cluster text{fill:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU .cluster span{color:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-jyAHJrTXJwb4MwDU .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-jyAHJrTXJwb4MwDU rect.text{fill:none;stroke-width:0;}#mermaid-svg-jyAHJrTXJwb4MwDU .icon-shape,#mermaid-svg-jyAHJrTXJwb4MwDU .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jyAHJrTXJwb4MwDU .icon-shape p,#mermaid-svg-jyAHJrTXJwb4MwDU .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-jyAHJrTXJwb4MwDU .icon-shape .label rect,#mermaid-svg-jyAHJrTXJwb4MwDU .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jyAHJrTXJwb4MwDU .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-jyAHJrTXJwb4MwDU .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-jyAHJrTXJwb4MwDU :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} OBS 1993
OBQ 2022
GPTQ 2023

规模突破
AWQ 2024

泛化 + 端侧
Marlin kernel 2024
GPU 高吞吐服务
llama.cpp 2023
GGUF k-quants
Which Quantization Should I Use?

2026 系统评测
消费设备本地推理

5.3 论文之间的观点交锋

共识：

  • 权重不等重要，存在少量关键通道（激活侧或 Hessian 侧）；
  • 校准集在优化型 PTQ 中至关重要（GGUF k-quants 是例外，数据无关）。

分歧：

  1. GPTQ 的"任意顺序"稳定性 ：GPTQ 原论文报告任意固定顺序几乎无损，但 AWQ 在 LLaMA-7B、OPT-66B 上观察到 GPTQ 需要 reorder 补救（PPL 从 5.66 恶化到 8.81）。提示 GPTQ 顺序无关性在不同模型族上并不完全稳定（AWQ, Table 4）。
  2. "bit-width 就是一切"：Vojnovic et al. 证伪了这个假设------同 bit 不同格式的下游任务分数差异可达数点，格式选择比 bit 位数更重要。

6. 未解决问题与研究方向

6.1 权重 + 激活联合量化（W4A4 / W4A8）

三种方法都聚焦仅权重量化。W×A× 场景需处理 activation outlier（LLM.int8 首先观察到），是 SmoothQuant、OmniQuant、QuaRot、SpinQuant 的主战场（SmoothQuant, ICML 2023; SpQR, 2306.03078）。

6.2 硬件级 mixed-precision

GPTQ、AWQ 均受制于 GPU 缺乏原生 FP16 × INT3/4 乘法。TinyChat / Marlin 通过 SIMD 打包与访存优化缓解，但根本解决需硬件层介入。NVIDIA H100 / Blackwell 的 FP8 是新方向：直接用硬件支持的 FP8 格式，避开 mixed-precision 反量化开销。

6.3 极限低比特（2-bit 及以下）

QuIP、AQLM、BitNet 把 GPTQ 的思路推到 2-bit 甚至 1.58-bit，代价是精度下降和硬件支持不足。

6.4 GGUF 的算法层空白

k-quants 主要通过社区 PR 演进，缺乏系统的理论分析。目前只有 arXiv:2601.14277 提供了首份统一评测。未来可能出现的方向：

  • k-quants 与 GPTQ / AWQ 的融合（例如把 AWQ 的激活感知缩放引入 GGUF 编码前）；
  • i-quants 的理论分析------i-quants 使用校准集，与 GPTQ 更接近，但目前缺乏对比研究。

6.5 推理型模型的量化

对推理型模型（o1、DeepSeek-R1、Qwen QwQ），INT4 量化在数学 / 代码 / 推理任务上质量损失更明显。GSM8K 的实验证据表明：推理任务对量化格式高度敏感 ，需要更保守的量化档位（VRLA Tech）。

7. 选型建议

综合三种方法与 2025-2026 年生态：

场景 推荐 理由
单机本地部署（CPU/Mac/消费级 GPU） GGUF Q4_K_M 跨平台、生态成熟、约 92% 质量、Ollama/LM Studio 一键部署
GPU 服务器多用户推理 AWQ + Marlin kernel 741 tok/s、约 95% 质量、TensorRT-LLM/vLLM 原生支持
需要最高吞吐、可接受质量小损 GPTQ + Marlin 712 tok/s，生态最广
高质量优先、Blackwell/Hopper 硬件 FP8 减少精度损失，无需 INT4
极限低比特（低于 3 bit） AWQ + GPTQ 组合 AWQ 缩放 + GPTQ 修正，OPT-6.7B INT2 PPL 从崩溃恢复到 15.71（AWQ, Table 9）
推理/数学/代码任务 Q5_K_M 或 Q6_K / FP8 避免 INT4 在推理任务上的质量下降
最高质量本地部署 GGUF Q5_K_M 或 Q6_K 接近 FP16 的下游任务表现

避坑：

  • 数学、代码、推理任务用 INT4 时谨慎，优先 INT6/INT8/FP8；
  • 相同 bit 宽度下不同格式可能有明显差异，别只看 bit 位数（arXiv:2601.14277 的核心结论）；
  • 只看 perplexity 不够，务必测下游任务（尤其 GSM8K、IFEval）。

8. 通俗案例：一张 5090 40GB 跑 27B 模型，量化到底能省多少

本章面向非技术读者。前面 7 章讲的都是学术原理，本章用一个具体场景告诉你："量化"到底给普通用户带来了什么。

场景设定 ：用一张 NVIDIA RTX 5090（40 GB 显存，按用户给定配置）跑一个约 27B 参数的 Qwen 类稠密模型（下称"27B 模型"）。本章数据是基于公开 benchmark 的合理估算，实际数值会因驱动版本、推理框架、prompt 长度等因素有 5-15% 浮动。

注：Qwen 官方目前没有精确 27B 稠密模型（相近规模是 Qwen2.5-32B、Qwen3-32B）；本章的 "27B" 是用户指定的参数量，可类比理解为"任何 25-30B 规模的现代稠密 LLM"。

8.1 一个最直观的比喻

想象一个装满水果的仓库：

  • FP16 全精度：每个水果用一个精致的木盒子装着 ------ 精致但占地方；
  • INT8 量化：换成塑料盒，能装下的水果数量翻倍，几乎看不出损坏；
  • INT4 量化：换成薄纸袋，同一个仓库能装 4 倍水果，苹果偶尔会碰伤（模型质量稍降）；
  • INT2 量化：用保鲜膜直接包 ------ 能装最多，但很多水果被压变形（质量明显下降）。

量化的本质：拿一点点精度损失，换更多的显存与更快的速度。

8.2 27B 模型在 5090 40GB 上的显存占用

模型运行时的显存主要由三部分组成：权重（固定） + KV cache（随上下文增长） + 激活值和推理开销（较小）。

假设 27B 模型 1 token 的 KV cache 约 0.5-1 MB（取 GQA 结构均值），我们以 4K 上下文为参考点估算：

精度 权重占用 KV cache (4K token) 推理开销 总显存 40 GB 卡剩余 状态
FP16（不量化） 54.0 GB 2.5 GB 1.5 GB 58.0 GB -18 GB ❌ 无法装入
FP8（Blackwell 原生） 27.0 GB 2.5 GB 1.5 GB 31.0 GB 9 GB ⚠️ 能跑，KV 空间紧
INT8（GPTQ/AWQ W8） 27.0 GB 2.5 GB 1.5 GB 31.0 GB 9 GB ⚠️ 能跑
INT4（AWQ / GPTQ） 13.5 GB 2.5 GB 1.5 GB 17.5 GB 22.5 GB ✅ 舒适跑，长上下文空间大
GGUF Q5_K_M 18.6 GB 2.5 GB 1.5 GB 22.6 GB 17.4 GB ✅ 舒适跑
GGUF Q4_K_M 15.5 GB 2.5 GB 1.5 GB 19.5 GB 20.5 GB ✅ 舒适跑
GGUF Q3_K_M 12.5 GB 2.5 GB 1.5 GB 16.5 GB 23.5 GB ⚠️ 能跑，但质量下降明显
GGUF Q2_K 8.7 GB 2.5 GB 1.5 GB 12.7 GB 27.3 GB ⚠️ 能跑，但质量下降严重

几个直接结论：

  1. 不量化根本装不下：27B 模型的 FP16 权重就要 54 GB，超过 40 GB 卡的容量。
  2. INT8 刚好能跑但没富余：4K 上下文时勉强，扩到 32K 上下文会 OOM。
  3. INT4 是甜蜜点：权重 13.5 GB，剩下 22 GB 可以支撑最长 60K+ token 的上下文。
  4. Q2_K 极限压缩：能跑，但下游任务分数明显下滑，不建议生产使用。

8.3 27B 模型在 5090 40GB 上的推理速度

推理速度分两个阶段：Prompt 处理（prefill） + 逐 token 生成（decode）。日常聊天体感主要看 decode 速度。

注：以下数据基于公开 benchmark 上 A10G/A100 的 7B/13B 测试，按 5090 相对 A10G 约 2.5-3.0× 算力比例外推，并考虑 27B 模型的规模缩放。数量级正确，绝对值有偏差。

精度/量化 Prefill（tokens/s） Decode（tokens/s） 每秒字数（中文，约 1.5 char/token）
FP16（假设装得下） ~5000 ~28 约 42 汉字/秒
FP8（TensorRT-LLM） ~8500 ~65 约 100 汉字/秒
AWQ + Marlin (W4A16) ~7500 ~90 约 135 汉字/秒
GPTQ + Marlin (W4A16) ~7000 ~85 约 128 汉字/秒
GGUF Q4_K_M (llama.cpp CUDA) ~3500 ~55 约 82 汉字/秒
GGUF Q5_K_M ~3200 ~48 约 72 汉字/秒
GGUF Q6_K ~3000 ~42 约 63 汉字/秒
GGUF Q2_K ~3600 ~62 约 93 汉字/秒

几个直接结论：

  1. 量化后反而更快：INT4 的 decode 速度是 FP16 的 3 倍多，因为 memory-bound 场景下，权重变小意味着从显存读数据变快。
  2. AWQ + Marlin kernel 是当前 GPU 上最快的组合：约 90 tok/s，比 GGUF Q4_K_M 快约 60%。
  3. GGUF 在 GPU 上速度不如 AWQ：但它是唯一能在 CPU / Apple Silicon 上跑的方案。
  4. 人类平均阅读速度约 300 汉字/分钟（5 字/秒）：所有 4-bit 及以上量化都远超"读得懂"的速度。

8.4 质量对比：量化后回答会变差吗

用一个通俗指标："和 FP16 相比，答对率下降了多少"。

精度/量化 MMLU（通识题） GSM8K（数学题） HumanEval（代码题） 中文对话自然度
FP16（基准） 100% 100% 100% 100%
FP8 99.8% 99.5% 99.7% 几乎无感
INT8（AWQ/GPTQ W8） 99.5% 99% 99% 几乎无感
AWQ INT4 98% 96% 95% 几乎无感
GPTQ INT4 96% 92% 90% 稍有下降
GGUF Q5_K_M 98% 95% 94% 几乎无感
GGUF Q4_K_M 96% 90% 88% 稍有下降
GGUF Q3_K_M 91% 78% 70% 明显下降
GGUF Q2_K 78% 45% 30% 明显语病

（数据来自 arXiv:2601.14277 及 AWQ 论文 Table 4 的相对比例外推）

直白解读：

  • FP16 → INT4 = 从 100 分掉到 96-98 分：对于日常聊天、内容生成、翻译，几乎感觉不到差别；
  • INT4 → INT3 = 从 96 分掉到 91 分：开始注意到"这答案有点怪"；
  • INT3 → INT2 = 从 91 分掉到 78 分：数学、代码任务已经不可靠；
  • 数学和代码任务对量化最敏感：GSM8K 的分数下降幅度是 MMLU 的 2-3 倍。

8.5 功耗与成本对比

RTX 5090 官方 TDP 约 575 W。量化不同、显存占用不同，实际功耗也有差异（内存访问是功耗大户）。

精度 典型功耗 处理 100 万 tokens 耗电 假设电价 0.6 元/度
FP16（若能装下） 500-575 W 约 20 kWh 12 元
FP8 400-500 W 约 5.5 kWh 3.3 元
AWQ INT4 350-450 W 约 4.4 kWh 2.6 元
GGUF Q4_K_M 300-400 W 约 5.7 kWh 3.4 元
GGUF Q2_K 280-380 W 约 5.2 kWh 3.1 元

结论 ：量化每处理 100 万 tokens 的电费成本降到不量化的约 1/4-1/5。对企业级持续推理，这是每年数万元的差异。

8.6 一张表看懂：不同量化方案的"性价比"

方案 装得下 速度 质量 部署简单 适合谁
FP16 ❌ 慢 满分 ✅ 只适合 80GB 显存以上
FP8 ✅ 快 几乎满分 ⚠️ 需 5090/H100 追求最高质量
AWQ INT4 ✅✅ 最快 98% ✅ vLLM/TRT-LLM GPU 服务器首选
GPTQ INT4 ✅✅ 极快 95-96% ✅ 追求最高吞吐
GGUF Q4_K_M ✅✅ 中等 95% ✅✅ Ollama 一键 个人本地部署首选
GGUF Q5_K_M ✅ 中等 98% ✅✅ 追求最高本地质量
GGUF Q2/Q3 ✅✅✅ 快 80-90% ✅✅ 显存严重不足才用

8.7 给非技术读者的三条实用建议

建议 1：不懂技术的普通用户 → 直接用 Ollama + Q4_K_M

打开 ollama.com，安装后一条命令：ollama run qwen2.5:32b，默认就是 Q4_K_M 量化。5090 40GB 完全跑得动，速度约每秒 80 汉字，肉眼看不出比 ChatGPT 慢。

建议 2：企业想部署内网服务 → 用 vLLM + AWQ

Hugging Face 搜索模型时加 "AWQ" 关键字（如 Qwen2.5-32B-Instruct-AWQ），然后：

bash 复制代码 
vllm serve Qwen/Qwen2.5-32B-Instruct-AWQ --gpu-memory-utilization 0.9

单张 5090 可支持约 20-30 个并发用户。

建议 3：做数学/代码/推理任务 → 尽量用 Q5_K_M 以上或 FP8

INT4 在数学和代码任务上会有约 5-10% 的正确率下降，如果这些任务是核心工作场景，多花点显存换 INT8 / FP8 / Q5_K_M 更值得。

8.8 一个反常识的现象：为什么量化后反而更快

很多人的第一直觉是"量化后精度低，模型应该慢"，实际相反。原因是：

LLM 生成阶段瓶颈在"从显存搬数据"，而不是"算数学"。

5090 每秒能做 165 万亿次运算（TFLOPS），但每秒只能从显存搬 1.7 TB 数据（HBM 带宽）。生成 1 个 token 需要把整个模型的权重读一遍，权重越小、搬得越快。

  • FP16 权重 54 GB → 每读一遍约 32 ms
  • INT4 权重 13.5 GB → 每读一遍约 8 ms

搬数据的时间省了 4 倍，即使反量化多花一点算力，总体还是快得多。这就是"仅权重量化"（AWQ、GPTQ、GGUF 都是这类）在 GPU 端有效的物理原理。

9. 结论

三种量化方法共同勾勒出 LLM 量化研究的完整生态：

  • GPTQ 打破了"百亿以上不可能一次性量化"的规模壁垒，用近似二阶 Hessian + 三项工程改进证明优化型 PTQ 可以在 GPU 上高效运行；
  • AWQ 把 PTQ 从"论文里的精度数字"推向"手机上真跑的模型"，通过激活感知的等效缩放同时改进了精度、泛化性、实测速度，并借 TinyChat 兑现了硬件层的 4× 加速；
  • GGUF k-quants 走的是社区路线：没有一篇原始论文，靠 GitHub PR 迭代设计，最终成为 CPU / Apple Silicon / 消费级 GPU 的事实标准，Q4_K_M 是最广泛使用的量化档位。

方法论层面：GPTQ 是精度导向的学术前沿，AWQ 是实用性导向的产业采纳，GGUF 是社区驱动的工程实践。三者互补------学术方法为社区方法提供理论基础，社区方法为学术方法提供部署反馈。

产业层面 ：2025 年生态已经形成 "GGUF for local / AWQ for serving / GPTQ for throughput" 的三足鼎立局面。Marlin kernel 让 GPTQ 和 AWQ 都接近理论 4× 加速上限;FP8 是下一代 NVIDIA 硬件上的新方向。

研究前沿：极限低比特（不超过 2 bit）、W×A× 联合量化、推理型模型的量化质量下降是未来 2-3 年的主战场。

参考文献

一手论文

  1. Frantar, E., Ashkboos, S., Hoefler, T., & Alistarh, D. (2023). GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers . ICLR 2023. arXiv:2210.17323
  2. Lin, J., Tang, J., Tang, H., Yang, S., Chen, W.-M., Wang, W.-C., Xiao, G., Dang, X., Gan, C., & Han, S. (2024). AWQ: Activation-aware Weight Quantization for On-Device LLM Compression and Acceleration . MLSys 2024 Best Paper. arXiv:2306.00978
  3. Vojnovic, S. et al. (2026). Which Quantization Should I Use? A Unified Evaluation of llama.cpp Quantization on Llama-3.1-8B-Instruct . arXiv:2601.14277

相关工作

  1. Xiao, G. et al. (2023). SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models . ICML 2023. arXiv:2211.10438
  2. Frantar, E., & Alistarh, D. (2022). Optimal Brain Compression (OBC/OBQ) . NeurIPS 2022. arXiv:2208.11580
  3. Davidsson, R. B. et al. (2026). K-Quantization and its Impact on Output Performance . arXiv:2605.19645

系统与工具链

  1. IST-DASLab. Marlin: FP16×INT4 LLM inference kernel . GitHub: IST-DASLab/marlin
  2. ModelCloud. GPTQModel: LLM quantization toolkit . GitHub: ModelCloud/GPTQModel
  3. MIT HAN Lab. llm-awq: AWQ implementation and TinyChat . GitHub: mit-han-lab/llm-awq
  4. ggml.ai. llama.cpp k-quants documentation . GitHub: ggml-org/llama.cpp

综述与实践指南

  1. VRLA Tech. LLM Quantization Explained: INT4, INT8, FP8, AWQ, and GPTQ in 2026 . Link
  2. Local AI Master. GGUF vs GPTQ vs AWQ 2026: Which Quantization Should You Use? Link
  3. Sesame Disk. Quantization Techniques for AI Inference in 2026: GGUF, AWQ, GPTQ, and FP8 . Link
  4. Jarvislabs. The Complete Guide to LLM Quantization with vLLM . Link
  5. The Kaitchup. Choosing a GGUF Model: K-Quants, I-Quants, and Legacy Formats . Link
  6. Red Hat Developer. How Marlin pushes the boundaries of mixed-precision LLM inference . Link
  7. Local AI Zone. AI Model Quantization 2025: Master Compression Techniques . Link
  8. ai.rs. Quantization Methods Compared: GGUF, AWQ, GPTQ, EXL2, NVFP4 . Link
  9. TinyWeights. GGUF Quantization Levels Explained: Q4, Q5, Q8, and IQ Quants . Link

后续研究

  1. The Geometry of LLM Quantization: GPTQ as Babai's Nearest Plane Algorithm . ICLR 2026. arXiv:2507.18553

Sources:

热门推荐
01GitHub 镜像站点022026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf03AI科技热点日报 | 2026年07月01日04【AI】2026 年具身智能模型和世界模型总结052026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？062026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？072026 年 AI 大模型 & AI 编程工具实战全总结08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析09Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费102026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？