Pytorch導出onnx模型,C++轉化為TensorRT并實現推理過程
前言
- 本文為旨在實現整個Python導出PyTorch模型,C++轉化為TensorRT并實現推理過程過程,只與模型推理,模型部署相關,不涉及模型訓練。
- 為突出整個部署過程而非具體模型本身,本文模型就采用最簡單的分類模型,并且直接使用 torchvision.model 中的權重。檢測、分割等其他模型在前后處理部分會有不同,但是模型本身的導出、轉換和推理的過程基本是一致的。
- 本文會先用 Pytorch 測試一個分類模型在一張測試圖片上的結果,將其轉換為 onnx 模型,再用 onnxruntime 測試結果,再用 C++ 將其轉換為 TensorRT 模型,再測試推理結果。預期三者測試結果一致,則轉換成功。
- 如果想要測試速度,Python 可以使用 time.perf_counter(), C++ 可以使用 std::chrono::high_resolution_clock 。建議多測數據集中的一些圖片,計算推理時間的均值和方差,而不是只測一張圖片。
1 Pytorch模型推理測試導出onnx
這部分我們使用 torchvision 實例化一個簡單的 ResNet50 分類模型,并將其導出為 onnx 模型。在這個過程中,我們還需要使用一張圖片進行推理,并記錄下 Python 模型的輸出,方便我們后面到處 TensoRT 模型并進行推理時進行準確性的驗證。
由于 torchvision 中的 resnet50 分類模型中是沒有進行最后的 softmax 操作的,這里我們為了之后使用方便,自己新建一個類 ResNet50_wSoftmax 將后處理 softmax 添加到模型中一起導出。
這也是 pytorch 導出 onnx 模型的一個推薦的方式,就是將一些必要后處理添加到模型中一起導出,這樣做有兩個優點:
- 可以直接得到端到端的 onnx/tensorrt 模型,不必在外面再做后處理操作
- 再之后我們會將 onnx 模型轉換為 tensorrt 模型,在轉換過程中 tensorrt 會對我們的模型進行一些針對特定的 Nvidia GPU 的推理優化,我們將后處理一起合并到 onnx 模型中,可能可以使得一些算子操作再轉換為 tensorrt 的過程中同樣得到優化。
最終代碼如下:
# export_onnx.py
import torch
import torchvision.models as models
import cv2
import numpy as npclass ResNet50_wSoftmax(torch.nn.Module):# 將softmax后處理合并到模型中,一起導出為onnxdef __init__(self):super().__init__()self.base_model = models.resnet50(pretrained=True)self.softmax = torch.nn.Softmax(dim=1)def forward(self, x):y = self.base_model(x)prob = self.softmax(y)return probdef preprocessing(img):# 預處理:BGR->RGB、歸一化/除均值減標準差IMAGENET_MEAN = [0.485, 0.456, 0.406]IMAGENET_STD = [0.229, 0.224, 0.225]img = img[:, :, ::-1]img = cv2.resize(img, (224, 224))img = img / 255.0img = (img - IMAGENET_MEAN) / IMAGENET_STDimg = img.transpose(2, 0, 1).astype(np.float32)tensor_img = torch.from_numpy(img)[None]return tensor_imgif __name__ == '__main__':# model = models.resnet50(pretrained=True)image_path = 'test.jpg'img = cv2.imread(image_path)tensor_img = preprocessing(img)model = ResNet50_wSoftmax() # 將后處理添加到模型中model.eval()pred = model(tensor_img)[0]max_idx = torch.argmax(pred)print(f"test_image: {image_path}, max_idx: {max_idx}, max_logit: {pred[max_idx].item()}")dummpy_input = torch.zeros(1, 3, 224, 224) # onnx的導出需要指定一個輸入,這里直接用上面的tenosr_img也可torch.onnx.export(model, dummpy_input, 'resnet50_wSoftmax.onnx',input_names=['image'],output_names=['predict'],opset_version=11,dynamic_axes={'image': {0: 'batch'}, 'predict': {0: 'batch'}} # 注意這里指定batchsize是動態可變的)
執行結果會輸出:
test_image: test.jpg, max_idx: 971, probability: 0.994541585445404
這些結果我們一會測試 onnx/tensorrt 模型時用于比對轉換是否有誤差。并得到一個 onnx 模型文件:classifier.onnx 。
2 onnxruntime推理測試
我們將剛剛得到的 classifier.onnx ,用 onnxruntime 來進行推理測試,看結果是否相同。
這里,我們就復用剛才測試 pytorch 模型時的預處理函數,整個 onnxruntime 推理測試代碼如下:
import onnxruntime as ort
import numpy as np
import cv2
from export_onnx import preprocessingimage_path = 'test.jpg'
ort_session = ort.InferenceSession("classifier.onnx") # 創建一個推理sessionimg = cv2.imread(image_path)
input_img = preprocessing(img)[None]pred = ort_session.run(None, { 'image' : input_img } )[0][0]
max_idx = np.argmax(pred)
print(f"test_image: {image_path}, max_idx: {max_idx}, probability: {pred[max_idx]}")
輸出:
test_image: test.jpg, max_idx: 971, probability: 0.994541585445404
可以看到,跟我們 pytorch 模型的測試結果是一致的。
3 C++ onnx模型轉換為tensorrt模型
本部分重度參考自課程:tensorRT從零起步邁向高性能工業級部署(就業導向)
我們進行模型部署推理肯定是追求極致的推理速度,這時再用 Python 來進行轉換和推理就不合適了,接下來我們就轉戰到 C++ 上,將onnx模型轉換為tensorrt模型。
對于大部分深度學習部署的 C/C++ 的初學者而言,環境配置都是個老大難的問題。本身 C/C++ 的包管理就不如 Python 的 pip、conda 等來的直接方便,再加上各種 nvidia driver/cuda/cudnn/cuda-runtime 的各種版本不對齊的問題,包括筆者在內的許多萌新們初期總是會在環境配置遇到許多問題。但是本文關注的重點是整個模型轉換和部署的過程,不可能花大篇幅再去介紹環境配置,將來有機會再單獨寫一篇介紹 Python/C++ 深度學習模型部署時環境配置的問題,這里就直接給出筆者使用的關鍵軟硬件的版本號/型號。
GPU: RTX 3060ti 12GB
OS: ubuntu 18.04
gcc: 7.5
TensorRT: 8.x
CUDA: 11.2
cuDNN: 8.x
頭文件
包含的頭文件:
// tensorrt相關
#include <NvInfer.h>
#include <NvInferRuntime.h>// onnx解析器相關
#include <onnx-tensorrt/NvOnnxParser.h>// cuda_runtime相關
#include <cuda_runtime.h>// 常用頭文件
#include <stdio.h>
#include <math.h>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <memory>
#include <functional>
#include <unistd.h>
#include <chrono>// opencv
#include <opencv2/opencv.hpp>
logger類
首先我們要準備一個 logger 類,來打印構建 tensorrt 模型過程中的一些錯誤或警告。按照指定的嚴重性程度 (severity),來打印信息。
inline const char* severity_string(nvinfer1::ILogger::Severity t) {switch (t) {case nvinfer1::ILogger::Severity::kINTERNAL_ERROR: return "internal_error";case nvinfer1::ILogger::Severity::kERROR: return "error";case nvinfer1::ILogger::Severity::kWARNING: return "warning";case nvinfer1::ILogger::Severity::kINFO: return "info";case nvinfer1::ILogger::Severity::kVERBOSE: return "verbose";default: return "unknown";}
}class TRTLogger : public nvinfer1::ILogger {
public:virtual void log(Severity severity, nvinfer1::AsciiChar const* msg) noexcept override {if (severity <= Severity::kWARNING) {if (severity == Severity::kWARNING) printf("\033[33m%s: %s\033[0m\n", severity_string(severity), msg);else if (severity == Severity::kERROR) printf("\031[33m%s: %s\033[0m\n", severity_string(severity), msg);else printf("%s: %s\n", severity_string(severity), msg);}}
};
build_model函數
build_model 函數,各步驟已在代碼中添加注釋:
bool build_model() {if (isFileExist( "classifier.trtmodel" )) {printf("classifier.trtmodel already exists.\n");return true;}TRTLogger logger;// 下面的builder, config, network是基本需要的組件// 形象的理解是你需要一個builder去build這個網絡,網絡自身有結構,這個結構可以有不同的配置nvinfer1::IBuilder* builder = nvinfer1::createInferBuilder(logger);// 創建一個構建配置,指定TensorRT應該如何優化模型,tensorRT生成的模型只能在特定配置下運行nvinfer1::IBuilderConfig* config = builder->createBuilderConfig();// 創建網絡定義,其中createNetworkV2(1)表示采用顯性batch size,新版tensorRT(>=7.0)時,不建議采用0非顯性batch sizenvinfer1::INetworkDefinition* network = builder->createNetworkV2(1);// onnx parser解析器來解析onnx模型auto parser = nvonnxparser::createParser(*network, logger);if (!parser->parseFromFile("classifier.onnx", 1)) {printf("Failed to parse classifier.onnx.\n");return false;}// 設置工作區大小printf("Workspace Size = %.2f MB\n", (1 << 28) / 1024.0f / 1024.0f);config->setMaxWorkspaceSize(1 << 28);// 需要通過profile來使得batchsize時動態可變的,這與我們之前導出onnx指定的動態batchsize是對應的int maxBatchSize = 10;auto profile = builder->createOptimizationProfile();auto input_tensor = network->getInput(0);auto input_dims = input_tensor->getDimensions();// 設置batchsize的最大/最小/最優值input_dims.d[0] = 1;profile->setDimensions(input_tensor->getName(), nvinfer1::OptProfileSelector::kMIN, input_dims);profile->setDimensions(input_tensor->getName(), nvinfer1::OptProfileSelector::kOPT, input_dims);input_dims.d[0] = maxBatchSize;profile->setDimensions(input_tensor->getName(), nvinfer1::OptProfileSelector::kMAX, input_dims);config->addOptimizationProfile(profile);// 開始構建tensorrt模型enginenvinfer1::ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);if (engine == nullptr) {printf("Build engine failed.\n");return false;}// 將構建好的tensorrt模型engine反序列化(保存成文件)nvinfer1::IHostMemory* model_data = engine->serialize();FILE* f = fopen("classifier.trtmodel", "wb");fwrite(model_data->data(), 1, model_data->size(), f);fclose(f);// 逆序destory掉指針model_data->destroy();engine->destroy();network->destroy();config->destroy();builder->destroy();printf("Build Done.\n");return true;
}
調用 build_model 函數成功后,我們會得到一個 classifier.trtmodel 文件。
make_nvshared
上面的實現有個比較不優雅的地方,對于我們創建的 builder、config 等指針,我們都需要一一進行 destroy,從而避免內存泄漏。實際上,這里我們可以通過共享指針,來實現自動釋放。
shared_ptr<_T> make_nvshared(_T *ptr) {return shared_ptr<_T>(ptr, [](_T* p){p->destroy();});
}
在這里指定一下釋放內存的方式,之后就可以通過類似:
auto network = make_nvshared(builder->createNetworkV2(1));
這樣的方式創建智能指針,他會自己 destroy 釋放,這樣最后幾行 destory 就不用寫了。
4 tensorrt模型推理測試
我們上一步已經成功將 onnx 模型導出為了 tensorrt 模型,現在我們用 tensorrt 模型來進行推理,看一下結果是否與之前 pytorch 和 onnx 推理的結果一致,如果一致,則模型轉換成功。
load_file
load_file 函數用于加載我們的 tensorrt 模型:
vector<unsigned char> load_file(const string& file) {ifstream in(file, ios::in | ios::binary);if (!in.is_open()) return {};in.seekg(0, ios::end);size_t length = in.tellg();vector<uint8_t> data;if (length > 0) {in.seekg(0, ios::beg);data.resize(length);in.read((char*)&data[0], length);}in.close();return data;
}
inference
void inference(const string& image_path) {TRTLogger logger;// 加載模型auto engine_data = load_file("classifier.trtmodel");// 執行推理前,需要創建一個推理的runtime接口實例。與builer一樣,runtime需要loggerauto runtime = make_nvshared(nvinfer1::createInferRuntime(logger));auto engine = make_nvshared(runtime->deserializeCudaEngine(engine_data.data(), engine_data.size()));if (engine == nullptr) {printf("Deserialize cuda engine failed.\n");runtime->destroy();return;}if (engine->getNbBindings() != 2) {printf("Must be single input, single Output, got %d output.\n", engine->getNbBindings() - 1);return;}// 創建CUDA流,以確定這個batch的推理是獨立的cudaStream_t stream = nullptr;checkRuntime(cudaStreamCreate(&stream));auto execution_context = make_nvshared(engine->createExecutionContext());int input_batch = 1;int input_channel = 3;int input_height = 224;int input_width = 224;// 準備好input_data_host和input_data_device,分別表示內存中的數據指針和顯存中的數據指針// 一會兒將預處理過的圖像數據搬運到GPUint input_numel = input_batch * input_channel * input_height * input_width;float* input_data_host = nullptr;float* input_data_device = nullptr;checkRuntime(cudaMallocHost(&input_data_host, input_numel * sizeof(float)));checkRuntime(cudaMalloc(&input_data_device, input_numel * sizeof(float)));// 圖片讀取與預處理,與之前python中的預處理方式一致:// BGR->RGB、歸一化/除均值減標準差float mean[] = {0.406, 0.456, 0.485};float std[] = {0.225, 0.224, 0.229};auto image = cv::imread(image_path);cv::resize(image, image, cv::Size(input_width, input_height));int image_area = image.cols * image.rows;unsigned char* pimage = image.data;float* phost_b = input_data_host + image_area * 0;float* phost_g = input_data_host + image_area * 1;float* phost_r = input_data_host + image_area * 2;for (int i=0; i<image_area; ++i, pimage += 3) {*phost_r++ = (pimage[0] / 255.0f - mean[0]) / std[0];*phost_g++ = (pimage[1] / 255.0f - mean[1]) / std[1];*phost_b++ = (pimage[2] / 255.0f - mean[2]) / std[2];}// 進行推理checkRuntime(cudaMemcpyAsync(input_data_device, input_data_host, input_numel *sizeof(float), cudaMemcpyHostToDevice, stream));const int num_classes = 1000;float output_data_host[num_classes];float* output_data_device = nullptr;checkRuntime(cudaMalloc(&output_data_device, sizeof(output_data_host)));auto input_dims = engine->getBindingDimensions(0);input_dims.d[0] = input_batch;execution_context->setBindingDimensions(0, input_dims);// 用一個指針數組bindings指定input和output在gpu中的指針。float* bindings[] = {input_data_device, output_data_device};bool success = execution_context->enqueueV2((void**)bindings, stream, nullptr);checkRuntime(cudaMemcpyAsync(output_data_host, output_data_device, sizeof(output_data_host), cudaMemcpyDeviceToHost, stream));checkRuntime(cudaStreamSynchronize(stream));float* prob = output_data_host;int predict_label = max_element(prob, prob + num_classes) - prob;float conf = prob[predict_label];printf("test_image: %s, max_idx: %d, probability: %f", image_path.c_str(), predict_label, conf);// 釋放顯存checkRuntime(cudaStreamDestroy(stream));checkRuntime(cudaFreeHost(input_data_host));checkRuntime(cudaFree(input_data_device));checkRuntime(cudaFree(output_data_device));
}
最終得到輸出:
test_image: test.jpg, max_idx: 971, probability: 0.994527
與之前 pytorch 和 onnx 推理的結果基本一致,模型轉換成功。
附錄
給出完整的參考代碼:https://github.com/Adenialzz/Hello-AIDeployment/tree/master/HAID/tensorrt/resnet