LLM量子化技法完全比較：GPTQ、AWQ、GGUF 実践適用ガイド

import torch

def absmax_quantize(tensor: torch.Tensor, bits: int = 8) -> tuple:
    """Absmax量子化：絶対最大値基準スケーリング"""
    qmax = 2 ** (bits - 1) - 1  # INT8なら127
    scale = tensor.abs().max() / qmax
    quantized = torch.round(tensor / scale).clamp(-qmax, qmax).to(torch.int8)
    return quantized, scale

def absmax_dequantize(quantized: torch.Tensor, scale: float) -> torch.Tensor:
    """逆量子化：元のスケールに復元"""
    return quantized.float() * scale

# 例：FP16重みの量子化
weight = torch.randn(4096, 4096, dtype=torch.float16)
q_weight, scale = absmax_quantize(weight.float())
restored = absmax_dequantize(q_weight, scale)
error = (weight.float() - restored).abs().mean()
print(f"平均量子化誤差: {error:.6f}")

import torch

def zeropoint_quantize(tensor: torch.Tensor, bits: int = 8) -> tuple:
    """Zero-Point量子化：非対称分布対応"""
    qmin = -(2 ** (bits - 1))
    qmax = 2 ** (bits - 1) - 1

    rmin, rmax = tensor.min(), tensor.max()
    scale = (rmax - rmin) / (qmax - qmin)
    zero_point = torch.round(qmin - rmin / scale).clamp(qmin, qmax)

    quantized = torch.round(tensor / scale + zero_point).clamp(qmin, qmax).to(torch.int8)
    return quantized, scale, zero_point

def zeropoint_dequantize(quantized: torch.Tensor, scale: float, zero_point: float) -> torch.Tensor:
    """Zero-Point逆量子化"""
    return (quantized.float() - zero_point) * scale

# 非対称分布テスト（ReLU出力のように正数偏重）
weight = torch.randn(4096, 4096).abs()  # 正数のみ
q_weight, scale, zp = zeropoint_quantize(weight)
restored = zeropoint_dequantize(q_weight, scale, zp)
error = (weight - restored).abs().mean()
print(f"Zero-Point量子化平均誤差: {error:.6f}")

delta_w = -(w - quant(w)) / H_inv[q,q] * H_inv[:, q]

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

# 1. 量子化設定
model_name = "meta-llama/Llama-3.1-8B-Instruct"
quantize_config = BaseQuantizeConfig(
    bits=4,                  # 4ビット量子化
    group_size=128,          # 128個の要素単位グループ
    desc_act=True,           # Activation order使用
    damp_percent=0.01,       # ヘッセ damping比率
    sym=True,                # 対称量子化
)

# 2. モデルおよびトークナイザーのロード
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantize_config=quantize_config,
    torch_dtype=torch.float16,
)

# 3. キャリブレーションデータの準備
calibration_data = [
    tokenizer("The meaning of life is", return_tensors="pt"),
    tokenizer("Artificial intelligence has", return_tensors="pt"),
    tokenizer("In the context of machine learning", return_tensors="pt"),
    # 実際には128～256個の多様なサンプル使用を推奨
]

# 4. 量子化実行（Llama-3.1-8B基準で約15～30分）
model.quantize(calibration_data)

# 5. 量子化モデルの保存
output_dir = "./llama-3.1-8b-gptq-4bit"
model.save_quantized(output_dir)
tokenizer.save_pretrained(output_dir)
print(f"量子化完了。保存先: {output_dir}")

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

# 1. モデルのロード
model_path = "meta-llama/Llama-3.1-8B-Instruct"
model = AutoAWQForCausalLM.from_pretrained(
    model_path,
    low_cpu_mem_usage=True,
    use_cache=False,
)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

# 2. 量子化設定
quant_config = {
    "zero_point": True,       # Zero-Point量子化を使用
    "q_group_size": 128,      # グループサイズ
    "w_bit": 4,               # 4ビット量子化
    "version": "GEMM",        # GEMMカーネル（汎用）vs GEMV（バッチ=1最適化）
}

# 3. 量子化実行（GPTQより高速、約10分）
model.quantize(tokenizer, quant_config=quant_config)

# 4. 保存
output_dir = "./llama-3.1-8b-awq-4bit"
model.save_quantized(output_dir)
tokenizer.save_pretrained(output_dir)
print(f"AWQ量子化完了: {output_dir}")

# 1. llama.cppのビルド
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp && mkdir build && cd build
cmake .. -DGGML_CUDA=ON  # GPUアクセラレーション使用時
cmake --build . --config Release

# 2. HFモデルをGGUF FP16に変換
python convert_hf_to_gguf.py \
    /path/to/Llama-3.1-8B-Instruct \
    --outtype f16 \
    --outfile llama-3.1-8b-f16.gguf

# 3. Q4_K_Mで量子化
./build/bin/llama-quantize \
    llama-3.1-8b-f16.gguf \
    llama-3.1-8b-q4_k_m.gguf \
    Q4_K_M

# 4. 推論テスト
./build/bin/llama-cli \
    -m llama-3.1-8b-q4_k_m.gguf \
    -p "Explain quantum computing in simple terms:" \
    -n 256 \
    --n-gpu-layers 35  # GPUオフローディングレイヤー数

from llama_cpp import Llama

# GGUFモデルのロード（GPUレイヤーオフローディング含む）
llm = Llama(
    model_path="./llama-3.1-8b-q4_k_m.gguf",
    n_gpu_layers=35,    # GPUに載せるレイヤー数（-1なら全体）
    n_ctx=4096,          # コンテキスト長
    n_threads=8,         # CPUスレッド数
    verbose=False,
)

# テキスト生成
output = llm(
    "Explain the difference between TCP and UDP:",
    max_tokens=512,
    temperature=0.7,
    top_p=0.9,
    stop=["\\n\\n"],
)
print(output["choices"][0]["text"])

# ChatCompletion APIスタイル
response = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is quantization in ML?"},
    ],
    max_tokens=512,
    temperature=0.7,
)
print(response["choices"][0]["message"]["content"])

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
)

# 4ビット量子化設定
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",           # NormalFloat4（QLoRA論文）
    bnb_4bit_compute_dtype=torch.bfloat16,  # 演算はBF16で
    bnb_4bit_use_double_quant=True,       # 二重量子化（追加のメモリ節約）
)

# モデルのロード（ロード時に自動量子化）
model_name = "meta-llama/Llama-3.1-8B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# メモリ使用量の確認
print(f"モデルメモリ: {model.get_memory_footprint() / 1e9:.2f} GB")

# 推論
inputs = tokenizer("Explain gradient descent:", return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

from vllm import LLM, SamplingParams

# AWQモデルのサービング（Marlinカーネル自動適用）
llm = LLM(
    model="casperhansen/llama-3.1-8b-instruct-awq",
    quantization="awq_marlin",      # Marlinカーネルを明示
    max_model_len=8192,
    gpu_memory_utilization=0.85,
    dtype="half",
)

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=1024,
)

prompts = [
    "Explain the CAP theorem in distributed systems.",
    "Write a Python function to implement binary search.",
    "What are the SOLID principles in software engineering?",
]

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    prompt = output.prompt
    generated = output.outputs[0].text
    print(f"Prompt: {prompt[:50]}...")
    print(f"Output: {generated[:200]}...")
    print("---")