c++使用onnxruntime加载模型进行图片去噪

已于 2023-04-21 14:45:22 修改
阅读量1k 收藏 6
点赞数
分类专栏： 深度学习 bugs 文章标签： c++ 开发语言 opencv
于 2023-02-24 17:15:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41061370/article/details/129204509
版权

1. visual stdio 安装使用onnxruntime

visual stdio 安装onnxruntime，工具->Nuget包管理->点管理台后输入如第二张图 PM> xxx, 等下载好后就可以在本项目的目录中看到package文件夹中的onnxruntime了

2. 模型推理代码

首先配置好项目的依赖 属性中配置include和lib，如下二图。再找到onnxruntime.dll copy到项目根目录下。（注不清楚这一步做不做有没有关系，因为后来我发现vs中自己导入了onnxruntime.dll，onnxruntime_providers_shared.dll这两个文件）

 

代码如下：

c++接口 导出成dll后还依赖源码



void printModelInfo(Ort::Session &session, Ort::AllocatorWithDefaultOptions &allocator)
{
	//输出模型输入节点的数量
	size_t num_input_nodes = session.GetInputCount();
	size_t num_output_nodes = session.GetOutputCount();
	cout << "Number of input node is:" << num_input_nodes << endl;
	cout << "Number of output node is:" << num_output_nodes << endl;

	//获取输入输出维度
	for (auto i = 0; i < num_input_nodes; i++)
	{
		std::vector<int64_t> input_dims = session.GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
		cout << endl << "input " << i << " dim is: ";
		for (auto j = 0; j < input_dims.size(); j++)
			cout << input_dims[j] << " ";
	}
	for (auto i = 0; i < num_output_nodes; i++)
	{
		std::vector<int64_t> output_dims = session.GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
		cout << endl << "output " << i << " dim is: ";
		for (auto j = 0; j < output_dims.size(); j++)
			cout << output_dims[j] << " ";
	}

	cout <<  endl;
	//input_dims_2[0] = input_dims_1[0] = output_dims[0] = 1;//batch size = 1
}

void testImgenDenosing() {

	//refer： https://blog.csdn.net/qq_42995327/article/details/122622222
	// initialize  environment...one environment per process
	Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "test");

	// initialize session options if needed
	Ort::SessionOptions session_options;
	session_options.SetInterOpNumThreads(1);
	Ort::AllocatorWithDefaultOptions allocator;

#ifdef _WIN32
	const wchar_t* model_path = L"D:\\Documents\\projects\\Image-Denoising-using-Deep-Learning\\model.onnx";
#else
	const char* model_path = "D:\\Documents\\projects\\Image-Denoising-using-Deep-Learning\\model.onnx";
#endif

//#ifdef _WIN32
//	const wchar_t* model_path = L"D:\\Documents\\projects\\Image-Denoising-using-Deep-Learning\\best_REDNet_blindnoise_256x256.onnx";
//#else
//	const char* model_path = "D:\\Documents\\projects\\Image-Denoising-using-Deep-Learning\\best_REDNet_blindnoise_256x256.onnx";
//#endif

	Ort::Session session(env, model_path, session_options);
	Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);

	// print number of model input nodes
	size_t num_input_nodes = session.GetInputCount();

	cout << num_input_nodes << endl;

	printModelInfo(session, allocator);
	cout << session.GetInputTypeInfo(0).GetTensorTypeAndShapeInfo().GetElementType() << endl;

	/**
	输出的数字对应
typedef enum ONNXTensorElementDataType {
  ONNX_TENSOR_ELEMENT_DATA_TYPE_UNDEFINED,
  ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT,   // maps to c type float
  ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8,   // maps to c type uint8_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_INT8,    // maps to c type int8_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT16,  // maps to c type uint16_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_INT16,   // maps to c type int16_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32,   // maps to c type int32_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64,   // maps to c type int64_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_STRING,  // maps to c++ type std::string
  ONNX_TENSOR_ELEMENT_DATA_TYPE_BOOL,
  ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16,
  ONNX_TENSOR_ELEMENT_DATA_TYPE_DOUBLE,      // maps to c type double
  ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT32,      // maps to c type uint32_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT64,      // maps to c type uint64_t
  ONNX_TENSOR_ELEMENT_DATA_TYPE_COMPLEX64,   // complex with float32 real and imaginary components
  ONNX_TENSOR_ELEMENT_DATA_TYPE_COMPLEX128,  // complex with float64 real and imaginary components
  ONNX_TENSOR_ELEMENT_DATA_TYPE_BFLOAT16     // Non-IEEE floating-point format based on IEEE754 single-precision
} ONNXTensorElementDataType;

	**/



	//输入网络的维度
	static constexpr const int width = 256;
	static constexpr const int height = 256;
	static constexpr const int channel = 3;
	std::array<int64_t, 4> input_shape_{ 1,width, height,channel };


	Mat img_1 = cv::imread("C:\\Users\\cls\\Downloads\\240px-NIND_BruegelLibraryS1_ISOH1.png");
	//通道交换
	cv::cvtColor(img_1, img_1, COLOR_BGR2RGB);
	Mat Input_1;
	resize(img_1, Input_1, Size(width, height));


	通道分离
	//vector<Mat> channels;
	//split(Input_1, channels);

	//Mat imageBlueChannel;
	//Mat imageGreenChannel;
	//Mat imageRedChannel;

	//imageBlueChannel = channels.at(0);
	//imageGreenChannel = channels.at(1);
	//imageRedChannel = channels.at(2);

	//channels.at(0) = imageRedChannel;
	//channels.at(2) = imageBlueChannel;

	//merge(channels, Input_1);


	std::vector<const char*> input_node_names = { "input_layer" };
	std::vector<const char*> output_node_names = { "add_3" };


	std::array<UINT8, width * height *channel> input_image_1{};
	UINT8* input_1 = input_image_1.data();

	for (int i = 0; i < Input_1.rows; i++) {
		for (int j = 0; j < Input_1.cols; j++) {
			for (int c = 0; c < 3; c++)
			{
				//NHWC 格式
				if (c == 0)
					input_1[i*Input_1.cols * 3 + j * 3 + c] = Input_1.ptr<uchar>(i)[j * 3 + 2];
				if (c == 1)
					input_1[i*Input_1.cols * 3 + j * 3 + c] = Input_1.ptr<uchar>(i)[j * 3 + 1];
				if (c == 2)
					input_1[i*Input_1.cols * 3 + j * 3 + c] = Input_1.ptr<uchar>(i)[j * 3 + 0];
				//NCHW 格式
//                if (c == 0)
//                     input_1[c*imgSource.rows*imgSource.cols + i * imgSource.cols + j] = imgSource.ptr<uchar>(i)[j * 3 + 2]/255.0;
//                if (c == 1)
//                     input_1[c*imgSource.rows*imgSource.cols + i * imgSource.cols + j] = imgSource.ptr<uchar>(i)[j * 3 + 1]/255.0;
//                if (c == 2)
//                     input_1[c*imgSource.rows*imgSource.cols + i * imgSource.cols + j] = imgSource.ptr<uchar>(i)[j * 3 + 0]/255.0;


			}
		}
	}


	std::vector<Ort::Value> input_tensors;
	input_tensors.push_back(Ort::Value::CreateTensor<UINT8>(
		memory_info, input_1, input_image_1.size(), input_shape_.data(), input_shape_.size()));


	auto output_tensors = session.Run(Ort::RunOptions{ nullptr },
		input_node_names.data(), //输入节点名
		input_tensors.data(),     //input tensors
		input_tensors.size(),     //1
		output_node_names.data(), //输出节点名
		output_node_names.size()); //1



	float* output = output_tensors[0].GetTensorMutableData<float>();


	Mat output_1 = Mat::zeros(Size(256, 256), CV_8UC3);

	//for (int i = 0; i < output_1.rows; i++) {
	//	for (int j = 0; j < output_1.cols; j++) {
	//		for (int c = 0; c < 3; c++)
	//		{
	//			//NHWC 格式
	//			if (c == 0)
	//			{
	//				output_1.at<Vec3f>(i, j)[2] = int(output[i*output_1.cols * 3 + j * 3 + c]); cout << output_1.at<Vec3f>(i, j)[2] << " ";
	//			}
	//			
	//			else if (c == 1)
	//			{
	//				output_1.at<Vec3f>(i, j)[1] = int(output[i*output_1.cols * 3 + j * 3 + c]); cout << output_1.at<Vec3f>(i, j)[2] << " ";
	//			}
	//			else if (c == 2)
	//			{
	//				output_1.at<Vec3f>(i, j)[0] = int(output[i*output_1.cols * 3 + j * 3 + c]); cout << output_1.at<Vec3f>(i, j)[2] << " ";
	//			}
	//			
	//		}
	//		cout << endl;
	//	}
	//}

	for (int i = 0; i < output_1.rows; i++) {
		for (int j = 0; j < output_1.cols; j++) {
			for (int c = 0; c < 3; c++)
			{
				//NHWC 格式
				if (c == 0)
				{
					output_1.ptr<UINT8>(i)[j * 3 + 2] = UINT8(output[i*output_1.cols * 3 + j * 3 + c]);
				}

				else if (c == 1)
				{
					output_1.ptr<UINT8>(i)[j * 3 + 1] = UINT8(output[i*output_1.cols * 3 + j * 3 + c]);
				}
				else if (c == 2)
				{
					output_1.ptr<UINT8>(i)[j * 3 + 0] = UINT8(output[i*output_1.cols * 3 + j * 3 + c]);
				}
			}
		}
	}

	cout << "tun to here" << endl;
	cv::imshow("input", Input_1);
	cv::imshow("output", output_1);
	cv::waitKey(0);
}

去噪效果感觉不行，主要是跑网络模型啦：

c接口 将版本设成10再导成dll可不依赖源码

	const char* inputNames[] = { "input_layer" }; //输入节点名
	const char* outputNames[] = { "add_3" }; //输出节点名
	int inputNodeNum = 1;//输入节点个数
	int outputNodeNum = 1; //输出节点个数

	int input_w = 256;//模型输入width
	int input_h = 256;//模型输入height

	//H*W*C
	size_t model_input_ele_count = input_h * input_w * 3;

	//input data
	UINT8* model_input = (UINT8*)malloc(sizeof(UINT8) * model_input_ele_count);

	//{N,C,H,W}
	int64_t input_shape[4];
	input_shape[0] = 1;
	input_shape[1] = input_h;
	input_shape[2] = input_w;
	input_shape[3] = 3;

	size_t input_shape_len = 4;//dim = 4

	size_t model_input_len = model_input_ele_count * sizeof(UINT8);

	//初始化OrtApi
	const OrtApi* g_ort = nullptr;
	//g_ort = OrtGetApiBase()->GetApi(ORT_API_VERSION); //这里得用10
	g_ort = OrtGetApiBase()->GetApi(10);
	//初始化OrtEnv
	OrtEnv* env;
	g_ort->CreateEnv(ORT_LOGGING_LEVEL_WARNING, "test", &env);

	//初始化session_options
	OrtSessionOptions* session_options;
	g_ort->CreateSessionOptions(&session_options);

	//初始化session
	OrtSession* session;
	g_ort->CreateSession(env, model_path, session_options, &session);


	//预处理
	cv::resize(srcimg, srcimg, Size(input_w, input_h));


	//BGR2RGB
	for (int i = 0; i < input_h; i++) {
		for (int j = 0; j < input_w; j++) {
			model_input[i * input_w + j + 0] = srcimg.at<cv::Vec3b>(i, j)[2];//R
			model_input[i * input_w + j + 1 * input_w * input_h] = srcimg.at<cv::Vec3b>(i, j)[1];//G
			model_input[i * input_w + j + 2 * input_w * input_h] = srcimg.at<cv::Vec3b>(i, j)[0];//B
		}
	}

	//input_tensor
	OrtValue* input_tensor = NULL;
	OrtMemoryInfo* memory_info = NULL;
	g_ort->CreateCpuMemoryInfo(OrtArenaAllocator, OrtMemTypeDefault, &memory_info);
	g_ort->CreateTensorWithDataAsOrtValue(memory_info, model_input, model_input_len, input_shape, input_shape_len, ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8, &input_tensor);
	assert(input_tensor != NULL);

	//推理
	OrtValue* output_tensor = NULL;
	g_ort->Run(session, NULL, inputNames, &input_tensor, inputNodeNum, outputNames, outputNodeNum, &output_tensor);
	assert(output_tensor != NULL);

	//后处理
	std::vector<float> result;

	//获取output的shape
	struct OrtTensorTypeAndShapeInfo* shape_info;
	g_ort->GetTensorTypeAndShape(output_tensor, &shape_info);


	//获取output的dim
	size_t dim_count;
	g_ort->GetDimensionsCount(shape_info, &dim_count);
	//std::cout<< dim_count << std::endl;

	//获取output的shape
	int64_t dims[2];
	g_ort->GetDimensions(shape_info, dims, sizeof(dims) / sizeof(dims[0]));
	//std::cout<< dims[0] << "," << dims[1] << std::endl;
	

	//取output数据
	float* f;
	auto onnx_status = g_ort->GetTensorMutableData(output_tensor, (void**)&f);
	float max_val = *max_element(f, f + input_h * input_w * 3);
	float min_val = *min_element(f, f + input_h * input_w * 3);
	float scale = max_val - min_val;

	Mat output = Mat::zeros(Size(input_h, input_w), CV_8UC3);

	//BGR2RGB
	for (int i = 0; i < input_h; i++) {
		for (int j = 0; j < input_w; j++) {
			output.at<cv::Vec3b>(i, j)[2] = UINT8((f[i * input_h + j + 0] - min_val) / scale * 255);
			output.at<cv::Vec3b>(i, j)[1] = UINT8((f[i * input_h + j + 1 * input_h * input_w] - min_val) / scale * 255);
			output.at<cv::Vec3b>(i, j)[0] = UINT8((f[i * input_h + j + 2 * input_h * input_w] - min_val) / scale * 255);
		}
	}


	cv::imshow("res", output);
	cv::waitKey(0);
	cv::destroyAllWindows();

refer:  https://blog.csdn.net/qq_42995327/article/details/122622222

模型：深度学习去噪onnx模型-深度学习文档类资源-CSDN文库

顺炸天
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ONNX：C++通过onnxruntime使用.onnx模型进行前向计算【下载的onnxruntime是编译好的库文件，可直接使用】
u013250861的博客
11-13 7908
利用onnx和onnxruntime实现深度框架使用C++推理进行服务器部署，模型推理的性能是比python快很多的。
C#onnxruntime模型部署时，无法在 DLL“onnxruntime”中找到名为“OrtGetApiBase”的入口点的解决方法
q852474220的博客
02-22 1420
Unable to find an entry point named ‘OrtGetApiBase‘ in DLL ‘onnxruntime‘
深度学习模型部署——基于Onnx Runtime的深度学习模型CPU与GPU部署（C++实现）
u013250861的博客
05-29 1098
许多机器学习和深度学习模型都是在基于 Python 的框架中开发和训练的，例如 PyTorch 和 TensorFlow 等。但是，当需要将这些训练好模型部署到生产环境中时，通常会希望将模型集成到生产流程中，而这些流程大多是用 C++ 编写的，因为 C++ 可以提供更快的实时性能。目前有许多工具和框架可以帮助我们将预训练模型部署到 C++ 应用程序中。
填坑记录: visual studio 无法解析的外部符号 OrtGetApiBase
qq_51729332的博客
11-17 1014
将 onnxruntime.dll文件拷贝到可执行当前目录(以下我添加的位置)下载 onnxruntime-win-x64-1.16.1。再次运行,问题解决!
Yolo v5 pytorch模型转onnx用c++进行推理
qq_33671888的博客
03-02 9380
yolov5 c++ python java 推理
C++ 上用 ONNXruntime 部署自己的模型
热门推荐
老邹的博客
01-21 1万+
利用C++ ONNXruntime部署自己的模型，这里用Keras搭建好的一个网络模型来举例，转换为onnx的文件，在C++上进行部署，另外可以利用tensorRT加速。 目录一、模型的准备二、配置ONNXruntime三、模型的部署1. 模型的初始化设置2. 构建推理构建推理函数computPoseDNN()步骤：函数具体代码：四、应用参考 一、模型的准备 搭建网络模型训练： tensorflow keras 搭建相机位姿估计网络–例 网络的输入输出为： 网络的输入： [image_ref , ima
onnxruntime c++ inference
juluwangriyue的博客
06-25 4688
1、导出模型 首先，利用pytorch自带的torch.onnx模块导出 .onnx模型文件，具体查看该部分pytorch官方文档，主要流程如下： import torch checkpoint = torch.load(model_path) model = ModelNet(params) model.load_state_dict(checkpoint['model']) model.eval() input_x_1 = torch.randn(10,20) input_x_2 = torch.ra
使用C++ 与ONNXRuntime部署yolov8旋转目标检测源码+模型(c++).zip
09-01
- 加载模型：使用ONNXRuntime API创建会话实例，加载预先转换好的ONNX模型。 - 数据预处理：将输入图像进行预处理，包括缩放、归一化等，以符合模型输入的要求。 - 执行推理：通过ONNXRuntime的接口，将预处理后...
C++ OnnxRuntime部署yolov8模型
07-20
本文将深入探讨如何使用C++配合ONNXRuntime来部署YOLOv8模型，实现高效的实时目标检测。 首先，让我们了解YOLOv8。YOLOv8是YOLO系列的最新迭代，它在保持快速检测速度的同时，提高了检测精度。YOLOv8通过改进网络...
基于C++和onnxruntime部署yolov10的onnx模型源码
最新发布
06-13
首先cmake生成exe文件，然后将onnxruntime.dll和onnxruntime_providers_shared.dll放到exe一起，不然会提示报错0xc000007b，这是因为系统目录也有个onnxruntime.dll引发冲突，并把car.mp4也放到exe一起。运行直接...
算法部署-基于C++和Python使用ONNXRuntime部署RT-DETR目标检测算法-附项目源码-优质项目实战.zip
05-12
3. **编译ONNX模型**：使用ONNXRuntime的API加载ONNX模型，并进行编译。这一步会根据目标硬件环境生成最佳的执行计划。 4. **编写推理代码**：在C++或Python中编写推理代码，加载编译后的执行计划，预处理输入图像...
C++使用onnxruntime/opencv对onnx模型进行推理(附代码)
05-23
C++使用onnxruntime/opencv对onnx模型进行推理(附代码)
人体姿态估计 HRNet C++版
xz1203的博客
04-25 3883
最近由于项目原因，需要用到HRNet网络，加上前面的目标检测部分，使用python版本的代码运行太慢，于是想到了用c++来重写HRNet，将pytorch的模型文件转换为onnx，采用onnx的c++的推理库。然后目标检测网络采用轻量级的nanodet，同时也采用onnx进行推理。最后，在我的笔记本电脑上（GTX960M）进行单人的姿态估计也跑到了20帧左右。其中nanodet是0.01s左右，hrnet是0.04s左右，hrnet是w32_256*192的模型转换而来的。多人的话时间就是成倍增长。
onnxruntime C#GPU推理闪退问题解决和Log日志使用方法OrtLoggingLevel
q852474220的博客
02-27 820
当我们正确安装CUDA、cudnn和Microsoft.ML.OnnxRuntime.Gpu（NuGet包）后，CPU可以正常推理，但是GPU一运行InferenceSession对象的Run()就闪退，没有任何提示。但是观察任务管理器加载模型时GPU专用内存有少量提升，Cuda性能有波动。这时问题一般出在缺少libwapi.dll上，安装即可。也可以启动onnxruntime的log记录功能查看。程序闪退时，GPU专用内存下降，Cuda性能有波动。
onnxruntime c++ 工程实例
jacke121的专栏
01-28 2275
onnxruntime下载： 库下载： https://gitee.com/benjaminwan/ocr-lite-onnx/releases/v1.0 参考项目： 1. paddlecor 参见我的另一篇博客： paddleoc onnx转换推理_jacke121的专栏-CSDN博客 2. A cross platform OCR Library based on PaddleOCR & OnnxRuntime https://github.com/RapidAI/Ra..
c++动态库之四 onnxruntime
qq_33619359的博客
03-22 1293
终于进入正题了，首先我们先默认已经装好了onnx并且能正常运行，具体步骤跳到第一篇文章去看。 注意，我输入的是特征而不是图片，即输入是二维的不是三维的，三维的情况下篇文章再说。 下方是总体代码，我数据处理部分太长就不贴出来了，最后输入的特征是vector< float >的格式，具体一点就是8046 ，输出是20183，我的label类别有83，特征804卷出来后是201。python的onnx是可以任意长度的输入，不过c++的好像必须是固定长度，这些数字在之前python输出onnx模型的时候
OCR 跨平台工程化onnxruntime gpu c++代码
weixin_42280271的博客
07-22 2655
OCR 跨平台工程化onnxruntime gpu c++代码 网上关于onnxruntime运行在gpu环境下运行OCR模型的代码较少，经过查阅，其实就是在初始化模型的时候这样写就可以了 void DbNet::setNumThread(int numOfThread) { numThread = numOfThread; //===session options=== // Sets the number of threads used to parallelize the ex
tensor.get_shape()
william_hehe的博客
12-10 1263
tensor.get_shape() 功能：获取已知张量的维度。 例子：import tensorflow as tfa=tf.get_variable('a',shape=[4,2,2,1],initializer=tf.constant_initializer(0))b=a.get_shape() #获取已知张量的维度，输出为一个元组。 c=b.as_list() #将元组转换为列表
onnxruntime使用c++对模型进行半精度推理
07-08
在C++中，你可以使用onnxruntime::InferenceSession类来加载和运行模型。使用onnxruntime::SessionOptions类可以设置推理选项，包括精度设置。 4. 设置输入数据。使用onnxruntime::RunOptions类可以设置运行选项，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值