3、INT8量化实战：使用PyTorch进行静态量化，校准数据集的选择，量化后的模型精度验证与调优

好，咱们今天来点真格的。前面聊了那么多量化的理论，什么对称非对称、per-tensor per-channel，说到底都是为了这一刻——动手干。

这一章，我带你走一遍PyTorch静态量化的完整流程。说白了，就是把一个FP32的模型，硬生生压到INT8，还得保证它不掉精度。嗯，这里面的门道不少，我踩过的坑也够写一本小册子了。

3.1 静态量化 vs 动态量化：我该怎么选？

先别急着写代码。你得想清楚，你的场景适合哪种量化方式。

  • 动态量化：权重提前转成INT8，但激活值还是FP32。每次推理时，动态计算激活的量化参数。好处是简单，几乎不用校准数据。坏处是速度提升有限，尤其对计算密集型层（比如卷积）不友好。
  • 静态量化：权重和激活都提前量化好。激活的scale和zero_point通过校准数据集提前统计出来。推理时全是INT8计算，速度起飞。

我的建议：如果你的模型跑在CPU上，或者对延迟要求极高，直接上静态量化。动态量化更适合那些对精度极其敏感、或者懒得准备校准数据的场景。我在项目中遇到过，一个BERT模型用动态量化只快了20%，换成静态量化直接翻倍。

3.2 PyTorch静态量化四步走

PyTorch的静态量化，流程非常固定。我把它拆成四步，你照着做就行。

  1. 准备模型：把模型里需要量化的层（Conv2d, Linear等）替换成可量化的版本。
  2. 插入观察器：在模型里插入Observer，用来收集激活值的分布。
  3. 校准：跑一遍校准数据集，让Observer统计出每个激活层的min/max。
  4. 转换：把Observer拿掉，把模型真正转换成INT8。

听起来简单？嗯，细节都在坑里。

3.3 代码实战：从FP32到INT8

咱们拿一个简单的ResNet18来演示。你手头如果有自己的模型，流程完全一样。

import torch
import torch.nn as nn
import torch.quantization as quant

# 1. 准备模型
model = models.resnet18(pretrained=True)
model.eval()

# 关键一步：把模型里需要量化的层，用torch.quantization.QuantStub和DeQuantStub包起来
class QuantizedResNet(nn.Module):
    def __init__(self, model_fp32):
        super().__init__()
        self.quant = quant.QuantStub()  # 输入量化
        self.model = model_fp32
        self.dequant = quant.DeQuantStub()  # 输出反量化

    def forward(self, x):
        x = self.quant(x)
        x = self.model(x)
        x = self.dequant(x)
        return x

model = QuantizedResNet(model)

# 2. 设置量化配置
model.qconfig = quant.get_default_qconfig('fbgemm')  # x86 CPU用fbgemm，ARM用qnnpack
# 或者自定义配置
# model.qconfig = quant.QConfig(
#     activation=quant.MinMaxObserver.with_args(dtype=torch.quint8),
#     weight=quant.MinMaxObserver.with_args(dtype=torch.qint8)
# )

# 3. 插入观察器
model = quant.prepare(model, inplace=True)

# 4. 校准
def calibrate(model, data_loader, num_batches=100):
    model.eval()
    with torch.no_grad():
        for i, (inputs, _) in enumerate(data_loader):
            if i >= num_batches:
                break
            model(inputs)

calibrate(model, your_calibration_loader, num_batches=200)

# 5. 转换
model = quant.convert(model, inplace=True)

# 现在model就是INT8的了
print(model)

避坑指南：我曾经在prepare之前忘了设置model.eval()，结果Observer统计出来的分布全是错的。因为训练模式下，BatchNorm的行为不一样。记住，量化校准必须在eval模式下进行。

3.4 校准数据集的选择：成败在此一举

校准数据集，说白了就是用来「喂」Observer的。它不需要有标签，但必须能代表真实数据的分布。

我见过有人随便拿100张ImageNet的图去校准一个目标检测模型，结果量化后精度掉了5个点。为什么？因为校准集和真实场景的数据分布不一样。

场景 校准集建议 数量建议
图像分类 从训练集中随机抽100-500张 100-500张
目标检测 包含各种目标大小、光照条件的图 200-1000张
NLP（BERT） 覆盖各种句长、主题的文本 500-2000条
语音识别 包含不同口音、背景噪音的音频 1000-5000段

注意：校准集的数量不是越多越好。我测试过，用1000张图和10000张图校准，精度几乎没区别。但校准集太少（比如10张），Observer统计的min/max可能严重偏离真实分布。我个人习惯用200-500张，既快又稳。

3.5 精度验证：量化后的模型到底行不行？

量化完，别急着部署。先跑一遍验证集，看看精度掉了多少。

def evaluate(model, val_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            outputs = model(inputs)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    accuracy = 100 * correct / total
    return accuracy

fp32_acc = evaluate(fp32_model, val_loader)
int8_acc = evaluate(int8_model, val_loader)

print(f"FP32精度: {fp32_acc:.2f}%")
print(f"INT8精度: {int8_acc:.2f}%")
print(f"精度损失: {fp32_acc - int8_acc:.2f}%")

一般来说，精度损失在0.5%以内算正常。如果超过1%，就得调优了。

3.6 精度调优：当INT8掉点严重时怎么办？

掉点严重？别慌。我总结了几个最有效的调优手段。

3.6.1 换Observer

默认的MinMaxObserver对离群点非常敏感。如果激活值里有个别极大的值，整个量化范围都会被拉宽，导致精度损失。

试试HistogramObserver或者MovingAverageMinMaxObserver。

model.qconfig = quant.QConfig(
    activation=quant.HistogramObserver.with_args(dtype=torch.quint8),
    weight=quant.MinMaxObserver.with_args(dtype=torch.qint8)
)

我记得有一次，一个模型用MinMaxObserver掉了2个点，换成HistogramObserver后，只掉了0.3个点。说白了，HistogramObserver会忽略那些极少出现的离群点，让量化范围更合理。

3.6.2 逐层量化 vs 逐通道量化

权重量化时，默认是per-tensor（整个权重张量共用一个scale）。但如果不同通道的数值范围差异很大，per-tensor会损失精度。

试试per-channel量化：

model.qconfig = quant.QConfig(
    activation=quant.MinMaxObserver.with_args(dtype=torch.quint8),
    weight=quant.PerChannelMinMaxObserver.with_args(dtype=torch.qint8)
)

代价是推理速度会稍微慢一点，但精度提升明显。我在一个MobileNet模型上试过，per-channel比per-tensor精度高了1.2个点。

3.6.3 跳过敏感层

有些层对量化特别敏感，比如第一层卷积和最后一层全连接。你可以手动把这些层排除在量化之外。

# 在prepare之前，对特定层设置qconfig为None
model.model.conv1.qconfig = None  # 跳过第一层
model.model.fc.qconfig = None     # 跳过最后一层

嗯，这招是最后的杀手锏。虽然会损失一些加速效果，但能保住精度。

3.7 验证加速效果

精度没问题了，还得看看速度。INT8量化最大的价值就是快。

import time

def benchmark(model, input_tensor, num_iterations=1000):
    model.eval()
    with torch.no_grad():
        # 预热
        for _ in range(100):
            _ = model(input_tensor)

        # 计时
        start = time.time()
        for _ in range(num_iterations):
            _ = model(input_tensor)
        end = time.time()

    avg_time = (end - start) / num_iterations * 1000  # 毫秒
    return avg_time

input_fp32 = torch.randn(1, 3, 224, 224)
input_int8 = torch.quantize_per_tensor(input_fp32, scale=1.0, zero_point=0, dtype=torch.quint8)

fp32_latency = benchmark(fp32_model, input_fp32)
int8_latency = benchmark(int8_model, input_int8)

print(f"FP32延迟: {fp32_latency:.2f} ms")
print(f"INT8延迟: {int8_latency:.2f} ms")
print(f"加速比: {fp32_latency / int8_latency:.2f}x")

一般来说，在CPU上，INT8量化能带来2-4倍的加速。如果用了AVX512或者VNNI指令集，加速比能到4-6倍。我在一个工业检测项目里，把模型从FP32换成INT8，延迟从120ms降到了35ms，精度只掉了0.1%。客户当场就拍板了。

3.8 总结一下

静态量化这条路，说难不难，说简单也不简单。核心就三点：

  • 校准集要选对，别拿训练集随便糊弄。
  • Observer要选好，HistogramObserver往往比MinMaxObserver更稳。
  • 敏感层要手动处理，该跳过的跳过，该per-channel的per-channel。

你按这个流程走一遍，基本不会出大问题。如果还掉点，那就得看看是不是模型本身对量化不友好——比如用了太多ReLU6或者Sigmoid，这些激活函数的数值范围天生就难量化。嗯，那是另一个话题了，咱们后面再聊。

← 上一章 📖 返回目录 下一章 →