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

yolov8-obb训练自己的数据集（标注，训练，推理，转化模型 + C#模型部署）_yoloobb

作者：酷酷是懒虫 | 2024-08-12 02:57:50

赞

踩

yoloobb

一、源码

直接去下载官方的yolov8源码就行，那里面集成了 obb

ultralytics/ultralytics/cfg/models/v8 at main · ultralytics/ultralytics · GitHub

二、环境

 如果你训练过yolov5以及以上的yolo环境，可以直接拷贝一个用就行，如果没有的话  直接pip

pip install requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

可以配置cuda，跑的比较快

三、标注

标注方法有两种，一中是下载标注工具   X-Anylabeling

GitHub - CVHub520/X-AnyLabeling: Effortless data labeling with AI support from Segment Anything and other awesome models.

方法可以看我博客 

X-AnyLabeling标注软件安装及使用dota数据集，voc数据集，coco数据集。以及报错No module named‘anylabeling‘的解决_x-anylabeling-cpu 导出 dota 没数据-CSDN博客

不过上面那种标注方式我训练时总是报错 一直找不到原因，有知道的可以指教指教

另一种标注方式

用rolabelimg旋转标注软件 

GitHub - cgvict/roLabelImg: Label Rotated Rect On Images for training

      旋转标注工具roLabelImg使用教程-CSDN博客

配置完环境后 直接右键运行  roLabelImg.py文件

可以用旋转标注  标注后点击 标注的框   用  z,x,c,v  来更改 角度

生成的是xml文件

需要转换成dota能用的obb的txt文件

转换脚本

  1. # 文件名称   ：roxml_to_dota.py
  2. # 功能描述   ：把rolabelimg标注的xml文件转换成dota能识别的xml文件，
  3. #             再转换成dota格式的txt文件
  4. #            把旋转框 cx,cy,w,h,angle，或者矩形框cx,cy,w,h,转换成四点坐标x1,y1,x2,y2,x3,y3,x4,y4
  5. import os
  6. import xml.etree.ElementTree as ET
  7. import math
  8.  
  9. cls_list = ['angle']  # 修改为自己的标签
  10.  
  11.  
  12. def edit_xml(xml_file, dotaxml_file):
  13.     """
  14.     修改xml文件
  15.     :param xml_file:xml文件的路径
  16.     :return:
  17.     """
  18.  
  19.     # dxml_file = open(xml_file,encoding='gbk')
  20.     # tree = ET.parse(dxml_file).getroot()
  21.  
  22.     tree = ET.parse(xml_file)
  23.     objs = tree.findall('object')
  24.     for ix, obj in enumerate(objs):
  25.         x0 = ET.Element("x0")  # 创建节点
  26.         y0 = ET.Element("y0")
  27.         x1 = ET.Element("x1")
  28.         y1 = ET.Element("y1")
  29.         x2 = ET.Element("x2")
  30.         y2 = ET.Element("y2")
  31.         x3 = ET.Element("x3")
  32.         y3 = ET.Element("y3")
  33.         # obj_type = obj.find('bndbox')
  34.         # type = obj_type.text
  35.         # print(xml_file)
  36.  
  37.         if (obj.find('robndbox') == None):
  38.             obj_bnd = obj.find('bndbox')
  39.             obj_xmin = obj_bnd.find('xmin')
  40.             obj_ymin = obj_bnd.find('ymin')
  41.             obj_xmax = obj_bnd.find('xmax')
  42.             obj_ymax = obj_bnd.find('ymax')
  43.             # 以防有负值坐标
  44.             xmin = max(float(obj_xmin.text), 0)
  45.             ymin = max(float(obj_ymin.text), 0)
  46.             xmax = max(float(obj_xmax.text), 0)
  47.             ymax = max(float(obj_ymax.text), 0)
  48.             obj_bnd.remove(obj_xmin)  # 删除节点
  49.             obj_bnd.remove(obj_ymin)
  50.             obj_bnd.remove(obj_xmax)
  51.             obj_bnd.remove(obj_ymax)
  52.             x0.text = str(xmin)
  53.             y0.text = str(ymax)
  54.             x1.text = str(xmax)
  55.             y1.text = str(ymax)
  56.             x2.text = str(xmax)
  57.             y2.text = str(ymin)
  58.             x3.text = str(xmin)
  59.             y3.text = str(ymin)
  60.         else:
  61.             obj_bnd = obj.find('robndbox')
  62.             obj_bnd.tag = 'bndbox'  # 修改节点名
  63.             obj_cx = obj_bnd.find('cx')
  64.             obj_cy = obj_bnd.find('cy')
  65.             obj_w = obj_bnd.find('w')
  66.             obj_h = obj_bnd.find('h')
  67.             obj_angle = obj_bnd.find('angle')
  68.             cx = float(obj_cx.text)
  69.             cy = float(obj_cy.text)
  70.             w = float(obj_w.text)
  71.             h = float(obj_h.text)
  72.             angle = float(obj_angle.text)
  73.             obj_bnd.remove(obj_cx)  # 删除节点
  74.             obj_bnd.remove(obj_cy)
  75.             obj_bnd.remove(obj_w)
  76.             obj_bnd.remove(obj_h)
  77.             obj_bnd.remove(obj_angle)
  78.  
  79.             x0.text, y0.text = rotatePoint(cx, cy, cx - w / 2, cy - h / 2, -angle)
  80.             x1.text, y1.text = rotatePoint(cx, cy, cx + w / 2, cy - h / 2, -angle)
  81.             x2.text, y2.text = rotatePoint(cx, cy, cx + w / 2, cy + h / 2, -angle)
  82.             x3.text, y3.text = rotatePoint(cx, cy, cx - w / 2, cy + h / 2, -angle)
  83.  
  84.         # obj.remove(obj_type)  # 删除节点
  85.         obj_bnd.append(x0)  # 新增节点
  86.         obj_bnd.append(y0)
  87.         obj_bnd.append(x1)
  88.         obj_bnd.append(y1)
  89.         obj_bnd.append(x2)
  90.         obj_bnd.append(y2)
  91.         obj_bnd.append(x3)
  92.         obj_bnd.append(y3)
  93.  
  94.         tree.write(dotaxml_file, method='xml', encoding='utf-8')  # 更新xml文件
  95.  
  96.  
  97. # 转换成四点坐标
  98. def rotatePoint(xc, yc, xp, yp, theta):
  99.     xoff = xp - xc;
  100.     yoff = yp - yc;
  101.     cosTheta = math.cos(theta)
  102.     sinTheta = math.sin(theta)
  103.     pResx = cosTheta * xoff + sinTheta * yoff
  104.     pResy = - sinTheta * xoff + cosTheta * yoff
  105.     return str(int(xc + pResx)), str(int(yc + pResy))
  106.  
  107.  
  108. def totxt(xml_path, out_path):
  109.     # 想要生成的txt文件保存的路径，这里可以自己修改
  110.  
  111.     files = os.listdir(xml_path)
  112.     i = 0
  113.     for file in files:
  114.  
  115.         tree = ET.parse(xml_path + os.sep + file)
  116.         root = tree.getroot()
  117.  
  118.         name = file.split('.')[0]
  119.  
  120.         output = out_path + '\\' + name + '.txt'
  121.         file = open(output, 'w')
  122.         i = i + 1
  123.         objs = tree.findall('object')
  124.         for obj in objs:
  125.             cls = obj.find('name').text
  126.             box = obj.find('bndbox')
  127.             x0 = int(float(box.find('x0').text))
  128.             y0 = int(float(box.find('y0').text))
  129.             x1 = int(float(box.find('x1').text))
  130.             y1 = int(float(box.find('y1').text))
  131.             x2 = int(float(box.find('x2').text))
  132.             y2 = int(float(box.find('y2').text))
  133.             x3 = int(float(box.find('x3').text))
  134.             y3 = int(float(box.find('y3').text))
  135.             if x0 < 0:
  136.                 x0 = 0
  137.             if x1 < 0:
  138.                 x1 = 0
  139.             if x2 < 0:
  140.                 x2 = 0
  141.             if x3 < 0:
  142.                 x3 = 0
  143.             if y0 < 0:
  144.                 y0 = 0
  145.             if y1 < 0:
  146.                 y1 = 0
  147.             if y2 < 0:
  148.                 y2 = 0
  149.             if y3 < 0:
  150.                 y3 = 0
  151.             for cls_index, cls_name in enumerate(cls_list):
  152.                 if cls == cls_name:
  153.                     file.write("{} {} {} {} {} {} {} {} {} {}\n".format(x0, y0, x1, y1, x2, y2, x3, y3, cls, cls_index))
  154.         file.close()
  155.         # print(output)
  156.         print(i)
  157.  
  158.  
  159. if __name__ == '__main__':
  160.     # -----**** 第一步：把xml文件统一转换成旋转框的xml文件 ****-----
  161.     roxml_path = r'H:\DL\YOLOv8_OBB_main\dataset_set\angle\1'
  162.     dotaxml_path = r'H:\DL\YOLOv8_OBB_main\dataset_set\angle\2'
  163.     out_path = r'H:\DL\YOLOv8_OBB_main\dataset_set\angle\4'
  164.     filelist = os.listdir(roxml_path)
  165.     for file in filelist:
  166.         edit_xml(os.path.join(roxml_path, file), os.path.join(dotaxml_path, file))
  167.  
  168.     # -----**** 第二步：把旋转框xml文件转换成txt格式 ****-----
  169.     totxt(dotaxml_path, out_path)

转换后是如下的样子

但是这还没完，还需要再次转换一下

打开你的数据集中的标签文件夹，新建两个文档 名称如下

然后 复制你文件夹路径，不是图片    也不是标签  

用obb中自带的转换脚本进行转换 那个路径是你数据集的路径

  1. from ultralytics.data.converter import convert_dota_to_yolo_obb
  2.  
  3. convert_dota_to_yolo_obb(r'H:\DL\YOLOv8_OBB_main\dataset_set\angle\00')

然后再按照ctrl+左键定位 这个函数  convert_dota_to_yolo_obb  直接可以定位到 converter.py 文件中

拉到大约376行修改你标注的标签名和数量

还有修改大约420行左右的地方  将这里改成你图片的后缀，不然就没有效果

然后你运行上方那个自带的转换代码，标签文件中会生成train和val两个文件夹

转换成功的txt如下，这就可以训练

配置好yolov8obb的环境和yaml文件，就可以训练了

训练

可以直接写新建一个py文件，train.py

  1. from ultralytics import YOLO
  2.  
  3. model_yaml_path = r"H:\DL\YOLOv8_OBB_main\ultralytics\cfg\models\v8\yolov8-obb.yaml"
  4. #数据集配置文件
  5. data_yaml_path = 'data/hat.yaml'
  6. #预训练模型
  7. pre_model_name = 'yolov8s-obb.pt'
  8.  
  9. def main():
  10.     model = YOLO(model_yaml_path).load(pre_model_name)  # build from YAML and transfer weights
  11.  
  12.     model.train(data=data_yaml_path,
  13.                 epochs=500,
  14.                 imgsz=640,
  15.                 batch=6,
  16.                 workers=5,
  17.                 name="train_obb/exp")
  18.  
  19. if __name__ == '__main__':
  20.     main()
  21.  
  22. # yolo obb train data=data/hat.yaml model=yolov8s-obb.pt epochs=200 imgsz=640 device=0

 detect.py 推理

  1. from ultralytics import YOLO
  2.  
  3. # Load a model
  4. # model = YOLO("yolov8n-obb.pt")  # load an official model
  5. model = YOLO(r"H:\DL\YOLOv8_OBB_main\runs\obb\train_obb\exp4\weights\best.pt")  # load a custom model
  6.  
  7. # Predict with the model
  8. results = model(r"C:\Users\Administrator\Desktop\gule\test",
  9.                 name="detect_obb/exp",
  10.                 conf=0.45,
  11.                 save=True,
  12.                 device='0'
  13.                 )  # predict on an image

模型转换  脚本代码

  1. from ultralytics import YOLO
  2.  
  3. model=YOLO(r"H:\DL\YOLOv8_OBB_main\runs\obb\train_obb\exp16\weights\best.pt")
  4.  
  5. model.export(format='onnx',device='0')

四、模型部署 C#

依旧是大佬的源码修改 https://github.com/guojin-yan/YoloDeployCsharp.git

 

然后缺哪种包 直接在nuget中下载就好

运行后如下

当然你也可以将其中的一个或者两个取出 进行封装为dll

创建class.cs文件  定义自己所需的nms  置信度  和 类别数量以及类别名

然后生成自己的dll 并且引到你的程序中

然后运行程序就可以了

有问题可以在评论区问或者私信我！！

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

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

  

闽ICP备14008679号