gptq

GPTQ (Generative Pre-trained Transformer Quantization)

グループ単位の量子化を用いて、LLM を最小限の精度低下で 4 ビットに圧縮する学習後量子化手法です。

GPTQ を使うべき場面

GPTQ を使うべき場合:

• 大規模モデル（70B 以上）を限られた GPU メモリに収める必要がある
• 精度低下 2% 未満で 4× のメモリ削減を得たい
• コンシューマー向け GPU（RTX 4090、3090）にデプロイする
• より高速な推論が必要である（FP16 比で 3〜4× の高速化）

代わりに AWQ を使うべき場合:

• わずかに高い精度（損失 1% 未満）が必要である
• 新しい GPU（Ampere、Ada）を使用している
• Marlin カーネルのサポートが欲しい（一部の GPU で 2× 高速）

代わりに bitsandbytes を使うべき場合:

• transformers との簡単な統合が必要である
• 8 ビット量子化が欲しい（圧縮率は低いが品質は高い）
• 事前量子化済みのモデルファイルは不要である

クイックスタート

インストール

# 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. 誤差の最小化: ヘッセ行列の情報を用いて量子化誤差を最小化する
4. 結果: FP16 にほぼ匹敵する精度を持つ 4 ビットの重み

グループサイズのトレードオフ:

グループサイズ	モデルサイズ	精度	速度	推奨
-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 ビット（推奨）

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 ビット）

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 ビット）

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）
• Compute capability ≥ 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 では OOM）

推論速度（Llama 2-7B、A100）

精度	トークン/秒	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
• GPTQ 形式のモデルが 1000 以上
• 複数のグループサイズ（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: Accurate Post-Training Quantization (arXiv:2210.17323)
• モデル: https://huggingface.co/models?library=gptq
• Discord: https://discord.gg/autogptq