模型量化实践：INT4 与 INT8 在不同硬件平台的精度与速度权衡

一、量化的本质：用精度换空间，但代价是什么

模型量化的核心思想是将模型权重和激活值从高精度浮点数（FP32/FP16）映射到低精度整数（INT8/INT4），从而减少显存占用和计算量。以 Llama-3-8B 为例，FP16 权重需要约 16GB 显存，INT8 量化后降至约 8GB，INT4 量化后仅需约 4GB——这意味着原本需要 A100 的模型，量化后可以在 RTX 4090 上运行。

但量化不是免费的。从 FP16 到 INT8，每个权重的信息量从 16 bit 压缩到 8 bit，精度损失是必然的。关键问题不是"是否损失精度"，而是"精度损失是否在业务可接受范围内"。不同任务对精度的敏感度差异巨大：文本分类对量化不敏感，代码生成和数学推理对量化高度敏感。

graph TD
    A[FP16 模型<br/>16GB 显存] --> B{量化策略选择}

    B -->|训练后量化 PTQ| C[INT8 量化<br/>8GB 显存]
    B -->|训练后量化 PTQ| D[INT4 量化<br/>4GB 显存]
    B -->|量化感知训练 QAT| E[INT8 量化<br/>8GB 显存<br/>精度更高]

    C --> F{精度评估}
    D --> F
    E --> F

    F -->|精度可接受| G[部署上线]
    F -->|精度不可接受| H[回退至更高精度<br/>或使用 QAT]

    style B fill:#fff3e0
    style F fill:#fff3e0

二、量化方法的技术原理：从对称量化到 GPTQ

对称量化（Symmetric Quantization） 将浮点数范围 [-max, max] 线性映射到整数范围 [-127, 127]（INT8）或 [-7, 7]（INT4）。对称量化的计算简单，但对于分布不对称的权重（如 ReLU 后的激活值），会浪费量化范围。

非对称量化（Asymmetric Quantization） 使用零点（Zero Point）和缩放因子（Scale），将浮点数范围 [min, max] 映射到整数范围 [0, 255]（INT8）或 [0, 15]（INT4）。非对称量化对分布不对称的数据更友好，但计算时需要额外的零点偏移。

GPTQ（Gradient-based Post-Training Quantization） 是目前最流行的 INT4 量化方法。GPTQ 的核心创新是：逐层量化时，通过 Hessian 矩阵近似量化误差的二阶影响，在量化当前权重时补偿对后续层的影响。这使得 INT4 量化后的模型精度损失显著低于简单的均匀量化。

AWQ（Activation-aware Weight Quantization） 是另一种 INT4 量化方法，核心观察是：并非所有权重同等重要——对激活值影响大的权重（称为"显著权重"）应保持更高精度。AWQ 通过分析激活值分布识别显著权重，对非显著权重进行更激进的量化，对显著权重保留 FP16 精度。

三、量化实践：校准数据集与精度评估

以下实现展示了量化流程的核心步骤，包括校准数据集构建和精度评估框架。

from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
import json

class QuantizationMethod(Enum):
    SYMMETRIC_INT8 = "symmetric_int8"
    ASYMMETRIC_INT8 = "asymmetric_int8"
    GPTQ_INT4 = "gptq_int4"
    AWQ_INT4 = "awq_int4"

@dataclass
class QuantizationConfig:
    """量化配置"""
    method: QuantizationMethod
    group_size: int = 128          # GPTQ/AWQ 的分组大小
    desc_act: bool = True          # GPTQ 是否按激活值大小排序
    damp_percent: float = 0.01     # GPTQ 阻尼系数
    calibration_samples: int = 128 # 校准样本数

@dataclass
class QuantizationResult:
    """量化结果"""
    method: QuantizationMethod
    model_size_mb: float           # 量化后模型大小
    perplexity: Optional[float] = None  # 困惑度
    benchmark: Optional[dict] = None    # 性能基准测试结果
    accuracy_metrics: dict = field(default_factory=dict)  # 精度指标

class QuantizationEvaluator:
    """量化精度评估器"""

    def evaluate(self, original_model, quantized_model,
                 eval_dataset, task_type: str) -> QuantizationResult:
        """评估量化模型的精度损失"""
        result = QuantizationResult(
            method=QuantizationMethod.SYMMETRIC_INT8,
            model_size_mb=0,
        )

        # 1. 困惑度评估：量化对语言建模能力的影响
        result.perplexity = self._compute_perplexity(
            quantized_model, eval_dataset
        )

        # 2. 任务特定精度评估
        if task_type == "classification":
            result.accuracy_metrics = self._eval_classification(
                original_model, quantized_model, eval_dataset
            )
        elif task_type == "generation":
            result.accuracy_metrics = self._eval_generation(
                original_model, quantized_model, eval_dataset
            )
        elif task_type == "code":
            result.accuracy_metrics = self._eval_code(
                original_model, quantized_model, eval_dataset
            )

        # 3. 性能基准测试
        result.benchmark = self._run_benchmark(quantized_model)

        return result

    def _compute_perplexity(self, model, dataset) -> float:
        """计算困惑度：越低越好，量化后应与原始模型接近"""
        total_log_prob = 0
        total_tokens = 0

        for sample in dataset:
            # 计算模型在文本上的对数概率
            log_prob = model.compute_log_probability(sample["text"])
            total_log_prob += log_prob
            total_tokens += len(sample["text"].split())

        # 困惑度 = exp(-平均对数概率)
        avg_log_prob = total_log_prob / max(total_tokens, 1)
        perplexity = float(-avg_log_prob)  # 简化计算
        return perplexity

    def _eval_classification(self, original, quantized, dataset) -> dict:
        """分类任务精度评估"""
        original_correct = 0
        quantized_correct = 0
        total = 0

        for sample in dataset:
            orig_pred = original.classify(sample["input"])
            quant_pred = quantized.classify(sample["input"])
            label = sample["label"]

            if orig_pred == label:
                original_correct += 1
            if quant_pred == label:
                quantized_correct += 1
            total += 1

        return {
            "original_accuracy": original_correct / total if total else 0,
            "quantized_accuracy": quantized_correct / total if total else 0,
            "accuracy_drop": (original_correct - quantized_correct) / total if total else 0,
        }

    def _eval_generation(self, original, quantized, dataset) -> dict:
        """生成任务精度评估：ROUGE / BLEU"""
        rouge_scores = []

        for sample in dataset:
            orig_output = original.generate(sample["prompt"], max_tokens=256)
            quant_output = quantized.generate(sample["prompt"], max_tokens=256)

            # 计算量化输出与原始输出的 ROUGE-L 相似度
            rouge_l = self._rouge_l(orig_output, quant_output)
            rouge_scores.append(rouge_l)

        avg_rouge = sum(rouge_scores) / len(rouge_scores) if rouge_scores else 0

        return {
            "avg_rouge_l_vs_original": avg_rouge,
            "interpretation": "量化输出与原始输出的相似度，>0.95 为优秀",
        }

    def _eval_code(self, original, quantized, dataset) -> dict:
        """代码生成精度评估：功能正确性"""
        pass_count_orig = 0
        pass_count_quant = 0
        total = 0

        for sample in dataset:
            orig_code = original.generate(sample["prompt"], max_tokens=512)
            quant_code = quantized.generate(sample["prompt"], max_tokens=512)

            # 通过测试用例验证功能正确性
            if self._run_test_cases(orig_code, sample.get("test_cases", [])):
                pass_count_orig += 1
            if self._run_test_cases(quant_code, sample.get("test_cases", [])):
                pass_count_quant += 1
            total += 1

        return {
            "original_pass_rate": pass_count_orig / total if total else 0,
            "quantized_pass_rate": pass_count_quant / total if total else 0,
            "pass_rate_drop": (pass_count_orig - pass_count_quant) / total if total else 0,
            "warning": "代码生成对量化高度敏感，INT4 可能导致变量名错误",
        }

    def _rouge_l(self, text_a: str, text_b: str) -> float:
        """简化版 ROUGE-L 计算"""
        words_a = text_a.split()
        words_b = text_b.split()
        # 最长公共子序列长度
        lcs_len = self._lcs_length(words_a, words_b)
        if not words_a or not words_b:
            return 0.0
        precision = lcs_len / len(words_b)
        recall = lcs_len / len(words_a)
        if precision + recall == 0:
            return 0.0
        return 2 * precision * recall / (precision + recall)

    def _lcs_length(self, a: list, b: list) -> int:
        """最长公共子序列长度"""
        m, n = len(a), len(b)
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if a[i-1] == b[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
        return dp[m][n]

    def _run_benchmark(self, model) -> dict:
        """性能基准测试"""
        return {
            "tokens_per_second": 0,  # 待实际测试填充
            "first_token_latency_ms": 0,
            "p99_latency_ms": 0,
        }

    def _run_test_cases(self, code: str, test_cases: list) -> bool:
        """运行测试用例验证代码正确性"""
        # 简化实现：实际应使用沙箱执行
        return True

四、量化的边界条件与硬件依赖

INT4 在不同 GPU 架构上的表现差异。 NVIDIA Ampere 架构（A100）原生支持 INT8 Tensor Core，但 INT4 需要软件模拟，性能提升有限。NVIDIA Hopper 架构（H100）对 INT4 的支持有所改善。AMD MI300X 对 INT8 的支持较好，但 INT4 生态尚不成熟。量化选型必须考虑目标硬件的原生支持情况。

校准数据集的代表性。 PTQ 的精度高度依赖校准数据集。如果校准数据与实际推理数据的分布不匹配，量化后的精度损失可能远超预期。建议使用业务实际数据构建校准集，而非通用语料库。

混合精度的必要性。 并非所有层都适合激进量化。Embedding 层和第一层 Transformer 对精度最敏感，INT4 量化后精度损失显著；中间层对量化较鲁棒。混合精度策略（敏感层 INT8/FP16，其余层 INT4）通常比全 INT4 效果更好，但增加了部署复杂度。

量化与推理引擎的兼容性。 不同推理引擎对量化格式的支持不同。vLLM 原生支持 AWQ 和 GPTQ，但 TensorRT-LLM 有自己的量化工具链。量化模型在引擎间的迁移需要格式转换，可能引入额外的精度损失。

五、总结

模型量化是降低推理成本的关键技术，INT8 量化在大多数场景下精度损失可控，INT4 量化需要更谨慎的评估。GPTQ 和 AWQ 是当前最成熟的 INT4 量化方案，但精度损失对代码生成和数学推理场景仍不可忽视。量化的效果高度依赖校准数据集的代表性、目标硬件的原生支持、以及混合精度策略的合理配置。

落地路线建议：第一，优先尝试 INT8 量化，精度可接受后再考虑 INT4；第二，使用业务实际数据构建校准集，而非通用语料；第三，建立量化前后的精度回归测试，每次量化都必须通过评估才能上线。