devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

YOLOv8部署到C++上（综合版笔记)_yolov8 c++

作者：空白诗007 | 2024-08-14 21:25:34

赞

踩

yolov8 c++

这段时间由于项目的需要，需要将yolov8部署到C++上以及跟相应的算法结合，花了我不少时间。

现阶段有考虑过使用onnx转Tensort，但是无法输出分类的结果，故放弃，有目标检测的小伙伴可以试试，接下来使用onnxruntime来试试。

win10下 yolov8 tensorrt模型部署_tensort8.4.2.4-CSDN博客

下面我将尝试用opencv CPP推理我们得到onnx文件

参考文章

VS2019配置onnxruntime推理环境 - 知乎 (zhihu.com)

yolov8 opencv模型部署（C++版）_yolov8 c++-CSDN博客

Opencv模型部署 onnxruntime调用yolov8（C++）

方法一

这个案例可以参考

C++ OpenCV onnxruntime调用yolov8 onnx模型_哔哩哔哩_bilibili

相应源代码

百度网盘 请输入提取码

OnnxRuntime调用onnx优点

ultralytics/examples/YOLOv8-ONNXRuntime-CPP at main · ultralytics/ultralytics (github.com)

下载我们yolov8相应源代码

创建新项目

创建我们的新项目并命名，导入相应的文件

右键我们的Demo3，并选择"在文件资源管理器中打开文件夹"

复制到相应位置

右键选择包括在项目中

添加一下我们对应的引用

这里我们要选择配置我们的Release x64,下面的我是忘记改了，后面想起来了，所以下面的步骤不变。

右键我们的项目，设置我们的属性，设置语言标准为C++ 17

修改我们的安全检查，如果不修改的话，后期可能还会有错误，不修改的话我们自己也可以使用自定义宏进行处理

对应的语言模式改为默认值，如果不改的话string型改为char型的话是需要手动进行的

引入头文件

opencv(图像处理，就是我们读图然后处理图像的时候使用)

Releases - OpenCV

CUDA（使用GPU加速的时候需要使用）11.8版本

CUDA安装教程（超详细）-CSDN博客

这里我先使用的是自己先前下载的11.7版本的试试

onnxruntime 1.15.1版本

Releases · microsoft/onnxruntime (github.com)

这里我先使用自己先前的版本试试

onnxruntime-win-x64-gpu-1.17.1(之前的版本)

Releases · microsoft/onnxruntime (github.com)

添加lib引用

我们可以在我们相关的文件里找到相应的dll文件

放入我们的文件夹里

从这里C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.7\include

导入我们相应的文件

我们的onnxruntime跟opencv也是这样操作

添加我们的lib文件

将我们的lib文件跟include文件复制粘贴到我们的项目下

调整我们的项目路径

添加我们三个对应头文件的目录

添加我们对应的引用

./include/opencv;./include/CUDA:./include/onnxruntime;

这三个头文件我们就添加好了

我们右键生成我们的项目，发现生成失败了，再继续按照上面的视频操作，肯定哪里有问题，有成功的小伙伴

然后我们回来看到我们的主函数，这里他是要找到我们对应的标识文件，这里我们可以给他注释

这里我们使用官方的案例来做

将我们相应的文件跟图片移入

调整我们的模型文件路径

再次重新生成一下

这里我们生成失败了，可以再使用up主给的文件再试试。（步骤还是按照上面的来）

百度网盘 请输入提取码

方法二（推荐）

VS2019配置onnxruntime推理环境 - 知乎 (zhihu.com)

主要参考的文章

由于我之前部署过tensorrt的成功了

所以我猜应该是配置属性表这边出了问题

解决：error C1083: 无法打开包括文件: “opencv2/opencv.hpp”: No such file or directory-CSDN博客

严重性 代码 说明 项目 文件 行 禁止显示状态 错误 LNK2001 无法解析的外部符号 “void __cdecl cv::imshow(class std::basic_string＜char,_严重性代码说明项目文件行禁止显示状态 错误lnk2001无法解析的外部符号-CSDN博客

这个是一个问题的解决方法，但是我后面把Opencv里的Lib文件换成了opencv.4.9.0的版本就没有报错了

后来发现确实是这

win10下 yolov8 tensorrt模型部署_tensort8.4.2.4-CSDN博客

VS配置属性表，保存Opencv配置信息_vs属性表-CSDN博客

可以参考这两篇文章

我们找到自己参考上面两篇文章以及配置好的属性表去重新配置

目前我成功生成的onnxruntime版本是onnxruntime-win-x64-gpu-1.17.1

opencv版本是4.9.0

期间出现了找不到opencv_490world.dll文件，我们需要将相应的两个dll文件复制粘贴至相应的文件夹下

又出现了未经处理的异常的问题

解决方法：

Opencv 未经处理的异常 Microsoft C++ 异常: cv::Exception，位于内存位置_: microsoft c++ 异常: cv::exception,位于内存位置 0x0000002-CSDN博客

这是我配置好的属性管理器

小结

最后总算成功了，但是我的检测模型的框都在左上角不知道怎么回事，知道的小伙伴可以帮我解答一下吗？

代码

main.cpp
  1. #include <iostream>
  2. #include <iomanip>
  3. #include "inference.h" // 导入推理相关的头文件
  4. #include <filesystem>
  5. #include <fstream>
  6. #include <random>
  7. #include <regex>
  8. // 对图像进行检测
  9. void Detector(YOLO_V8*& p) {
  10.     // 获取当前工作目录
  11.     std::filesystem::path current_path = std::filesystem::current_path();
  12.     // 图片所在目录为当前工作目录下的 "images" 文件夹
  13.     std::filesystem::path imgs_path = R"(D:\C++ project\Demo4\Demo4\images\data)";
  14.  
  15.     // 遍历图片目录中的所有文件
  16.     for (auto& i : std::filesystem::directory_iterator(imgs_path))
  17.     {
  18.         // 检查文件是否是图片文件（.jpg, .png, .jpeg）
  19.         if (i.path().extension() == ".jpg" || i.path().extension() == ".png" || i.path().extension() == ".jpeg")
  20.         {
  21.             // 获取图片路径并读取图像
  22.             std::string img_path = i.path().string();
  23.             cv::Mat img = cv::imread(img_path);
  24.             std::vector<DL_RESULT> res;
  25.             // 运行推理会话以检测对象
  26.             p->RunSession(img, res);
  27.  
  28.             // 对每个检测到的对象进行处理
  29.             for (auto& re : res)
  30.             {
  31.                 // 生成随机颜色
  32.                 cv::RNG rng(cv::getTickCount());
  33.                 cv::Scalar color(rng.uniform(0, 256), rng.uniform(0, 256), rng.uniform(0, 256));
  34.  
  35.                 // 在图像上绘制检测框
  36.                 cv::rectangle(img, re.box, color, 3);
  37.  
  38.                 // 格式化置信度并生成标签
  39.                 float confidence = floor(100 * re.confidence) / 100;
  40.                 std::cout << std::fixed << std::setprecision(2);
  41.                 std::string label = p->classes[re.classId] + " " +
  42.                     std::to_string(confidence).substr(0, std::to_string(confidence).size() - 4);
  43.  
  44.                 // 在图像上绘制标签
  45.                 cv::rectangle(
  46.                     img,
  47.                     cv::Point(re.box.x, re.box.y - 25),
  48.                     cv::Point(re.box.x + label.length() * 15, re.box.y),
  49.                     color,
  50.                     cv::FILLED
  51.                 );
  52.  
  53.                 cv::putText(
  54.                     img,
  55.                     label,
  56.                     cv::Point(re.box.x, re.box.y - 5),
  57.                     cv::FONT_HERSHEY_SIMPLEX,
  58.                     0.75,
  59.                     cv::Scalar(0, 0, 0),
  60.                     2
  61.                 );
  62.             }
  63.             // 显示结果并等待用户按下任意键
  64.             std::cout << "Press any key to exit" << std::endl;
  65.             cv::imshow("Result of Detection", img);
  66.             cv::waitKey(0);
  67.             cv::destroyAllWindows();
  68.         }
  69.     }
  70. }
  71.  
  72. // 对图像进行分类
  73. void Classifier(YOLO_V8*& p)
  74. {
  75.     // 获取当前工作目录
  76.     std::filesystem::path current_path = std::filesystem::current_path();
  77.     // 设置要访问的图片目录路径
  78.     std::filesystem::path imgs_path = R"(D:\C++ project\Demo4\Demo4\images\person)";
  79.     // 设置类别名称
  80.     p->classes = { "person", "normal" };
  81.  
  82.     // 生成随机数引擎
  83.     std::random_device rd;
  84.     std::mt19937 gen(rd());
  85.     std::uniform_int_distribution<int> dis(0, 255);
  86.  
  87.     // 遍历图片目录中的所有文件
  88.     for (auto& i : std::filesystem::directory_iterator(imgs_path))
  89.     {
  90.         // 检查文件是否是图片文件（.jpg, .png）
  91.         if (i.path().extension() == ".jpg" || i.path().extension() == ".png")
  92.         {
  93.             // 获取图片路径并读取图像
  94.             std::string img_path = i.path().string();
  95.             cv::Mat img = cv::imread(img_path);
  96.             std::vector<DL_RESULT> res;
  97.             // 运行推理会话以进行图像分类
  98.             char* ret = p->RunSession(img, res);
  99.  
  100.             // 绘制分类结果
  101.             float positionY = 50;
  102.             for (int i = 0; i < res.size(); i++)
  103.             {
  104.                 // 生成随机颜色
  105.                 int r = dis(gen);
  106.                 int g = dis(gen);
  107.                 int b = dis(gen);
  108.  
  109.                 // 获取类别名称和置信度
  110.                 std::string label;
  111.                 if (res[i].classId >= 0 && res[i].classId < p->classes.size()) {
  112.                     label = p->classes[res[i].classId] + ": " + std::to_string(res[i].confidence);
  113.                 }
  114.                 else {
  115.                     label = "Unknown";
  116.                 }
  117.  
  118.                 // 在图像上绘制分类标签和置信度
  119.                 cv::putText(img, label, cv::Point(10, positionY), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(b, g, r), 2);
  120.                 positionY += 50;
  121.             }
  122.  
  123.             // 在窗口中显示分类结果并等待用户按下任意键
  124.             cv::imshow("TEST_CLS", img);
  125.             cv::waitKey(0);
  126.             cv::destroyAllWindows();
  127.             // 可选：保存分类结果图像
  128.             //cv::imwrite("E:\\output\\" + std::to_string(k) + ".png", img);
  129.         }
  130.     }
  131. }
  132.  
  133.  
  134.  
  135. // 读取数据集的标签
  136. //int ReadCoCoYaml(YOLO_V8*& p) {
  137. //    // 打开YAML文件
  138. //    std::ifstream file("D:\\project\\yolov8_main\\ultralytics\\coco.yaml");
  139. //    if (!file.is_open())
  140. //    {
  141. //        // 如果打开文件失败，则输出错误信息
  142. //        std::cerr << "Failed to open file" << std::endl;
  143. //        return 1;
  144. //    }
  145. //
  146. //    // 逐行读取文件内容
  147. //    std::string line;
  148. //    std::vector<std::string> lines;
  149. //    while (std::getline(file, line))
  150. //    {
  151. //        lines.push_back(line);
  152. //    }
  153. //
  154. //    // 查找类别名称部分的起始和结束位置
  155. //    std::size_t start = 0;
  156. //    std::size_t end = 0;
  157. //    for (std::size_t i = 0; i < lines.size(); i++)
  158. //    {
  159. //        if (lines[i].find("names:") != std::string::npos)
  160. //        {
  161. //            start = i + 1;
  162. //        }
  163. //        else if (start > 0 && lines[i].empty())
  164. //        {
  165. //            end = i;
  166. //            break;
  167. //        }
  168. //    }
  169. //
  170. //    // 提取类别名称
  171. //    std::vector<std::string> names;
  172. //    for (std::size_t i = start; i < end; i++)
  173. //    {
  174. //        // 解析类别名称键值对
  175. //        std::size_t colon_pos = lines[i].find(':');
  176. //        if (colon_pos != std::string::npos)
  177. //        {
  178. //            std::string name = lines[i].substr(colon_pos + 1);
  179. //            // 去除字符串两端的空格
  180. //            name = std::regex_replace(name, std::regex("^ +| +$|( ) +"), "$1");
  181. //            names.push_back(name);
  182. //        }
  183. //    }
  184. //
  185. //    // 将类别名称赋值给YOLO_V8对象
  186. //    p->classes = names;
  187. //    return 0;
  188. //}
  189.  
  190. // 进行检测测试
  191. void DetectTest()
  192. {
  193. #define USE_CUDA
  194.     // 创建YOLO_V8对象指针
  195.     YOLO_V8* yoloDetector = new YOLO_V8;
  196.  
  197.     // 初始化推理参数
  198.     DL_INIT_PARAM params;
  199.     params.rectConfidenceThreshold = 0.1;
  200.     params.iouThreshold = 0.5;
  201.     params.modelPath = "./models/yolov8n.onnx";
  202.     params.imgSize = { 640, 640 };
  203.  
  204.     // 设置检测类别为"person"
  205.     yoloDetector->classes = { "person" };
  206.  
  207. #ifdef USE_CUDA
  208.     // 如果使用CUDA加速
  209.     params.cudaEnable = true;
  210.  
  211.     // 使用GPU FP32推理
  212.     params.modelType = YOLO_DETECT_V8;
  213.  
  214.     // 使用GPU FP16推理（注意：需要修改FP16的ONNX模型）
  215.     //params.modelType = YOLO_DETECT_V8_HALF;
  216.  
  217. #else
  218.     // 如果不使用CUDA，即使用CPU推理
  219.     params.modelType = YOLO_DETECT_V8;
  220.     params.cudaEnable = false;
  221.  
  222. #endif
  223.  
  224.     // 创建推理会话
  225.     yoloDetector->CreateSession(params);
  226.  
  227.     // 执行检测函数
  228.     Detector(yoloDetector);
  229. }
  230.  
  231. // 进行分类测试
  232. void ClsTest()
  233. {
  234.     // 创建YOLO_V8对象指针
  235.     YOLO_V8* yoloDetector = new YOLO_V8;
  236.  
  237.     // 设置分类模型路径
  238.     std::string model_path = "./models/yolov8s-cls.onnx";
  239.  
  240.     // 读取COCO数据集标签
  241.     /*ReadMuckYaml(yoloDetector);*/
  242.  
  243.     // 初始化推理参数
  244.     DL_INIT_PARAM params{ model_path, YOLO_CLS, {224, 224} };
  245.  
  246.     // 创建推理会话
  247.     yoloDetector->CreateSession(params);
  248.  
  249.     // 执行分类函数
  250.     Classifier(yoloDetector);
  251. }
  252.  
  253. // 主函数
  254. int main()
  255. {
  256.     // 执行检测测试
  257.     ClsTest();
  258.  
  259.     // 执行分类测试
  260.     //ClsTest();
  261. }

这里我把读取数据集标签注释掉了，因为我觉得直接输入分类更简单，就不用编译了

inference.h
  1. #pragma once
  2.  
  3. #define    RET_OK nullptr
  4.  
  5. #ifdef _WIN32
  6. #include <Windows.h>
  7. #include <direct.h>
  8. #include <io.h>
  9. #endif
  10.  
  11. #include <string>
  12. #include <vector>
  13. #include <cstdio>
  14. #include <opencv2/opencv.hpp>
  15. #include "onnxruntime_cxx_api.h"
  16.  
  17. #ifdef USE_CUDA
  18. #include <cuda_fp16.h>
  19. #endif
  20.  
  21.  
  22. enum MODEL_TYPE
  23. {
  24.     //FLOAT32 MODEL
  25.     YOLO_DETECT_V8 = 1,
  26.     YOLO_POSE = 2,
  27.     YOLO_CLS = 3,
  28.  
  29.     //FLOAT16 MODEL
  30.     YOLO_DETECT_V8_HALF = 4,
  31.     YOLO_POSE_V8_HALF = 5,
  32. };
  33.  
  34.  
  35. typedef struct _DL_INIT_PARAM
  36. {
  37.     std::string modelPath;
  38.     MODEL_TYPE modelType = YOLO_DETECT_V8;
  39.     std::vector<int> imgSize = { 640, 640 };
  40.     float rectConfidenceThreshold = 0.6;
  41.     float iouThreshold = 0.5;
  42.     int	keyPointsNum = 2;//Note:kpt number for pose
  43.     bool cudaEnable = false;
  44.     int logSeverityLevel = 3;
  45.     int intraOpNumThreads = 1;
  46. } DL_INIT_PARAM;
  47.  
  48.  
  49. typedef struct _DL_RESULT
  50. {
  51.     int classId;
  52.     float confidence;
  53.     cv::Rect box;
  54.     std::vector<cv::Point2f> keyPoints;
  55. } DL_RESULT;
  56.  
  57.  
  58. class YOLO_V8
  59. {
  60. public:
  61.     YOLO_V8();
  62.  
  63.     ~YOLO_V8();
  64.  
  65. public:
  66.     char* CreateSession(DL_INIT_PARAM& iParams);
  67.  
  68.     char* RunSession(cv::Mat& iImg, std::vector<DL_RESULT>& oResult);
  69.  
  70.     char* WarmUpSession();
  71.  
  72.     template<typename N>
  73.     char* TensorProcess(clock_t& starttime_1, cv::Mat& iImg, N& blob, std::vector<int64_t>& inputNodeDims,
  74.         std::vector<DL_RESULT>& oResult);
  75.  
  76.     char* PreProcess(cv::Mat& iImg, std::vector<int> iImgSize, cv::Mat& oImg);
  77.  
  78.     std::vector<std::string> classes{};
  79.  
  80. private:
  81.     Ort::Env env;
  82.     Ort::Session* session;
  83.     bool cudaEnable;
  84.     Ort::RunOptions options;
  85.     std::vector<const char*> inputNodeNames;
  86.     std::vector<const char*> outputNodeNames;
  87.  
  88.     MODEL_TYPE modelType;
  89.     std::vector<int> imgSize;
  90.     float rectConfidenceThreshold;
  91.     float iouThreshold;
  92.     float resizeScales;//letterbox scale
  93. };
inference.cpp
  1. #include "inference.h"
  2. #include <regex>
  3.  
  4. #define benchmark
  5. #define min(a,b)            (((a) < (b)) ? (a) : (b))
  6. YOLO_V8::YOLO_V8() {
  7.  
  8. }
  9.  
  10.  
  11. YOLO_V8::~YOLO_V8() {
  12.     delete session;
  13. }
  14.  
  15. #ifdef USE_CUDA
  16. namespace Ort
  17. {
  18.     template<>
  19.     struct TypeToTensorType<half> { static constexpr ONNXTensorElementDataType type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT16; };
  20. }
  21. #endif
  22.  
  23.  
  24. template<typename T>
  25. char* BlobFromImage(cv::Mat& iImg, T& iBlob) {
  26.     int channels = iImg.channels();
  27.     int imgHeight = iImg.rows;
  28.     int imgWidth = iImg.cols;
  29.  
  30.     for (int c = 0; c < channels; c++)
  31.     {
  32.         for (int h = 0; h < imgHeight; h++)
  33.         {
  34.             for (int w = 0; w < imgWidth; w++)
  35.             {
  36.                 iBlob[c * imgWidth * imgHeight + h * imgWidth + w] = typename std::remove_pointer<T>::type(
  37.                     (iImg.at<cv::Vec3b>(h, w)[c]) / 255.0f);
  38.             }
  39.         }
  40.     }
  41.     return RET_OK;
  42. }
  43.  
  44.  
  45. char* YOLO_V8::PreProcess(cv::Mat& iImg, std::vector<int> iImgSize, cv::Mat& oImg)
  46. {
  47.     if (iImg.channels() == 3)
  48.     {
  49.         oImg = iImg.clone();
  50.         cv::cvtColor(oImg, oImg, cv::COLOR_BGR2RGB);
  51.     }
  52.     else
  53.     {
  54.         cv::cvtColor(iImg, oImg, cv::COLOR_GRAY2RGB);
  55.     }
  56.  
  57.     switch (modelType)
  58.     {
  59.     case YOLO_DETECT_V8:
  60.     case YOLO_POSE:
  61.     case YOLO_DETECT_V8_HALF:
  62.     case YOLO_POSE_V8_HALF://LetterBox
  63.     {
  64.         if (iImg.cols >= iImg.rows)
  65.         {
  66.             resizeScales = iImg.cols / (float)iImgSize.at(0);
  67.             cv::resize(oImg, oImg, cv::Size(iImgSize.at(0), int(iImg.rows / resizeScales)));
  68.         }
  69.         else
  70.         {
  71.             resizeScales = iImg.rows / (float)iImgSize.at(0);
  72.             cv::resize(oImg, oImg, cv::Size(int(iImg.cols / resizeScales), iImgSize.at(1)));
  73.         }
  74.         cv::Mat tempImg = cv::Mat::zeros(iImgSize.at(0), iImgSize.at(1), CV_8UC3);
  75.         oImg.copyTo(tempImg(cv::Rect(0, 0, oImg.cols, oImg.rows)));
  76.         oImg = tempImg;
  77.         break;
  78.     }
  79.     case YOLO_CLS://CenterCrop
  80.     {
  81.         int h = iImg.rows;
  82.         int w = iImg.cols;
  83.         int m = min(h, w);
  84.         int top = (h - m) / 2;
  85.         int left = (w - m) / 2;
  86.         cv::resize(oImg(cv::Rect(left, top, m, m)), oImg, cv::Size(iImgSize.at(0), iImgSize.at(1)));
  87.         break;
  88.     }
  89.     }
  90.     return RET_OK;
  91. }
  92.  
  93.  
  94. char* YOLO_V8::CreateSession(DL_INIT_PARAM& iParams) {
  95.     char* Ret = RET_OK;
  96.     std::regex pattern("[\u4e00-\u9fa5]");
  97.     bool result = std::regex_search(iParams.modelPath, pattern);
  98.     if (result)
  99.     {
  100.         Ret = "[YOLO_V8]:Your model path is error.Change your model path without chinese characters.";
  101.         std::cout << Ret << std::endl;
  102.         return Ret;
  103.     }
  104.     try
  105.     {
  106.         rectConfidenceThreshold = iParams.rectConfidenceThreshold;
  107.         iouThreshold = iParams.iouThreshold;
  108.         imgSize = iParams.imgSize;
  109.         modelType = iParams.modelType;
  110.         env = Ort::Env(ORT_LOGGING_LEVEL_WARNING, "Yolo");
  111.         Ort::SessionOptions sessionOption;
  112.         if (iParams.cudaEnable)
  113.         {
  114.             cudaEnable = iParams.cudaEnable;
  115.             OrtCUDAProviderOptions cudaOption;
  116.             cudaOption.device_id = 0;
  117.             sessionOption.AppendExecutionProvider_CUDA(cudaOption);
  118.         }
  119.         sessionOption.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);
  120.         sessionOption.SetIntraOpNumThreads(iParams.intraOpNumThreads);
  121.         sessionOption.SetLogSeverityLevel(iParams.logSeverityLevel);
  122.  
  123. #ifdef _WIN32
  124.         int ModelPathSize = MultiByteToWideChar(CP_UTF8, 0, iParams.modelPath.c_str(), static_cast<int>(iParams.modelPath.length()), nullptr, 0);
  125.         wchar_t* wide_cstr = new wchar_t[ModelPathSize + 1];
  126.         MultiByteToWideChar(CP_UTF8, 0, iParams.modelPath.c_str(), static_cast<int>(iParams.modelPath.length()), wide_cstr, ModelPathSize);
  127.         wide_cstr[ModelPathSize] = L'\0';
  128.         const wchar_t* modelPath = wide_cstr;
  129. #else
  130.         const char* modelPath = iParams.modelPath.c_str();
  131. #endif // _WIN32
  132.  
  133.         session = new Ort::Session(env, modelPath, sessionOption);
  134.         Ort::AllocatorWithDefaultOptions allocator;
  135.         size_t inputNodesNum = session->GetInputCount();
  136.         for (size_t i = 0; i < inputNodesNum; i++)
  137.         {
  138.             Ort::AllocatedStringPtr input_node_name = session->GetInputNameAllocated(i, allocator);
  139.             char* temp_buf = new char[50];
  140.             strcpy(temp_buf, input_node_name.get());
  141.             inputNodeNames.push_back(temp_buf);
  142.         }
  143.         size_t OutputNodesNum = session->GetOutputCount();
  144.         for (size_t i = 0; i < OutputNodesNum; i++)
  145.         {
  146.             Ort::AllocatedStringPtr output_node_name = session->GetOutputNameAllocated(i, allocator);
  147.             char* temp_buf = new char[10];
  148.             strcpy(temp_buf, output_node_name.get());
  149.             outputNodeNames.push_back(temp_buf);
  150.         }
  151.         options = Ort::RunOptions{ nullptr };
  152.         WarmUpSession();
  153.         return RET_OK;
  154.     }
  155.     catch (const std::exception& e)
  156.     {
  157.         const char* str1 = "[YOLO_V8]:";
  158.         const char* str2 = e.what();
  159.         std::string result = std::string(str1) + std::string(str2);
  160.         char* merged = new char[result.length() + 1];
  161.         std::strcpy(merged, result.c_str());
  162.         std::cout << merged << std::endl;
  163.         delete[] merged;
  164.         return "[YOLO_V8]:Create session failed.";
  165.     }
  166.  
  167. }
  168.  
  169.  
  170. char* YOLO_V8::RunSession(cv::Mat& iImg, std::vector<DL_RESULT>& oResult) {
  171. #ifdef benchmark
  172.     clock_t starttime_1 = clock();
  173. #endif // benchmark
  174.  
  175.     char* Ret = RET_OK;
  176.     cv::Mat processedImg;
  177.     PreProcess(iImg, imgSize, processedImg);
  178.     if (modelType < 4)
  179.     {
  180.         float* blob = new float[processedImg.total() * 3];
  181.         BlobFromImage(processedImg, blob);
  182.         std::vector<int64_t> inputNodeDims = { 1, 3, imgSize.at(0), imgSize.at(1) };
  183.         TensorProcess(starttime_1, iImg, blob, inputNodeDims, oResult);
  184.     }
  185.     else
  186.     {
  187. #ifdef USE_CUDA
  188.         half* blob = new half[processedImg.total() * 3];
  189.         BlobFromImage(processedImg, blob);
  190.         std::vector<int64_t> inputNodeDims = { 1,3,imgSize.at(0),imgSize.at(1) };
  191.         TensorProcess(starttime_1, iImg, blob, inputNodeDims, oResult);
  192. #endif
  193.     }
  194.  
  195.     return Ret;
  196. }
  197.  
  198.  
  199. template<typename N>
  200. char* YOLO_V8::TensorProcess(clock_t& starttime_1, cv::Mat& iImg, N& blob, std::vector<int64_t>& inputNodeDims,
  201.     std::vector<DL_RESULT>& oResult) {
  202.     Ort::Value inputTensor = Ort::Value::CreateTensor<typename std::remove_pointer<N>::type>(
  203.         Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU), blob, 3 * imgSize.at(0) * imgSize.at(1),
  204.         inputNodeDims.data(), inputNodeDims.size());
  205. #ifdef benchmark
  206.     clock_t starttime_2 = clock();
  207. #endif // benchmark
  208.     auto outputTensor = session->Run(options, inputNodeNames.data(), &inputTensor, 1, outputNodeNames.data(),
  209.         outputNodeNames.size());
  210. #ifdef benchmark
  211.     clock_t starttime_3 = clock();
  212. #endif // benchmark
  213.  
  214.     Ort::TypeInfo typeInfo = outputTensor.front().GetTypeInfo();
  215.     auto tensor_info = typeInfo.GetTensorTypeAndShapeInfo();
  216.     std::vector<int64_t> outputNodeDims = tensor_info.GetShape();
  217.     auto output = outputTensor.front().GetTensorMutableData<typename std::remove_pointer<N>::type>();
  218.     delete[] blob;
  219.     switch (modelType)
  220.     {
  221.     case YOLO_DETECT_V8:
  222.     case YOLO_DETECT_V8_HALF:
  223.     {
  224.         int strideNum = outputNodeDims[1];//8400
  225.         int signalResultNum = outputNodeDims[2];//84
  226.         std::vector<int> class_ids;
  227.         std::vector<float> confidences;
  228.         std::vector<cv::Rect> boxes;
  229.         cv::Mat rawData;
  230.         if (modelType == YOLO_DETECT_V8)
  231.         {
  232.             // FP32
  233.             rawData = cv::Mat(strideNum, signalResultNum, CV_32F, output);
  234.         }
  235.         else
  236.         {
  237.             // FP16
  238.             rawData = cv::Mat(strideNum, signalResultNum, CV_16F, output);
  239.             rawData.convertTo(rawData, CV_32F);
  240.         }
  241.         //Note:
  242.         //ultralytics add transpose operator to the output of yolov8 model.which make yolov8/v5/v7 has same shape
  243.         //https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt
  244.         //rowData = rowData.t();
  245.  
  246.         float* data = (float*)rawData.data;
  247.  
  248.         for (int i = 0; i < strideNum; ++i)
  249.         {
  250.             float* classesScores = data + 4;
  251.             cv::Mat scores(1, this->classes.size(), CV_32FC1, classesScores);
  252.             cv::Point class_id;
  253.             double maxClassScore;
  254.             cv::minMaxLoc(scores, 0, &maxClassScore, 0, &class_id);
  255.             if (maxClassScore > rectConfidenceThreshold)
  256.             {
  257.                 confidences.push_back(maxClassScore);
  258.                 class_ids.push_back(class_id.x);
  259.                 float x = data[0];
  260.                 float y = data[1];
  261.                 float w = data[2];
  262.                 float h = data[3];
  263.  
  264.                 int left = int((x - 0.5 * w) * resizeScales);
  265.                 int top = int((y - 0.5 * h) * resizeScales);
  266.  
  267.                 int width = int(w * resizeScales);
  268.                 int height = int(h * resizeScales);
  269.  
  270.                 boxes.push_back(cv::Rect(left, top, width, height));
  271.             }
  272.             data += signalResultNum;
  273.         }
  274.         std::vector<int> nmsResult;
  275.         cv::dnn::NMSBoxes(boxes, confidences, rectConfidenceThreshold, iouThreshold, nmsResult);
  276.         for (int i = 0; i < nmsResult.size(); ++i)
  277.         {
  278.             int idx = nmsResult[i];
  279.             DL_RESULT result;
  280.             result.classId = class_ids[idx];
  281.             result.confidence = confidences[idx];
  282.             result.box = boxes[idx];
  283.             oResult.push_back(result);
  284.         }
  285.  
  286. #ifdef benchmark
  287.         clock_t starttime_4 = clock();
  288.         double pre_process_time = (double)(starttime_2 - starttime_1) / CLOCKS_PER_SEC * 1000;
  289.         double process_time = (double)(starttime_3 - starttime_2) / CLOCKS_PER_SEC * 1000;
  290.         double post_process_time = (double)(starttime_4 - starttime_3) / CLOCKS_PER_SEC * 1000;
  291.         if (cudaEnable)
  292.         {
  293.             std::cout << "[YOLO_V8(CUDA)]: " << pre_process_time << "ms pre-process, " << process_time << "ms inference, " << post_process_time << "ms post-process." << std::endl;
  294.         }
  295.         else
  296.         {
  297.             std::cout << "[YOLO_V8(CPU)]: " << pre_process_time << "ms pre-process, " << process_time << "ms inference, " << post_process_time << "ms post-process." << std::endl;
  298.         }
  299. #endif // benchmark
  300.  
  301.         break;
  302.     }
  303.     case YOLO_CLS:
  304.     {
  305.         DL_RESULT result;
  306.         for (int i = 0; i < this->classes.size(); i++)
  307.         {
  308.             result.classId = i;
  309.             result.confidence = output[i];
  310.             oResult.push_back(result);
  311.         }
  312.         break;
  313.     }
  314.     default:
  315.         std::cout << "[YOLO_V8]: " << "Not support model type." << std::endl;
  316.     }
  317.     return RET_OK;
  318.  
  319. }
  320.  
  321.  
  322. char* YOLO_V8::WarmUpSession() {
  323.     clock_t starttime_1 = clock();
  324.     cv::Mat iImg = cv::Mat(cv::Size(imgSize.at(0), imgSize.at(1)), CV_8UC3);
  325.     cv::Mat processedImg;
  326.     PreProcess(iImg, imgSize, processedImg);
  327.     if (modelType < 4)
  328.     {
  329.         float* blob = new float[iImg.total() * 3];
  330.         BlobFromImage(processedImg, blob);
  331.         std::vector<int64_t> YOLO_input_node_dims = { 1, 3, imgSize.at(0), imgSize.at(1) };
  332.         Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
  333.             Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU), blob, 3 * imgSize.at(0) * imgSize.at(1),
  334.             YOLO_input_node_dims.data(), YOLO_input_node_dims.size());
  335.         auto output_tensors = session->Run(options, inputNodeNames.data(), &input_tensor, 1, outputNodeNames.data(),
  336.             outputNodeNames.size());
  337.         delete[] blob;
  338.         clock_t starttime_4 = clock();
  339.         double post_process_time = (double)(starttime_4 - starttime_1) / CLOCKS_PER_SEC * 1000;
  340.         if (cudaEnable)
  341.         {
  342.             std::cout << "[YOLO_V8(CUDA)]: " << "Cuda warm-up cost " << post_process_time << " ms. " << std::endl;
  343.         }
  344.     }
  345.     else
  346.     {
  347. #ifdef USE_CUDA
  348.         half* blob = new half[iImg.total() * 3];
  349.         BlobFromImage(processedImg, blob);
  350.         std::vector<int64_t> YOLO_input_node_dims = { 1,3,imgSize.at(0),imgSize.at(1) };
  351.         Ort::Value input_tensor = Ort::Value::CreateTensor<half>(Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU), blob, 3 * imgSize.at(0) * imgSize.at(1), YOLO_input_node_dims.data(), YOLO_input_node_dims.size());
  352.         auto output_tensors = session->Run(options, inputNodeNames.data(), &input_tensor, 1, outputNodeNames.data(), outputNodeNames.size());
  353.         delete[] blob;
  354.         clock_t starttime_4 = clock();
  355.         double post_process_time = (double)(starttime_4 - starttime_1) / CLOCKS_PER_SEC * 1000;
  356.         if (cudaEnable)
  357.         {
  358.             std::cout << "[YOLO_V8(CUDA)]: " << "Cuda warm-up cost " << post_process_time << " ms. " << std::endl;
  359.         }
  360. #endif
  361.     }
  362.     return RET_OK;
  363. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/980741
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号