YOLOv5训练自己的数据集（超详细完整版）

一.Requirements 本教程所用环境：代码版本V3.0，源码下载地址：https://github.com/ultralytics/yolov5.git Pytorch：1.6.0 Cuda：10.1 Python：3.7 官方要求Python>=3.8 and PyTorch>=1.6. 通过git clone https://github.com/ultralytics/yolov5.git将YOLOv5源码下载到本地，创建好虚拟环境，并通过pip install -r requirements.txt安装依赖包。

二. 准备自己的数据集（VOC格式） 1.在yolov5目录下创建paper_data文件夹（名字可以自定义），目录结构如下，将之前labelImg标注好的xml文件和图片放到对应目录下 paper_data …images # 存放图片 …Annotations # 存放图片对应的xml文件 …ImageSets/Main #之后会在Main文件夹内自动生成train.txt，val.txt，test.txt和trainval.txt四个文件，存放训练集、验证集、测试集图片的名字（无后缀.jpg） 示例如下： paper_data文件夹下内容如下：

Annotations文件夹下面为xml文件（标注工具采用labelImage），内容如下：

images为VOC数据集格式中的JPEGImages，内容如下：

ImageSets文件夹下面有个Main子文件夹，其下面存放训练集、验证集、测试集的划分，通过脚本生成，可以创建一个split_train_val.py文件，代码内容如下：

# coding:utf-8

import os import random import argparse

parser = argparse.ArgumentParser() #xml文件的地址，根据自己的数据进行修改 xml一般存放在Annotations下 parser.add_argument('--xml_path', default='Annotations', type=str, help='input xml label path') #数据集的划分，地址选择自己数据下的ImageSets/Main parser.add_argument('--txt_path', default='ImageSets/Main', type=str, help='output txt label path') opt = parser.parse_args()

trainval_percent = 1.0 train_percent = 0.9 xmlfilepath = opt.xml_path txtsavepath = opt.txt_path total_xml = os.listdir(xmlfilepath) if not os.path.exists(txtsavepath):     os.makedirs(txtsavepath)

num = len(total_xml) list_index = range(num) tv = int(num * trainval_percent) tr = int(tv * train_percent) trainval = random.sample(list_index, tv) train = random.sample(trainval, tr)

file_trainval = open(txtsavepath + '/trainval.txt', 'w') file_test = open(txtsavepath + '/test.txt', 'w') file_train = open(txtsavepath + '/train.txt', 'w') file_val = open(txtsavepath + '/val.txt', 'w')

for i in list_index:     name = total_xml[i][:-4] + '\n'     if i in trainval:         file_trainval.write(name)         if i in train:             file_train.write(name)         else:             file_val.write(name)     else:         file_test.write(name)

file_trainval.close() file_train.close() file_val.close() file_test.close() 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 运行代码后，在Main文件夹下生成下面四个txt文档：

2.接下来准备labels，把数据集格式转换成yolo_txt格式，即将每个xml标注提取bbox信息为txt格式（这种数据集格式成为yolo_txt格式），每个图像对应一个txt文件，文件每一行为一个目标的信息，包括class, x_center, y_center, width, height格式。格式如下：

参考如下（https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data#2-create-labels）：

创建voc_label.py文件，将训练集、验证集、测试集生成label标签（训练中要用到），同时将数据集路径导入txt文件中，代码内容如下：

# -*- coding: utf-8 -*- import xml.etree.ElementTree as ET import os from os import getcwd

sets = ['train', 'val', 'test'] classes = ["a", "b"]   # 改成自己的类别 abs_path = os.getcwd() print(abs_path)

def convert(size, box):     dw = 1. / (size[0])     dh = 1. / (size[1])     x = (box[0] + box[1]) / 2.0 - 1     y = (box[2] + box[3]) / 2.0 - 1     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_annotation(image_id):     in_file = open('/home/trainingai/zyang/yolov5/paper_data/Annotations/%s.xml' % (image_id), encoding='UTF-8')     out_file = open('/home/trainingai/zyang/yolov5/paper_data/labels/%s.txt' % (image_id), '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         difficult = obj.find('Difficult').text         cls = obj.find('name').text         if cls not in classes or int(difficult) == 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))         b1, b2, b3, b4 = b         # 标注越界修正         if b2 > w:             b2 = w         if b4 > h:             b4 = h         b = (b1, b2, b3, b4)         bb = convert((w, h), b)         out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')

wd = getcwd() for image_set in sets:     if not os.path.exists('/home/trainingai/zyang/yolov5/paper_data/labels/'):         os.makedirs('/home/trainingai/zyang/yolov5/paper_data/labels/')     image_ids = open('/home/trainingai/zyang/yolov5/paper_data/ImageSets/Main/%s.txt' % (image_set)).read().strip().split()     list_file = open('paper_data/%s.txt' % (image_set), 'w')     for image_id in image_ids:         list_file.write(abs_path + '/paper_data/images/%s.jpg\n' % (image_id))         convert_annotation(image_id)     list_file.close() 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 运行后会生成如下labels文件夹和三个包含数据集的txt文件，其中labels中为不同图像的标注文件，train.txt等txt文件为划分后图像所在位置的绝对路径，如train.txt就含有所有训练集图像的绝对路径。 运行voc_label.py时报错“ZeroDivisionError: float division by zero”的原因是：标注文件中存在width为0或者height为0的数据，检查修改后可解决。

三个txt文件里面的内容如下：

3.配置文件 1）数据集的配置 在yolov5目录下的data文件夹下新建一个ab.yaml文件（可以自定义命名），用来存放训练集和验证集的划分文件（train.txt和val.txt），这两个文件是通过运行voc_label.py代码生成的，然后是目标的类别数目和具体类别列表，ab.yaml内容如下：

疑问：ab.yaml文件中train和val通过train.txt和val.txt指定，我在训练时报错（别人没有报错，很费解！评论中有人遇到一样的报错，给出解决方法是：发现冒号后面需要加空格，否则会被认为是字符串而不是字典，可以试一下），于是我参照官网上data/coco128.yaml的形式指定train和val，内容如下：

2）编辑模型的配置文件 2-1) 聚类得出先验框（可选）（聚类重新生成anchors运行时间较长） 最新版的yolov5，它会自动kmeans算出anchors 如下图所示：

kmeans.py代码内容如下：

import numpy as np

def iou(box, clusters):     """     Calculates the Intersection over Union (IoU) between a box and k clusters.     :param box: tuple or array, shifted to the origin (i. e. width and height)     :param clusters: numpy array of shape (k, 2) where k is the number of clusters     :return: numpy array of shape (k, 0) where k is the number of clusters     """     x = np.minimum(clusters[:, 0], box[0])     y = np.minimum(clusters[:, 1], box[1])     if np.count_nonzero(x == 0) > 0 or np.count_nonzero(y == 0) > 0:         raise ValueError("Box has no area")                 # 如果报这个错，可以把这行改成pass即可

    intersection = x * y     box_area = box[0] * box[1]     cluster_area = clusters[:, 0] * clusters[:, 1]

    iou_ = intersection / (box_area + cluster_area - intersection)

    return iou_

def avg_iou(boxes, clusters):     """     Calculates the average Intersection over Union (IoU) between a numpy array of boxes and k clusters.     :param boxes: numpy array of shape (r, 2), where r is the number of rows     :param clusters: numpy array of shape (k, 2) where k is the number of clusters     :return: average IoU as a single float     """     return np.mean([np.max(iou(boxes[i], clusters)) for i in range(boxes.shape[0])])

def translate_boxes(boxes):     """     Translates all the boxes to the origin.     :param boxes: numpy array of shape (r, 4)     :return: numpy array of shape (r, 2)     """     new_boxes = boxes.copy()     for row in range(new_boxes.shape[0]):         new_boxes[row][2] = np.abs(new_boxes[row][2] - new_boxes[row][0])         new_boxes[row][3] = np.abs(new_boxes[row][3] - new_boxes[row][1])     return np.delete(new_boxes, [0, 1], axis=1)

def kmeans(boxes, k, dist=np.median):     """     Calculates k-means clustering with the Intersection over Union (IoU) metric.     :param boxes: numpy array of shape (r, 2), where r is the number of rows     :param k: number of clusters     :param dist: distance function     :return: numpy array of shape (k, 2)     """     rows = boxes.shape[0]

    distances = np.empty((rows, k))     last_clusters = np.zeros((rows,))

    np.random.seed()

    # the Forgy method will fail if the whole array contains the same rows     clusters = boxes[np.random.choice(rows, k, replace=False)]

    while True:         for row in range(rows):             distances[row] = 1 - iou(boxes[row], clusters)

        nearest_clusters = np.argmin(distances, axis=1)

        if (last_clusters == nearest_clusters).all():             break

        for cluster in range(k):             clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)

        last_clusters = nearest_clusters

    return clusters

if __name__ == '__main__':     a = np.array([[1, 2, 3, 4], [5, 7, 6, 8]])     print(translate_boxes(a)) 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 聚类生成新anchors的文件clauculate_anchors.py，代码内容如下：

# -*- coding: utf-8 -*- # 根据标签文件求先验框

import os import numpy as np import xml.etree.cElementTree as et from kmeans import kmeans, avg_iou

FILE_ROOT = "/home/trainingai/zyang/yolov5/paper_data/"     # 根路径 ANNOTATION_ROOT = "Annotations"  # 数据集标签文件夹路径 ANNOTATION_PATH = FILE_ROOT + ANNOTATION_ROOT

ANCHORS_TXT_PATH = "/home/trainingai/zyang/yolov5/data/anchors.txt"

CLUSTERS = 9 CLASS_NAMES = ['a', 'b']

def load_data(anno_dir, class_names):     xml_names = os.listdir(anno_dir)     boxes = []     for xml_name in xml_names:         xml_pth = os.path.join(anno_dir, xml_name)         tree = et.parse(xml_pth)

        width = float(tree.findtext("./size/width"))         height = float(tree.findtext("./size/height"))

        for obj in tree.findall("./object"):             cls_name = obj.findtext("name")             if cls_name in class_names:                 xmin = float(obj.findtext("bndbox/xmin")) / width                 ymin = float(obj.findtext("bndbox/ymin")) / height                 xmax = float(obj.findtext("bndbox/xmax")) / width                 ymax = float(obj.findtext("bndbox/ymax")) / height

                box = [xmax - xmin, ymax - ymin]                 boxes.append(box)             else:                 continue     return np.array(boxes)

if __name__ == '__main__':

    anchors_txt = open(ANCHORS_TXT_PATH, "w")

    train_boxes = load_data(ANNOTATION_PATH, CLASS_NAMES)     count = 1     best_accuracy = 0     best_anchors = []     best_ratios = []

    for i in range(10):      ##### 可以修改，不要太大，否则时间很长         anchors_tmp = []         clusters = kmeans(train_boxes, k=CLUSTERS)         idx = clusters[:, 0].argsort()         clusters = clusters[idx]         # print(clusters)

        for j in range(CLUSTERS):             anchor = [round(clusters[j][0] * 640, 2), round(clusters[j][1] * 640, 2)]             anchors_tmp.append(anchor)             print(f"Anchors:{anchor}")

        temp_accuracy = avg_iou(train_boxes, clusters) * 100         print("Train_Accuracy:{:.2f}%".format(temp_accuracy))

        ratios = np.around(clusters[:, 0] / clusters[:, 1], decimals=2).tolist()         ratios.sort()         print("Ratios:{}".format(ratios))         print(20 * "*" + " {} ".format(count) + 20 * "*")

        count += 1

        if temp_accuracy > best_accuracy:             best_accuracy = temp_accuracy             best_anchors = anchors_tmp             best_ratios = ratios

    anchors_txt.write("Best Accuracy = " + str(round(best_accuracy, 2)) + '%' + "\r\n")     anchors_txt.write("Best Anchors = " + str(best_anchors) + "\r\n")     anchors_txt.write("Best Ratios = " + str(best_ratios))     anchors_txt.close() 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 clauculate_anchors.py 内要修改为自己数据集的路径，如下：

FILE_ROOT = "xxx"    # 根路径 ANNOTATION_ROOT = "xxx"  # 数据集标签文件夹路径 ANNOTATION_PATH = FILE_ROOT + ANNOTATION_ROOT 1 2 3 运行clauculate_anchors.py跑完会生成一个文件 anchors.txt，里面有得出的建议先验框anchors，内容如下：

PS: 如果自己动手生成anchors时候报错“ raise ValueError(“Box has no area”)”，可能是标注数据中有的目标物很小很小，可以把kmeans.py中第13行注释掉，改成pass即可解决这个报错。

2-2) 选择一个你需要的模型 在yolov5目录下的model文件夹下是模型的配置文件，这边提供s、m、l、x版本，逐渐增大（随着架构的增大，训练时间也是逐渐增大），假设采用yolov5s.yaml，只用修改一个参数，把nc改成自己的类别数；如果anchors是重新生成的，也需要修改，根据anchors.txt 中的 Best Anchors 修改，需要取整（可选） 如下：

至此，自定义数据集已创建完毕，接下来就是训练模型了。 三.模型训练 1.下载预训练模型 源码中在yolov5目录下的weights文件夹下提供了下载四种预训练模型的脚本----download_weights.sh 执行这个shell脚本就可以下载，这里weights的下载可能因为网络而难以进行，有人分享了百度网盘的下载地址，但是不一定是v3.0版本最新的预训练模型，如果不是v3.0版本最新的预训练模型，在训练时会报错如下：

出现这个问题原因是预训练模型下载的不是最新的，例如V3.0的代码，下载的是V2.0或者V1.0的模型权重就会报错，重新下载最新的模型权重即可解决。我是通过官网源码给的链接翻墙在google云盘上下载的。 2.训练 在train.py进行以下几个修改：

以上参数解释如下： 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：单类别的训练集 之后运行训练命令如下：

python train.py --img 640 --batch 16 --epoch 300 --data data/ab.yaml --cfg models/yolov5s.yaml --weights weights/yolov5s.pt --device '0'     # 0号GPU 1 根据自己的硬件配置修改参数，训练好的模型会被保存在yolov5目录下的runs/exp0/weights/last.pt和best.pt，详细训练数据保存在runs/exp0/results.txt文件中。 如果Cuda版本不对（不是>=10.1版本），在调用GPU训练时会报错如下：

3.训练过程可视化 利用tensorboard可视化训练过程，训练开始会在yolov5目录生成一个runs文件夹，利用tensorboard打开即可查看训练日志，命令如下：

tensorboard --logdir=runs 1

由于TensorFlow2.0及以上版本现在支持CUDA10.0，还不支持CUDA10.1，因此我在使用TensorFlow2.0以上版本利用tensorboard打开训练日志时报错如下：

于是我改用tensorflow-gpu1.13.1版本的环境，利用tensorboard即可成功打开并查看训练日志，可视化结果如上图。

至此YOLOv5训练自己的数据集，训练阶段已完毕。 YOLOv5训练速度更快，准确率更高，个人感觉最大的优势是相比YOLOv3，YOLOv5的模型更加轻量级，同样的数据集训练出来的模型大小是YOLOv3的将近四分之一大小。 四.模型测试 评估模型好坏就是在有标注的测试集或者验证集上进行模型效果的评估，在目标检测中最常使用的评估指标为mAP。在test.py文件中指定数据集配置文件和训练结果模型，如下：

通过下面的命令进行模型测试：

python test.py  --data data/ab.yaml --weights runs/exp1/weights/best.pt --augment 1 模型测试效果如下：

五.模型推理 最后，模型在没有标注的数据集上进行推理，在detect.py文件中指定测试图片和测试模型的路径，其他参数（img_size、置信度object confidence threshold、IOU threshold for NMS）可自行修改，如下：

使用下面的命令（该命令中save_txt选项用于生成结果的txt标注文件，不指定则只会生成结果图像），其中，weights使用最满意的训练模型即可，source则提供一个包含所有测试图片的文件夹路径即可。

 python detect.py --weights runs/exp1/weights/best.pt --source inference/images/ --device 0 --save-txt 1 测试完毕后，每个测试图片会在指定的inference/output输出文件夹中生成结果图片和同名的txt文件，如下：

每个txt会生成一行一个目标的信息，信息包括类别序号、xcenter ycenter w h，后面四个为bbox位置，均为归一化数值，如下图：

在进行模型推理时，无论是加载模型的速度还是对测试图片的推理速度，都能明显感觉到YOLOv5比YOLOv3速度快，尤其是加载模型的速度，因为同样的数据集训练出来的模型YOLOv5更加轻量级，模型大小减小为YOLOv3的将近四分之一。 至此YOLOv5训练自己的数据集整个过程：制作数据集----模型训练----模型测试----模型推理阶段已全部完成。