INT8 中的稀疏性:加速的训练工作流程和NVIDIA TensorRT 最佳实践

news/2024/5/18 12:27:32

INT8 中的稀疏性:加速的训练工作流程和NVIDIA TensorRT 最佳实践


文章目录

  • INT8 中的稀疏性:加速的训练工作流程和NVIDIA TensorRT 最佳实践
    • 结构稀疏
    • 量化
    • 在 TensorRT 中部署稀疏量化模型的工作流程
    • 案例研究:ResNet-34
      • 要求
      • 第 1 步:从密集模型中进行稀疏化和微调
      • 第 2 步:量化 PyTorch 模型
        • PTQ 通过 TensorRT 校准
        • QAT 通过 pytorch-quantization 工具包
      • 第三步:部署TensorRT引擎
    • 结果

深度学习 (DL) 模型的训练阶段包括学习大量密集的浮点权重矩阵,这导致推理过程中需要进行大量的浮点计算。 研究表明,可以通过强制某些权重为零来跳过其中许多计算,而对最终精度的影响很小。

与此同时,之前的帖子表明较低的精度(例如 INT8)通常足以在推理过程中获得与 FP32 相似的精度。 稀疏性和量化是流行的优化技术,用于解决这些问题,缩短推理时间并减少内存占用。

NVIDIA TensorRT 已经提供量化支持一段时间(从 2.1 版本开始),并且最近在 NVIDIA Ampere 架构 Tensor Cores 中内置了对稀疏性的支持,并在 TensorRT 8.0 中引入。

这篇文章是关于如何使用稀疏性和量化技术使用 TensorRT 加速 DL 模型的分步指南。 尽管已经单独讨论了这些优化中的每一个,但仍然需要展示从训练到使用 TensorRT 部署的端到端工作流,同时考虑这两种优化。

在这篇文章中,我们旨在弥合这一差距并帮助您了解稀疏量化训练工作流程是什么样的,就 TensorRT 加速方面的稀疏性最佳实践提出建议,并展示 ResNet-34 的端到端案例研究.

结构稀疏

NVIDIA 稀疏张量核心使用 2:4 模式,这意味着四个值的每个连续块中的两个必须为零。 换句话说,我们遵循 50% 的细粒度结构化稀疏度配方,由于直接在 Tensor Core 上提供可用支持,因此不会对零值进行任何计算。 这导致在相同的时间内计算更多的工作量。 在这篇文章中,我们将此过程称为修剪。

有关详细信息,请参阅使用 NVIDIA Ampere 架构和 NVIDIA TensorRT 通过稀疏性加速推理。

量化

量化是指将连续的无限值映射到一组有限的离散值(例如,FP32 到 INT8)的过程。 这篇文章中讨论了两种主要的量化技术:

  • 训练后量化 (PTQ):使用隐式量化工作流程。 在隐式量化网络中,每个量化张量都有一个关联的标度,用于通过校准对值进行隐式量化和反量化。 然后 TensorRT 检查该层运行速度更快的精度并相应地执行它。
  • 量化感知训练 (QAT):使用显式量化工作流程。 显式量化网络利用量化和反量化 (Q/DQ) 节点来明确指示必须量化哪些层。 这意味着您可以更好地控制在 INT8 中运行哪些层。 有关详细信息,请参阅 Q/DQ 层布局建议。

有关量化基础知识、PTQ 和 QAT 量化技术之间的比较、何时选择哪种量化的见解以及 TensorRT 中的量化的更多信息,请参阅使用 NVIDIA TensorRT 的量化感知训练实现 INT8 推理的 FP32 精度。

在 TensorRT 中部署稀疏量化模型的工作流程

在 TensorRT 中部署稀疏量化模型的工作流程,以 PyTorch 作为 DL 框架,有以下步骤:

  • 在 PyTorch 中对预训练的密集模型进行稀疏化和微调。
  • 通过 PTQ 或 QAT 工作流程量化稀疏化模型。
  • 在 TensorRT 中部署获得的稀疏 INT8 引擎。
    下图显示了所有三个步骤。 步骤 2 中的一个区别是 Q/DQ 节点存在于通过 QAT 生成的 ONNX 图中,但在通过 PTQ 生成的 ONNX 图中不存在。 有关详细信息,请参阅使用 INT8。

鉴于此,这是 QAT 的完整工作流程:

  • 在 PyTorch 中对预训练的密集模型进行稀疏化和微调。
  • 在 PyTorch 中量化、校准和微调稀疏模型。
  • 将 PyTorch 模型导出到 ONNX。
  • 通过 ONNX 生成 TensorRT 引擎。
  • 在 TensorRT 中部署获得的 Sparse INT8 引擎。

另一方面,这是 PTQ 的完整工作流程:

  • 在 PyTorch 中对预训练的密集模型进行稀疏化和微调。
  • 将 PyTorch 模型导出到 ONNX。
  • 通过 TensorRT 构建器对稀疏化的 ONNX 模型进行校准和量化,生成 TensorRT 引擎。
  • 在 TensorRT 中部署获得的稀疏 INT8 引擎。

在这里插入图片描述

案例研究:ResNet-34

本节演示了使用 ResNet-34 的稀疏量化工作流程的案例研究。 有关详细信息,请参阅 /SparsityINT8 GitHub 存储库中的完整代码示例。

要求

以下是完成此案例研究所需的基本配置:

  • Python 3.8
  • PyTorch 1.11 (also tested with 2.0.0)
  • PyTorch vision
  • apex sparsity toolkit
  • pytorch-quantization toolkit
  • TensorRT 8.6
  • Polygraphy
  • ONNX opset>=13
  • NVIDIA Ampere architecture GPU for Tensor Core support

本案例研究需要使用 ImageNet 2012 数据集进行图像分类。 有关下载数据集并将其转换为所需格式的更多信息,请参阅 GitHub 存储库上的自述文件。

稀疏训练、稀疏 QAT 模型微调和稀疏 PTQ 模型校准需要此数据集。 它还用于评估模型。

第 1 步:从密集模型中进行稀疏化和微调

加载预训练的密集模型并增强模型和优化器以进行稀疏训练。 有关详细信息,请参阅 NVIDIA/apex/tree/master/apex/contrib/sparsity 文件夹。

import copy
from torchvision import models
from apex.contrib.sparsity import ASP# Load dense model
model_dense = models.__dict__["resnet34"](pretrained=True)# Initialize sparsity mode before starting sparse training
model_sparse = copy.deepcopy(model_dense)
ASP.prune_trained_model(model_sparse, optimizer)# Re-train model
for e in range(0, epoch):for i, (image, target) in enumerate(data_loader):image, target = image.to(device), target.to(device)output = model_sparse(image)loss = criterion(output, target)optimizer.zero_grad()loss.backward()optimizer.step()# Save model
torch.save(model_sparse.state_dict(), "sparse_finetuned.pth")

第 2 步:量化 PyTorch 模型

您可以为此步骤选择两种量化方法:PTQ 或 QAT。

PTQ 通过 TensorRT 校准

此选项将 PyTorch 模型导出到 ONNX 并通过 TensorRT Python API 对其进行校准。 这会生成校准缓存和准备部署的 TensorRT 引擎。

将稀疏 PyTorch 模型导出到 ONNX:

dummy_input = torch.randn(batch_size, 3, 224, 224, device="cuda")
torch.onnx.export(model_sparse, dummy_input, "sparse_finetuned.onnx", opset_version=13, do_constant_folding=True)

使用校准数据集校准在上一步中导出的 ONNX 模型。 以下代码示例假定 ONNX 模型具有静态输入形状和批量大小。

from infer_engine import infer
from polygraphy.backend.trt import Calibrator, CreateConfig, EngineFromNetwork, NetworkFromOnnxPath, TrtRunner, SaveEngine
from polygraphy.logger import G_LOGGER# Data loader argument to `Calibrator` 
def calib_data(val_batches, input_name):for iteration, (images, labels) in enumerate(val_batches):yield {input_name: images.numpy()}# Set path to ONNX model
onnx_path = "sparse_finetuned.onnx"# Set calibrator
calibration_cache_path = onnx_path.replace(".onnx", "_calibration.cache")
calibrator = Calibrator(data_loader=calib_data(data_loader_calib, args.onnx_input_name), cache=calibration_cache_path
)# Build engine from ONNX model by enabling INT8 and sparsity weights, and providing the calibrator
build_engine = EngineFromNetwork(NetworkFromOnnxPath(onnx_path),config=CreateConfig(int8=True,calibrator=calibrator,sparse_weights=True)
)# Trigger engine saving
engine_path = onnx_path.replace(".onnx", ".engine")
build_engine = SaveEngine(build_engine, path=engine_path)# Calibrate engine (activated by the runner)
with G_LOGGER.verbosity(G_LOGGER.VERBOSE), TrtRunner(build_engine) as runner:print("Calibrated engine!")# Infer PTQ engine and evaluate its accuracylog_file = engine_path.split("/")[-1].replace(".engine", "_accuracy.txt")infer(engine_path,data_loader_test,batch_size=args.batch_size,log_file=log_file)

QAT 通过 pytorch-quantization 工具包

此选项使用 pytorch-quantization 工具包在稀疏 PyTorch 模型中添加 Q/DQ 节点,对其进行校准,并对其进行微调几个 epoch。 然后将微调后的模型导出到 ONNX 并转换为 TensorRT 引擎进行部署。

为确保已计算的稀疏浮点权重不会被覆盖,确保 QAT 权重也将结构化为稀疏,您必须再次准备模型进行剪枝。

在加载微调的稀疏权重之前初始化 QAT 模型和优化器以进行修剪。 稀疏掩码重新计算也必须禁用,因为它们已经在步骤 1 中计算过。这需要一个自定义函数,该函数是对 APEX 工具包的 prune_trained_model 函数的轻微修改。 修改在代码示例中突出显示:

from apex.contrib.sparsity import ASPdef prune_trained_model_custom(model, optimizer, compute_sparse_masks=False):asp = ASP()asp.init_model_for_pruning(model, mask_calculator="m4n2_1d", verbosity=2, whitelist=[torch.nn.Linear, torch.nn.Conv2d], allow_recompute_mask=False)asp.init_optimizer_for_pruning(optimizer)if compute_sparse_masks:asp.compute_sparse_masks()

为了优化 Q/DQ 节点放置,您必须修改模型的定义以量化残差分支,如 pytorch-quantization 工具包示例所示。 例如,对于ResNet,需要在残差分支中添加Q/DQ节点的修改突出显示如下:


from pytorch_quantization import nn as quant_nnclass BasicBlock(nn.Module):def __init__(self, ..., quantize: bool = False) -> None:super().__init__()...if self._quantize:self.residual_quantizer = quant_nn.TensorQuantizer(quant_nn.QuantConv2d.default_quant_desc_input)def forward(self, x: Tensor) -> Tensor:identity = x...if self._quantize:out += self.residual_quantizer(identity)else:out += identityout = self.relu(out)return out

必须对 Bottleneck 类重复相同的修改,并且必须通过 ResNet、_resnet 和 resnet34 函数传播量化 bool 参数。 完成这些修改后,使用 quantize=True 实例化模型。 有关详细信息,请参阅 resnet.py 中的第 734 行。

通过 QAT 量化稀疏模型的第一步是在模型中启用量化和剪枝。 第二步是加载微调的稀疏检查点,对其进行校准,然后最后对该模型进行一些 epoch 的微调。 有关 collect_stats 和 compute_amax 函数的更多信息,请参阅 calibrate_quant_resnet50.ipynb。

# Add Q/DQ nodes to the dense model
from pytorch_quantization import quant_modules
quant_modules.initialize()
model_qat = models.__dict__["resnet34"](pretrained=True, quantize=True)# Initialize sparsity mode before starting Sparse-QAT fine-tuning
prune_trained_model_custom(model_qat, optimizer, compute_sparse_masks=False)# Load Sparse weights
load_dict = torch.load("sparse_finetuned.pth")
model_qat.load_state_dict(load_dict["model_state_dict"])# Calibrate model
collect_stats(model_qat, data_loader_calib, num_batches=len(data_loader_calib))
compute_amax(model_qat, method="entropy”)# Fine-tune model
for e in range(0, epoch):for i, (image, target) in enumerate(data_loader):image, target = image.to(device), target.to(device)output = model_qat(image)...# Save model
torch.save(model_qat.state_dict(), "quant_finetuned.pth")

要准备部署 TensorRT 引擎,您必须将稀疏量化 PyTorch 模型导出到 ONNX。 TensorRT 期望 QAT ONNX 模型指示哪些层应该通过一组 QuantizeLinear 和 DequantizeLinear ONNX 操作进行量化。 在将量化的 PyTorch 模型导出到 ONNX 时,通过启用伪量化来满足此要求。

from pytorch_quantization import nn as quant_nn
quant_nn.TensorQuantizer.use_fb_fake_quant = True
dummy_input = torch.randn(batch_size, 3, 224, 224, device="cuda")
torch.onnx.export(model_qat, dummy_input, "quant_finetuned.onnx", opset_version=13, do_constant_folding=True)

最后,构建 TensorRT 引擎:

$ trtexec --onnx=quant_finetuned.onnx --int8 --sparsity=enable --saveEngine=quant_finetuned.engine --skipInference

第三步:部署TensorRT引擎

$ trtexec --loadEngine=quant_finetuned.engine -v

结果

以下是在配备 TensorRT 8.6-GA (8.6.1.6) 的 NVIDIA A40 GPU 上针对 ResNet-34 密集量化和稀疏量化模型在分类精度和运行时方面的性能测量。 要重现这些结果,请遵循上一节中描述的工作流程。

下图显示了 TensorRT 中 ResNet-34 在三种设置下的密集精度与稀疏精度的比较:

  • FP32 中的密集与稀疏
  • INT8 中的密集 PTQ 与稀疏 PTQ
  • INT8 中的密集 QAT 与稀疏 QAT

如您所见,与所有设置的密集变体相比,稀疏变体在很大程度上可以保持准确性。


https://dhexx.cn/news/show-4628165.html

相关文章

redis缓存穿透、缓存雪崩 、缓存击穿

一、缓存穿透、缓存雪崩 、缓存击穿 摘自尚硅谷文档 1、缓存穿透 缓存穿透是指查询一个一定不存在的数据,由于缓存是不命中,将去查询数据库,但是数 据库也无此记录,我们没有将这次查询的 null 写入缓存,这将导致这个…

CXGRid实现拖动鼠标多选

要实现在CXGrid中拖动鼠标多选,您可以按住鼠标左键并拖动鼠标,直到选择了要选择的单元格或行。您可以在拖动过程中按住Shift键来限制选择范围。拖动选择的单元格或行时,您可以按住Ctrl键来添加或删除单元格或行的选择。当您完成选择时&#x…

GTK官方教程

前言: 让你在开发中爱不释手的 GT 包。关注GSLS官网,查看更多源码 ヾ(✿゚▽゚)ノ工具包。 所有文章 小编尽量让读者可以 直接 读懂 与 完全 复制粘贴,其中复杂或较多 的源码 会有 源码 并 贴上 github 网址。 GT 类 里面…

【JUC基础】14. ThreadLocal

目录 1、前言 2、什么是ThreadLocal 3、ThreadLocal作用 4、ThradLocal基本使用 4.1、创建和初始化 4.2、存储和获取线程变量 4.3、清理和释放线程变量 4.4、小结 4.5、示例代码 5、ThreadLocal原理 5.1、set() 5.2、get() 5.3、变量清理 5.4、ThreadLocalMap 6、…

springboot+vue+elementui计算机专业课程选课管理系统vue

本系统的主要任务就是负责对学生选课。主要用户为老师、学生,其中,学生可对自己的信息进行查询,可以进行选课,也可以进行删除已选课程,教师可对学生和课程的信息进行查询,教师拥有所有的权限,可以添加删除学生信息。系统提供界面,操作简单。 为实现这些功能,系统一个…

弄清楚Node.js的功能特性、运行时、组成和发展趋势分析以及与JavaScript的区别

目录 Node.js介绍 Node.js的作用和功能特性 Node.js应用场景 运行时是什么 Node.js的组成 1. V8引擎 2. 本地(核心)模块 3. 标准库 Node.js的发展趋势 总结 Node.js是一个基于Chrome V8引擎的JavaScript运行时环境,使JavaScript可以…

图论试题2021

25 A:最大度是7,大于了顶点数6,故不是简单图的度序列。 C:树的度序列至少要有两个度为1的顶点 D:只要度数为奇数的个数有偶数个,就是度序列。 A:每棵树的中心由一个点或两个相邻点组成 B&…

Vue+springboot舞蹈基础课程视频学习分享平台的实现和开发

基于java语言设计并实现了舞蹈基础数据平台。该系统基于B/S即所谓浏览器/服务器模式,应用Springboot框架,选择MySQL作为后台数据库。系统主要包括首页、个人中心、用户管理、舞蹈类型管理、舞蹈视频管理、用户留言、管理员管理、系统管理等功能模块。 重…

平面图学习

空调管道的设计:某景区有6个景点,位置分布如下图。 分析者认为:(1) A1与A4, (2) A2与A5, (3) A3与A6间人流较少,其它景点之间人流量大,必须投资铺设空调管道,但要求空调管道间不能交…

2.项目中的文件

项目的路径是这样的 目录 1 pages 1.1 json 1.2 wxml 1.3 wxss 1.4 js 2 utils 3 .eslintrc.js 4 app.js 5 app.json 6 app.wxss 7 project.config.json 8 project.private.config.json 9 sitemap.json 1 pages pages 用来存放所有小程序的页面&am…