模型压缩与量化：INT8 推理的精度保持与部署实践

一、模型压缩的必要性：从云端到边缘的算力鸿沟

一个 7B 参数的 LLaMA 模型，FP16 精度下需要 14GB 显存。即使是最新的消费级 GPU（如 RTX 4090，24GB 显存），也只能勉强运行推理，无法进行微调。在边缘设备（手机、嵌入式）上，模型部署的显存和算力限制更加严苛。

模型压缩不是"把模型变小"这么简单。压缩必须在精度、速度和大小三者之间找到平衡。INT8 量化可以将模型体积减半、推理速度翻倍，但不当的量化策略会导致精度暴跌。理解量化的数学原理，是制定正确压缩策略的前提。

二、量化的数学原理：从 FP32 到 INT8 的映射

量化的核心是将连续的浮点数空间映射到离散的整数空间。线性量化（最常用）的映射公式为：

$$x_{int8} = \text{round}\left(\frac{x_{fp32}}{scale}\right) + zero_point$$

flowchart TB
    A[FP32 权重分布] --> B{量化策略选择}
    B -->|对称量化| C[Scale = max|abs|x| / 127<br/>Zero_point = 0]
    B -->|非对称量化| D[Scale = max - min / 255<br/>Zero_point = round(-min/scale)]

    C --> E[INT8 权重<br/>-128 到 127]
    D --> F[INT8 权重<br/>0 到 255]

    E --> G[推理时反量化<br/>x_fp32 ≈ scale × x_int8]
    F --> G

    A --> H[异常值处理]
    H --> I[百分位裁剪<br/>忽略 top 0.1% 极值]
    H --> J[分组量化<br/>每组独立 scale]

    style C fill:#e8f5e9
    style D fill:#fff3e0
    style I fill:#fce4ec

对称量化假设权重分布关于零点对称，适用于大部分权重（均值接近零）。非对称量化允许零点偏移，适用于激活值（如 ReLU 后全为正数）。关键问题是异常值——少数极大值会拉大 scale，导致大部分正常值的量化精度严重损失。

三、生产级代码实现

3.1 PyTorch 原生量化

import torch
import torch.nn as nn
import torch.quantization as quant
from typing import Optional


class QuantizableModel(nn.Module):
    """可量化的模型：插入量化/反量化桩"""

    def __init__(self, original_model: nn.Module):
        super().__init__()
        # 量化配置
        self.quant = quant.QuantStub()
        self.dequant = quant.DeQuantStub()

        # 复制原始模型的层
        self.features = original_model.features
        self.classifier = original_model.classifier

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # 量化输入
        x = self.quant(x)
        # 前向传播（量化计算）
        x = self.features(x)
        x = self.classifier(x)
        # 反量化输出
        x = self.dequant(x)
        return x


def apply_dynamic_quantization(model: nn.Module) -> nn.Module:
    """
    动态量化：运行时将线性层和 LSTM 层的权重转为 INT8
    激活值保持 FP32
    优点：无需校准数据，精度损失最小
    缺点：只有权重被量化，加速有限
    """
    quantized_model = torch.quantization.quantize_dynamic(
        model,
        {nn.Linear, nn.LSTM},  # 量化目标层类型
        dtype=torch.qint8,
    )
    return quantized_model


def apply_static_quantization(model: nn.Module,
                               calibration_loader: torch.utils.data.DataLoader,
                               num_calibration_batches: int = 100) -> nn.Module:
    """
    静态量化：权重和激活值都转为 INT8
    需要校准数据确定激活值的 scale 和 zero_point
    优点：推理速度最快
    缺点：需要校准数据，精度损失可能较大
    """
    # 1. 设置量化配置
    model.qconfig = quant.get_default_qconfig('x86')

    # 2. 插入观察器（Observer）
    model_prepared = quant.prepare(model)

    # 3. 校准：用真实数据统计激活值分布
    model_prepared.eval()
    with torch.no_grad():
        for i, (inputs, _) in enumerate(calibration_loader):
            model_prepared(inputs)
            if i >= num_calibration_batches:
                break

    # 4. 转换为量化模型
    model_quantized = quant.convert(model_prepared)

    return model_quantized


def compare_model_size(original: nn.Module,
                        quantized: nn.Module) -> dict:
    """比较原始模型和量化模型的大小"""
    import tempfile
    import os

    with tempfile.NamedTemporaryFile(delete=False, suffix=".pt") as f:
        torch.save(original.state_dict(), f.name)
        original_size = os.path.getsize(f.name) / 1024 / 1024
        os.unlink(f.name)

    with tempfile.NamedTemporaryFile(delete=False, suffix=".pt") as f:
        torch.save(quantized.state_dict(), f.name)
        quantized_size = os.path.getsize(f.name) / 1024 / 1024
        os.unlink(f.name)

    result = {
        "original_mb": round(original_size, 1),
        "quantized_mb": round(quantized_size, 1),
        "compression_ratio": round(original_size / quantized_size, 2),
    }

    print(f"原始模型: {result['original_mb']}MB")
    print(f"量化模型: {result['quantized_mb']}MB")
    print(f"压缩比: {result['compression_ratio']}x")

    return result

3.2 GPTQ 权重量化（大语言模型专用）

def apply_gptq_quantization(model_path: str,
                              output_path: str,
                              bits: int = 4,
                              group_size: int = 128,
                              calibration_data: Optional[str] = None):
    """
    GPTQ 量化：专门用于大语言模型的权重量化
    核心思想：逐层量化，每层量化后补偿对后续层的影响
    支持 4-bit 量化，精度损失极小
    """
    try:
        from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
        from transformers import AutoTokenizer
    except ImportError:
        raise ImportError("请安装 auto-gptq: pip install auto-gptq")

    tokenizer = AutoTokenizer.from_pretrained(model_path)

    # 量化配置
    quantize_config = BaseQuantizeConfig(
        bits=bits,                    # 量化位数：4 或 8
        group_size=group_size,        # 分组大小：128 或 -1（不分组）
        desc_act=True,                # 按激活值大小排序权重
        damp_percent=0.01,            # Hessian 矩阵的阻尼系数
        sym=True,                     # 对称量化
    )

    # 加载模型
    model = AutoGPTQForCausalLM.from_pretrained(
        model_path,
        quantize_config=quantize_config,
        torch_dtype=torch.float16,
    )

    # 准备校准数据
    if calibration_data is None:
        # 使用默认校准数据
        calibration_texts = [
            "The quick brown fox jumps over the lazy dog.",
            "Machine learning models require careful optimization.",
        ] * 128
    else:
        with open(calibration_data) as f:
            calibration_texts = f.readlines()

    # Tokenize 校准数据
    calibration_encodings = tokenizer(
        calibration_texts,
        return_tensors="pt",
        padding=True,
        truncation=True,
        max_length=2048,
    )

    # 执行量化
    model.quantize(calibration_encodings.input_ids)

    # 保存量化模型
    model.save_quantized(output_path)
    tokenizer.save_pretrained(output_path)

    print(f"GPTQ 量化完成: {bits}-bit, group_size={group_size}")
    print(f"输出路径: {output_path}")


def benchmark_quantized_model(model_path: str,
                               prompt: str = "Hello, world!",
                               max_new_tokens: int = 100,
                               num_iterations: int = 10) -> dict:
    """基准测试量化模型的推理性能"""
    from transformers import AutoTokenizer, TextGenerationPipeline

    tokenizer = AutoTokenizer.from_pretrained(model_path)

    try:
        from auto_gptq import AutoGPTQForCausalLM
        model = AutoGPTQForCausalLM.from_quantized(
            model_path, device="cuda:0"
        )
    except ImportError:
        from transformers import AutoModelForCausalLM
        model = AutoModelForCausalLM.from_pretrained(
            model_path, device_map="auto"
        )

    pipeline = TextGenerationPipeline(
        model=model, tokenizer=tokenizer
    )

    # 预热
    pipeline(prompt, max_new_tokens=max_new_tokens)

    # 正式测试
    latencies = []
    for _ in range(num_iterations):
        start = time.perf_counter()
        output = pipeline(prompt, max_new_tokens=max_new_tokens)
        elapsed = time.perf_counter() - start
        latencies.append(elapsed)

    avg_latency = np.mean(latencies)
    tokens_per_second = max_new_tokens / avg_latency

    return {
        "avg_latency_s": round(avg_latency, 3),
        "tokens_per_second": round(tokens_per_second, 1),
        "max_new_tokens": max_new_tokens,
    }

3.3 量化精度评估

def evaluate_quantization_accuracy(
    original_model: nn.Module,
    quantized_model: nn.Module,
    test_loader: torch.utils.data.DataLoader,
    metrics: list[str] = ["accuracy", "f1"],
) -> dict:
    """评估量化前后的精度差异"""
    original_results = evaluate_model(original_model, test_loader)
    quantized_results = evaluate_model(quantized_model, test_loader)

    comparison = {}
    for metric in metrics:
        original_val = original_results[metric]
        quantized_val = quantized_results[metric]
        diff = quantized_val - original_val
        pct_diff = (diff / original_val) * 100 if original_val != 0 else 0

        comparison[metric] = {
            "original": original_val,
            "quantized": quantized_val,
            "diff": diff,
            "pct_diff": pct_diff,
        }

        print(f"{metric}: 原始={original_val:.4f}, "
              f"量化={quantized_val:.4f}, "
              f"差异={diff:+.4f} ({pct_diff:+.2f}%)")

    return comparison

四、量化的精度-速度权衡与选型建议

动态量化 vs 静态量化：动态量化只量化权重，激活值在推理时动态转换。精度损失极小（< 0.5%），但加速有限（约 1.5-2x）。静态量化同时量化权重和激活值，加速显著（约 2-4x），但需要校准数据，精度损失可能达 1-3%。建议 CPU 推理用动态量化，GPU 推理用静态量化。

4-bit 量化的风险：GPTQ 的 4-bit 量化可以将 7B 模型压缩到约 4GB，在消费级 GPU 上可运行。但 4-bit 的精度损失在复杂任务（数学推理、代码生成）上可能超过 5%。建议对话和摘要场景使用 4-bit，推理和代码场景使用 8-bit。

分组量化的参数选择：group_size 越小，每组独立 scale 越多，量化精度越高，但模型文件越大。group_size=128 是最常用的平衡点；group_size=-1（不分组）精度最低但压缩比最高；group_size=32 精度最高但文件增大 20%。

量化感知训练（QAT）的必要性：训练后量化（PTQ）在大多数场景下足够，但极端压缩（如 4-bit）时精度损失可能不可接受。QAT 在训练过程中模拟量化误差，让模型学习适应低精度。代价是需要完整的训练流水线，成本远高于 PTQ。

五、总结

模型量化的核心是"精度换速度换空间"。本文的三种量化策略为：动态量化（最安全，精度损失 < 0.5%）、静态量化（最实用，精度损失 1-3%）、GPTQ 4-bit（最激进，大模型专用）。选型建议：CPU 推理用动态量化，GPU 推理用静态量化，大语言模型用 GPTQ。量化后必须在验证集上评估精度，损失超过 3% 时应回退到更高精度或使用 QAT。group_size 建议默认 128，精度不足时减小到 32。

补充落地建议：围绕“模型压缩与量化：INT8 推理的精度保持与部署实践”继续推进时，应把验证标准写成可执行清单，而不是停留在经验判断。性能类方案要给出基准数据，架构类方案要给出故障隔离方式，AI 类方案要给出输出质量和人工兜底策略。每一次迭代都应回答三个问题：收益是否可量化，失败是否可回滚，维护成本是否被团队接受。

如果短期资源有限，可以先保留最关键的观测指标，包括处理耗时、失败率、资源占用和人工介入次数。等这些指标稳定后，再扩展自动化能力。这样的节奏更慢，但风险更低，也更符合生产级技术文章强调的工程可验证性。