TensorRT的使用流程c++和python

于 2024-08-14 23:51:31 发布
阅读量695 收藏 4
点赞数 8
分类专栏： 基于tensorrt的yolov5推理实现 文章标签： python 算法 人工智能 机器学习 ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39333636/article/details/141202925
版权

TensorRT包含解析器parser，构建器builder，引擎engine，执行上下文context，其中解析器parser负责加载模型框架和权重。构建器builder负责构建网络，引擎engine和执行上下文context负责在网络中进行前向传播。

TensorRT模型的来源有两种：

  1、自定义构建TensorRT模型

  2、外界导入trt模型，以pytorch为例，pt文件转onnx转trt。

外界导入trt模型之后，创建流程如下：

读trt文件→创建runtime→runtime反序列化trt文件得到engine→engine创建context→为运行分配空间→将数据拷贝到分配的空间上→模型推理→后处理

class Logger : public ILogger {
public:
        void log(Severity severity, const char* msg) noexcept override
        {
                // suppress info-level messages
                if (severity <= Severity::kWARNING)
                        std::cout << msg << std::endl;
        }
}gLogger;
 
//假设模型已经被读入到vector<char> modeltrt中
initLibNvInferPlugins(&gLogger, "");
//模型导入
Logger m_logger;
IRuntime* runtime = createInferRuntime(gLogger);
ICudaEngine* engine = runtime->deserializeCudaEngine(modeltrt.data(), modeltrt.size(), nullptr);
IExecutionContext* context = engine->createExecutionContext();
 
//分配空间
void* buffers[2];
buffers[0] = buffers[1] = NULL;
cudaMallocManaged(&buffers[0], 3 * 640 * 640 * 4);
cudaMallocManaged(&buffers[1], 1 * 25200 * 85 * 4);
cudaStream_t stream;
cudaStreamCreate(&stream);
 
//假设输入数据已经复制到buffers上，运行
context->enqueueV2(buffers, stream, nullptr);

TensorRT_Python

TensorRT 是 NVIDIA 推出的一个高性能深度学习推理库，专门用于优化深度学习模型以在 NVIDIA GPU 上进行高效的推理。它可以对深度学习模型进行图层融合、精度混合以及其他优化，从而加快模型的推理速度并减少延迟。TensorRT 主要支持 FP32、FP16 和 INT8 精度。

下面我们通过 YOLOv5 的例子来讲解如何使用 TensorRT 进行推理。

安装 TensorRT

在安装 TensorRT 之前，确保你已经安装了 CUDA 和 cuDNN。然后，你可以通过 pip 安装 TensorRT：

pip install nvidia-pyindex pip install nvidia-tensorrt

使用 TensorRT 进行推理的步骤

  1. 导出模型为 ONNX 格式: YOLOv5 模型首先需要转换为 ONNX 格式。你可以使用 YOLOv5 的官方工具来完成这个步骤。

  2. python export.py --weights yolov5s.pt --include onnx

  3. 将 ONNX 模型转换为 TensorRT 引擎: 使用 tensorrt 库将 ONNX 模型转换为 TensorRT 引擎。

  4. 加载 TensorRT 引擎并进行推理: 使用 tensorrt 库加载 TensorRT 引擎，并使用其进行推理。

下面是一个完整的例子，演示如何使用 TensorRT 库加载和推理 YOLOv5 的模型。

代码示例

首先，我们需要一些必要的库：

1. 导出模型为 ONNX 格式

python export.py --weights yolov5s.pt --include onnx

2. 将 ONNX 模型转换为 TensorRT 引擎

使用 TensorRT 的 trtexec 工具可以将 ONNX 模型转换为 TensorRT 引擎：

trtexec --onnx=yolov5s.onnx --saveEngine=yolov5s.trt --fp16

3. 加载 TensorRT 引擎并进行推理

下面是 Python 代码，演示如何加载 TensorRT 引擎并进行推理：

class YoLov5TRT(object):
    def __init__(self, engine_file_path):
        # 创建一个 Runtime 对象
        self.trt_logger = trt.Logger(trt.Logger.INFO)
        self.runtime = trt.Runtime(self.trt_logger)

        # 反序列化 TensorRT 引擎
        with open(engine_file_path, "rb") as f:
            self.engine = self.runtime.deserialize_cuda_engine(f.read())

        # 创建执行上下文
        self.context = self.engine.create_execution_context()

        # 分配输入和输出内存
        self.inputs, self.outputs, self.bindings, self.stream = self.allocate_buffers()

    def allocate_buffers(self):
        inputs = []
        outputs = []
        bindings = []
        stream = cuda.Stream()

        for binding in self.engine:
            size = trt.volume(self.engine.get_binding_shape(binding)) * self.engine.max_batch_size
            dtype = trt.nptype(self.engine.get_binding_dtype(binding))

            # 分配主机和设备内存
            host_mem = cuda.pagelocked_empty(size, dtype)
            device_mem = cuda.mem_alloc(host_mem.nbytes)

            # 记录绑定
            bindings.append(int(device_mem))

            if self.engine.binding_is_input(binding):
                inputs.append(host_mem)
            else:
                outputs.append(host_mem)

        return inputs, outputs, bindings, stream

    def infer(self, image):
        # 预处理图像
        input_image = self.preprocess_image(image)
        np.copyto(self.inputs[0], input_image.ravel())

        # 将输入数据从主机复制到设备
        cuda.memcpy_htod_async(self.inputs[0], self.bindings[0], self.stream)

        # 执行推理
        self.context.execute_async_v2(bindings=self.bindings, stream_handle=self.stream.handle)

        # 将输出数据从设备复制到主机
        cuda.memcpy_dtoh_async(self.outputs[0], self.bindings[1], self.stream)
        self.stream.synchronize()

        return self.postprocess_results(self.outputs[0])

    def preprocess_image(self, image):
        # Resize and normalize the image
        input_shape = (self.engine.max_batch_size, 3, 640, 640)
        image = cv2.resize(image, (640, 640))
        image = image.astype(np.float32) / 255.0
        image = np.transpose(image, (2, 0, 1))
        image = np.expand_dims(image, axis=0)
        return image

    def postprocess_results(self, output):
        # 后处理推理结果
        # 这里的实现取决于模型的输出格式
        return output

# 创建 YOLOv5 TensorRT 推理对象
yolov5_trt = YoLov5TRT("yolov5s.trt")

# 读取输入图像
image = cv2.imread("image.jpg")

# 执行推理
output = yolov5_trt.infer(image)

# 打印或处理输出结果
print(output)

总结

这个示例演示了如何使用 TensorRT 库加载并推理 YOLOv5 模型。主要步骤包括：

  1. 将模型导出为 ONNX 格式。

  2. 使用 TensorRT 工具将 ONNX 模型转换为 TensorRT 引擎。

  3. 使用 TensorRT Python API 加载引擎并进行推理。

希望这个例子能帮助你更好地理解如何使用 TensorRT 进行高效的模型推理。

TensorRT_C++

TensorRT 是 NVIDIA 提供的一个用于深度学习推理的高性能库。它可以对经过训练的神经网络进行优化，生成一个高效的推理引擎，并能够在 NVIDIA 的 GPU 上高效运行。TensorRT 支持多种模型格式，包括 Caffe、TensorFlow、ONNX 等，并且可以对模型进行图层融合、精度混合、内存优化等操作，以实现更快的推理速度和更低的延迟。

使用 TensorRT 进行 YOLOv5 推理的步骤

  1. 导出模型为 ONNX 格式: 首先需要将 YOLOv5 模型转换为 ONNX 格式。

  2. 将 ONNX 模型转换为 TensorRT 引擎: 使用 TensorRT 的 trtexec 工具将 ONNX 模型转换为 TensorRT 引擎。

  3. 使用 C++ 加载 TensorRT 引擎并进行推理: 使用 C++ API 加载 TensorRT 引擎，并实现前处理、推理和后处理。

1. 导出模型为 ONNX 格式

首先需要使用 YOLOv5 的官方工具将模型导出为 ONNX 格式：

python export.py --weights yolov5s.pt --include onnx

2. 将 ONNX 模型转换为 TensorRT 引擎

使用 TensorRT 的 trtexec 工具将 ONNX 模型转换为 TensorRT 引擎：

trtexec --onnx=yolov5s.onnx --saveEngine=yolov5s.trt --fp16

3. 使用 C++ 加载 TensorRT 引擎并进行推理

下面是一个完整的 C++ 示例代码，演示如何加载 TensorRT 引擎并进行推理。

必要的库和头文件

你需要安装并包含以下库和头文件：

#include <NvInfer.h>
#include <NvOnnxParser.h>
#include <cuda_runtime_api.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include <fstream>
#include <memory>
#include <vector>
YOLOv5 推理类
class YoLov5TRT {
public:
    YoLov5TRT(const std::string& engine_file_path);
    ~YoLov5TRT();
    std::vector<float> infer(const cv::Mat& image);

private:
    void loadEngine(const std::string& engine_file_path);
    void preprocessImage(const cv::Mat& image, float* gpu_input);
    std::vector<float> postprocessResults(float* gpu_output);

    nvinfer1::IRuntime* runtime_;
    nvinfer1::ICudaEngine* engine_;
    nvinfer1::IExecutionContext* context_;
    cudaStream_t stream_;
    void* buffers_[2];
    int input_size_;
    int output_size_;
};

YoLov5TRT::YoLov5TRT(const std::string& engine_file_path) {
    loadEngine(engine_file_path);
}

YoLov5TRT::~YoLov5TRT() {
    cudaStreamDestroy(stream_);
    cudaFree(buffers_[0]);
    cudaFree(buffers_[1]);
    context_->destroy();
    engine_->destroy();
    runtime_->destroy();
}

void YoLov5TRT::loadEngine(const std::string& engine_file_path) {
    // 创建 Runtime
    runtime_ = nvinfer1::createInferRuntime(gLogger);
    std::ifstream engine_file(engine_file_path, std::ios::binary);
    if (!engine_file) {
        std::cerr << "Failed to open engine file." << std::endl;
        return;
    }
    engine_file.seekg(0, std::ifstream::end);
    size_t fsize = engine_file.tellg();
    engine_file.seekg(0, std::ifstream::beg);
    std::vector<char> engine_data(fsize);
    engine_file.read(engine_data.data(), fsize);
    engine_file.close();

    // 反序列化引擎
    engine_ = runtime_->deserializeCudaEngine(engine_data.data(), fsize, nullptr);
    context_ = engine_->createExecutionContext();

    // 获取输入输出大小
    input_size_ = 1 * 3 * 640 * 640;  // 假设输入是 640x640 的图像
    output_size_ = 1 * 25200 * 7;     // 假设输出是 25200x7

    // 分配 GPU 内存
    cudaMalloc(&buffers_[0], input_size_ * sizeof(float));
    cudaMalloc(&buffers_[1], output_size_ * sizeof(float));

    cudaStreamCreate(&stream_);
}

void YoLov5TRT::preprocessImage(const cv::Mat& image, float* gpu_input) {
    cv::Mat resized;
    cv::resize(image, resized, cv::Size(640, 640));
    resized.convertTo(resized, CV_32FC3, 1.0 / 255);
    std::vector<float> input_data(input_size_);
    std::memcpy(input_data.data(), resized.data, input_data.size() * sizeof(float));
    cudaMemcpyAsync(gpu_input, input_data.data(), input_size_ * sizeof(float), cudaMemcpyHostToDevice, stream_);
}

std::vector<float> YoLov5TRT::postprocessResults(float* gpu_output) {
    std::vector<float> output_data(output_size_);
    cudaMemcpyAsync(output_data.data(), gpu_output, output_size_ * sizeof(float), cudaMemcpyDeviceToHost, stream_);
    cudaStreamSynchronize(stream_);
    return output_data;
}

std::vector<float> YoLov5TRT::infer(const cv::Mat& image) {
    preprocessImage(image, static_cast<float*>(buffers_[0]));

    // 执行推理
    context_->enqueueV2(buffers_, stream_, nullptr);

    return postprocessResults(static_cast<float*>(buffers_[1]));
}
主程序
int main() {
    // 加载 TensorRT 引擎
    YoLov5TRT yolov5_trt("yolov5s.trt");

    // 读取输入图像
    cv::Mat image = cv::imread("image.jpg");

    // 执行推理
    std::vector<float> output = yolov5_trt.infer(image);

    // 打印或处理输出结果
    for (const auto& val : output) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

总结

这个示例展示了如何使用 C++ 和 TensorRT 进行 YOLOv5 模型的推理。主要步骤包括：

  1. 将模型导出为 ONNX 格式。

  2. 使用 TensorRT 工具将 ONNX 模型转换为 TensorRT 引擎。

  3. 使用 C++ API 加载引擎，并实现图像的前处理和后处理。

yzZ_here
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YoloV8的TensorRT框架的C++版本
m0_49586319的博客
04-24 228
YOLOv8的C++版本的TensorRT框架部署
tensorRT部署resnet网络Python、c++源码
08-18
使用TensorRT来加速部署图片分类项目，此文档中包含全部 软件及依赖库 在Win10系统上完成，需要用到的软件与依赖包有：cuda 10.2 , cudnn 7.6.5 , VS2017 , OpenCV 3.4.0 , Anaconda3 , CMake 3.19.4 , TensorRT 8.0...
tensorrt 推理Unet网络（python && C++）
maobin_1的博客
01-11 734
分类数量改为2，训练部分参考源码 ，源码中可能由于pytorch版本不一样需要改一下。我的输入是（1，3，720，1280），输出是（1，2，720，1280），源码。重要推理部分如下，C++部分改天上传。
YOLOv5 Tensorrt Python/C++部署
热门推荐
weixin_45747759的博客
04-10 2万+
YOLOv5 Tensorrt Python/C++部署 支持Windows10/Linux
win10安装TensorRT（C++，Python）
clownwai的博客
03-17 1万+
文章目录前言一、先决条件二、TensorRT下载1.官网下载2.C++3.Python总结 前言 本偏文章主要用于记录Win10上TensorRT的安装过程。 C++软件：VS2019 python PS：conda环境安装python依赖包时注意激活环境。 一、先决条件 在安装TensorRT前，首先需要安装CUDA、CUDNN等NVIDIA的基本库。 CUDA： 11.3； cmd执行 nvcc -V cudnn：8.2.1 py-cuda （我用的11.5） pip install cuda-
使用Python部署TensorRT
wq_0708的博客
11-11 7393
使用Python API构建TensorRT engine
C++/Python 调用 Pytorch -＞ ONNX -＞ TensorRT 模型转换与部署
～勿据散客～的博客
12-03 3078
系统环境：网上相关流程很多，我就不重复了 可以参考Pytorch分类模型转onnx以及onnx模型推理 或者直接看Pytorch官方怎么干的。ONNX Githubonnxruntime调用onnx模型推理时有一个provider的参数，可选 [‘TensorrtExecutionProvider’, ‘CUDAExecutionProvider’, ‘CPUExecutionProvider’]，不知道是还需要其他设置还是怎样，'TensorrtExecutionProvider’和’CPUExecuti
python与C++的效率区别、模型部署/ONNXRuntime/tensorrt
qq_15821487的博客
09-08 5882
解释执行：由解释器根据输入的数据当场执行而不生成任何的目标程序。编译执行：先将源代码编译成目标语言（例如机器语言）之后，通过连接程序连接到生成的目标程序进行执行。python和C++python是一种脚本语言，是解释执行的，不需要经过编译，所以很方便快捷，且能够很好地跨平台，写一些小工具小程序特别合适。而C++则是一种需要编译后运行语言，在特定的机器上编译后在特定的机上运行，运行效率高，安全稳定。但编译后的程序一般是不跨平台的。
ubuntu16.4 安装TensorRT (C++/Python)
zhangyue123的博客
11-04 875
根据自己的系统版本和 CUDA 版本，选择安装包，如图所示（如果是完整安装，建议选择Tar File Install Packages，这样可以自行选择安装位置）在/etc/ld.so.conf里面加一行/home/zhy/Downloads/soft/TensorRT-6.0.1.5/lib，然后sudo ldconfig.如果使用tensorflow的话，需要安装UFF的.whl文件(optional)上有两种方式安装：.deb文件/tar文件。这里介绍通过.tar文件安装的过程。
yolov5使用TensorRT进行c++部署
weixin_41311686的博客
12-29 6775
有了前面用c++进行opencv里dnn部署和onnxruntime部署的经验，使用TensorRT进行部署，我们只要了解tensorrt和cuda的一些相关api的使用即可方便的部署，整个部署流程都差不多。
yolov5_tensorrt_dll c++动态链接库接口
09-06
本文将详细介绍如何将YOLOv5模型与TensorRT结合，通过C++实现动态链接库接口，以便于其他如C#、Java等语言调用。 首先，我们需要了解YOLOv5模型。YOLO（You Only Look Once）是一种基于卷积神经网络的目标检测框架...
tensorrt c++ 推理项目
07-03
tensorrt c++ 推理示例项目，支持分类网络，比如alexnet，mobileone,skipnet等轻量级网络。...python生成tensorrt引擎步骤，可以查看我的博客： https://blog.csdn.net/jacke121/article/details/125382721
TensorRT-使用TensorRT+Python调用网络摄像头Webcam在GPU上进行目标检测算法的部署-优质项目实战
02-28
总之，通过这个项目实战，你不仅可以掌握TensorRT与Python的结合使用，还能深入了解目标检测模型的实时部署，这对于深度学习应用的开发和部署具有重要的实际意义。不断优化和调整，你将能够在各种硬件环境下实现高效...
YOLOv9-使用TensorRT部署YOLOv9目标检测算法-支持Python+Cpp-优质算法部署项目实战.zip
03-15
TensorRT提供了Python和C++ API，可以用来构建、优化和执行神经网络模型。对于YOLOv9，我们需要使用TensorRT的API来解析模型的ONNX或TensorFlow格式，并对其进行量化、剪枝等优化操作，以进一步提高推理速度。 在...
Python 算法交易实验80 QTV200日常推进-目标估算
yukai08008的博客
08-10 492
业务目标在先，月利3%是第一个目标。虽然日常有在常规推进，但目标是什么？现在做的是什么？与目标的关联是什么？业务上讲，如果月利能够达到3%(几何平均)，上下波动不超过1%，就算达标了(2%~4%)。考虑到金融领域有不可测风险，所以资金还会分摊到3个月。例如，假如总投资资金是30万，那么每个月的最大投资金额是10万。这样即使遇到大跳水，问题也不大。目标达到的话，10万本金每月的盈利是3000， 按复利计,24个月就会double，我觉得已经足够理想。假设投资90万，则可以按30万计算复利效果。
汽车免拆诊断案例 | DAF（达富）汽油尾气处理液故障警示
虹科Pico汽车示波器的博客
08-14 740
一辆DAF（达富）故障警示灯亮，提示DEF系统故障，使用虹科Pico汽车示波器检查发现故障的原因是......
Falsk测试与部署（第九阶段）
蜡笔小新星的博客
08-09 695
在本章节中，我们学习了如何使用unittest和pytest进行单元和集成测试，以及如何配置Flask应用，使用WSGI服务器部署，容器化Flask应用并将其部署到各种云服务平台。通过这些步骤，你可以确保你的Flask应用在生产环境中的稳定性和可靠性。希望这些知识能够帮助你在实际项目中更好地实现测试和部署。
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 304
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
tensorrt有c++和python的区别吗
05-05
TensorRT是一个高性能的推理引擎，可用于加速深度学习模型的推理。TensorRT具有C++和Python API，两种API的使用方式略有不同。一般来说，C++ API更适合在嵌入式设备上使用，而Python API则更适合在数据科学和深度学习研究领域使用。 C++ API提供了更好的性能和可控性，因为它可以直接调用TensorRT库中的C++函数。使用C++ API时，您需要手动编写代码来处理模型加载、数据预处理、推理和结果输出等过程。这需要您具备一定的编程技能和经验。 Python API则更加易于使用，因为它提供了更高级别的接口，可以在几行代码中完成模型加载、数据预处理、推理和结果输出等过程。Python API还可以与其他Python库（如PyTorch和TensorFlow等）配合使用，方便快捷。 总之，C++ API更适合在嵌入式系统和高性能计算环境中使用，而Python API更适合在数据科学和深度学习研究领域中使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值