模型量化与压缩技术：GPTQ、AWQ、GGUF与FP8的工程实践指南

┌──────────────────────────────────────────────────────────────┐
│                    量化方案决策矩阵                            │
├──────────────────────────────────────────────────────────────┤
│  目标硬件                                                     │
│  ├── CPU / Apple Silicon / 边缘设备 ──────→ GGUF             │
│  ├── NVIDIA GPU（纯推理） ─────────────────→ GPTQ 或 AWQ      │
│  └── Hopper+ GPU（生产级） ────────────────→ FP8             │
│                                                              │
│  核心需求                                                     │
│  ├── 追求极致吞吐量 ──────────────────────→ GPTQ + Marlin    │
│  ├── 追求最佳质量保留 ────────────────────→ AWQ              │
│  └── 追求跨平台灵活性 ────────────────────→ GGUF             │
└──────────────────────────────────────────────────────────────┘

from transformers import AutoModelForCausalLM, GPTQConfig, AutoTokenizer

quantization_config = GPTQConfig(
    bits=4,
    dataset="c4",
    group_size=128,
    desc_act=True,
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    quantization_config=quantization_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

text = "The future of AI is"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

┌─────────────────────────────────────────────────────┐
│            AWQ 量化流程示意                           │
├─────────────────────────────────────────────────────┤
│                                                     │
│  输入：权重 W + 校准数据激活 X                        │
│       ↓                                             │
│  Step 1：统计通道级平均激活幅度                        │
│       ↓                                             │
│  Step 2：识别 salient channels（Top 1%）             │
│       ↓                                             │
│  Step 3：搜索最优缩放因子 α                           │
│       ↓                                             │
│  Step 4：对 salient channels 做 scale 保护            │
│       ↓                                             │
│  Step 5：执行标准分组量化                              │
│       ↓                                             │
│  输出：量化权重 + scale/zero-point 元数据             │
│                                                     │
└─────────────────────────────────────────────────────┘

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "meta-llama/Llama-3.1-8B"
quant_path = "Llama-3.1-8B-AWQ"

model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM",
}

model.quantize(
    tokenizer,
    quant_config=quant_config,
    calib_data="pileval",
)

model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

# Step 1：将 Hugging Face 模型转换为 GGUF 格式
python convert_hf_to_gguf.py \
    --outfile model-f16.gguf \
    --outtype bf16 \
    meta-llama/Llama-3.1-8B

# Step 2：量化为 Q4_K_M
./llama-quantize model-f16.gguf model-q4_k_m.gguf Q4_K_M

# Step 3：使用 importance matrix 进一步优化（可选）
./llama-quantize \
    --imatrix imatrix.gguf \
    model-f16.gguf \
    model-q4_k_m-imatrix.gguf \
    Q4_K_M

# Step 4：运行推理
./llama-cli -m model-q4_k_m.gguf \
    -p "The future of AI is" \
    -n 100

# 创建 Modelfile
echo 'FROM ./model-q4_k_m.gguf' > Modelfile

# 运行模型
ollama create my-model -f Modelfile
ollama run my-model

# Docker 一行启动 FP8 推理服务
docker run --gpus all \
    --ipc=host \
    -p 8000:8000 \
    vllm/vllm-openai:latest \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --quantization fp8 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.92

# Python API 方式
from vllm import LLM

llm = LLM(
    model="meta-llama/Llama-3.1-70B-Instruct",
    quantization="fp8",
    kv_cache_dtype="fp8",
    gpu_memory_utilization=0.92,
)

from llmcompressor import oneshot
from llmcompressor.modifiers.quantization import QuantizationModifier

recipe = QuantizationModifier(
    targets="Linear",
    scheme="FP8_DYNAMIC",
    ignore=["lm_head"],
)

oneshot(
    model="meta-llama/Llama-3.1-8B-Instruct",
    recipe=recipe,
    output_dir="Llama-3.1-8B-FP8",
)

from vllm import LLM

# 启用 FP8 KV Cache，显存减半
llm = LLM(
    model="meta-llama/Llama-3.1-70B-Instruct",
    quantization="fp8",
    kv_cache_dtype="fp8",
    calculate_kv_scales=True,  # 推荐：使用校准数据优化 scale
)

你的 GPU 是什么？
│
├── H100/H200/B200（Hopper/Blackwell）
│   ├── 需要最高质量？──→ FP8 + FP8 KV Cache
│   ├── 需要极致吞吐量？──→ AWQ 4-bit + Marlin
│   └── 追求简单部署？──→ FP8（vLLM 一行启动）
│
├── A100/3090/4090（Ampere/Ada Lovelace）
│   ├── 显存足够放 FP16？──→ 直接用 FP16/BF16
│   └── 显存不够？
│       ├── 追求质量？──→ AWQ 4-bit
│       ├── 追求吞吐量？──→ GPTQ 4-bit + Marlin
│       └── 需要 CPU 推理？──→ GGUF Q4_K_M
│
└── CPU / Apple Silicon / 边缘设备
    └── GGUF Q4_K_M 或 Q5_K_M

# 1. 安装依赖
pip install vllm autoawq

# 2. 启动推理服务（使用预量化的 AWQ 模型）
python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Llama-3.1-8B-AWQ \
    --quantization awq \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.90 \
    --host 0.0.0.0 \
    --port 8000

# 3. 测试 API
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "TheBloke/Llama-3.1-8B-AWQ",
        "messages": [{"role": "user", "content": "Hello!"}]
    }'

# 1. 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 2. 创建自定义量化模型
cat > Modelfile << 'EOF'
FROM ./llama-3.1-8b-Q4_K_M.gguf
TEMPLATE """{{ .System }}
{{ .Prompt }}"""
PARAMETER temperature 0.7
PARAMETER top_p 0.9
EOF

# 3. 构建并运行
ollama create llama-local -f Modelfile
ollama run llama-local

# 使用 AutoGPTQ 量化
pip install auto-gptq

python -c "
from transformers import AutoModelForCausalLM, GPTQConfig, AutoTokenizer

config = GPTQConfig(bits=4, dataset='c4', group_size=128)
model = AutoModelForCausalLM.from_pretrained(
    'meta-llama/Llama-3.1-8B',
    quantization_config=config,
    device_map='auto',
)
model.save_pretrained('llama-3.1-8b-gptq-4bit')
AutoTokenizer.from_pretrained('meta-llama/Llama-3.1-8B').save_pretrained(
    'llama-3.1-8b-gptq-4bit'
)
"

from lm_eval import evaluator, tasks

results = evaluator.simple_evaluate(
    model="hf",
    model_args="pretrained=llama-3.1-8b-gptq-4bit",
    tasks=["mmlu", "gsm8k", "humaneval"],
    batch_size=8,
)

for task, metrics in results["results"].items():
    print(f"{task}: {metrics}")