使用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文件里面的开始
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。