模型量化！ONNX转TensorRT(FP32, FP16, INT8)

已于 2023-08-08 17:08:19 修改
阅读量4.7k 收藏 48
点赞数 5
文章标签： c++ 开发语言 深度学习
于 2022-07-10 12:16:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43522163/article/details/125703758
版权

本文为C++实现，Python实现链接模型量化
  
支持三种不同精度的量化

模型单精度量化 (FP32)
模型半精度量化 (FP16)
模型Int8量化 (INT8)

经测试yolov5，yolov6，yolov7，yolov8转化成功
yolov5: https://github.com/ultralytics/yolov5
yolov6: https://github.com/meituan/YOLOv6
yolov7: https://github.com/WongKinYiu/yolov7
yolov8: https://github.com/ultralytics/ultralytics

注意：若使用INT8量化，需要额外的文件，这里是calibrator.cpp & calibrator.h

文章目录

先决条件

如果还没有安装CUDA和CUDNN，请参考这篇文章：
文章链接：Win10配置CUDA和cudnn
我的CUDA版本：11.3
我的CUDNN版本：8.4.1

下载TensorRT

建议下载GA版本（正式版本），链接：https://developer.nvidia.com/tensorrt
我下载的8.4.1.5版本，下载完成后解压

在这里插入图片描述
解压后可以看到这三个文件夹

在这里插入图片描述

Debug模式

1. 创建新项目

在这里插入图片描述

2. 复制TensorRT文件至CUDA

将lib中的dll文件复制到 …\NVIDIA GPU Computing Toolkit\CUDA\v11.3\bin（这是我的路径）

在这里插入图片描述

在这里插入图片描述

3. 创建onnx2TensorRT函数

当前是Debug模式，将代码copy进去，这时出现错误（红色波浪线）不用管。

在这里插入图片描述

main.cpp

#include <iostream>
#include <fstream>
#include "calibrator.h"
#include "NvInfer.h"
#include "NvOnnxParser.h"

// 实例化记录器界面，捕获所有警告性信息，但忽略信息性消息
class Logger : public nvinfer1::ILogger {
	void log(Severity severity, const char* msg) noexcept override {
		if (severity <= Severity::kWARNING) {
			std::cout << msg << std::endl;
		}
	}
}logger;

void ONNX2TensorRT(const char* ONNX_file, std::string& Engine_file, bool& FP16, bool& INT8, std::string& image_dir, const char*& calib_table) {
	std::cout << "Load ONNX file form: " << ONNX_file << "\nStart export..." << std::endl;
	// 1.创建构建器的实例
	nvinfer1::IBuilder* builder = nvinfer1::createInferBuilder(logger);

	// 2.创建网络定义
	uint32_t flag = 1U << static_cast<uint32_t>(nvinfer1::NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
	nvinfer1::INetworkDefinition* network = builder->createNetworkV2(flag);

	// 3.创建一个 ONNX 解析器来填充网络
	nvonnxparser::IParser* parser = nvonnxparser::createParser(*network, logger);
	
	// 4.读取模型文件并处理任何错误
	parser->parseFromFile(ONNX_file, static_cast<int32_t>(nvinfer1::ILogger::Severity::kWARNING));
	for (int32_t i = 0; i < parser->getNbErrors(); ++i)
		std::cout << parser->getError(i)->desc() << std::endl;

	// 5.创建构建配置，指定TensorRT如何优化模型
	nvinfer1::IBuilderConfig* config = builder->createBuilderConfig();

	// 6.设置属性来控制 TensorRT 如何优化网络
	// 设置内存池的空间
	config->setMemoryPoolLimit(nvinfer1::MemoryPoolType::kWORKSPACE, 16 * (1 << 20));
	if (FP16) {
		// 判断硬件是否支持FP16
		if (!builder->platformHasFastFp16()) {
			std::cout << "不支持FP16量化！" << std::endl;
			system("pause");
			return;
		}
		config->setFlag(nvinfer1::BuilderFlag::kFP16);
	}
	else if (INT8) {
		if (!builder->platformHasFastInt8()) {
			std::cout << "不支持INT8量化！" << std::endl;
			system("pause");
			return;
		}
		config->setFlag(nvinfer1::BuilderFlag::kINT8);
		nvinfer1::IInt8EntropyCalibrator2* calibrator = new Calibrator(1, 640, 640, image_dir, calib_table);
		config->setInt8Calibrator(calibrator);
	}

	// 7.指定配置后，构建引擎
	nvinfer1::IHostMemory* serializeModel = builder->buildSerializedNetwork(*network, *config);

	// 8.保存TensorRT模型
	std::ofstream engine(Engine_file, std::ios::binary);
	engine.write(reinterpret_cast<const char*>(serializeModel->data()), serializeModel->size());

	// 9.序列化引擎包含权重的必要副本，因此不再需要解析器、网络定义、构建器配置和构建器，可以安全地删除
	delete parser;
	delete network;
	delete config;
	delete builder;

	// 10.将引擎保存到磁盘后 ，并且可以删除它被序列化到的缓冲区
	delete serializeModel;
	std::cout << "Export success, Save as: " << Engine_file << std::endl;
}

int main(int argc, char** argv) {
	// ONNX 文件路径
	const char* ONNX_file = "../weights/yolov8s.onnx";
	// ENGINE 文件保存路径
	std::string Engine_file = "../weights/yolov8s.engine";

	// 当量化为INT8时，图片路径
	std::string image_dir = "../images/";
	// 当量化为INT8时，校准表路径（存在读取，不存在创建）
	const char* calib_table = "../weights/calibrator.table";

	// 选择量化方式，若两个都为false，使用FP32生成 ENGINE文件
	bool FP16 = false;
	bool INT8 = true;

	std::ifstream file(ONNX_file, std::ios::binary);
	if (!file.good()) {
		std::cout << "Load ONNX file failed！" << std::endl;
	}

	ONNX2TensorRT(ONNX_file, Engine_file, FP16, INT8, image_dir, calib_table);

	return 0;
}

calibrator.cpp

#include <fstream>
#include <io.h>
#include "calibrator.h"

cv::Mat Calibrator::preprocess_img(cv::Mat& img, int input_w, int input_h) {
    int w, h, x, y;
    float r_w = input_w / (img.cols * 1.0);
    float r_h = input_h / (img.rows * 1.0);
    if (r_h > r_w) {
        w = input_w;
        h = r_w * img.rows;
        x = 0;
        y = (input_h - h) / 2;
    }
    else {
        w = r_h * img.cols;
        h = input_h;
        x = (input_w - w) / 2;
        y = 0;
    }
    cv::Mat re(h, w, CV_8UC3);
    cv::resize(img, re, re.size(), 0, 0, cv::INTER_LINEAR);
    cv::Mat out(input_h, input_w, CV_8UC3, cv::Scalar(128, 128, 128));
    re.copyTo(out(cv::Rect(x, y, re.cols, re.rows)));
    return out;
}

void Calibrator::getFiles(std::string path, std::vector<std::string>& files){
    intptr_t Handle;
    struct _finddata_t FileInfo;
    std::string p;
    Handle = _findfirst(p.assign(path).append("\\*").c_str(), &FileInfo);

    while (_findnext(Handle, &FileInfo) == 0) {
        if (strcmp(FileInfo.name, ".") != 0 && strcmp(FileInfo.name, "..") != 0) {
            files.push_back(FileInfo.name);
        }
    }
}

Calibrator::Calibrator(int batchsize, int input_w, int input_h, std::string img_dir, const char* calib_table_name, bool read_cache){
    BATCHSIZE = batchsize;
    WIDTH = input_w;
    HEIGHT = input_h;
    INDEX = 0;
    IMAGEDIR = img_dir;
    CALIBRATORTABLE = calib_table_name;
    READCACHE = read_cache;
    INPUTSIZE = BATCHSIZE * 3 * WIDTH * HEIGHT;

    cudaMalloc(&DEVICEINPUT, INPUTSIZE * sizeof(float));
    getFiles(IMAGEDIR, IMAGEFILES);
}

Calibrator::~Calibrator() {
    cudaFree(DEVICEINPUT);
}

int Calibrator::getBatchSize() const noexcept {
    return BATCHSIZE;
}

bool Calibrator::getBatch(void* bindings[], const char* names[], int nbBindings) noexcept {
    if (INDEX + BATCHSIZE > (int)IMAGEFILES.size()) return false;

    std::vector<cv::Mat> input_imgs;
    for (int i = INDEX; i < INDEX + BATCHSIZE; i++) {
        cv::Mat temp = cv::imread(IMAGEDIR + IMAGEFILES[i]);
        if (temp.empty()) {
            std::cerr << "Image cannot open!" << std::endl;
            return false;
        }
        cv::Mat pr_img = preprocess_img(temp, WIDTH, HEIGHT);
        input_imgs.push_back(pr_img);
    }
    INDEX += BATCHSIZE;
    cv::Mat blob = cv::dnn::blobFromImages(input_imgs, 1.0 / 255.0, cv::Size(WIDTH, HEIGHT), cv::Scalar(0, 0, 0), true, false);

    cudaMemcpy(DEVICEINPUT, blob.ptr<float>(0), INPUTSIZE * sizeof(float), cudaMemcpyHostToDevice);
    bindings[0] = DEVICEINPUT;
    return true;
}

const void* Calibrator::readCalibrationCache(size_t& length) noexcept {
    std::cout << "reading calib cache: " << CALIBRATORTABLE << std::endl;
    CALIBRATORCACHE.clear();
    std::ifstream input(CALIBRATORTABLE, std::ios::binary);
    input >> std::noskipws;
    if (READCACHE && input.good()) {
        std::copy(std::istream_iterator<char>(input), std::istream_iterator<char>(), std::back_inserter(CALIBRATORCACHE));
    }
    length = CALIBRATORCACHE.size();
    return length ? CALIBRATORCACHE.data() : nullptr;
}

void Calibrator::writeCalibrationCache(const void* cache, size_t length) noexcept {
    std::cout << "writing calib cache: " << CALIBRATORTABLE << std::endl;
    std::ofstream output(CALIBRATORTABLE, std::ios::binary);
    output.write(reinterpret_cast<const char*>(cache), length);
}

calibrator.h

#pragma once
#include <NvInfer.h>
#include<vector>
#include <opencv2/opencv.hpp>
class Calibrator : public nvinfer1::IInt8EntropyCalibrator2 {
public:
	Calibrator(int batchsize, int input_w, int input_h, std::string img_dir, const char* calib_table_name, bool read_cache = true);

	virtual ~Calibrator();
	int getBatchSize() const noexcept override;
	bool getBatch(void* bindings[], const char* names[], int nbBindings) noexcept override;
	const void* readCalibrationCache(size_t& length) noexcept override;
	void writeCalibrationCache(const void* cache, size_t length) noexcept override;

private:
	int BATCHSIZE;
	int WIDTH;
	int HEIGHT;
	int INDEX;
	std::string IMAGEDIR;
	std::vector<std::string> IMAGEFILES;
	size_t INPUTSIZE;
	std::string CALIBRATORTABLE;
	bool READCACHE;
	void* DEVICEINPUT;
	std::vector<char> CALIBRATORCACHE;

	cv::Mat preprocess_img(cv::Mat& img, int input_w, int input_h);
	void getFiles(std::string path, std::vector<std::string>& files);
};

4. 设置属性

右键属性

在这里插入图片描述

4.1. 设置属性 — 包含目录

找到VC++目录中的包含目录，将下面的路径写入，保存退出

注意：TensorRT路径需要替换成你的路径，CUDA路径复制即可。

$(CUDA_PATH)\include
D:\software\opencv\build\include
D:\software\TensorRT-8.4.1.5_CUDA11.6_Cudnn8.4.1\include
D:\software\TensorRT-8.4.1.5_CUDA11.6_Cudnn8.4.1\samples\common

在这里插入图片描述

在这里插入图片描述

4.2. 设置属性 — 库目录

找到库目录，将下面的路径写入，保存退出

注意：TensorRT路径需要替换成你的路径，CUDA路径复制即可。

$(CUDA_PATH)\lib
$(CUDA_PATH)\lib\x64
D:\software\opencv\build\x64\vc15\lib
D:\software\TensorRT-8.4.1.5_CUDA11.6_Cudnn8.4.1\lib

在这里插入图片描述

在这里插入图片描述

4.3. 设置属性 — 链接器

找到链接器下的输入，在附加依赖项中加入
nvinfer.lib
nvinfer_plugin.lib
nvonnxparser.lib
nvparsers.lib
cudnn.lib
cublas.lib
cudart.lib

在这里插入图片描述

在这里插入图片描述

5. 创建模型文件夹

新建weights文件夹，将你的onnx文件放在里面

在这里插入图片描述

在这里插入图片描述

6. 运行

点击运行即可（可能有点慢）

在这里插入图片描述

7. 问题 — 缺少 zlibwapi.dll 文件

若出现缺少zlibwapi.dll，需要下载，
链接：https://pan.baidu.com/s/12sVdiDH-NOOZNI9QqJoZuA?pwd=a0n0
提取码：a0n0
下载后解压，将zlibwapi.dll 放入 …\NVIDIA GPU Computing Toolkit\CUDA\v11.3\bin(我的路径)
重新运行程序

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

8. 生成engine文件

在这里插入图片描述

Release模式

点击，更换为Release

在这里插入图片描述

重新配置属性

重新配置步骤4，添加库目录，包含目录，附加依赖项，即可。

结束。

田小草儿
关注
  • 5
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
yolov5模型，yolov5量化模型，yolov5 FP16 FP32 INT8量化模型
08-03
yolov5模型，yolov5量化模型，yolov5 FP16 FP32 INT8量化模型，yolov5s.onnx,yolov5s.pt,yolov5s.engine,yolov5s.trt,yolov5s_fp16.engine,yolov5s_fp16_int8_engine,yolov5s_int8.engine， 模型量化，各种量化版本测试https://blog.csdn.net/m0_37556124/article/details/132020541?spm=1001.2014.3001.5501
Ultralytics（YoloV8）开发环境配置，训练，模型转换，部署全流程测试记录
千人斩的博客
10-04 4624
Ultralytics（YoloV8）开发环境配置，训练，模型转换，部署全流程测试记录
Cap2.2：Pytorch转TensorRT（下：ONNX-＞TensorRT）
xu.hyj
04-15 567
在上章节中我们将resnet18导出为onnx模型，现在我们需要将onnx转为tensorRT支持的模型。
使用 TensorRT 对 YOLOv8 模型进行 int8 量化
drin201312的博客
09-27 3185
对 YOLOv8 模型进行 int8 量化，主要用到 Python 版的 TensorRT。
Onnx精度转换 FP32-＞FP16
thisiszdy的博客
10-24 1275
Onnx精度转换
YOLOv8目标检测实战：TensorRT加速部署
09-01
PyTorch版的YOLOv8是先进的高性能实时目标检测方法。 TensorRT是针对英伟达GPU的加速工具。本课程讲述如何使用TensorRT对YOLOv8目标检测进行加速和部署。采用改进后的tensorrtx/yolov8的代码，使用TensorRT API构建优化推理引擎支持在GPU上端到端TensorRT加速部署，包括预处理（图像resize, BGR->RGB，归一化）、网络推理、后处理（非极大抑制） 均在GPU上执行支持FP16和INT8量化加速提供C++和Python的TensorRT加速命令接口分别在Windows和Ubuntu系统上做YOLOv8的TensorRT加速和部署演示支持图片、图片文件夹、视频文件的TensorRT的加速推理提供YOLOv8的TensorRT加速部署代码和代码解析文档实测推理速度提高3倍以上，采用INT8量化加速后推理速度更快。RTX 3060 GPU上端到端处理速度约2.5毫秒，INT8量化加速后推理速度可小于2毫秒。课程内容包括：原理篇（YOLOv8网络架构与组件、TensorRT基础、TensorRT INT8量化、CUDA编程方法）、实践篇（Windows和Ubuntu系统上的TensorRT加速和INT8量化部署演示）、代码解析篇（YOLOv8的TensorRT加速的代码解析） 。本课程提供YOLOv8的TensorRT加速部署代码和代码解析文档。
基于python的tensorrt int8 量化yolov5 onnx模型实现
03-26
基于python的tensorrt int8 量化yolov5 onnx模型实现
onnx转TensorRT使用的三种方式（最终在Python运行）
weixin_42492254的博客
07-28 1万+
onnx转TensorRT使用的三种方式（Python运行）
一文掌握Pytorch-onnx-tensorrt模型转换
m0_38043555的博客
03-07 2万+
一文掌握Pytorch-onnx-tensorrt模型转换pytorch转onnx pytorch转onnx 对于实际部署的需求，很多时候pytorch是不满足的，所以需要转成其他模型格式来加快推理。常用的就是onnx，onnx天然支持很多框架模型的转换， 如Pytorch,tf,darknet,caffe等。而pytorch也给我们提供了对应的接口，就是torch.onnx.export。下面具体到每一步。 首先，环境和依赖：onnx包，cuda和cudnn，我用的版本号分别是1.7.0, 10.1
onnx转换tensorrt的两种方法
热门推荐
weixin_42476942的博客
02-08 2万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、tensorrt是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、tensorrt是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入
TensorRT推理——（二）转换成TensorRT模型、部署python版
weixin_39263657的博客
05-15 2019
使用TensorRT推理肯定是在英伟达GPU环境上进行推理的。
s7310-8-bit-inference-with-tensorrt.pdf
11-08
● Goal: Convert FP32 CNNs into INT8 without significant accuracy loss. ● Why: INT8 math has higher throughput, and lower memory requirements. ● Challenge: INT8 has significantly lower precision and dynamic range than FP32. ● Solution: Minimize loss of information when quantizing trained model weights to INT8 and during INT8 computation of activations. ● Result: Method was implemented in TensorRT. It does not require any additional fine tuning or retraining.
【TensorRT】TensorRT的INT8校准原理
01-06
INT8校准就是原来用32bit（float32）表示的tensor现在用8bit来表示，并且要求精度不能下降太多。 将FP32转换为 INT8的操作需要针对每一层的输入tensor和网络学习到的参数进行。 但是不同网络结构的不同layer的激活值分布很不一样，因此合理的量化方式。应该适用于不同的激活值分布，并且减小信息损失。 使用相对熵（也叫KL散度）来衡量不同的INT8分布与原来的FP3F2分布之间的差异程度。 确定每一层的|T|值的过程称为校准。方法是从验证集选取一个子集作为校准集，校准集应该具有代表性，多样性，最好是验证集的一个子集，不应该只是分类类别的一小部分。激活值分布就是从校准
算法部署-使用OpenVINO+C++部署YOLOX+YOLOV5+V8+V9目标检测算法-支持fp32+fp16+int8推理
最新发布
04-26
算法部署_使用OpenVINO+C++部署YOLOX+YOLOV5+V8+V9目标检测算法_支持fp32+fp16+int8推理_项目源码_优质项目实战
INT8 DistilBERT 底座无外壳微调 SST-2 该模型是一个微调的 DistilBERT 模型
04-01
该模型是一个微调的 DistilBERT 模型，用于情感分类的下游任务，在 SST-2 数据集上进行训练，并从原始 FP32 模型 （distilbert-base-uncased-finetuned-sst-2-english） 量化为 INT8（训练后静态量化）。 同一模型以...
TensorRT8.6 计算机视觉模型部署与加速课程
06-01
使用TensorRT提供的工具与SDK接口实现从FP32到FP16与INT8模型量化加速，自己开发提供了量化脚本支持YOLOv5~YOLOv8系列模型一键量化INT8，使用OpenCV CUDA函数实现预处理加速等各种开发实战技巧，全面提升深度学习...
onnx精度验证
xiaoxiannvyi的博客
05-20 3332
一、yolov5-v6.1 onnx模型转换 1、export.py 参数设置：data、weights、device(cpu)、dynamic(triton需要转成动态的)、include 建议先转fp32，再转fp16： import onnxmltools from onnxmltools.utils.float16_converter import convert_float_to_float16 # Update the input name and path for your
【Pytorch-＞ONNX-＞NCNN-＞NCNNfp16-＞vs编译】Windows NCNN部署
qq_38253797的博客
01-07 5853
目录前言一、Pytorch2ONNX1.1、具体操作1.2、代码二、ONNX2NCNNReference 前言 以YOLOv5为例子，在Windows下将权重文件进行这一整套的转换。 进行转换之前，首先得先安装以下环境： Visual Studio 2019 这个b站很多下载安装介绍，就不说了。 OpenCV 注意它的安装配置：VS中opencv的配置. cmake 注意它的安装配置：windows下载安装cmake. 简单说说他们几个的关系：VS是美国微软公司的开发工具包系列产品，在该项目中有提供GC
onnx 转 tensorrt 的几种方法
ywfwyht的博客
09-23 1774
onnx转tensoorrt的几种方法总结
fp32/fp16/int8/int4/fp8
10-21
这些都是浮点数或整数的数据类型，常用于计算机中的数值计算。其中，fp32和fp16分别表示32位和16位浮点数，int8和int4分别表示8位和4位整数，而fp8则表示8位浮点数。 在深度学习中，这些数据类型也经常被使用。例如，fp32是最常用的数据类型，因为它可以提供足够的精度来处理大多数深度学习任务。但是，由于fp32需要更多的存储空间和计算资源，因此在一些资源受限的场景下，可以使用fp16或int8等低精度数据类型来加速计算。 具体来说，fp16可以在一定程度上减少存储空间和计算资源的使用，但是由于其精度较低，可能会影响模型的准确性。而int8和int4则可以进一步减少存储空间和计算资源的使用，但是需要特殊的硬件支持，并且需要对模型进行量化训练。 至于fp8，则较少使用，因为其精度过低，在深度学习中很难保证模型的准确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值