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

yolov5训练记录（使用矩池云服务器）_矩池云训练yolo

作者：我家自动化 | 2024-03-29 23:26:06

赞

踩

矩池云训练yolo
1、数据集准备

我用的是开源的自动驾驶数据集BDD100K，数据集中包含train，val和test的image和label，其中label是json格式的。

yolo使用的label是txt格式的，所以需要先将json格式转换成txt格式。有多种方式可以转换：第一次训练的时候我用的是先将json转换成xml，再将xml转换成txt，这种方式我没找到怎么进行数据清洗的方法；第二次训练的时候我用的是直接将json转换成txt，这种方式可以在里面添加一些函数用于过滤掉黑夜和过于小的目标的图片，进行数据清洗。

第一次训练的时候分了10个类：

第二次训练的时候分了3个类：

这是json转xml的代码：

  1. # jsonToXml
  2. import os
  3. import json
  4. import sys
  5. from xml.etree import ElementTree
  6. from xml.etree.ElementTree import Element, SubElement
  7. from lxml import etree
  8. from xml.dom.minidom import parseString
  9.  
  10. # 数据集个类别
  11. categorys = ['car', 'bus', 'person', 'bike', 'truck', 'motor', 'train', 'rider', 'traffic sign', 'traffic light']
  12.  
  13.  
  14. def parseJson(jsonFile):
  15.     '''
  16.       params:
  17.         jsonFile -- BDD00K数据集的一个json标签文件
  18.       return:
  19.         返回一个列表的列表，存储了一个json文件里面的方框坐标及其所属的类，
  20.         形如：[[325, 342, 376, 384, 'car'], [245, 333, 336, 389, 'car']]
  21.     '''
  22.     objs = []
  23.     obj = []
  24.     f = open(jsonFile)
  25.     info = json.load(f)
  26.     objects = info['frames'][0]['objects']
  27.     for i in objects:
  28.         if (i['category'] in categorys):
  29.             obj.append(int(i['box2d']['x1']))
  30.             obj.append(int(i['box2d']['y1']))
  31.             obj.append(int(i['box2d']['x2']))
  32.             obj.append(int(i['box2d']['y2']))
  33.             obj.append(i['category'])
  34.             objs.append(obj)
  35.             obj = []
  36.     # print("objs",objs)
  37.     return objs
  38.  
  39.  
  40. class PascalVocWriter:
  41.  
  42.     def __init__(self, foldername, filename, imgSize, databaseSrc='Unknown', localImgPath=None):
  43.         '''
  44.         params:
  45.           foldername -- 要存储的xml文件的父目录
  46.           filename -- xml文件的文件名
  47.           imgSize -- 图片的尺寸
  48.           databaseSrc -- 数据库名，这里不需要，默认为Unknown
  49.           localImaPath -- xml文件里面的<path></path>标签的内容
  50.       '''
  51.         self.foldername = foldername
  52.         self.filename = filename
  53.         self.databaseSrc = databaseSrc
  54.         self.imgSize = imgSize
  55.         self.boxlist = []
  56.         self.localImgPath = localImgPath
  57.  
  58.     def prettify(self, elem):
  59.         """
  60.         params:
  61.           elem -- xml的根标签，以<annotation>开始
  62.         return:
  63.           返回一个美观输出的xml（用到minidom），本质是一个str
  64.         """
  65.         xml = ElementTree.tostring(elem)
  66.         dom = parseString(xml)
  67.         #        print(dom.toprettyxml('  '))
  68.         prettifyResult = dom.toprettyxml('    ')
  69.         return prettifyResult
  70.  
  71.     def genXML(self):
  72.         """
  73.         return:
  74.           生成一个VOC格式的xml，返回一个xml的根标签，以<annotation>开始
  75.         """
  76.         # Check conditions
  77.         if self.filename is None or \
  78.                 self.foldername is None or \
  79.                 self.imgSize is None or \
  80.                 len(self.boxlist) <= 0:
  81.             return None
  82.  
  83.         top = Element('annotation')  # 创建一个根标签<annotation>
  84.         folder = SubElement(top, 'folder')  # 在根标签<annotation>下创建一个子标签<folder>
  85.         folder.text = self.foldername  # 用self.foldername的数据填充子标签<folder>
  86.  
  87.         filename = SubElement(top, 'filename')  # 在根标签<annotation>下创建一个子标签<filename>
  88.         filename.text = self.filename  # 用self.filename的数据填充子标签<filename>
  89.  
  90.         localImgPath = SubElement(top, 'path')  # 在根标签<annotation>下创建一个子标签<path>
  91.         localImgPath.text = self.localImgPath  # 用self.localImgPath的数据填充子标签<path>
  92.  
  93.         source = SubElement(top, 'source')  # 在根标签<annotation>下创建一个子标签<source>
  94.         database = SubElement(source, 'database')  # 在根标签<source>下创建一个子标签<database>
  95.         database.text = self.databaseSrc  # 用self.databaseSrc的数据填充子标签<database>
  96.  
  97.         size_part = SubElement(top, 'size')  # 在根标签<annotation>下创建一个子标签<size>
  98.         width = SubElement(size_part, 'width')  # 在根标签<size>下创建一个子标签<width>
  99.         height = SubElement(size_part, 'height')  # 在根标签<size>下创建一个子标签<height>
  100.         depth = SubElement(size_part, 'depth')  # 在根标签<size>下创建一个子标签<depth>
  101.         width.text = str(self.imgSize[1])  # 用self.imgSize[1]的数据填充子标签<width>
  102.         height.text = str(self.imgSize[0])  # 用self.imgSize[0]的数据填充子标签<height>
  103.         if len(self.imgSize) == 3:  # 如果图片深度为3，则用self.imgSize[2]的数据填充子标签<height>，否则用1填充
  104.             depth.text = str(self.imgSize[2])
  105.         else:
  106.             depth.text = '1'
  107.  
  108.         segmented = SubElement(top, 'segmented')
  109.         segmented.text = '0'
  110.         return top
  111.  
  112.     def addBndBox(self, xmin, ymin, xmax, ymax, name):
  113.         '''
  114.         将检测对象框坐标及其对象类别作为一个字典加入到self.boxlist中
  115.         params:
  116.           xmin -- 检测框的左上角的x坐标
  117.           ymin -- 检测框的左上角的y坐标
  118.           xmax -- 检测框的右下角的x坐标
  119.           ymax -- 检测框的右下角的y坐标
  120.           name -- 检测框内的对象类别名
  121.         '''
  122.         bndbox = {'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax}
  123.         bndbox['name'] = name
  124.         self.boxlist.append(bndbox)
  125.  
  126.     def appendObjects(self, top):
  127.         '''
  128.         在xml文件中加入检测框的坐标及其对象类别名
  129.         params:
  130.           top -- xml的根标签，以<annotation>开始
  131.         '''
  132.         for each_object in self.boxlist:
  133.             object_item = SubElement(top, 'object')
  134.             name = SubElement(object_item, 'name')
  135.             name.text = str(each_object['name'])
  136.             pose = SubElement(object_item, 'pose')
  137.             pose.text = "Unspecified"
  138.             truncated = SubElement(object_item, 'truncated')
  139.             truncated.text = "0"
  140.             difficult = SubElement(object_item, 'Difficult')
  141.             difficult.text = "0"
  142.             bndbox = SubElement(object_item, 'bndbox')
  143.             xmin = SubElement(bndbox, 'xmin')
  144.             xmin.text = str(each_object['xmin'])
  145.             ymin = SubElement(bndbox, 'ymin')
  146.             ymin.text = str(each_object['ymin'])
  147.             xmax = SubElement(bndbox, 'xmax')
  148.             xmax.text = str(each_object['xmax'])
  149.             ymax = SubElement(bndbox, 'ymax')
  150.             ymax.text = str(each_object['ymax'])
  151.  
  152.     def save(self, targetFile=None):
  153.         '''
  154.         以美观输出的xml格式来保存xml文件
  155.         params:
  156.           targetFile -- 存储的xml文件名，不包括.xml部分
  157.         '''
  158.         root = self.genXML()
  159.         self.appendObjects(root)
  160.         out_file = None
  161.         subdir = self.foldername.split('/')[-1]
  162.         if not os.path.isdir(subdir):
  163.             os.mkdir(subdir)
  164.         if targetFile is None:
  165.             with open(self.foldername + '/' + self.filename + '.xml', 'w') as out_file:
  166.                 prettifyResult = self.prettify(root)
  167.                 out_file.write(prettifyResult)
  168.                 out_file.close()
  169.         else:
  170.             with open(targetFile, 'w') as out_file:
  171.                 prettifyResult = self.prettify(root)
  172.                 out_file.write(prettifyResult)
  173.                 out_file.close()
  174.  
  175.  
  176. class PascalVocReader:
  177.  
  178.     def __init__(self, filepath):
  179.         # shapes type:
  180.         # [labbel, [(x1,y1), (x2,y2), (x3,y3), (x4,y4)], color, color]
  181.         self.shapes = []
  182.         self.filepath = filepath
  183.         self.parseXML()
  184.  
  185.     def getShapes(self):
  186.         return self.shapes
  187.  
  188.     def addShape(self, label, bndbox):
  189.         xmin = int(bndbox.find('xmin').text)
  190.         ymin = int(bndbox.find('ymin').text)
  191.         xmax = int(bndbox.find('xmax').text)
  192.         ymax = int(bndbox.find('ymax').text)
  193.         points = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]
  194.         self.shapes.append((label, points, None, None))
  195.  
  196.     def parseXML(self):
  197.         assert self.filepath.endswith('.xml'), "Unsupport file format"
  198.         parser = etree.XMLParser(encoding='utf-8')
  199.         xmltree = ElementTree.parse(self.filepath, parser=parser).getroot()
  200.         filename = xmltree.find('filename').text
  201.  
  202.         for object_iter in xmltree.findall('object'):
  203.             bndbox = object_iter.find("bndbox")
  204.             label = object_iter.find('name').text
  205.             self.addShape(label, bndbox)
  206.         return True
  207.  
  208.  
  209. def main(srcDir, dstDir):
  210.     i = 1
  211.     # os.walk()
  212.     # dirName是你所要遍历的目录的地址, 返回的是一个三元组(root,dirs,files)
  213.     # root所指的是当前正在遍历的这个文件夹的本身的地址
  214.     # dirs是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
  215.     # files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
  216.     for dirpath, dirnames, filenames in os.walk(srcDir):
  217.         #        print(dirpath, dirnames, filenames)
  218.         for filepath in filenames:
  219.             fileName = os.path.join(dirpath, filepath)
  220.             print(fileName)
  221.             print("processing: {}, {}".format(i, fileName))
  222.             i = i + 1
  223.             xmlFileName = filepath[:-5]  # remove ".json" 5 character
  224.             # 解析该json文件，返回一个列表的列表，存储了一个json文件里面的所有方框坐标及其所属的类
  225.             objs = parseJson(str(fileName))
  226.             # 如果存在检测对象，创建一个与该json文件具有相同名的VOC格式的xml文件
  227.             if len(objs):
  228.                 tmp = PascalVocWriter(dstDir, xmlFileName, (720, 1280, 3), fileName)
  229.                 for obj in objs:
  230.                     tmp.addBndBox(obj[0], obj[1], obj[2], obj[3], obj[4])
  231.                 tmp.save()
  232.             else:
  233.                 print(fileName)
  234.  
  235.  
  236. if __name__ == '__main__':
  237.     # 这里写自己的json标签路径
  238.     srcDir = r'D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\val'      # 原json存放路径
  239.     dstDir = r'D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\val_xml'  # 转换后xml存放路径
  240.     # srcDir = r'D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\train'
  241.     # dstDir = r"D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\train_xml"
  242.     main(srcDir, dstDir)
  243.

 这是xml转txt的代码：

  1. # xmlToTxt
  2. import os
  3. import glob
  4. import xml.etree.ElementTree as ET
  5.  
  6. xml_file=r'D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\val_xml'
  7.  
  8. l=['car', 'bus', 'person', 'bike', 'truck', 'motor', 'train', 'rider', 'traffic sign', 'traffic light']
  9.  
  10. def convert(box,dw,dh):
  11.     x=(box[0]+box[2])/2.0
  12.     y=(box[1]+box[3])/2.0
  13.     w=box[2]-box[0]
  14.     h=box[3]-box[1]
  15.  
  16.     x=x/dw
  17.     y=y/dh
  18.     w=w/dw
  19.     h=h/dh
  20.  
  21.     return x,y,w,h
  22.  
  23. def f(name_id):
  24.     xml_o=open(r'D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\val_xml\%s.xml'%name_id)
  25.     txt_o=open(r'D:\postgraduate\competition\dataset\bdd100k_labels\bdd100k\labels\100k\val_txt\%s.txt'%name_id,'w')
  26.  
  27.     pares=ET.parse(xml_o)
  28.     root=pares.getroot()
  29.     objects=root.findall('object')
  30.     size=root.find('size')
  31.     dw=int(size.find('width').text)
  32.     dh=int(size.find('height').text)
  33.  
  34.     for obj in objects :
  35.         c=l.index(obj.find('name').text)
  36.         bnd=obj.find('bndbox')
  37.  
  38.         b=(float(bnd.find('xmin').text),float(bnd.find('ymin').text),
  39.            float(bnd.find('xmax').text),float(bnd.find('ymax').text))
  40.  
  41.         x,y,w,h=convert(b,dw,dh)
  42.  
  43.         write_t="{} {:.5f} {:.5f} {:.5f} {:.5f}\n".format(c,x,y,w,h)
  44.         txt_o.write(write_t)
  45.  
  46.     xml_o.close()
  47.     txt_o.close()
  48.  
  49. name=glob.glob(os.path.join(xml_file,"*.xml"))
  50. for i in name :
  51.     name_id=os.path.basename(i)[:-4]
  52.     f(name_id)

这是json转txt的代码：

  1. # jsonToTxt
  2. import re
  3. import os
  4. import json
  5.  
  6.  
  7. def search_file(data_dir, pattern=r'\.jpg$'):
  8.     # 返回一个目录的绝对路径
  9.     root_dir = os.path.abspath(data_dir)
  10.     # print(root_dir)
  11.     for root, dirs, files in os.walk(root_dir):
  12.         for f in files:
  13.             # print(f)
  14.             # print("****************")
  15.             if re.search(pattern, f, re.I):
  16.                 abs_path = os.path.join(root, f)
  17.                 print(abs_path)
  18.                 # print('new file %s' % absfn)
  19.                 yield abs_path
  20.  
  21.  
  22. class Bdd2yolov5:
  23.     def __init__(self):
  24.         self.bdd100k_width = 1280
  25.         self.bdd100k_height = 720
  26.         self.select_categorys = ["person", "car", "bus", "truck", 'traffic light']
  27.         self.cat2id = {
  28.             "person": 0,
  29.             "car": 1,
  30.             "bus": 1,
  31.             "truck": 1,
  32.             'traffic light': 2
  33.         }
  34.  
  35.     @property
  36.     def all_categorys(self):
  37.         return ["person", "rider", "car", "bus", "truck", "bike",
  38.                 "motor", "traffic light", "traffic sign", "train"]
  39.  
  40.     def _filter_by_attr(self, attr=None):
  41.         if attr is None:
  42.             return False
  43.             # 过滤掉晚上的图片
  44.         if attr['timeofday'] == 'night':
  45.             return True
  46.         return False
  47.  
  48.     def _filter_by_box(self, w, h):
  49.         # size ratio
  50.         # 过滤掉过于小的小目标
  51.         threshold = 0.001
  52.         if float(w * h) / (self.bdd100k_width * self.bdd100k_height) < threshold:
  53.             return True
  54.         return False
  55.  
  56.     def bdd2yolov5(self, path):
  57.         lines = ""
  58.         with open(path) as fp:
  59.             j = json.load(fp)
  60.             if self._filter_by_attr(j['attributes']):
  61.                 return
  62.             for fr in j["frames"]:
  63.                 dw = 1.0 / self.bdd100k_width
  64.                 dh = 1.0 / self.bdd100k_height
  65.                 for obj in fr["objects"]:
  66.                     if obj["category"] in self.select_categorys:
  67.                         idx = self.cat2id[obj["category"]]
  68.                         cx = (obj["box2d"]["x1"] + obj["box2d"]["x2"]) / 2.0
  69.                         cy = (obj["box2d"]["y1"] + obj["box2d"]["y2"]) / 2.0
  70.                         w = obj["box2d"]["x2"] - obj["box2d"]["x1"]
  71.                         h = obj["box2d"]["y2"] - obj["box2d"]["y1"]
  72.                         if w <= 0 or h <= 0:
  73.                             continue
  74.                         if self._filter_by_box(w, h):
  75.                             continue
  76.                         # 根据图片尺寸进行归一化
  77.                         cx, cy, w, h = cx * dw, cy * dh, w * dw, h * dh
  78.                         line = f"{idx} {cx:.6f} {cy:.6f} {w:.6f} {h:.6f}\n"
  79.                         lines += line
  80.                 if len(lines) != 0:
  81.                     # 转换后的以*.txt结尾的标注文件我就直接和*.json放一具目录了
  82.                     # yolov5中用到的时候稍微挪一下就行了
  83.                     yolo_txt = path.replace(".json", ".txt")
  84.                     with open(yolo_txt, 'w') as fp2:
  85.                         fp2.writelines(lines)
  86.                 # print("%s has been dealt!" % path)
  87.  
  88.  
  89. if __name__ == "__main__":
  90.     bdd_label_dir = "./val"
  91.     cvt = Bdd2yolov5()
  92.     for path in search_file(bdd_label_dir, r"\.json$"):
  93.         cvt.bdd2yolov5(path)

使用第二种直接将json转成txt的方法时，会出现不知道哪些image被过滤掉的情况，因为在转换的时候没有用到image，所以需要用到一个找到文件名称相同但后缀不同的代码：

  1. # 找同名但后缀不同的文件并输出
  2.  
  3. import os
  4. import glob
  5. from PIL import Image
  6.  
  7. # 指定找到文件后，另存为的文件夹路径
  8. outDir = os.path.abspath(r'D:\postgraduate\competition\dataset\data\val\img')
  9.  
  10. # 指定第一个文件夹的位置
  11. imageDir1 = os.path.abspath(r'D:\BaiduNetdiskDownload\BDD100K\images\bdd100k\images\100k\val')
  12.  
  13. # 定义要处理的第一个文件夹变量
  14. image1 = []  # image1指文件夹里的文件，包括文件后缀格式；
  15. imgname1 = []  # imgname1指里面的文件名称，不包括文件后缀格式
  16.  
  17. # 通过glob.glob来获取第一个文件夹下，所有'.jpg'文件
  18. imageList1 = glob.glob(os.path.join(imageDir1, '*.jpg'))
  19.  
  20. # 遍历所有文件，获取文件名称（包括后缀）
  21. for item in imageList1:
  22.     image1.append(os.path.basename(item))
  23.  
  24. # 遍历文件名称，去除后缀，只保留名称
  25. for item in image1:
  26.     (temp1, temp2) = os.path.splitext(item)
  27.     imgname1.append(temp1)
  28.  
  29. # 对于第二个文件夹路径，做同样的操作
  30. imageDir2 = os.path.abspath(r'D:\postgraduate\competition\dataset\data\val\label')
  31. image2 = []
  32. imgname2 = []
  33. imageList2 = glob.glob(os.path.join(imageDir2, '*.txt'))
  34.  
  35. for item in imageList2:
  36.     image2.append(os.path.basename(item))
  37.  
  38. for item in image2:
  39.     (temp1, temp2) = os.path.splitext(item)
  40.     imgname2.append(temp1)
  41.  
  42. # 通过遍历，获取第一个文件夹下，文件名称（不包括后缀）与第二个文件夹相同的文件，并另存在outDir文件夹下。文件名称与第一个文件夹里的文件相同，后缀格式亦保持不变。
  43. for item1 in imgname1:
  44.     for item2 in imgname2:
  45.         if item1 == item2:
  46.             dir = imageList1[imgname1.index(item1)]
  47.             img = Image.open(dir)
  48.             name = os.path.basename(dir)
  49.             img.save(os.path.join(outDir, name))

这样datasets就准备好了，目录结构是这样的：

 2、yolov5训练参数调整

修改train.py文件：

主要是修改parse_opt函数里面的参数：

① 修改weights：我用的是yolov5l.pt。

yolov5共有4中预训练权重，区别如下：总的来说就是模型越小，检测速度越快，检测准确度越低。

 ② 修改cfg：这里需要对原有的yolov5l.yaml文件做一下修改，只需要修改class的数量，我这里一共检测3个类别，所以就把nc改成3.

 ③ 修改data：这里需要在原有的data文件夹下新建一个yaml文件，里面要写的内容如下：

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

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