TensorRt（5）动态尺寸输入的分割模型测试

文章目录

1、固定输入尺寸逻辑
2、动态输入尺寸
- 2.1、模型导出
- 2.2、推理测试
- 2.3、显存分配问题
- 2.4、完整代码

这里主要说明使用TensorRT进行加载编译优化后的模型engine进行推理测试，与前面进行目标识别、目标分类的模型的网络输入是固定大小不同，导致输入维度不能直接获取需要自己手动调整的问题。

1、固定输入尺寸逻辑

基本逻辑如下：

读取engine文件到内存
使用TensorRT运行时IRuntime序列化一个引擎ICudaEngine，在创建一个上下文对象IExecutionContext
从引擎中ICudaEngine获取输入、输出的纬度和数据类型，并分配显存
将输入从host内存中拷贝到输入device显存中
利用创建的上下文对象IExecutionContext执行推理
将推理结果从输出device显存拷贝到host内存中

至于显存分配，根据engine是可以获取网络输入输出的尺寸的。以前面【TensorRt（3）mnist示例中的C++ API】博客中的简要代码为例说推理代码路程：

int simple2()
{/// 2.1  加载engine到内存// .... 省略std::vector<char> buf(buflen);// .... /// 2.2 反序列化std::unique_ptr<IRuntime> runtime{ createInferRuntime(sample::gLogger.getTRTLogger()) };auto mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(runtime->deserializeCudaEngine(buf.data(),buf.size()),[](nvinfer1::ICudaEngine* p) {delete p; });// inference上下文auto context = std::unique_ptr<nvinfer1::IExecutionContext>(mEngine->createExecutionContext());// 网络输入、输出信息  auto mInputDims = mEngine->getBindingDimensions(0);     // 部署使用 [1,1,28,28]auto mOutputDims = mEngine->getBindingDimensions(1);    // 部署使用 [1,10]int inputH = mInputDims.d[2];int inputW = mInputDims.d[3];//----------  整个网络输入只有1个，输出只有1个，且均为float类型，分配cuda显存std::vector<void*> bindings(mEngine->getNbBindings());for (int i = 0; i < bindings.size(); i++) {nvinfer1::DataType type = mEngine->getBindingDataType(i);// 明确为 floatsize_t volume = sizeof(float) * std::accumulate(dims.d,dims.d + dims.nbDims,1,std::multiplies<size_t>());CHECK(cudaMalloc(&bindings[i],volume));}// 加载一个random imagesrand(unsigned(time(nullptr)));std::vector<uint8_t> fileData(inputH * inputW);// 省略.... //----------  输入host数据类型从uint8_t转换为float, 这里明确知道 1*1*28*28std::vector<float> hostDataBuffer(1 * 1 * 28 * 28); for (int i = 0; i < inputH * inputW; i++) {hostDataBuffer[i] = 1.0 - float(fileData[i] / 255.0);}//----------  将图像数据从host空间拷贝到device空间CHECK(cudaMemcpy(bindings[0],static_cast<const void*>(hostDataBuffer.data()),hostDataBuffer.size() * sizeof(float), cudaMemcpyHostToDevice));//----------  excution执行推理bool status = context->executeV2(bindings.data());///  2.3 处理推理结果数据，//----------  将推理结果从device空间拷贝到host空间std::vector<float> pred(1 * 10); // 这里明确知道 1*10)CHECK(cudaMemcpy(static_cast<void*>(pred.data()),bindings[1], pred.size() * sizeof(float),cudaMemcpyDeviceToHost));// .... 省略
}

2、动态输入尺寸

以paddle中的语义语义分割模型 OCRNet + backbone HRNet_w18 为例进行说明测试。

2.1、模型导出

默认训练模型导出推理模型是不带softmax和argmax层的，为避免后续实现效率降低，添加这两层之再导出推理模型，使用paddle2onnx导出onnx模型，

paddle2onnx --model_dir saved_inference_model \--model_filename model.pdmodel \--params_filename model.pdiparams \--save_file model.onnx \--enable_dev_version True       # --opset_version 12 # default 9

使用netron工具查看输入和输出的尺寸信息截图如下
在这里插入图片描述
输入尺寸为 [n, 3, h, w]，原始输出为[n,c,h,w]，由于使用soft和argmax，输出直接为[1, h, w]。输出和输入图像宽高一致，输出的每个像素位置就是像素分类的类别数。

之后使用 trtexec 将onnx模型编译优化导出为engine类型，由于是动态输入，因此指定了输入尺寸范围和最优尺寸。

trtexec.exe --onnx=model.onnx --explicitBatch --fp16 --minShapes=x:1x3x540x960 --optShapes=x:1x3x720x1280 --maxShapes=x:1x3x1080x1920 --saveEngine=model.trt

2.2、推理测试

（0）基本类型数据准备
我们仅使用#include "NvInfer.h" ，来使用TensorRT sdk，定义几个需要的宏和对象

#define CHECK(status)                                                            \do                                                                           \{                                                                            \auto ret = (status);                                                     \if (ret != 0)                                                            \{                                                                        \std::cerr << "Cuda failure: " << ret << std::endl;                   \abort();                                                             \}                                                                        \} while (0)

class Logger : public nvinfer1::ILogger
{
public:Logger(Severity severity = Severity::kWARNING) : severity_(severity) {}virtual void log(Severity severity, const char* msg) noexcept override{// suppress info-level messagesif(severity <= severity_)std::cout << msg << std::endl;}nvinfer1::ILogger& getTRTLogger() noexcept{return *this;}
private:Severity severity_;
};

struct InferDeleter
{template <typename T>void operator()(T* obj) const{delete obj;}
};template <typename T>
using SampleUniquePtr = std::unique_ptr<T, InferDeleter>;

（1）加载模型

Logger logger(nvinfer1::ILogger::Severity::kVERBOSE);/*trtexec.exe --onnx=inference_model\model.onnx --explicitBatch --fp16 --minShapes=x:1x3x540x960 --optShapes=x:1x3x720x1280 --maxShapes=x:1x3x1080x1920 --saveEngine=model.trt*/std::string trtFile = R"(C:\Users\wanggao\Desktop\123\inference_model_0\model.trt)";//std::string trtFile = "model.test.trt";std::ifstream ifs(trtFile, std::ifstream::binary);if(!ifs) {return false;}ifs.seekg(0, std::ios_base::end);int size = ifs.tellg();ifs.seekg(0, std::ios_base::beg);std::unique_ptr<char> pData(new char[size]);ifs.read(pData.get(), size);ifs.close();// engine模型//SampleUniquePtr<nvinfer1::IRuntime> runtime{nvinfer1::createInferRuntime(logger.getTRTLogger())};//auto mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(//    runtime->deserializeCudaEngine(pData.get(), size), InferDeleter());//auto context = SampleUniquePtr<nvinfer1::IExecutionContext>(mEngine->createExecutionContext());std::shared_ptr<nvinfer1::ICudaEngine> mEngine;{SampleUniquePtr<nvinfer1::IRuntime> runtime{nvinfer1::createInferRuntime(logger.getTRTLogger())};mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(runtime->deserializeCudaEngine(pData.get(), size), InferDeleter());}auto context = SampleUniquePtr<nvinfer1::IExecutionContext>(mEngine->createExecutionContext());

（2）输入
将RGB三通道图像转换为NCHW格式数据，数据类型为float。

    // 输入 前处理//cv::Mat img = cv::imread("dog.jpg");cv::Mat img = cv::imread(R"(C:\Users\wanggao\Desktop\123\data\test\t.jpg)");cv::Mat blob = cv::dnn::blobFromImage(img, 1 / 255., img.size(), {0,0,0}, true, false);//blob = blob * 2 - 1;  // 测试使用，可以不归一化

（3）显存分配
不同于固定输入，通过engine获取尺寸并分配显存大小

	// 固定输入尺寸的显存分配方式std::vector<void*> bindings(mEngine->getNbBindings());for (int i = 0; i < bindings.size(); i++) {nvinfer1::DataType type = mEngine->getBindingDataType(i);nvinfer1::Dims dims = mEngine->getBindingDimensions(i);//size_t volume = //   sizeof(float) * std::accumulate(dims.d,dims.d + dims.nbDims,1,std::multiplies<size_t>());size_t volume = std::accumulate(dims.d,dims.d + dims.nbDims,1,std::multiplies<size_t>());switch (type){case nvinfer1::DataType::kINT32:case nvinfer1::DataType::kFLOAT: volume *= 4; break;  // 明确为类型 floatcase nvinfer1::DataType::kHALF: volume *= 2; break;case nvinfer1::DataType::kBOOL:case nvinfer1::DataType::kINT8:default:break;}CHECK(cudaMalloc(&bindings[i],volume));}

这里通过模型获取的输入类型为float尺寸为[-1,3,1,1]、输出类型为int32尺寸为[-1,-1,-1]，即获取不到尺寸信息。所以，只能根据输入的尺寸来分配显存大小。(文后说明在实际推理中应该如何分配)

	// 设置网络的输入尺寸context->setBindingDimensions(0, nvinfer1::Dims4{1, 3 , img.rows, img.cols});// 分配显存std::vector<void*> bindings(mEngine->getNbBindings()); //auto type1 = mEngine->getBindingDataType(0);  // kFLOAT  float//auto type2 = mEngine->getBindingDataType(1);  // kINT32  intCHECK(cudaMalloc(&bindings[0], sizeof(float) * 1 * 3 * img.rows * img.cols*3));    // n*3*h*wCHECK(cudaMalloc(&bindings[1], sizeof(int) * 1 * 1 * img.rows * img.cols*3));   // n*1*h*w

注意，必须通过context->setBindingDimensions()设置网络的输入尺寸，否则网络在推理时报错，即输入维度未指定，导出网络输出无结果。

3: [executionContext.cpp::nvinfer1::rt::ShapeMachineContext::resolveSlots::1541] Error Code 3: API Usage Error (Parameter check failed at: executionContext.cpp::nvinfer1::rt::ShapeMachineContext::resolveSlots::1541, condition: allInputDimensionsSpecified(routine)
)
9: [executionContext.cpp::nvinfer1::rt::ExecutionContext::executeInternal::564] Error Code 9: Internal Error (Could not resolve slots: )

（4）推理
将前处理后的图片数据拷贝到显存中，之后进行推理，之后将推理结果数据从显存拷贝到内存中

    cv::Mat pred(img.size(), CV_32SC1, {255,255,255}); // 用于输出//cv::reduceArgMax()  //opencv 4.8.0//buffers.copyInputToDevice();CHECK(cudaMemcpy(bindings[0], static_cast<const void*>(blob.data), 3 * img.rows * img.cols * sizeof(float), cudaMemcpyHostToDevice));context->executeV2(bindings.data());// buffers.copyOutputToHost()CHECK(cudaMemcpy(static_cast<void*>(pred.data), bindings[1], pred.total() * sizeof(int), cudaMemcpyDeviceToHost));

（5）结果数据展示（后处理）
这里仅显示，运行截图如下
在这里插入图片描述

2.3、显存分配问题

在示例中，我们根据图片大小来分配显存，实际应用将进行多次推理，有多种方案：

1、根据实际输入大小，每次进行动态分配（使用完后释放原已分配显存）
2、在1基础上，如果显存不够再分配（分配前释放原已分配显存）
3、预分配一块较大的显存，程序退出时释放显存

为提高效率，我们可以选择第三种，已知我们动态输入最大尺寸为 --maxShapes=x:1x3x1080x1920，因此我们直接根据网络输入输出类型分配显存

    std::vector<void*> bindings(mEngine->getNbBindings());  // 1个输入，1个输出CHECK(cudaMalloc(&bindings[0], sizeof(float) * 1 * 3 * 1280 * 1920)); // n*3*h*wCHECK(cudaMalloc(&bindings[1], sizeof(int) * 1 * 1 * * 1280 * 1920)); // n*1*h*w

当输入尺寸超过我们设置的 maxShapes 时，context->setBindingDimensions()将报异常提示，这一种情况就不应该继续执行分配显存，属于输出错误。

2.4、完整代码

#include "opencv2\opencv.hpp"#include "NvInfer.h"
#include <cuda_runtime_api.h>
#include <random>//using namespace nvinfer1;
//using samplesCommon::SampleUniquePtr;#include <fstream>
#include <string>#define CHECK(status)                                                                \do                                                                               \{                                                                                \auto ret = (status);                                                         \if (ret != 0)                                                                \{                                                                            \std::cerr << "Cuda failure: " << ret << std::endl;                       \abort();                                                                 \}                                                                            \} while (0)class Logger : public nvinfer1::ILogger
{
public:Logger(Severity severity = Severity::kWARNING) : severity_(severity) {}virtual void log(Severity severity, const char* msg) noexcept override {// suppress info-level messagesif(severity <= severity_)std::cout << msg << std::endl;}nvinfer1::ILogger& getTRTLogger() noexcept{return *this;}
private:Severity severity_;
};struct InferDeleter
{template <typename T>void operator()(T* obj) const{delete obj;}
};template <typename T>
using SampleUniquePtr = std::unique_ptr<T, InferDeleter>;int inference();int main(int argc, char** argv)
{return inference();
}int inference()
{Logger logger(nvinfer1::ILogger::Severity::kVERBOSE);/*trtexec.exe --onnx=inference_model\model.onnx --explicitBatch --fp16 --minShapes=x:1x3x540x960 --optShapes=x:1x3x720x1280 --maxShapes=x:1x3x1080x1920 --saveEngine=model.trt*/std::string trtFile = R"(C:\Users\wanggao\Desktop\123\inference_model_0\model.trt)";//std::string trtFile = "model.test.trt";std::ifstream ifs(trtFile, std::ifstream::binary);if(!ifs) {return false;}ifs.seekg(0, std::ios_base::end);int size = ifs.tellg();ifs.seekg(0, std::ios_base::beg);std::unique_ptr<char> pData(new char[size]);ifs.read(pData.get(), size);ifs.close();// engine模型//SampleUniquePtr<nvinfer1::IRuntime> runtime{nvinfer1::createInferRuntime(logger.getTRTLogger())};//auto mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(//    runtime->deserializeCudaEngine(pData.get(), size), InferDeleter());//auto context = SampleUniquePtr<nvinfer1::IExecutionContext>(mEngine->createExecutionContext());std::shared_ptr<nvinfer1::ICudaEngine> mEngine;{SampleUniquePtr<nvinfer1::IRuntime> runtime{nvinfer1::createInferRuntime(logger.getTRTLogger())};mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(runtime->deserializeCudaEngine(pData.get(), size), InferDeleter());}auto context = SampleUniquePtr<nvinfer1::IExecutionContext>(mEngine->createExecutionContext());// 输入//cv::Mat img = cv::imread("dog.jpg");cv::Mat img = cv::imread(R"(C:\Users\wanggao\Desktop\123\data\test\t.jpg)");cv::Mat blob = cv::dnn::blobFromImage(img, 1 / 255., img.size(), {0,0,0}, true, false);//blob = blob * 2 - 1;cv::Mat pred(img.size(), CV_32SC1, {255,255,255});//cv::reduceArgMax() //4.8.0context->setBindingDimensions(0, nvinfer1::Dims4{1, 3 , img.rows, img.cols});// 分配显存std::vector<void*> bindings(mEngine->getNbBindings()); //auto type1 = mEngine->getBindingDataType(0);  // kFLOAT  float//auto type2 = mEngine->getBindingDataType(1);  // kINT32  intCHECK(cudaMalloc(&bindings[0], sizeof(float) * 1 * 3 * img.rows * img.cols*3));    // n*3*h*wCHECK(cudaMalloc(&bindings[1], sizeof(int) * 1 * 1 * img.rows * img.cols*3));   // n*1*h*w// 推理// warmingup ...CHECK(cudaMemcpy(bindings[0], static_cast<const void*>(blob.data), 1 * 3 * 640 * 640 * sizeof(float), cudaMemcpyHostToDevice));context->executeV2(bindings.data());context->executeV2(bindings.data());context->executeV2(bindings.data());context->executeV2(bindings.data());CHECK(cudaMemcpy(static_cast<void*>(pred.data), bindings[1], 1 * 84 * 8400 * sizeof(int), cudaMemcpyDeviceToHost));auto t1 = cv::getTickCount();//buffers.copyInputToDevice();CHECK(cudaMemcpy(bindings[0], static_cast<const void*>(blob.data), 3 * img.rows * img.cols * sizeof(float), cudaMemcpyHostToDevice));context->executeV2(bindings.data());// buffers.copyOutputToHost()CHECK(cudaMemcpy(static_cast<void*>(pred.data), bindings[1], pred.total() * sizeof(int), cudaMemcpyDeviceToHost));auto t2 = cv::getTickCount();std::cout << (t2-t1) / cv::getTickFrequency() << std::endl;// 资源释放cudaFree(bindings[0]);cudaFree(bindings[1]);return 0;
}