onnxruntime和tensorrt多batch推理

已于 2023-12-10 17:14:38 修改
阅读量2.3k 收藏 21
点赞数 7
分类专栏： # classification # model deployment deep learning 文章标签： onnxruntime tensorrt 模型推理
于 2023-12-10 17:07:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taifyang/article/details/134623380
版权

以lenet网络为例。

onnxruntime多batch推理

当batch size为2时，导出如下结构的onnx文件：
在这里插入图片描述
python推理：

import cv2
import numpy as np
import onnxruntime


img0 = cv2.imread("2.png", 0)
img1 = cv2.imread("10.png", 0)
blob0 = cv2.dnn.blobFromImage(img0, 1/255., size=(28,28), swapRB=True, crop=False)
blob1 = cv2.dnn.blobFromImage(img1, 1/255., size=(28,28), swapRB=True, crop=False)
onnx_session = onnxruntime.InferenceSession("lenet.onnx", providers=['CPUExecutionProvider'])

input_name = []
for node in onnx_session.get_inputs():
    input_name.append(node.name)

output_name = []
for node in onnx_session.get_outputs():
    output_name.append(node.name)

inputs = {}
for name in input_name:
    inputs[name] = np.concatenate((blob0, blob1), axis=0)

outputs = onnx_session.run(None, inputs)[0]
print(np.argmax(outputs, axis=1))

C++推理：

#include <iostream>
#include <opencv2/opencv.hpp>
#include <onnxruntime_cxx_api.h>


int main(int argc, char* argv[])
{
	Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "lenet");
	Ort::SessionOptions session_options;
	session_options.SetIntraOpNumThreads(1);
	session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);

	const wchar_t* model_path = L"lenet.onnx";
	Ort::Session session(env, model_path, session_options);
	Ort::AllocatorWithDefaultOptions allocator;

	std::vector<const char*>  input_node_names;
	for (size_t i = 0; i < session.GetInputCount(); i++)
	{
		input_node_names.push_back(session.GetInputName(i, allocator));
	}

	std::vector<const char*> output_node_names;
	for (size_t i = 0; i < session.GetOutputCount(); i++)
	{
		output_node_names.push_back(session.GetOutputName(i, allocator));
	}

	const size_t input_tensor_size = 2 * 1 * 28 * 28;
	std::vector<float> input_tensor_values(input_tensor_size);

	cv::Mat image0 = cv::imread("2.png", 0);
	cv::Mat image1 = cv::imread("10.png", 0);
	image0.convertTo(image0, CV_32F, 1.0 / 255);
	image1.convertTo(image1, CV_32F, 1.0 / 255);
	for (int i = 0; i < 28; i++)
	{
		for (int j = 0; j < 28; j++)
		{
			input_tensor_values[i * 28 + j] = image0.at<float>(i, j);
			input_tensor_values[28 * 28 + i * 28 + j] = image1.at<float>(i, j);
		}
	}

	std::vector<int64_t> input_node_dims = { 2, 1, 28, 28 };
	auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
	Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_size, input_node_dims.data(), input_node_dims.size());

	std::vector<Ort::Value> inputs;
	inputs.push_back(std::move(input_tensor));

	std::vector<Ort::Value> outputs = session.Run(Ort::RunOptions{ nullptr }, input_node_names.data(), inputs.data(), input_node_names.size(), output_node_names.data(), output_node_names.size());

	const float* rawOutput = outputs[0].GetTensorData<float>();
	std::vector<int64_t> outputShape = outputs[0].GetTensorTypeAndShapeInfo().GetShape();
	size_t count = outputs[0].GetTensorTypeAndShapeInfo().GetElementCount();
	std::vector<float> preds(rawOutput, rawOutput + count);

	int predict_label0 = std::max_element(preds.begin(), preds.begin() + 10) - preds.begin();
	int predict_label1 = std::max_element(preds.begin() + 10, preds.begin() + 20) - preds.begin() - 10;
	std::cout << predict_label0 << std::endl;
	std::cout << predict_label1 << std::endl;

	return 0;
}

tensorrt多batch推理

python推理：

import cv2
import numpy as np
import tensorrt as trt
import pycuda.autoinit  #负责数据初始化，内存管理，销毁等
import pycuda.driver as cuda  #GPU CPU之间的数据传输


# 创建logger：日志记录器
logger = trt.Logger(trt.Logger.WARNING)
# 创建runtime并反序列化生成engine
with open("lenet.engine", "rb") as f, trt.Runtime(logger) as runtime:
    engine = runtime.deserialize_cuda_engine(f.read())
context = engine.create_execution_context()

# 分配CPU锁页内存和GPU显存
h_input = cuda.pagelocked_empty(trt.volume(context.get_binding_shape(0)), dtype=np.float32)
h_output = cuda.pagelocked_empty(trt.volume(context.get_binding_shape(1)), dtype=np.float32)
d_input = cuda.mem_alloc(h_input.nbytes)
d_output = cuda.mem_alloc(h_output.nbytes)
# 创建cuda流
stream = cuda.Stream()

#加载图片
img0 = cv2.imread("2.png", 0)
img1 = cv2.imread("10.png", 0)
blob0 = cv2.dnn.blobFromImage(img0, 1/255., size=(28,28), swapRB=True, crop=False)
blob1 = cv2.dnn.blobFromImage(img1, 1/255., size=(28,28), swapRB=True, crop=False)
np.copyto(h_input, np.concatenate((blob0, blob1), axis=0).ravel())

# 创建context并进行推理
with engine.create_execution_context() as context:
    # Transfer input data to the GPU.
    cuda.memcpy_htod_async(d_input, h_input, stream)
    # Run inference.
    context.execute_async_v2(bindings=[int(d_input), int(d_output)], stream_handle=stream.handle)
    # Transfer predictions back from the GPU.
    cuda.memcpy_dtoh_async(h_output, d_output, stream)
    # Synchronize the stream
    stream.synchronize()
    # Return the host output. 该数据等同于原始模型的输出数据
    pred = np.argmax(h_output.reshape(2, 10), axis=1)
    print(pred)

C++推理：

// tensorRT include
#include <NvInfer.h>
#include <NvInferRuntime.h>
#include <NvOnnxParser.h> // onnx解析器的头文件

// cuda include
#include <cuda_runtime.h>
#include <opencv2/opencv.hpp>

// system include
#include <stdio.h>
#include <fstream>


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 "unknow";
	}
}


class TRTLogger : public nvinfer1::ILogger
{
public:
	virtual void log(Severity severity, nvinfer1::AsciiChar const* msg) noexcept override
	{
		if (severity <= Severity::kINFO)
		{
			if (severity == Severity::kWARNING)
				printf("\033[33m%s: %s\033[0m\n", severity_string(severity), msg);
			else if (severity <= Severity::kERROR)
				printf("\033[31m%s: %s\033[0m\n", severity_string(severity), msg);
			else
				printf("%s: %s\n", severity_string(severity), msg);
		}
	}
} logger;



std::vector<unsigned char> load_file(const std::string & file)
{
	std::ifstream in(file, std::ios::in | std::ios::binary);
	if (!in.is_open())
		return {};

	in.seekg(0, std::ios::end);
	size_t length = in.tellg();

	std::vector<uint8_t> data;
	if (length > 0)
	{
		in.seekg(0, std::ios::beg);
		data.resize(length);
		in.read((char*)& data[0], length);
	}
	in.close();
	return data;
}


void inference()
{
	// ------------------------------ 1. 准备模型并加载   ----------------------------
	TRTLogger logger;
	auto engine_data = load_file("lenet.engine");
	// 执行推理前，需要创建一个推理的runtime接口实例。与builer一样，runtime需要logger：
	nvinfer1::IRuntime* runtime = nvinfer1::createInferRuntime(logger);
	// 将模型从读取到engine_data中，则可以对其进行反序列化以获得engine
	nvinfer1::ICudaEngine* engine = runtime->deserializeCudaEngine(engine_data.data(), engine_data.size());
	if (engine == nullptr)
	{
		printf("Deserialize cuda engine failed.\n");
		runtime->destroy();
		return;
	}

	nvinfer1::IExecutionContext* execution_context = engine->createExecutionContext();
	cudaStream_t stream = nullptr;
	// 创建CUDA流，以确定这个batch的推理是独立的
	cudaStreamCreate(&stream);

	// ------------------------------ 2. 准备好要推理的数据并搬运到GPU   ----------------------------
	int input_numel = 2 * 1 * 28 * 28;
	float* input_data_host = nullptr;
	cudaMallocHost(&input_data_host, input_numel * sizeof(float));

	cv::Mat image0 = cv::imread("2.png", 0);
	image0.convertTo(image0, CV_32FC1, 1.0f / 255.0f);
	float* pimage = (float*)image0.data;
	for (int i = 0; i < 28 * 28; i++)
	{
		input_data_host[i] = pimage[i];
	}

	cv::Mat image1 = cv::imread("10.png", 0);
	image1.convertTo(image1, CV_32FC1, 1.0f / 255.0f);
	pimage = (float*)image1.data;
	for (int i = 0; i < 28 * 28; i++)
	{
		input_data_host[28 * 28 + i] = pimage[i];
	}

	float* input_data_device = nullptr;
	float output_data_host[20];
	float* output_data_device = nullptr;
	cudaMalloc(&input_data_device, input_numel * sizeof(float));
	cudaMalloc(&output_data_device, sizeof(output_data_host));

	cudaMemcpyAsync(input_data_device, input_data_host, input_numel * sizeof(float), cudaMemcpyHostToDevice, stream);

	// 用一个指针数组指定input和output在gpu中的指针
	float* bindings[] = { input_data_device, output_data_device };

	// ------------------------------ 3. 推理并将结果搬运回CPU   ----------------------------
	bool success = execution_context->enqueueV2((void**)bindings, stream, nullptr);
	cudaMemcpyAsync(output_data_host, output_data_device, sizeof(output_data_host), cudaMemcpyDeviceToHost, stream);
	cudaStreamSynchronize(stream);

	int predict_label0 = std::max_element(output_data_host, output_data_host + 10) - output_data_host;
	int predict_label1 = std::max_element(output_data_host + 10, output_data_host + 20) - output_data_host - 10;
	std::cout << predict_label0 << std::endl;
	std::cout << predict_label1 << std::endl;

	// ------------------------------ 4. 释放内存 ----------------------------
	cudaStreamDestroy(stream);
	execution_context->destroy();
	engine->destroy();
	runtime->destroy();
}


int main()
{
	inference();

	return 0;
}
给算法爸爸上香
关注
专栏目录
Onnxruntime之tensorrt加速
如果想成为中心，那么就到中心去吧。
09-14 6858
引擎将在第一次构建时被缓存，因此下次创建新的推理会话时，引擎可以直接从缓存中加载。ORT_TENSORRT_INT8_USE_NATIVE_CALIBRATION_TABLE：选择在 INT8 模式下用于非 QDQ 模型的校准表。ORT_TENSORRT_CACHE_PATH：如果 ORT_TENSORRT_ENGINE_CACHE_ENABLE 为 1，则指定 TensorRT 引擎和配置文件的路径，如果 ORT_TENSORRT_INT8_ENABLE 为 1，则指定 INT8 校准表文件的路径。
pytorch 38 对tensorRT、openvino、onnxruntime（fp32、fp16）推理速度进行对比
a486259的博客
04-17 4223
tensorRT与openvino部署模型有必要么？本博文对tensorRT、openvino、onnxruntime推理速度进行对比，分别在vgg16、resnet50、efficientnet_b1和cspdarknet53四个模型进行进行实验，对于openvino和onnxruntime还进行了cpu下的推理对比。对比囊括了fp32、fp16两种情况。在float32下通过实验得出：openvino GPU < onnxruntime CPU
pytorch gpu推理、onnxruntime gpu推理、tensorrt gpu推理比较，及安装教程，有详细代码解释
m0_59156726的博客
10-30 5444
onnx , tensorrt 安装推理比较，有代码
onnxruntime c++ 推理例子
最新发布
weixin_43632469的博客
09-20 540
内存竞技场是一块预先分配的内存区域，用于存储模型推理过程中的所有中间数据。这种机制可以减少频繁的内存分配和释放操作，从而提高性能，尤其是在处理多个推理请求时。是 ONNX Runtime 中的一个会话选项，用于控制是否在模型推理过程中使用内存模式优化。内存模式优化是指 ONNX Runtime 会根据模型的内存访问模式来分配和重用内存，以减少内存分配和释放的开销，从而提高推理性能。然而，在某些情况下，如多线程环境中，内存竞技场可能会导致内存使用不断增加，因为分配的内存不会立即释放回操作系统。
tensorRT 多batch 推理
cindywry的博客
02-27 1316
tensorrt 多batch 推理
tensorRT多batch动态推理
qq_35037684的博客
07-26 2009
tensorRT的多batch推理，导出的onnx模型必须是动态batch，只需在导出的时候，设置一个dynamic_axis参数即可。增加这一句：context->setBindingDimensions(0, Dims4(5, 3, 256, 256));
利用 onnxruntime 库同时推理多个模型的效率研究
qq_42681787的博客
05-31 776
利用 onnxruntime 库同时推理多个模型的效率研究
【TensorRT】动态batch进行推理
豆芽菜
07-25 4466
模型训练时，每次训练可以接受不同batch大小的数据进行迭代，同样，在推理时，也会遇到输入Tensor大小(shape)是不确定的情况，其中最常见的就是动态batch了。
onnx处理和TensorRT量化推理相关代码工具
qq_35435798的博客
08-07 371
1. onnx合并、拆分、修改等操作 2. tensorrt模型量化推理等
TensorRT：在NVIDIA各种GPU硬件平台下运行的高性能推理C++库【Pytorch-＞ONNX-＞TensorRT】【实现神经网络提速(读取ONNX模型并运行)】【目前对ONNX的支持最好】
u013250861的博客
05-08 3355
一、什么是TensorRT TensorRT是可以在NVIDIA各种GPU硬件平台下运行的一个C++推理框架。 它旨在与TesnsorFlow、Caffe、Pytorch以及MXNet等训练框架以互补的方式进行工作，专门致力于在GPU上快速有效地进行网络推理。 我们利用Pytorch、TF或者其他框架训练好的模型，可以转化为TensorRT的格式，然后利用TensorRT推理引擎去运行我们这个模型，从而提升这个模型在英伟达GPU上运行的速度。 速度提升的比例是比较可观的。 借官方的话来说： The cor
【TensorRT】ONNX/TensorRT模型转换
尊新必威的博客
09-16 5001
TensorRT 模型的推理速度比 libtorch 模型更快，所以 PyTorch 模型转换为 TensorRT 模型部署几乎是最好的选择。通常TensorRT 模型首先需要转换为 ONNX 模型，再由 ONNX 模型转换为TensorRT 模型。本文对转换方法及一些注意点做一个记录。
一文掌握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
关于多batch推理的一点思考
Thomas_Cai的记忆殿堂
07-07 747
然后支持多batch的onnx模型转trt模型不要指定shape，指定optshape。然后推理trt模型，指定shape，这里指定shape不知道有没有效果，感觉没用，因为改变数字推理时间不会变长，应该是固定的用之前转trt的optshape在跑。最近要用nv卡跟其他卡对比多batch推理性能，调研后理了一下逻辑，记录一下，相关命令见我上一篇博文。最后看结果Throughtput为吞吐量，End-to-End的时间为跑完测试数据的平均时间，如果要算FPS，这里要Xbatchsize。
TensorRT(8):动态batch进行推理
hjxu2016的博客
08-19 1万+
TensorRT系列传送门(不定期更新): 深度框架|TensorRT 文章目录一、引言二、TRT在线加载模型，并序列化保存支持动态batch的引擎 一、引言 模型训练时，每次训练可以接受不同batch大小的数据进行迭代，同样，在推理时，也会遇到输入Tensor大小(shape)是不确定的情况，其中最常见的就是动态batch了。 动态batch，故名思意，就是只batch大小不确定的情况，比如这次推理了一张图像，下次推理就需要同时推理两张图像。 在Tensorflow中，定义一个动态batch的Ten.
pytorch模型的多batch推理
yangsn0719的博客
11-23 658
pytorch模型的多batch推理，这里用的是一个多标签分类模型，所以最后用的不是softmax而是sigmod。
ONNXRuntime、TensorRT扫盲
weixin_43870390的博客
02-20 1611
ONNXRuntime TensorRT
onnxruntime c++ 推理示例（tensorRT/cuda provider)
wohenibdxt的博客
06-15 6078
onnxruntime-gpu：在 nvidia gpu 上跑onnx模型获得与tensorRT相媲美的推理速度
yolov8多batch推理，nms后处理
nodototao的博客
03-08 3263
yolov8, 多batch，nms
onnx转trtengine多batch输入
qq_41062677的博客
08-23 215
inputIndex是输入绑定的索引值，可以使用engine->getNbBindings() 来获取模型输入输出的总绑定数。
onnx转tensorrt
06-06
TensorRT 是 NVIDIA 的一个高性能深度学习推理引擎，可以在 NVIDIA GPU 上加速深度学习推理。而 ONNX 是一种跨平台、开放的深度学习模型表示格式，可以在不同的深度学习框架之间灵活转换模型。 TensorRT 提供了一个 ONNX Parser，可以将 ONNX 模型解析为 TensorRT 的网络表示形式。这样，您就可以在 TensorRT 中加载 ONNX 模型，并在 NVIDIA GPU 上进行加速推理。以下是将 ONNX 模型转换为 TensorRT 的一些步骤： 1. 安装 TensorRT 和 ONNX Runtime 在使用 ONNX Parser 之前，需要先安装 TensorRT 和 ONNX Runtime。可以从 NVIDIA 官网下载 TensorRT，也可以通过 pip 安装 ONNX Runtime。 2. 将 ONNX 模型解析为 TensorRT 的网络表示形式 使用 TensorRT 的 ONNX Parser，可以将 ONNX 模型解析为 TensorRT 的网络表示形式。这个过程可以通过以下 Python 代码实现： ```python import tensorrt as trt import onnx # Load the ONNX model onnx_model = onnx.load("model.onnx") # Create a TensorRT builder builder = trt.Builder(TRT_LOGGER) # Create a TensorRT network from the ONNX model network = builder.create_network() parser = trt.OnnxParser(network, TRT_LOGGER) parser.parse(onnx_model.SerializeToString()) # Build an engine from the TensorRT network engine = builder.build_cuda_engine(network) ``` 在这个过程中，首先使用 ONNX 的 Python API 加载 ONNX 模型。然后，使用 TensorRT 的 Python API 创建一个 TensorRT builder 和一个 TensorRT network。接下来，使用 TensorRT 的 ONNX Parser 将 ONNX 模型解析为 TensorRT 的网络表示形式，并将其添加到 TensorRT network 中。最后，使用 TensorRT builder 构建一个 TensorRT 引擎。 3. 运行 TensorRT 引擎 构建完 TensorRT 引擎后，可以使用以下代码来运行 TensorRT 推理： ```python import pycuda.driver as cuda import pycuda.autoinit import numpy as np # Load the engine with open("engine.plan", "rb") as f: engine_data = f.read() engine = runtime.deserialize_cuda_engine(engine_data) # Allocate input and output buffers on the GPU input_bindings = [] output_bindings = [] stream = cuda.Stream() for binding in engine: size = trt.volume(engine.get_binding_shape(binding)) * engine.max_batch_size dtype = trt.nptype(engine.get_binding_dtype(binding)) if engine.binding_is_input(binding): input_bindings.append(cuda.mem_alloc(size * dtype.itemsize)) else: output_bindings.append(cuda.mem_alloc(size * dtype.itemsize)) # Load input data to the GPU input buffer input_data = np.random.randn(batch_size, input_size) cuda.memcpy_htod(input_bindings[0], input_data.flatten().astype(np.float32)) # Run inference context = engine.create_execution_context() context.execute_async_v2(bindings=input_bindings + output_bindings, stream_handle=stream.handle) cuda.streams.synchronize() # Get the output data from the GPU output buffer output_data = np.empty((batch_size, output_size), dtype=np.float32) cuda.memcpy_dtoh(output_data.flatten(), output_bindings[0]) ``` 在这个过程中，首先使用 TensorRT 的 Python API 加载 TensorRT 引擎。然后，使用 PyCUDA 分配输入和输出缓冲区，并将输入数据从主机（CPU）传输到设备（GPU）。接下来，使用 TensorRT 的 Python API 创建一个 TensorRT 执行上下文，并在 GPU 上异步执行 TensorRT 推理。最后，使用 PyCUDA 将输出数据从设备（GPU）传输到主机（CPU）。 这就是将 ONNX 模型转换为 TensorRT 的一些步骤。由于 ONNX Parser 是 TensorRT 的一部分，因此可以使用 TensorRT 的 Python API 轻松地将 ONNX 模型转换为 TensorRT。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

给算法爸爸上香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值