yolov7使用onnx推理(带&不带NMS)

这篇具有很好参考价值的文章主要介绍了yolov7使用onnx推理(带&不带NMS)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

官方代码:

GitHub - WongKinYiu/yolov7: Implementation of paper - YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors

        上个月,官方放了个使用onnx推理的ipynb文件,过了几天上去看,官方又给删了,不知道是不是要更新波大的,还好手快保存了一份,这个可以作为备忘,懒得再重新写(不过这得是多懒,都在这码字了不去写代码。。。)

不带NMS 

        先贴代码吧:

import cv2
import time
import requests
import random
import numpy as np
import onnxruntime as ort
from PIL import Image
from pathlib import Path
from collections import OrderedDict,namedtuple

cuda = False
w = "yolov7.onnx"
providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if cuda else ['CPUExecutionProvider']
session = ort.InferenceSession(w, providers=providers)

def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleup=True, stride=32):
    # Resize and pad image while meeting stride-multiple constraints
    shape = im.shape[:2]  # current shape [height, width]
    if isinstance(new_shape, int):
        new_shape = (new_shape, new_shape)

    # Scale ratio (new / old)
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
    if not scaleup:  # only scale down, do not scale up (for better val mAP)
        r = min(r, 1.0)

    # Compute padding
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]  # wh padding

    if auto:  # minimum rectangle
        dw, dh = np.mod(dw, stride), np.mod(dh, stride)  # wh padding

    dw /= 2  # divide padding into 2 sides
    dh /= 2

    if shape[::-1] != new_unpad:  # resize
        im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
    im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # add border
    return im, r, (dw, dh)

names = ['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']
colors = {name:[random.randint(0, 255) for _ in range(3)] for i,name in enumerate(names)}

# url = 'https://oneflow-static.oss-cn-beijing.aliyuncs.com/tripleMu/image1.jpg'
# file = requests.get(url)

img_path = r'\inference\images\image3.jpg'
# img = cv2.imdecode(np.frombuffer(file.content, np.uint8), 1)
img = cv2.imread(img_path)
# img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

image = img.copy()
image, ratio, dwdh = letterbox(image, auto=False)
image = image.transpose((2, 0, 1))
image = np.expand_dims(image, 0)
image = np.ascontiguousarray(image)

im = image.astype(np.float32)
im /= 255


outname = [i.name for i in session.get_outputs()]
inname = [i.name for i in session.get_inputs()]

inp = {inname[0]:im}
t1 = time.time()
outputs = session.run(outname, inp)[0]
print('inference time :%.4f'%(time.time()-t1))
# print(outputs)

ori_images = [img.copy()]

for i,(batch_id,x0,y0,x1,y1,cls_id,score) in enumerate(outputs):
    image = ori_images[int(batch_id)]
    box = np.array([x0,y0,x1,y1])
    box -= np.array(dwdh*2)
    box /= ratio
    box = box.round().astype(np.int32).tolist()
    cls_id = int(cls_id)
    score = round(float(score),3)
    name = names[cls_id]
    color = colors[name]
    name += ' '+str(score)
    cv2.rectangle(image,box[:2],box[2:],color,2)
    cv2.putText(image,name,(box[0], box[1] - 2),cv2.FONT_HERSHEY_SIMPLEX,0.75,[225, 255, 255],thickness=2)

cv2.imshow('dddd',ori_images[0])
cv2.waitKey(0)
cv2.destroyAllWindows()

# Image.fromarray(ori_images[0])

        熟悉yolo系列的朋友应该看出上面的问题了,没有NMS,这是因为官方代码在导出onnx的时候做了简化和端到端的处理。

        导出指令:

python export.py --weights yolov7.pt --grid --end2end --simplify \
        --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640

        如果单纯运行export.py导出的onnx是运行不了上面的代码的,在for循环的时候会报错。

在控制台执行以上指令:

yolov7 onnx,深度学习模型部署,深度学习,人工智能,yolo,计算机视觉

        可以看到模型最后是导出成功的,过程会有些警告,忽视即可,不过简化失败,这个主要是应为onnx的版本问题,我的是1.9,降级到1.8.1之后就可以了。

        直接运行最初的onnx推理代码,不过需要注意的是图片的路径可能需要修改一下

img_path = r'改成本地图片路径'

        推理结果:

 yolov7 onnx,深度学习模型部署,深度学习,人工智能,yolo,计算机视觉

带NMS

        这里是带有nms的版本

        在yolov7的根目录下创建detect_onnx.py,并复制如下代码:

import argparse
import time
from pathlib import Path

import cv2
import torch
import torch.backends.cudnn as cudnn
from numpy import random
from utils.datasets import LoadStreams, LoadImages
from utils.general import check_img_size, check_requirements, check_imshow, non_max_suppression, apply_classifier, \
    scale_coords, xyxy2xywh, strip_optimizer, set_logging, increment_path
from utils.plots import plot_one_box
from utils.torch_utils import select_device, load_classifier, time_synchronized
import onnxruntime

def detect(save_img=False):
    source, weights, view_img, save_txt, imgsz, trace = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size, not opt.no_trace
    save_img = not opt.nosave and not source.endswith('.txt')  # save inference images
    webcam = source.isnumeric() or source.endswith('.txt') or source.lower().startswith(
        ('rtsp://', 'rtmp://', 'http://', 'https://'))

    # Directories
    save_dir = Path(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok))  # increment run
    (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True)  # make dir

    # Initialize
    set_logging()
    device = select_device(opt.device)
    half = device.type != 'cpu'  # half precision only supported on CUDA

    cuda = torch.cuda.is_available()
    check_requirements(('onnx', 'onnxruntime-gpu' if cuda else 'onnxruntime'))
    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if cuda else ['CPUExecutionProvider']
    session = onnxruntime.InferenceSession(weights, providers=providers)

    # Load model
    model = session
    # stride = int(model.stride.max())  # model stride
    stride = 32
    imgsz = check_img_size(imgsz, s=stride)  # check img_size

    # Second-stage classifier
    classify = False
    if classify:
        modelc = load_classifier(name='resnet101', n=2)  # initialize
        modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model']).to(device).eval()

    # Set Dataloader
    vid_path, vid_writer = None, None
    if webcam:
        view_img = check_imshow()
        cudnn.benchmark = True  # set True to speed up constant image size inference
        dataset = LoadStreams(source, img_size=imgsz, stride=stride)
    else:
        dataset = LoadImages(source, img_size=imgsz, stride=stride,auto=False)

    # Get names and colors
    names = ['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']
    colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]

    # Run inference
    if device.type != 'cpu':
        model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # run once
    t0 = time.time()
    for path, img, im0s, vid_cap in dataset:
        img = torch.from_numpy(img).to(device)
        img = img.half() if half else img.float()  # uint8 to fp16/32
        img /= 255.0  # 0 - 255 to 0.0 - 1.0
        if img.ndimension() == 3:
            img = img.unsqueeze(0)

        # Inference
        t1 = time_synchronized()
        ts = time.time()

        im = img.cpu().numpy()  # torch to numpy
        pred = model.run([session.get_outputs()[0].name], {session.get_inputs()[0].name: im})[0]
        # pred = model.run([i.name for i in session.get_outputs()], {session.get_inputs()[0].name: im})[0]
        te = time.time()
        print('inference time : %.4f s'%(te-ts))
        # Apply NMS
        pred = torch.from_numpy(pred).reshape(1,-1,85)
        pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
        t2 = time_synchronized()

        # Apply Classifier
        if classify:
            pred = apply_classifier(pred, modelc, img, im0s)

        # Process detections
        for i, det in enumerate(pred):  # detections per image
            if webcam:  # batch_size >= 1
                p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy(), dataset.count
            else:
                p, s, im0, frame = path, '', im0s, getattr(dataset, 'frame', 0)

            p = Path(p)  # to Path
            save_path = str(save_dir / p.name)  # img.jpg
            txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}')  # img.txt
            s += '%gx%g ' % img.shape[2:]  # print string
            gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]  # normalization gain whwh
            if len(det):
                # Rescale boxes from img_size to im0 size
                det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()

                # Print results
                for c in det[:, -1].unique():
                    n = (det[:, -1] == c).sum()  # detections per class
                    s += f"{n} {names[int(c)]}{'s' * (n > 1)}, "  # add to string

                # Write results
                for *xyxy, conf, cls in reversed(det):
                    if save_txt:  # Write to file
                        xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  # normalized xywh
                        line = (cls, *xywh, conf) if opt.save_conf else (cls, *xywh)  # label format
                        with open(txt_path + '.txt', 'a') as f:
                            f.write(('%g ' * len(line)).rstrip() % line + '\n')

                    if save_img or view_img:  # Add bbox to image
                        label = f'{names[int(cls)]} {conf:.2f}'
                        plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)

            # Print time (inference + NMS)
            print(f'{s}Done. ({t2 - t1:.3f}s)')

            # Stream results
            if view_img:
                cv2.imshow(str(p), im0)
                cv2.waitKey(0)  # 1 millisecond

            # Save results (image with detections)
            if save_img:
                if dataset.mode == 'image':
                    cv2.imwrite(save_path, im0)
                    print(f" The image with the result is saved in: {save_path}")
                else:  # 'video' or 'stream'
                    if vid_path != save_path:  # new video
                        vid_path = save_path
                        if isinstance(vid_writer, cv2.VideoWriter):
                            vid_writer.release()  # release previous video writer
                        if vid_cap:  # video
                            fps = vid_cap.get(cv2.CAP_PROP_FPS)
                            w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
                            h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
                        else:  # stream
                            fps, w, h = 30, im0.shape[1], im0.shape[0]
                            save_path += '.mp4'
                        vid_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
                    vid_writer.write(im0)

    if save_txt or save_img:
        s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
        #print(f"Results saved to {save_dir}{s}")

    print(f'Done. ({time.time() - t0:.3f}s)')


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--weights', nargs='+', type=str, default='yolov7.onnx', help='model.onnx path(s)')
    parser.add_argument('--source', type=str, default='inference/images', help='source')  # file/folder, 0 for webcam
    parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
    parser.add_argument('--conf-thres', type=float, default=0.25, help='object confidence threshold')
    parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    parser.add_argument('--view-img', action='store_true', help='display results')
    parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
    parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
    parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
    parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
    parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
    parser.add_argument('--augment', action='store_true', help='augmented inference')
    parser.add_argument('--update', action='store_true', help='update all models')
    parser.add_argument('--project', default='runs/detect', help='save results to project/name')
    parser.add_argument('--name', default='exp', help='save results to project/name')
    parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
    parser.add_argument('--no-trace', action='store_true', help='don`t trace model')
    opt = parser.parse_args()
    print(opt)
    #check_requirements(exclude=('pycocotools', 'thop'))

    with torch.no_grad():
        if opt.update:  # update all models (to fix SourceChangeWarning)
            for opt.weights in ['yolov7.pt']:
                detect()
                strip_optimizer(opt.weights)
        else:
            detect()

这里有两点要注意:

1、dataset = LoadImages(source, img_size=imgsz, stride=stride,auto=False)
需要加auto参数,并设置为False,主要是为了把参数传到以下函数里,不然自动padding的时候图像大小可能会变化,导致报错
img = letterbox(img0, self.img_size, stride=self.stride,auto=self.auto)[0]

2、导出onnx时的语句:python export.py --weights yolov7.pt --grid --img-size 640 640

推理结果:

yolov7 onnx,深度学习模型部署,深度学习,人工智能,yolo,计算机视觉

 文章来源地址https://www.toymoban.com/news/detail-571996.html

到了这里,关于yolov7使用onnx推理(带&不带NMS)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • OpenCV DNN模块推理YOLOv5 ONNX模型方法

    本文档主要描述 python 平台,使用 opencv-python 深度神经网络模块 dnn ,推理 YOLOv5 模型的方法。 文档主要包含以下内容: opencv-python 模块的安装 YOLOv5 模型格式的说明 ONNX 格式模型的加载 图片数据的预处理 模型推理 推理结果后处理,包括 NMS , cxcywh 坐标转换为 xyxy 坐标等 关键方

    2024年02月16日
    浏览(54)
  • YOLO系列 --- YOLOV7算法(六):YOLO V7算法onnx模型部署

    有很多人来问我,基于YOLO v7算法训练出来一个权重文件,如何进行部署。所以特地写一篇部署的blog~ 一般,我们基于pytorch深度学习框架训练出来的权重文件是pt格式的,我们可以用python来直接调用这个文件。但是实际工业中,一般都是c++去调用权重文件的,所以我们需要将

    2024年02月07日
    浏览(45)
  • Yolov5/Yolov7优化:引入Soft-NMS并结合各个IOU变体GIOU、DIOU、CIOU、EIOU、SIOU,进一步提升密集遮挡场景检测精度  

    💡💡💡本文改进:Soft-NMS并与各个IOU变体GIOU、DIOU、CIOU、EIOU、SIOU结合, 实现二次创新,并提升密集遮挡场景检测精度 💡💡💡Yolov8魔术师, 独家首发创新(原创) ,适用于 Yolov5、Yolov7、Yolov8等各个Yolo系列 ,专栏文章 提供每一步步骤和源码,轻松带你上手魔改网络 💡💡

    2024年02月10日
    浏览(43)
  • YOLOv8 人体姿态估计(关键点检测) python推理 && ONNX RUNTIME C++部署

    目录   1、下载权重 ​编辑2、python 推理 3、转ONNX格式 4、ONNX RUNTIME C++ 部署 utils.h utils.cpp detect.h detect.cpp main.cpp CmakeList.txt 我这里之前在做实例分割的时候,项目已经下载到本地,环境也安装好了,只需要下载pose的权重就可以 输出:   用netron查看一下:  如上图所是,YOLO

    2024年02月07日
    浏览(48)
  • Yolov7如期而至,奉上ONNXRuntime的推理部署流程(CPU/GPU)

    一、V7效果真的的v587,识别率和速度都有了极大的提升,这里先放最新鲜的github链接: https://github.com/WongKinYiu/yolov7 二、v7的训练我这里就不做过多的赘述了,这里主要是进行讲解怎么把.pt文件转为onnx和后续的推理问题:  2.1首先是pip的版本非常重要,博主亲自测试了,发现

    2024年02月10日
    浏览(45)
  • 基于树莓派Qt+opencv+yolov5-Lite+C++部署深度学习推理

            本文是基于 qt和opencv的dnn 深度学习推理模块,在树莓派上部署YOLO系列推理,适用于yolov5-6.1以及yolov5-Lite,相比直接用python的onnxruntime,用基于opencv的dnn模块,利用训练生成的onnx模型,即可快速部署,不需要在树莓派上额外安装深度学习的一系列环境,因为我们知道

    2024年04月16日
    浏览(65)
  • yolov7-论文深度解析

    yolov7自提出便号称在速度和精度方面超过了所有的目标检测器,并能够同时支持边缘设备到云端的移动GPU和GPU设备,而yolov7则具有以下优势: 1、更高的检测精度:相较于其前身 YOLOv5,YOLOv7 在保持速度优势的同时,通过改进骨干网络和特征融合方法等方式,进一步提升了检测

    2024年02月08日
    浏览(40)
  • python使用onnx模型进行推理

    我们可以看到基于YoloV7训练的cfg有两种yaml文件,一个是training文件夹,一个是deploy文件夹,这两种文件夹有啥不一样呢??? 大家可以看下下面别人的issuse,,记住这个很关键,就是你选择哪个yaml训练对你后面导出的onnx是很关键的,后面我们会说到。 1、training中的yaml文件

    2024年02月12日
    浏览(52)
  • 【深度学习】RTX2060 2080如何安装CUDA,如何使用onnx runtime

    RTX 2060虽然是一款较早的显卡型号,但仍然广泛使用。对于Python开发者来说,配置CUDA 10是非常关键的,尤其是在深度学习和GPU加速计算任务中。本文将为你提供一个详细的配置指南。 首先,确保你已经安装了最新版本的NVIDIA显卡驱动。你可以通过访问NVIDIA官方网站来下载和安

    2024年01月17日
    浏览(41)
  • 【ONNX】使用 C++ 调用 ONNX 格式的 PyTorch 深度学习模型进行预测(Windows, C++, PyTorch, ONNX, Visual Studio, OpenCV)

    要使用 ONNX 模型进行预测,就需要使用 onnx runtime 首先到 ONNX 官网查询所需的版本 这里使用的 Windows,同时装了 CUDA 下面的链接可以进入到安装网址 https://www.nuget.org/packages/Microsoft.ML.OnnxRuntime.Gpu 安装命令为: 首先打开 Visual Studio 2019 新建一个用于测试的项目 右键点击项目,可

    2024年02月09日
    浏览(59)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包