RT-DETR目标检测onnxruntime和tensorrt推理

原创 已于 2024-12-12 09:27:43 修改 · 721 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#目标检测 #人工智能 #计算机视觉 #rt-detr

于 2024-10-15 23:45:46 首次发布

使用ultralytics 工程（https://github.com/ultralytics/ultralytics）导出onnx模型：

from ultralytics import RTDETR

# Load a model
model = RTDETR("rtdetr-l.pt")

# Export the model
model.export(format="onnx")
model.export(format="engine")

模型结构如下：
在这里插入图片描述

onnxruntime推理

import cv2
import math
import numpy as np
import onnxruntime


class_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'] #coco80类别 
input_shape = (640, 640) 
score_threshold = 0.5 
nms_threshold = 0.5


def nms(boxes, scores, score_threshold, nms_threshold):
    x1 = boxes[:, 0]
    y1 = boxes[:, 1]
    x2 = boxes[:, 2]
    y2 = boxes[:, 3]
    areas = (y2 - y1 + 1) * (x2 - x1 + 1)
    keep = []
    index = scores.argsort()[::-1] 

    while index.size > 0:
        i = index[0]
        keep.append(i)
        x11 = np.maximum(x1[i], x1[index[1:]]) 
        y11 = np.maximum(y1[i], y1[index[1:]])
        x22 = np.minimum(x2[i], x2[index[1:]])
        y22 = np.minimum(y2[i], y2[index[1:]])
        w = np.maximum(0, x22 - x11 + 1)                              
        h = np.maximum(0, y22 - y11 + 1) 
        overlaps = w * h
        ious = overlaps / (areas[i] + areas[index[1:]] - overlaps)
        idx = np.where(ious <= nms_threshold)[0]
        index = index[idx + 1]
    return keep


def xywh2xyxy(x):
    y = np.copy(x)
    y[:, 0] = x[:, 0] - x[:, 2] / 2
    y[:, 1] = x[:, 1] - x[:, 3] / 2
    y[:, 2] = x[:, 0] + x[:, 2] / 2
    y[:, 3] = x[:, 1] + x[:, 3] / 2
    return y


def filter_box(output): #过滤掉无用的框    
    output = np.squeeze(output)
     
    boxes = []
    scores = []
    class_ids = []    
    output = output[output[..., 4] > score_threshold] 
    for i in range(output.shape[0]):
        boxes.append(output[i, :6])
        scores.append(output[i][4])
        class_ids.append(output[i][5])  
            
    boxes = np.array(boxes)
    boxes = xywh2xyxy(boxes)
    boxes[..., [0, 2]] *= input_shape[0]
    boxes[..., [1, 3]] *= input_shape[1]
    return boxes


def letterbox(im, new_shape=(416, 416), color=(114, 114, 114)):
    # Resize and pad image while meeting stride-multiple constraints
    shape = im.shape[:2]  # current shape [height, width]

    # Scale ratio (new / old)
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
    
    # Compute padding
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))    
    dw, dh = (new_shape[1] - new_unpad[0])/2, (new_shape[0] - new_unpad[1])/2  # wh padding 
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
    
    if shape[::-1] != new_unpad:  # resize
        im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
    im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # add border
    return im


def scale_boxes(boxes, output_shape):
    # Rescale boxes (xyxy) from self.input_shape to shape
    gain = min(input_shape[0] / output_shape[0], input_shape[1] / output_shape[1])  # gain  = old / new
    pad = (input_shape[1] - output_shape[1] * gain) / 2, (input_shape[0] - output_shape[0] * gain) / 2  # wh padding
    boxes[..., [0, 2]] -= pad[0]  # x padding
    boxes[..., [1, 3]] -= pad[1]  # y padding
    boxes[..., :4] /= gain
    boxes[..., [0, 2]] = boxes[..., [0, 2]].clip(0, output_shape[1])  # x1, x2
    boxes[..., [1, 3]] = boxes[..., [1, 3]].clip(0, output_shape[0])  # y1, y2
    return boxes


def draw(image, box_data):
    box_data = scale_boxes(box_data, image.shape)
    boxes = box_data[...,:4].astype(np.int32) 
    scores = box_data[...,4]
    classes = box_data[...,5].astype(np.int32)
   
    for box, score, cl in zip(boxes, scores, classes):
        top, left, right, bottom = box
        cv2.rectangle(image, (top, left), (right, bottom), (255, 0, 0), 1)
        cv2.putText(image, '{0} {1:.2f}'.format(class_names[cl], score), (top, left), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1)


if __name__=="__main__":
    image = cv2.imread('bus.jpg', -1)
    input = letterbox(image, input_shape)
    input = input[:, :, ::-1].transpose(2, 0, 1).astype(dtype=np.float32)  #BGR2RGB和HWC2CHW
    input = input / 255.0
    input_tensor = []
    input_tensor.append(input)
    
    onnx_session = onnxruntime.InferenceSession('rtdetr-l.onnx', providers=['CPUExecutionProvider', 'CUDAExecutionProvider'])
        
    input_name = []
    for node in onnx_session.get_inputs():
        input_name.append(node.name)

    output_name = []
    for node in onnx_session.get_outputs():
        output_name.append(node.name)

    inputs = {}
    for name in input_name:
        inputs[name] =  np.array(input_tensor)
  
    outputs = onnx_session.run(None, inputs)[0]
    
    boxes = filter_box(outputs)
    draw(image, boxes)
    cv2.imwrite('result.jpg', image)

tensorrt推理

import cv2
import math
import numpy as np
import tensorrt as trt
import pycuda.autoinit 
import pycuda.driver as cuda 


class_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'] #coco80类别 
input_shape = (640, 640) 
score_threshold = 0.5 
nms_threshold = 0.5


def nms(boxes, scores, score_threshold, nms_threshold):
    x1 = boxes[:, 0]
    y1 = boxes[:, 1]
    x2 = boxes[:, 2]
    y2 = boxes[:, 3]
    areas = (y2 - y1 + 1) * (x2 - x1 + 1)
    keep = []
    index = scores.argsort()[::-1] 

    while index.size > 0:
        i = index[0]
        keep.append(i)
        x11 = np.maximum(x1[i], x1[index[1:]]) 
        y11 = np.maximum(y1[i], y1[index[1:]])
        x22 = np.minimum(x2[i], x2[index[1:]])
        y22 = np.minimum(y2[i], y2[index[1:]])
        w = np.maximum(0, x22 - x11 + 1)                              
        h = np.maximum(0, y22 - y11 + 1) 
        overlaps = w * h
        ious = overlaps / (areas[i] + areas[index[1:]] - overlaps)
        idx = np.where(ious <= nms_threshold)[0]
        index = index[idx + 1]
    return keep


def xywh2xyxy(x):
    y = np.copy(x)
    y[:, 0] = x[:, 0] - x[:, 2] / 2
    y[:, 1] = x[:, 1] - x[:, 3] / 2
    y[:, 2] = x[:, 0] + x[:, 2] / 2
    y[:, 3] = x[:, 1] + x[:, 3] / 2
    return y


def filter_box(output): #过滤掉无用的框    
    output = np.squeeze(output)
     
    boxes = []
    scores = []
    class_ids = []    
    output = output[output[..., 4] > score_threshold] 
    for i in range(output.shape[0]):
        boxes.append(output[i, :6])
        scores.append(output[i][4])
        class_ids.append(output[i][5])  
            
    boxes = np.array(boxes)
    boxes = xywh2xyxy(boxes)
    boxes[..., [0, 2]] *= input_shape[0]
    boxes[..., [1, 3]] *= input_shape[1]
    return boxes

def letterbox(im, new_shape=(416, 416), color=(114, 114, 114)):
    # Resize and pad image while meeting stride-multiple constraints
    shape = im.shape[:2]  # current shape [height, width]

    # Scale ratio (new / old)
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
    
    # Compute padding
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))    
    dw, dh = (new_shape[1] - new_unpad[0])/2, (new_shape[0] - new_unpad[1])/2  # wh padding 
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
    
    if shape[::-1] != new_unpad:  # resize
        im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
    im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # add border
    return im


def scale_boxes(boxes, output_shape):
    # Rescale boxes (xyxy) from self.input_shape to shape
    gain = min(input_shape[0] / output_shape[0], input_shape[1] / output_shape[1])  # gain  = old / new
    pad = (input_shape[1] - output_shape[1] * gain) / 2, (input_shape[0] - output_shape[0] * gain) / 2  # wh padding
    boxes[..., [0, 2]] -= pad[0]  # x padding
    boxes[..., [1, 3]] -= pad[1]  # y padding
    boxes[..., :4] /= gain
    boxes[..., [0, 2]] = boxes[..., [0, 2]].clip(0, output_shape[1])  # x1, x2
    boxes[..., [1, 3]] = boxes[..., [1, 3]].clip(0, output_shape[0])  # y1, y2
    return boxes


def draw(image, box_data):
    box_data = scale_boxes(box_data, image.shape)
    boxes = box_data[...,:4].astype(np.int32) 
    scores = box_data[...,4]
    classes = box_data[...,5].astype(np.int32)
   
    for box, score, cl in zip(boxes, scores, classes):
        top, left, right, bottom = box
        cv2.rectangle(image, (top, left), (right, bottom), (255, 0, 0), 1)
        cv2.putText(image, '{0} {1:.2f}'.format(class_names[cl], score), (top, left), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1)


if __name__=="__main__":
    logger = trt.Logger(trt.Logger.WARNING)
    with open("rtdetr-l.engine", "rb") as f, trt.Runtime(logger) as runtime:
        engine = runtime.deserialize_cuda_engine(f.read())
    context = engine.create_execution_context()
    inputs_host = cuda.pagelocked_empty(trt.volume(context.get_binding_shape(0)), dtype=np.float32)
    outputs_host = cuda.pagelocked_empty(trt.volume(context.get_binding_shape(1)), dtype=np.float32)
    inputs_device = cuda.mem_alloc(inputs_host.nbytes)
    outputs_device = cuda.mem_alloc(outputs_host.nbytes)
    stream = cuda.Stream()
    
    image = cv2.imread('bus.jpg', -1)
    input = letterbox(image, input_shape)
    input = input[:, :, ::-1].transpose(2, 0, 1).astype(dtype=np.float32)  #BGR2RGB和HWC2CHW
    input = input / 255.0
    input = np.expand_dims(input, axis=0)     
    np.copyto(inputs_host, input.ravel())

    with engine.create_execution_context() as context:
        cuda.memcpy_htod_async(inputs_device, inputs_host, stream)
        context.execute_async_v2(bindings=[int(inputs_device), int(outputs_device)], stream_handle=stream.handle)
        cuda.memcpy_dtoh_async(outputs_host, outputs_device, stream)
        stream.synchronize()  
        boxes = filter_box(outputs_host.reshape(context.get_binding_shape(1)))
        draw(image, boxes)
        cv2.imwrite('result.jpg', image)

在这里插入图片描述

详解RT-DETR网络结构/数据集获取/环境搭建/训练/推理/验证/导出/部署
Snu77的博客
11-27 4万+
本文给大家带来是利用RT-DETR模训练自己的数据集，RT-DETR是一种新提出的目标检测模型，它利用的自注意力机制来处理图像数据。不同于YOLO通过连续的卷积层直接对图像区域进行分析，RT-DETR采用Transformer架构中的自注意力机制，这允许模型更有效地理解图像中不同部分之间的关系。这种方法使得RT-DETR在处理图像中的复杂场景和多对象环境时，能够展现出更高的准确性和效率。此外，RT-DETR在保持高精度的同时，也针对实时处理进行了优化，使其适合需要快速响应的应用场景。
基于RT-DETR的YOLOv8目标检测框架优化及其应用前景
shrgegrb的博客
02-28 1100
RT-DETR是一个创新的目标检测框架，它结合了Transformer架构和传统的区域卷积特征提取策略。该方法的核心思想是利用Transformers的强大建模能力，来精确地捕捉图像中各个目标之间的空间关系，并通过高效的区域编码进一步提高检测精度。RT-DETR通过改进的变换器结构，突破了DETR（Detection Transformer）中传统的全局查询问题，提升了检测的性能和效率。
RT-DETR训练好的pth导出为onnx模型报错记录
Nelson_hehe的博客
11-19 513
本文记录了一次导出训练模型.onnx的报错及处理方法。
ultralytics框架进行RT-DETR目标检测训练
最新发布
pengxiang1998的博客
05-06 1024
自DETR提出以来，其采用匈牙利匹配方式真正的实现了端到端检测效果，避免了NMS等后处理过程，同时，相较CNN的局部特征提取，其凭借着强大的全局特征提取能力，在目标检测领域可谓大杀四方，基于的目标检测方法因此层出不穷。然后，尽管DETR类目标检测方法具有较好的数据拟合能力，但本身的计算复杂度较高，这使其很难完成实时检测任务，而今天我们则要介绍的便是百度提出的实时DETR目标检测方法，这个方法我已经在先前的博客中有过介绍，当时是基于RT-DETR的源码进行介绍的，今天我们则要介绍的是中的RT-DETR模型。
RT-DETR模型导出与推理
weixin_53895623的博客
12-21 2534
本文介绍将RT-DETR的模型训练结果导出为onnx权重文件，并利用该权重文件进行模型推理。
官方pytorch版本RT_DETR训练自己的数据集过程并导出结果
TracyGC的博客
12-08 3752
rtdetr_pytorch/configs/dataset/coco_detection.yml"里面把文件地址修改成自己的数据集地址，配制成my_coco.yml,同时修改需要训练"rtdetr_pytorch/configs/rtder/rtdetr_r50vd_m_6x_coco.yml"里面的数据集。然后利用"RT-DETR-main/rtdetr_pytorch/tools/train.py，记得加入configs。在前面的步骤中，利用配置好的。
YOLO系列和RT-DETR转onnx和tensorrt，测FPS
weixin_45734021的博客
08-31 2599
YOLO系列和RT-DETR转onnx和tensorrt，测FPS
RT-DETR目标检测项目部署指南：C++与Python结合ONNXRuntime
资源摘要信息: "基于C++和Python使用ONNXRuntime部署RT-DETR目标检测源码+详细项目说明.zip" 本资源包提供了使用C++和Python语言结合ONNXRuntime进行RT-DETR模型的目标检测部署的源码以及详细项目说明。RT-DETR是一...
RT-DETR改进策略【模型轻量化】| 替换骨干网络为 GhostNet V3 2024华为的重参数轻量化模型
Limiiiing的博客
01-21 424
本文记录的是基于 GhostNetV3 的 RT-DETR轻量化改进方法研究。GhostNetV3的轻量模块采用方法，训练时为深度可分离卷积和1×1卷积添加，推理时通过移除分支、折叠操作，能够在不增加推理成本的同时提高性能，从而实现RT-DETR的轻量化改进。
首次尝试RT-DETR：一种实时印刷电路板（PCB）缺陷检测方法
sybh的博客
06-23 930
RT-DETR，即实时对象检测与追踪系统（Real-Time Detection and Tracking System），是一款基于视觉变换器（ViT）模型的全新深度学习算法。该模型的目标是实时检测并追踪各种环境中的潜在风险，并通过预警提高工作人员的安全性。本文利用RT-DETR-R101在工业缺陷检测数据集上进行模型的训练验证与推理部署，通过100轮的训练模型的map为0.46，V100环境下average FPS: 18.4，实现了又快又好的效果。
RT-DETR改进策略【Backbone/主干网络】| CVPR 2024 替换骨干网络为 RMT，增强空间信息的感知能力
Limiiiing的博客
01-22 658
RMT模型是一种具有显式空间先验的视觉骨干网络，旨在解决中自注意力机制存在的问题。
RT-DETR~onnxruntime部署
whaosoft143ai的博客
12-30 2071
在上一篇文章《AI模型部署 | onnxruntime部署YOLOv8分割模型详细教程》中我介绍了如何使用onnxruntime框架来部署。每个目标的坐标信息都是做了归一化的，只要乘以原始图像的尺寸就可以把坐标恢复到在原始图像中的大小。前面我们打印了模型的输入输出属性，可以知道模型只有一个输出分支，所以只要取。工具对模型进行简化，否则生成的模型有一大堆零碎的算子，看起来就很麻烦。从上面的打印信息可以知道，模型有一个尺寸为。下载使用，本文使用的模型为。从前文知道模型输出的维度为。，那么导出模型的时候会把。
ultralytics版本的RT-DETR的FLOPs计算
m0_73659233的博客
12-23 1313
官方论文上的 FLOPs 和 Params 分别是 110 GFLOPs 和 32 M，两者存在一定差距，但是很接近了。ultralytics版本的 RT-DETR 无法打印 FLOPs。
rtdetr的onnx推理
weixin_62918638的博客
04-15 166
【代码】rtdetr的onnx推理。
[转]RT-DETR推理详解及部署实现-优快云博客
chinagudujian的专栏
01-04 4896
是由 Baidu 提出的基于 transformer 的端到端实时检测器，本篇文章主要分享博主在实现 RT-DETR 推理和部署时做的一些尝试，不涉及任何的原理性分析。若有问题欢迎各位看官批评指正😄博主在这里针对 RT-DETR 的预处理和后处理做了简单分析，同时与大家分享了 C++ 上的实现流程，目的是帮大家理清思路，更好的完成后续的部署工作😄。
【使用YOLOv8下的RT-DETR训练自己的数据集】
weixin_44574971的博客
08-22 2519
对疟原虫细胞医学显微图像进行目标检测，使用RT-DETR对其进行检测训练，将原数据集分为训练集和验证集，测试集有单独的样本（不纳入训练）
YOLOv8训练和断点续训——使用python命令
m0_74424344的博客
12-23 2038
通过上面的方式就可以实现YOLOv8模型的训练和断点续训了。训练过程中如果中断了训练可以换用下面方式从断点处重新训练。
ultralytics中rtdetr的.pt模型转onnx
liugan528的博客
01-01 446
ultralytics中rtdetr的.pt模型转onnx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

给算法爸爸上香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值