gptq

GPTQ（生成式预训练 Transformer 量化）

训练后量化方法，通过分组量化将大模型压缩至 4 bit，同时最大限度减少精度损失。

何时使用 GPTQ

在以下情况下使用 GPTQ：

• 需要在有限的 GPU 内存中运行大型模型（70B 及以上）
• 希望将内存占用降低 4 倍，同时精度损失小于 2%
• 在消费级 GPU（RTX 4090、3090）上部署
• 需要更快的推理速度（相比 FP16 提速 3～4 倍）

在以下情况下改用 AWQ：

• 需要略高的精度（损失小于 1%）
• 使用较新的 GPU（Ampere、Ada）
• 希望支持 Marlin 内核（部分 GPU 上速度提升 2 倍）

在以下情况下改用 bitsandbytes：

• 需要与 transformers 简单集成
• 希望进行 8 bit 量化（压缩率较低，质量较好）
• 不需要预量化的模型文件

快速开始

安装

# Install AutoGPTQ
pip install auto-gptq

# With Triton (Linux only, faster)
pip install auto-gptq[triton]

# With CUDA extensions (faster)
pip install auto-gptq --no-build-isolation

# Full installation
pip install auto-gptq transformers accelerate

加载预量化模型

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM

# Load quantized model from HuggingFace
model_name = "TheBloke/Llama-2-7B-Chat-GPTQ"

model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_triton=False  # Set True on Linux for speed
)

tokenizer = AutoTokenizer.from_pretrained(model_name)

# Generate
prompt = "Explain quantum computing"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda:0")
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0]))

量化自己的模型

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from datasets import load_dataset

# Load model
model_name = "meta-llama/Llama-2-7b-chat-hf"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Quantization config
quantize_config = BaseQuantizeConfig(
    bits=4,              # 4-bit quantization
    group_size=128,      # Group size (recommended: 128)
    desc_act=False,      # Activation order (False for CUDA kernel)
    damp_percent=0.01    # Dampening factor
)

# Load model for quantization
model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantize_config=quantize_config
)

# Prepare calibration data
dataset = load_dataset("c4", split="train", streaming=True)
calibration_data = [
    tokenizer(example["text"])["input_ids"][:512]
    for example in dataset.take(128)
]

# Quantize
model.quantize(calibration_data)

# Save quantized model
model.save_quantized("llama-2-7b-gptq")
tokenizer.save_pretrained("llama-2-7b-gptq")

# Push to HuggingFace
model.push_to_hub("username/llama-2-7b-gptq")

分组量化

GPTQ 的工作原理：

1. 对权重分组：将每个权重矩阵划分为多个组（通常每组包含 128 个元素）
2. 按组量化：每组都有自己的缩放因子/零点
3. 最小化误差：利用 Hessian 信息将量化误差降至最低
4. 结果：获得精度接近 FP16 的 4 bit 权重

组大小的权衡：

组大小	模型大小	精度	速度	建议
-1（按列）	最小	最佳	最慢	仅用于研究
32	较小	较好	较慢	需要高精度时使用
128	中等	良好	快	推荐默认值
256	较大	较低	更快	速度至关重要时使用
1024	最大	最低	最快	不推荐

示例：

Weight matrix: [1024, 4096] = 4.2M elements

Group size = 128:
- Groups: 4.2M / 128 = 32,768 groups
- Each group: own 4-bit scale + zero-point
- Result: Better granularity → better accuracy

量化配置

标准 4 bit（推荐）

from auto_gptq import BaseQuantizeConfig

config = BaseQuantizeConfig(
    bits=4,              # 4-bit quantization
    group_size=128,      # Standard group size
    desc_act=False,      # Faster CUDA kernel
    damp_percent=0.01    # Dampening factor
)

性能：

• 内存：减少 4 倍（70B 模型：140GB → 35GB）
• 精度：困惑度增加约 1.5%
• 速度：比 FP16 快 3～4 倍

高精度（使用更大分组的 3 bit 量化）

config = BaseQuantizeConfig(
    bits=3,              # 3-bit (more compression)
    group_size=128,      # Keep standard group size
    desc_act=True,       # Better accuracy (slower)
    damp_percent=0.01
)

权衡：

• 内存：减少 5 倍
• 精度：困惑度增加约 3%
• 速度：快 5 倍（但精度较低）

最高精度（使用较小分组的 4 bit 量化）

config = BaseQuantizeConfig(
    bits=4,
    group_size=32,       # Smaller groups (better accuracy)
    desc_act=True,       # Activation reordering
    damp_percent=0.005   # Lower dampening
)

权衡：

• 内存：减少 3.5 倍（占用略大）
• 精度：困惑度增加约 0.8%（最佳）
• 速度：快 2～3 倍（内核开销）

内核后端

ExLlamaV2（默认，速度最快）

model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_exllama=True,      # Use ExLlamaV2
    exllama_config={"version": 2}
)

性能：比 Triton 快 1.5～2 倍

Marlin（Ampere 及更新的 GPU）

# Quantize with Marlin format
config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=False  # Required for Marlin
)

model.quantize(calibration_data, use_marlin=True)

# Load with Marlin
model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_marlin=True  # 2× faster on A100/H100
)

要求：

• NVIDIA Ampere 或更新架构（A100、H100、RTX 40xx）
• 计算能力 ≥ 8.0

Triton（仅限 Linux）

model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_triton=True  # Linux only
)

性能：比 CUDA 后端快 1.2～1.5 倍

与 transformers 集成

直接使用 transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

# Load quantized model (transformers auto-detects GPTQ)
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-2-13B-Chat-GPTQ",
    device_map="auto",
    trust_remote_code=False
)

tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-13B-Chat-GPTQ")

# Use like any transformers model
inputs = tokenizer("Hello", return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=100)

QLoRA 微调（GPTQ + LoRA）

from transformers import AutoModelForCausalLM
from peft import prepare_model_for_kbit_training, LoraConfig, get_peft_model

# Load GPTQ model
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-2-7B-GPTQ",
    device_map="auto"
)

# Prepare for LoRA training
model = prepare_model_for_kbit_training(model)

# LoRA config
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# Add LoRA adapters
model = get_peft_model(model, lora_config)

# Fine-tune (memory efficient!)
# 70B model trainable on single A100 80GB

性能基准

内存占用降低

模型	FP16	GPTQ 4 bit	降幅
Llama 2-7B	14 GB	3.5 GB	4 倍
Llama 2-13B	26 GB	6.5 GB	4 倍
Llama 2-70B	140 GB	35 GB	4 倍
Llama 3-405B	810 GB	203 GB	4 倍

可实现：

• 在单张 A100 80GB 上运行 70B（FP16 则需要 2 张 A100）
• 在 3 张 A100 80GB 上运行 405B（FP16 则需要 11 张 A100）
• 在 RTX 4090 24GB 上运行 13B（FP16 则会因显存不足而失败）

推理速度（Llama 2-7B，A100）

精度	Tokens/秒	相比 FP16
FP16	25 tok/s	1 倍
GPTQ 4 bit（CUDA）	85 tok/s	3.4 倍
GPTQ 4 bit（ExLlama）	105 tok/s	4.2 倍
GPTQ 4 bit（Marlin）	120 tok/s	4.8 倍

精度（WikiText-2 上的困惑度）

模型	FP16	GPTQ 4 bit（g=128）	精度下降
Llama 2-7B	5.47	5.55	+1.5%
Llama 2-13B	4.88	4.95	+1.4%
Llama 2-70B	3.32	3.38	+1.8%

质量保留效果出色——精度下降不到 2%！

常见用法

多 GPU 部署

# Automatic device mapping
model = AutoGPTQForCausalLM.from_quantized(
    "TheBloke/Llama-2-70B-GPTQ",
    device_map="auto",  # Automatically split across GPUs
    max_memory={0: "40GB", 1: "40GB"}  # Limit per GPU
)

# Manual device mapping
device_map = {
    "model.embed_tokens": 0,
    "model.layers.0-39": 0,  # First 40 layers on GPU 0
    "model.layers.40-79": 1,  # Last 40 layers on GPU 1
    "model.norm": 1,
    "lm_head": 1
}

model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device_map=device_map
)

CPU 卸载

# Offload some layers to CPU (for very large models)
model = AutoGPTQForCausalLM.from_quantized(
    "TheBloke/Llama-2-405B-GPTQ",
    device_map="auto",
    max_memory={
        0: "80GB",  # GPU 0
        1: "80GB",  # GPU 1
        2: "80GB",  # GPU 2
        "cpu": "200GB"  # Offload overflow to CPU
    }
)

批量推理

# Process multiple prompts efficiently
prompts = [
    "Explain AI",
    "Explain ML",
    "Explain DL"
]

inputs = tokenizer(prompts, return_tensors="pt", padding=True).to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=100,
    pad_token_id=tokenizer.eos_token_id
)

for i, output in enumerate(outputs):
    print(f"Prompt {i}: {tokenizer.decode(output)}")

查找预量化模型

HuggingFace 上的 TheBloke：

• https://huggingface.co/TheBloke
• 1000+ 个 GPTQ 格式的模型
• 多种分组大小（32、128）
• 支持 CUDA 和 Marlin 格式

搜索：

# Find GPTQ models on HuggingFace
https://huggingface.co/models?library=gptq

下载：

from auto_gptq import AutoGPTQForCausalLM

# Automatically downloads from HuggingFace
model = AutoGPTQForCausalLM.from_quantized(
    "TheBloke/Llama-2-70B-Chat-GPTQ",
    device="cuda:0"
)

支持的模型

• LLaMA 系列：Llama 2、Llama 3、Code Llama
• Mistral：Mistral 7B、Mixtral 8x7B、8x22B
• Qwen：Qwen、Qwen2、QwQ
• DeepSeek：V2、V3
• Phi：Phi-2、Phi-3
• Yi、Falcon、BLOOM、OPT
• HuggingFace 上的 100+ 个模型

参考资料

• 校准指南 - 数据集选择、量化流程、质量优化
• 集成指南 - Transformers、PEFT、vLLM、TensorRT-LLM
• 故障排除 - 常见问题、性能优化

资源

• GitHub：https://github.com/AutoGPTQ/AutoGPTQ
• 论文：GPTQ：准确的训练后量化（arXiv:2210.17323）
• 模型：https://huggingface.co/models?library=gptq
• Discord：https://discord.gg/autogptq

Agent 操作流程

1. 检查环境。 检查 GPU 类型、内存和驱动/CUDA 版本（nvidia-smi）、框架版本，以及数据集的位置和大小。
2. 明确输入。 根据数据或用户确认格式、标识符和参数。对于任何会改变结果的值，应询问而不是猜测。
3. 先运行小规模版本。 执行冒烟测试：使用小型模型或子集，运行少量步骤，并确认损失下降且检查点成功保存。
4. 使用上述说明和参考资料执行完整任务。
5. 验证结果。 跟踪留出数据上的指标，与基线进行比较，并记录随机种子、配置和硬件。
6. 报告。 说明运行了什么（版本、命令、参数）、检查了什么，以及仍有哪些不确定之处。

如果出现这种情况	请这样做
CUDA 内存不足	减小批次大小，启用梯度累积/检查点或混合精度，或者对模型进行分片。
损失为 NaN 或发散	降低学习率，检查数据中是否有无效值，并启用梯度裁剪。
这些说明中提到的函数、标志或端点在已安装版本中不存在	查阅已安装版本自身的文档（help()、--help、官方文档），调整做法，并告知用户。切勿编造 API。
所需输入、标识符或参数含糊不清	询问用户，或在运行前明确说明所采用的假设。

诚信规则

• 切勿捏造结果、参数、标识符、引文或统计数据。如果某项操作无法运行或验证，请明确说明。
• 没有日志时，切勿声称取得了训练结果；启动大型任务前应估算计算成本。
• 将此处与特定版本相关的细节视为可能已过时：请根据已安装版本的官方文档进行确认。
• 对于需要付费、占用共享 GPU 或云配额、涉及个人或患者数据，或无法撤销的操作，请先征求同意。

相关技能

• quantizing-models-bitsandbytes：将大模型量化为 8 位或 4 位，在准确率损失极小的情况下减少 50-75% 的内存占用。
• hqq-quantization：无需校准数据即可对大模型进行半二次量化。
• awq-quantization：采用感知激活的权重量化，将大模型压缩为 4 位，实现 3 倍加速且准确率损失极小。