模型量化实践：GPTQ 与 AWQ 在生产环境的精度与速度权衡

模型量化实践：GPTQ 与 AWQ 在生产环境的精度与速度权衡

一、模型量化的工程动机与精度挑战

大模型推理的显存占用和计算成本是生产部署的核心瓶颈。一个 FP16 精度的 7B 模型需要约 14GB 显存，而 70B 模型需要约 140GB------超出单卡容量。量化（Quantization）通过降低模型参数的数值精度（从 FP16 降到 INT8 或 INT4），将显存需求减半甚至减至 1/4，同时利用整数运算单元提升推理速度。

然而，量化并非无损压缩。INT4 量化将每个参数的表示范围从 65536 个值压缩到 16 个值，信息损失不可避免。核心挑战在于：如何选择量化方案，使得在目标精度损失可接受的前提下，最大化推理加速效果？

二、GPTQ 与 AWQ 的算法原理对比

GPTQ 和 AWQ 是当前最主流的两种训练后量化（Post-Training Quantization, PTQ）方案，它们的核心差异在于对"哪些权重更重要"的判断方式。

graph TB A[FP16 模型] --> B{量化方案选择} B --> C[GPTQ: 基于二阶信息的逐层量化] C --> D[1. 校准数据集前向传播] D --> E[2. 计算 Hessian 矩阵] E --> F[3. 按 Hessian 对角线排序权重重要性] F --> G[4. 逐个量化权重，用未量化权重补偿误差] G --> H[INT4 量化模型] B --> I[AWQ: 基于激活感知的权重保护] I --> J[1. 校准数据集前向传播] J --> K[2. 分析每通道激活幅值] K --> L[3. 识别高激活通道的权重为"重要权重"] L --> M[4. 对重要权重缩放后量化，非重要权重直接量化] M --> N[INT4 量化模型]

GPTQ 的核心思想是：量化某个权重时，利用 Hessian 矩阵（损失函数的二阶导数）评估该权重对输出的敏感度，并通过调整未量化的权重来补偿量化误差。这种方法在数学上是近似最优的，但计算 Hessian 矩阵需要较大的校准数据集和较长的量化时间。

AWQ 的核心观察是：并非所有权重通道同等重要------与高激活值通道对应的权重对模型输出影响更大。AWQ 通过分析激活分布找到"重要权重通道"，对这些通道先做缩放（放大以减少量化误差）再量化，其余通道直接量化。这种方法不需要计算 Hessian，量化速度更快。

2.1 量化方案对比

维度	GPTQ	AWQ
量化速度（7B 模型）	~30 分钟	~5 分钟
校准数据需求	128 样本	128 样本
精度保持（MMLU）	下降 1%~2%	下降 1%~3%
推理加速（vs FP16）	2×~3×	2.5×~3.5×
显存节省	50%~75%	50%~75%
实现复杂度	较高	较低
推理框架支持	auto-gptq, vLLM	autoawq, vLLM

三、量化部署的工程实现

3.1 量化流程自动化

import subprocess
import logging
import time
from dataclasses import dataclass
from pathlib import Path

logger = logging.getLogger(__name__)


@dataclass
class QuantizationConfig:
    model_id: str              # HuggingFace 模型 ID
    quant_method: str          # "gptq" 或 "awq"
    bits: int = 4              # 量化位数
    group_size: int = 128      # 分组量化大小
    desc_act: bool = True      # GPTQ: 是否按激活值降序排列
    zero_point: bool = True    # 是否使用非对称量化
    calibration_samples: int = 128
    output_dir: str = ""


class ModelQuantizer:
    """模型量化自动化工具"""

    def __init__(self, config: QuantizationConfig):
        self.config = config
        if not config.output_dir:
            model_name = config.model_id.split("/")[-1]
            self.config.output_dir = f"./quantized/{model_name}-{config.quant_method}-int{config.bits}"

    def quantize(self) -> Path:
        """执行量化流程"""
        start_time = time.time()
        output_path = Path(self.config.output_dir)

        if output_path.exists():
            logger.info(f"量化模型已存在: {output_path}")
            return output_path

        logger.info(
            f"开始量化: {self.config.model_id}, "
            f"方法: {self.config.quant_method}, "
            f"位数: {self.config.bits}bit"
        )

        if self.config.quant_method == "gptq":
            self._quantize_gptq()
        elif self.config.quant_method == "awq":
            self._quantize_awq()
        else:
            raise ValueError(f"不支持的量化方法: {self.config.quant_method}")

        elapsed = time.time() - start_time
        logger.info(f"量化完成，耗时: {elapsed:.1f}s，输出: {output_path}")
        return output_path

    def _quantize_gptq(self) -> None:
        """使用 AutoGPTQ 执行量化"""
        from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
        from transformers import AutoTokenizer
        from datasets import load_dataset

        tokenizer = AutoTokenizer.from_pretrained(self.config.model_id)
        model = AutoGPTQForCausalLM.from_pretrained(
            self.config.model_id,
            trust_remote_code=True,
        )

        # 准备校准数据
        dataset = load_dataset("allenai/c4", "en", split="train", streaming=True)
        calibration_data = []
        for i, sample in enumerate(dataset):
            if i >= self.config.calibration_samples:
                break
            tokens = tokenizer(sample["text"], return_tensors="pt",
                             max_length=2048, truncation=True)
            calibration_data.append(tokens.input_ids)

        # 配置量化参数
        quantize_config = BaseQuantizeConfig(
            bits=self.config.bits,
            group_size=self.config.group_size,
            desc_act=self.config.desc_act,
            damp_percent=0.01,
        )

        # 执行量化
        model.quantize(calibration_data, quantize_config=quantize_config)

        # 保存量化模型
        model.save_quantized(self.config.output_dir)
        tokenizer.save_pretrained(self.config.output_dir)

    def _quantize_awq(self) -> None:
        """使用 AutoAWQ 执行量化"""
        from awq import AutoAWQForCausalLM
        from transformers import AutoTokenizer

        tokenizer = AutoTokenizer.from_pretrained(self.config.model_id)
        model = AutoAWQForCausalLM.from_pretrained(
            self.config.model_id,
            trust_remote_code=True,
        )

        # 配置量化参数
        quant_config = {
            "zero_point": self.config.zero_point,
            "q_group_size": self.config.group_size,
            "w_bit": self.config.bits,
            "version": "GEMM",
        }

        # 执行量化
        model.quantize(tokenizer, quant_config=quant_config)

        # 保存量化模型
        model.save_quantized(self.config.output_dir)
        tokenizer.save_pretrained(self.config.output_dir)

3.2 量化模型推理服务

from typing import Optional
import logging

logger = logging.getLogger(__name__)


class QuantizedInferenceService:
    """量化模型推理服务，支持 GPTQ 和 AWQ 后端"""

    def __init__(self, model_path: str, quant_method: str,
                 max_batch_size: int = 8):
        self._model_path = model_path
        self._quant_method = quant_method
        self._max_batch_size = max_batch_size
        self._model = None
        self._tokenizer = None

    def load(self) -> None:
        """加载量化模型"""
        if self._quant_method == "gptq":
            self._load_gptq()
        elif self._quant_method == "awq":
            self._load_awq()
        else:
            raise ValueError(f"不支持的量化方法: {self._quant_method}")

    def _load_gptq(self) -> None:
        from auto_gptq import AutoGPTQForCausalLM
        from transformers import AutoTokenizer

        self._tokenizer = AutoTokenizer.from_pretrained(self._model_path)
        self._model = AutoGPTQForCausalLM.from_quantized(
            self._model_path,
            device_map="auto",
            use_safetensors=True,
            trust_remote_code=True,
        )
        logger.info(f"GPTQ 模型加载完成: {self._model_path}")

    def _load_awq(self) -> None:
        from awq import AutoAWQForCausalLM
        from transformers import AutoTokenizer

        self._tokenizer = AutoTokenizer.from_pretrained(self._model_path)
        self._model = AutoAWQForCausalLM.from_quantized(
            self._model_path,
            device_map="auto",
            safetensors=True,
            trust_remote_code=True,
        )
        logger.info(f"AWQ 模型加载完成: {self._model_path}")

    def generate(self, prompt: str, max_new_tokens: int = 512,
                 temperature: float = 0.7) -> str:
        """生成文本"""
        inputs = self._tokenizer(prompt, return_tensors="pt").to(
            self._model.device
        )
        outputs = self._model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            do_sample=temperature > 0,
        )
        # 仅返回新生成的 Token
        new_tokens = outputs[0][inputs.input_ids.shape[1]:]
        return self._tokenizer.decode(new_tokens, skip_special_tokens=True)

四、量化方案的工程权衡

精度损失的场景差异：量化对不同任务的影响差异显著。在简单分类和摘要任务上，INT4 量化的精度损失通常在 1%~2% 以内；但在数学推理和代码生成任务上，损失可能达到 3%~8%。建议对目标场景做专项基准测试，而非依赖通用基准数据。

GPTQ 的量化时间成本：GPTQ 量化一个 7B 模型需要约 30 分钟，70B 模型需要数小时。如果模型需要频繁更新（如持续微调），量化时间会成为部署瓶颈。AWQ 的量化速度约为 GPTQ 的 5~6 倍，更适合需要快速迭代的场景。

推理框架的兼容性：vLLM 同时支持 GPTQ 和 AWQ，但 TensorRT-LLM 对 AWQ 的支持更成熟。如果使用 NVIDIA GPU 部署，AWQ + TensorRT-LLM 的组合通常能获得更高的推理吞吐量。

混合精度量化的可能性：并非所有层都需要量化到相同精度。注意力层的 Query/Key/Value 对量化更敏感，可以保持 FP16 而仅量化 FFN 层。这种混合精度方案可以在精度和性能之间取得更精细的平衡，但需要更复杂的部署配置。

五、总结

GPTQ 和 AWQ 是当前最主流的两种训练后量化方案，核心差异在于权重重要性的评估方式。GPTQ 基于 Hessian 信息做误差补偿，精度略优但量化速度慢；AWQ 基于激活感知做权重保护，量化速度快且推理效率更高。在工程落地时，建议先用 AWQ 快速验证量化可行性，再根据精度测试结果决定是否切换到 GPTQ。无论选择哪种方案，都必须在目标场景上做专项基准测试------通用基准数据无法替代业务场景的精度验证。