devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于RESNET网络实现tensorrt转换教程(onnx转engine和wts转engine)

作者：盐析白兔 | 2024-04-02 06:19:14

赞

踩

onnx转为tensorrt的engine模型

近日很想验证使用pytorch训练模型转tensorrt各种关系，更深理解基于C++ API接口engine加速理论(Python API接口稍微简单，将不在验证)，本文基于ResNet分类网络。

本文内容主要分为六个内容，第一个内容介绍使用python构建网络，获取pt/wts/onnx文件；第二个内容介绍基于C++ API构建engine；第三个内容介绍基于C++使用onnx构建

engine；第四个内容介绍windows性能及linux性能(添加于20220914)；第五个内容介绍验证；第六个内容介绍如何在Linux环境下编译engine且运行。

代码：ResNet.zip

链接：https://pan.baidu.com/s/1ujX19IUV0EPSIMyIcBnClA?pwd=r63z  
提取码：r63z

                                                                      版本：tensorrt版本8.4，可使用8.0以上版本

 一.使用torchvision获得wts  onnx   编译语言:python

 ①.此代码通过调用torchvision获得resnet18分类权重，并转换为wts和onnx

  1. from torchvision.transforms import transforms
  2. import torch
  3. import torchvision.models as models
  4. import struct
  5.  
  6. transform_train = transforms.Compose([
  7.     transforms.ToTensor(),
  8.     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
  9. ])
  10. transforms_test = transforms.Compose([
  11.     transforms.ToTensor(),
  12.     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
  13. ])
  14.  
  15.  
  16.  
  17. def build_model():
  18.     model = models.resnet18(pretrained=True)
  19.     model = model.eval()
  20.     model = model.cuda()
  21.     torch.save(model, "./resnet18.pth")
  22.  
  23.  
  24.  
  25.  
  26. def get_wts(model_path='./resnet18.pth',save_wts_path="./resnet18.wts"):
  27.     net = torch.load(model_path)
  28.  
  29.     net = net.cuda()
  30.     net = net.eval()
  31.     print('model: ', net)
  32.     # print('state dict: ', net.state_dict().keys())
  33.     tmp = torch.ones(1, 3, 224, 224).cuda()
  34.     print('input: ', tmp)
  35.     out = net(tmp)
  36.  
  37.     print('output:', out)
  38.  
  39.  
  40.     f = open(save_wts_path, 'w')
  41.     f.write("{}\n".format(len(net.state_dict().keys())))
  42.     for k, v in net.state_dict().items():
  43.         print('key: ', k)
  44.         print('value: ', v.shape)
  45.         vr = v.reshape(-1).cpu().numpy()
  46.         f.write("{} {}".format(k, len(vr)))
  47.         for vv in vr:
  48.             f.write(" ")
  49.             f.write(struct.pack(">f", float(vv)).hex())
  50.         f.write("\n")
  51.  
  52. def get_onnx(model_path='./resnet18.pth',save_onnx_path="./resnet18.onnx"):
  53.     # 定义静态onnx，若推理input_data格式不一致，将导致保存
  54.     input_data = torch.randn(2, 3, 224, 224).cuda()
  55.     model = torch.load(model_path).cuda()
  56.     input_names = ["data"] + ["called_%d" % i for i in range(2)]
  57.     output_names = ["prob"]
  58.     torch.onnx.export(
  59.         model,
  60.         input_data,
  61.         save_onnx_path,
  62.         verbose=True,
  63.         input_names=input_names,
  64.         output_names=output_names
  65.     )
  66.  
  67.  
  68.  
  69. if __name__ == '__main__':
  70.     # build_model()
  71.     # get_wts(model_path='./resnet18.pth',save_wts_path="./resnet18.wts")
  72.  
  73.     get_onnx(model_path='./resnet18.pth', save_onnx_path="./resnet18.onnx")
resnet分类之python

 二.Resnet分类采用C++ API 转换tensorrt  编译语言:C++/tensorrt 

 ①.此代码为resnet分类转换为tensorrt代码，已可使用visualstudi编译器

resnet18.cpp文件

  1. #include "NvInfer.h"
  2. #include "cuda_runtime_api.h"
  3. //#include "logging.h"
  4. #include <fstream>
  5. #include <iostream>
  6. #include <map>
  7. #include <sstream>
  8. #include <vector>
  9. #include <chrono>
  10. #include <cmath>
  11. #include <cassert>
  12.  
  13.  
  14. #include<opencv2/core/core.hpp>
  15. #include<opencv2/highgui/highgui.hpp>
  16. #include <opencv2/opencv.hpp>
  17.  
  18.  
  19.  
  20. using namespace std;
  21.  
  22. #define CHECK(status) \
  23.     do\
  24.     {\
  25.         auto ret = (status);\
  26.         if (ret != 0)\
  27.         {\
  28.             std::cerr << "Cuda failure: " << ret << std::endl;\
  29.             abort();\
  30.         }\
  31.     } while (0)
  32.  
  33. // stuff we know about the network and the input/output blobs
  34. static const int INPUT_H = 224;
  35. static const int INPUT_W = 224;
  36. static const int OUTPUT_SIZE = 1000;
  37.  
  38. const char* INPUT_BLOB_NAME = "data";
  39. const char* OUTPUT_BLOB_NAME = "prob";
  40.  
  41. using namespace nvinfer1;
  42.  
  43. //static Logger gLogger;
  44.  
  45. //构建Logger
  46. class Logger : public ILogger
  47. {
  48.     void log(Severity severity, const char* msg) noexcept override
  49.     {
  50.         // suppress info-level messages
  51.         if (severity <= Severity::kWARNING)
  52.             std::cout << msg << std::endl;
  53.     }
  54. } gLogger;
  55.  
  56.  
  57. // Load weights from files shared with TensorRT samples.
  58. // TensorRT weight files have a simple space delimited format:
  59. // [type] [size] <data x size in hex>
  60. std::map<std::string, Weights> loadWeights(const std::string file)
  61. {
  62.     std::cout << "Loading weights: " << file << std::endl;
  63.     std::map<std::string, Weights> weightMap;
  64.  
  65.     // Open weights file
  66.     std::ifstream input(file);
  67.     assert(input.is_open() && "Unable to load weight file.");
  68.  
  69.     // Read number of weight blobs
  70.     int32_t count;
  71.     input >> count;
  72.     assert(count > 0 && "Invalid weight map file.");
  73.  
  74.     while (count--)
  75.     {
  76.         Weights wt{ DataType::kFLOAT, nullptr, 0 };
  77.         uint32_t size;
  78.  
  79.         // Read name and type of blob
  80.         std::string name;
  81.         input >> name >> std::dec >> size;
  82.         wt.type = DataType::kFLOAT;
  83.  
  84.         // Load blob
  85.         uint32_t* val = reinterpret_cast<uint32_t*>(malloc(sizeof(val) * size));
  86.         for (uint32_t x = 0, y = size; x < y; ++x)
  87.         {
  88.             input >> std::hex >> val[x];
  89.         }
  90.         wt.values = val;
  91.  
  92.         wt.count = size;
  93.         weightMap[name] = wt;
  94.     }
  95.  
  96.     return weightMap;
  97. }
  98.  
  99. IScaleLayer* addBatchNorm2d(INetworkDefinition* network, std::map<std::string, Weights>& weightMap, ITensor& input, std::string lname, float eps) {
  100.     float* gamma = (float*)weightMap[lname + ".weight"].values;
  101.     float* beta = (float*)weightMap[lname + ".bias"].values;
  102.     float* mean = (float*)weightMap[lname + ".running_mean"].values;
  103.     float* var = (float*)weightMap[lname + ".running_var"].values;
  104.     int len = weightMap[lname + ".running_var"].count;
  105.     std::cout << "len " << len << std::endl;
  106.  
  107.     float* scval = reinterpret_cast<float*>(malloc(sizeof(float) * len));
  108.     for (int i = 0; i < len; i++) {
  109.         scval[i] = gamma[i] / sqrt(var[i] + eps);
  110.     }
  111.     Weights scale{ DataType::kFLOAT, scval, len };
  112.  
  113.     float* shval = reinterpret_cast<float*>(malloc(sizeof(float) * len));
  114.     for (int i = 0; i < len; i++) {
  115.         shval[i] = beta[i] - mean[i] * gamma[i] / sqrt(var[i] + eps);
  116.     }
  117.     Weights shift{ DataType::kFLOAT, shval, len };
  118.  
  119.     float* pval = reinterpret_cast<float*>(malloc(sizeof(float) * len));
  120.     for (int i = 0; i < len; i++) {
  121.         pval[i] = 1.0;
  122.     }
  123.     Weights power{ DataType::kFLOAT, pval, len };
  124.  
  125.     weightMap[lname + ".scale"] = scale;
  126.     weightMap[lname + ".shift"] = shift;
  127.     weightMap[lname + ".power"] = power;
  128.     IScaleLayer* scale_1 = network->addScale(input, ScaleMode::kCHANNEL, shift, scale, power);
  129.     assert(scale_1);
  130.     return scale_1;
  131. }
  132.  
  133. IActivationLayer* basicBlock(INetworkDefinition* network, std::map<std::string, Weights>& weightMap, ITensor& input, int inch, int outch, int stride, std::string lname) {
  134.     Weights emptywts{ DataType::kFLOAT, nullptr, 0 };
  135.  
  136.     IConvolutionLayer* conv1 = network->addConvolutionNd(input, outch, DimsHW{ 3, 3 }, weightMap[lname + "conv1.weight"], emptywts);
  137.     assert(conv1);
  138.     conv1->setStrideNd(DimsHW{ stride, stride });
  139.     conv1->setPaddingNd(DimsHW{ 1, 1 });
  140.  
  141.     IScaleLayer* bn1 = addBatchNorm2d(network, weightMap, *conv1->getOutput(0), lname + "bn1", 1e-5);
  142.  
  143.     IActivationLayer* relu1 = network->addActivation(*bn1->getOutput(0), ActivationType::kRELU);
  144.     assert(relu1);
  145.  
  146.     IConvolutionLayer* conv2 = network->addConvolutionNd(*relu1->getOutput(0), outch, DimsHW{ 3, 3 }, weightMap[lname + "conv2.weight"], emptywts);
  147.     assert(conv2);
  148.     conv2->setPaddingNd(DimsHW{ 1, 1 });
  149.  
  150.     IScaleLayer* bn2 = addBatchNorm2d(network, weightMap, *conv2->getOutput(0), lname + "bn2", 1e-5);
  151.  
  152.     IElementWiseLayer* ew1;
  153.     if (inch != outch) {
  154.         IConvolutionLayer* conv3 = network->addConvolutionNd(input, outch, DimsHW{ 1, 1 }, weightMap[lname + "downsample.0.weight"], emptywts);
  155.         assert(conv3);
  156.         conv3->setStrideNd(DimsHW{ stride, stride });
  157.         IScaleLayer* bn3 = addBatchNorm2d(network, weightMap, *conv3->getOutput(0), lname + "downsample.1", 1e-5);
  158.         ew1 = network->addElementWise(*bn3->getOutput(0), *bn2->getOutput(0), ElementWiseOperation::kSUM);
  159.     }
  160.     else {
  161.         ew1 = network->addElementWise(input, *bn2->getOutput(0), ElementWiseOperation::kSUM);
  162.     }
  163.     IActivationLayer* relu2 = network->addActivation(*ew1->getOutput(0), ActivationType::kRELU);
  164.     assert(relu2);
  165.     return relu2;
  166. }
  167.  
  168. // Creat the engine using only the API and not any parser.
  169. ICudaEngine* createEngine(unsigned int maxBatchSize, IBuilder* builder, IBuilderConfig* config, DataType dt, string wts_path = "../resnet18.wts")
  170. {
  171.     INetworkDefinition* network = builder->createNetworkV2(0U);
  172.  
  173.     // Create input tensor of shape { 3, INPUT_H, INPUT_W } with name INPUT_BLOB_NAME
  174.     ITensor* data = network->addInput(INPUT_BLOB_NAME, dt, Dims3{ 3, INPUT_H, INPUT_W });
  175.     assert(data);
  176.  
  177.     std::map<std::string, Weights> weightMap = loadWeights(wts_path);
  178.     Weights emptywts{ DataType::kFLOAT, nullptr, 0 };
  179.  
  180.     IConvolutionLayer* conv1 = network->addConvolutionNd(*data, 64, DimsHW{ 7, 7 }, weightMap["conv1.weight"], emptywts);
  181.     assert(conv1);
  182.     conv1->setStrideNd(DimsHW{ 2, 2 });
  183.     conv1->setPaddingNd(DimsHW{ 3, 3 });
  184.  
  185.     IScaleLayer* bn1 = addBatchNorm2d(network, weightMap, *conv1->getOutput(0), "bn1", 1e-5);
  186.  
  187.     IActivationLayer* relu1 = network->addActivation(*bn1->getOutput(0), ActivationType::kRELU);
  188.     assert(relu1);
  189.  
  190.     IPoolingLayer* pool1 = network->addPoolingNd(*relu1->getOutput(0), PoolingType::kMAX, DimsHW{ 3, 3 });
  191.     assert(pool1);
  192.     pool1->setStrideNd(DimsHW{ 2, 2 });
  193.     pool1->setPaddingNd(DimsHW{ 1, 1 });
  194.  
  195.     IActivationLayer* relu2 = basicBlock(network, weightMap, *pool1->getOutput(0), 64, 64, 1, "layer1.0.");
  196.     IActivationLayer* relu3 = basicBlock(network, weightMap, *relu2->getOutput(0), 64, 64, 1, "layer1.1.");
  197.  
  198.     IActivationLayer* relu4 = basicBlock(network, weightMap, *relu3->getOutput(0), 64, 128, 2, "layer2.0.");
  199.     IActivationLayer* relu5 = basicBlock(network, weightMap, *relu4->getOutput(0), 128, 128, 1, "layer2.1.");
  200.  
  201.     IActivationLayer* relu6 = basicBlock(network, weightMap, *relu5->getOutput(0), 128, 256, 2, "layer3.0.");
  202.     IActivationLayer* relu7 = basicBlock(network, weightMap, *relu6->getOutput(0), 256, 256, 1, "layer3.1.");
  203.  
  204.     IActivationLayer* relu8 = basicBlock(network, weightMap, *relu7->getOutput(0), 256, 512, 2, "layer4.0.");
  205.     IActivationLayer* relu9 = basicBlock(network, weightMap, *relu8->getOutput(0), 512, 512, 1, "layer4.1.");
  206.  
  207.     IPoolingLayer* pool2 = network->addPoolingNd(*relu9->getOutput(0), PoolingType::kAVERAGE, DimsHW{ 7, 7 });
  208.     assert(pool2);
  209.     pool2->setStrideNd(DimsHW{ 1, 1 });
  210.  
  211.     IFullyConnectedLayer* fc1 = network->addFullyConnected(*pool2->getOutput(0), 1000, weightMap["fc.weight"], weightMap["fc.bias"]);
  212.     assert(fc1);
  213.  
  214.     fc1->getOutput(0)->setName(OUTPUT_BLOB_NAME);
  215.     std::cout << "set name out" << std::endl;
  216.     network->markOutput(*fc1->getOutput(0));
  217.  
  218.     // Build engine
  219.     builder->setMaxBatchSize(maxBatchSize);
  220.     config->setMaxWorkspaceSize(1 << 20);
  221.     //config->setFlag(nvinfer1::BuilderFlag::kFP16);
  222.  
  223.     ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);
  224.     std::cout << "build out" << std::endl;
  225.  
  226.     // Don't need the network any more
  227.     network->destroy();
  229.     // Release host memory
  230.     for (auto& mem : weightMap)
  231.     {
  232.         free((void*)(mem.second.values));
  233.     }
  235.     return engine;
  236. }
  238. void APIToModel(unsigned int maxBatchSize, IHostMemory** modelStream)
  239. {
  240.     string wts_path = "./resnet18.wts";
  241.     // Create builder
  242.     IBuilder* builder = createInferBuilder(gLogger);
  243.     IBuilderConfig* config = builder->createBuilderConfig();
  245.     // Create model to populate the network, then set the outputs and create an engine
  246.     ICudaEngine* engine = createEngine(maxBatchSize, builder, config, DataType::kFLOAT, wts_path = wts_path);
  247.     assert(engine != nullptr);
  249.     // Serialize the engine
  250.     (*modelStream) = engine->serialize();
  252.     // Close everything down
  253.     engine->destroy();
  254.     builder->destroy();
  255.     config->destroy();
  256. }
  258. void doInference(IExecutionContext& context, float* input, float* output, int batchSize)
  259. {
  260.     const ICudaEngine& engine = context.getEngine();
  262.     // Pointers to input and output device buffers to pass to engine.
  263.     // Engine requires exactly IEngine::getNbBindings() number of buffers.
  264.     assert(engine.getNbBindings() == 2);
  265.     void* buffers[2];
  267.     // In order to bind the buffers, we need to know the names of the input and output tensors.
  268.     // Note that indices are guaranteed to be less than IEngine::getNbBindings()
  269.     const int inputIndex = engine.getBindingIndex(INPUT_BLOB_NAME);
  270.     const int outputIndex = engine.getBindingIndex(OUTPUT_BLOB_NAME);
  272.     // Create GPU buffers on device
  273.     CHECK(cudaMalloc(&buffers[inputIndex], batchSize * 3 * INPUT_H * INPUT_W * sizeof(float)));
  274.     CHECK(cudaMalloc(&buffers[outputIndex], batchSize * OUTPUT_SIZE * sizeof(float)));
  276.     // Create stream
  277.     cudaStream_t stream;
  278.     CHECK(cudaStreamCreate(&stream));
  280.     // DMA input batch data to device, infer on the batch asynchronously, and DMA output back to host
  281.     CHECK(cudaMemcpyAsync(buffers[inputIndex], input, batchSize * 3 * INPUT_H * INPUT_W * sizeof(float), cudaMemcpyHostToDevice, stream));
  282.     context.enqueue(batchSize, buffers, stream, nullptr);
  283.     CHECK(cudaMemcpyAsync(output, buffers[outputIndex], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));
  284.     cudaStreamSynchronize(stream);
  286.     // Release stream and buffers
  287.     cudaStreamDestroy(stream);
  288.     CHECK(cudaFree(buffers[inputIndex]));
  289.     CHECK(cudaFree(buffers[outputIndex]));
  290. }
  293. //加工图片变成拥有batch的输入， tensorrt输入需要的格式，为一个维度
  294. void ProcessImage(cv::Mat image, float input_data[]) {
  295.     //只处理一张图片,总之结果为一维[batch*3*INPUT_W*INPUT_H]
  296.     //以下代码为投机取巧了
  298.     cv::resize(image, image, cv::Size(INPUT_W, INPUT_H), 0, 0, cv::INTER_LINEAR);
  299.     std::vector<cv::Mat> InputImage;
  301.     InputImage.push_back(image);
  305.     int ImgCount = InputImage.size();
  307.     //float input_data[BatchSize * 3 * INPUT_H * INPUT_W];
  308.     for (int b = 0; b < ImgCount; b++) {
  309.         cv::Mat img = InputImage.at(b);
  310.         int w = img.cols;
  311.         int h = img.rows;
  312.         int i = 0;
  313.         for (int row = 0; row < h; ++row) {
  314.             uchar* uc_pixel = img.data + row * img.step;
  315.             for (int col = 0; col < INPUT_W; ++col) {
  316.                 input_data[b * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;
  317.                 input_data[b * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;
  318.                 input_data[b * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;
  319.                 uc_pixel += 3;
  320.                 ++i;
  321.             }
  322.         }
  324.     }
  326. }
  328. int get_trtengine() {
  330.     IHostMemory* modelStream{ nullptr };
  331.     APIToModel(1, &modelStream);
  332.     assert(modelStream != nullptr);
  334.     std::ofstream p("./resnet18.engine", std::ios::binary);
  335.     if (!p)
  336.     {
  337.         std::cerr << "could not open plan output file" << std::endl;
  338.         return -1;
  339.     }
  340.     p.write(reinterpret_cast<const char*>(modelStream->data()), modelStream->size());
  341.     modelStream->destroy();
  345.     return 0;
  347. }
  349. int infer() {
  351.     //加载engine引擎
  352.     char* trtModelStream{ nullptr };
  353.     size_t size{ 0 };
  354.     std::ifstream file("./resnet18.engine", std::ios::binary);
  355.     if (file.good()) {
  356.         file.seekg(0, file.end);
  357.         size = file.tellg();
  358.         file.seekg(0, file.beg);
  359.         trtModelStream = new char[size];
  360.         assert(trtModelStream);
  361.         file.read(trtModelStream, size);
  362.         file.close();
  363.     }
  364.     //反序列为engine，创建context
  366.     IRuntime* runtime = createInferRuntime(gLogger);
  367.     assert(runtime != nullptr);
  368.     ICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream, size, nullptr);
  369.     assert(engine != nullptr);
  370.     IExecutionContext* context = engine->createExecutionContext();
  371.     assert(context != nullptr);
  372.     delete[] trtModelStream;
  376.     //*********************推理*********************//
  379.     //   循环推理
  380.     float time_read_img = 0.0;
  381.     float time_infer = 0.0;
  382.     static float prob[OUTPUT_SIZE];
  383.     for (int i = 0; i < 1000; i++) {
  385.         // 处理图片为固定输出
  386.         
  387.         auto start = std::chrono::system_clock::now();  //时间函数
  388.         std::string path = "./1.jpg";
  389.         std::cout << "img_path=" << path << endl;
  390.         static float data[3 * INPUT_H * INPUT_W];
  391.         cv::Mat img = cv::imread(path);
  392.         ProcessImage(img, data);
  393.         auto end = std::chrono::system_clock::now();
  394.         time_read_img = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() + time_read_img;
  396.         
  398.         //Run inference
  399.         start = std::chrono::system_clock::now();  //时间函数
  400.         doInference(*context, data, prob, 1);
  401.         end = std::chrono::system_clock::now();
  402.         time_infer = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() + time_infer;
  403.         std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
  405.         //输出后处理
  407.         //std::cout <<"prob="<<prob << std::endl;
  408.         float cls_float = prob[0];
  409.         int cls_id = 0;
  410.         for (int i = 0; i < OUTPUT_SIZE; i++) {
  412.             if (cls_float < prob[i]) {
  413.                 cls_float = prob[i];
  414.                 cls_id = i;
  415.             }
  416.         }
  417.         std::cout << "i=" << i << "\tcls_id=" << cls_id << "\t cls_float=" << cls_float << std::endl;
  421.     }
  422.    
  423.     std::cout << "C++2engine" << "mean read img time =" << time_read_img / 1000 << "ms\t" << "mean infer img time =" << time_infer / 1000 << "ms" << std::endl;
  424.     // Destroy the engine
  425.     context->destroy();
  426.     engine->destroy();
  427.     runtime->destroy();
  436.     return 0;
  437. }
  444. int main(int argc, char** argv)
  445. {
  452.     //string mode = argv[1];
  453.     string mode = "-d";  //适用windows编译，固定指定参数
  455.     //if (std::string(argv[1]) == "-s") {
  456.     if (mode == "-s") {
  457.         get_trtengine();
  458.     }
  459.     //else if (std::string(argv[1]) == "-d") {
  460.     else if (mode == "-d") {
  461.         infer();
  462.     }
  463.     else {
  464.         return -1;
  465.     }
  468.     return 0;
  469. }
resnet18.cpp

②.若需要linux系统运行可编译的CMakeLists.txt文件为:

  1. cmake_minimum_required(VERSION 2.6)
  2.  
  3. project(resnet)
  4.  
  5. add_definitions(-std=c++11)
  6.  
  7. option(CUDA_USE_STATIC_CUDA_RUNTIME OFF)
  8. set(CMAKE_CXX_STANDARD 11)
  9. set(CMAKE_BUILD_TYPE Debug)
  10.  
  11. include_directories(${PROJECT_SOURCE_DIR}/include)
  12. # include and link dirs of cuda and tensorrt, you need adapt them if yours are different
  13. # cuda
  14. include_directories(/usr/local/cuda/include)
  15. link_directories(/usr/local/cuda/lib64)
  16. # tensorrt
  17. include_directories(/usr/include/x86_64-linux-gnu/)
  18. link_directories(/usr/lib/x86_64-linux-gnu/)
  19.  
  20. add_executable(resnet18 ${PROJECT_SOURCE_DIR}/resnet18.cpp)
  21. target_link_libraries(resnet18 nvinfer)
  22. target_link_libraries(resnet18 cudart)
  23.  
  24.  
  25. add_definitions(-O2 -pthread)
CMakeLists.txt

③.visual studio预测结果：

总之测试2张图基本在一个大类中，应该没啥错误。

④.linux预测结果显示：

 三.Resnet分类采用C++ API  使用onnx 转换tensorrt  编译语言:C++/tensorrt 

①.此代码为resnet分类采用onnx转换为tensorrt代码，已可使用visualstudi编译器

resnet18.cpp文件

  1. #include "NvInfer.h"
  2. #include "cuda_runtime_api.h"
  3. #include <fstream>
  4. #include <iostream>
  5. #include <map>
  6. #include <sstream>
  7. #include <vector>
  8. #include <chrono>
  9. #include <cmath>
  10. #include <cassert>
  11.  
  12.  
  13. #include<opencv2/core/core.hpp>
  14. #include<opencv2/highgui/highgui.hpp>
  15. #include <opencv2/opencv.hpp>
  16.  
  17.  
  18. // onnx转换头文件
  19. #include "NvOnnxParser.h"
  20. using namespace nvonnxparser;
  21.  
  22.  
  23.  
  24.  
  25.  
  26. using namespace std;
  27.  
  28. #define CHECK(status) \
  29.     do\
  30.     {\
  31.         auto ret = (status);\
  32.         if (ret != 0)\
  33.         {\
  34.             std::cerr << "Cuda failure: " << ret << std::endl;\
  35.             abort();\
  36.         }\
  37.     } while (0)
  38.  
  39. // stuff we know about the network and the input/output blobs
  40. static const int INPUT_H = 224;
  41. static const int INPUT_W = 224;
  42. static const int OUTPUT_SIZE = 1000;
  43.  
  44. const char* INPUT_BLOB_NAME = "data";
  45. const char* OUTPUT_BLOB_NAME = "prob";
  46.  
  47. using namespace nvinfer1;
  48.  
  49. //static Logger gLogger;
  50.  
  51. //构建Logger
  52. class Logger : public ILogger
  53. {
  54.     void log(Severity severity, const char* msg) noexcept override
  55.     {
  56.         // suppress info-level messages
  57.         if (severity <= Severity::kWARNING)
  58.             std::cout << msg << std::endl;
  59.     }
  60. } gLogger;
  61.  
  62.  
  63.  
  64.  
  65.  
  66. // Creat the engine using only the API and not any parser.
  67. ICudaEngine* createEngine(unsigned int maxBatchSize, IBuilder* builder, IBuilderConfig* config)
  68. {
  69.  
  70.     const char* onnx_path = "./resnet18.onnx";
  71.  
  72.     INetworkDefinition* network = builder->createNetworkV2(1U); //此处重点1U为OU就有问题
  73.  
  74.  
  75.  
  76.  
  77.     IParser* parser = createParser(*network, gLogger);
  78.     parser->parseFromFile(onnx_path, static_cast<int32_t>(ILogger::Severity::kWARNING));
  79.  
  80.     for (int32_t i = 0; i < parser->getNbErrors(); ++i) { std::cout << parser->getError(i)->desc() << std::endl; }
  81.  
  82.     std::cout << "successfully load the onnx model" << std::endl;
  83.  
  84.  
  85.     // Build engine
  86.     builder->setMaxBatchSize(maxBatchSize);
  87.     config->setMaxWorkspaceSize(1 << 20);
  88.     config->setFlag(nvinfer1::BuilderFlag::kFP16); // 设置精度计算
  89.     //config->setFlag(nvinfer1::BuilderFlag::kINT8);
  90.     ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);
  91.     std::cout << "successfully  create engine " << std::endl;
  92.  
  93.     //销毁
  94.     network->destroy();
  95.     parser->destroy();
  96.  
  97.     return engine;
  98. }
  99.  
  100. void APIToModel(unsigned int maxBatchSize, IHostMemory** modelStream)
  101. {
  102.  
  103.     // Create builder
  104.     IBuilder* builder = createInferBuilder(gLogger);
  105.     IBuilderConfig* config = builder->createBuilderConfig();
  106.  
  107.     // Create model to populate the network, then set the outputs and create an engine
  108.     ICudaEngine* engine = createEngine(maxBatchSize, builder, config);
  109.  
  110.  
  111.     assert(engine != nullptr);
  112.  
  113.     // Serialize the engine
  114.     (*modelStream) = engine->serialize();
  115.  
  116.     // Close everything down
  117.     engine->destroy();
  118.     builder->destroy();
  119.     config->destroy();
  120. }
  121.  
  122. void doInference(IExecutionContext& context, float* input, float* output, int batchSize)
  123. {
  124.     const ICudaEngine& engine = context.getEngine();
  125.  
  126.     // Pointers to input and output device buffers to pass to engine.
  127.     // Engine requires exactly IEngine::getNbBindings() number of buffers.
  128.     assert(engine.getNbBindings() == 2);
  129.     void* buffers[2];
  130.  
  131.     // In order to bind the buffers, we need to know the names of the input and output tensors.
  132.     // Note that indices are guaranteed to be less than IEngine::getNbBindings()
  133.     const int inputIndex = engine.getBindingIndex(INPUT_BLOB_NAME);
  134.     const int outputIndex = engine.getBindingIndex(OUTPUT_BLOB_NAME);
  135.  
  136.     // Create GPU buffers on device
  137.     CHECK(cudaMalloc(&buffers[inputIndex], batchSize * 3 * INPUT_H * INPUT_W * sizeof(float)));
  138.     CHECK(cudaMalloc(&buffers[outputIndex], batchSize * OUTPUT_SIZE * sizeof(float)));
  139.  
  140.     // Create stream
  141.     cudaStream_t stream;
  142.     CHECK(cudaStreamCreate(&stream));
  143.  
  144.     // DMA input batch data to device, infer on the batch asynchronously, and DMA output back to host
  145.     CHECK(cudaMemcpyAsync(buffers[inputIndex], input, batchSize * 3 * INPUT_H * INPUT_W * sizeof(float), cudaMemcpyHostToDevice, stream));
  146.     context.enqueue(batchSize, buffers, stream, nullptr);
  147.     CHECK(cudaMemcpyAsync(output, buffers[outputIndex], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));
  148.     cudaStreamSynchronize(stream);
  149.  
  150.     // Release stream and buffers
  151.     cudaStreamDestroy(stream);
  152.     CHECK(cudaFree(buffers[inputIndex]));
  153.     CHECK(cudaFree(buffers[outputIndex]));
  154. }
  155.  
  156.  
  157. //加工图片变成拥有batch的输入， tensorrt输入需要的格式，为一个维度
  158. void ProcessImage(cv::Mat image, float input_data[]) {
  159.     //只处理一张图片,总之结果为一维[batch*3*INPUT_W*INPUT_H]
  160.     //以下代码为投机取巧了
  161.  
  162.     cv::resize(image, image, cv::Size(INPUT_W, INPUT_H), 0, 0, cv::INTER_LINEAR);
  163.     std::vector<cv::Mat> InputImage;
  164.  
  165.     InputImage.push_back(image);
  166.  
  167.  
  168.  
  169.     int ImgCount = InputImage.size();
  170.  
  171.     //float input_data[BatchSize * 3 * INPUT_H * INPUT_W];
  172.     for (int b = 0; b < ImgCount; b++) {
  173.         cv::Mat img = InputImage.at(b);
  174.         int w = img.cols;
  175.         int h = img.rows;
  176.         int i = 0;
  177.         for (int row = 0; row < h; ++row) {
  178.             uchar* uc_pixel = img.data + row * img.step;
  179.             for (int col = 0; col < INPUT_W; ++col) {
  180.                 input_data[b * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;
  181.                 input_data[b * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;
  182.                 input_data[b * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;
  183.                 uc_pixel += 3;
  184.                 ++i;
  185.             }
  186.         }
  187.  
  188.     }
  189.  
  190. }
  191.  
  192. int get_trtengine() {
  193.  
  194.     IHostMemory* modelStream{ nullptr };
  195.     APIToModel(1, &modelStream);
  196.     assert(modelStream != nullptr);
  197.  
  198.     std::ofstream p("./resnet18.engine", std::ios::binary);
  199.     if (!p)
  200.     {
  201.         std::cerr << "could not open plan output file" << std::endl;
  202.         return -1;
  203.     }
  204.     p.write(reinterpret_cast<const char*>(modelStream->data()), modelStream->size());
  205.     modelStream->destroy();
  206.  
  207.     return 0;
  208.  
  209. }
  210.  
  211. int infer() {
  212.  
  213.     //加载engine引擎
  214.     char* trtModelStream{ nullptr };
  215.     size_t size{ 0 };
  216.     std::ifstream file("./resnet18.engine", std::ios::binary);
  217.     if (file.good()) {
  218.         file.seekg(0, file.end);
  219.         size = file.tellg();
  220.         file.seekg(0, file.beg);
  221.         trtModelStream = new char[size];
  222.         assert(trtModelStream);
  223.         file.read(trtModelStream, size);
  224.         file.close();
  225.     }
  226.     //反序列为engine，创建context
  227.  
  228.     IRuntime* runtime = createInferRuntime(gLogger);
  229.     assert(runtime != nullptr);
  230.     ICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream, size, nullptr);
  231.     assert(engine != nullptr);
  232.     IExecutionContext* context = engine->createExecutionContext();
  233.     assert(context != nullptr);
  234.     delete[] trtModelStream;
  235.  
  236.  
  237.  
  238.     //*********************推理*********************//
  239.  
  240.  
  241.     //   循环推理
  242.  
  243.  
  244.     float time_read_img = 0.0;
  245.     float time_infer = 0.0;
  246.     static float prob[OUTPUT_SIZE];
  247.     for (int i = 0; i < 1000; i++) {
  248.  
  249.         // 处理图片为固定输出
  250.  
  251.         auto start = std::chrono::system_clock::now();  //时间函数
  252.         std::string path = "./1.jpg";
  253.         std::cout << "img_path=" << path << endl;
  254.         static float data[3 * INPUT_H * INPUT_W];
  255.         cv::Mat img = cv::imread(path);
  256.         ProcessImage(img, data);
  257.         auto end = std::chrono::system_clock::now();
  258.         time_read_img = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() + time_read_img;
  259.  
  260.  
  261.  
  262.         //Run inference
  263.         start = std::chrono::system_clock::now();  //时间函数
  264.         doInference(*context, data, prob, 1);
  265.         end = std::chrono::system_clock::now();
  266.         time_infer = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() + time_infer;
  267.         std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
  268.  
  269.         //输出后处理
  270.         //std::cout <<"prob="<<prob << std::endl;
  271.         float cls_float = prob[0];
  272.         int cls_id = 0;
  273.         for (int i = 0; i < OUTPUT_SIZE; i++) {
  274.             if (cls_float < prob[i]) {
  275.                 cls_float = prob[i];
  276.                 cls_id = i;
  277.             }
  278.         }
  279.         std::cout << "i=" << i << "\tcls_id=" << cls_id << "\t cls_float=" << cls_float << std::endl;
  280.     }
  281.  
  282.     std::cout << "C++2engine" << "mean read img time =" << time_read_img / 1000 << "ms\t" << "mean infer img time =" << time_infer / 1000 << "ms" << std::endl;
  283.     
  284.  
  285.  
  286.  
  287.  
  288.  
  289.     // Destroy the engine
  290.     context->destroy();
  291.     engine->destroy();
  292.     runtime->destroy();
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301.     return 0;
  302. }
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309. int main(int argc, char** argv)
  310. {
  311.  
  312.     //string mode = argv[1];
  313.     string mode = "-d";  //适用windows编译，固定指定参数
  314.  
  315.     //if (std::string(argv[1]) == "-s") {
  316.     if (mode == "-s") {
  317.         get_trtengine();
  318.     }
  319.     //else if (std::string(argv[1]) == "-d") {
  320.     else if (mode == "-d") {
  321.         infer();
  322.     }
  323.     else {
  324.         return -1;
  325.     }
  326.  
  327.  
  328.     return 0;
  329. }
resnet18.cpp

windows visual studio tensorrt8.4版本 onnx转engine展示

 ②.使用onnx-simpiler 进行优化onnx，但已是最简化，但若能简化，猜想预测会更快一些。

四.性能测试

性能测试结果(测试平台：windows10 cuda11.4 tensorrt8.4  RTX 2060)：

 性能测试结果(测试平台：Linux ubuntu18.4 cuda11.3  tensorrt8.2  RTX 2060)(添加：20220914)：

 注：检测1000张的平均时间

说明 window10与ubuntu是2个独立设备(电脑)，读图主要是CPU处理代码，后期可改成CUDA处理提速。

五.验证

①.使用python将onnx转为engine引擎，使用C++调用验证。

结论:windows系统 可行！  很令人兴奋，意味着使用python转换为engine，将可以使用C++调用，无需再使用C++创建engine。

注:推理时间变长了快2倍。

python代码将其转为engine库，注：使用同样的tensorrt版本

onnx2engine.py

C++推理代码(使用二或三中推理也可以)，此代码已简化:

  1. #include "NvInfer.h"
  2. #include "cuda_runtime_api.h"
  3. #include <fstream>
  4. #include <iostream>
  5. #include <map>
  6. #include <sstream>
  7. #include <vector>
  8. #include <chrono>
  9. #include <cmath>
  10. #include <cassert>
  11.  
  12.  
  13. #include<opencv2/core/core.hpp>
  14. #include<opencv2/highgui/highgui.hpp>
  15. #include <opencv2/opencv.hpp>
  16.  
  17.  
  18.  
  19.  
  20. using namespace std;
  21.  
  22. #define CHECK(status) \
  23.     do\
  24.     {\
  25.         auto ret = (status);\
  26.         if (ret != 0)\
  27.         {\
  28.             std::cerr << "Cuda failure: " << ret << std::endl;\
  29.             abort();\
  30.         }\
  31.     } while (0)
  32.  
  33. // stuff we know about the network and the input/output blobs
  34. static const int INPUT_H = 224;
  35. static const int INPUT_W = 224;
  36. static const int OUTPUT_SIZE = 1000;
  37.  
  38. const char* INPUT_BLOB_NAME = "data";
  39. const char* OUTPUT_BLOB_NAME = "prob";
  40.  
  41. using namespace nvinfer1;
  42.  
  43. //static Logger gLogger;
  44.  
  45. //构建Logger
  46. class Logger : public ILogger
  47. {
  48.     void log(Severity severity, const char* msg) noexcept override
  49.     {
  50.         // suppress info-level messages
  51.         if (severity <= Severity::kWARNING)
  52.             std::cout << msg << std::endl;
  53.     }
  54. } gLogger;
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62. void doInference(IExecutionContext& context, float* input, float* output, int batchSize)
  63. {
  64.     const ICudaEngine& engine = context.getEngine();
  65.  
  66.     // Pointers to input and output device buffers to pass to engine.
  67.     // Engine requires exactly IEngine::getNbBindings() number of buffers.
  68.     assert(engine.getNbBindings() == 2);
  69.     void* buffers[2];
  70.  
  71.     // In order to bind the buffers, we need to know the names of the input and output tensors.
  72.     // Note that indices are guaranteed to be less than IEngine::getNbBindings()
  73.     const int inputIndex = engine.getBindingIndex(INPUT_BLOB_NAME);
  74.     const int outputIndex = engine.getBindingIndex(OUTPUT_BLOB_NAME);
  75.  
  76.     // Create GPU buffers on device
  77.     CHECK(cudaMalloc(&buffers[inputIndex], batchSize * 3 * INPUT_H * INPUT_W * sizeof(float)));
  78.     CHECK(cudaMalloc(&buffers[outputIndex], batchSize * OUTPUT_SIZE * sizeof(float)));
  79.  
  80.     // Create stream
  81.     cudaStream_t stream;
  82.     CHECK(cudaStreamCreate(&stream));
  83.  
  84.     // DMA input batch data to device, infer on the batch asynchronously, and DMA output back to host
  85.     CHECK(cudaMemcpyAsync(buffers[inputIndex], input, batchSize * 3 * INPUT_H * INPUT_W * sizeof(float), cudaMemcpyHostToDevice, stream));
  86.     context.enqueue(batchSize, buffers, stream, nullptr);
  87.     CHECK(cudaMemcpyAsync(output, buffers[outputIndex], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));
  88.     cudaStreamSynchronize(stream);
  89.  
  90.     // Release stream and buffers
  91.     cudaStreamDestroy(stream);
  92.     CHECK(cudaFree(buffers[inputIndex]));
  93.     CHECK(cudaFree(buffers[outputIndex]));
  94. }
  95.  
  96.  
  97. //加工图片变成拥有batch的输入， tensorrt输入需要的格式，为一个维度
  98. void ProcessImage(cv::Mat image, float input_data[]) {
  99.     //只处理一张图片,总之结果为一维[batch*3*INPUT_W*INPUT_H]
  100.     //以下代码为投机取巧了
  101.  
  102.     cv::resize(image, image, cv::Size(INPUT_W, INPUT_H), 0, 0, cv::INTER_LINEAR);
  103.     std::vector<cv::Mat> InputImage;
  104.  
  105.     InputImage.push_back(image);
  106.  
  107.  
  108.  
  109.     int ImgCount = InputImage.size();
  110.  
  111.     //float input_data[BatchSize * 3 * INPUT_H * INPUT_W];
  112.     for (int b = 0; b < ImgCount; b++) {
  113.         cv::Mat img = InputImage.at(b);
  114.         int w = img.cols;
  115.         int h = img.rows;
  116.         int i = 0;
  117.         for (int row = 0; row < h; ++row) {
  118.             uchar* uc_pixel = img.data + row * img.step;
  119.             for (int col = 0; col < INPUT_W; ++col) {
  120.                 input_data[b * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;
  121.                 input_data[b * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;
  122.                 input_data[b * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;
  123.                 uc_pixel += 3;
  124.                 ++i;
  125.             }
  126.         }
  127.  
  128.     }
  129.  
  130. }
  131.  
  132.  
  133. int infer() {
  134.  
  135.     //加载engine引擎
  136.     char* trtModelStream{ nullptr };
  137.     size_t size{ 0 };
  138.     std::ifstream file("./resnet18.engine", std::ios::binary);
  139.     if (file.good()) {
  140.         file.seekg(0, file.end);
  141.         size = file.tellg();
  142.         file.seekg(0, file.beg);
  143.         trtModelStream = new char[size];
  144.         assert(trtModelStream);
  145.         file.read(trtModelStream, size);
  146.         file.close();
  147.     }
  148.     //反序列为engine，创建context
  149.  
  150.     IRuntime* runtime = createInferRuntime(gLogger);
  151.     assert(runtime != nullptr);
  152.     ICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream, size, nullptr);
  153.     assert(engine != nullptr);
  154.     IExecutionContext* context = engine->createExecutionContext();
  155.     assert(context != nullptr);
  156.     delete[] trtModelStream;
  157.  
  158.  
  159.  
  160.     //*********************推理*********************//
  161.  
  162.  
  163.     //   循环推理
  164.  
  165.  
  166.     float time_read_img = 0.0;
  167.     float time_infer = 0.0;
  168.     static float prob[OUTPUT_SIZE];
  169.     for (int i = 0; i < 1000; i++) {
  170.  
  171.         // 处理图片为固定输出
  172.  
  173.         auto start = std::chrono::system_clock::now();  //时间函数
  174.         std::string path = "./1.jpg";
  175.         std::cout << "img_path=" << path << endl;
  176.         static float data[3 * INPUT_H * INPUT_W];
  177.         cv::Mat img = cv::imread(path);
  178.         ProcessImage(img, data);
  179.         auto end = std::chrono::system_clock::now();
  180.         time_read_img = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() + time_read_img;
  181.  
  182.  
  183.  
  184.         //Run inference
  185.         start = std::chrono::system_clock::now();  //时间函数
  186.         doInference(*context, data, prob, 1);
  187.         end = std::chrono::system_clock::now();
  188.         time_infer = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() + time_infer;
  189.         std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
  190.  
  191.         //输出后处理
  192.         //std::cout <<"prob="<<prob << std::endl;
  193.         float cls_float = prob[0];
  194.         int cls_id = 0;
  195.         for (int i = 0; i < OUTPUT_SIZE; i++) {
  196.             if (cls_float < prob[i]) {
  197.                 cls_float = prob[i];
  198.                 cls_id = i;
  199.             }
  200.         }
  201.         std::cout << "i=" << i << "\tcls_id=" << cls_id << "\t cls_float=" << cls_float << std::endl;
  202.     }
  203.  
  204.     std::cout << "C++2engine" << "mean read img time =" << time_read_img / 1000 << "ms\t" << "mean infer img time =" << time_infer / 1000 << "ms" << std::endl;
  205.     
  206.  
  207.  
  208.  
  209.  
  210.  
  211.     // Destroy the engine
  212.     context->destroy();
  213.     engine->destroy();
  214.     runtime->destroy();
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.     return 0;
  224. }
  225.  
  226.  
  227.  
  228. int main(int argc, char** argv)
  229. {
  230.  
  231.     infer();
  232.   
  233.     return 0;
  234. }
resnet18_infer.cpp

注:最终因环未在服务器验证ONNX转engine方法，但CMakeList可借鉴wts转engine。

六.Linux环境下编译engine(添加:20220914)

本节介绍如何使用编译命令在ubuntu(linux)环境中运行，我将使用C++ API构建的网络称为Cengine，将Onnx转换构建的网络称为Oengine，那么本节将介绍主要介绍CMakeLists.txt文件的构建：

Cengine的CMakeLists.txt构建：

  1. cmake_minimum_required(VERSION 2.6)
  2.  
  3. project(resnet)
  4.  
  5. add_definitions(-std=c++11)
  6.  
  7. option(CUDA_USE_STATIC_CUDA_RUNTIME OFF)
  8. set(CMAKE_CXX_STANDARD 11)
  9. set(CMAKE_BUILD_TYPE Debug)
  10.  
  11. include_directories(${PROJECT_SOURCE_DIR}/include)
  12. # include and link dirs of cuda and tensorrt, you need adapt them if yours are different
  13. # cuda
  14. include_directories(/usr/local/cuda/include)
  15. link_directories(/usr/local/cuda/lib64)
  16. # tensorrt
  17. include_directories(/home/ubuntu/soft/TensorRT-8.2.5.1/include/)
  18. link_directories(/home/ubuntu/soft/TensorRT-8.2.5.1/lib/)
  19.  
  20. #include_directories(/usr/include/x86_64-linux-gnu/)
  21. #link_directories(/usr/lib/x86_64-linux-gnu/)
  22.  
  23. # opencv
  24. find_package(OpenCV REQUIRED)
  25. include_directories(${OpenCV_INCLUDE_DIRS})
  26. add_executable(resnet18 ${PROJECT_SOURCE_DIR}/main.cpp)
  27. target_link_libraries(resnet18 nvinfer)
  28. target_link_libraries(resnet18 cudart)
  29. target_link_libraries(resnet18 ${OpenCV_LIBS})
  30.  
  31. add_definitions(-O2 -pthread)

Oengine的CMakeLists.txt构建：

  1. cmake_minimum_required(VERSION 2.6)
  2. project(resnet)
  3. add_definitions(-std=c++11)
  4. option(CUDA_USE_STATIC_CUDA_RUNTIME OFF)
  5. set(CMAKE_CXX_STANDARD 11)
  6. set(CMAKE_BUILD_TYPE Debug)
  7. include_directories(${PROJECT_SOURCE_DIR}/include)
  8. # include and link dirs of cuda and tensorrt, you need adapt them if yours are different
  9. # cuda
  10. include_directories(/usr/local/cuda/include)
  11. link_directories(/usr/local/cuda/lib64)
  12. # tensorrt
  13. include_directories(/home/ubuntu/soft/TensorRT-8.2.5.1/include/)
  14. link_directories(/home/ubuntu/soft/TensorRT-8.2.5.1/lib/)
  15.  
  16. include_directories(/home/ubuntu/soft/TensorRT-8.2.5.1/samples/common/)
  17. #link_directories(/home/ubuntu/soft/TensorRT-8.2.5.1/lib/stubs/)
  18.  
  19. # opencv
  20. find_package(OpenCV REQUIRED)
  21. include_directories(${OpenCV_INCLUDE_DIRS})
  22.  
  23. add_executable(resnet18 ${PROJECT_SOURCE_DIR}/main.cpp)
  24. target_link_libraries(resnet18 nvinfer)
  25. target_link_libraries(resnet18 cudart)
  26. target_link_libraries(resnet18 ${OpenCV_LIBS})
  27. target_link_libraries(resnet18 /home/ubuntu/soft/TensorRT-8.2.5.1/lib/stubs/libnvonnxparser.so
  28. )
  29. add_definitions(-O2 -pthread)

以上为ONNX及C++构建engine的cmakelists的语句，主要在于库的链接或头文件之类，相关可看其它博客或网上资料。

附带说明:以上Onnx的CmakeLists.txt语句已经在yolov5、yolov7中验证，可以编译运行。

ResNet代码在上面已有说明，我将不放在本博客中，其中细节代码在我发布的链接中可下载使用。

测试结果展示:

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/351097
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号