GPTQ (Generative Pre-trained Transformer Quantization)

グループ単位の量子化を使用して、最小限の精度低下でLLMを4ビットに圧縮するポストトレーニング量子化手法です。

GPTQ を使用する場合

GPTQ を使用する場合：

• 大規模モデル（70B以上）を限られたGPUメモリに収める必要がある
• 4倍のメモリ削減と2%未満の精度損失が必要
• 消費者向けGPU（RTX 4090、3090）にデプロイする
• FP16比で3～4倍高速な推論が必要

代わりに AWQ を使用する場合：

• より優れた精度（1%未満の損失）が必要
• より新しいGPU（Ampere、Ada）を使用している
• Marlin カーネルのサポートが必要（一部のGPUで2倍高速）

代わりに bitsandbytes を使用する場合：

• transformersとの簡単な統合が必要
• 8ビット量子化を希望している（圧縮が少なく、品質が高い）
• 事前量子化モデルファイルが不要

クイックスタート

インストール

# AutoGPTQ をインストール
pip install auto-gptq

# Triton 付き（Linux のみ、高速）
pip install auto-gptq[triton]

# CUDA 拡張機能付き（高速）
pip install auto-gptq --no-build-isolation

# 完全インストール
pip install auto-gptq transformers accelerate

事前量子化モデルの読み込み

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM

# HuggingFace から量子化モデルを読み込む
model_name = "TheBloke/Llama-2-7B-Chat-GPTQ"

model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_triton=False  # Linux では True に設定して高速化
)

tokenizer = AutoTokenizer.from_pretrained(model_name)

# 生成
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

# モデルを読み込む
model_name = "meta-llama/Llama-2-7b-chat-hf"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 量子化設定
quantize_config = BaseQuantizeConfig(
    bits=4,              # 4ビット量子化
    group_size=128,      # グループサイズ（推奨: 128）
    desc_act=False,      # アクティベーション順序（CUDA カーネル用は False）
    damp_percent=0.01    # ダンピング係数
)

# 量子化用モデルを読み込む
model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantize_config=quantize_config
)

# キャリブレーションデータを準備
dataset = load_dataset("c4", split="train", streaming=True)
calibration_data = [
    tokenizer(example["text"])["input_ids"][:512]
    for example in dataset.take(128)
]

# 量子化
model.quantize(calibration_data)

# 量子化モデルを保存
model.save_quantized("llama-2-7b-gptq")
tokenizer.save_pretrained("llama-2-7b-gptq")

# HuggingFace にプッシュ
model.push_to_hub("username/llama-2-7b-gptq")

グループ単位の量子化

GPTQ の動作方法：

1. 重みをグループ化: 各重み行列を（通常128要素の）グループに分割
2. グループごとに量子化: 各グループは独自のスケール/ゼロポイントを持つ
3. エラーを最小化: Hessian 情報を使用して量子化エラーを最小化
4. 結果: FP16に近い精度を持つ4ビット重み

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

グループサイズ	モデルサイズ	精度	速度	推奨
-1 (列単位)	最小	最高	最遅	研究のみ
32	より小さい	より高い	より遅い	高精度が必要
128	中程度	良好	高速	推奨デフォルト
256	より大きい	より低い	より高速	速度が重要
1024	最大	最低	最速	非推奨

例：

重み行列: [1024, 4096] = 420万要素

グループサイズ = 128:
- グループ数: 420万 / 128 = 32,768グループ
- 各グループ: 独自の4ビットスケール + ゼロポイント
- 結果: より細かい粒度 → より高い精度

量子化設定

標準的な4ビット（推奨）

from auto_gptq import BaseQuantizeConfig

config = BaseQuantizeConfig(
    bits=4,              # 4ビット量子化
    group_size=128,      # 標準グループサイズ
    desc_act=False,      # より高速な CUDA カーネル
    damp_percent=0.01    # ダンピング係数
)

パフォーマンス：

• メモリ: 4倍削減（70B モデル: 140GB → 35GB）
• 精度: パープレキシティ約1.5%増加
• 速度: FP16 比3～4倍高速

高精度（3ビット、より大きなグループ）

config = BaseQuantizeConfig(
    bits=3,              # 3ビット（より高い圧縮）
    group_size=128,      # 標準グループサイズを維持
    desc_act=True,       # より高い精度（低速）
    damp_percent=0.01
)

トレードオフ：

• メモリ: 5倍削減
• 精度: パープレキシティ約3%増加
• 速度: 5倍高速（ただし精度は低い）

最大精度（4ビット、小さなグループ）

config = BaseQuantizeConfig(
    bits=4,
    group_size=32,       # より小さいグループ（より高い精度）
    desc_act=True,       # アクティベーション並べ替え
    damp_percent=0.005   # より低いダンピング
)

トレードオフ：

• メモリ: 3.5倍削減（やや大きい）
• 精度: パープレキシティ約0.8%増加（最高）
• 速度: 2～3倍高速（カーネルオーバーヘッド）

カーネルバックエンド

ExLlamaV2（デフォルト、最速）

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

パフォーマンス: Triton 比1.5～2倍高速

Marlin（Ampere+ GPU）

# Marlin フォーマットで量子化
config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=False  # Marlin に必須
)

model.quantize(calibration_data, use_marlin=True)

# Marlin で読み込む
model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_marlin=True  # A100/H100 で2倍高速
)

要件：

• NVIDIA Ampere 以上（A100、H100、RTX 40xx）
• コンピュート機能 ≥ 8.0

Triton（Linux のみ）

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

パフォーマンス: CUDA バックエンド比1.2～1.5倍高速

transformers との統合

transformers の直接使用

from transformers import AutoModelForCausalLM, AutoTokenizer

# 量子化モデルを読み込む（transformers が 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")

# 任意の transformers モデルのように使用
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

# GPTQ モデルを読み込む
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-2-7B-GPTQ",
    device_map="auto"
)

# LoRA トレーニング用に準備
model = prepare_model_for_kbit_training(model)

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

# LoRA アダプタを追加
model = get_peft_model(model, lora_config)

# 微調整（メモリ効率的！）
# 70B モデルは単一の A100 80GB でトレーニング可能

パフォーマンスベンチマーク

メモリ削減

モデル	FP16	GPTQ 4ビット	削減率
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倍

実現できる場合：

• 70B を単一 A100 80GB で実行（FP16 では 2倍 A100 が必要）
• 405B を 3倍 A100 80GB で実行（FP16 では 11倍 A100 が必要）
• 13B を RTX 4090 24GB で実行（FP16 では OOM）

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

精度	トークン/秒	FP16 比
FP16	25 トークン/秒	1倍
GPTQ 4ビット（CUDA）	85 トークン/秒	3.4倍
GPTQ 4ビット（ExLlama）	105 トークン/秒	4.2倍
GPTQ 4ビット（Marlin）	120 トークン/秒	4.8倍

精度（WikiText-2 のパープレキシティ）

モデル	FP16	GPTQ 4ビット（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デプロイメント

# 自動デバイスマッピング
model = AutoGPTQForCausalLM.from_quantized(
    "TheBloke/Llama-2-70B-GPTQ",
    device_map="auto",  # GPU 全体に自動的に分割
    max_memory={0: "40GB", 1: "40GB"}  # GPU ごとの制限
)

# 手動デバイスマッピング
device_map = {
    "model.embed_tokens": 0,
    "model.layers.0-39": 0,  # 最初の 40 層は GPU 0
    "model.layers.40-79": 1,  # 最後の 40 層は GPU 1
    "model.norm": 1,
    "lm_head": 1
}

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

CPU オフロード

# いくつかの層を CPU にオフロード（非常に大規模なモデル用）
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"  # オーバーフロー時に CPU にオフロード
    }
)

バッチ推論

# 複数のプロンプトを効率的に処理
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 フォーマット両方

検索：

# HuggingFace で GPTQ モデルを検索
https://huggingface.co/models?library=gptq

ダウンロード：

from auto_gptq import AutoGPTQForCausalLM

# 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