什么是模型量化（Model Quantization）

最新推荐文章于 2025-05-10 11:29:03 发布

彬彬侠

最新推荐文章于 2025-05-10 11:29:03 发布

阅读量1.4k

点赞数 29

分类专栏：大模型文章标签： Quantization 模型量化模型压缩 pytorch python

本文链接：https://blog.csdn.net/u013172930/article/details/147386286

版权

大模型专栏收录该内容

99 篇文章

订阅专栏

模型量化（Model Quantization）是一种模型压缩和加速技术，通过将模型中的高精度数值（通常是32位浮点数，FP32）转换为低精度表示（如8位整数，INT8，或更低的位数），来减少模型的存储需求、计算量和推理延迟，同时尽量保持模型的精度。量化广泛应用于深度学习模型的部署，特别是在资源受限的设备（如移动端、嵌入式设备）上。

核心概念

量化类型：
- 权重量化：仅对模型的权重进行量化，推理时仍可能使用浮点计算。
- 激活量化：对模型的激活值（即中间层的输出）也进行量化，通常与权重量化结合，形成全量化模型。
- 混合精度量化：部分层使用低精度，部分层保留高精度，以平衡性能和精度。
量化方式：
- 均匀量化：将浮点数映射到固定间隔的整数表示，常见于INT8量化。
- 非均匀量化：使用非线性映射（如对数量化），适合某些特定分布的权重或激活。
- 静态量化 vs 动态量化：
  - 静态量化：在训练后，预先确定量化参数（如缩放因子和零点）。
  - 动态量化：在推理时动态计算激活的量化参数，适合激活值分布变化较大的场景。
量化公式：
均匀量化的基本公式为：
$\text{round}\left(\frac{x - z}{s}\right)$
$\approx s \cdot q + z$
其中：
- $x$ ：原始浮点数值。
- $q$ ：量化后的整数值。
- $s$ ：缩放因子（scale），控制量化范围。
- $z$ ：零点（zero point），用于偏移非对称量化。
量化感知训练（QAT） vs 训练后量化（PTQ）：
- QAT：在训练过程中模拟量化效果，调整模型参数以适应量化带来的误差，精度更高。
- PTQ：在训练完成后直接对模型进行量化，简单但可能导致精度下降。

优点

降低存储需求：INT8模型比FP32模型占用内存少约4倍。
加速推理：低精度计算（如INT8）在硬件上更快，尤其是支持向量化的硬件（如GPU、TPU、NPU）。
能耗优化：减少计算量，降低设备功耗，适合边缘设备。

缺点

精度损失：量化可能导致模型性能下降，尤其在极低位（如4位或二值化）时。
硬件依赖：量化加速需要硬件支持（如ARM的NEON、NVIDIA的TensorRT）。
实现复杂性：QAT需要重新训练，PTQ需要仔细校准量化参数。

应用场景

移动设备：如手机上的图像分类、语音识别模型。
边缘设备：如物联网设备上的传感器数据处理。
实时推理：如自动驾驶中的目标检测。

举例

假设一个权重值为 $x = 3.14159$ （FP32），通过INT8量化：

量化范围为 $[- 128, 127]$ ，缩放因子 $\frac{\text{max}(|x|)}{127}$ ，零点 $z = 0$ （对称量化）。
计算量化值： $\text{round}\left(\frac{3.14159}{s}\right)$ 。
反量化近似： $\hat{x} = s \cdot q$ .

示例代码

以下是一个使用PyTorch进行静态训练后量化的示例，展示如何将一个简单的CNN模型量化为INT8。代码包括模型定义、量化配置和推理过程。

import torch
import torch.nn as nn
import torch.quantization
import torchvision
import torchvision.transforms as transforms

# 定义一个简单的CNN模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, 3, 1)
        self.relu1 = nn.ReLU()
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 3, 1)
        self.relu2 = nn.ReLU()
        self.fc = nn.Linear(32 * 5 * 5, 10)

    def forward(self, x):
        x = self.pool(self.relu1(self.conv1(x)))
        x = self.pool(self.relu2(self.conv2(x)))
        x = x.view(-1, 32 * 5 * 5)
        x = self.fc(x)
        return x

# 设置设备
device = torch.device("cpu")  # 量化通常在CPU上进行

# 加载预训练模型（假设已训练）
model = SimpleCNN().to(device)
model.eval()

# 准备量化配置
model.qconfig = torch.quantization.get_default_qconfig('fbgemm')  # 使用fbgemm后端，适合x86 CPU
torch.quantization.fuse_modules(model, [['conv1', 'relu1'], ['conv2', 'relu2']], inplace=True)  # 融合Conv+ReLU层

# 转换为量化准备状态
model_quant = torch.quantization.prepare(model, inplace=False)

# 校准量化参数（使用少量数据模拟输入分布）
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
calib_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
calib_loader = torch.utils.data.DataLoader(calib_dataset, batch_size=32, shuffle=False)

with torch.no_grad():
    for inputs, _ in calib_loader:
        inputs = inputs.to(device)
        model_quant(inputs)  # 运行前向传播以收集激活统计信息
        break  # 仅用少量数据校准

# 执行量化
model_quant = torch.quantization.convert(model_quant, inplace=False)

# 测试量化模型
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)

correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model_quant(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of quantized model: {100 * correct / total}%')

# 保存量化模型
torch.jit.save(torch.jit.script(model_quant), "quantized_model.pt")