使用YOLOv3训练BDD100K数据集之标签格式转换

目录

  • 1 将BDD100K数据集的json标签格式转换为VOC的xml标签格式
  • 2 将xml标签格式转换为darknet的txt标签格式
  • 3 生成train.txt和val.txt

1 将BDD100K数据集的json标签格式转换为VOC的xml标签格式

此部分参考并整理了自动驾驶数据集BDD训练mobileNet-SSD,感谢博主的无私奉献!

首先,我们需要两个辅助脚本:parseJson.py(用来解析json里面的对象检测部分的数据)和pascal_voc_io.py(创建VOC格式的xml,并把json文件的数据填充到xml)。

  • parseJson.py
#!/usr/bin/env python
# -*- coding: utf8 -*-
#parse json,input json filename,output info needed by voc

import json
#这里是我需要的10个类别
categorys = ['car', 'bus', 'person', 'bike', 'truck', 'motor', 'train', 'rider', 'traffic sign', 'traffic light']

def parseJson(jsonFile):
    '''
      params:
        jsonFile -- BDD00K数据集的一个json标签文件
      return:
        返回一个列表的列表,存储了一个json文件里面的方框坐标及其所属的类,
        形如:[[325, 342, 376, 384, 'car'], [245, 333, 336, 389, 'car']]
    '''
    objs = []
    obj = []
    f = open(jsonFile)
    info = json.load(f)
    objects = info['frames'][0]['objects']
    for i in objects:
        if(i['category'] in categorys):
            obj.append(int(i['box2d']['x1']))
            obj.append(int(i['box2d']['y1']))
            obj.append(int(i['box2d']['x2']))
            obj.append(int(i['box2d']['y2']))
            obj.append(i['category'])
            objs.append(obj)
            obj = []
    #print("objs",objs)
    return objs

#test
#result = parseJson("/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/labels/100k/val/b1c9c847-3bda4659.json")
#print(len(result))
#print(result)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • pascal_voc_io.py
#!/usr/bin/env python
# -*- coding: utf8 -*-
import sys
import os
from xml.etree import ElementTree
from xml.etree.ElementTree import Element, SubElement
from lxml import etree
from xml.dom.minidom import parseString


class PascalVocWriter:

    def __init__(self, foldername, filename, imgSize, databaseSrc='Unknown', localImgPath=None):
        '''
        params:
          foldername -- 要存储的xml文件的父目录
          filename -- xml文件的文件名
          imgSize -- 图片的尺寸
          databaseSrc -- 数据库名,这里不需要,默认为Unknown
          localImaPath -- xml文件里面的标签的内容
      '''
        self.foldername = foldername
        self.filename = filename
        self.databaseSrc = databaseSrc
        self.imgSize = imgSize
        self.boxlist = []
        self.localImgPath = localImgPath

    def prettify(self, elem):
        """
        params:
          elem -- xml的根标签,以开始
        return:
          返回一个美观输出的xml(用到minidom),本质是一个str
        """
        xml = ElementTree.tostring(elem)
        dom = parseString(xml)
#        print(dom.toprettyxml('  '))
        prettifyResult = dom.toprettyxml('    ')
        return prettifyResult
        

    def genXML(self):
        """
        return:
          生成一个VOC格式的xml,返回一个xml的根标签,以开始
        """
        # Check conditions
        if self.filename is None or \
                self.foldername is None or \
                self.imgSize is None or \
                len(self.boxlist) <= 0:
            return None

        top = Element('annotation') # 创建一个根标签
        folder = SubElement(top, 'folder')  # 在根标签下创建一个子标签
        folder.text = self.foldername       # 用self.foldername的数据填充子标签

        filename = SubElement(top, 'filename')  # 在根标签下创建一个子标签
        filename.text = self.filename           # 用self.filename的数据填充子标签

        localImgPath = SubElement(top, 'path')  # 在根标签下创建一个子标签
        localImgPath.text = self.localImgPath   # 用self.localImgPath的数据填充子标签

        source = SubElement(top, 'source')          # 在根标签下创建一个子标签
        database = SubElement(source, 'database')   # 在根标签下创建一个子标签
        database.text = self.databaseSrc            # 用self.databaseSrc的数据填充子标签

        size_part = SubElement(top, 'size')         # 在根标签下创建一个子标签
        width = SubElement(size_part, 'width')      # 在根标签下创建一个子标签
        height = SubElement(size_part, 'height')    # 在根标签下创建一个子标签
        depth = SubElement(size_part, 'depth')      # 在根标签下创建一个子标签
        width.text = str(self.imgSize[1])           # 用self.imgSize[1]的数据填充子标签
        height.text = str(self.imgSize[0])          # 用self.imgSize[0]的数据填充子标签
        if len(self.imgSize) == 3:                  # 如果图片深度为3,则用self.imgSize[2]的数据填充子标签,否则用1填充
            depth.text = str(self.imgSize[2])
        else:
            depth.text = '1'

        segmented = SubElement(top, 'segmented')
        segmented.text = '0'
        return top

    def addBndBox(self, xmin, ymin, xmax, ymax, name):
        '''
        将检测对象框坐标及其对象类别作为一个字典加入到self.boxlist中
        params:
          xmin -- 检测框的左上角的x坐标
          ymin -- 检测框的左上角的y坐标
          xmax -- 检测框的右下角的x坐标
          ymax -- 检测框的右下角的y坐标
          name -- 检测框内的对象类别名
        '''
        bndbox = {'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax}
        bndbox['name'] = name
        self.boxlist.append(bndbox)

    def appendObjects(self, top):
        '''
        在xml文件中加入检测框的坐标及其对象类别名
        params:
          top -- xml的根标签,以开始
        '''
        for each_object in self.boxlist:
            object_item = SubElement(top, 'object')
            name = SubElement(object_item, 'name')
            name.text = str(each_object['name'])
            pose = SubElement(object_item, 'pose')
            pose.text = "Unspecified"
            truncated = SubElement(object_item, 'truncated')
            truncated.text = "0"
            difficult = SubElement(object_item, 'Difficult')
            difficult.text = "0"
            bndbox = SubElement(object_item, 'bndbox')
            xmin = SubElement(bndbox, 'xmin')
            xmin.text = str(each_object['xmin'])
            ymin = SubElement(bndbox, 'ymin')
            ymin.text = str(each_object['ymin'])
            xmax = SubElement(bndbox, 'xmax')
            xmax.text = str(each_object['xmax'])
            ymax = SubElement(bndbox, 'ymax')
            ymax.text = str(each_object['ymax'])

    def save(self, targetFile=None):
        '''
        以美观输出的xml格式来保存xml文件
        params:
          targetFile -- 存储的xml文件名,不包括.xml部分
        '''
        root = self.genXML()
        self.appendObjects(root)
        out_file = None
        subdir = self.foldername.split('/')[-1]
        if not os.path.isdir(subdir):
            os.mkdir(subdir)
        if targetFile is None:
            with open(self.foldername+'/'+self.filename + '.xml', 'w') as out_file:
                prettifyResult = self.prettify(root)
                out_file.write(prettifyResult)
                out_file.close()
        else:
            with open(targetFile, 'w') as out_file:
                prettifyResult = self.prettify(root)
                out_file.write(prettifyResult)
                out_file.close()

        
        


class PascalVocReader:

    def __init__(self, filepath):
        # shapes type:
        # [labbel, [(x1,y1), (x2,y2), (x3,y3), (x4,y4)], color, color]
        self.shapes = []
        self.filepath = filepath
        self.parseXML()

    def getShapes(self):
        return self.shapes

    def addShape(self, label, bndbox):
        xmin = int(bndbox.find('xmin').text)
        ymin = int(bndbox.find('ymin').text)
        xmax = int(bndbox.find('xmax').text)
        ymax = int(bndbox.find('ymax').text)
        points = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]
        self.shapes.append((label, points, None, None))

    def parseXML(self):
        assert self.filepath.endswith('.xml'), "Unsupport file format"
        parser = etree.XMLParser(encoding='utf-8')
        xmltree = ElementTree.parse(self.filepath, parser=parser).getroot()
        filename = xmltree.find('filename').text

        for object_iter in xmltree.findall('object'):
            bndbox = object_iter.find("bndbox")
            label = object_iter.find('name').text
            self.addShape(label, bndbox)
        return True


# tempParseReader = PascalVocReader('test.xml')
# print tempParseReader.getShapes()
#"""
# Test
#tmp = PascalVocWriter('temp','test', (10,20,3))
#tmp.addBndBox(10,10,20,30,'chair')
#tmp.addBndBox(1,1,600,600,'car')
#tmp.save()
#"""
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192

其次,我们创建一个脚本bdd2voc.py将两个辅助脚本整合起来。

  • bdd2voc.py
# -*- coding: utf8 -*-
import os
import pascal_voc_io
import parseJson

def main(srcDir, dstDir):
    i = 1
    # os.walk()
    # dirName是你所要遍历的目录的地址, 返回的是一个三元组(root,dirs,files)
    # root所指的是当前正在遍历的这个文件夹的本身的地址
    # dirs是一个 list ,内容是该文件夹中所有的目录的名字(不包括子目录)
    # files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
    for dirpath, dirnames, filenames in os.walk(srcDir):
#        print(dirpath, dirnames, filenames)
        for filepath in filenames:
            fileName = os.path.join(dirpath,filepath)
            print(fileName)
            print("processing: {}, {}".format(i, fileName))
            i = i + 1
            xmlFileName = filepath[:-5] # remove ".json" 5 character
            # 解析该json文件,返回一个列表的列表,存储了一个json文件里面的所有方框坐标及其所属的类
            objs = parseJson.parseJson(str(fileName)) 
            # 如果存在检测对象,创建一个与该json文件具有相同名的VOC格式的xml文件
            if len(objs):
                tmp = pascal_voc_io.PascalVocWriter(dstDir, xmlFileName, (720,1280,3), fileName)
                for obj in objs:
                    tmp.addBndBox(obj[0],obj[1],obj[2],obj[3],obj[4])
                tmp.save()
            else:
                print(fileName)

if __name__ == '__main__':
    # test
    # these paths should be your own path
#    srcDir = '/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/labels/100k/val'
#    dstDir = '/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/Annotations/val'
    srcDir = '/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/labels/100k/train'
    dstDir = '/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/Annotations/train'
    main(srcDir, dstDir)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

将这三个脚本文件放在我的前一篇博客(一)使用YOLOv3训练BDD100K数据集之数据集下载
中提高的bdd100k文件夹的同一目录下,我这里是/media/xavier/SSD256/global_datasets/BDD00K,里面存放的文件如下图:
在这里插入图片描述
我们这里只需要用到bdd100k文件夹三个脚本文件。根据bdd2voc.py,我们还需要在bdd100k文件夹内创建Annotations文件夹,在Annotations文件夹内创建train文件夹和val文件夹,用来存储转换后的xml文件
最后,打开终端,进入到/media/xavier/SSD256/global_datasets/BDD00K目录下,运行脚本bdd2voc.py

cd /media/xavier/SSD256/global_datasets/BDD00K
python bdd2voc.py
  • 1
  • 2

最终在/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/Annotations下生成了train和val的xml标签,接下来我们还需要将xml转换为darknet中YOLOv3需要的txt格式。

2 将xml标签格式转换为darknet的txt标签格式

此部分只需要模仿并稍微修改YOLOv3训练KITTI数据集中的第3部分即可。

首先,创建一个脚本xml_to_yolo_txt.py,用于把刚刚生成的xml文件转换为darknet需要的txt格式的文件。

  • xml_to_yolo_txt.py

import glob
import xml.etree.ElementTree as ET

#  类名
class_names = ['car', 'bus', 'person', 'bike', 'truck', 'motor', 'train', 'rider', 'traffic sign', 'traffic light']
#  转换一个xml文件为txt
def single_xml_to_txt(xml_file):
	tree = ET.parse(xml_file)
	root = tree.getroot()
	#  保存的txt文件路径
	txt_file = xml_file.split('.')[0]+'.txt'
	with open(txt_file, 'w') as txt_file:
		for member in root.findall('object'):
			#filename = root.find('filename').text
			picture_width = int(root.find('size')[0].text)
			picture_height = int(root.find('size')[1].text)
			class_name = member[0].text
			#  类名对应的index
			class_num = class_names.index(class_name)
            
			box_x_min = int(member[4][0].text)  # 左上角横坐标
			box_y_min = int(member[4][1].text)  # 左上角纵坐标
			box_x_max = int(member[4][2].text)  # 右下角横坐标
			box_y_max = int(member[4][3].text)  # 右下角纵坐标
			# 转成相对位置和宽高
			x_center = (box_x_min + box_x_max) / (2 * picture_width)
			y_center = (box_y_min + box_y_max) / (2 * picture_height)
			width = (box_x_max - box_x_min) / (2 * picture_width)
			height = (box_y_max - box_y_min) / (2 * picture_height)
			print(class_num, x_center, y_center, width, height)
			txt_file.write(str(class_num) + ' ' + str(x_center) + ' ' + str(y_center) + ' ' + str(width) + ' ' + str(height) + '\n')

#  转换文件夹下的所有xml文件为txt
def dir_xml_to_txt(path):
    i=1
    for xml_file in glob.glob(path + '*.xml'):
        print("processing {}, {}".format(i, xml_file+'.xml'))
        single_xml_to_txt(xml_file)
        i += 1
        

def main(path):

    dir_xml_to_txt(path)

if __name__ == '__main__':
    #  xml文件路径
    path = '/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/Annotations/train/' 
	#path = '/media/xavier/SSD256/global_datasets/BDD00K/bdd100k/Annotations/val/' 
    main(path)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

运行该脚本python xml_to_yolo_txt.py,会在原来xml所在目录生成相同名的txt文件。为了使用darknet,我们在darknet安装目录下创建一个bdd100k_data文件夹,并在该文件夹内创建val_labels文件夹和train_labels文件夹,在终端中运行命令,将生成的txt文件剪切到darknet目录下的对应文件夹内(当然也可以在脚本中直接修改txt保存的路径,这样就节省了这个步骤):

# 移动验证集标签
mv /media/xavier/SSD256/global_datasets/BDD00K/bdd100k/labels/100k/val/*txt  /media/xavier/SSD256/darknet/bdd100k_data/val_labels/
# 移动训练集标签
mv /media/xavier/SSD256/global_datasets/BDD00K/bdd100k/labels/100k/train/*txt  /media/xavier/SSD256/darknet/bdd100k_data/train_labels/
  • 1
  • 2
  • 3
  • 4

3 生成train.txt和val.txt

此部分只需要模仿并稍微修改YOLOv3训练KITTI数据集中的第4部分即可。

train.txt和val.txt包含了训练集和验证集的所有图片的路径,这里我们需要先把BDD100K数据集的训练集和验证集图片的文件夹创建一个软链接,并把此软链接放在darknet/bdd100k_data/目录下,运行命令:

# ln -s 源地址 目标地址
ln -s /media/xavier/SSD256/global_datasets/BDD00K/bdd100k/images/100k/train    /media/xavier/SSD256/darknet/bdd100k_data/train_images

ln -s /media/xavier/SSD256/global_datasets/BDD00K/bdd100k/images/100k/val   /media/xavier/SSD256/darknet/bdd100k_data/val_images
  • 1
  • 2
  • 3
  • 4

在darknet安装目录下创建一个bdd100k_train_val.py文件,代码如下:

#此代码位于darknet根目录下
import glob

def generate_train_and_val(image_path, txt_file):
    with open(txt_file, 'w') as tf:
        i=1
        for jpg_file in glob.glob(image_path + '*.jpg'):
            print("processing {}".format(i))
            tf.write(jpg_file + '\n')
            i += 1


def main(path, dstpath):
    generate_train_and_val(path, dstpath)
    

if __name__ == '__main__':
    #srcpath = 'bbdd100k_data/val_images/'
	#dstpath = 'bbdd100k_data/val.txt'
    srcpath = 'bbdd100k_data/train_images/'
    dstpath = 'bbdd100k_data/train.txt'
    main(srcpath, dstpath)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

打开终端,切换加粗样式到darknet目录下,运行脚本:

cd /media/xavier/SSD256/darknet
python bdd100k_train_val.py
  • 1
  • 2

运行结束后,会在/media/xavier/SSD256/darknet/bdd100k_data/目录下生成tran.txt和val.txt。

你可能感兴趣的:(CNN,卷积神经网络)