YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理

这篇具有很好参考价值的文章主要介绍了YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

InferOnnx项目


本项目gitee链接:点击跳转
本项目资源链接:点击跳转
欢迎批评指正。


环境设置

CPU:i5-9400F
GPU:GTX1060


参考文档

yolov5使用onnxruntime进行c++部署:跳转链接

详细介绍 Yolov5 转 ONNX模型 + 使用 ONNX Runtime 的 C++ 部署(包含官方文档的介绍):跳转链接

yolov5-v6.1-opencv-onnxrun:跳转链接

【推理引擎】从源码看ONNXRuntime的执行流程 :跳转链接


推理

整个ONNXRuntime的运行可以分为三个阶段

YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++

相关结构体

定义两个结构体 Net_config 和 BoxInfo。
结构体 Net_config 包含了一些模型配置参数,包括:

  • confThreshold:置信度阈值;
  • nmsThreshold:非极大值抑制阈值;
  • objThreshold:物体置信度阈值;
  • modelpath:模型路径;
  • gpu:是否使用 GPU。
    结构体 BoxInfo 包含了每个检测框的信息,包括:
  • x1:检测框左上角 x 坐标;
  • y1:检测框左上角 y 坐标;
  • x2:检测框右下角 x 坐标;
  • y2:检测框右下角 y 坐标;
  • score:检测框的置信度得分;
  • label:检测框的标签。
    这两个结构体在目标检测算法中经常被用于存储模型配置参数和检测结果等信息,方便代码的编写和阅读。
struct Net_config
{
    float confThreshold; // Confidence threshold
    float nmsThreshold;  // Non-maximum suppression threshold
    float objThreshold;  // Object Confidence threshold
    string modelpath;    // model path
    bool gpu = false;   // using gpu
};

typedef struct BoxInfo
{
    float x1;
    float y1;
    float x2;
    float y2;
    float score;
    int label;
} BoxInfo;

实现YOLO类

我们需要一段代码来一个 YOLO 类,用于目标检测的模型推理。
首先,初始化YOLO类时需要根据输入的参数来生成模型;方法就是根据上一段的Net_config 结构体参数进行生成。之后模型需要一个外部接口用于模型推理的成员变量和函数。
因此,类中主要函数包括:

  • YOLO(Net_config config):构造函数,用于初始化模型配置参数;
  • void detect(Mat& frame):目标检测函数,用于对输入的图像进行检测,并输出检测结果。

成员变量包括:

  • float* anchors:每层特征图所使用的 anchor 数组;
  • int num_stride:anchor 采样的步长;
  • int inpWidth:输入图像的宽度;
  • int inpHeight:输入图像的高度;
  • int nout:网络输出节点的数量;
  • int num_proposal:每个特征点预测目标框的数量;
  • vector class_names:目标类别名称的列表;
  • int num_class:目标类别的数量;
  • int seg_num_class:分割图像的类别数量;
  • float confThreshold:目标置信度得分的阈值;
  • float nmsThreshold:非最大值抑制的阈值;
  • float objThreshold:目标置信度得分的阈值;
  • const bool keep_ratio:是否保持原始图像宽高比;
  • vector input_image_:输入图像的数据指针;
  • env:ONNX 运行环境;
  • ort_session:ONNX 模型的运行会话;
  • sessionOptions:ONNX 会话配置参数;
  • input_names:输入节点的名称列表;
  • output_names:输出节点的名称列表;
  • input_node_dims:输入节点的维度列表;
  • output_node_dims:输出节点的维度列表;
  • In_AllocatedStringPtr:输入节点的数据指针列表;
  • Out_AllocatedStringPtr:输出节点的数据指针列表。

成员函数包括:

  • void normalize_(Mat img):对输入图像进行像素归一化;
  • void nms(vector& input_boxes):对检测结果进行非最大值抑制;
  • Mat resize_image(Mat srcimg, int *newh, int *neww, int *top, int *left):调整输入图像的大小以适应模型输入节点的要求。
class YOLO
{
public:
    YOLO(Net_config config);
    void detect(Mat& frame);
private:
    float* anchors;
    int num_stride;
    int inpWidth;
    int inpHeight;
    int nout;
    int num_proposal;
    vector<string> class_names;
    int num_class;
    int seg_num_class;

    float confThreshold;
    float nmsThreshold;
    float objThreshold;
    const bool keep_ratio = true;
    vector<float> input_image_;
    void normalize_(Mat img);
    void nms(vector<BoxInfo>& input_boxes);
    Mat resize_image(Mat srcimg, int *newh, int *neww, int *top, int *left);

    Env env = Env(ORT_LOGGING_LEVEL_ERROR, "yolov5s");
    Ort::Session *ort_session = nullptr;
    SessionOptions sessionOptions = SessionOptions();
    vector<const char* > input_names;
    vector<const char* > output_names;
    vector<vector<int64_t>> input_node_dims; // >=1 outputs
    vector<vector<int64_t>> output_node_dims; // >=1 outputs
    std::vector<AllocatedStringPtr> In_AllocatedStringPtr;
    std::vector<AllocatedStringPtr> Out_AllocatedStringPtr;
};

相关代码

.h文件

#ifndef INFERONNX_H
#define INFERONNX_H
#include <fstream>
#include <sstream>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <onnxruntime_cxx_api.h>

using namespace std;
using namespace cv;
using namespace Ort;

struct Net_config
{
    float confThreshold; // Confidence threshold
    float nmsThreshold;  // Non-maximum suppression threshold
    float objThreshold;  // Object Confidence threshold
    string modelpath;    // model path
    bool gpu = false;   // using gpu
};

typedef struct BoxInfo
{
    float x1;
    float y1;
    float x2;
    float y2;
    float score;
    int label;
} BoxInfo;

int endsWith(string s, string sub);

const float anchors_640[3][6] = { {10.0,  13.0, 16.0,  30.0,  33.0,  23.0},
                                 {30.0,  61.0, 62.0,  45.0,  59.0,  119.0},
                                 {116.0, 90.0, 156.0, 198.0, 373.0, 326.0} };

const float anchors_1280[4][6] = { {19, 27, 44, 40, 38, 94},{96, 68, 86, 152, 180, 137},{140, 301, 303, 264, 238, 542},
                       {436, 615, 739, 380, 925, 792} };

class YOLO
{
public:
    YOLO(Net_config config);
    void detect(Mat& frame);
private:
    float* anchors;
    int num_stride;
    int inpWidth;
    int inpHeight;
    int nout;
    int num_proposal;
    vector<string> class_names;
    int num_class;
    int seg_num_class;

    float confThreshold;
    float nmsThreshold;
    float objThreshold;
    const bool keep_ratio = true;
    vector<float> input_image_;
    void normalize_(Mat img);
    void nms(vector<BoxInfo>& input_boxes);
    Mat resize_image(Mat srcimg, int *newh, int *neww, int *top, int *left);

    Env env = Env(ORT_LOGGING_LEVEL_ERROR, "yolov5s");
    Ort::Session *ort_session = nullptr;
    SessionOptions sessionOptions = SessionOptions();
    vector<const char* > input_names;
    vector<const char* > output_names;
    vector<vector<int64_t>> input_node_dims; // >=1 outputs
    vector<vector<int64_t>> output_node_dims; // >=1 outputs
    std::vector<AllocatedStringPtr> In_AllocatedStringPtr;
    std::vector<AllocatedStringPtr> Out_AllocatedStringPtr;
};
#endif // INFERONNX_H

CPP文件

#include "InferOnxx.h"

int endsWith(string s, string sub) {
    return s.rfind(sub) == (s.length() - sub.length()) ? 1 : 0;
}

YOLO::YOLO(Net_config config)
{
    this->confThreshold = config.confThreshold;
    this->nmsThreshold = config.nmsThreshold;
    this->objThreshold = config.objThreshold;

    string classesFile = "D:/workspace/C++/Onnx/InferOnxx/InferOnxx/class.names";
    string model_path = config.modelpath;
    std::wstring widestr = std::wstring(model_path.begin(), model_path.end());

    if (config.gpu) {
        OrtSessionOptionsAppendExecutionProvider_CUDA(sessionOptions, 0);   //CUDA加速开启
    }

    sessionOptions.SetGraphOptimizationLevel(ORT_ENABLE_BASIC); //设置图优化类型

    ort_session = new Session(env, widestr.c_str(), sessionOptions);    // 创建会话,把模型加载到内存中

    size_t numInputNodes = ort_session->GetInputCount();            //输入输出节点数量    
    size_t numOutputNodes = ort_session->GetOutputCount();

    for (int i = 0; i < numInputNodes; i++)                         // onnxruntime1.12版本后不能按照从前格式写
    {
        AllocatorWithDefaultOptions allocator;                              // 配置输入输出节点内存
        In_AllocatedStringPtr.push_back(ort_session->GetInputNameAllocated(i, allocator));
        input_names.push_back(In_AllocatedStringPtr.at(i).get());           // 内存
        Ort::TypeInfo input_type_info = ort_session->GetInputTypeInfo(i);   // 类型
        auto input_tensor_info = input_type_info.GetTensorTypeAndShapeInfo();
        auto input_dims = input_tensor_info.GetShape();                     // 输入shape
        input_node_dims.push_back(input_dims);                              // 输入维度信息
    }
    for (int i = 0; i < numOutputNodes; i++)
    {
        AllocatorWithDefaultOptions allocator;
        Out_AllocatedStringPtr.push_back(ort_session->GetOutputNameAllocated(i, allocator));
        output_names.push_back(Out_AllocatedStringPtr.at(i).get());
        Ort::TypeInfo output_type_info = ort_session->GetOutputTypeInfo(i);
        auto output_tensor_info = output_type_info.GetTensorTypeAndShapeInfo();
        auto output_dims = output_tensor_info.GetShape();
        output_node_dims.push_back(output_dims);
    }
    this->inpHeight = input_node_dims[0][2];
    this->inpWidth = input_node_dims[0][3];
    this->nout = output_node_dims[0][2];                // 5+classese 85
    this->num_proposal = output_node_dims[0][1];        // 3*(小检测框+中检测框+大检测框) 3*((20*20)+(40*40)+(80*80))

    ifstream ifs(classesFile.c_str());
    string line;
    while (getline(ifs, line)) this->class_names.push_back(line);
    this->num_class = class_names.size();

    if (endsWith(config.modelpath, "6.onnx"))           // 判断版本
    {
        anchors = (float*)anchors_1280;
        this->num_stride = 4;
    }
    else
    {
        anchors = (float*)anchors_640;
        this->num_stride = 3;
    }
}

Mat YOLO::resize_image(Mat srcimg, int *newh, int *neww, int *top, int *left)
{
    int srch = srcimg.rows, srcw = srcimg.cols;
    *newh = this->inpHeight;
    *neww = this->inpWidth;
    Mat dstimg;
    if (this->keep_ratio && srch != srcw) {
        float hw_scale = (float)srch / srcw;
        if (hw_scale > 1) {                             // srch>srcw
            *newh = this->inpHeight;
            *neww = int(this->inpWidth / hw_scale);     // set/scale
            resize(srcimg, dstimg, Size(*neww, *newh), INTER_AREA);     // resize(nw,nh)
            *left = int((this->inpWidth - *neww) * 0.5);                // 计算padding距离
            copyMakeBorder(dstimg, dstimg, 0, 0, *left, this->inpWidth - *neww - *left, BORDER_CONSTANT, 114);  // padding
        }
        else {
            *newh = (int)this->inpHeight * hw_scale;
            *neww = this->inpWidth;
            resize(srcimg, dstimg, Size(*neww, *newh), INTER_AREA);
            *top = (int)(this->inpHeight - *newh) * 0.5;
            copyMakeBorder(dstimg, dstimg, *top, this->inpHeight - *newh - *top, 0, 0, BORDER_CONSTANT, 114);
        }
    }
    else {
        resize(srcimg, dstimg, Size(*neww, *newh), INTER_AREA);
    }
    return dstimg;
}

void YOLO::normalize_(Mat img)
{
    //    img.convertTo(img, CV_32F);
    int row = img.rows;
    int col = img.cols;
    this->input_image_.resize(row * col * img.channels());
    for (int c = 0; c < 3; c++)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                float pix = img.ptr<uchar>(i)[j * 3 + 2 - c];       // HWC to CHW, BGR to RGB,j * 3 + 2 - c即完成转换
                this->input_image_[c * row * col + i * col + j] = pix / 255.0;
            }
        }
    }
}

void YOLO::nms(vector<BoxInfo>& input_boxes)
{
    sort(input_boxes.begin(), input_boxes.end(), [](BoxInfo a, BoxInfo b) { return a.score > b.score; });   // 按照置信度排序, []Lambda 表达式
    vector<float> vArea(input_boxes.size());                            // 记录每个检测框面积
    for (int i = 0; i < int(input_boxes.size()); ++i)                   // 遍历所有检测框
    {
        vArea[i] = (input_boxes.at(i).x2 - input_boxes.at(i).x1 + 1)
            * (input_boxes.at(i).y2 - input_boxes.at(i).y1 + 1);
    }

    vector<bool> isSuppressed(input_boxes.size(), false);               // 记录是否抑制,默认为FALSE
    for (int i = 0; i < int(input_boxes.size()); ++i)                   // 遍历所有检测框
    {
        if (isSuppressed[i]) { continue; }                              // 是否已经判断过
        for (int j = i + 1; j < int(input_boxes.size()); ++j)           // 第二个指针遍历
        {
            if (isSuppressed[j]) { continue; }
            float xx1 = (max)(input_boxes[i].x1, input_boxes[j].x1);
            float yy1 = (max)(input_boxes[i].y1, input_boxes[j].y1);
            float xx2 = (min)(input_boxes[i].x2, input_boxes[j].x2);
            float yy2 = (min)(input_boxes[i].y2, input_boxes[j].y2);

            float w = (max)(float(0), xx2 - xx1 + 1);
            float h = (max)(float(0), yy2 - yy1 + 1);
            float inter = w * h;
            float ovr = inter / (vArea[i] + vArea[j] - inter);          // 计算miou

            if (ovr >= this->nmsThreshold)
            {
                isSuppressed[j] = true;                                 // 大于设定的阈值,则抑制
            }
        }
    }
    // return post_nms;
    int idx_t = 0;
    // remove_if()函数 remove_if(beg, end, op) //移除区间[beg,end)中每一个“令判断式:op(elem)获得true”的元素
    input_boxes.erase(remove_if(input_boxes.begin(), input_boxes.end(), [&idx_t, &isSuppressed](const BoxInfo& f) { return isSuppressed[idx_t++]; }), input_boxes.end());
}

void YOLO::detect(Mat& frame)
{
    int newh = 0, neww = 0, padh = 0, padw = 0;     // padh:上下边的padding距离; padw:左右padding的距离
    Mat dstimg = this->resize_image(frame, &newh, &neww, &padh, &padw);
    this->normalize_(dstimg);
    array<int64_t, 4> input_shape_{ 1, 3, this->inpHeight, this->inpWidth };

    auto memory_info = MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);
    Value input_tensor_ = Value::CreateTensor<float>(memory_info, input_image_.data(), input_image_.size(), input_shape_.data(), input_shape_.size());


    vector<Value> ort_outputs = ort_session->Run(RunOptions{ nullptr }, &input_names[0], &input_tensor_, 1, output_names.data(), output_names.size()); 
    vector<BoxInfo> generate_boxes;
    const float* pdata = ort_outputs[0].GetTensorMutableData<float>();                  // 数组,存放预测数据 [bs,anchor'classes,anchor'number,pos+conf+ num'classes]
    float ratioh = (float)frame.rows / newh, ratiow = (float)frame.cols / neww;         // 计算缩放倍数
    for (int i = 0; i < num_proposal; ++i)      // 遍历所有的num_pre_boxes 3*((20*20)+(40*40)+(80*80))
    {
        int index = i * nout;                   // 索引
        float obj_conf = pdata[index + 4];      // 第四个为置信度分数
        if (obj_conf > this->objThreshold)      // 大于阈值
        {
            // 求最大分数和索引
            int class_idx = 0;                  // 记录类别id
            float max_class_socre = 0;          // 记录最大概率
            for (int k = 0; k < this->num_class; ++k)   // K个类别里循环
            {
                if (pdata[k + index + 5] > max_class_socre) // 判断分数
                {
                    max_class_socre = pdata[k + index + 5]; // 记录分数
                    class_idx = k;                          // 记录类别数
                }
            }
            max_class_socre *= obj_conf;   // 最大的类别分数*置信度
            if (max_class_socre > this->confThreshold) // 再次筛选
            {
                float cx = pdata[index];        //x:检测框中心点
                float cy = pdata[index + 1];    //y
                float w = pdata[index + 2];     //w:检测框宽
                float h = pdata[index + 3];     //h
                // 映射到原来的图像上
                float xmin = (cx - padw - 0.5 * w)*ratiow;      // (推理位置-左边padding距离-0.5*宽)*缩放倍数=原图像左上角x位置
                float ymin = (cy - padh - 0.5 * h)*ratioh;      // (推理位置-上边padding距离-0.5*高)*缩放倍数=原图像左上角y位置
                float xmax = (cx - padw + 0.5 * w)*ratiow;      // 
                float ymax = (cy - padh + 0.5 * h)*ratioh;      // 

                generate_boxes.push_back(BoxInfo{ xmin, ymin, xmax, ymax, max_class_socre, class_idx }); //记录相关数据
            }
        }
    }

    // Perform non maximum suppression to eliminate redundant overlapping boxes with
    // lower confidences
    nms(generate_boxes);
    for (size_t i = 0; i < generate_boxes.size(); ++i)
    {
        int xmin = int(generate_boxes[i].x1);
        int ymin = int(generate_boxes[i].y1);
        rectangle(frame, Point(xmin, ymin), Point(int(generate_boxes[i].x2), int(generate_boxes[i].y2)), Scalar(0, 0, 255), 2);
        string label = format("%.2f", generate_boxes[i].score);
        label = this->class_names[generate_boxes[i].label] + ":" + label;
        putText(frame, label, Point(xmin, ymin - 5), FONT_HERSHEY_SIMPLEX, 0.75, Scalar(0, 255, 0), 1);
    }
}

推理结果

在coco验证集上推理图片所花的时间如下

  • cpu推理两张图片
    YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++

  • gpu推理两张图片
    YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++

  • cpu推理100张图片
    YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++

  • gpu推理100张图片
    YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++

  • 推理部分结果
    YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++
    YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理,onnx,深度学习,opencv,计算机视觉,c++


值得注意的地方

版本不同引起的相关改动

  1. 开启cuda加速
    1.12版本后一句话就可以开启cuda加速
    OrtSessionOptionsAppendExecutionProvider_CUDA(sessionOptions, 0);   //CUDA加速开启
    
  2. 获取输入输出节点数
    for (int i = 0; i < numInputNodes; i++)                         // onnxruntime1.12版本后不能按照从前格式写
    {
        AllocatorWithDefaultOptions allocator;                              // 配置输入输出节点内存
        In_AllocatedStringPtr.push_back(ort_session->GetInputNameAllocated(i, allocator));
        input_names.push_back(In_AllocatedStringPtr.at(i).get());           // 内存
        Ort::TypeInfo input_type_info = ort_session->GetInputTypeInfo(i);   // 类型
        auto input_tensor_info = input_type_info.GetTensorTypeAndShapeInfo();
        auto input_dims = input_tensor_info.GetShape();                     // 输入shape
        input_node_dims.push_back(input_dims);                              // 输入维度信息
    }
    for (int i = 0; i < numOutputNodes; i++)
    {
        AllocatorWithDefaultOptions allocator;
        Out_AllocatedStringPtr.push_back(ort_session->GetOutputNameAllocated(i, allocator));
        output_names.push_back(Out_AllocatedStringPtr.at(i).get());
        Ort::TypeInfo output_type_info = ort_session->GetOutputTypeInfo(i);
        auto output_tensor_info = output_type_info.GetTensorTypeAndShapeInfo();
        auto output_dims = output_tensor_info.GetShape();
        output_node_dims.push_back(output_dims);
    }

这里如果按照之前版本写,会造成内存泄漏,从而引发异常

这段代码定义了 YOLO 类中的像素归一化函数 normalize_()。该函数接收一个 cv::Mat 类型的图像作为输入,并将其像素值归一化至 [0,1] 的范围内,将像素数据存储到 input_image_ 数组中。值得注意的是,在读取像素点时,使用 img.ptr<uchar>(i)[j * 3 + 2 - c] 获取像素点的值,其中 i 表示行数,j 表示列数,c 表示当前通道数。由于输入图像的通道顺序为 BGR,而在存储到 input_image_ 数组中时需要按照 RGB 通道的顺序进行存储,因此需要使用 j * 3 + 2 - c 对通道顺序进行转换。最终将 input_image_ 数组的大小设置为 row * col * img.channels(),即所有像素点的数量。

相关知识点学习

cv::glob
cv::glob:提取目录下的文件地址

// 提取文件名称
string path = "路径"
int sttr_start = path.find_last_of("\\");
int sttr_size = path.size();
string sub_path = path.substr(sttr_start, sttr_size - 1);
归一化函数
void YOLO::normalize_(Mat img)
{
    //    img.convertTo(img, CV_32F);
    int row = img.rows;
    int col = img.cols;
    this->input_image_.resize(row * col * img.channels());
    for (int c = 0; c < 3; c++)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                float pix = img.ptr<uchar>(i)[j * 3 + 2 - c];       // HWC to CHW, BGR to RGB,j * 3 + 2 - c即完成转换
                this->input_image_[c * row * col + i * col + j] = pix / 255.0;
            }
        }
    }
}
YOLOv5head

YOLOv5的输出是检测框的中心点位置,以及检测框的高宽,因此最后画框的时候需要转换坐标轴位置文章来源地址https://www.toymoban.com/news/detail-626418.html

if (max_class_socre > this->confThreshold) // 再次筛选
            {
                float cx = pdata[index];        //x:检测框中心点
                float cy = pdata[index + 1];    //y
                float w = pdata[index + 2];     //w:检测框宽
                float h = pdata[index + 3];     //h
                // 映射到原来的图像上
                float xmin = (cx - padw - 0.5 * w)*ratiow;      // (推理位置-左边padding距离-0.5*宽)*缩放倍数=原图像左上角x位置
                float ymin = (cy - padh - 0.5 * h)*ratioh;      // (推理位置-上边padding距离-0.5*高)*缩放倍数=原图像左上角y位置
                float xmax = (cx - padw + 0.5 * w)*ratiow;      // 
                float ymax = (cy - padh + 0.5 * h)*ratioh;      // 

                generate_boxes.push_back(BoxInfo{ xmin, ymin, xmax, ymax, max_class_socre, class_idx }); //记录相关数据
            }

到了这里,关于YOLOv5在C++中通过Onnxruntime在window平台上的cpu与gpu推理的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 使用c++onnxruntime部署yolov5模型并使用CUDA加速(超详细)

    前言 1.Yolo简介 2.onnxruntime简介 3.Yolov5模型训练及转换 4.利用cmake向C++部署该onnx模型 总结 接到一个项目,需要用c++和单片机通信,还要使用yolo模型来做到目标检测的任务,但目前网上的各种博客并没有完整的流程教程,让我在部署过程费了不少劲,也踩了不少坑(甚至一度把

    2024年02月02日
    浏览(46)
  • YOLOV8 Onnxruntime Opencv DNN C++部署

          OpenCV由各种不同组件组成。OpenCV源代码主要由OpenCV core(核心库)、opencv_contrib和opencv_extra等子仓库组成。近些年,OpenCV的主仓库增加了深度学习相关的子仓库:OpenVINO(即DLDT, Deep Learning Deployment Toolkit)、open_model_zoo,以及标注工具CVAT等。         OpenCV深度学习模块只

    2024年02月16日
    浏览(48)
  • 【模型部署 01】C++实现GoogLeNet在OpenCV DNN、ONNXRuntime、TensorRT、OpenVINO上的推理部署

    深度学习领域常用的基于CPU/GPU的推理方式有OpenCV DNN、ONNXRuntime、TensorRT以及OpenVINO。这几种方式的推理过程可以统一用下图来概述。整体可分为模型初始化部分和推理部分,后者包括步骤2-5。 以GoogLeNet模型为例,测得几种推理方式在推理部分的耗时如下: 结论: GPU加速首选

    2024年02月06日
    浏览(57)
  • 【零基础玩转yolov5】yolov5训练自己的数据集(CPU训练+GPU训练)

     博主也是最近开始玩yolov5的,甚至也是最近开始使用python的,很多东西都没有接触过,因此训练自己的数据集花了不少时间,所以想写篇博客记录一下,希望同样是零基础的小伙伴们可以更加轻松的上手。同时大家如果发现了错误和理解偏差,欢迎指正。 参考资料: Yolo

    2024年02月06日
    浏览(74)
  • 【模型部署 01】C++实现分类模型(以GoogLeNet为例)在OpenCV DNN、ONNXRuntime、TensorRT、OpenVINO上的推理部署

    深度学习领域常用的基于CPU/GPU的推理方式有OpenCV DNN、ONNXRuntime、TensorRT以及OpenVINO。这几种方式的推理过程可以统一用下图来概述。整体可分为模型初始化部分和推理部分,后者包括步骤2-5。 以GoogLeNet模型为例,测得几种推理方式在推理部分的耗时如下: 结论: GPU加速首选

    2024年02月06日
    浏览(57)
  • Ubuntu环境下C++使用onnxruntime和Opencv进行YOLOv8模型部署

    目录 环境配置 系统环境 项目文件路径  文件环境  config.txt  CMakeLists.txt type.names  读取config.txt配置文件 修改图片尺寸格式 读取缺陷标志文件 生成缺陷随机颜色标识 模型推理 推理结果获取 缺陷信息还原并显示 总代码 Ubuntu18.04 onnxruntime-linux-x64 1.12.1:https://github.com/microsof

    2024年01月17日
    浏览(46)
  • yolov5环境搭建(Anaconda-py3.9、PyTorch-CPU、yolov5-4.0、PyCharm)

    Windows 10 Anaconda(基于Python3.9),已配置好环境变量 yolov5相关的代码、权重文件等,已经打包整理好,可以通过百度网盘绿色下载。链接: https://pan.baidu.com/s/1okVkfpqjI5wD6PigK-AH0w?pwd=yscw 提取码: yscw Anconda除了提供丰富的科学包外,还可以通过创建虚拟化境的方式用于进行环境隔离

    2024年02月04日
    浏览(39)
  • 无人机上仅使用CPU实时运行Yolov5(OpenVINO实现)(上篇)

    I ntel CPU 在运行 视觉导航 等算法时实时性要优于Nvidia等平台,如Jetson Tx2,NX。而 Nvidia平台 在运行 深度学习算法 方面具有很大优势,两种平台各有利弊。但是,Intel OpenVINO的推出允许NUC平台实时运行深度学习模型,如目前最流行的目标检测程序Yolov5,这样就太好了, 仅使用

    2024年02月10日
    浏览(37)
  • 在CPU上进行完整版yolov5项目跟练记录

    本节内容参考来源:1、2、3 1. 目标检测任务说明 目标检测指的是:输入图像或视频,要从图像中获取需要的物体类型以及位置等信息。 主要的检测性能指标如下图所示: 1.1 基础检测 精度 指标: 1.2 基础检测 速度 指标: 2. 目标检测与yolov5发展历程 2.1目标检测发展史 2.2

    2024年02月06日
    浏览(51)
  • yolov5模型(.pt)在RK3588(S)上的部署(实时摄像头检测)

    github仓库 所需: 安装了Ubuntu20系统的RK3588 安装了Ubuntu18的电脑或者虚拟机 一、yolov5 PT模型获取 Anaconda教程 YOLOv5教程 经过上面两个教程之后,你应该获取了自己的 best.pt 文件 二、PT模型转onnx模型 将 models/yolo.py 文件中的 class 类下的 forward 函数由: 改为: 将 export.py 文件中的

    2024年02月06日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包