PyTorch 模型精度调优工具

由于浮点转定点过程中存在误差，当您在使用量化训练工具时，难免会碰到量化模型精度掉点问题。通常来说，造成掉点的原因有：

原有浮点模型不利于量化，如存在共享 op 或共享结构。
QAT 网络结构或配置异常，如模型中存在没有 fuse 的 pattern，没有设置高精度输出等。
某些算子对量化比较敏感，该算子的量化误差在前向传播过程中逐层累积，最终导致模型输出误差较大。

针对上述情况，量化训练工具提供了精度调优工具来帮助您快速定位并解决精度问题，主要包括如下：

模型结构检查：检查模型中是否存在共享 op、没有 fuse 的 pattern 或者不符合预期的量化配置。
使用 QuantAnalysis 类自动比对分析两个模型：通过对比定位到量化模型中异常算子或者量化敏感 op。
使用ModelProfiler 类和 HbirModelProfiler 类获得模型中每一个 op 的数值特征信息：获取的信息包括输入输出的最大最小值等。这两个类的功能完全一致，区别在于 HbirModelProfiler 仅接受 qat hbir 模型作为输入。通常您无需手动调用该模块，可以直接通过 QuantAnalysis.run 来获得两个模型的数值信息。

快速上手

当碰到量化模型精度掉点问题时，我们推荐按照如下的流程使用精度调优工具。

检查模型中是否存在不利于量化的结构或者异常配置。
使用 QuantAnalysis 模块进行分析，具体步骤如下：

1). 找到一个基准模型和待分析模型输出相差最大的那个输入(即bad case)作为模型的输入。

2). 进行量化敏感度分析，目前的经验是 L1 敏感度排序前 n 个通常为量化敏感 op（不同的模型 n 的数值不一样，因此暂无自动确定的方法，需要手动尝试，如前 10 个，20 个...）。将量化敏感 op 设置高精度量化（如 int16 量化），重新进行量化流程。

3). 或者逐层比较两个模型的输入输出等信息，检查是否存在数据范围过大或者 scale 不合理等量化异常的 op，如某些具有物理含义的 op 应设置固定 scale。
当您碰到部署一致性问题时，QuantAnalysis 模块也支持分析 hbir 模型，接口使用和分析流程可以参考部署一致性分析说明章节。

整体的流程图如下：

一个完整的例子如下：

from horizon_plugin_profiler import QuantAnalysis
from horizon_plugin_profiler.utils.entities import Metric

import torch
from torch import nn
from torch.quantization import DeQuantStub, QuantStub

from horizon_plugin_pytorch import set_march, qint8
from horizon_plugin_pytorch.quantization import FakeQuantState
from horizon_plugin_pytorch.quantization import hbdk4 as hb4
from horizon_plugin_pytorch.quantization import (
    prepare,
    set_fake_quantize,
    get_qconfig,
)
from horizon_plugin_pytorch.quantization.qconfig_setter import *


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Conv2d(3, 3, 1)
        self.relu = nn.ReLU()
        self.quant = QuantStub()
        self.dequant = DeQuantStub()

    def forward(self, x):
        x = self.quant(x)
        x = self.conv(x)
        x = self.relu(x)
        x = torch.nn.functional.interpolate(
            x, scale_factor=1.3, mode="bilinear", align_corners=False
        )
        x = self.dequant(x)
        return x

data = torch.rand((1, 3, 32, 32))
float_net = Net()
float_net(data)

set_march("nash-e")


############################### 模型结构检查 ##############################
# 确认提示的异常层是否符合预期
calib_net = prepare(
    float_net,
    data,
    qconfig_setter=QconfigSetter(
        get_qconfig(),
        [
            ModuleNameTemplate({"": qint8}),
            ConvDtypeTemplate(),
            MatmulDtypeTemplate(),
        ],
    ),
)
##########################################################################

# 进行 calibration。这里有两种场景。

# 场景 1：若您还未进行过calibration，请先进行 calibration。
set_fake_quantize(calib_net.eval(), FakeQuantState.CALIBRATION)
calib_net(data)

# 场景2：若您已进行过calibration，可以参考如下直接load权重，注意此处参数需要替换为您实际的模型权重路径
# calib_ckpt = torch.load("/your_calib_ckpt_path")
# calib_net.load_state_dict(calib_ckpt)

float_net.eval()
# 重要！！！将 calibration 模型置为 validation 状态
set_fake_quantize(calib_net.eval(), FakeQuantState.VALIDATION)

# 导出 hbir 模型
qat_hbir = hb4.export(calib_net, (data,))

############################### quant analysis ############################

# 1. 初始化
qa = QuantAnalysis(
    baseline_model=float_net,
    analysis_model=calib_net,
    analysis_model_type="fake_quant",
    device_ids=0,  # 仅支持单 GPU，多机/多卡请参考多机多卡章节
    out_dir="./floatvsqat",
)

# 也支持对比 qat 和 qat hbir
# qa = QuantAnalysis(
#     baseline_model=calib_net,
#     analysis_model=qat_hbir,
#     analysis_model_type="export",
#     device_ids=0,  # 仅支持单 GPU，多机/多卡请参考多机多卡章节
#     out_dir="./qatvshbir",
# )

# 2. 若有已知的 badcase，可以通过该接口直接设置此 badcase 输入
qa.set_bad_case(data)

# 实际场景下推荐使用 auto_find_bad_case 在整个 dataloader 上搜索 bad case
# 也支持设置 num_steps 参数来控制搜索的范围
# qa.auto_find_bad_case(your_dataloader, num_steps=100)

# 3. 运行两个模型
qa.run()

# 4. 两个模型逐层比较。确认产出物中 advice 列提示的异常层是否符合预期
qa.compare_per_layer()

# 5. 计算敏感度节点。可以将 qint8-qint16 收益排名靠前的节点设置高精度来提升量化模型精度
qa.sensitivity(use_sensitivity_v2=True)

# 6. 可选。根据敏感度结果自动搜索需要提升到 int16 的算子
# outputs_config 的 key 为模型实际的输出名字，本例为单输出模型，名字为 ""
qa.tune_bad_case(
    outputs_config={
        "": {
            "metric": Metric.ATOL,
            "threshold": 0.2,
            "max_tuned_stubs": 10,
        },
    },
)

基于 loss metric 的推荐流程

上面的快速上手使用的是默认的 Metric.ATOL，它衡量的是单个 tensor 上的绝对误差。对于多输出网络，"某个 head 输出 ATOL 大" 和 "任务精度掉点" 之间往往没有直接对应关系。

因此，我们推荐您优先注册一个与最终任务目标一致的自定义 loss metric，并围绕这个 loss 做 debug。这样可以直接围绕任务目标定位问题，而不是只看某个输出上的局部误差。

两种常见的 loss metric 写法

1. 直接使用真实 GT 计算 loss

让模型的输出里额外携带真实 GT，然后在 metric 内部从 output1 中拆出 GT，再和 output2 中对应的量化预测结果计算 loss。

import torch.nn.functional as F
from horizon_plugin_profiler.utils.entities import Metric


@Metric.register("ce_loss_with_gt", False, "all")
def ce_loss_with_gt(output1, output2):
    gt_label = output1["label"]
    qat_logits = output2["logits"]
    return F.cross_entropy(qat_logits, gt_label)

2. 先用浮点模型输出构造 pseudo GT，再计算 loss

根据 output1 中的浮点预测结果构造 pseudo GT，再用它和 output2 中的量化预测结果计算 loss。

import torch.nn.functional as F
from horizon_plugin_profiler.utils.entities import Metric


@Metric.register("distill_loss", False, "all")
def pseudo_gt_ce_loss(output1, output2):
    float_logits = output1["logits"]
    qat_logits = output2["logits"]

    pseudo_label = float_logits.argmax(dim=-1)
    return F.cross_entropy(qat_logits, pseudo_label)

怎么选：

如果您有可靠的 GT，并且更关心任务精度（精度调优），用「真实 GT loss」。
如果您没有 GT，或者当前目标是定位量化引入的误差（一致性分析或精度调优），用「浮点构造 pseudo GT 的 loss」。

多机多卡

QuantAnalysis 工具已支持多机多卡。若您已有 torch.nn.parallel.DistributedDataParallel 构建的训练环境，您只需将 train 函数替换成示例中的 quant_analysis 函数即可。

import os
import sys
import time
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.optim as optim
import torch.multiprocessing as mp
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import Dataset, DataLoader
from torch.utils.data.distributed import DistributedSampler

from horizon_plugin_pytorch.quantization import (
    QuantStub,
    prepare,
    QconfigSetter,
    set_fake_quantize,
    FakeQuantState,
    get_qconfig,
    observer_v2,
)
from horizon_plugin_pytorch.quantization.qconfig_setter import ModuleNameTemplate
from horizon_plugin_pytorch.march import set_march
from horizon_plugin_pytorch.dtype import qint8
from torch.ao.quantization import DeQuantStub
from horizon_plugin_profiler import QuantAnalysis
from horizon_plugin_profiler.utils.entities import Metric

# 示例数据集，debug 时请使用评测数据集
class ExampleDataset(Dataset):
    def __init__(self, size=10000, input_size=32):
        self.size = size
        self.data = torch.randn(size, 3, input_size, input_size)

    def __len__(self):
        return self.size

    def __getitem__(self, idx):
        return self.data[idx]


# 模型定义
class ConvNet(nn.Module):
    def __init__(self, num_classes=10):
        super(ConvNet, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        self.fc = nn.Linear(8 * 8 * 32, num_classes)
        self.quant = QuantStub()
        self.dequant = DeQuantStub()

    def forward(self, x):
        x = self.quant(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = x.reshape(x.size(0), -1)
        x = self.fc(x)
        x = self.dequant(x)
        return x


def setup(rank, world_size, master_addr, master_port):
    """初始化分布式环境"""
    os.environ["MASTER_ADDR"] = master_addr
    os.environ["MASTER_PORT"] = str(master_port)

    # 初始化进程组
    dist.init_process_group(backend="nccl", rank=rank, world_size=world_size)
    torch.cuda.set_device(rank)  # 设置当前GPU


def cleanup():
    """清理分布式训练环境"""
    dist.destroy_process_group()


def quant_analysis(rank, world_size, config):
    setup(rank, world_size, config["master_addr"], config["master_port"])

    # 设置目标硬件平台代号，注意此处的 march 区分 nash-e/m/p
    set_march("nash-e")
    float_net = ConvNet()

    # 准备数据，需要使用 DistributedSampler
    dataset = ExampleDataset(size=10000)
    sampler = DistributedSampler(
        dataset,
        num_replicas=world_size,
        rank=rank,
        shuffle=False,
    )
    dataloader = DataLoader(
        dataset,
        batch_size=1,  # 建议 debug 时设置 batch = 1
        sampler=sampler,
        num_workers=config["num_workers"],
        pin_memory=True,
    )

    # 加载训练好的浮点权重，注意此处的参数需要替换为您实际的模型权重路径
    float_ckpt = torch.load("/your_float_ckpt_path")
    float_net.load_state_dict(float_ckpt)

    # 将浮点模型转 calib 模型
    example_inputs = torch.rand((1, 3, 32, 32))
    calib_net = prepare(
        float_net,
        example_inputs,
        QconfigSetter(
            reference_qconfig=get_qconfig(observer=observer_v2.MSEObserver),
            templates=[
                ModuleNameTemplate({"": qint8}),
            ],
        ),
    )

    # 加载 calibration 权重，注意此处的参数需要替换为您实际的模型权重路径
    calib_ckpt = torch.load("/your_calib_ckpt_path")
    calib_net.load_state_dict(calib_ckpt)

    float_net.eval()
    # 重要！！！将 calibration 模型置为 validation 状态
    set_fake_quantize(calib_net.eval(), FakeQuantState.VALIDATION)

    # 进行 debug
    qa = QuantAnalysis(
        baseline_model=float_net,
        analysis_model=calib_net,
        analysis_model_type="fake_quant",
        device_ids=rank,  # 将 device_ids 设置为当前 rank
        out_dir=config["output_dir"],
    )
    qa.auto_find_bad_case(
        data_generator=dataloader,
        num_steps=100,
        topk=10,
    )
    qa.run(metric=Metric.ATOL)
    qa.compare_per_layer()
    qa.sensitivity(metric=Metric.ATOL, use_sensitivity_v2=True)

    # 清理分布式环境
    cleanup()


def main():
    import argparse

    parser = argparse.ArgumentParser(description="Multi-Node QuantAnalysis")
    parser.add_argument(
        "--nnodes", type=int, default=1, help="number of nodes in the cluster"
    )
    parser.add_argument(
        "--nproc_per_node",
        type=int,
        default=torch.cuda.device_count(),
        help="number of GPUs per node",
    )
    parser.add_argument(
        "--node_rank",
        type=int,
        default=0,
        help="rank of this node in the cluster (0-indexed)",
    )
    parser.add_argument(
        "--master_addr",
        type=str,
        default="localhost",
        help="IP address of the master node (node with rank 0)",
    )
    parser.add_argument(
        "--master_port",
        type=int,
        default=29500,
        help="port on master node for communication",
    )
    parser.add_argument(
        "--num_workers",
        type=int,
        default=4,
        help="number of data loader workers per GPU",
    )
    parser.add_argument(
        "--output_dir",
        type=str,
        default="./quant_analysis_output",
        help="directory to save debug outputs",
    )

    args = parser.parse_args()

    os.makedirs(args.output_dir, exist_ok=True)

    config = {
        "master_addr": args.master_addr,
        "master_port": args.master_port,
        "num_workers": args.num_workers,
        "output_dir": args.output_dir,
    }

    # 计算全局world size
    world_size = args.nnodes * args.nproc_per_node

    # 打印配置信息
    if args.node_rank == 0:
        print(f"Starting multi-node QuantAnalysis with:")
        print(f"  Nodes: {args.nnodes}")
        print(f"  GPUs per node: {args.nproc_per_node}")
        print(f"  Total GPUs: {world_size}")
        print(f"  Master address: {args.master_addr}:{args.master_port}")

    # 启动分布式 debug
    mp.spawn(
        quant_analysis, args=(world_size, config), nprocs=args.nproc_per_node, join=True
    )


if __name__ == "__main__":
    main()

执行命令：

python quant_analysis_ddp.py \
  --nnodes <节点数> \
  --nproc_per_node <每个节点的 GPU 数> \
  --node_rank <当前节点 rank> \
  --master_addr <主节点 IP> \
  --master_port 29500

API Reference

模型结构检查

# from horizon_plugin_pytorch.utils.check_model import check_qat_model

def check_qat_model(
    model: torch.nn.Module,
    example_inputs: Any,
    save_results: bool = False,
    out_dir: Optional[str] = None,
):

检查 calibration/qat 模型中是否存在不利于量化的结构以及量化 qconfig 配置是否符合预期。

参数

model: 待检查模型。
example_inputs: 模型输入。
save_results: 是否将检查结果保存到 txt 文件。默认 False。
out_dir: 结果文件 'model_check_result.txt' 的保存路径。默认空，保存到 .model_check_results/ 目录下。

输出

屏幕输出：检查出的异常层。
model_check_result.txt：在 save_results = True 时生成。主要由 5 部分组成：

1). 未 fuse 的 pattern。

2). 每个 module 的调用次数。正常每个 op 仅调用 1 次，0 表示未被调用，超过 1 次则表示被共享了多次。未调用或者共享多次的会有异常提示。

3). 每个 op 输出的 qconfig 配置。

4). 每个 op weight（如果有的话）的 qconfig 配置。

5). 异常 qconfig 提示（如果有的话）。

Fusable modules are listed below:
name    type
------  -----------------------------------------------------
conv    <class 'horizon_plugin_pytorch.nn.qat.conv2d.Conv2d'>
relu    <class 'horizon_plugin_pytorch.nn.qat.relu.ReLU'>

All modules in the model run exactly once.

Each layer out qconfig:
+---------------+-----------------------------------------------------------+---------------+---------------+----------------+-----------------------------+
| Module Name   | Module Type                                               | Input dtype   | out dtype     | ch_axis        | observer                    |
|---------------+-----------------------------------------------------------+---------------+---------------+----------------+-----------------------------|
| quant         | <class 'horizon_plugin_pytorch.nn.qat.stubs.QuantStub'>   | torch.float32 | qint8         | -1             | MovingAverageMinMaxObserver |
| conv          | <class 'horizon_plugin_pytorch.nn.qat.conv2d.Conv2d'>     | qint8         | qint8         | -1             | MovingAverageMinMaxObserver |
| relu          | <class 'horizon_plugin_pytorch.nn.qat.relu.ReLU'>         | qint8         | qint8         | qconfig = None |                             |
| dequant       | <class 'horizon_plugin_pytorch.nn.qat.stubs.DeQuantStub'> | qint8         | torch.float32 | qconfig = None |                             |
+---------------+-----------------------------------------------------------+---------------+---------------+----------------+-----------------------------+

Weight qconfig:
+---------------+-------------------------------------------------------+----------------+-----------+---------------------------------------+
| Module Name   | Module Type                                           | weight dtype   |   ch_axis | observer                              |
|---------------+-------------------------------------------------------+----------------+-----------+---------------------------------------|
| conv          | <class 'horizon_plugin_pytorch.nn.qat.conv2d.Conv2d'> | qint8          |         0 | MovingAveragePerChannelMinMaxObserver |
+---------------+-------------------------------------------------------+----------------+-----------+---------------------------------------+

注解

prepare 接口已集成该检查。请您关注此接口输出的检查结果，并根据检查结果对模型做针对性的调整。

QuantAnalysis 类

QuantAnalysis 类可以自动寻找两个模型输出最大的 bad case，并以此作为输入，逐层比较两个模型的输出。此外，QuantAnalysis 类还提供计算敏感度功能，您可以尝试将敏感度排名 topk 的节点设置高精度，如 int16 量化，来提升量化模型精度。

class QuantAnalysis(object):
    def __init__(
        self,
        baseline_model: Union[torch.nn.Module, HbirModule],
        analysis_model: Union[torch.nn.Module, HbirModule],
        analysis_model_type: str,
        device_ids: Optional[int] = None,
        post_process: Optional[Callable] = None,
        out_dir: Optional[str] = None,
        metric_list: Optional[List[_Metric]] = None,
    )

参数

baseline_model: 基准模型（高精度）。
analysis_model：待分析的模型（精度掉点）。
analysis_model_type: 待分析的模型类型。支持输入：
- fake_quant：支持以下两种情况：
  - 待分析的模型可以是精度掉点的 calibration 模型，此时基准模型可以是原始浮点模型或者一个精度达标的 int8/int16 混合配置的 calibration 模型。
  - 待分析的模型是精度掉点的定点 hbir 模型，基准模型是对应的伪量化 hbir 模型。
- pre_export：待分析的模型是查表转定点的伪量化模型，基准模型是对应的原始伪量化模型。
- export：待分析的模型是伪量化 hbir 模型，基准模型是对应的查表转定点的伪量化模型。
- convert：待分析的模型是定点 hbir 模型，基准模型是对应的查表转定点的伪量化模型。
device_ids：对比分析时模型运行的 GPU 设备 index，仅支持单 GPU，多机/多卡请参考多机多卡章节。
post_process：模型后处理。
out_dir：指定比较结果的输出目录。默认 ./horizon_quant_analysis。
metric_list：参与比较的 metric 列表。默认 [Metric.L1, Metric.COSINE, Metric.ATOL]。可选的 metric 见 Metric 说明。

注意

由于 QAT 训练会改变模型 weight 分布，通常情况下，我们不建议您将浮点或 calibration 模型和 qat 模型做对比。
hbir 模型不支持敏感度计算，若您对比的是两个 hbir 模型，请勿调用 sensitivity 接口。

Metric 说明

metric_list、run、sensitivity 等接口中使用的 metric 均来自 horizon_plugin_profiler.utils.entities.Metric。当前内置的 metric 如下：

metric	取值范围	排序方向	适用场景
`Metric.ATOL`	[0, $+\infty$ ]	越大越敏感	绝对误差，默认使用
`Metric.L1`	[0, $+\infty$ ]	越大越敏感	平均绝对误差，适合 bbox 回归等任务
`Metric.COSINE`	[0, 1]	越接近 0 越敏感	余弦相似度，适合分类等关注整体分布的任务
`Metric.MSE`	[0, $+\infty$ ]	越大越敏感	均方误差
`Metric.RTOL`	[0, $+\infty$ ]	越大越敏感	相对误差
`Metric.KL`	[0, $+\infty$ ]	越大越敏感	KL 散度
`Metric.SQNR`	(- $\infty$ , $+\infty$ ]	越小越敏感	量化信噪比，单位 dB

若内置 metric 无法满足需求，也可以通过 Metric.register 注册自定义 metric。注册后的 metric 可用于查找 badcase、敏感度计算等所有功能。

from horizon_plugin_profiler.utils.entities import Metric

@Metric.register(name, ascending, scope)
def custom_metric(output1, output2):
    ...

参数

name：metric 名称，用于展示和索引，不能与已有 metric 重名。注册后可通过 Metric.{name} 或 Metric.get_metric(name) 访问。
ascending：指标排序方向。True 表示值越大精度越好（如 COSINE、SQNR），False 表示值越大精度越差（如 L1、ATOL）。
scope：定义 metric 作用在单个 tensor 上，还是作用在整个模型输出结构上。
- "pertensor"：对每个 tensor 输出单独计算。工具会展开模型输出中的 leaf tensor，并使用 0、1、key 等名称记录输出。
- "all"：对整个模型输出结构计算一个整体分数。适用于输出结构复杂、希望用单个总分衡量整体误差的场景，最常见的就是 loss。此时输出名固定为 all。

其中 output1 和 output2 分别来自 baseline_model 和 analysis_model，但它们的粒度由 scope 决定：

当 scope="all" 时，output1 / output2 是两侧完整的输出结构。
当 scope="pertensor" 时，工具会先把输出展开成 tensor leaf，再逐个调用自定义函数，因此 output1 / output2 只是单个 tensor。

import torch.nn.functional as F
from horizon_plugin_profiler import QuantAnalysis
from horizon_plugin_profiler.utils.entities import Metric

@Metric.register("loss", False, "all")
def loss(output1, output2):
    return F.l1_loss(output1, output2, reduction="mean")

qa = QuantAnalysis(
    baseline_model=float_net,
    analysis_model=calib_net,
    analysis_model_type="fake_quant",
    metric_list=[Metric.loss],
)

注解

对于多输出网络，我们更推荐您注册一个与最终任务目标一致的 loss metric，并围绕它做 debug，而不是只看某个输出上的局部误差。具体原因和推荐流程见基于 loss metric 的推荐流程章节。

该类中各个 method 如下：

auto_find_bad_case

def auto_find_bad_case(
    self,
    data_generator: Iterable,
    num_steps: int = sys.maxsize,
    cached_attrs: Optional[Tuple[str, ...]] = None,
    dump_in_run: bool = False,
    topk: int = 1,
):

自动寻找导致两个模型输出最差的 badcase。

参数

data_generator：dataloader 或者一个自定义的迭代器，每次迭代产生一个数据。
num_steps：迭代 steps 次数。
cached_attrs：作为模型输入的某些属性。通常在时序模型中使用，如运行第二帧时，将第一帧的某些结果作为输入。
dump_in_run: 是否在运行过程中保存 badcase。为 True 时边找边写磁盘，速度较慢但没有 OOM 风险；为 False 时先在内存中保存、结束时统一落盘，速度较快但可能占用较多内存。多机多卡环境下强制为 True，单机单卡默认 False。
topk：每个输出、每种 metric 各保留多少个 badcase。默认 1。推荐设置 topk > 1，保留多个 badcase，再结合后续的 sensitivity(use_sensitivity_v2=True) 交叉验证。很多模型的问题并不只集中在单个最差样本上，只看 top-1 容易把视野锁死在某一个局部异常上，导致后续敏感度分析给出的结论不稳定。

注解

auto_find_bad_case 函数遍历传入的 data_generator，运行基准模型和待分析模型，计算每个输出在初始化时 metric_list 指定的各个 metric 上的比较结果，并找到在各个 metric 上比较结果最差的 topk 个 badcase 输入。

注意

旧版本中的 metric、device、custom_metric_func 和 custom_metric_order_seq 参数均已废弃。传入这些参数不会报错，但不再生效：

metric：badcase 不再在查找阶段按单一 metric 筛选，而是对 metric_list 中的每个 metric 各保留一份结果。选择使用哪个 metric 的 badcase，改为在 run / sensitivity 中通过 metric 参数指定。
device：改为在 QuantAnalysis 初始化时通过 device_ids 指定。
custom_metric_func / custom_metric_order_seq：自定义 metric 改为通过 Metric.register 注册，再传入初始化时的 metric_list，详见 Metric 说明。

输出

badcase_report.html：以 HTML 页面形式展示 badcase 报告，包括以下内容：
- 每个输出在各 metric 下的 topk badcase 索引及对应 metric 值的表格。
- 每个输出在各 metric 下所有 case 的统计信息（平均值、最差值）。
- 每个输出在各 metric 下 topk badcase 的统计信息（平均值、最差值）。
- 每个输出在各 metric 下 badcase 误差的分布直方图及百分位信息（如 99%、99.9%、99.99%）。
all_badcase_info.pt：保存的 BadCaseReport 对象，包含完整的 badcase 信息，可通过 torch.load 加载。
badcase 文件夹：该目录下保存了 badcase_report.html 中显示的各个 index 的输入，如 0.pt，16.pt 等。

返回值

BadCaseReport 对象，同时也会保存在 self.badcase_report 中。

set_bad_case

def set_bad_case(
    self,
    data: Any,
    baseline_model_cached_attr: Optional[Dict] = None,
    analysis_model_cached_attr: Optional[Dict] = None,
):

手动设置 badcase。

注意

通常情况下，我们建议您通过 auto_find_bad_case 函数寻找 badcase。若手动设置的 badcase 非真正的 badcase，分析工具很难找出量化敏感层。

参数

data: badcase 输入。
baseline_model_cached_attr：基准模型的 cached_attrs。
analysis_model_cached_attr：待分析模型的 cached_attrs。

load_bad_case

def load_bad_case(self, path: Optional[str] = None)

加载已保存的 badcase 报告。

参数

path：默认 None，直接从初始化时指定的 out_dir 目录中加载 all_badcase_info.pt。也可以传入一个本地目录，或者一个 http/https 链接（如集群上的产物路径），此时工具会先把该目录下的 all_badcase_info.pt、badcase 目录和 badcase_report.html 拷贝/下载到 out_dir，再从 out_dir 加载。多机多卡场景下仅 rank 0 负责拷贝/下载，其余 rank 在 barrier 处等待后从本地加载。

注解

该接口常用于复用一次已经跑完的 badcase 查找结果。例如在 convert 一致性分析中，先用 QuantAnalysis(qat_bc, quantized_bc, "convert") 找到 badcase，再用 QuantAnalysis(qat_export_pt, quantized_bc, "convert") 配合 load_bad_case() 基于同一个 badcase 跑敏感度分析。

set_model_profiler_dir

def set_model_profiler_dir(
    self,
    baseline_model_profiler_path: str,
    analysis_model_profiler_path: str,
):

手动指定 model_profiler 的输出保存路径。

某些情况下，在 QuantAnalysis 初始化之前，ModelProfiler 就已定义并运行，此时可以直接指定已有的 ModelProfiler 路径，跳过 QuantAnalysis 的 run 步骤，直接比较两个模型的输出。

参数

baseline_model_profiler_path：基准模型的 profiler 路径。
analysis_model_profiler_path：待分析模型的 profiler 路径。

run

def run(
    self,
    device: Optional[Union[torch.device, str, int, List[int]]] = None,
    index: Optional[int] = None,
    run_baseline_model: bool = True,
    run_analysis_model: bool = True,
    metric: Optional[_Metric] = None,
    run_on_cpu: bool = False,
    out_name: Optional[str] = None,
)

运行两个模型并分别保存模型中每一层的结果。

参数

device：该参数已废弃。通过 QuantAnalysis 初始化时的 device_ids 指定 GPU。
index：输入数据在 data_generator 中的 index。指定后将直接使用该 index 对应的 badcase，不再按 metric 选择。不能与 metric 同时指定。
run_baseline_model：是否运行基准模型。默认 True。
run_analysis_model：是否运行待分析模型。默认 True。
metric：使用哪个 metric 挑选出的 badcase 作为输入。默认 None，等价于 Metric.ATOL。
run_on_cpu：是否强制在 CPU 上运行模型。默认 False。当 analysis_model_type 为 export 或 convert 时，工具会自动使用 CPU，因为 hbir 模型与 torch CPU 结果对齐更好，与 torch CUDA 可能存在较大差异，用 CPU 推理得到的单算子误差更准确。
out_name：只在指定的某个输出上挑选 badcase。默认 None，即在所有输出中挑选最差的 badcase。仅在未指定 index 时生效。

注意

仅支持 auto_find_bad_case 找到并在 badcase_report.html 中显示的 index 作为 index 参数输入。

分析统计信息

在 run 接口被调用后，baseline_model 和 analysis_model 会使用 badcase 进行推理，并将模型每一层的输入输出保存在输出路径的 op_infos 文件夹下。您可以使用 torch.load 加载 opinfo 文件，可以得到算子的输入输出。使用 matplotlib 可以绘制对应的数值分布图。

import torch
import matplotlib.pyplot as plt

# 加载 opinfo
opinfo = torch.load("xxx.opinfo", weights_only=False)  # opinfo 包含任意 Python 对象，不仅是权重

input = opinfo.input
output = opinfo.output

# 画数值分布图
plt.hist(output[0].as_subclass(torch.Tensor).flatten().cpu().numpy(), bins=30, color='blue')
plt.title("Output Distribution")
plt.xlabel("Value")
plt.ylabel("Frequency")
plt.grid(True)
plt.savefig("output.png")

在分析单算子误差时，可以构造只包含一个算子的模型，将 opinfo 中的输入送入模型，对比模型输出和 opinfo 输出的差异，绘制散点图或直方图。

compare_per_layer

def compare_per_layer(
    self,
    prefixes: Tuple[str, ...] = None,
    types: Tuple[Type, ...] = None,
):

比较两个模型中每一层的结果。

参数

prefixes：指定 op 名字的前缀。
types：op 类型。

注解

通常您无需指定 prefixes 和 types 参数。若您基于一些先验经验，想跳过某些确定的、量化影响较小 op 的比较，或想节省时间，您可以通过两个参数，指定比较某些 op 或者某类 op。

输出

compare_per_layer_report_0.html：以 HTML 页面形式展示逐层比较结果，包括每层 metric 值的趋势图和详细数据表格。

compare_per_layer_out_0.txt: 以表格的形式展示模型中每层 layer 的具体信息，包括各种指标、数据范围、量化 dtype 等。从左到右每一列分别表示：

Index：op index。
mod_name：该 op 名字，若 op 为 module 类型，则显示该 module 在模型中的 prefix name，若为 function 类型，则不显示。
base_op_type：基准模型中该 op 的 type，可能是 module 类型或者 function 名称。
analy_op_type：待分析模型中该 op 的 type，可能是 module 类型或者 function 名称。
Shape：该 op 输出的 shape。
dtype：该 op 输出的数据类型。
qscale：该 op 输出的量化 scale。
L1：该 op 在两个模型中输出的 L1 距离。
COSINE：该 op 在两个模型中输出的余弦相似度。
ATOL：该 op 在两个模型中输出的绝对误差。
max_qscale_diff：该 op 在两个模型中输出最大相差了几个 scale。
base_model_min：基准模型中该 op 输出的最小值。
analy_model_min：待分析模型中该 op 输出的最小值。
base_model_max：基准模型中该 op 输出的最大值。
analy_model_max：待分析模型中该 op 输出的最大值。
base_model_mean：基准模型中该 op 输出的平均值。
analy_model_mean：待分析模型中该 op 输出的平均值。
same_in_qatbc_qdiff：该 op 在 qat bc 模型中相同位置的量化误差（以 scale 为单位）。仅在 export/convert 模式下有值。
same_in_intbc_qdiff：该 op 在定点 bc 模型中相同位置的量化误差（以 scale 为单位）。仅在 export/convert 模式下有值。

advice：对该 op 的诊断建议，包括数据范围过大、包含 inf 或 NaN、输出未设置高精度、clamp error 等。

+----+------------+--------------------------------------------------------------------+--------------------------------------------------------------------+----------------------------+---------------+-----------+-----------+-----------+-----------+-------------------+------------------+-------------------+------------------+-------------------+-------------------+--------------------+-----------------------+-----------------------+-----------+
|    | mod_name   | base_op_type                                                       | analy_op_type                                                      | shape                      | dtype         |    qscale |    COSINE |        L1 |      ATOL |   max_qscale_diff |   base_model_min |   analy_model_min |   base_model_max |   analy_model_max |   base_model_mean |   analy_model_mean | same_in_qatbc_qdiff   | same_in_intbc_qdiff   | advice    |
|----+------------+--------------------------------------------------------------------+--------------------------------------------------------------------+----------------------------+---------------+-----------+-----------+-----------+-----------+-------------------+------------------+-------------------+------------------+-------------------+-------------------+--------------------+-----------------------+-----------------------+-----------|
|  0 | quant      | torch.ao.quantization.stubs.QuantStub                              | horizon_plugin_pytorch.nn.qat.stubs.QuantStub                      | torch.Size([1, 3, 32, 32]) | qint8         | 0.0078404 | 0.9999922 | 0.0019772 | 0.0039202 |         0.5000016 |        0.0002798 |         0.0000000 |        0.9996471 |         0.9957269 |         0.4986397 |          0.4986700 |                       |                       |           |
|  1 | conv       | torch.nn.modules.conv.Conv2d                                       | horizon_plugin_pytorch.nn.qat.conv2d.Conv2d                        | torch.Size([1, 3, 32, 32]) | qint8         | 0.0056401 | 0.9999791 | 0.0020876 | 0.0092935 |         1.6477517 |       -0.7193903 |        -0.7162931 |        0.5436335 |         0.5414499 |        -0.0423445 |         -0.0413149 |                       |                       |           |
|  2 | relu       | torch.nn.modules.activation.ReLU                                   | torch.nn.modules.activation.ReLU                                   | torch.Size([1, 3, 32, 32]) | qint8         | 0.0056401 | 0.9999741 | 0.0009586 | 0.0088447 |         1.5681799 |        0.0000000 |         0.0000000 |        0.5436335 |         0.5414499 |         0.1555644 |          0.1557564 |                       |                       |           |
|  3 |            | horizon_plugin_pytorch.nn.interpolate.autocasted_interpolate_outer | horizon_plugin_pytorch.nn.interpolate.autocasted_interpolate_outer | torch.Size([1, 3, 41, 41]) | qint8         | 0.0056401 | 0.9924216 | 0.0160291 | 0.2094204 |        37.1305954 |        0.0000000 |         0.0000000 |        0.5149657 |         0.5301697 |         0.1550578 |          0.1559310 |                       |                       |           |
|  4 | dequant    | torch.ao.quantization.stubs.DeQuantStub                            | horizon_plugin_pytorch.nn.qat.stubs.DeQuantStub                    | torch.Size([1, 3, 41, 41]) | torch.float32 |           | 0.9924216 | 0.0160291 | 0.2094204 |                   |        0.0000000 |         0.0000000 |        0.5149657 |         0.5301697 |         0.1550578 |          0.1559310 |                       |                       |           |
+----+------------+--------------------------------------------------------------------+--------------------------------------------------------------------+----------------------------+---------------+-----------+-----------+-----------+-----------+-------------------+------------------+-------------------+------------------+-------------------+--------------------+--------------------+-----------------------+-----------------------+-----------+

compare_per_layer_out_0.csv: 以 csv 的格式展示每层的具体信息。内容和 txt 文件完全一致，csv 文件的存储格式方便您通过 excel 等软件打开分析。

sensitivity

def sensitivity(
    self,
    metric: Union[str, _Metric] = Metric.ATOL,
    prefixes: Optional[Tuple[str, ...]] = None,
    types: Optional[Tuple[Type, ...]] = None,
    output_names: Optional[Tuple[str, ...]] = None,
    use_sensitivity_v2: bool = False,
    sensitivity_method: str = "ablation",
):

模型中各个节点的敏感度排序。适用于 float 转 calibration 的精度掉点问题。

注解

做精度调优时，推荐您始终开启 use_sensitivity_v2=True。相比默认输出，它会额外拆分出截断和舍入误差，并直接给出每个节点从 int8 换成 int16 的收益，同时提供 csv 和 HTML 报告，更便于分析。下文的输出说明也以 v2 为准。

参数

metric：相似度排序的 metric，默认 Metric.ATOL。可选值见 Metric 说明。
prefixes：指定前缀的 op 跑敏感度。默认 None，跑所有 op 的敏感度。
types：指定类型的 op 跑敏感度。默认 None，跑所有 op 的敏感度。同时指定 prefixes 和 types 时，只有同时满足两个条件的 op 才会参与计算。
output_names：仅跑指定输出的敏感度。注意需使用 badcase_report.html 中显示的输出名字。默认 None，跑所有输出的敏感度。
use_sensitivity_v2：是否使用 v2 版敏感度，推荐设置为 True。开启后，除了单节点量化敏感度，还会额外拆分出 round / clip 误差，并给出该节点分别在 qint8 和 qint16 下的敏感度以及两者的差值，便于直接判断把该节点提升到 int16 能带来多少收益。仅支持 analysis_model_type="fake_quant"，因此一致性分析场景无法使用。
sensitivity_method：敏感度计算方法。仅在 use_sensitivity_v2=True 且 analysis_model_type="fake_quant" 时可选。
- "ablation"：默认方法，逐个改变 fake stub 状态并前向一次，观察输出误差。速度较慢，但一般不会爆显存。
- "grad_x_error"：使用 梯度 × 误差 估计敏感度，只需一次前向 + 反向，速度非常快，但对显存要求更高。该方法要求 metric 的 scope 为 "all"，且该 metric 必须返回可反向传播的标量 tensor。若自定义 metric 返回非 tensor、非标量 tensor 或不可导 tensor，会在运行时报错。

注解

grad_x_error 的原理是把网络在某个 stub 处切开，量化在该处引入误差 $\delta$ ，将下游网络与 loss 的复合函数在当前工作点做一阶 Taylor 展开，用 $\nabla g(y)^{\top}\delta$ 近似该 stub 对最终 loss 的影响。

需要注意的是，使用 grad_x_error 时，结果表中的 metric 列名为 GRAD_X_ERROR（并附带 GRAD_MAGNITUDE、ERROR_MAGNITUDE），而不是您传入的 metric 名字。

注意

旧版本中的 device 和 reserve 参数已废弃。传入这两个参数不会报错，但不再生效。device 请改为在 QuantAnalysis 初始化时通过 device_ids 指定；若需要查看不敏感的 op（可以尝试设置为 int8 以提升性能），请直接从结果表格的末尾往前看。

输出

结果文件按输出和 badcase 分别生成，命名为 output_{out_name}_case_{index}_sensitive_ops.txt / .csv / .pt，其中 out_name 为输出名字，index 为该 badcase 在 data_generator 中的 index。

注解

out_name 由模型输出结构自动推导：模型只返回单个 tensor 时为空字符串（文件名形如 output__case_...）；返回 list/tuple 时为 0、1；返回 dict 或 namedtuple 时为对应的 key，嵌套结构则以 - 连接，如 0-1。若使用 scope="all" 的 metric，输出名固定为 all。您可以通过 list(qa.badcase_report.output_to_badcase_info.keys()) 查看当前模型的实际输出名字，output_names 和 tune_bad_case 中需要使用这些名字。

除了每个 badcase 各自的结果，还会生成两份汇总表和一份 HTML 报告：

output_{out_name}_case_mean_sensitive_ops.* 和 output_{out_name}_case_worst_sensitive_ops.*：当 topk > 1 时，对该输出的多个 badcase 结果分别取平均值和最差值后的汇总表。相比单个 badcase 的结果，汇总表通常更稳定，更适合作为配置混合精度的依据。
sensitivity_v2_report.html：以 HTML 页面形式展示敏感度结果，包括各 metric 的排序柱状图和详细数据表格，页面中同样包含 mean 和 worst 敏感度表，列名可以交互排序。您可以通过排序后的变化趋势，决定从排序中的哪个算子开始把 qint8 设置为 qint16。

推荐优先查看 csv，可以综合不同 case 的敏感度、平均敏感度和最差敏感度一起分析精度问题。

文件中按照量化敏感度从高到低的顺序排列 op。主要列含义如下：

op_name：op 名字。
op_type：op 类型。
fake_stub_type：计算量化敏感的类型，包括：
- output：仅量化该 op 输出的量化敏感度。
- weight：仅量化该 op 权重的量化敏感度。
- input-{n}：仅量化该 op 第 n 个输入的量化敏感度。
metric 列：按 {量化方式}_{metric} 的形式展开成多列，metric 即您传入的 metric 名字，如 qint8_ATOL、qint16_ATOL、qint8-qint16_ATOL、round_ATOL、clip_ATOL、fp16_ATOL。各 metric 的取值范围和排序方向见 Metric 说明。其中：
- round / clip：分别表示只保留舍入误差、只保留截断误差时的敏感度，用于判断该节点的误差主要来自哪一种。
- qint8 / qint16 / fp16：该节点在对应 dtype 下的敏感度。
- qint8-qint16：两者的差值，数值越大说明把该节点从 int8 提升到 int16 的收益越大。结果默认按该列排序。
dtype：该 op 输出的量化 dtype。通常为 qint8/qint16/torch.float16。
flops：该 op 的计算量以及在整个模型计算量中的占比。

注解

旧版本兼容说明

若未开启 use_sensitivity_v2，工具会输出旧版格式的敏感度结果：文件名为 output_{out_name}_case_{index}_{metric}_sensitive_ops.txt（带 metric，且不生成 csv），表格中只有一列 metric 值，fake_stub_type 列名为 sensitive_type，dtype 列名为 quant_dtype。旧版结果不包含 round / clip 拆分和 qint8-qint16 收益列，也无法用于 tune_bad_case。

一致性分析（analysis_model_type 为 pre_export / export / convert）目前只能使用旧版敏感度。

返回值

一个 dict，key 为输出名字，value 为 SensitivityTable 对象的列表，每个 badcase 对应一个表。SensitivityTable 可以通过 sort_by_column 重新排序。

结果表格示例如下（省略了部分 metric 列）：

op_name           fake_stub_type  dtype  flops         clip_ATOL    round_ATOL   qint8_ATOL   qint16_ATOL  qint8-qint16_ATOL
----------------  --------------  -----  ------------  -----------  -----------  -----------  -----------  -----------------
conv              output          qint8  5184(98.18%)  0.045126150  0.066827238  0.066827238  0.000211666  0.066615572
conv              weight          qint8  5184(98.18%)  0.000000358  0.011085004  0.011085004  0.000082999  0.011002004
quant             output          qint8  0(0%)         0.000243107  0.008408447  0.008408447  0.000040362  0.008368085
_generated_add_1  output          qint8  0(0%)         0.276775519  0.004773577  0.276775519  0.271611373  0.005164146

您可以将 qint8-qint16 列排名前 n 的 op 配置为 int16 来尝试提升量化模型精度。

注解

若未开启 use_sensitivity_v2，返回值中每个 value 为敏感度 List，List 中每个元素是记录一个 op 敏感度信息的子 list，格式为 [op_name, sensitive_type, op_type, metric, dtype, flops]。

tune_bad_case

def tune_bad_case(
    self,
    outputs_config: Dict[str, Any],
    skip_prefix: Optional[Dict[str, List[str]]] = None,
):

基于 sensitivity v2 的结果，在当前 badcase 上按敏感度顺序模拟把 qint8 提升为 qint16，观察累计误差的改善情况。它解决的是"拿到敏感度表之后，还要自己搭一版实验才能看到真实收益"的问题。

具体流程为：读取 output_{out_name}_case_{case}_sensitive_ops.pt 中保存的 SensitivityTable，按 qint8-qint16_{metric} 排序，随后逐个尝试将候选 qint8 临时改为 qint16：

若本次提升让最终输出的 metric 变好，则保留该 qint16 配置，并记录累计收益；
若没有收益，则恢复原本的 qint8 dtype 和原 scale；
达到 threshold 或 max_tuned_stubs 后停止。

注意

该接口仅支持 analysis_model_type="fake_quant"。
调用前必须先执行 sensitivity(use_sensitivity_v2=True)，该接口依赖 v2 生成的 output_{out_name}_case_{index}_sensitive_ops.pt。若使用旧版敏感度，会因找不到该文件而报 FileNotFoundError。
多机多卡场景下仅 rank 0 执行实际搜索。

参数

outputs_config：按输出配置的搜索参数，key 为输出名字。单输出模型为空字符串 ""，多输出模型通常为 "0"、"1"，使用 scope="all" 的 metric 时为 "all"。每个输出的配置包含：
- metric：衡量 badcase 的 metric。
- threshold：metric 达到该阈值后停止搜索。
- max_tuned_stubs：最多调整多少个节点。
skip_prefix：跳过指定前缀的 op，key 为 op 名字前缀，value 为需要跳过的 fake_stub_type 列表，如 {"backbone": ["output", "weight"]}。

from horizon_plugin_profiler.utils.entities import Metric

# 必须先跑 v2 敏感度
qa.sensitivity(metric=Metric.ATOL, use_sensitivity_v2=True)

qa.tune_bad_case(
    outputs_config={
        "0": {
            "metric": Metric.ATOL,
            "threshold": 0.2,
            "max_tuned_stubs": 10,
        },
    },
    skip_prefix={"backbone": ["output", "weight"]},
)

输出

output_{out_name}_tuned_case_{index}_sensitive_ops.txt / .csv / .pt：在敏感度表的基础上增加 tuned_cumulative_{metric} 列，记录每次调整后模型输出的 metric 变化。有值的行即为被提升到 int16 后确实带来改善的节点。

clean

def clean(self)

清除中间结果。仅保留比较结果等文件。

ModelProfiler 类

统计模型 forward 过程中，每一层算子的输入输出等信息。

# from horizon_plugin_profiler import ModelProfiler

class ModelProfiler(object):
    def __init__(
        self,
        model: torch.nn.Module,
        out_dir: str,
    )

参数

model: 需要统计的模型。
out_dir: 相关文件保存的路径。

注解

该类仅支持通过 with 语句的方式使用。

with ModelProfiler(net, "./profiler_dir") as p:
    net(data)

p.get_info_manager().table()
p.get_info_manager().tensorboard()

该类中其中各个 method 如下：

get_info_manager

def get_info_manager(self)

获得管理每个 op 信息的结构体。

返回值

管理存储的每个 op 信息的结构体 OpRunningInfoManager。其中两个重要的接口如下：

table

class OpRunningInfoManager:
    def table(
        self,
        out_dir: str = None,
        prefixes: Tuple[str, ...] = None,
        types: Tuple[Type, ...] = None,
        with_stack: bool = False,
    )

在一个表格中展示单个模型统计量。存储到 statistic.txt 文件中。

参数

out_dir：statistic.txt 文件的存储路径，默认 None，存储到 self.out_dir。
prefixes：需要统计的模型中 op 的 prefixes。默认统计所有 op。
types：需要统计的模型中 op 的 type。默认统计所有 op。
with_stack: 是否显示每个 op 在代码中对应的位置。

输出

statistic.txt 文件，从左到右每一列分别为：

Index：op index。
Op Name：op type，module 类名或者 function 名。
Mod Name：若是 module 类，则显示该 module 在模型中的 prefix name；若是 function 类型，则显示该 function 所在的 module prefix name。
Attr：input/output/weight/bias。
Dtype：tensor 的数据类型。
Scale：tensor 的 scale。
Min：当前 tensor 的最小值。
Max：当前 tensor 的最大值。
Mean：当前 tensor 的平均值。
Var：当前 tensor 中数值的方差。
Shape：tensor shape。

+---------+--------------------------------------------------------------------+------------+--------+---------------+-----------+------------+-----------+-----------+-----------+----------------------------+
| Index   | Op Name                                                            | Mod Name   | Attr   | Dtype         | Scale     | Min        | Max       | Mean      | Var       | Shape                      |
|---------+--------------------------------------------------------------------+------------+--------+---------------+-----------+------------+-----------+-----------+-----------+----------------------------|
| 0       | horizon_plugin_pytorch.nn.qat.stubs.QuantStub                      | quant      | input  | torch.float32 |           | 0.0000797  | 0.9998382 | 0.4980516 | 0.0823590 | torch.Size([1, 3, 32, 32]) |
| 0       | horizon_plugin_pytorch.nn.qat.stubs.QuantStub                      | quant      | output | qint8         | 0.0078419 | 0.0000000  | 0.9959173 | 0.4980148 | 0.0823754 | torch.Size([1, 3, 32, 32]) |
| 1       | horizon_plugin_pytorch.nn.qat.conv2d.Conv2d                        | conv       | input  | qint8         | 0.0078419 | 0.0000000  | 0.9959173 | 0.4980148 | 0.0823754 | torch.Size([1, 3, 32, 32]) |
| 1       | horizon_plugin_pytorch.nn.qat.conv2d.Conv2d                        | conv       | weight | torch.float32 |           | -0.5051875 | 0.5390092 | 0.0225839 | 0.1342911 | torch.Size([3, 3, 1, 1])   |
| 1       | horizon_plugin_pytorch.nn.qat.conv2d.Conv2d                        | conv       | bias   | torch.float32 |           | 0.1814680  | 0.4194079 | 0.2941962 | 0.0142707 | torch.Size([3])            |
| 1       | horizon_plugin_pytorch.nn.qat.conv2d.Conv2d                        | conv       | output | torch.float32 |           | -0.3565997 | 1.1367939 | 0.3289838 | 0.0682679 | torch.Size([1, 3, 32, 32]) |
| 2       | horizon_plugin_pytorch.nn.qat.relu.ReLU                            | relu       | input  | torch.float32 |           | -0.3565997 | 1.1367939 | 0.3289838 | 0.0682679 | torch.Size([1, 3, 32, 32]) |
| 2       | horizon_plugin_pytorch.nn.qat.relu.ReLU                            | relu       | output | qint8         | 0.0089490 | 0.0000000  | 1.1365263 | 0.3404330 | 0.0589806 | torch.Size([1, 3, 32, 32]) |
| 3       | horizon_plugin_pytorch.nn.interpolate.autocasted_interpolate_outer |            | input  | qint8         | 0.0089490 | 0.0000000  | 1.1365263 | 0.3404330 | 0.0589806 | torch.Size([1, 3, 32, 32]) |
| 3       | horizon_plugin_pytorch.nn.interpolate.autocasted_interpolate_outer |            | output | qint8         | 0.0089490 | 0.0000000  | 1.1365263 | 0.3395261 | 0.0588461 | torch.Size([1, 3, 40, 40]) |
| 4       | horizon_plugin_pytorch.nn.qat.stubs.DeQuantStub                    | dequant    | input  | qint8         | 0.0089490 | 0.0000000  | 1.1365263 | 0.3395261 | 0.0588461 | torch.Size([1, 3, 40, 40]) |
| 4       | horizon_plugin_pytorch.nn.qat.stubs.DeQuantStub                    | dequant    | output | torch.float32 |           | 0.0000000  | 1.1365263 | 0.3395261 | 0.0588461 | torch.Size([1, 3, 40, 40]) |
+---------+--------------------------------------------------------------------+------------+--------+---------------+-----------+------------+-----------+-----------+-----------+----------------------------+

tensorboard

class OpRunningInfoManager:
    def tensorboard(
        self,
        out_dir: str = None,
        prefixes: Tuple[str, ...] = None,
        types: Tuple[Type, ...] = None,
        force_per_channel: bool = False,
    ):

在 tensorboard 中显示每一层输入输出直方图。

参数

out_dir：tensorboard 相关文件保目录。默认保存到 self.out_dir/tensorboard 目录下。
prefixes：需要统计的模型中 op 的 prefixes。默认统计所有。
types：需要统计的模型中 op 的 type。默认统计所有。
force_per_channel：是否以 per_channel 量化的方式展示直方图。

输出

tensorboard 文件，打开后截图如下：

tensorboard

HbirModelProfiler 类

该类的功能和使用方式与 ModelProfiler 类完全一致。请参考 ModelProfiler 类进行使用。

注意

由于 hbir 模型的特殊格式，qat hbir 模型在 forward 时需添加索引 0。

with HbirModelProfiler(qat_hbir, "./hbir_dir") as p:
    qat_hbir[0](data)

p.get_info_manager().table()
p.get_info_manager().tensorboard()

#PyTorch 模型精度调优工具

#快速上手

#基于 loss metric 的推荐流程

#两种常见的 loss metric 写法

#推荐流程

#多机多卡

#API Reference

#模型结构检查

#QuantAnalysis 类

#Metric 说明

#auto_find_bad_case

#set_bad_case

#load_bad_case

#set_model_profiler_dir

#run

#分析统计信息

#compare_per_layer

#sensitivity

#tune_bad_case

#clean

#ModelProfiler 类

#get_info_manager

#table

#tensorboard

#HbirModelProfiler 类

PyTorch 模型精度调优工具

快速上手

基于 loss metric 的推荐流程

两种常见的 loss metric 写法

推荐流程

多机多卡

API Reference

模型结构检查

QuantAnalysis 类

Metric 说明

auto_find_bad_case

set_bad_case

load_bad_case

set_model_profiler_dir

run

分析统计信息

compare_per_layer

sensitivity

tune_bad_case

clean

ModelProfiler 类

get_info_manager

table

tensorboard

HbirModelProfiler 类