yolov5-7.0模型DNN加载函数及参数详解(重要)

news/2024/10/7 3:42:09 标签: YOLO, dnn, 人工智能, c++

yolov5-7.0模型DNN加载函数及参数详解（重要）

  • 引言
  • yolov5（v7.0）
    • 1，yolov5.h(加载对应模型里面的相关参数要更改)
    • 2，main主程序
      • （1）加载网络
      • （2）检测推理（forward）
        • （2.1）制作黑背景正方形，用于blobFromImage的无损缩放
        • （2.2）blobFromImage改变图像格式为网络出入格式
        • （2.3）输入setInput图像并forward推理
        • （2.4）结果解析
          • （2.4.0）方法0直接Mat读取解析（主要用于理解输出结构）
          • （2.4.1）方法1指针法Mat.data解析（快但不易理解）
        • （2.5）绘制结果

引言

  使用opencv的dnn模块对应yolov5（v7.0）的导出的onnx模型进行推理解析，明确各个参数的对应含义及结果。理论上，有了onnx模型，有了该网络模型的输入输出各个参数含义，就可以使用任意的可以读取onnx模型的部署框架进行部署推理。

yolov5（v7.0）

Yolov5（v7.0）
部署：使用opencv4.5.5（opencv4.5.4以上可以读取网络），dnn模块部署

已经导出的cpu、opset=12、640大小图像、默认静态
在这里插入图片描述

如上，输入输出层在后面的DNN模块推理会用到

1，yolov5.h(加载对应模型里面的相关参数要更改)

需要修改的相关参数如下：要根据自己的模型来进行
在这里插入图片描述
在这里插入图片描述

#include <fstream>
#include <sstream>
#include <iostream>
#include <opencv2/dnn.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
using namespace cv;
using namespace dnn;
using namespace std;

class YOLO
{
public:
    struct Detection
    {
        int class_id;
        float confidence;
        Rect box;
    };
public:
    YOLO();
    ~YOLO();
    bool loadNet(string model_path, bool is_cuda);
    Mat formatYolov5(const Mat& source);
    void detect(Mat& image, vector<Detection>& output);
    void drawRect(Mat& image, vector<Detection>& output);
private:
    Net m_net;
    //修改为训练时自己模型Img大小
    float inputWidth = 640;
    float inputHeight = 640;
    //修改 dimensions = 类别数 + 5
    const int dimensions = 6;
    //修改 通过Netron可查看，图片大小320，rows为6300，图片大小640，rows为25200
    const int rows = 25200;

    float scoreThreshold = 0.2;
    float nmsThreshold = 0.4;
    float confThreshold = 0.4;
public:
    //修改为自己的类别数
    const vector<string> m_classNames = { "qrcode" };
    /*const std::vector<std::string> m_classNames = { "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
        "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
        "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
        "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
        "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
        "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
        "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone",
        "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear",
        "hair drier", "toothbrush" };*/

    const vector<Scalar> colors = { Scalar(255, 255, 0), Scalar(0, 255, 0), Scalar(0, 255, 255), Scalar(255, 0, 0) };
};

2，main主程序

int main(int argc, char** argv)
{
    Mat frame = imread("2.jpeg");
    YOLO yolov5;
    //加载模型
    yolov5.loadNet("qrcode.onnx", false);
    std::vector<YOLO::Detection> output;

    //进行检测
    //检测时间
    DWORD time_start, time_end;
    /* 获取开始时间 */
    time_start = GetTickCount(); //从操作系统启动经过的毫秒数

    yolov5.detect(frame, output);

    time_end = GetTickCount();
    int time = (time_end - time_start);
    cout << "Time = " << (time_end - time_start) << "ms\n ";
    //将所耗时间显示到图片上
    putText(frame, format("time:%dms", time), Point(20, 50), FONT_HERSHEY_SIMPLEX, 1.2, Scalar(255, 0,0), 2);
    
    //绘制结果
    yolov5.drawRect(frame, output);
    imshow("output", frame);
    waitKey(0);
    return 0;
}

（1）加载网络

加载已经导出的onnx网络，打印各个层级参数，此时网络读取成功（opencv要在4.5.4以上）
bool YOLO::loadNet(string model_path, bool is_cuda)
{
    try {
        m_net = readNet(model_path);

        //获取各层信息
        vector<string> layer_names = m_net.getLayerNames();		//此时我们就可以获取所有层的名称了，有了这些可以将其ID取出
        for (int i = 0; i < layer_names.size(); i++) {
            int id = m_net.getLayerId(layer_names[i]);			//通过name获取其id
            auto layer = m_net.getLayer(id);						//通过id获取layer
            printf("layer id:%d,type:%s,name:%s\n", id, layer->type.c_str(), layer->name.c_str());	//将每一层的id，类型，姓名打印出来（可以明白此网络有哪些结构信息了）
        }
    }
    catch (const std::exception&) {
        cout << "load faild" << endl;
        return false;
    }
    
    if (is_cuda)
    {
        cout << "Attempty to use CUDA\n";
        m_net.setPreferableBackend(DNN_BACKEND_CUDA);
        m_net.setPreferableTarget(DNN_TARGET_CUDA_FP16);
    }
    else
    {
        cout << "Running on CPU\n";
        m_net.setPreferableBackend(DNN_BACKEND_OPENCV);
        m_net.setPreferableTarget(DNN_TARGET_CPU);
    }
    return true;
}

在这里插入图片描述

（2）检测推理（forward）

推理前要对图像进行预处理，使其变为网络的输入格式

（2.1）制作黑背景正方形，用于blobFromImage的无损缩放

也可以不制作黑背景，但后面blobFromImage缩放计算可能结果有损失

//制作黑背景正方形，用于blobFromImage的无损缩放
//对于长宽比过大的图片，由于opencv的blobFromImage()函数在缩放的时候不是无损缩放，
//会导致图像变形严重导致结果错误或者漏检。虽然blobFromImage里面有个参数可以保持比例缩放，
//但是只会保留中间的部分，两边信息全部丢掉，所以如果你的目标全部在中间就可以无所谓，
//如果不是，那么需要简单的自己做个无损缩放，制作一张全黑的3通道正方形图片，边长为原图的长边，
//最后将原图放在（0，0）的位置上面，这样就可以直接输入blobFromImage里面就可以实现无损缩放了，
//而且不用对检测结果进行二次修正位置了。
//https ://blog.csdn.net/qq_34124780/article/details/116464727
Mat YOLO::formatYolov5(const Mat& source)
{
    int col = source.cols;
    int row = source.rows;
    int _max = MAX(col, row);
    Mat result = Mat::zeros(_max, _max, CV_8UC3);
    source.copyTo(result(Rect(0, 0, col, row)));
    return result;
}
（2.2）blobFromImage改变图像格式为网络出入格式
 Mat blob;
 auto input_image = formatYolov5(image);
 blobFromImage(input_image, blob, 1. / 255., Size(inputWidth, inputHeight), Scalar(), true, false);//1. / 255.数据归一化，图像大小变为输入格式（640*640）true进行通道交换，false不进行切片

此时经过blobFromImage的图像就变成4维了，在imagewatch中不显示
在这里插入图片描述
在这里插入图片描述

（2.3）输入setInput图像并forward推理
m_net.setInput(blob);
vector<Mat> outputs;
m_net.forward(outputs, m_net.getUnconnectedOutLayersNames());

Forward函数有很多，可以得到如下，有的是将所有的输出结果得到（有时输出层有多个），有的是将对应层的输出结果得到，这里直接得到所有最终输出结果就行了
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实际这里推理只有1个输出结果

 cout << "outputs.size():" << outputs.size() << endl;

在这里插入图片描述

（2.4）结果解析

实际此时推理输出为[1252006]共三维的图像，使用指针的方法的话二维还是三维都会展开成一维指针进行读取
在这里插入图片描述

输出结果如下dims=3维度
在这里插入图片描述

将其转换成Mat可以显示的方式，用于查看对应的效果
在这里插入图片描述

效果如下
在这里插入图片描述

（2.4.0）方法0直接Mat读取解析（主要用于理解输出结构）

在这里插入图片描述

与指针相比，通过mat数组获取对应的第4列的数据是对应的起来的，如下应该使用32F数据格式即可（要将其结果转为（25200*6格式的数据保存到mat中））
在这里插入图片描述

上图最右侧的第6列的数据是类的分数（虽然显示1，但实际上分值是浮点数接近1的）
在这里插入图片描述

三维的
在这里插入图片描述

//使用Mat进行相关数据的保存解析（这里主要通过mat用于理解对应的输出结构）
void YOLO::detect2(Mat& image, vector<Detection>& output) {
    Mat blob;
    auto input_image = formatYolov5(image);
    blobFromImage(input_image, blob, 1. / 255., Size(inputWidth, inputHeight), Scalar(), true, false);//1. / 255.数据归一化，图像大小变为输入格式（640*640）true进行通道交换，false不进行切片

    m_net.setInput(blob);
    vector<Mat> outputs;
    m_net.forward(outputs, m_net.getUnconnectedOutLayersNames());

    //结果解析
    //方法0、使用Mat进行解析
    //***********输出测试
    //几个输出结果
    cout << "outputs.size():" << outputs.size() << endl;

    /*Mat detect_res = m_net.forward("output0");
    cout << "detect_res.channels():" << detect_res.size() << endl;
    cout << "outputs[0].channels():" << outputs[0].size() << endl;*/

    //对其结果使用下方的重新复制一个MAT，这样的才能在imagewatch中看到，否则无法显示
    Mat d1 = outputs[0].clone();
    //重新定义一个Mat对象接收（将其转换成输出结构）（rows = 25200， dimensions=6）
    Mat detectionMat2(rows, dimensions, CV_32F, d1.ptr<float>());		//此处是初始化一个行为size[2]，深度为浮点型，数据从detection中获取	
                                                                                        //使用imagewatch可以看到6*25200的数组，单通道32F深度
    cout << "detect_res.rows:" << detectionMat2.rows << endl;

    //先得到原始用于blobFromImage归一化的input_image图像与/640的比例，后面用于目标框的结果返回
    float x_factor1 = float(input_image.cols) / inputWidth;   //用于blobFromImage归一化的input_image图像/640，得到对应的比例
    float y_factor1 = float(input_image.rows) / inputHeight;  //用于blobFromImage归一化的input_image图像/640

    vector<int> class_ids1;
    vector<float> confidences1;
    vector<Rect> boxes1;
    //25200行的数据（对应的onnx的输出参数）
    for (int i = 0; i < detectionMat2.rows; i++) {
        float confidence1 = detectionMat2.at<float>(i, 4);         //置信度方框box的得分分值
        //cout << "confidence1：" << confidence1 << endl;
        if (confidence1 >= confThreshold)    //求置信度>某个值
        {
            //cout << "confidence1：" << confidence1 << endl;

            //求类别得分将第一个类别后面的所有的类别作为一个mat一行
            //制作一个vector对象，//循环从类别后面截取各个类的分值,并保存
            vector<float> classes_scores1;
            for (int j = 5; j < detectionMat2.cols; j++) {
                classes_scores1.push_back(detectionMat2.at<float>(i, j));
            }
            //求classes_scores1的最大值及对应的索引
            auto max_class_score = max_element(classes_scores1.begin(), classes_scores1.end());
            int idMax = max_class_score - classes_scores1.begin();
            //cout << "类别的分数值：" << *max_class_score << "id：" << idMax << endl;

            if (*max_class_score > scoreThreshold)
            {
                confidences1.push_back(confidence1);
                class_ids1.push_back(idMax);

                //前4行对应的（物体的x、y、w、h）（这里的x、y、w、h结果只是图像640*640的结果的，要返回）
                float x = detectionMat2.at<float>(i, 0);
                float y = detectionMat2.at<float>(i, 1);
                float w = detectionMat2.at<float>(i, 2);
                float h = detectionMat2.at<float>(i, 3);

                //将x、y、w、h结果返回（由640*640的结果返回到原图size（）大小的结果）
                int left = int((x - 0.5 * w) * x_factor1);//（x_factor1*x）
                int top = int((y - 0.5 * h) * y_factor1);
                int width = int(w * x_factor1);             //宽高直接*对应比列即可
                int height = int(h * y_factor1);
                boxes1.push_back(Rect(left, top, width, height));   //得到最终原图对应的矩形框大小
            }
        }

    }

    cout << "boxes.size():" << boxes1.size() << endl;

    //NMS结果非极大值抑制（有些结果是重合的，此处通过nms去除）
    vector<int> nms_result; //保存对应的索引值
    NMSBoxes(boxes1, confidences1, scoreThreshold, nmsThreshold, nms_result);
    for (int i = 0; i < nms_result.size(); i++)
    {
        int idx = nms_result[i];
        Detection result;
        result.class_id = class_ids1[idx];
        result.confidence = confidences1[idx];
        result.box = boxes1[idx];
        output.push_back(result);
    }
}
（2.4.1）方法1指针法Mat.data解析（快但不易理解）
//使用指针进行相关的结果解析（更快速，但不易理解）（相关取值计算过程和上方一样，可以看detect2进行理解）
void YOLO::detect(Mat& image, vector<Detection>& output)
{
    Mat blob;
    auto input_image = formatYolov5(image);
    blobFromImage(input_image, blob, 1. / 255., Size(inputWidth, inputHeight), Scalar(), true, false);//1. / 255.数据归一化，图像大小变为输入格式（640*640）true进行通道交换，false不进行切片
    
    m_net.setInput(blob);
    vector<Mat> outputs;
    m_net.forward(outputs, m_net.getUnconnectedOutLayersNames());

     
    //方法1、使用指针进行解析（1*25200*6）
    float x_factor = float(input_image.cols) / inputWidth;   //用于blobFromImage归一化的input_image图像/640，得到对应的比例
    float y_factor = float(input_image.rows) / inputHeight;  //用于blobFromImage归一化的input_image图像/640
    float* data = (float*)outputs[0].data;  //获取输出结果的初始指针

    vector<int> class_ids;
    vector<float> confidences;
    vector<Rect> boxes;

    for (int i = 0; i < rows; ++i)
    {
        float confidence = data[4];          //置信度方框box的分值
        
        if (confidence >= confThreshold)    //求置信度
        {
            float* classes_scores = data + 5;   //求类别得分
            //求类别得分将第一个类别后面的所有的类别作为一个mat一行(x、y、w、h、confidence、class1、class2、、、)
            //一行，m_classNames.size()个长度
            Mat scores(1, m_classNames.size(), CV_32FC1, classes_scores);
            //求当前最大分数的类别及其索引
            Point class_id;
            double max_class_score;
            minMaxLoc(scores, 0, &max_class_score, 0, &class_id);

            if (max_class_score > scoreThreshold)
            {
                confidences.push_back(confidence);
                class_ids.push_back(class_id.x);

                //box
                float x = data[0];
                float y = data[1];
                float w = data[2];
                float h = data[3];
                int left = int((x - 0.5 * w) * x_factor);
                int top = int((y - 0.5 * h) * y_factor);
                int width = int(w * x_factor);
                int height = int(h * y_factor);
                boxes.push_back(Rect(left, top, width, height));
            }
        }
        data += dimensions;  //data隔着对应结果（类别数1+5（x、y、w、h））
    }

    //NMS结果非极大值抑制
    vector<int> nms_result;
    NMSBoxes(boxes, confidences, scoreThreshold, nmsThreshold, nms_result);
    for (int i = 0; i < nms_result.size(); i++)
    {
        int idx = nms_result[i];
        Detection result;
        result.class_id = class_ids[idx];
        result.confidence = confidences[idx];
        result.box = boxes[idx];
        output.push_back(result);
    }
}
（2.5）绘制结果

就是将矩形框、分值等数据绘制到对应的图像上

void YOLO::drawRect(Mat& image, vector<Detection>& output)
{
    int detections = output.size();
    for (int i = 0; i < detections; ++i)
    {
        auto detection = output[i];
        auto box = detection.box;
        auto classId = detection.class_id;
        const auto color = colors[classId % colors.size()];
        rectangle(image, box, color, 3);

        rectangle(image, Point(box.x, box.y - 40), Point(box.x + box.width, box.y), color, FILLED);
        string label = m_classNames[classId] + ":" + to_string(output[i].confidence);
        putText(image, label, Point(box.x, box.y - 5), FONT_HERSHEY_SIMPLEX, 1.5, Scalar(0, 0, 0), 2);
    }

}

下面是Yolov5s.onnx对应模型的结果

在这里插入图片描述


http://www.niftyadmin.cn/n/5692409.html

相关文章

神经网络激活函数列表大全及keras中的激活函数定义

神经网络激活函数列表大全及keras中的激活函数定义

一、概述 在机器学习中&#xff0c;激活函数是神经网络中的一种函数&#xff0c;用于在神经网络的每个神经元中引入非线性。没有激活函数&#xff0c;神经网络就无法学习复杂的模式&#xff0c;因为线性变换的组合仍然是线性的。 在神经网络的每层中&#xff0c;将该层所有输…
阅读更多...
vue.js组建开发

vue.js组建开发

Vue.js是一个用于构建用户界面的渐进式JavaScript框架。它采用了组件化的开发方式&#xff0c;将UI界面拆分成多个可重用的组件&#xff0c;通过组合这些组件来构建复杂的应用程序。在本文中&#xff0c;我们将探讨Vue.js组件开发的相关概念和技术。 一、组件化开发的优势 组件…
阅读更多...
【Python】Hypercorn：轻量级的异步ASGI/WSGI服务器

【Python】Hypercorn：轻量级的异步ASGI/WSGI服务器

Hypercorn 是一个支持异步 ASGI 和同步 WSGI 应用的高效 Python 服务器。它结合了现代协议支持&#xff08;包括 HTTP/1、HTTP/2 和 HTTP/3&#xff09;&#xff0c;并且为异步 Web 框架&#xff08;如 FastAPI 和 Quart&#xff09;提供了卓越的性能和灵活性。通过 Hypercorn&…
阅读更多...
字符设备驱动过程

字符设备驱动过程

阅读更多...
安全帽头盔检测数据集 3类 12000张 安全帽数据集 voc yolo

安全帽头盔检测数据集 3类 12000张 安全帽数据集 voc yolo

安全帽头盔检测数据集 3类 12000张 安全帽数据集 voc yolo 安全帽头盔检测数据集介绍 数据集名称 安全帽头盔检测数据集 (Safety Helmet and Person Detection Dataset) 数据集概述 该数据集专为训练和评估基于YOLO系列目标检测模型&#xff08;包括YOLOv5、YOLOv6、YOLOv7…
阅读更多...
【Python游戏开发】贪吃蛇游戏demo拓展

【Python游戏开发】贪吃蛇游戏demo拓展

拓展上一项目【Python游戏开发】贪吃蛇 实现穿墙效果 # 检测游戏是否结束 def check_gameover():global finished# 移除蛇头位置超过窗口判断for n in range(len(body) - 1):if(body[n].x snake_head.x and body[n].y snake_head.y):finished True # 状态检测 def ch…
阅读更多...
HTTP 重定向：301 与 308 的区别

HTTP 重定向：301 与 308 的区别

在Web开发中，HTTP 重定向是非常常见的一种操作。当我们需要将用户从一个URL自动引导到另一个URL时，HTTP重定向就起到了关键的作用。最常见的重定向状态码有301 Moved Permanently和308 Permanent Redirect。它们之间的差别不仅仅体现在行为上，也影响了请求方法的处理，进而影…
阅读更多...
Java 面向对象设计一口气讲完！[]~(￣▽￣)~*（上）

Java 面向对象设计一口气讲完！[]~(￣▽￣)~*（上）

目录 Java 类实例 Java面向对象设计 - Java类实例 null引用类型 访问类的字段的点表示法 字段的默认初始化 Java 访问级别 Java面向对象设计 - Java访问级别 Java 导入 Java面向对象设计 - Java导入 单类型导入声明 按需导入声明 静态导入声明 例子 Java 方法 J…
阅读更多...
最新文章

Copyright @ 2022~2023