FP8量化实战：vLLM与SGLang部署DeepSeek显存减半、吞吐翻倍——Agent推理引擎篇（二）

# vLLM 在线FP8量化 — 最简单的方式
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --quantization fp8 \
    --gpu-memory-utilization 0.95 \
    --max-model-len 32768 \
    --tensor-parallel-size 8 \
    --host 0.0.0.0 \
    --port 8000

# SGLang 在线FP8量化
python -m sglang.launch_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --quantization fp8 \
    --mem-fraction-static 0.85 \
    --context-length 32768 \
    --tp 8 \
    --host 0.0.0.0 \
    --port 30000

INFO: Loading model weights took 134.72 GB  # BF16 全量加载
INFO: Quantizing model weights to FP8...
INFO: Model weights quantized, now using 67.36 GB  # 减半

# SGLang 在线FP8 + 指定后端
python -m sglang.launch_server \
    --model Qwen/Qwen3-8B \
    --quantization fp8 \
    --enable-fp8  # SGLang 特有标记

# 安装 llm-compressor
pip install llmcompressor

# 量化脚本 quantize_fp8.py

from llmcompressor import oneshot
from llmcompressor.recipe import Recipe

# 定义 FP8 Recipe：Round-to-Nearest 算法
recipe = Recipe("""
quant_stage:
    quant_modifiers:
        FP8DynamicPerTensor:
            targets: ["Linear"]
            scheme:
                weights: {num_bits: 8, type: float, strategy: tensor, symmetric: true, group_size: 128}
                input_activations: {num_bits: 8, type: float, strategy: tensor, symmetric: true}
""")

# 一键量化（自动加载、量化、保存）
oneshot(
    model="deepseek-ai/DeepSeek-V3-0324",
    recipe=recipe,
    output_dir="./DeepSeek-V3-FP8",
    dataset="openai/gsm8k",      # 校准数据集
    max_seq_length=4096,          # 校准序列长度
    num_calibration_samples=512,  # 校准样本数（512 足够）
)

# 量化后的模型应该大约是 BF16 的一半
du -sh ./DeepSeek-V3-FP8/
# 预期输出: ~284 GB（原版 BF16 是 ~568 GB）

# 检查权重格式
python -c "
import torch
import safetensors
from safetensors import safe_open
with safe_open('./DeepSeek-V3-FP8/model-00001-of-00009.safetensors', 
               framework='pt') as f:
    for key in f.keys():
        if 'weight' in key and 'proj' in key:
            print(f'{key}: dtype={f.get_tensor(key).dtype}')
            break
"
# 预期输出: model.layers.0.self_attn.q_proj.weight: dtype=torch.float8_e4m3fn

pip install git+https://github.com/neuralmagic/AutoFP8.git

from datasets import load_dataset
from transformers import AutoTokenizer
from auto_fp8 import AutoFP8ForCausalLM, BaseQuantizeConfig

pretrained_model_dir = "meta-llama/Meta-Llama-3-8B-Instruct"
quantized_model_dir = "Meta-Llama-3-8B-Instruct-FP8-Static"

# 步骤1：准备校准数据（512-2048 条样本，UltraChat 或自定义）
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_dir, use_fast=True)
tokenizer.pad_token = tokenizer.eos_token

ds = load_dataset("neuralmagic/ultrachat_2k", split="train_sft").select(range(2048))
examples = [tokenizer.apply_chat_template(batch["messages"], tokenize=False) 
            for batch in ds]
examples = tokenizer(examples, padding=True, truncation=True, 
                     return_tensors="pt").to("cuda")

# 步骤2：定义静态量化配置
quantize_config = BaseQuantizeConfig(
    quant_method="fp8",
    activation_scheme="static"  # 关键：静态 scale
)

# 步骤3：加载模型 → 量化 → 保存
model = AutoFP8ForCausalLM.from_pretrained(pretrained_model_dir, quantize_config)
model.quantize(examples)
model.save_quantized(quantized_model_dir)

print(f"✅ FP8 量化完成，模型保存至: {quantized_model_dir}")

# 加载离线量化的 FP8 模型——直接飞
python -m vllm.entrypoints.openai.api_server \
    --model ./DeepSeek-V3-FP8 \
    --gpu-memory-utilization 0.95 \
    --max-model-len 32768 \
    --tensor-parallel-size 8 \
    --host 0.0.0.0 \
    --port 8000

# vLLM — 一行参数
python -m vllm.entrypoints.openai.api_server \
    --model ./DeepSeek-V3-FP8 \
    --kv-cache-dtype fp8 \
    --gpu-memory-utilization 0.95 \
    --max-model-len 131072 \
    --tensor-parallel-size 8

# SGLang — 等价配置
python -m sglang.launch_server \
    --model ./DeepSeek-V3-FP8 \
    --kv-cache-dtype fp8_e4m3 \
    --context-length 131072 \
    --tp 8

# ❌ 这样会 OOM（如果显存 < 568 GB）
vllm serve deepseek-ai/DeepSeek-V3-0324 --quantization fp8

# ✅ 这样不会 OOM
# 先在 CPU 内存足够的机器上量化
python quantize_fp8.py  # → 产出 ./DeepSeek-V3-FP8 (~284 GB)
# 然后再加载
vllm serve ./DeepSeek-V3-FP8

# 用 lm-evaluation-harness 验证量化前后的精度
pip install lm-eval

# BF16 基准
lm_eval --model vllm \
    --model_args pretrained=meta-llama/Meta-Llama-3-8B-Instruct \
    --tasks mmlu,gsm8k,hellaswag \
    --batch_size auto

# FP8 量化后
lm_eval --model vllm \
    --model_args pretrained=./Meta-Llama-3-8B-Instruct-FP8 \
    --tasks mmlu,gsm8k,hellaswag \
    --batch_size auto

# 对比两份输出的 "metric" 列，差异应在 1% 以内

System Prompt (2K tokens)
  → User Query (500 tokens)
  → Tool Call 1 (3K tokens 返回)
  → Tool Call 2 (5K tokens 返回)
  → Tool Call 3 (2K tokens 返回)
  → Final Response (1K tokens)

# Agent 专用配置：量化一切
vllm serve ./Llama-3-70B-FP8 \
    --kv-cache-dtype fp8 \          # KV Cache 减半
    --gpu-memory-utilization 0.92 \  # 留 8% 给突发
    --max-model-len 65536 \          # 支持 64K 上下文
    --max-num-seqs 128               # 能塞更多并发会话

vllm serve ./model-FP8 \
    --guided-decoding-backend outlines  # 启用语法约束解码

你要在生产环境部署 LLM 推理服务
│
├─ GPU 是 H100 / L40s / MI300x？
│  ├─ 是 → FP8 可用（最优方案）
│  │  │
│  │  ├─ 能先加载全量 BF16 模型？
│  │  │  ├─ 是 → 在线动态量化（方案①），快速验证
│  │  │  └─ 否 → 离线量化（方案③），必须走
│  │  │
│  │  ├─ 并发请求数 > 20？
│  │  │  └─ 是 → 加 --kv-cache-dtype fp8
│  │  │
│  │  └─ Agent 场景，需要结构化输出？
│  │     └─ 是 → 加 guided decoding
│  │
│  └─ 否（A100/V100/4090）
│     └─ 退回到 AWQ 或 GPTQ INT4（Ampere 不支持 FP8 Tensor Core）
│
└─ 目标是极致吞吐？
   └─ 使用 llm-compressor + 静态激活 scale + CUTLASS kernel