Ubuntu下YOLOv4训练自己的数据成功！

最新推荐文章于 2023-05-24 18:40:51 发布

YingTUNG

最新推荐文章于 2023-05-24 18:40:51 发布

阅读量829

点赞数 2

文章标签： python 深度学习机器学习人工智能神经网络

本文链接：https://blog.csdn.net/weixin_45102257/article/details/109164337

版权

Ubuntu下YOLOv4训练自己的数据！

本博客主要：参考来源

假设已有原始.jpg图片和打好标签的.xml文件（注意：要对应，图片命名不要出现空格、中文和（2）等）。

1、利用voc制作自己的数据集

在目录下新建VOC2007，并在VOC2007下新建Annotations，ImageSets和JPEGImages三个文件夹。在ImageSets下新建Main文件夹。文件目录如下所示：
在这里插入图片描述

将自己的数据集.jpg图片拷贝到JPEGImages目录下，将数据集标签文件中.xml文件拷贝到Annotations目录下。在VOC2007下新建test.py文件夹，将下面代码拷贝进去运行，将在Main中生成四个文件：train.txt,val.txt,test.txt和trainval.txt。

import os
import random

trainval_percent = 0.8
train_percent = 0.8
xmlfilepath = 'Annotations'
txtsavepath = 'ImageSets\Main'
total_xml = os.listdir(xmlfilepath)

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

ftrainval = open('ImageSets/Main/trainval.txt', 'w')
ftest = open('ImageSets/Main/test.txt', 'w')
ftrain = open('ImageSets/Main/train.txt', 'w')
fval = open('ImageSets/Main/val.txt', 'w')

for i in list:
    name = total_xml[i][:-4] + '\n'
    if i in trainval:
        ftrainval.write(name)
        if i in train:
            ftrain.write(name)
        else:
            fval.write(name)
    else:
        ftest.write(name)

ftrainval.close()
ftrain.close()
fval.close()
ftest.close()

或者下面这个代码，作用是一样的（里面路径啥的要改的）：

import os
import random
import sys
root_path = './scripts/VOCdevkit/VOC2007'
xmlfilepath = root_path + '/Annotations'
txtsavepath = root_path + '/ImageSets/Main'
if not os.path.exists(root_path):
    print("cannot find such directory: " + root_path)
    exit()
if not os.path.exists(txtsavepath):
    os.makedirs(txtsavepath)
trainval_percent = 0.9
train_percent = 0.8
total_xml = os.listdir(xmlfilepath)
num = len(total_xml)
list = range(num)
tv = int(num * trainval_percent)
tr = int(tv * train_percent)
trainval = random.sample(list, tv)
train = random.sample(trainval, tr)
print("train and val size:", tv)
print("train size:", tr)
ftrainval = open(txtsavepath + '/trainval.txt', 'w')
ftest = open(txtsavepath + '/test.txt', 'w')
ftrain = open(txtsavepath + '/train.txt', 'w')
fval = open(txtsavepath + '/val.txt', 'w')
for i in list:
    name = total_xml[i][:-4] + '\n'
    if i in trainval:
        ftrainval.write(name)
        if i in train:
            ftrain.write(name)
        else:
            fval.write(name)
    else:
        ftest.write(name)
ftrainval.close()
ftrain.close()
fval.close()
ftest.close()

生成后的目录结构如下所示：
在这里插入图片描述

做好这一步之后，自己的数据集基本做好了，接下来需要转移阵地到代码环境中去。

2、处理数据集

假设Darknet环境已编译好（过程可参考前面的博客）

在darknet目录下新建个文件夹，在该文件夹下新建个VOCdevkit文件夹，然后把刚才制作的VOC2007文件夹拷贝到该文件夹下。（YOLOV3的label标注的一行五个数分别代表类别（从 0 开始编号）， BoundingBox 中心 X 坐标，中心 Y 坐标，宽，高。这些坐标都是 0～1 的相对坐标。和我们刚才标注的label不同，因此我们需要下面的py文件帮我们转换label。）

所以，把voc_label.py文件放在VOCdevkit同级目录下修改（主要修改图中#号的地方）并运行：

python voc_label.py

在这里插入图片描述

（报错：
上面代码错写成：
原因是：Windows和Linux不一样）

运行完会生成如下文件和VOC2007文件夹下一个labels文件夹：
在这里插入图片描述

3、配置文件

把voc.data、coco.names，yolov4.cfg、yolov4.conv.137拷贝到放在VOCdevkit同级目录下，修改前三个：

.names文件准备

.names保存检测类别名称。将源码里面data文件夹下voc.names或coco.names文件。将内容改为我们自己的检测类别。

.data文件准备

.data保存相关文件路径。将源码里面cfg文件夹下voc.data文件，将对应部分修改

classes：需要检测的类型个数。

train：训练集里面的2007_train.txt路径。（voc_label.py生成的）

valid：验证集里面的2007_val.txt路径。（voc_label.py生成的）

names：coco.names的路径。

backup=backup/。

注意：路径错了，文件选错了，都报错。

.cfg文件准备

进入darknet/cfg目录下，复制yolov4-custom.cfg，名字改为yolov4.cfg，并打开该文件，进行下面的6处修改：

（1）yolov4-my.cfg文件第1-7行如下：
----------------------------------------------------------------
[net]
# Testing
#batch=1
#subdivisions=1
# Training
batch=64
subdivisions=16
----------------------------------------------------------------
注意：由于是进行训练，这里不需要修改。训练过程中可能出现CUDA out of memory的提示，可将这里的subdivisions增大，如32或64，但是数值越大耗时越长，因此需要权衡一下；或调小batch。

（2）yolov4-my.cfg文件第8-9行可将608修改为416：
----------------------------------------------------------------
width=416
height=416
----------------------------------------------------------------
注意：这里也可不改，如果原始的数值608可能会导致CUDA out of memory的提示，而且这里的数值必须是32的倍数，这里也是数值越大耗时越长；

如果不是标准数据集。还要进行一下修改：
（3）第20行的参数max_batches原始值为500500，（如果不是标准数据集也要修改，max_batches = classes*2000，但是max_batches不要低于训练的图片张数）

（4）第22行的参数steps=（）,（），这两个数值分别为max_batches的80%和90%；

（5）继续修改yolov4-cat.cfg文件，（Windows下：按Ctrl+F键；Linux下：按ESC，输入”/文字“回车，即可找到第一个，并且光标定位；修改完，按ESC，再按n，就到下一个，再按n，下下个，n，下下下个，挨个改；要想一次把所有都改了：按ESC，输入 :1,$ s/文字/改后的文字/g 回车）搜索“classes”，一共有3处，先定位到第一处，将classes=80改为classes=自己的，并将classes前面最近的filters修改为自己的（计算由来filters=（classes+5）*3）；

（6）继续修改yolov4-cat.cfg文件，按照上面的步骤同样修改第二处和第三处的classes；

4、开始训练

在Darknet文件夹下右键打开终端，运行

./darknet detector train voc.data yolov4.cfg yolov4.conv.137

注意：全部换成绝对路径

图片测试：

./darknet detect cfg/yolov4.cfg yolov4.weights data/dog.jpg

视频测试：

./darknet detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights <video file>

摄像头测试：

./darknet detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights

测试mAP

./darknet detector map cfg/voc.data cfg/yolov4-voc.cfg backup/yolov4-voc_last.weights

COCO数据集的json2xml

from pycocotools.coco import COCO
import os
import shutil
from tqdm import tqdm
import skimage.io as io
import matplotlib.pyplot as plt
import cv2
from PIL import Image, ImageDraw

#提取出的类别的保存路径i
savepath="/data/yolov4.1/darknet/coco2017/VOC2020/"
datasets_list=['train2017']    
##运行完之后再改为val2017再运行一次
img_dir=savepath+'images/'         #####这个路径会把你处理的图片拷贝进来，这里我们只处理了train2017文件夹下的数据，所以处理好之后需要修改生成image文件夹的名称为train2017
anno_dir=savepath+'annotations/'       # 当前目录下会生成annotations文件夹存放xml，结束后修改名称
#这里填写需要提取的类别
classes_names =['liner','container ship', 'bulk carrier','island reef','sailboat', 'other ship']
#原coco数据集的目录
dataDir= '/data/yolov4.1/darknet/coco2017'

headstr = """\
<annotation>
    <folder>VOC</folder>
    <filename>%s</filename>
    <source>
        <database>My Database</database>
        <annotation>COCO</annotation>
        <image>flickr</image>
        <flickrid>NULL</flickrid>
    </source>
    <owner>
        <flickrid>NULL</flickrid>
        <name>company</name>
    </owner>
    <size>
        <width>%d</width>
        <height>%d</height>
        <depth>%d</depth>
    </size>
    <segmented>0</segmented>
"""

objstr = """\
    <object>
        <name>%s</name>
        <pose>Unspecified</pose>
        <truncated>0</truncated>
        <difficult>0</difficult>
        <bndbox>
            <xmin>%d</xmin>
            <ymin>%d</ymin>
            <xmax>%d</xmax>
            <ymax>%d</ymax>
        </bndbox>
    </object>
"""
 
tailstr = '''\
</annotation>
'''
def mkr(path):
    if os.path.exists(path):
        shutil.rmtree(path)
        os.mkdir(path)
    else:
        os.mkdir(path)
mkr(img_dir)
mkr(anno_dir)

def id2name(coco):
    classes=dict()
    for cls in coco.dataset['categories']:
        classes[cls['id']]=cls['name']
    return classes
 
def write_xml(anno_path,head, objs, tail):
    f = open(anno_path, "w")
    f.write(head)
    for obj in objs:
        f.write(objstr%(obj[0],obj[1],obj[2],obj[3],obj[4]))
    f.write(tail)
 
 
def save_annotations_and_imgs(coco,dataset,filename,objs):
    anno_path=anno_dir+filename[:-3]+'xml'
    print('anno_path:%s'%anno_path)
    #img_path=dataDir+'/'+'images'+'/'+dataset+'/'+filename
    img_path=dataDir+'/'+dataset+'/'+filename
    print('img_path:%s'%img_path)
    print('step3-image-path-OK')
    dst_imgpath=img_dir+filename
 
    img=cv2.imread(img_path)
    '''if (img.shape[2] == 1):
        print(filename + " not a RGB image")     
        return''' 
    print('img_path:%s'%img_path)
    print('dst_imgpath:%s'%dst_imgpath)
    shutil.copy(img_path, dst_imgpath)
 
    head=headstr % (filename, img.shape[1], img.shape[0], img.shape[2])
    tail = tailstr
    write_xml(anno_path,head, objs, tail)
 
 
def showimg(coco,dataset,img,classes,cls_id,show=True):
    global dataDir
    #I=Image.open('%s/%s/%s/%s'%(dataDir,'images',dataset,img['file_name']))
    I=Image.open('%s/%s/%s'%(dataDir,dataset,img['file_name']))  ########may be you can changed
    annIds = coco.getAnnIds(imgIds=img['id'], catIds=cls_id, iscrowd=None)
    anns = coco.loadAnns(annIds)
    objs = []
    for ann in anns:
        class_name=classes[ann['category_id']]
        if class_name in classes_names:
            print(class_name)
            if 'bbox' in ann:
                bbox=ann['bbox']
                xmin = int(bbox[0])
                ymin = int(bbox[1])
                xmax = int(bbox[2] + bbox[0])
                ymax = int(bbox[3] + bbox[1])
                obj = [class_name, xmin, ymin, xmax, ymax]
                objs.append(obj)
                #draw = ImageDraw.Draw(I)
                #draw.rectangle([xmin, ymin, xmax, ymax])
    # if show:
        # plt.figure()
        # plt.axis('off')
        # plt.imshow(I)
        # plt.show()
    return objs
 
for dataset in datasets_list:
    annFile='/data/yolov4.1/darknet/coco2017/annotations/instances_train2017.json' # 你放json文件的路径
    print('annFile:%s'%annFile)  
    coco = COCO(annFile)         
    '''
    loading annotations into memory...
    Done (t=0.81s)
    creating index...
    index created!
    '''
    classes = id2name(coco)                     
    print("classes:%s"%classes)
    classes_ids = coco.getCatIds(catNms=classes_names)
    print(classes_ids)
    for cls in classes_names:
        cls_id=coco.getCatIds(catNms=[cls])
        img_ids=coco.getImgIds(catIds=cls_id)
        print(cls,len(img_ids))
        # imgIds=img_ids[0:10]
        for imgId in tqdm(img_ids):
            img = coco.loadImgs(imgId)[0]
            filename = img['file_name']
            #print(filename)
            objs=showimg(coco, dataset, img, classes,classes_ids,show=False)  
            #print(objs)
            save_annotations_and_imgs(coco, dataset, filename, objs)

对COCO验证集进行检测

./darknet -i 0 detector valid cfg/coco.data cfg/yolov3.cfg yolov3.weights # '-i 0'代表使用0号GPU

运行完上述命令后会生成results/coco_results.json文件，该文件保存了检测结果计算mAP。
注意：运行此命令的时候coco.data里的必须添加eval = coco不然生成的文件是class类个txt文件，结果会自动生成在result文件夹下。

coco数据集计算mAP
在darknet目录下编写一个python脚本(compute_coco_mAP.py)用于计算mAP（注意根据自己的实际情况修改两个文件路径）

#-*- coding:utf-8 -*-
import matplotlib.pyplot as plt 
from pycocotools.coco import COCO 
from pycocotools.cocoeval import COCOeval 
import numpy as np 
import skimage.io as io 
import pylab,json 
pylab.rcParams['figure.figsize'] = (10.0, 8.0) 
def get_img_id(file_name): 
    ls = [] 
    myset = [] 
    annos = json.load(open(file_name, 'r')) 
    for anno in annos: 
      ls.append(anno['image_id']) 
    myset = {}.fromkeys(ls).keys() 
    return myset 
if __name__ == '__main__': 
    annType = ['segm', 'bbox', 'keypoints']#set iouType to 'segm', 'bbox' or 'keypoints'
    annType = annType[1] # specify type here
    cocoGt_file = 'data/coco/annotations/instances_val2014.json' #需要根据自己的实际情况配置该路径
    cocoGt = COCO(cocoGt_file)#取得标注集中coco json对象
    cocoDt_file = 'results/coco_results.json' #需要根据自己的实际情况配置该路径
    imgIds = get_img_id(cocoDt_file) 
    print(len(imgIds))
    cocoDt = cocoGt.loadRes(cocoDt_file)#取得结果集中image json对象
    imgIds = sorted(imgIds)#按顺序排列coco标注集image_id
    imgIds = imgIds[0:5000]#标注集中的image数据
    cocoEval = COCOeval(cocoGt, cocoDt, annType) 
    cocoEval.params.imgIds = imgIds#参数设置
    cocoEval.evaluate()#评价
    cocoEval.accumulate()#积累
    cocoEval.summarize()#总结

运行compute_coco_mAP.py脚本

python compute_coco_mAP.py

YingTUNG

关注

2
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Ubuntu下YOLOv4训练自己的数据成功！

Ubuntu下YOLOv4训练自己的数据本博客主要：参考来源假设已有原始.jpg图片和打好标签的.xml文件（注意：要对应，图片命名不要出现空格、中文和（2）等）。1、利用voc制作自己的数据集在目录下新建VOC2007，并在VOC2007下新建Annotations，ImageSets和JPEGImages三个文件夹。在ImageSets下新建Main文件夹。文件目录如下所示：将自己的数据集.jpg图片拷贝到JPEGImages目录下，将数据集标签文件中.xml文件拷贝到Annotations
复制链接

扫一扫