精华内容
下载资源
问答
  • yolov4训练自制数据集

    千次阅读 2020-11-22 18:51:18
    yolov4训练自制数据集(过拟合版本)

    一、准备代码和预训练权重:

    本次训练代码参考:https://github.com/bubbliiiing/yolov4-pytorch

    二、准备数据集:

    1、标注工具

    本次使用的标注工具为lablelimg,安装方式见:https://blog.csdn.net/ssunshining/article/details/109453311

    2、准备图片数据:

    统一数据为RGB格式图片,大小无所谓能看清目标即可

    jpg图片存放在Photo文件夹下(下图中的所有文件都放在mydataset文件夹下):

    image.png

    三、准备标签数据

    1、使用labelimg的VOC数据标注格式,标注的.xml文件存放在Annotations文件夹下,标注注完成之后,将标注过的图片移动到JPEGImages文件夹下。

    2、运行generate_my_train_TXT.py文件生成可以对应文件名与xml的txt文件

    (注意:如果是自己的文件,需要修改路径)

    image.png

     

    3.运行xparse_myAnnotations.py文件生成训练数据的标签

     

    image.png

    前边是图片的绝对路径,后边的数字每5个一组(目标的位置+类别),将生成的txt文件复制到mydataset文件夹下面。

     

    (注意需要修改:

    image.png

     

    4.建立类别标签的txt文件,如果类别较少可以手动写入到mydataset文件夹下的obj_class.txt文件中,类别较多可以自己写个python文件写入。

    image.png

    5.运行kmeans_for_anchors.py生成先验框,会自动写入到yolo_anchors.txt文件中

    先验框如下,一共9组:

    image.png

    三、训练过程

    运行train.py文件,等待运行完成

    (注意:需要修改annotation_path为训练标签的路径,classes_path为类别标签的路径,model_path为预训练权重的路径)

    每次保存的参数会保存在logs文件夹下

    四、测试训练效果

    由于本次的训练是过拟合版本直接,直接运行predict.py文件,输入需要检测的图片的路径就可以成功进行检测。

    (注意:需要在yolo.py文件中更改以下参数

    image.png

    其中model_path为保存的权重的路径,anchors_path为先验框的txt的路径,classes_path为类别标签的路径,model_image_size和训练有关,和train.py中的input_shape保持一致 ,confidence为置信度大小

    image.png

    训练效果展示:

    image.png

     

    参考资料:

    https://www.bilibili.com/video/BV1Q54y1D7vj?t=96&p=12

    https://blog.csdn.net/weixin_44791964/article/details/106214657

    https://blog.csdn.net/nan355655600/article/details/106246625?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160603577619724838503635%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=160603577619724838503635&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v1~rank_blog_v1-1-106246625.pc_v1_rank_blog_v1&utm_term=yolov4&spm=1018.2118.3001.4450

    展开全文
  • yolov5训练自己数据集

    千次阅读 2021-01-08 12:20:24
    yolov5训练自己数据集 项目地址:https://github.com/ultralytics/yolov5 环境:Windows pytorch-gpu==1.6.0 ** 一、数据集准备** ├── data │ ├── Annotations 进行 detection 任务时的标签文件,xml 形式,...

    yolov5训练自己数据集

    项目地址:https://github.com/ultralytics/yolov5
    环境:Windows pytorch-gpu==1.6.0

    ** 一、数据集准备**

    ├── data
    │   ├── Annotations  进行 detection 任务时的标签文件,xml 形式,文件名与图片名一一对应
    │   ├── images  存放 .jpg 格式的图片文件
    │   ├── ImageSets  存放的是分类和检测的数据集分割文件,包含train.txt, val.txt,trainval.txt,test.txt
    │   ├── labels  存放label标注信息的txt文件,与图片一一对应
    
    ├── ImageSets(train,val,test建议按照8:1:1比例划分)
    │   ├── train.txt  写着用于训练的图片名称
    │   ├── val.txt  写着用于验证的图片名称
    │   ├── trainval.txt  train与val的合集
    │   ├── test.txt  写着用于测试的图片名称
    
    

    1.ImageSets 下文件的生成
    运行我的data文件夹下的makeTxt.py文件。生成如图所示data/ImageSets下四个文件。

    文件内容如图所示:
    在这里插入图片描述
    makeTxt.py完整代码如下:

    import os
    import random
    
    trainval_percent = 0.1# 训练集和验证集所占比例,剩下的0.2是测试集比例
    train_percent = 0.9# 训练集所占比例
    xmlfilepath = './Annotations'
    txtsavepath = './ImageSets'
    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/trainval.txt', 'w') #只包含名称,没有后缀和路径
    ftest = open('./ImageSets/test.txt', 'w')
    ftrain = open('./ImageSets/train.txt', 'w')
    fval = open('./ImageSets/val.txt', 'w')
    
    for i in list:
        name = total_xml[i][:-4] + '\n'
        if i in trainval:
            ftrainval.write(name)
            if i in train:
                ftest.write(name)
            else:
                fval.write(name)
        else:
            ftrain.write(name)
    ftrainval.close()
    ftrain.close()
    fval.close()
    ftest.close()
    

    运行voc_label.py文件,将图片数据集标注后的xml文件中的标注信息读取出来并写入txt文件,运行后在labels文件夹中出现所有图片数据集的标注信息,并在data目录下生成三个txt文件。
    在这里插入图片描述

    # xml解析包 在labels中存放txt格式的标签信息
    import xml.etree.ElementTree as ET
    import pickle
    import os
    # os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
    from os import listdir, getcwd
    from os.path import join
    
    
    sets = ['train', 'test', 'val']
    classes = ['jyz', 'xcxj', 'fzc', 'nc','jyz_gz','fzc_gz']
    
    
    # 进行归一化操作
    def convert(size, box): # size:(原图w,原图h) , box:(xmin,xmax,ymin,ymax)
        dw = 1./size[0]     # 1/w
        dh = 1./size[1]     # 1/h
        x = (box[0] + box[1])/2.0   # 物体在图中的中心点x坐标
        y = (box[2] + box[3])/2.0   # 物体在图中的中心点y坐标
        w = box[1] - box[0]         # 物体实际像素宽度
        h = box[3] - box[2]         # 物体实际像素高度
        x = x*dw    # 物体中心点x的坐标比(相当于 x/原图w)
        w = w*dw    # 物体宽度的宽度比(相当于 w/原图w)
        y = y*dh    # 物体中心点y的坐标比(相当于 y/原图h)
        h = h*dh    # 物体宽度的宽度比(相当于 h/原图h)
        return (x, y, w, h)    # 返回 相对于原图的物体中心点的x坐标比,y坐标比,宽度比,高度比,取值范围[0-1]
    
    
    # year ='2012', 对应图片的id(文件名)
    def convert_annotation(image_id):
        '''
        将对应文件名的xml文件转化为label文件,xml文件包含了对应的bunding框以及图片长款大小等信息,
        通过对其解析,然后进行归一化最终读到label文件中去,也就是说
        一张图片文件对应一个xml文件,然后通过解析和归一化,能够将对应的信息保存到唯一一个label文件中去
        labal文件中的格式:calss x y w h  同时,一张图片对应的类别有多个,所以对应的bunding的信息也有多个
        '''
        # 对应的通过year 找到相应的文件夹,并且打开相应image_id的xml文件,其对应bund文件
        in_file = open('./Annotations/%s.xml' % (image_id), encoding='utf-8')
        # 准备在对应的image_id 中写入对应的label,分别为
        # <object-class> <x> <y> <width> <height>
        out_file = open('./labels/%s.txt' % (image_id), 'w', encoding='utf-8')
        # 解析xml文件
        tree = ET.parse(in_file)
        # 获得对应的键值对
        root = tree.getroot()
        # 获得图片的尺寸大小
        size = root.find('size')
        # 获得宽
        w = int(size.find('width').text)
        # 获得高
        h = int(size.find('height').text)
        # 遍历目标obj
        for obj in root.iter('object'):
            # 获得difficult ??
            difficult = obj.find('difficult').text
            # 获得类别 =string 类型
            cls = obj.find('name').text
            # 如果类别不是对应在我们预定好的class文件中,或difficult==1则跳过
            if cls not in classes or int(difficult) == 1:
                continue
            # 通过类别名称找到id
            cls_id = classes.index(cls)
            # 找到bndbox 对象
            xmlbox = obj.find('bndbox')
            # 获取对应的bndbox的数组 = ['xmin','xmax','ymin','ymax']
            b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
                 float(xmlbox.find('ymax').text))
            print(image_id, cls, b)
            # 带入进行归一化操作
            # w = 宽, h = 高, b= bndbox的数组 = ['xmin','xmax','ymin','ymax']
            bb = convert((w, h), b)
            # bb 对应的是归一化后的(x,y,w,h)
            # 生成 calss x y w h 在label文件中
            out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    
    
    # 返回当前工作目录
    wd = getcwd()
    print(wd)
    
    
    for image_set in sets:
        '''
        对所有的文件数据集进行遍历
        做了两个工作:
        1.讲所有图片文件都遍历一遍,并且将其所有的全路径都写在对应的txt文件中去,方便定位
        2.同时对所有的图片文件进行解析和转化,将其对应的bundingbox 以及类别的信息全部解析写到label 文件中去
             最后再通过直接读取文件,就能找到对应的label 信息
        '''
        # 先找labels文件夹如果不存在则创建
        if not os.path.exists('./labels/'):
            os.makedirs('./labels/')
        # 读取在ImageSets/Main 中的train、test..等文件的内容
        # 包含对应的文件名称
        image_ids = open('./ImageSets/%s.txt' % (image_set)).read().strip().split()
        # 打开对应的2012_train.txt 文件对其进行写入准备
        list_file = open('./%s.txt' % (image_set), 'w')
        # 将对应的文件_id以及全路径写进去并换行
        for image_id in image_ids:
            list_file.write('./images/%s.jpg\n' % (image_id))
            # 调用  year = 年份  image_id = 对应的文件名_id
            convert_annotation(image_id)
        # 关闭文件`在这里插入代码片`
        list_file.close()
    

    二、模型训练和检测
    1.在data目录下,复制一份coco.yaml文件并将其重命名为my.yaml,放在data目录下,并对cat.yaml中的参数进行配置。

    #修改训练集、验证集和测试集txt路径
    train: data/train.txt  # 118287 images
    val: data/val.txt  # 5000 images
    test: data/test.txt  # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
    # 修改类别数
    nc: 6
    
    # 修改类名
    names: ['jyz', 'xcxj', 'fzc', 'nc','jyz_gz','fzc_gz']
    

    2.修改models目录下的yolov5s.yaml文件。这里可以根据自己选择的模型大小修改对应文件。

    nc: 6   #nc:类别数,你的类别有多少就填写多少。从1开始算起,不是0-14这样算。
    #顺便一提, 下面两个参数可控制网络结构,不需修改,与模型大小已经对应。
    depth_multiple: 0.33  # 控制模型的深度,假设yolov5l中有三个Bottleneck,那yolov5s中就只有一个Bottleneck。
    width_multiple: 0.50  # 控制卷积核的个数设置为0.5,Focus就变成[32, 3],Conv就变成[64, 3, 2]。以此类推,卷积核的个数都变成了设置的一半。
    

    3.训练参数修改 train.py,也可在终端通过命令进行指定参数。注意修改以下几个参数。运行train.py

    parser.add_argument('--weights', type=str, default='yolov5s.pt', help='initial weights path')
    parser.add_argument('--cfg', type=str, default='models/yolov5s.yaml', help='model.yaml path')
    #自己的yaml文件
    parser.add_argument('--data', type=str, default='data/my.yaml', help='data.yaml path')
    parser.add_argument('--epochs', type=int, default=300)
    #爆显存的话调小一点
    parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs')
    parser.add_argument('--img-size', nargs='+', type=int, default=[640, 640], help='[train, test] image sizes')
    # 训练的设备,cpu;0(表示一个gpu设备cuda:0);0,1,2,3(多个gpu设备)。值为空时,训练时默认使用计算机自带的显卡或CPU
    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    # dataloader的最大worker数量。这里我记得报错,可以将workers修改为0.
    parser.add_argument('--workers', type=int, default=4, help='maximum number of dataloader workers')
    
    

    可视化:进入环境
    tensorboard --logdir runs
    根据提示打开浏览器http://localhost:6006/
    4.检测需要修改的参数,一般修改的以下几个参数,然后运行detect.py。

    # 选用训练的权重
    parser.add_argument('--weights', nargs='+', type=str, default='runs/train/exp/weights/best.pt', help='model.pt path(s)')
    # source=0表示摄像头实时检测,也可输入视频路径
    parser.add_argument('--source', type=str, default='inference/videos/jyz.mp4', help='source') 
    # 网络输入图片大小
    parser.add_argument('--view-img', action='store_true', help='display results')
    # 是否将检测的框坐标以txt文件形式保存,默认False,当需要报存时,可修改路径default="inference/output"
    parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
    # 设置只保留某一部分类别,添加语句default=[0,1,2]等id。
    parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
    

    三、pytorch转onnx
    1.官方自带的export.py,选择模型

    python models/export.py --weights weights/yolov5s.pt --img 640 --batch 1
    

    2.根据错误提示pip install coremltools、packaging。然后继续运行1的命令
    3.此时 weights下出现三个文件 :onnx、mlmodel、torchscript
    4.使用神经网络Netron,出现网络结构图。

    import netron
    netron.start('yolov5s.onnx')
    

    5 . pt模型转为了onnx模型,可以说已经脱离了pytorch了,但是转ncnn还需要对模型做一个Simplifier操作,因为转出的onnx模型还有许多冗余,这在ncnn里也是不支持的,避免转ncnn时各种报错安装简化 打开weights简化

    python -m onnxsim yolov5s.onnx yolov5s_sim.onnx 
    

    四、 遇到的问题
    1.路径一定不要包含中文,不让opencv报错。如果必须要读中文的话,读取路径那里添加一句话:

    img = cv2.imdecode(np.fromfile(img_path, dtype=np.uint8), -1)
    

    2.batch-size要根据自己显存调节,不然会报错。

    展开全文
  • YoloV4训练自己数据集

    千次阅读 热门讨论 2020-11-16 14:15:50
    YoloV4训练自己数据集


    1-建立工作文件夹

    新建一个项目文件夹,用于存放接下来训练所需要的文件。

    mkdir train    # 或者其他英文名
    

    切换至工作文件夹

    cd train
    

    按照下图所示建立相关文件夹和文件。

    .
    ├── JPEGImages
    ├── Annotations
    ├── labels
    ├── backup
    ├── data
    │   ├── train.data
    │   ├── train.names
    │   ├── yolov4.cfg
    │   ├── yolov4-tiny.cfg
    ├── darknet
    ├── gen_files.py
    ├── yolov4.conv.137
    ├── yolov4-tiny.conv.29
    
    相关文件夹的作用
    文件/文件夹作用
    JPEGImages用于存放训练需要使用的图片
    Annotations用于存放训练图片对应的XML标注文件
    labels用于存放YOLO格式的txt标注文件
    backup用于存放训练出来的模型文件
    data用于存放模型训练需要的一些参数文件
    相关文件的作用
    文件作用如何获取
    darknetdarknet可执行文件编译darknet后,将darknet可执行文件拷贝进来
    gen_files.py用于对训练图片和标注进行处理归档见下面的gen_files.py文件内容
    yolov4.conv.137yolov4在coco数据集上的预训练权重文件(不含yolo head层)自行下载
    yolov4-tiny.conv.29yolov4-tiny在coco数据集上的预训练权重文件(不含yolo head层)自行下载
    train.data训练数据自行建立,一会在里面添加文本内容
    train.names训练的标签自行建立,一会在里面添加文本内容
    yolov4.cfg训练YoloV4需要的结构文件在darknet项目的cfg文件夹里,拷贝进来即可
    yolov4-tiny.cfg训练YoloV4-Tiny需要的结构文件在darknet项目的cfg文件夹里,拷贝进来即可

    gen_files.py内容如下:

    import xml.etree.ElementTree as ET
    import pickle
    import os
    from os import listdir, getcwd
    from os.path import join
    import random
    
    # 类别列表
    classes=["ball"]
    
    
    # 递归清除Linux隐藏文件
    def clear_hidden_files(path):
        dir_list = os.listdir(path)
        for i in dir_list:
            abspath = os.path.join(os.path.abspath(path), i)
            if os.path.isfile(abspath):
                if i.startswith("._"):
                    os.remove(abspath)
            else:
                clear_hidden_files(abspath)
    
    
    # PASCAL VOC格式的xml标注文件 转换为 YOLO格式的txt文本标注文件
    def convert(size, box):
        '''
        size = (w, h)
        box = (xmin, xmax, ymin, ymax)
        '''
        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_annotation(image_id):
        in_file = open('Annotations/%s.xml' %image_id)
        out_file = open('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
            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))
            bb = convert((w,h), b)
            out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
        in_file.close()
        out_file.close()
    
    
    # 当前目录
    wd = os.getcwd()
    
    # 检查是否存在Annotations文件夹
    annotation_dir = os.path.join(wd, "Annotations/")
    if not os.path.isdir(annotation_dir):
            os.mkdir(annotation_dir)
    # 清除隐藏文件
    clear_hidden_files(annotation_dir)
    
    # 检查是否存在JPEGImages文件夹
    image_dir = os.path.join(wd, "JPEGImages/")
    if not os.path.isdir(image_dir):
            os.mkdir(image_dir)
    # 清除隐藏文件
    clear_hidden_files(image_dir)
    
    # 检查是否存在backup文件夹
    backup_dir = os.path.join(wd, "backup/")
    if not os.path.isdir(backup_dir):
            os.mkdir(backup_dir)
    # 清除隐藏文件
    clear_hidden_files(backup_dir)
    
    # 检查是否存在labels文件夹
    labels_dir = os.path.join(wd, "labels/")
    if not os.path.isdir(labels_dir):
            os.mkdir(labels_dir)
    # 清除隐藏文件
    clear_hidden_files(labels_dir)
    
    # 新建文件train.txt、test.txt
    # 存放需要训练和测试的完整文件路径
    train_file = open(os.path.join(wd, "train.txt"), 'w')
    test_file = open(os.path.join(wd, "test.txt"), 'w')
    train_file.close()
    test_file.close()
    
    
    # 训练数据集
    train_file = open(os.path.join(wd, "train.txt"), 'a')
    # 测试数据集
    test_file = open(os.path.join(wd, "test.txt"), 'a')
    
    # 列出所有图片文件
    list = os.listdir(image_dir)
    # 设置训练集/测试集划分比例的随机数
    probo = random.randint(1, 100)
    print("Probobility: %d" % probo)
    for i in range(0,len(list)):
        path = os.path.join(image_dir,list[i])
        if os.path.isfile(path):
            image_path = image_dir + list[i]
            # 根据文件名,得到没有后缀的文件名和后缀名
            (nameWithoutExtention, extention) = os.path.splitext(os.path.basename(image_path))
            # 标注文件名
            annotation_name = nameWithoutExtention + '.xml'
            # 标注文件地址
            annotation_path = os.path.join(annotation_dir, annotation_name)
        # 设置训练集/测试集划分比例的随机数
        probo = random.randint(1, 100)
        print("Probobility: %d" % probo)
        # 训练集和测试集的划分,这里的75代表训练集/测试集的划分比例为75:25
        # 训练集
        if(probo < 75):
            if os.path.exists(annotation_path):
                # 在当前目录下的train.txt文本文件中,写入训练图片的完整地址
                train_file.write(image_path + '\n')
                # 执行标注格式转换
                convert_annotation(nameWithoutExtention)
        # 测试集
        else:
            if os.path.exists(annotation_path):
                # 在当前目录下的test.txt文本文件中,写入训练图片的完整地址
                test_file.write(image_path + '\n')
                # 执行标注格式转换
                convert_annotation(nameWithoutExtention)
    # 文件操作结束后,关闭文件流
    train_file.close()
    test_file.close()
    

    2-准备训练数据集

    2-1 将训练所需的图片拷贝至JPEGImages文件夹下。

    2-2 将训练图片对应的XML标注文件拷贝至Annotations下。

    确保labels文件夹下没有文件及隐藏文件
    确保训练图片和标注一一对应

    2-3 修改gen_files.py中的classes为自己的标签。

    例如:

    classes = ["person", "phone", "chair"]
    

    有几个标签修改为几个。

    2-4 在终端运行gen_files.py

    python3 gen_files.py
    

    此时会在当前训练文件夹生成文本文件train.txttest.txt
    labels文件夹下会生成YOLO格式的txt标注文件。

    train.txt文件内容为训练集图片的绝对地址的集合,一行一条。
    test.txt文件内容为测试集图片的绝对地址的集合,一行一条。

    可以看到train.txttest.txt中的条目数的比例大致为之前设置的75:25。
    当然也可以设置为其他的训练集/测试集划分比例。

    labels下的文件是JPEGImages文件夹下每一个图像的YOLO格式的标注文件,这是由Annotations文件夹的xml标注文件转换来的。

    最终训练只需要:

    • train.txt
    • test.txt
    • labels文件夹下的txt文本标注文件
    • JPEGImages文件夹下的图像文件

    此时训练文件夹的目录树如下所示:

    .
    ├── JPEGImages
    ├── Annotations
    ├── labels
    ├── backup
    ├── data
    │   ├── train.data
    │   ├── train.names
    │   ├── yolov4.cfg
    │   ├── yolov4-tiny.cfg
    ├── darknet
    ├── gen_files.py
    ├── yolov4.conv.137
    ├── yolov4-tiny.conv.29
    ├── train.txt
    ├── test.txt
    

    新增train.txttest.txt
    labels文件夹下新增n个YOLO格式的txt标注文件。


    3 修改配置文件

    3-1 新建data/train.names文件

    可以复制darknet目录下的data/voc.names到训练目录下的data/train.names
    再根据自己情况的修改,可以重新命名如:data/train.names

    names文件存放训练的标签,一行一个标签,不要有空行。

    例如3个标签的情况下,可以修改为:

    person
    phone
    chair
    

    替换为自己训练的标签即可。

    3-2 新建data/train.data文件
    可以复制darknet目录下的cfg/coco.data到训练目录下的data/train.data

    再根据自己情况的修改,可以重新命名如:data/train.data

    data文件存放类别数、训练集位置、测试集位置、names文件位置、训练出来的模型的存放地址等信息。

    例如:

    classes = 80
    train  = train.txt
    valid  = test.txt
    #valid = data/coco_val_5k.list
    names = data/train.names
    backup = backup
    eval = coco
    

    这里的文件地址都是相对于训练工作文件夹的。

    train.data相关参数及其作用
    参数名作用
    classes类别数,标注、训练了几个类别,就写几
    train训练集train.txt的文件地址
    valid测试集test.txt的文件地址
    namesnames标签文件的文件地址
    backup训练出来的模型的存放文件夹
    eval评估参数(暂时没有搞明白)

    3-3和3-4二选一,看需要训练的模型是YoloV4还是YoloV4-Tiny。


    3-3 新建data/yolov4-tiny.cfg
    可以复制darknet目录下的cfg/yolov4-tiny.cfg到训练目录下的yolov4-tiny.cfg
    再根据自己情况的修改,可以重新命名data/yolov4-tiny-xxx.cfg

    batch = 64
    subdivisions = 32
    

    data/yolov4-tiny.cfg文件中,两个yolo层和各自前面的convolutional层的参数需要修改:

    • 两个yolo层都要改:yolo层中的classes为类别数
    • 每一个yolo层前的convolutional层中的filters =(类别+5)* 3

    例如:
    yolo层:classes=1;convolutional层:filters=18
    yolo层:classes=2; convolutional层:filters=21
    yolo层:classes=4;convolutional层:filters=27

    3-4 新建data/yolov4.cfg

    可以复制darknet目录下的cfg/yolov4.cfg到训练目录下的yolov4.cfg
    再根据自己情况的修改,可以重新命名data/yolov4-xxx.cfg

    batch = 64
    subdivisions = 32
    

    data/yolov4.cfg文件中,两个yolo层和各自前面的convolutional层的参数需要修改:

    • 两个yolo层都要改:yolo层中的classes为类别数
    • 每一个yolo层前的convolutional层中的filters =(类别+5)* 3

    例如:
    yolo层:classes=1;convolutional层:filters=18
    yolo层:classes=2; convolutional层:filters=21
    yolo层:classes=4;convolutional层:filters=27


    4-Anchor Box先验框聚类分析与修改

    4-1 使用k-means聚类获得自己数据集的先验框大小

    对于YoloV4-Tiny:

    ./darknet detector calc_anchors data/train.data -num_of_clusters 6 -width 416 -height 416
    

    对于YoloV4:

    ./darknet detector calc_anchors data/train.data -num_of_clusters 9 -width 416 -height 416
    

    4-2 修改cfg文件中的先验框大小

    cfg文件中的anchors位置的几个数字

    4-3 重新训练和测试

    5-训练自己的数据集

    5-1 确保yolov4-tiny.conv.29或者yolov4.conv.137在训练文件夹下

    5-2 开始训练

    训练命令:

    ./darknet detector train data文件地址 cfg文件地址 预训练权重文件(不含yolo head层) -map
    

    如需无须显示训练过程的map变化,在命令末尾加-map,即:

    ./darknet detector train data/train.data data/yolov4-tiny.cfg yolov4-tiny.conv.29
    

    如需要显示训练过程的map变化,在命令末尾加-map,即:

    ./darknet detector train data/train.data data/yolov4-tiny.cfg yolov4-tiny.conv.29 -map
    

    对于YoloV4模型的训练,只需要把命令里的cfg配置文件和预训练权重文件替换为YoloV4版本的就可以。

    5-3 训练建议

    • batch=64
    • subdivisions=4(或2,1)
    • YOLOv4: 把max_batches设置为 (classes*2000);但最小为4000。 YOLOv4-tiny可减少
    • YOLOv4: 把steps改为max_batches的80% and 90%;例如steps=3200, 3600。YOLOv4-tiny可相应减少
    • 为增加网络分辨率可增大heightwidth的值,但必须是32的倍数 (height=608, width=608或者是32的整数倍) 。这有助于提高检测精度

    6-测试训练出来的网络模型

    训练好后可以在backup目录下看到权重文件。

    测试图片

    ./darknet detector test data/train.data data/yolov4-tiny.cfg backup/yolov4-tiny_best.weights xxx.jpg
    

    测试视频

    ./darknet detector demo data/train.data data/yolov4-tiny.cfg backup/yolov4-tiny_best.weights xxx.mp4
    

    7-性能统计

    模型的性能主要体现在:mAP

    6-1 统计 mAP@IoU=0.50:

    ./darknet detector map data/train.data data/yolov4-tiny.cfg backup/yolov4-tiny_best.weights
    

    6-2 统计 mAP@IoU=0.75:

    ./darknet detector map data/train.data data/yolov4-tiny.cfg backup/yolov4-tiny_best.weights -iou_thresh 0.75
    
    展开全文
  • YOLOv4训练自定义数据集

    千次阅读 2020-06-01 17:39:01
    YOLOv4 训练自定义数据集 [Github 原文档] @Bobby Chen 记得留下小星星 YOLOv4 水下目标检测 0. 配置环境 Ubuntu 16.04/18.04 CUDA 10.0 cuDNN 7.6.0 Python 3.6 OpenCV 4.2.0 tensorflow-gpu 1.13.0 1. 下载依赖...

    YOLOv4 训练自定义数据集

    [Github 原文档] @Bobby Chen 记得留下小星星

    YOLOv4 水下目标检测

    0. 配置环境

    • Ubuntu 16.04/18.04
    • CUDA 10.0
    • cuDNN 7.6.0
    • Python 3.6
    • OpenCV 4.2.0
    • tensorflow-gpu 1.13.0

    1. 下载依赖项 - [Github]

    pip3 install -r requirements.txt
    

    Download the source code

    git clone https://github.com/AlexeyAB/darknet.git
    cd darknet
    
    vim Makefile
    
    GPU=1
    CUDNN=1 
    CUDNN_HALF=1 
    OPENCV=1 
    DEBUG=1 
    OPENMP=1 
    LIBSO=1 
    ZED_CAMERA=1 
    
    make
    

    2. 下载预训练权重

    [Google drive] - yolov4.conv.137

    [Baidu drive] - yolov4.conv.137 code: nppt


    3. 标记自定义数据集 (可跳过

    LabelImg is a graphical image annotation tool - labelImg

    Ubuntu Linux Python3 + Qt5

    git clone https://github.com/tzutalin/labelImg.git
    sudo apt-get install pyqt5-dev-tools
    sudo pip3 install -r requirements/requirements-linux-python3.txt
    make qt5py3
    cd labelImg
    
    python3 labelImg.py
    python3 labelImg.py [IMAGE_PATH] [PRE-DEFINED CLASS FILE]
    

    4. 制作训练数据路径链接

    ├── JPEGImages
    ├── object_00001.jpg
    └── object_00002.jpg

    ├── Annotations
    ├── object_00001.xml
    └── object_00002.xml

    ├── labels
    ├── object_00001.txt
    └── object_00002.txt

    ├── backup
    ├── yolov3-voc-object.backup
    └── yolov3-voc-object_20000.weights

    ├── cfg
    ├── yolo3_object.data
    └── yolov3-voc-object.cfg

    • JPEGImages – 储存所有的图片

    • Annotations – 储存所有的标注 [.xml] 文件

    • labels – 储存所有转换的 [.txt] 文件 (convert all [.xml] file to [.txt] file) 执行 voc_label.py 转换

      python3 ./tools/voc_label.py (convert xml2txt and check your file paths)
      
    a. 首先创建训练集文件夹和验证集文件夹,并在所有自定义数据目录执行
    python3 ./tools/img2train.py [img_path]
    
    将所有数据分为训练集和验证集并生成 train.txt 和 val.txt 两个文件
    • train.txt – 该文件内容为所有训练图片名(不带.jpg后缀)
    • val.txt – 该文件内容为所有验证集图片名(不带.jpg后缀)
    b.执行 voc_label.py 获取以下带路径的文件(用于 .data 文件)
    • object_train.txt – 该文件内容为所有训练集的 绝对路径
    • object_val.txt – 该文件内容为所有验证集的 绝对路径

    5. 制作和更改 [.names] [.data] 和 [.cfg] 文件

    • .names 文件内容为训练类别
    gedit train.names
    
    Person 
    Car
    Dog
    Cat
    ...
    

    创建 train.names 后保存退出

    • .data 文件内容为创建以上文件的软链接(建议使用绝对路径)
    gedit obj.data
    
       classes= [类别数]
       train = [object_train.txt 文件的绝对路径]
       valid = [object_val.txt 文件的绝对路径]
       names = [train.names 文件的绝对路径]
       backup = backup/ #训练后权重存储的文件夹
    
    • .cfg 文件可以更改 darknet/cfg/yolov4-custom.cfg (复制 yolov4-custom.cfg 到本地进行更改) 需要更改以下部分:

      • change line batch to batch=64 (32 or 16)

      • change line subdivisions to subdivisions=16 (根据你的GPU性能可调整为 32 or 64.)

      • change line max_batches to (classes*2000 but not less than number of training images, and not less than 6000), f.e. max_batches=6000 if you train for 3 classes

      • change line steps to 80% and 90% of max_batches, f.e. steps=4800,5400

      • set network size width=416 height=416 or any value multiple of 32:

      • 更改 cfg 文件中的类别数 将 classes=80 更改为自定义数据类别数,共有 3 个 [yolo]-layers 需要更改,位置如下:

      • 更改 cfg 文件中的 [filters=255] 参数,更新后的 filters=(类别数 + 5)x3 ,位于每个 [yolo] layer 中最后的 [convolutional] 层,共有 3[filters=255] 需要更改,位置如下:


    5. 训练

    在这里插入图片描述

    • 训练及训练过程可视化

      sudo ./darknet detector train [obj.data path] [yolov4-custom.cfg path]  yolov4.conv.137 -map
      
    • 使用多GPU训练

      sudo ./darknet detector train [obj.data path] [yolov4-custom.cfg path]  yolov4.conv.137 -gpus 0,1,2 -map
      

    6. 测试

    在这里插入图片描述

    • 测试单张图片

      ./darknet detector test [obj.data path] [yolov4-custom.cfg path] [weights file path] [image path]
      
    • 测试视频

      ./darknet detector demo [obj.data path] [yolov4-custom.cfg path] [weights file path] [video path]
      
    • 测试视频并保存测试结果

      ./darknet detector demo [obj.data path] [yolov4-custom.cfg path] [weights file path] [video path] -out_filename [Custom naming]
      
    展开全文
  • yolov4训练自己数据集

    万次阅读 多人点赞 2020-04-30 20:47:25
    开始训练自己数据集 ./darknet detector train cfg/obj.data cfg/yolo-obj.cfg yolov4.conv.137 如若报错这个错误,则将cfg/yolo-obj.cfg 里面26行mosaic=1改成mosaic=0或者注释掉。没报错就忽略。 7.预测 ./...
  • (一) yolov3训练voc 数据集
  • YOLOv5训练自己数据集(超详细完整版)

    万次阅读 多人点赞 2020-10-16 11:38:18
    一.Requirements 本教程所用环境:代码版本V3.0... 准备自己数据集(VOC格式) 1.在yolov5目录下创建paper_data文件夹(名字可以自定义),目录结构如下,将之前labelImg标注好的xml文件和图片放到对应目录下 paper_
  • WIN10 +pytorch版yolov3训练自己数据集

    万次阅读 多人点赞 2019-05-17 08:16:36
    pytorch版yolov3训练自己数据集 目录 1. 环境搭建 2. 数据集构建 3. 训练模型 4. 测试模型 5. 评估模型 6. 可视化 7. 高级进阶-网络结构更改 1. 环境搭建 将github库download下来。 git clone ...
  • YOLOv4训练自己数据集

    千次阅读 2020-05-21 18:10:48
    YOLOv4训练自己数据集----darknet版_记录 点击YOLOv4论文地址 本文基于代码链接实现训练自己数据集 环境配置 Ubuntu+cuda10.02+darknet+python 1.下载模型文件 git clone ...
  • 该资源是我的博客《【YOLO初探】之 keras-yolov3训练自己数据集》代码的第三部分的内容。内容包括我自己数据集。加上第二、一部分的内容,就可以之家运行,请参看博客文章
  • pytorch-YOLOv4训练自己数据集

    千次阅读 热门讨论 2020-11-24 16:29:50
    题记:之前用YOLOv3训练自己数据集,详见该博客,Darknet--Yolov3训练自己的数据。准备试试YOLOv4,试试看校测效果是否再提高,因需要,用的pytorch版本。 一、下载代码 1、下载项目代码 git clone ...
  • 该资源是我的博客《【YOLO初探】之 keras-yolov3训练自己数据集》代码的第二部分的内容。内容包括我自己训练完成的权重。加上第一、三部分的内容,就可以之家运行,请参看博客文章
  • 该资源是我的博客《【YOLO初探】之 keras-yolov3训练自己数据集》代码的第一部分的内容。内容包括图像标记软件labelImg。加上第二、三部分的内容,就可以之家运行,请参看博客文章。
  • Yolov4训练自己数据集 代码运行环境Ubuntu18.04+python3.6+显卡1080Ti+CUDA10.0+cudnn7.5.1+OpenCV3.4.6+Cmake3.12.2,详细环境配置安装步骤就不讲解拉,网上教程一大堆。 从github克隆下载源码,链接地址:...
  • yolov4训练custom数据集

    2020-05-26 11:01:59
    训练代码 ./darknet detector train cfg/obj.data cfg/yolo-obj.cfg weights/yolov4.conv.137.pth -dont_show cfg/obj.data文件内容: cfg/yolo-obj.cfg文件内容: data目录结构 训练执行结果:
  • win10+torch+yolov3训练自己数据集

    万次阅读 多人点赞 2020-03-19 00:06:52
    穷苦学生一枚,恰好最近在学习object detection,用到了yolov3模型,捣鼓了好几天,看了各大论坛、贴吧、CSDN,知乎,博客园等好多大佬前辈们写的文章(吐血.jpg),在这里将自己的过程和结果写出来,希望大家能少走...
  • YoLov3训练自己数据集(小白手册)

    万次阅读 多人点赞 2018-08-02 11:00:12
    1.标注自己数据集。用labelimg进行标注,保存后会生成与所标注图片文件名相同的xml文件,如图。我们标注的是各种表,名称就简单的按外观大小分了s、m、l、xl、xxl共5类标签名 2.下载yolov3项目工程。按照YoLo官网...
  • YOLOV5训练自己数据集(踩坑经验之谈)

    万次阅读 多人点赞 2020-12-19 13:01:54
    这几天也一直在csdn里学习YOLOv3与YOLOv5训练数据集的具体步骤,几经波折终于实现了很好的效果。因此,决定利用闲暇时间,为大家写一篇YOLOv5训练数据集的小白手册,还望大家喜欢!有不同看法或意见欢迎在评论区指出...
  • 基于tensorflow2.0的yolov4训练自己数据集(一) 在windows和linux分别训练了基于tensorflow2的yolov4模型,将方法记录下来,方便其他同学参考借鉴。内容较多,分批写出来: 目录 一、制作数据集 1、下载...
  • pytorch版yolov3训练自己数据集
  • yolov3,yolov4训练自己数据集的流程,用opencv库函数调用训练结果文件的的流程。
  • Win10下 + YOLOv4训练VOC数据集成功!

    千次阅读 2020-09-30 19:57:10
    Windows10 + YOLOv4训练VOC数据集 1、数据集准备 由于VOCdevkit数据集比较大,官网下载要很久,所有直接硬盘拷的,一般要放在D:\darknet\build\darknet\x64\data\voc文件夹下面,如下所示: 把voc_label.py文件...
  • 本文主要是简述如何训练自己数据集,这里以FLIR的红外数据集为例,配置运行以及原理不再叙述 1.修改Makefile 这步一般已经在配置运行的时候已经做过了,没什么大问题 2.将自己数据集处理成yolo训练所需的...
  • yoloV4自己数据集.zip

    2020-04-29 15:25:49
    刚刚出了yoloV4,相信很多人都需要使用并训练测试,数据集的处理和获取很麻烦,这个是我自己训练数据集,已经训练过了没任何问题,需要调试源码的随时联系。YOLO V4自己的数据集。
  • 这里写目录标题配置完后的整体目录结构拉取yolov4数据集准备数据集文件夹准备划分训练集、验证集、测试集生成训练集、测试集配置文件更改网络结构配置weights文件训练 配置完后的整体目录结构 . ├── cfg ├── ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,605
精华内容 4,642
关键字:

yolov4训练自己的数据集