模型量化与推理加速：从 FP32 到 INT4 的精度守护，部署落地的工程实践

一、大模型部署的算力墙：推理成本的现实约束

大语言模型的推理成本已成为其规模化落地的核心瓶颈。以 70B 参数模型为例，FP16 精度下模型权重占用 140GB 显存，单次推理需要至少 4 张 A100（80GB）。即使使用 7B 模型，FP16 权重也需要 14GB 显存，超出消费级 GPU（如 RTX 4090 的 24GB）在考虑 KV Cache 后的实际可用容量。

量化是压缩模型体积、降低推理成本最直接的手段：将权重和激活值从 FP32（4字节）压缩到 INT8（1字节）或 INT4（0.5字节），显存占用分别降低 4 倍和 8 倍。但量化并非无损压缩——低精度表示的数值范围和精度有限，会引入量化误差，影响模型输出质量。核心挑战在于：如何在最大限度压缩的同时，将精度损失控制在可接受范围内。

二、量化技术体系与精度保障机制

flowchart TB
    A[模型量化] --> B{量化时机}
    B -->|训练后| C[PTQ 训练后量化]
    B -->|训练中| D[QAT 量化感知训练]

    C --> C1[静态量化<br>校准数据集标定]
    C --> C2[动态量化<br>运行时统计激活范围]
    C --> C3[GPTQ/AWQ<br>逐层最优量化]

    D --> D1[伪量化插入<br>模拟量化噪声]
    D --> D2[混合精度训练<br>关键层FP16]

    C1 --> E[精度评估]
    C2 --> E
    C3 --> E
    D1 --> E
    D2 --> E

    E --> F{精度损失可接受?}
    F -->|是| G[部署上线]
    F -->|否| H[混合精度策略<br>敏感层保留高精度]
    H --> E

量化的核心矛盾：压缩率与精度的 trade-off。解决思路是"差异化对待"——对量化敏感的层保留高精度，对不敏感的层激进压缩。

三、GPTQ 量化与混合精度部署实现

# quantization_engine.py — 模型量化与混合精度部署引擎
# 设计意图：实现训练后量化（PTQ）的关键算法，
# 包含校准、敏感度分析和混合精度策略

import numpy as np
from dataclasses import dataclass
from typing import List, Dict, Tuple, Optional
from enum import Enum

class QuantDtype(Enum):
    FP32 = "fp32"
    FP16 = "fp16"
    INT8 = "int8"
    INT4 = "int4"

@dataclass
class QuantConfig:
    """量化配置"""
    dtype: QuantDtype
    group_size: int = 128        # 分组量化：每组独立计算缩放因子
    sym: bool = True             # 对称量化 vs 非对称量化

    @property
    def bits(self) -> int:
        return {"fp32": 32, "fp16": 16, "int8": 8, "int4": 4}[self.dtype.value]

class Calibrator:
    """量化校准器：统计激活值范围"""

    def __init__(self, config: QuantConfig):
        self.config = config
        self.min_vals = {}
        self.max_vals = {}
        self.abs_max_vals = {}

    def collect(self, layer_name: str, activations: np.ndarray):
        """收集激活值统计信息"""
        if layer_name not in self.min_vals:
            self.min_vals[layer_name] = activations.min()
            self.max_vals[layer_name] = activations.max()
            self.abs_max_vals[layer_name] = np.abs(activations).max()
        else:
            self.min_vals[layer_name] = min(
                self.min_vals[layer_name], activations.min()
            )
            self.max_vals[layer_name] = max(
                self.max_vals[layer_name], activations.max()
            )
            self.abs_max_vals[layer_name] = max(
                self.abs_max_vals[layer_name], np.abs(activations).max()
            )

    def compute_scale(self, layer_name: str) -> Tuple[float, float]:
        """计算量化缩放因子和零点"""
        if self.config.sym:
            # 对称量化：[-max_abs, max_abs] 映射到 [-127, 127]
            max_abs = self.abs_max_vals[layer_name]
            n_levels = 2 ** (self.config.bits - 1) - 1
            scale = max_abs / n_levels if max_abs > 0 else 1.0
            zero_point = 0.0
        else:
            # 非对称量化：[min, max] 映射到 [0, 255]
            min_val = self.min_vals[layer_name]
            max_val = self.max_vals[layer_name]
            n_levels = 2 ** self.config.bits - 1
            scale = (max_val - min_val) / n_levels if max_val > min_val else 1.0
            zero_point = -min_val / scale

        return scale, zero_point


class GPTQQuantizer:
    """GPTQ 量化器：逐层最优量化
    核心思想：将量化视为逐权重的优化问题，
    最小化量化误差的 Hessian 加权平方和"""

    def __init__(self, config: QuantConfig, block_size: int = 128):
        self.config = config
        self.block_size = block_size

    def quantize_weight_block(
        self,
        weight_block: np.ndarray,
        hessian_inv: np.ndarray,
    ) -> Tuple[np.ndarray, np.ndarray]:
        """对权重块进行 GPTQ 量化
        设计意图：逐列量化权重，每量化一列后，
        用 Hessian 逆矩阵调整剩余未量化权重，
        补偿量化引入的误差"""
        n_rows, n_cols = weight_block.shape
        quantized = np.zeros_like(weight_block)
        scale = np.zeros(n_cols, dtype=np.float32)
        errors = np.zeros_like(weight_block)

        for col in range(n_cols):
            w_col = weight_block[:, col]

            # 计算当前列的缩放因子
            max_abs = np.abs(w_col).max()
            n_levels = 2 ** (self.config.bits - 1) - 1
            col_scale = max_abs / n_levels if max_abs > 0 else 1.0
            scale[col] = col_scale

            # 量化当前列
            q_col = np.round(w_col / col_scale).clip(-n_levels, n_levels)
            quantized[:, col] = q_col * col_scale

            # 计算量化误差
            err = (w_col - quantized[:, col]) / hessian_inv[col, col]
            errors[:, col] = err

            # 将误差分配到后续未量化的权重上
            if col < n_cols - 1:
                weight_block[:, col+1:] -= err.reshape(-1, 1) * hessian_inv[col, col+1:]

        return quantized, scale


class MixedPrecisionPolicy:
    """混合精度策略：根据敏感度分析决定每层的量化精度"""

    def __init__(self, model_layers: List[str]):
        self.layer_sensitivity: Dict[str, float] = {}
        self.layer_config: Dict[str, QuantConfig] = {}

    def measure_sensitivity(
        self,
        layer_name: str,
        original_output: np.ndarray,
        quantized_output: np.ndarray,
    ) -> float:
        """测量单层量化对输出的影响程度"""
        # 设计意图：不是所有层对量化同等敏感，
        # 首尾层和注意力投影层通常更敏感
        mse = np.mean((original_output - quantized_output) ** 2)
        signal_power = np.mean(original_output ** 2)
        # 信噪比越低，敏感度越高
        snr = 10 * np.log10(signal_power / (mse + 1e-10))
        sensitivity = max(0, 100 - snr)  # 归一化到 [0, 100]
        self.layer_sensitivity[layer_name] = sensitivity
        return sensitivity

    def assign_precision(self, budget_ratio: float = 0.5) -> Dict[str, QuantConfig]:
        """根据敏感度分配量化精度
        budget_ratio: 允许使用高精度的层比例"""
        if not self.layer_sensitivity:
            return {}

        # 按敏感度降序排列
        sorted_layers = sorted(
            self.layer_sensitivity.items(),
            key=lambda x: x[1],
            reverse=True,
        )

        # 高敏感层保留 FP16，低敏感层使用 INT4
        n_high = int(len(sorted_layers) * budget_ratio)

        for i, (name, _) in enumerate(sorted_layers):
            if i < n_high:
                self.layer_config[name] = QuantConfig(dtype=QuantDtype.FP16)
            else:
                self.layer_config[name] = QuantConfig(
                    dtype=QuantDtype.INT4, group_size=128
                )

        return self.layer_config

    def estimate_memory_saving(self) -> float:
        """估算混合精度策略的内存节省比例"""
        total_bits = 0
        original_bits = 0
        for name, config in self.layer_config.items():
            total_bits += config.bits
            original_bits += 16  # 原始 FP16

        return 1.0 - total_bits / original_bits if original_bits > 0 else 0.0

四、Trade-offs：量化部署的精度与效率边界

INT4 的精度悬崖。 从 FP16 到 INT8，大多数任务的精度损失在 1% 以内；但从 INT8 到 INT4，某些任务（如代码生成、数学推理）的精度可能骤降 5-10%。INT4 的数值范围仅 [-8, 7]（对称量化），对权重分布集中的层影响巨大。建议对精度敏感场景使用 GPTQ + 混合精度，而非一刀切的 INT4。

校准数据集的代表性。 PTQ 依赖校准数据集统计激活值范围，校准数据的分布偏差会导致缩放因子不准确。例如，用新闻文本校准的模型在代码生成任务上可能表现不佳。建议校准数据集应覆盖目标部署场景的数据分布。

分组量化的额外开销。 group_size=128 意味着每 128 个权重共享一个缩放因子，需要存储额外的缩放因子元数据。虽然元数据占用远小于权重本身，但在极小模型（<1B）上，元数据占比不可忽略。

量化与稀疏化的组合。 量化与结构化剪枝可以叠加使用，但组合效应并非简单相加——剪枝后的权重分布可能更不利于量化（稀疏分布的统计特性更差）。建议先量化再剪枝，或使用专门针对稀疏模型的量化算法。

五、总结

模型量化是大模型推理部署的核心技术，目标是在精度可接受的前提下最大化压缩率。工程落地路径：第一步，使用动态量化快速验证基线精度，确认量化可行性；第二步，用校准数据集进行静态量化，获取更精确的缩放因子；第三步，对精度不达标的层进行敏感度分析，实施混合精度策略；第四步，对极致压缩需求使用 GPTQ 逐层最优量化。核心原则：量化不是越激进越好，而是要在目标部署硬件的约束下找到精度与效率的最优平衡点，用数据驱动决策而非经验猜测。