当前位置： 首页 > article >正文

【深度学习】【目标检测】【OnnxRuntime】【C++】YOLOV3模型部署

article 2025/3/29 12:35:08

【深度学习】【目标检测】【OnnxRuntime】【C++】YOLOV3模型部署

提示:博主取舍了很多大佬的博文并亲测有效,分享笔记邀大家共同学习讨论

文章目录

  • 【深度学习】【目标检测】【OnnxRuntime】【C++】YOLOV3模型部署
  • 前言
  • Windows平台搭建依赖环境
  • 模型转换--pytorch转onnx
  • ONNXRuntime推理代码
    • YOLOV3前后处理代码
    • 完整推理代码
  • 总结

前言

本期将讲解深度学习目标检查网络YOLOV3模型的部署，对于该算法的基础知识，可以参考其他博主博文。
读者可以通过学习【OnnxRuntime部署】系列学习文章目录的C++篇* 的内容，系统的学习OnnxRuntime部署不同任务的onnx模型。

Windows平台搭建依赖环境

在【入门基础篇】中详细的介绍了onnxruntime环境的搭建以及ONNXRuntime推理核心流程代码，不再重复赘述。

模型转换–pytorch转onnx

本博文将通过Ultralytics–YOLOv3算法的人脸检测项目【参考博文：Windows11下YOLOV3人脸目标检测】，简要介绍YOLOV3模型部署。
在博文Windows11下YOLOV3人脸目标检测项目中已经通过以下命令导出了onnx模型：

python export.py --weights runs/train/exp/weights/best.pt --include onnx


【yolov3-face.onnx百度云链接，提取码：zd6a 】直接下载使用即可。

ONNXRuntime推理代码

YOLOV3前后处理代码

1.利用可视化工具查看onnx模型结构： 为了直观地看到整个神经网络的架构，包括各个层（如卷积层、全连接层等）及其连接方式，需要通过可视化工具展示，Netron是一个开源的可视化工具【在线工具】，支持包括ONNX在内的多种深度学习模型格式。它提供了一个交互式的用户界面，可以展示模型的层次结构、参数细节等。
将onnx模型上传到在线Netron可视化工具：

简单说明下四个输出分别代表的含义：
第一个输出：1代表batchsize；25200代表检测框的个数；6代表框的详细信息：即框中心点xy+框宽高hw+框置信度conf+框分类个数(这里是1)。
第二(三/四)个输出：1代表batchsize；3代表着当前网络层输出的特征图每个像素包含的框的个数；,80和80代表特征图的分辨率；6代表框的详细信息。

2.获取模型输出信息： YOLOV3模型是单输入多输出的模型，输入信息的获取方式和之前讲解的图像分类的保持一致，这里重点讲解下多输出信息的获取方式。 YOLOV3模型通常只需要获取第一个输出信息，这里博主分别保存了每个输出的信息，为未来处理其他多输入/输出时模型候提供参考。

// 获取模型输出信息
std::vector<int> nums;
std::vector<int> nbs;				
std::vector<int> ncs;
std::vector<int> ncs1;
std::vector<int> ncs2;
for (int i = 0; i < output_nodes_num; i++) {
	// 获得输出节点的名称并存储
	auto output_name = session_.GetOutputNameAllocated(i, allocator);
	output_node_names.push_back(output_name.get());
	// 显示输出结果的形状
	auto outShapeInfo = session_.GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
	nums.push_back(outShapeInfo[0]);
	nbs.push_back(outShapeInfo[1]);
	ncs.push_back(outShapeInfo[2]);
	if (outShapeInfo.size()>3) {
	ncs1.push_back(outShapeInfo[3]);
	ncs2.push_back(outShapeInfo[4]);
	std::cout << output_node_names[i].c_str() << " format: " << nums[i] << "x" << nbs[i] << "x" << ncs[i] << "x" << ncs1[i] 
		<< "x" << ncs2[i] << std::endl;
	}
	else {
		ncs1.push_back(0);
		ncs2.push_back(0);
		std::cout << output_node_names[i].c_str() << " format: " << nums[i] << "x" << nbs[i] << "x" << ncs[i] << std::endl;
	}

3.输入数据预处理： 输入预处理基本流程和此前的图像分类的类似，只是在YOLO系列中不需要考虑方差，因为rgb通道调整、归一化、图像缩放等可以直接通过 cv::dnn::blobFromImage函数完成。

	// ******************* 5.输入数据预处理 *******************
	// 原始图像的宽高
	int w = frame.cols;
	int h = frame.rows;
	// 原始图像与输入图像之间的缩放系数
	float x_factor = 0.0;
	float y_factor = 0.0;
	// 获得原始图像中宽高中的长边,最为变换正方形的边长
	int _max = std::max(h, w);	
	// 将原始的矩形图像放大变换成正方形图像,默认补零
	cv::Mat image = cv::Mat::zeros(cv::Size(_max, _max), CV_8UC3);
	cv::Rect roi(0, 0, w, h);
	frame.copyTo(image(roi));
	// 计算宽高的缩放系数,模型的输入恒定为640×640,必须强制转换成浮点数
	x_factor = image.cols / static_cast<float>(640);	
	y_factor = image.rows / static_cast<float>(640);
	// 完成归一化:1.0 / 255.0;缩放:cv::Size(input_w, input_h);格式转换(BGR转RGB):true
	cv::Mat blob = cv::dnn::blobFromImage(image, 1.0 / 255.0, cv::Size(input_w, input_h), cv::Scalar(0, 0, 0), true, false);
	std::cout << blob.size[0] << "x" << blob.size[1] << "x" << blob.size[2] << "x" << blob.size[3] << std::endl;
	// ********************************************************

这里需要注意一点，通常预测图像都不是规则的正方形尺寸，但是博主的yolov3版本是640×640的规则输入，因为宽高进行等比缩放(resize)操作或者宽高单独进行粗暴的缩放操作都可能会影响模型的预测，因此需要先将预测图像补零扩展变成规则的规则输入，再进行缩放操作。

4.后处理推理结果： YOLOV3输出得到的目标框个数为25200(通常是固定的)，通过置信度得分和分类得分筛选出有目标的目标框，在通过NMS剔除针对同一目标重复多余的目标框。

	// ******************* 8.后处理推理结果 *******************
	// 1x25200x6 获取(第一个)输出数据并包装成一个cv::Mat对象,为了方便后处理
	const float* pdata = ort_outputs[0].GetTensorMutableData<float>();
	cv::Mat det_output(nbs[0], ncs[0], CV_32F, (float*)pdata);
	std::vector<cv::Rect> boxes;		// 目标框的坐标位置
	std::vector<float> confidences;		// 目标框的置信度
	std::vector<int> classIds;			// 目标框的类别得分
	// 剔除置信度较低的目标框,不作处理
	for (int i = 0; i < det_output.rows; i++) {
		float confidence = det_output.at<float>(i, 4);
		if (confidence < 0.45) {
			continue;
		}
		// 获得当前目标框的类别得分
		cv::Mat classes_scores = det_output.row(i).colRange(5, ncs[0]);
		// 这里与图像分类的方式一致
		cv::Point classIdPoint;		// 用于存储分类中的得分最大值索引(坐标)
		double score;				// 用于存储分类中的得分最大值
		minMaxLoc(classes_scores, 0, &score, 0, &classIdPoint);
		// 处理分类得分较高的目标框
		if (score > 0.25)
		{	
			// 计算在原始图像上,目标框的左上角坐标和宽高
			// 在输入图像上目标框的中心点坐标和宽高
			float cx = det_output.at<float>(i, 0);	
			float cy = det_output.at<float>(i, 1);
			float ow = det_output.at<float>(i, 2);
			float oh = det_output.at<float>(i, 3);
			//原始图像上目标框的左上角坐标
			int x = static_cast<int>((cx - 0.5 * ow) * x_factor);	
			int y = static_cast<int>((cy - 0.5 * oh) * y_factor);
			//原始图像上目标框的宽高
			int width = static_cast<int>(ow * x_factor);
			int height = static_cast<int>(oh * y_factor);
			// 记录目标框信息
			cv::Rect box;
			box.x = x;
			box.y = y;
			box.width = width;
			box.height = height;
			boxes.push_back(box);
			classIds.push_back(classIdPoint.x);
			confidences.push_back(score);
		}
	}
	// NMS:非极大值抑制(Non-Maximum Suppression),剔除针对同一目标重复多余的目标框
	std::vector<int> indexes;	// 剔除多余目标框后,保留的目标框的序号
	cv::dnn::NMSBoxes(boxes, confidences, 0.25, 0.45, indexes);

	// 遍历筛选出的目标框
	for (size_t i = 0; i < indexes.size(); i++) {
		int idx = indexes[i];		// 获取当前目标框序号
		int cid = classIds[idx];	// 获取目标框分类得分
		// 输入/输出图像:frame;目标位置信息:boxes[idx];目标框颜色: cv::Scalar(0, 0, 255);
		// 边框线的厚度:4;线条类型:8;坐标点小数位数精度:0(通常为0)
		cv::rectangle(frame, boxes[idx], cv::Scalar(0, 0, 255), 4, 8, 0);	// 在原始图片上框选目标区域
		// 输入/输出图像:frame;绘制文本内容:labels[cid].c_str();文本起始位置(左下角):boxes[idx].tl();
		// 字体类型:cv::FONT_HERSHEY_PLAIN;字体大小缩放比例:2.5;文本颜色:cv::Scalar(255, 0, 0);文本线条的厚度:3;线条类型:8
		putText(frame, labels[cid].c_str(), boxes[idx].tl(), cv::FONT_HERSHEY_PLAIN, 2.5, cv::Scalar(255, 0, 0), 3, 8);	// 目标区域的类别
	}
	// ********************************************************

完整推理代码

需要配置face_classes.txt文件存储人脸的分类标签，并将其放置到工程目录下(推荐)。

face

这里需要将yolov3-face.onnx放置到工程目录下(推荐)，并且将以下推理代码拷贝到新建的cpp文件中，并执行查看结果。

#include "onnxruntime_cxx_api.h"
#include "cpu_provider_factory.h"
#include <opencv2/opencv.hpp>
#include <fstream>

// 加载标签文件获得分类标签
std::string labels_txt_file = "./face_classes.txt";
std::vector<std::string> readClassNames();
std::vector<std::string> readClassNames()
{
	std::vector<std::string> classNames;

	std::ifstream fp(labels_txt_file);
	if (!fp.is_open())
	{
		printf("could not open file...\n");
		exit(-1);
	}
	std::string name;
	while (!fp.eof())
	{
		std::getline(fp, name);
		if (name.length())
			classNames.push_back(name);
	}
	fp.close();
	return classNames;
}

int main(int argc, char** argv) {

	// 预测的目标标签数
	std::vector<std::string> labels = readClassNames();

	// 测试图片
	cv::Mat frame = cv::imread("./zidane.jpg");
	cv::imshow("输入图", frame);

	// ******************* 1.初始化ONNXRuntime环境 *******************
	Ort::Env env = Ort::Env(ORT_LOGGING_LEVEL_ERROR, "YOLOV3-onnx");
	// ***************************************************************

	// ******************* 2.设置会话选项 *******************
	// 创建会话
	Ort::SessionOptions session_options;
	// 优化器级别:基本的图优化级别
	session_options.SetGraphOptimizationLevel(ORT_ENABLE_BASIC);
	// 线程数:4
	session_options.SetIntraOpNumThreads(4);
	// 设备使用优先使用GPU而是才是CPU
	std::cout << "onnxruntime inference try to use GPU Device" << std::endl;
	OrtSessionOptionsAppendExecutionProvider_CUDA(session_options, 0);
	OrtSessionOptionsAppendExecutionProvider_CPU(session_options, 1);
	// ******************************************************
	
	// ******************* 3.加载模型并创建会话 *******************
	// onnx训练模型文件
	std::string onnxpath = "./yolov3-face.onnx";
	std::wstring modelPath = std::wstring(onnxpath.begin(), onnxpath.end());
	Ort::Session session_(env, modelPath.c_str(), session_options);
	// ************************************************************
	
	// ******************* 4.获取模型输入输出信息 *******************
	int input_nodes_num = session_.GetInputCount();			// 输入节点输
	int output_nodes_num = session_.GetOutputCount();		// 输出节点数
	std::vector<std::string> input_node_names;				// 输入节点名称
	std::vector<std::string> output_node_names;				// 输出节点名称
	Ort::AllocatorWithDefaultOptions allocator;				// 创建默认配置的分配器实例,用来分配和释放内存		
	// 输入图像尺寸
	int input_h = 0;
	int input_w = 0;
	// 获取模型输入信息
	for (int i = 0; i < input_nodes_num; i++) {
		// 获得输入节点的名称并存储
		auto input_name = session_.GetInputNameAllocated(i, allocator);
		input_node_names.push_back(input_name.get());
		// 显示输入图像的形状
		auto inputShapeInfo = session_.GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
		int ch = inputShapeInfo[1];
		input_h = inputShapeInfo[2];
		input_w = inputShapeInfo[3];
		std::cout << "input format: " << ch << "x" << input_h << "x" << input_w << std::endl;
	}
	// 获取模型输出信息
	std::vector<int> nums;
	std::vector<int> nbs;				
	std::vector<int> ncs;
	std::vector<int> ncs1;
	std::vector<int> ncs2;
	for (int i = 0; i < output_nodes_num; i++) {
		// 获得输出节点的名称并存储
		auto output_name = session_.GetOutputNameAllocated(i, allocator);
		output_node_names.push_back(output_name.get());
		// 显示输出结果的形状
		auto outShapeInfo = session_.GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
		nums.push_back(outShapeInfo[0]);
		nbs.push_back(outShapeInfo[1]);
		ncs.push_back(outShapeInfo[2]);
		if (outShapeInfo.size()>3) {
		ncs1.push_back(outShapeInfo[3]);
		ncs2.push_back(outShapeInfo[4]);
		std::cout << output_node_names[i].c_str() << " format: " << nums[i] << "x" << nbs[i] << "x" << ncs[i] << "x" << ncs1[i] 
			<< "x" << ncs2[i] << std::endl;
		}
		else {
			ncs1.push_back(0);
			ncs2.push_back(0);
			std::cout << output_node_names[i].c_str() << " format: " << nums[i] << "x" << nbs[i] << "x" << ncs[i] << std::endl;
		}
	}
	// **************************************************************

	// ******************* 5.输入数据预处理 *******************
	// 原始图像的宽高
	int w = frame.cols;
	int h = frame.rows;
	// 原始图像与输入图像之间的缩放系数
	float x_factor = 0.0;
	float y_factor = 0.0;
	// 获得原始图像中宽高中的长边,最为变换正方形的边长
	int _max = std::max(h, w);	
	// 将原始的矩形图像放大变换成正方形图像,默认补零
	cv::Mat image = cv::Mat::zeros(cv::Size(_max, _max), CV_8UC3);
	cv::Rect roi(0, 0, w, h);
	frame.copyTo(image(roi));
	// 计算宽高的缩放系数,模型的输入恒定为640×640,必须强制转换成浮点数
	x_factor = image.cols / static_cast<float>(640);	
	y_factor = image.rows / static_cast<float>(640);
	// 完成归一化:1.0 / 255.0;缩放:cv::Size(input_w, input_h);格式转换(BGR转RGB):true
	cv::Mat blob = cv::dnn::blobFromImage(image, 1.0 / 255.0, cv::Size(input_w, input_h), cv::Scalar(0, 0, 0), true, false);
	std::cout << blob.size[0] << "x" << blob.size[1] << "x" << blob.size[2] << "x" << blob.size[3] << std::endl;
	// ********************************************************

	// ******************* 6.推理准备 *******************
	// 占用内存大小,后续计算是总像素*数据类型大小
	size_t tpixels = 3 * input_h * input_w;
	std::array<int64_t, 4> input_shape_info{ 1, 3, input_h, input_w };
	// 准备数据输入
	auto allocator_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);
	Ort::Value input_tensor_ = Ort::Value::CreateTensor<float>(allocator_info, blob.ptr<float>(), tpixels, input_shape_info.data(), input_shape_info.size());
	// 模型输入输出所需数据(名称及其数量),模型只认这种类型的数组
	const std::array<const char*, 1> inputNames = { input_node_names[0].c_str() };
	const std::array<const char*, 4> outNames = { output_node_names[0].c_str(), output_node_names[1].c_str(), output_node_names[2].c_str(), output_node_names[3].c_str()};
	// **************************************************
	
	// ******************* 7.执行推理 *******************
	std::vector<Ort::Value> ort_outputs;
	try {
		ort_outputs = session_.Run(Ort::RunOptions{ nullptr }, inputNames.data(), &input_tensor_, 1, outNames.data(), outNames.size());
	}
	catch (std::exception e) {
		std::cout << e.what() << std::endl;
	}
	// **************************************************

	// ******************* 8.后处理推理结果 *******************
	// 1x25200x6 获取(第一个)输出数据并包装成一个cv::Mat对象,为了方便后处理
	const float* pdata = ort_outputs[0].GetTensorMutableData<float>();
	cv::Mat det_output(nbs[0], ncs[0], CV_32F, (float*)pdata);
	std::vector<cv::Rect> boxes;		// 目标框的坐标位置
	std::vector<float> confidences;		// 目标框的置信度
	std::vector<int> classIds;			// 目标框的类别得分
	// 剔除置信度较低的目标框,不作处理
	for (int i = 0; i < det_output.rows; i++) {
		float confidence = det_output.at<float>(i, 4);
		if (confidence < 0.45) {
			continue;
		}
		// 获得当前目标框的类别得分
		cv::Mat classes_scores = det_output.row(i).colRange(5, ncs[0]);
		// 这里与图像分类的方式一致
		cv::Point classIdPoint;		// 用于存储分类中的得分最大值索引(坐标)
		double score;				// 用于存储分类中的得分最大值
		minMaxLoc(classes_scores, 0, &score, 0, &classIdPoint);
		// 处理分类得分较高的目标框
		if (score > 0.25)
		{	
			// 计算在原始图像上,目标框的左上角坐标和宽高
			// 在输入图像上目标框的中心点坐标和宽高
			float cx = det_output.at<float>(i, 0);	
			float cy = det_output.at<float>(i, 1);
			float ow = det_output.at<float>(i, 2);
			float oh = det_output.at<float>(i, 3);
			//原始图像上目标框的左上角坐标
			int x = static_cast<int>((cx - 0.5 * ow) * x_factor);	
			int y = static_cast<int>((cy - 0.5 * oh) * y_factor);
			//原始图像上目标框的宽高
			int width = static_cast<int>(ow * x_factor);
			int height = static_cast<int>(oh * y_factor);
			// 记录目标框信息
			cv::Rect box;
			box.x = x;
			box.y = y;
			box.width = width;
			box.height = height;
			boxes.push_back(box);
			classIds.push_back(classIdPoint.x);
			confidences.push_back(score);
		}
	}
	// NMS:非极大值抑制(Non-Maximum Suppression),去除同一个物体的重复多余的目标框
	std::vector<int> indexes;	// 剔除多余目标框后,保留的目标框的序号
	cv::dnn::NMSBoxes(boxes, confidences, 0.25, 0.45, indexes);

	// 遍历筛选出的目标框
	for (size_t i = 0; i < indexes.size(); i++) {
		int idx = indexes[i];		// 获取当前目标框序号
		int cid = classIds[idx];	// 获取目标框分类得分
		// 输入/输出图像:frame;目标位置信息:boxes[idx];目标框颜色: cv::Scalar(0, 0, 255);
		// 边框线的厚度:4;线条类型:8;坐标点小数位数精度:0(通常为0)
		cv::rectangle(frame, boxes[idx], cv::Scalar(0, 0, 255), 4, 8, 0);	// 在原始图片上框选目标区域
		// 输入/输出图像:frame;绘制文本内容:labels[cid].c_str();文本起始位置(左下角):boxes[idx].tl();
		// 字体类型:cv::FONT_HERSHEY_PLAIN;字体大小缩放比例:2.5;文本颜色:cv::Scalar(255, 0, 0);文本线条的厚度:3;线条类型:8
		putText(frame, labels[cid].c_str(), boxes[idx].tl(), cv::FONT_HERSHEY_PLAIN, 2.5, cv::Scalar(255, 0, 0), 3, 8);	// 目标区域的类别
	}
	// ********************************************************
	
	// 在测试图像上加上预测的目标位置和类别
	cv::imshow("输入图像", frame);
	cv::waitKey(0);

	// ******************* 9.释放资源*******************
	session_options.release();
	session_.release();
	// *************************************************
	return 0;
}

图片正确识别人脸：

总结

尽可能简单、详细的讲解了C++下OnnxRuntime环境部署YOLOV3模型的过程。


http://www.kler.cn/a/599275.html

相关文章：

  • 模版的特化引发的权限扩大的解决方法
  • 基于51单片机的双机通信温度检测报警系统的仿真设计
  • 腾讯云大模型知识引擎×DeepSeek | 企业应用快速接入手册
  • LVS-DR模式配置脚本
  • 5.4 位运算专题：LeetCode 137. 只出现一次的数字 II
  • 模糊推理规则生成方法详解
  • CentOS8 安装 Docker-CE
  • FPGA中串行执行方式之流水线（Pipeline）
  • Spring MVC配置详解：从历史到实战
  • Node.js系列（6）--安全实践指南
  • 基于PySide6与pycatia的CATIA绘图文本批量处理工具开发实践
  • 永久禁用 firewalld: systemctl disable firewalld
  • C++类与对象的第二个简单的实战练习-3.24笔记
  • MobaXterm配置ssh端口转发autodl服务器网页页面
  • UNIX网络编程笔记：TCP、UDP、SCTP编程的区别
  • 机器视觉工程师如何看机器视觉展会，有些机器视觉兄弟参加机器视觉展会，真的是参加了？重在参与？
  • 【机器学习/大模型/八股文 面经 （一）】
  • 如何扩展 Linux 中 ext4 文件系统的大小
  • 补Java基础之重生（13）类与对象（补充版）+面向对象综合案例
  • 智算中心系统化建设与运营框架