【推理与部署篇05】模型量化部署深度对比：GPTQ、AWQ、GGUF与FP8实战指南

2026年最新版 | 量化技术从入门到选型，覆盖 7 种主流方案，含完整代码与实测数据

📑 目录

1. 为什么需要量化？

一个 70B 参数模型以 FP16 精度运行需要 140GB+ 显存，这意味着至少需要 2×H100（80GB）或 4×A100（40GB）才能推理。量化技术将权重从 FP16 降到 INT4，显存需求直接降至 35GB——一块 H100 即可运行。

量化的本质是"用精度换效率"：

FP32 (32-bit) → FP16 (16-bit) → INT8 (8-bit) → INT4 (4-bit)

精度 ↓  显存占用 ↓  推理速度 ↑  吞吐量 ↑
                  ↓
关键在于"下降多少精度，换来多少效率"

2026年，量化的精度损失已经控制到极小：

精度 显存节省 速度提升 精度损失 (MMLU)
FP16 基准 基准 基准
INT8 ~50% 1.5-2× <0.5%
INT4 ~75% 2-3× 1-3%
FP8 ~50% 2× <1%
NVFP4 ~75% 3× 2-4%

2. 量化基础概念速览

2.1 量化类型

类型 描述 压缩比 精度损失 适用场景
PTQ（训练后量化） 模型训练完成后直接量化 2-4× 低 生产部署首选
QAT（量化感知训练） 训练过程中模拟量化误差 2-4× 极低 对精度要求极致
动态量化 运行时动态量化激活值 1.5× 中 边缘设备

2.2 量化粒度

Per-tensor:   整个层共享一个缩放因子  → 简单但精度低
Per-channel:  每个输出通道一个缩放因子 → 精度高
Per-group:    每 N 个权重一组        → 平衡精度和效率（最常用，group_size=128/64）
Per-token:    每个 token 动态量化    → 适合激活值量化

2.3 对称量化 vs 非对称量化

对称量化: scale = max(|w|) / 127     → INT8 对称
          范围 [-127, 127]

非对称量化: scale = (max - min) / 255 → INT8 非对称
            zero_point = round(-min / scale)
           范围 [0, 255]
           多一个 zero_point 参数，但能更好利用量化范围

3. GPTQ：基于梯度的精准量化

3.1 核心原理

GPTQ（Generative Pre-trained Transformer Quantization）由 Frantar 等人提出（ICLR 2023），核心思想来自最优脑外科（OBS）算法——逐个权重地量化，每量化一个权重后，调整剩余权重补偿误差 [1]。

GPTQ 逐层量化流程：

对于每一层权重 W：
  1. 计算 Hessian 矩阵 H = 2XX^T （基于校准数据）
  2. 初始化量化后的权重 Q = W
  3. 对 Q 中每个列（按重要性排序）：
     a. 量化该列：q = round(w / scale) * scale
     b. 计算量化误差：err = w - q
     c. 根据 Hessian 将误差分摊到剩余未量化列
     d. 更新剩余列：remaining -= err / H_diag * H_row
  4. 输出量化后的权重 Q

关键创新：利用 Hessian 矩阵的"误差补偿"，
使单次量化误差被后续未量化权重"吸收"

GPTQ 的独有优势：不需要反向传播（不同于 QAT），只需要一次前向传播获取校准数据的激活值，速度远快于 QAT。

3.2 实战代码

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
import torch

# 1. 配置量化参数
quantize_config = BaseQuantizeConfig(
    bits=4,                # 4-bit 量化
    group_size=128,        # 分组大小，越小精度越高但速度越慢
    desc_act=False,        # 是否按激活值排序（True精度更高但慢）
    damp_percent=0.01,     # 阻尼系数，防止 Hessian 奇异
    static_groups=False,   # 静态分组
)

# 2. 加载并量化
model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantize_config,
    device_map="auto",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 3. 准备校准数据（关键！直接影响量化质量）
calibration_texts = [
    "深度学习是机器学习的一个分支，它使用多层神经网络。",
    "自然语言处理是人工智能的重要方向，涵盖文本分类、机器翻译等任务。",
    "人工智能正在改变世界，从自动驾驶到医疗诊断都有广泛应用。",
    # 建议使用 100-500 条与业务相关的短文本
]

# 4. 执行量化
model.quantize(calibration_texts, batch_size=1)

# 5. 保存
model.save_quantized("./qwen2.5-7b-gptq")
tokenizer.save_pretrained("./qwen2.5-7b-gptq")

3.3 GPTQ 在 vLLM 中部署

from vllm import LLM, SamplingParams

llm = LLM(
    model="./qwen2.5-7b-gptq",
    quantization="gptq",
    dtype="float16",
    gpu_memory_utilization=0.9
)

sampling_params = SamplingParams(temperature=0.7, max_tokens=512)
outputs = llm.generate(["人工智能是什么？"], sampling_params)
print(outputs[0].outputs[0].text)

3.4 优缺点

优点 缺点
压缩率高，4-bit 可达 4× 压缩 需要校准数据
推理速度快（GPU 上仅次于 AWQ） 量化过程较慢（大模型需数小时）
社区生态成熟，HuggingFace 上已有大量预量化模型 对异常值敏感
vLLM、TGI 均原生支持 desc_act=True 时推理变慢

4. AWQ：激活感知权重量化

4.1 核心原理

AWQ（Activation-aware Weight Quantization）由 MIT 提出（MLSys 2024），核心洞察是：并非所有权重都同等重要——那些与大幅激活值相乘的权重对模型输出的影响更大 [2]。

AWQ 关键洞察：

权重 W 与激活 X 相乘：Y = WX

如果某个通道的激活值 X 特别大，
那么这个通道的权重 W 的重要性就更高。

AWQ 的做法：
1. 收集校准数据下的激活值分布
2. 对每个通道计算"重要性分数" = mean(|activation|)
3. 对重要通道的权重乘以保护因子 s（略小于1）
4. 对次要通道除以 s（略大于1）
5. 然后再量化

数学表达：
W_quantized = round(W * s / scale) * scale / s

其中 s = 1 + α * (重要度 - 1)，α 是保护强度
重要通道：s ≈ 0.95（保护精度）
次要通道：s ≈ 1.05（容忍损失）

GPTQ vs AWQ 的本质区别：

GPTQ 是"事后补救"：量化后调整剩余权重补偿误差
AWQ 是"事前预防"：量化前缩放权重，减少重要通道的量化损失

4.2 实战代码

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

# 1. 加载模型
model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoAWQForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    safetensors=True
)
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

# 2. 配置量化参数
quant_config = {
    "zero_point": True,           # 使用零点量化（非对称）
    "q_group_size": 128,          # 分组大小
    "w_bit": 4,                   # 量化位数
    "version": "GEMM",            # GEMM（通用矩阵乘）或 GEMV（向量乘）
    "calib_dataset": "wikitext",  # 校准数据集
    "calib_samples": 128,         # 校准样本数
}

# 3. 执行量化（AWQ 量化速度比 GPTQ 快约 50%）
model.quantize(tokenizer, quant_config=quant_config)

# 4. 保存
model.save_quantized("./qwen2.5-7b-awq")
tokenizer.save_pretrained("./qwn2.5-7b-awq")

4.3 AWQ 在 vLLM 中部署

# AWQ 直接在 vLLM 中原生加载
from vllm import LLM, SamplingParams

llm = LLM(
    model="./qwen2.5-7b-awq",
    quantization="awq",       # 仅需指定 quantization="awq"
    dtype="auto",             # vLLM 自动选择最佳 dtype
    gpu_memory_utilization=0.9
)

4.4 GPTQ vs AWQ 详细对比

维度 GPTQ AWQ
技术路线 梯度下降 + Hessian 补偿 激活感知缩放保护
量化速度 较慢（大模型数小时） 较快（快 50%）
推理精度 良好 更优（通常高 0.5-1%）
推理速度 快 更快（+5-15%）
社区模型 丰富（TheBloke 大量预量化） 快速增长
vLLM 支持 原生支持 原生支持
TGI 支持 原生支持 原生支持

5. GGUF：llama.cpp 的万能格式

5.1 GGUF 是什么？

GGUF（GPT-Generated Unified Format）是 llama.cpp 项目开发的专用模型格式，统一了模型权重 + 分词器 + 超参数在单一文件中 [3]。

GGUF 文件结构：

┌──────────────────────────────────────┐
│  GGUF Header                         │
│  - 魔数: 0x46554747 ("GGUF")          │
│  - 版本号: v3                         │
│  - 张量数量、元数据大小                │
├──────────────────────────────────────┤
│  元数据 KV                           │
│  - 模型架构（llama/gptneox/mistral）  │
│  - 分词器类型及词表                    │
│  - 超参数（n_layer, n_head 等）       │
│  - RoPE 配置、激活函数                │
├──────────────────────────────────────┤
│  张量数据（权重）                     │
│  - 按量化类型编码                     │
│  - Q4_0 / Q4_K_M / Q5_0 / Q8_0 等    │
└──────────────────────────────────────┘

5.2 GGUF 量化类型

GGUF 提供了丰富的量化类型，K-quant 是最具特色的创新：

类型 位数 描述 推荐场景
Q2_K 2-bit 2-bit K-quant，极限压缩 实验性
Q3_K_M 3-bit 3-bit 中等 低资源
Q4_0 4-bit 4-bit 基础版，最快 CPU 快速推理
Q4_K_M 4-bit 4-bit K-quant 推荐版 平衡首选
Q5_K_M 5-bit 5-bit 高质量 精度敏感
Q6_K 6-bit 6-bit 接近无损 高质量需求
Q8_0 8-bit 8-bit 几乎无损 完美保真

K-quant 的核心原理：不同层使用不同位数，注意力层用更多位数（更敏感），FFN 层用更少位数。

5.3 实战：转换与量化

# 1. 克隆 llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# 2. 编译
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j

# 3. 将 HuggingFace 模型转为 GGUF FP16
python ../convert_hf_to_gguf.py \
    ./qwen2.5-7b-instruct \
    --outfile qwen2.5-7b-f16.gguf \
    --outtype f16

# 4. 量化到 Q4_K_M
./bin/quantize \
    qwen2.5-7b-f16.gguf \
    qwen2.5-7b-q4_k_m.gguf \
    q4_k_m

# 5. 推理
./bin/main \
    -m qwen2.5-7b-q4_k_m.gguf \
    -p "人工智能是" \
    -n 256 \
    --temp 0.7 \
    --threads 8

# 6. 启动 API 服务
./bin/server \
    -m qwen2.5-7b-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -c 8192

5.4 GGUF 最佳实践

# 用 Ollama 加载 GGUF - 最简单的方式
# 1. 创建 Modelfile
cat > Modelfile << EOF
FROM ./qwen2.5-7b-q4_k_m.gguf
PARAMETER temperature 0.7
PARAMETER top_p 0.9
TEMPLATE """{{ .Prompt }}"""
EOF

# 2. 创建模型
ollama create qwen2.5-7b -f Modelfile

# 3. 运行
ollama run qwen2.5-7b

# 4. API 调用
curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5-7b", "prompt": "人工智能是什么？"}'

5.5 GGUF 最佳场景

  • CPU 推理：GGUF 是 CPU 推理的唯一最优选择
  • Mac 用户：llama.cpp 对 Apple Silicon 深度优化（Metal 加速）
  • 消费级 GPU：6GB - 12GB 显存的显卡（RTX 3060/4060）
  • 边缘设备：树莓派、NAS 等低功耗设备

6. BitsAndBytes：加载即量化

6.1 核心特性

BitsAndBytes 由 Tim Dettmers 开发，提供了一个独特的思路——不需要单独的量化工具，一行代码即可在加载模型时完成量化 [4]。它的 NF4（Normal Float 4）量化格式是 QLoRA 微调的基础。

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

# 4-bit NF4 量化配置（QLoRA 使用的格式）
bnb_config_4bit = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,   # 嵌套量化：对缩放因子再次量化
    bnb_4bit_quant_type="nf4",        # NF4 (Normal Float 4) 或 fp4
    bnb_4bit_compute_dtype=torch.float16,  # 计算精度
    bnb_4bit_quant_storage_dtype=torch.uint8  # 存储格式
)

# 8-bit 量化配置
bnb_config_8bit = BitsAndBytesConfig(
    load_in_8bit=True,
    bnb_8bit_compute_dtype=torch.float16,
    llm_int8_threshold=6.0,            # 异常值阈值
    llm_int8_has_fp16_weight=False,
    llm_int8_skip_modules=["output_layer"]  # 跳过某些模块
)

# 一行代码加载 70B 模型到单卡
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-72B-Instruct",
    quantization_config=bnb_config_4bit,
    device_map="auto",
    trust_remote_code=True
)

6.2 NF4 格式原理

NF4 是 BitsAndBytes 独创的 4-bit 数据格式，比普通 INT4 更适合神经网络权重的分布：

NF4 (Normal Float 4) - 正态分布优化 4-bit 格式

神经网络的权重分布 ≈ N(0, σ²)  正态分布

普通 INT4: 均匀量化，[-8, 7] 等间距
           问题：大量权重集中在 0 附近，但 INT4 给 0 附近的精度不够

NF4：非均匀量化，根据正态分布 CDF 设计
      在 0 附近更密集（更多量化级别）
      在远离 0 处更稀疏
      约 68% 的权重在 ±1σ 内，NF4 对这些权重分配了 8/16 的级别

NF4 的精度明显优于普通 INT4，这是 QLoRA 能同时实现 4× 压缩且保持良好效果的关键原因。

6.3 QLoRA 微调 + BitsAndBytes

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# 准备模型用于训练
model = prepare_model_for_kbit_training(model)

# LoRA 配置
lora_config = LoraConfig(
    r=16,                        # LoRA 秩
    lora_alpha=32,               # 缩放参数
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # 目标模块
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)

# 训练时：只有 LoRA 参数更新，原始权重保持 NF4 量化状态
# 显存：70B 模型仅需 ~40GB 显存即可微调

6.4 BnB 的优缺点

优点 缺点
一行代码即可量化，无需复杂工具 推理速度不如 GPTQ/AWQ
支持微调（QLoRA） 生产部署不如 vLLM 成熟
NF4 格式精度优于普通 INT4 需要 PyTorch + Transformers 环境
支持 70B+ 模型单卡加载 不适合超低延迟场景

7. FP8/NVFP4：NVIDIA 原生精度

7.1 FP8：Hopper 架构的原生格式

FP8 是 Hopper 架构（H100/H200）的原生计算格式，无需反量化即可在 FP8 Tensor Core 上直接计算。

FP8 有两种格式：

E4M3: 4 bit 指数 + 3 bit 尾数
      动态范围: ±448
      精度: 较高
      适用: 权重 + 激活值量化（对称分布）

E5M2: 5 bit 指数 + 2 bit 尾数
      动态范围: ±57344
      精度: 较低
      适用: 梯度量化（动态范围大）

TensorRT-LLM 使用 FP8 量化的典型方案：
权重: FP8 (E4M3) per-tensor
激活: FP16
KV Cache: FP8 (E4M3)

TensorRT-LLM 中的 FP8 量化完整流程：

# Step 1: ModelOpt 提供 FP8 校准
python convert_checkpoint.py \
    --model_dir ./Meta-Llama-4-70B \
    --output_dir ./trt_llama4_fp8 \
    --dtype float16 \
    --use_weight_only \
    --weight_only_precision fp8 \
    --calib_size 512

# Step 2: 构建 FP8 引擎
trtllm-build \
    --checkpoint_dir ./trt_llama4_fp8 \
    --output_dir ./engine_fp8 \
    --gemm_plugin fp8 \
    --gpt_attention_plugin float16 \
    --context_fmha enable

# Step 3: 推理
python -m tensorrt_llm.commands.serve \
    --engine_dir ./engine_fp8 \
    --host 0.0.0.0 --port 8000

FP8 性能数据（LLaMA 3.1 70B）：

指标 A100 FP16 H100 FP8 提升
峰值吞吐 2,800 tok/s 10,200 tok/s 3.6×
TTFT 340ms 100ms -71%
显存 140GB 72GB -49%
MMLU 精度 82.1% 82.0% -0.1%

7.2 NVFP4：Blackwell 的 4-bit 突破

NVFP4 是 Blackwell（B100/B200/B300）引入的原生 4-bit 浮点格式。与 INT4 等宽量化不同，NVFP4 是对称的 E2M1 格式，直接用 FP4 Tensor Core 计算，无需反量化 [5]。

NVFP4: [S:1bit][E:2bit][M:1bit]

vs INT4:   [-8, -7, ..., 0, ..., 7]
vs NF4:    正态分布优化的非线性 4-bit
vs NVFP4:  E2M1 浮点格式，值分布更合理

实测效果（DeepSeek-R1 671B on B200）：

FP8 8×B200:  1,200 tok/s, ~900GB 显存
NVFP4 8×B200: 4,800 tok/s, ~480GB 显存  → 4× 提升 🚀

7.3 FP8/NVFP4 适用场景

格式 需要硬件 推荐模型大小 推荐场景
FP8 H100/H200/B200 任何模型 企业级 GPU 集群
NVFP4 B100/B200/B300 70B+ 大模型 Blackwell 原生部署

8. AQLM：极限压缩新方案

8.1 原理概述

AQLM（Additive Quantization for Language Models）是 2025-2026 年兴起的新量化方法，借鉴了信息检索领域的加性量化（Additive Quantization） 技术 [6]。

AQLM 的核心思路：

将权重矩阵 W 分解为多个码本（codebooks）的和：

W ≈ Σᵢ Cᵢ[bᵢ]

其中 Cᵢ 是第 i 个码本（大小为 K×d），
bᵢ 是第 i 个码本的索引向量

2-bit AQLM: 4 个码本 × 每个码本 256 个向量
             总需存储: 4 × log₂(256) = 32 bits / 组

AQLM 在 2-bit 量化的精度上显著优于其他方案，甚至在某些任务上接近 4-bit GPTQ 的水平。

8.2 与主流方案对比

方案 2-bit 3-bit 4-bit
GPTQ 不可用 精度较差 良好
AWQ 不可用 一般 优秀
GGUF Q2_K 可用 可用 可用
AQLM 最佳 最佳 良好

8.3 使用示例

# AQLM 需要特定后端支持
# 目前在 transformers 中可通过以下方式加载
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "ISTA-DASLab/Llama-2-7b-AQLM-2Bit-1x64",
    trust_remote_code=True,
    device_map="auto"
)

9. 全方案性能对比

9.1 显存需求（7B/13B/70B 模型）

方案 7B 13B 70B
FP16 14 GB 26 GB 140 GB
INT8 (BnB) 7.5 GB 13.5 GB 72 GB
GPTQ-4bit 4.5 GB 8.5 GB 40 GB
AWQ-4bit 4.5 GB 8.5 GB 40 GB
GGUF Q4_K_M 4.8 GB 8.9 GB 42 GB
BnB NF4 4.8 GB 8.9 GB 42 GB
FP8 (TRT-LLM) 7.5 GB 13.5 GB 72 GB
NVFP4 (Blackwell) — — 38 GB
AQLM 2-bit 2.8 GB 5.2 GB 26 GB

9.2 推理速度（A100 80G，LLaMA-2-7B）

方案 吞吐 (tok/s) 相对 FP16 适用引擎
FP16 95 1.0× vLLM/SGLang
GPTQ-4bit 110 1.16× vLLM/ExLlama
AWQ-4bit 125 1.32× vLLM/TGI
GGUF Q4_K_M (GPU) 55 0.58× llama.cpp
GGUF Q4_K_M (CPU) 12 0.13× llama.cpp
BnB NF4 70 0.74× Transformers
TRT-LLM FP8 (H100) 210 2.21× TensorRT-LLM

9.3 精度损失（MMLU 分数，LLaMA-2-7B）

方案 MMLU 相对 FP16 损失
FP16 (baseline) 45.3% —
GPTQ-4bit (g128) 44.7% -0.6%
AWQ-4bit (g128) 45.1% -0.2%
GGUF Q4_K_M 44.5% -0.8%
BnB NF4 44.8% -0.5%
TRT-LLM FP8 45.2% -0.1%
AQLM 2-bit 42.1% -3.2%

10. 选型决策指南

10.1 决策树

你的部署场景是什么？
 │
 ├── GPU 云端生产环境
 │   ├── 有 NVIDIA H100/B200 → TensorRT-LLM + FP8/NVFP4 ✅
 │   │   └── 极致性能，最低延迟，精度几乎无损
 │   │
 │   └── 通用 GPU 服务器
 │       ├── 追求精度与速度平衡 → AWQ + vLLM ✅
 │       │   └── AWQ 精度最佳，vLLM 生态成熟
 │       └── 需要大量预量化模型 → GPTQ + vLLM ✅
 │           └── HuggingFace 上 GPTQ 模型最丰富
 │
 ├── 本地/消费级 GPU (8-24GB)
 │   ├── 追求速度 → GGUF Q4_K_M + llama.cpp ✅
 │   ├── 需要微调 → BnB NF4 + QLoRA ✅
 │   └── 离线批处理 → GPTQ/AWQ + vLLM ✅
 │
 ├── CPU / Mac / 边缘设备
 │   └── GGUF Q4_K_M / Q5_K_M + llama.cpp ✅
 │       └── CPU 推理的唯一最优选择
 │
 └── 极限压缩 (<3GB)
     └── AQLM 2-bit ✅
         └── 精度有损失，但显存需求减到最低

10.2 场景速查表

场景 推荐方案 显存 推理引擎
企业级线上服务 FP8 (TRT-LLM) 或 AWQ H100 80GB TensorRT-LLM / vLLM
高吞吐 API 服务 AWQ-4bit 32-80GB vLLM / SGLang
RAG/Agent 应用 AWQ-4bit 或 FP8 32-80GB SGLang (RadixAttention)
个人开发调试 GGUF Q4_K_M 6-12GB Ollama / llama.cpp
微调大模型 BnB NF4 (QLoRA) 24-48GB Transformers + PEFT
边缘设备部署 GGUF Q4_0 2-6GB llama.cpp
极致压缩部署 AQLM 2-bit 3-6GB Transformers
多模态模型 FP8 (TRT-LLM) 80GB TensorRT-LLM

10.3 生产环境代码模板

# =====================================================
# 生产环境量化部署模板
# 根据你的 GPU 和需求选择对应方案
# =====================================================

# 方案 A：AWQ + vLLM（最推荐的通用方案）
# 适合：通用 GPU 服务器，精度速度均衡
from vllm import LLM, SamplingParams
llm = LLM(
    model="Qwen/Qwen2.5-7B-Instruct-AWQ",  # 直接加载预量化模型
    quantization="awq",
    dtype="auto",
    tensor_parallel_size=1,  # 多卡时增大
    gpu_memory_utilization=0.9,
    max_num_seqs=256,
    enable_prefix_caching=True,
)

# 方案 B：GPTQ + vLLM（模型生态最丰富）
llm = LLM(
    model="TheBloke/Llama-2-7B-GPTQ",
    quantization="gptq",
    dtype="float16",
)

# 方案 C：FP8 + TensorRT-LLM（极致性能）
# 需要离线编译 engine，参考第 7 节

📌 面试加分点

1️⃣ 量化三剑客核心区别一句话总结

方案 核心思路 一句话
GPTQ 量化后补偿 “先犯错，再弥补”——用 Hessian 矩阵将误差分摊到剩余权重
AWQ 量化前保护 “先保护，再量化”——根据激活值重要性缩放权重
GGUF 统一格式 + K-quant “一次转换，到处运行”——分层混合精度量化

2️⃣ 为什么 AWQ 比 GPTQ 精度更高？

AWQ 的关键洞察是：权重的重要性不由自身决定，而由与之相乘的激活值决定。GPTQ 对所有权重一视同仁地做误差补偿，AWQ 则优先保护"重要通道"。实测 AWQ 在 MMLU 上比 GPTQ 高 0.4-0.8%。

3️⃣ FP8 vs INT8 的选择

FP8 (E4M3): 动态范围 ±448，精度高 → 适合权重 + 激活量化
INT8: 动态范围 ±127，精度略低 → 需要 per-channel 补偿

FP8 优势：H100/B200 Tensor Core 原生支持，无需反量化
INT8 优势：所有 GPU 都支持（Turing+）

关键：在 H100 上 FP8 比 INT8 快 30-50%

4️⃣ 量化面试高频题

Q: 为什么 4-bit 量化只损失 1-3% 的精度？
A: 因为模型参数存在大量冗余（over-parameterization），
量化只是去除了这部分冗余信息。
实验结果：去掉 50% 小权重对精度影响很小 → 4-bit ≈ 保留 75% 的精度信息。

Q: 量化后的模型还能微调吗？
A: 可以。通过 QLoRA 技术，将原始权重保持 NF4 量化状态，
只在旁路的 LoRA 适配器上做 BF16 训练。
训练完成后，可以将 LoRA 权重合并回量化模型。

Q: 什么情况下不适合量化？
A: 1) 数学/逻辑推理任务（量化会损失数值精度）
   2) 代码生成（偶数位错误影响语法正确性）
   3) 对温度/随机性敏感的应用
   这些场景建议使用 INT8 或 FP8，避免 INT4。

参考来源

  1. GPTQ: Frantar et al. “GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers” — ICLR 2023
  2. AWQ: Lin et al. “AWQ: Activation-aware Weight Quantization for On-Device LLM Compression and Acceleration” — MLSys 2024
  3. llama.cpp / GGUF: ggerganov/llama.cpp — GitHub (2023-2026)
  4. QLoRA / BitsAndBytes: Dettmers et al. “QLoRA: Efficient Finetuning of Quantized LLMs” — NeurIPS 2023
  5. NVFP4: NVIDIA TensorRT-LLM 官方文档 — Blackwell Quantization Guide (2026)
  6. AQLM: Egiazarian et al. “Extreme Compression of Large Language Models via Additive Quantization” — ICML 2024
  7. NVIDIA TensorRT-LLM 部署与低比特量化实战 — CSDN 2026
  8. 大模型量化技术深度对比：GPTQ vs AWQ vs GGUF — CSDN 2026
# chrome # 前端
Logo
加入AMD AI开发者计划！

免费领 150 小时云算力，进群参与显卡、AI PC 幸运抽奖

更多推荐

大模型输出格式约束原理

Prompt 引导 → 后处理验证 → 约束解码 → API 原生结构化输出这个过程中，核心思想从生成后检查转变为生成中约束——从概率保证走向了确定保证。场景推荐方案简单格式要求Prompt 引导 + 后处理验证严格 Schema自部署模型vLLM + XGrammar（推荐）复杂 DSL/文法多平台兼容AI SDK + 适配层不再把模型当作文本生成器，而是把它当作受控的数据生成器。当模型的输出格

avatar AMD开发者中国社区
cover

7.4 工具能力实现体系《AI智能体应用开发》

avatar AMD开发者中国社区
cover

WSL2 GPU 直连与 vLLM 大模型推理

avatar AMD开发者中国社区