【做法说明】Yolo训练行人车辆目标检测数据集储备与模型训练【KITTI】

happylife2002

已于 2024-05-11 21:15:25 修改

阅读量4.3k

点赞数 36

文章标签：深度学习机器学习人工智能

于 2024-01-23 01:08:56 首次发布

本文链接：https://blog.youkuaiyun.com/happylife2002/article/details/135761366

版权

一、数据集介绍

KITTI数据集由德国卡尔斯鲁厄理工学院和丰田工业大学芝加哥分校联合赞助的用于自动驾驶领域研究的数据集。作者收集了长达6个小时的真实交通环境，数据集由经过校正和同步的图像、雷达扫描、高精度的GPS信息和IMU加速信息等多种模态的信息组成。作者还在数据集官网提供了光流、物体检测、深度估计等多种任务的Benchmark。

数据集链接：http://www.cvlibs.net/datasets/kitti/

论文链接：http://www.webmail.cvlibs.net/publications/Geiger2012CVPR.pdf

精确的地面真相由Velodyne激光扫描仪和GPS定位系统提供。我们的数据集是通过在中型城市卡尔斯鲁厄(Karlsruhe)、乡村地区和高速公路上行驶来获取的。每张图像可看到多达15辆汽车和30个行人。除了以原始格式提供所有数据外，我们还为每个任务提取基准。对于我们的每一个基准，我们也提供了一个评估指标和这个评估网站。初步实验表明，在现有基准中排名靠前的方法，如Middlebury方法，在脱离实验室进入现实世界后，表现低于平均水平。我们的目标是减少这种偏见，并通过向社会提供具有新困难的现实基准来补充现有基准。

二、数据集下载

KITTI的官网地址为：The KITTI Vision Benchmark Suite

由于使用做行人车辆目标检测训练，仅寻找与行人，车辆有关的内容，该部分需要注册账号，链接如下：

Downloadhttp://www.cvlibs.net/download.php?file=data_object_image_2.zip

Downloadhttp://www.cvlibs.net/download.php?file=data_object_label_2.zip

得到需要的图片和标签。

也可以在官网上直接下载：

https://s3.eu-central-1.amazonaws.com/avg-kitti/data_object_image_2.ziphttps://s3.eu-central-1.amazonaws.com/avg-kitti/data_object_image_2.zip

https://s3.eu-central-1.amazonaws.com/avg-kitti/data_object_label_2.ziphttps://s3.eu-central-1.amazonaws.com/avg-kitti/data_object_label_2.zip

文件需要科学上网，下载时注意网速问题。

下载完成后，我们在yolov5/dataset下创建文件夹kitti，在kitti中放入我们的数据

|——kitti
     ├── imgages
     │     └── origin
     │           ├── 000001.png               
     │           └── ....... 
     └── labels
           ├── origin
           │     ├── 000001.txt 
           │     └── .......    
           └──  xml

三、KITTI数据集LABLE转换

1. KITTI原数据格式介绍

原先文件中，LABLE如下所示。

官网上可以查询到其数据格式：

2. 数据类别的整合

该数据集的标注一共分为9个类别：

’Car’，’Van’，’Truck’，‘Tram’，’Pedestrian’，’Person_sitting’，’Cyclist’，’Misc’和’DontCare’。

在代码中，将’Pedestrian’, ’Person_sitting’合并为’Pedestrian’ ，删除’Misc’和’DontCare’

首先我们把类别归一一下，因为我们需要用到6个类（代码中的路径需要修改）

# modify_annotations_txt.py

import glob
import string

txt_list = glob.glob('D:/File/yolov5-mobileone-master/dataset/kitti/labels/origin/*.txt') # 存储Labels文件夹所有txt文件路径

print(txt_list)
def show_category(txt_list):
    category_list= []
    for item in txt_list:
        try:
            with open(item) as tdf:
                for each_line in tdf:
                    labeldata = each_line.strip().split(' ') # 去掉前后多余的字符并把其分开
                    category_list.append(labeldata[0]) # 只要第一个字段，即类别
        except IOError as ioerr:
            print('File error:'+str(ioerr))
    print(set(category_list)) # 输出集合

def merge(line):
    each_line=''
    for i in range(len(line)):
        if i!= (len(line)-1):
            each_line=each_line+line[i]+' '
        else:
            each_line=each_line+line[i] # 最后一条字段后面不加空格
    each_line=each_line+'\n'
    return (each_line)

print('before modify categories are:\n')
show_category(txt_list)

for item in txt_list:
    new_txt=[]
    try:
        with open(item, 'r') as r_tdf:
            for each_line in r_tdf:
                labeldata = each_line.strip().split(' ')
                # if labeldata[0] in ['Truck','Van','Tram']: # 合并汽车类
                #     labeldata[0] = labeldata[0].replace(labeldata[0],'Car')
                if labeldata[0] == 'Person_sitting': # 合并行人类
                    labeldata[0] = labeldata[0].replace(labeldata[0],'Pedestrian')
                if labeldata[0] == 'DontCare': # 忽略Dontcare类
                    continue
                if labeldata[0] == 'Misc': # 忽略Misc类
                    continue
                new_txt.append(merge(labeldata)) # 重新写入新的txt文件
        with open(item,'w+') as w_tdf: # w+是打开原文件将内容删除，另写新内容进去
            for temp in new_txt:
                w_tdf.write(temp)
    except IOError as ioerr:
        print('File error:'+str(ioerr))

print('\nafter modify categories are:\n')
show_category(txt_list)

输出结果为：

3. 数据的储存（转化为xml文件）

然后再把它转换为xml文件，在Labels目录创建一个xml文件夹用于存放xml。

# kitti_txt_to_xml.py
# encoding:utf-8
# 根据一个给定的XML Schema，使用DOM树的形式从空白文件生成一个XML
from xml.dom.minidom import Document
import cv2
import glob
import os
def generate_xml(name,split_lines,img_size,class_ind):
    doc = Document() # 创建DOM文档对象
    annotation = doc.createElement('annotation')
    doc.appendChild(annotation)
    title = doc.createElement('folder')
    title_text = doc.createTextNode('KITTI')
    title.appendChild(title_text)
    annotation.appendChild(title)
    img_name=name+'.jpg'
    title = doc.createElement('filename')
    title_text = doc.createTextNode(img_name)
    title.appendChild(title_text)
    annotation.appendChild(title)
    source = doc.createElement('source')
    annotation.appendChild(source)
    title = doc.createElement('database')
    title_text = doc.createTextNode('The KITTI Database')
    title.appendChild(title_text)
    source.appendChild(title)
    title = doc.createElement('annotation')
    title_text = doc.createTextNode('KITTI')
    title.appendChild(title_text)
    source.appendChild(title)
    size = doc.createElement('size')
    annotation.appendChild(size)
    title = doc.createElement('width')
    title_text = doc.createTextNode(str(img_size[1]))
    title.appendChild(title_text)
    size.appendChild(title)
    title = doc.createElement('height')
    title_text = doc.createTextNode(str(img_size[0]))
    title.appendChild(title_text)
    size.appendChild(title)
    title = doc.createElement('depth')
    title_text = doc.createTextNode(str(img_size[2]))
    title.appendChild(title_text)
    size.appendChild(title)
    for split_line in split_lines:
        line=split_line.strip().split()
        if line[0] in class_ind:
            object = doc.createElement('object')
            annotation.appendChild(object)
            title = doc.createElement('name')
            title_text = doc.createTextNode(line[0])
            title.appendChild(title_text)
            object.appendChild(title)
            bndbox = doc.createElement('bndbox')
            object.appendChild(bndbox)
            title = doc.createElement('xmin')
            title_text = doc.createTextNode(str(int(float(line[4]))))
            title.appendChild(title_text)
            bndbox.appendChild(title)
            title = doc.createElement('ymin')
            title_text = doc.createTextNode(str(int(float(line[5]))))
            title.appendChild(title_text)
            bndbox.appendChild(title)
            title = doc.createElement('xmax')
            title_text = doc.createTextNode(str(int(float(line[6]))))
            title.appendChild(title_text)
            bndbox.appendChild(title)
            title = doc.createElement('ymax')
            title_text = doc.createTextNode(str(int(float(line[7]))))
            title.appendChild(title_text)
            bndbox.appendChild(title)
    # 将DOM对象doc写入文件
    f = open('D:/File/yolov5-mobileone-master/dataset/kitti/labels/xml/'+name+'.xml','w')#xml
    f.write(doc.toprettyxml(indent = ''))
    f.close()
if __name__ == '__main__':
    class_ind=('Car', 'Cyclist', 'Truck', 'Van', 'Pedestrian', 'Tram')
    # cur_dir=os.getcwd()
    labels_dir= "D:/File/yolov5-mobileone-master/dataset/kitti/labels/origin"
    # labels_dir=os.path.join(cur_dir,'label_2')
    for parent, dirnames, filenames in os.walk(labels_dir):# 分别得到根目录，子目录和根目录下文件
        for file_name in filenames:
            full_path=os.path.join(parent, file_name) # 获取文件全路径
            f=open(full_path)
            split_lines = f.readlines() #以行为单位读
            name= file_name[:-4] # 后四位是扩展名.txt，只取前面的文件名
            img_name=name+'.png'
            img_path=os.path.join('D:/File/yolov5-mobileone-master/dataset/kitti/images/origin',img_name) # 路径需要自行修改
            img_size=cv2.imread(img_path).shape
            generate_xml(name,split_lines,img_size,class_ind)
print('txts has converted into xmls')

这个时候我们已经将.txt转化为.xml并存放在设定的文件夹xml下了。

4. 数据格式的转化与数据集划分

最后我们再把.xml转化为适合于yolo训练的标签模式，将下面代码放置在数据集文件夹的根目录，注意不要将图片文件夹和要生成文件夹的名称重复。按照0.7:0.15:0.15构造数据集、测试集、验证集并分别分配到不同文件夹去。

|——kitti
     ├── imgages
     │     ├── train
     │     │     ├── 00XXXA.png 
     │     │     └── .......    
     │     ├──  val
     │     │     ├── 00XXXB.png 
     │     │     └── .......    
     │     └── test
     │           └── 00XXXC.png               
     │           └── ....... 
     │
     └── labels
           ├── train
           │     ├── 00XXXA.txt 
           │     └── .......    
           ├──  val
           │     ├── 00XXXB.txt 
           │     └── .......    
           └── test
                 ├── 00XXXC.txt  
                 └── .......

分配代码如下：

#  xml_to_txt_yolo.py 
#  将此文件放置在你的数据集根目录下即可
#  一定要放到根目录下

import xml.etree.ElementTree as ET
import os
import shutil
import random

xml_file_path = 'D:/File/yolov5-mobileone-master/dataset/kitti/labels/xml/'       # 检查和自己的xml文件夹名称是否一致
images_file_path = 'images/origin/'  # 检查和自己的图像文件夹名称是否一致
# 改成自己的类别名称
classes = ['Car', 'Cyclist', 'Truck', 'Van', 'Pedestrian', 'Tram']
# 数据集划分比例，训练集75%，验证集15%，测试集15%
train_percent = 0.7
val_percent = 0.15
test_percent = 0.15
# 此处不要改动，只是创一个临时文件夹
if not os.path.exists('temp_labels/'):
    os.makedirs('temp_labels/')
txt_file_path = 'temp_labels/'


def convert(size, box):
    dw = 1. / size[0]
    dh = 1. / size[1]
    x = (box[0] + box[1]) / 2.0
    y = (box[2] + box[3]) / 2.0
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x * dw
    w = w * dw
    y = y * dh
    h = h * dh
    return x, y, w, h


def convert_annotations(image_name):
    in_file = open(xml_file_path + image_name + '.xml')
    out_file = open(txt_file_path + image_name + '.txt', 'w')
    tree = ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)
    for obj in root.iter('object'):
        # difficult = obj.find('difficult').text
        cls = obj.find('name').text
        # if cls not in classes or int(difficult) == 1:
        #     continue
        if cls not in classes == 1:
            continue
        cls_id = classes.index(cls)
        xmlbox = obj.find('bndbox')
        b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text),
             float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text))
        bb = convert((w, h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')


total_xml = os.listdir(xml_file_path)
num_xml = len(total_xml)  # XML文件总数

for i in range(num_xml):
    name = total_xml[i][:-4]
    convert_annotations(name)


# *********************************************** #
#  parent folder
#  --data
#  ----images
#       ----train
#       ----val
#       ----test
#  ----labels
#       ----train
#       ----val
#       ----test
def create_dir():
    if not os.path.exists('images/'):
        os.makedirs('images/')
    if not os.path.exists('labels/'):
        os.makedirs('labels/')
    if not os.path.exists('images/train'):
        os.makedirs('images/train')
    if not os.path.exists('images/val'):
        os.makedirs('images/val')
    if not os.path.exists('images/test'):
        os.makedirs('images/test/')
    if not os.path.exists('labels/train'):
        os.makedirs('labels/train')
    if not os.path.exists('labels/val'):
        os.makedirs('labels/val')
    if not os.path.exists('labels/test'):
        os.makedirs('labels/test')

    return


# *********************************************** #
# 读取所有的txt文件
create_dir()
total_txt = os.listdir(txt_file_path)
num_txt = len(total_txt)
list_all_txt = range(num_txt)  # 范围 range(0, num)

num_train = int(num_txt * train_percent)
num_val = int(num_txt * val_percent)
num_test = num_txt - num_train - num_val

train = random.sample(list_all_txt, num_train)
# train从list_all_txt取出num_train个元素
# 所以list_all_txt列表只剩下了这些元素：val_test
val_test = [i for i in list_all_txt if not i in train]
# 再从val_test取出num_val个元素，val_test剩下的元素就是test
val = random.sample(val_test, num_val)
# 检查两个列表元素是否有重合的元素
# set_c = set(val_test) & set(val)
# list_c = list(set_c)
# print(list_c)
# print(len(list_c))

print("训练集数目：{}, 验证集数目：{},测试集数目：{}".format(len(train), len(val), len(val_test) - len(val)))
for i in list_all_txt:
    name = total_txt[i][:-4]

    srcImage = images_file_path + name + '.png'
    srcLabel = txt_file_path + name + '.txt'

    if i in train:
        dst_train_Image = 'images/train/' + name + '.png'
        dst_train_Label = 'labels/train/' + name + '.txt'
        shutil.copyfile(srcImage, dst_train_Image)
        shutil.copyfile(srcLabel, dst_train_Label)
    elif i in val:
        dst_val_Image = 'images/val/' + name + '.png'
        dst_val_Label = 'labels/val/' + name + '.txt'
        shutil.copyfile(srcImage, dst_val_Image)
        shutil.copyfile(srcLabel, dst_val_Label)
    else:
        dst_test_Image = 'images/test/' + name + '.png'
        dst_test_Label = 'labels/test/' + name + '.txt'
        shutil.copyfile(srcImage, dst_test_Image)
        shutil.copyfile(srcLabel, dst_test_Label)
print("complete")

数据分配结果如下：

数据集、验证集、测试集分配情况如下：

可以看到，数据与标签对应，数据个数与标签一致。

至此，数据准备已经全部完毕，可以载入yolo进行训练。在训练之前需要改变一些参数。

四、配置文件的修改

1. 修改数据集yaml文件

修改yaml文件,将dat目录下的coco128.yaml复制一份修改为kitti.yaml。

需要注意names部分应当与前述的一致，否则会出现错误。

# kitti.yaml

train: D:/File/yolov5-mobileone-master/dataset/kitti/images/train  # train images (relative to 'path') 5236 images
val: D:/File/yolov5-mobileone-master/dataset/kitti/images/val/  # val images (relative to 'path') 1122 images
test: D:/File/yolov5-mobileone-master/dataset/kitti/images/test/ # test images (optional)
nc:  6 # number of classes
names: ['Car', 'Cyclist', 'Truck', 'Van', 'Pedestrian', 'Tram']  # class names

2. 修改models配置文件

本次实验使用yolov5s，故修改yolov5s.yaml文件，在models目录下。

修改nc（类别数量）即可。

# yolov5s.yaml
# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# Parameters
nc: 6  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

3. 修改训练文件train.py

根据配置情况更改配置路径，参考修改如下：

def parse_opt(known=False):
    parser = argparse.ArgumentParser()
    parser.add_argument('--weights', type=str, default='yolov5s.pt', help='initial weights path')
    parser.add_argument('--cfg', type=str, default=ROOT / 'models/yolov5s.yaml', help='model.yaml path')
    parser.add_argument('--data', type=str, default=ROOT / 'data/kitti.yaml', help='dataset.yaml path')
    parser.add_argument('--hyp', type=str, default=ROOT / 'data/hyps/hyp.scratch-low.yaml', help='hyperparameters path')
    parser.add_argument('--epochs', type=int, default=20, help='total training epochs')
    parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs, -1 for autobatch')

配置参数名称解释如下：

epochs：         指的就是训练过程中整个数据集将被迭代多少次,显卡不行你就调小点。
batch-size：     一次看完多少张图片才进行权重更新，梯度下降的mini-batch,显卡不行你就调小点。
cfg：            存储模型结构的配置文件
data：           存储训练、测试数据的文件
img-size：       输入图片宽高,显卡不行你就调小点。
rect：           进行矩形训练
resume：         恢复最近保存的模型开始训练
nosave：         仅保存最终checkpoint
notest：         仅测试最后的epoch
evolve：         进化超参数
bucket：         gsutil bucket
cache-images：   缓存图像以加快训练速度
weights：        权重文件路径
name：           重命名results.txt to results_name.txt
device：         cuda device, i.e. 0 or 0,1,2,3 or cpu
adam：           使用adam优化
multi-scale：    多尺度训练，img-size +/- 50%
single-cls：     单类别的训练集

4. 修改训练命令

最后训练命令,要根据自己的路径做对应的修改。

python train.py --img 640 --batch 16 --epoch 100 --data data/kitti.yaml --cfg models/yolov5s.yaml --weights yolov5s.pt --device '0'    # 0号GPU

配置示意如下：

img：         传入图片像素的大小
batch：       是每一次迭代送到网络的图片数量，也称作批数量，增大这个可以让网络在较少的迭代次数下完成一个epoch   在固定最大迭代次数的前提下，增加batch会延长训练时间，但会更好的寻找到梯度下降的方向，如果在大家的显存足够大，可以适当的增大这个值来提高内存的利用率，需要不断地尝试选取，过小会让训练不够收敛，过大会陷入局部最优
epoch：       迭代的次数
data：        配置文件
weights：     模型

5. 出现的问题

（1）BrokenPipeError: [Errno 32] Broken pipe

解决方案：在参数设计阶段将worker设置成0即可。查找资料发现，在win10上需要将nw(num-worker)设置成0

问题原因：worker参数是指的是：在使用Pytorch的DataLoad函数时，一个重要的参数。数据需要加载到内存中在传入GPU，numworker越大，传入的越快，当然也很吃CPU。在WIN中无比设置成0，在Linux中可以设置成多线程CPU的核心数。

（2）RuntimeError: CUDA out of memory

查询资料可以知道，内容存在该两种报错。

# 报错情况01
RuntimeError: CUDA out of memory. Tried to allocate 16.00 MiB (GPU 0; 2.00 GiB total capacity; 1.34 GiB already allocated; 14.76 MiB free; 1.38 GiB reserved in total by PyTorch)
# 报错情况02
RuntimeError: CUDA out of memory. Tried to allocate 12.50 MiB (GPU 0; 10.92 GiB total capacity; 8.57 MiB already allocated; 9.28 GiB free; 4.68 MiB cached)

解决方案：在参数设计阶段减少batch-size的数值，从而减少参数带来的压力。

问题原因：提示的是CUDA out of memory.可以知道咱们设置的内存使用超过了cuda的限制那么我们将batch_size降低，将数值调小，然后再试一下。一般是最初设置的一半，不行的话再降低一半，问题解决。

五、初步训练情况

1. 使用CPU训练

（1）开始测试

由于持续报错RuntimeError: CUDA out of memory，故首先采用CPU进行训练，可以看出使用CPU进行训练时，训练时间非常长。

* 训练意外中断恢复处理

训练完五组后意外中断了训练，尝试恢复。

将第九个参数第9个参数 resume，将其设置为default = True即可，也就是那一行代码改变为:

	parser.add_argument('--resume', nargs='?', const=True, default=True, help='resume most recent training')

接下来运行train.py，键入代码：

python train.py

运行从未完成的一个Epoch开始，成功恢复。

（2）继续测试

十个周期跑了快16个小时，也是比较慢了。

（3）测试效果

由于测试的周期比较少，测试结果一般。

还是需要尝试使用GPU进行训练，加快计算效率，从而提升准确率（模型训练效果）。

2. 使用GPU训练

（1）开始训练

由于显卡的原因，batch-size的数值调整为4。

前五个周期可以看出，训练速度是原先的10倍。

显示字符为红色的原因是，使用CPU进行训练时，使用的是命令行；而使用GPU进行训练时，使用的是编译器，二者颜色不同。都是使用Pytorch进行的训练。

使用不到三个小时便训练完成了，足以证明使用GPU的速度相当之迅速。

（2）测试效果

可以看出训练效果依然部分不理想，原因是训练的epoch数量不足，但是使用GPU的优势就是速度快，可以跑更多的epoch从而完善训练。

3. 检测

输入以下代码，使用现有的参数进行检测。

python detect.py --weights runs/train/exp/weights/best.pt 
				 --source Road_traffic_video2.mp4 这里可以是图片 也可以是视频 也可以是0（摄像头）
				 --device 0

后续如果训练的轮次更多的话，训练效果会更好。

部分参考文章：

yolov5测试和训练自己的数据集_yolo5测试集-优快云博客

用yolov5训练kitti数据集-优快云博客

基于KITTI数据集的KERAS-YOLOV3实践_基于ketti数据集-优快云博客