第58篇：昇腾NPU量化实战——从FP32到INT8的完整指南

量化是把模型从高精度（FP32）转成低精度（INT8/INT4）的技术，可以在几乎不损失精度的情况下，把模型体积缩小4_{8倍，推理速度提升2}4倍。

核心原则：不要为了量化而量化。先试BF16，再试INT8静态，最后才考虑QAT。

---

一、量化的核心概念与选型策略

1. 昇腾910B 精度性能对比

昇腾NPU拥有专用的 Matrix Unit（矩阵单元），专门加速低精度计算。

精度	算力 (TFLOPS/TOPS)	显存占用	速度提升	适用场景	风险
FP32	40 TFLOPS	高 (基准)	1x	调试、数值敏感层	慢，显存大
BF16	400 TFLOPS	中 (2x)	~2x	首选方案，训练/推理	极低
FP16	400 TFLOPS	中 (2x)	~2-3x	部分CV模型	易溢出 (Range窄)
INT8	800 TOPS	低 (4x)	~4-8x	大规模部署，实时推理	需校准，有精度损
INT4	1600 TOPS	极低 (8x)	~8-16x	端侧/资源极度受限	精度损失大，需特殊算子

关键洞察：对于LLM和大多数Transformer模型，BF16 是性价比最高的选择（无需校准，几乎无损）。只有当显存或带宽成为瓶颈时，才考虑 INT8。

2. 选型决策树

---

二、PTQ后训练量化（最常用，推荐首选）

PTQ (Post-Training Quantization)：在已有模型上直接转换，无需重新训练。

方案A：BF16 (最简单，强烈推荐)

如果你的昇腾环境支持BF16（910B/910A均支持），这是第一选择。它不需要校准数据，精度几乎无损。

import torch
import torch.nn as nn

def convert_to_bf16(model):
    """
    将模型转换为BF16
    
    注意：某些层（如Softmax, LayerNorm）建议保留FP32以防止数值不稳定
    """
    model = model.eval()
    
    # 全局转换
    model = model.to(torch.bfloat16)
    
    # 保护关键层 (可选)
    for name, module in model.named_modules():
        if isinstance(module, (nn.Softmax, nn.LayerNorm)):
            module.to(torch.float32)
            
    return model

方案B：INT8 静态量化 (需要校准数据)

适用于对延迟极其敏感的在线服务。

1. 准备校准数据

• 数量: 100 ~ 500 张代表性样本。
• 质量: 覆盖真实分布，避免极端异常值。
• 格式: 必须与推理输入一致。

2. 执行量化流程 (使用 CANN 工具链)

import torch
from cann.quantization import Calibrator, StaticQuantizer
from cann import Compiler

class INT8Quantizer:
    def __init__(self, model, calib_loader):
        self.model = model.eval()
        self.calib_loader = calib_loader
        self.calibrator = Calibrator()
        
    def calibrate(self, num_samples=100):
        print(f"开始校准 {num_samples} 条数据...")
        with torch.no_grad():
            for i, (data, _) in enumerate(self.calib_loader):
                if i >= num_samples:
                    break
                # 关键点：校准时用FP32跑一遍，收集统计信息
                _ = self.model(data.npu())
                
        self.calibrator.finish_calibration()
        print("校准完成，Scale/ZeroPoint已生成")
        return self
        
    def quantize_and_compile(self, output_path="model_int8.om"):
        """
        使用 ATC 编译器生成 .om 模型
        """
        compiler = Compiler(
            model=self.model,
            output=output_path,
            precision_mode="allow_int8",  # 启用INT8模式
            calibration_tool=self.calibrator,
            op_select_implmode="high_precision", # 优先保证精度
        )
        
        quantized_model = compiler.compile()
        print(f"✅ 量化模型已保存至: {output_path}")
        return quantized_model

# ===== 实战示例 =====
# 假设 model 是已经加载好的 PyTorch 模型
# calib_loader 包含 100 张真实图片

quantizer = INT8Quantizer(model, calib_loader)
quantizer.calibrate(num_samples=100)
int8_model = quantizer.quantize_and_compile("resnet50_int8.om")

3. 精度验证与调优

如果精度下降超过 0.5% (分类任务) 或 1% (回归任务)，请尝试以下策略：

1. 增加校准数据: 从100张增加到500张。
2. 调整校准算法: 尝试 percentile 代替默认的 minmax (抗噪性更好)。
3. 混合精度: 仅对敏感层（如输出层）保持FP16/FP32。
4. 回退方案: 如果无法接受损失，立即切换回 BF16。

---

三、QAT 量化感知训练 (精度兜底)

QAT (Quantization-Aware Training)：在训练过程中模拟量化噪声，让模型“习惯”低精度。

适用场景：PTQ导致精度大幅下降（>1%），且无法通过调整参数解决。
代价：需要重新训练，耗时增加。

1. 原理

在训练时插入 FakeQuantize 节点，模拟INT8的截断效果。模型会自适应地学习如何在这种噪声下工作。

2. 代码实现

import torch
import torch.nn as nn
from cann.quantization import FakeQuantize, QuantAwareTrainer

class QATWrapper(nn.Module):
    def __init__(self, model):
        super().__init__()
        self.model = model
        # 定义伪量化节点 (模拟INT8行为)
        self.fake_quant_input = FakeQuantize(bits=8, mode='symmetric')
        self.fake_quant_output = FakeQuantize(bits=8, mode='symmetric')
        
    def forward(self, x):
        # 输入伪量化
        x = self.fake_quant_input(x)
        
        # 正常前向传播
        x = self.model(x)
        
        # 输出伪量化
        x = self.fake_quant_output(x)
        
        return x

def train_qat(model, train_loader, epochs=10, lr=1e-3):
    """
    QAT 训练流程
    """
    qat_model = QATWrapper(model).to("npu")
    optimizer = torch.optim.Adam(qat_model.parameters(), lr=lr)
    criterion = nn.CrossEntropyLoss()
    
    qat_model.train()
    for epoch in range(epochs):
        for data, target in train_loader:
            data, target = data.npu(), target.npu()
            
            optimizer.zero_grad()
            output = qat_model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            
        print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
        
    return qat_model

def freeze_and_export(qat_model, output_path="model_int8_qat.om"):
    """
    冻结量化参数并导出OM
    """
    qat_model.eval()
    
    # 提取伪量化节点的 Scale/ZeroPoint
    scales = {}
    zero_points = {}
    
    for name, module in qat_model.named_modules():
        if hasattr(module, 'scale'):
            scales[name] = module.scale.detach()
            zero_points[name] = module.zero_point.detach()
            
    print(f"提取了 {len(scales)} 个量化参数")
    
    # 使用 CANN Compiler 进行真量化转换
    # 注意：具体API可能随CANN版本变化，此处为示意
    from cann import Compiler
    compiler = Compiler(
        model=qat_model,
        output=output_path,
        precision_mode="allow_int8",
        # 传入冻结后的参数
        frozen_scales=scales,
        frozen_zero_points=zero_points,
    )
    
    final_model = compiler.compile()
    print(f"✅ QAT模型已导出: {output_path}")
    return final_model

---

四、常见坑点与解决方案

1. 精度突然暴跌

• 原因: 校准数据分布与测试数据不一致（例如训练集全是白天图片，校准集用了晚上图片）。
• 解决: 确保校准数据覆盖所有真实场景（光照、角度、类别平衡）。

2. NPU利用率低

• 原因: INT8算子未正确融合，或者使用了不支持INT8的自定义算子。
• 解决:
  • 检查 op_not_support.log。
  • 使用 --fusion_switch_file 强制融合。
  • 确认使用的算子在昇腾INT8算子列表中。

3. 推理结果全为0或NaN

• 原因: Scale因子计算错误，或者动态范围过小。
• 解决:
  • 切换到 percentile 校准模式（忽略极值）。
  • 检查输入数据是否归一化（通常需 [0, 1] 或 [-1, 1]）。

4. 显存反而变大

• 原因: 开启了动态Shape或未开启内存复用。
• 解决: 设置 ASCEND_RT_MEMORY_REUSE=1 并在ATC编译时指定固定Shape。

---

五、总结：最佳实践路径

1. 第一步: 尝试 BF16。
   • 910B原生支持，速度快2倍，显省一半，几乎无损。
   • 代码改动最小：model.to(torch.bfloat16)。
2. 第二步: 如果显存不够，尝试 INT8 PTQ。
   • 准备100-500条校准数据。
   • 使用 Calibrator 进行静态校准。
   • 验证精度，若损失<0.5%则部署。
3. 第三步: 如果PTQ精度损失大，且业务允许重训，使用 QAT。
   • 包装模型，插入FakeQuantize。
   • 微调训练几轮。
   • 冻结参数导出OM。
4. 第四步: 极端场景（端侧/超低显存）再考虑 INT4。
   • 需要专门的算子支持和复杂的量化策略。

记住：量化不是银弹。BF16 通常是昇腾NPU上最好的平衡点。只有在显存或带宽成为硬性瓶颈时，才引入INT8的复杂性。