精华内容
下载资源
问答
  • WIN10 +pytorch版yolov3训练自己数据集

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

    pytorch版yolov3训练自己数据集

    目录

    1. 环境搭建

    1. 将github库download下来。
    git clone https://github.com/ultralytics/yolov3.git
    1. 建议在linux环境下使用anaconda进行搭建
    conda create -n yolov3 python=3.7
    1. 安装需要的软件
    pip install -r requirements.txt

    环境要求:

    • python >= 3.7
    • pytorch >= 1.1
    • numpy
    • tqdm
    • opencv-python

    其中只需要注意pytorch的安装:

    https://pytorch.org/中根据操作系统,python版本,cuda版本等选择命令即可。

    关于深度学习环境搭建请参看:https://www.cnblogs.com/pprp/p/9463974.html

    anaconda常用用法:https://www.cnblogs.com/pprp/p/9463124.html

    2. 数据集构建

    1. xml文件生成需要Labelimg软件

    在Windows下使用:
    wget https://github.com/pprp/DeepLearning/blob/master/windows_v1.5.1/labelImg.exe
    • 使用快捷键:
    Ctrl + u  加载目录中的所有图像,鼠标点击Open dir同功能
    Ctrl + r  更改默认注释目标目录(xml文件保存的地址) 
    Ctrl + s  保存
    Ctrl + d  复制当前标签和矩形框
    space     将当前图像标记为已验证
    w         创建一个矩形框
    d         下一张图片
    a         上一张图片
    del       删除选定的矩形框
    Ctrl++    放大
    Ctrl--    缩小
    ↑→↓←        键盘箭头移动选定的矩形框

    2. VOC2007 数据集格式

    -data
        - VOCdevkit2007
            - VOC2007
                - Annotations (标签XML文件,用对应的图片处理工具人工生成的)
                - ImageSets (生成的方法是用sh或者MATLAB语言生成)
                    - Main
                        - test.txt
                        - train.txt
                        - trainval.txt
                        - val.txt
                - JPEGImages(原始文件)
                - labels (xml文件对应的txt文件)

    通过以上软件主要构造好JPEGImages和Annotations文件夹中内容,Main文件夹中的txt文件可以通过python脚本生成:

    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()

    生成labels文件,voc_label.py文件具体内容如下:

    # -*- coding: utf-8 -*-
    """
    Created on Tue Oct  2 11:42:13 2018
    将本文件放到VOC2007目录下,然后就可以直接运行
    需要修改的地方:
    1. sets中替换为自己的数据集
    2. classes中替换为自己的类别
    3. 将本文件放到VOC2007目录下
    4. 直接开始运行
    """
    
    import xml.etree.ElementTree as ET
    import pickle
    import os
    from os import listdir, getcwd
    from os.path import join
    sets=[('2007', 'train'), ('2007', 'val'), ('2007', 'test')]  #替换为自己的数据集
    classes = ["head", "eye", "nose"]     #修改为自己的类别
    #classes = ["eye", "nose"]
    
    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(year, image_id):
        in_file = open('VOC%s/Annotations/%s.xml'%(year, image_id))  #将数据集放于当前目录下
        out_file = open('VOC%s/labels/%s.txt'%(year, 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')
    wd = getcwd()
    for year, image_set in sets:
        if not os.path.exists('VOC%s/labels/'%(year)):
            os.makedirs('VOC%s/labels/'%(year))
        image_ids = open('VOC%s/ImageSets/Main/%s.txt'%(year, image_set)).read().strip().split()
        list_file = open('%s_%s.txt'%(year, image_set), 'w')
        for image_id in image_ids:
            list_file.write('VOC%s/JPEGImages/%s.jpg\n'%(year, image_id))
            convert_annotation(year, image_id)
        list_file.close()   
    #os.system("cat 2007_train.txt 2007_val.txt > train.txt")     #修改为自己的数据集用作训练

    到底为止,VOC格式数据集构造完毕,但是还需要继续构造符合darknet格式的数据集(coco)。

    需要说明的是:如果打算使用coco评价标准,需要构造coco中json格式,如果要求不高,只需要VOC格式即可,使用作者写的mAP计算程序即可。

    voc的xml转coco的json文件脚本:xml2json.py

    # -*- coding: utf-8 -*-
    """
    Created on Tue Aug 28 15:01:03 2018
    需要改动xml_path and json_path
    """
    #!/usr/bin/python
    # -*- coding:utf-8 -*-
    # @Description: xml转换到coco数据集json格式
     
    import os, sys, json,xmltodict
     
    from xml.etree.ElementTree import ElementTree, Element
    from collections import OrderedDict
     
    XML_PATH = "/home/learner/datasets/VOCdevkit2007/VOC2007/Annotations/test"
    JSON_PATH = "./test.json"
    json_obj = {}
    images = []
    annotations = []
    categories = []
    categories_list = []
    annotation_id = 1
     
    def read_xml(in_path):
        '''读取并解析xml文件'''
        tree = ElementTree()
        tree.parse(in_path)
        return tree
     
    def if_match(node, kv_map):
        '''判断某个节点是否包含所有传入参数属性
          node: 节点
          kv_map: 属性及属性值组成的map'''
        for key in kv_map:
            if node.get(key) != kv_map.get(key):
                return False
        return True
     
    def get_node_by_keyvalue(nodelist, kv_map):
        '''根据属性及属性值定位符合的节点,返回节点
          nodelist: 节点列表
          kv_map: 匹配属性及属性值map'''
        result_nodes = []
        for node in nodelist:
            if if_match(node, kv_map):
                result_nodes.append(node)
        return result_nodes
     
    def find_nodes(tree, path):
        '''查找某个路径匹配的所有节点
          tree: xml树
          path: 节点路径'''
        return tree.findall(path)
     
    print ("-----------------Start------------------")
    xml_names = []
    for xml in os.listdir(XML_PATH):
        #os.path.splitext(xml)
        #xml=xml.replace('Cow_','')
        xml_names.append(xml)
        
    
    '''xml_path_list=os.listdir(XML_PATH)
    os.path.split
    xml_path_list.sort(key=len)'''
    xml_names.sort(key=lambda x:int(x[:-4]))
    new_xml_names = []
    for i in xml_names:
        j = 'Cow_' + i
        new_xml_names.append(j)
    
    #print xml_names
    #print new_xml_names
    for xml in new_xml_names:
        tree = read_xml(XML_PATH + "/" + xml)
        object_nodes = get_node_by_keyvalue(find_nodes(tree, "object"), {})
        if len(object_nodes) == 0:
            print (xml, "no object")
            continue
        else:
            image = OrderedDict()
            file_name = os.path.splitext(xml)[0];  # 文件名
                    #print os.path.splitext(xml)
            para1 = file_name + ".jpg"
                   
    
                    height_nodes = get_node_by_keyvalue(find_nodes(tree, "size/height"), {})
            para2 = int(height_nodes[0].text)
                    
                    width_nodes = get_node_by_keyvalue(find_nodes(tree, "size/width"), {})
            para3 = int(width_nodes[0].text)
            
            fname=file_name[4:]
            para4 = int(fname)
            
            
                    
                    for f,i in [("file_name",para1),("height",para2),("width",para3),("id",para4)]:
                        image.setdefault(f,i)
    
                    #print(image)
                    images.append(image)    #构建images
              
         
            name_nodes = get_node_by_keyvalue(find_nodes(tree, "object/name"), {})
            xmin_nodes = get_node_by_keyvalue(find_nodes(tree, "object/bndbox/xmin"), {})
            ymin_nodes = get_node_by_keyvalue(find_nodes(tree, "object/bndbox/ymin"), {})
            xmax_nodes = get_node_by_keyvalue(find_nodes(tree, "object/bndbox/xmax"), {})
            ymax_nodes = get_node_by_keyvalue(find_nodes(tree, "object/bndbox/ymax"), {})
               # print ymax_nodes
            for index, node in enumerate(object_nodes):
                annotation = {}
                segmentation = []
                bbox = []
                seg_coordinate = []     #坐标
                seg_coordinate.append(int(xmin_nodes[index].text))
                seg_coordinate.append(int(ymin_nodes[index].text))
                seg_coordinate.append(int(xmin_nodes[index].text))
                seg_coordinate.append(int(ymax_nodes[index].text))
                seg_coordinate.append(int(xmax_nodes[index].text))
                seg_coordinate.append(int(ymax_nodes[index].text))
                seg_coordinate.append(int(xmax_nodes[index].text))
                seg_coordinate.append(int(ymin_nodes[index].text))
                segmentation.append(seg_coordinate)
                width = int(xmax_nodes[index].text) - int(xmin_nodes[index].text)
                height = int(ymax_nodes[index].text) - int(ymin_nodes[index].text)
                area = width * height
                bbox.append(int(xmin_nodes[index].text))
                bbox.append(int(ymin_nodes[index].text))
                bbox.append(width)
                bbox.append(height)
         
                annotation["segmentation"] = segmentation
                annotation["area"] = area
                annotation["iscrowd"] = 0
                fname=file_name[4:]
                annotation["image_id"] = int(fname)
                annotation["bbox"] = bbox
                cate=name_nodes[index].text
                if cate=='head':
                    category_id=1
                elif cate=='eye':
                    category_id=2
                elif cate=='nose':
                    category_id=3
                annotation["category_id"] = category_id
                annotation["id"] = annotation_id
                annotation_id += 1
                annotation["ignore"] = 0
                annotations.append(annotation)
         
                if category_id in categories_list:
                    pass
                else:
                    categories_list.append(category_id)
                    categorie = {}
                    categorie["supercategory"] = "none"
                    categorie["id"] = category_id
                    categorie["name"] = name_nodes[index].text
                    categories.append(categorie)
         
    json_obj["images"] = images
    json_obj["type"] = "instances"
    json_obj["annotations"] = annotations
    json_obj["categories"] = categories
     
    f = open(JSON_PATH, "w")
    #json.dump(json_obj, f)
    json_str = json.dumps(json_obj)
    f.write(json_str)
    print ("------------------End-------------------")

    (运行bash yolov3/data/get_coco_dataset.sh,仿照格式将数据放到其中)

    但是这个库还需要其他模型:

    3. 创建*.names file,

    其中保存的是你的所有的类别,每行一个类别,如data/coco.names:

    head
    eye
    nose

    4. 更新data/coco.data,其中保存的是很多配置信息

    classes = 3 # 改成你的数据集的类别个数
    train = ./data/2007_train.txt # 通过voc_label.py文件生成的txt文件
    valid = ./data/2007_test.txt # 通过voc_label.py文件生成的txt文件
    names = data/coco.names # 记录类别
    backup = backup/ # 记录checkpoint存放位置
    eval = coco # 选择map计算方式

    5. 更新cfg文件,修改类别相关信息

    打开cfg文件夹下的yolov3.cfg文件,大体而言,cfg文件记录的是整个网络的结构,是核心部分,具体内容讲解请见:https://pprp.github.io/2018/09/20/tricks.html

    只需要更改每个[yolo]层前边卷积层的filter个数即可:

    每一个[region/yolo]层前的最后一个卷积层中的 filters=num(yolo层个数)*(classes+5) ,5的意义是5个坐标,论文中的tx,ty,tw,th,po

    举个例子:我有三个类,n = 3, 那么filter = 3 * (3+5) = 21

    [convolutional]
    size=1
    stride=1
    pad=1
    filters=255 # 改为 21
    activation=linear
    
    
    [yolo]
    mask = 6,7,8
    anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    classes=80 # 改为 3
    num=9
    jitter=.3
    ignore_thresh = .7
    truth_thresh = 1
    random=1

    6. 数据集格式说明

    - yolov3
        - data
          - 2007_train.txt
          - 2007_test.txt
          - coco.names
          - coco.data
          - annotations(json files)
          - images(将2007_train.txt中的图片放到train2014文件夹中,test同理)
            - train2014
              - 0001.jpg
              - 0002.jpg
            - val2014
              - 0003.jpg
              - 0004.jpg
          - labels(voc_labels.py生成的内容需要重新组织一下)
            - train2014
              - 0001.txt
              - 0002.txt
            - val2014
              - 0003.txt
              - 0004.txt
          - samples(存放待测试图片)

    2007_train.txt内容示例:

    /home/dpj/yolov3-master/data/images/val2014/Cow_1192.jpg
    /home/dpj/yolov3-master/data/images/val2014/Cow_1196.jpg
    .....

    注意images和labels文件架构一致性,因为txt是通过简单的替换得到的:

    images -> labels
    .jpg -> .txt

    3. 训练模型

    预训练模型:

    开始训练:

    python train.py --data data/coco.data --cfg cfg/yolov3.cfg

    如果日志正常输出那证明可以运行了

    如果中断了,可以恢复训练

    python train.py --data data/coco.data --cfg cfg/yolov3.cfg --resume

    4. 测试模型

    将待测试图片放到data/samples中,然后运行

    python detect.py --weights weights/best.pt

    5. 评估模型

    python test.py --weights weights/latest.pt

    如果使用cocoAPI使用以下命令:

    git clone https://github.com/cocodataset/cocoapi && cd cocoapi/PythonAPI && make && cd ../.. && cp -r cocoapi/PythonAPI/pycocotools yolov3
    cd yolov3
     
    python3 test.py --save-json --img-size 416
    Namespace(batch_size=32, cfg='cfg/yolov3-spp.cfg', conf_thres=0.001, data_cfg='data/coco.data', img_size=416, iou_thres=0.5, nms_thres=0.5, save_json=True, weights='weights/yolov3-spp.weights')
    Using CUDA device0 _CudaDeviceProperties(name='Tesla V100-SXM2-16GB', total_memory=16130MB)
                   Class    Images   Targets         P         R       mAP        F1
    Calculating mAP: 100%|█████████████████████████████████████████| 157/157 [05:59<00:00,  1.71s/it]
                     all     5e+03  3.58e+04     0.109     0.773      0.57     0.186
     Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.335
     Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.565
     Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.349
     Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.151
     Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.360
     Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.493
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.280
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.432
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.458
     Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.255
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.494
     Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.620
    
    python3 test.py --save-json --img-size 608 --batch-size 16
    Namespace(batch_size=16, cfg='cfg/yolov3-spp.cfg', conf_thres=0.001, data_cfg='data/coco.data', img_size=608, iou_thres=0.5, nms_thres=0.5, save_json=True, weights='weights/yolov3-spp.weights')
    Using CUDA device0 _CudaDeviceProperties(name='Tesla V100-SXM2-16GB', total_memory=16130MB)
                   Class    Images   Targets         P         R       mAP        F1
    Computing mAP: 100%|█████████████████████████████████████████| 313/313 [06:11<00:00,  1.01it/s]
                     all     5e+03  3.58e+04      0.12      0.81     0.611     0.203
     Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.366
     Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.607
     Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.386
     Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.207
     Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.391
     Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.485
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.296
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.464
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.494
     Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.331
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.517
     Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.618

    6. 可视化

    可以使用python -c from utils import utils;utils.plot_results()

    创建drawLog.py

    def plot_results():
        # Plot YOLO training results file 'results.txt'
        import glob
        import numpy as np
        import matplotlib.pyplot as plt
        #import os; os.system('rm -rf results.txt && wget https://storage.googleapis.com/ultralytics/results_v1_0.txt')
    
        plt.figure(figsize=(16, 8))
        s = ['X', 'Y', 'Width', 'Height', 'Objectness', 'Classification', 'Total Loss', 'Precision', 'Recall', 'mAP']
        files = sorted(glob.glob('results.txt'))
        for f in files:
            results = np.loadtxt(f, usecols=[2, 3, 4, 5, 6, 7, 8, 17, 18, 16]).T  # column 16 is mAP
            n = results.shape[1]
            for i in range(10):
                plt.subplot(2, 5, i + 1)
                plt.plot(range(1, n), results[i, 1:], marker='.', label=f)
                plt.title(s[i])
                if i == 0:
                    plt.legend()
        plt.savefig('./plot.png')
    if __name__ == "__main__":
        plot_results()

    7. 高级进阶-网络结构更改

    详细cfg文件讲解:https://pprp.github.io/2018/09/20/tricks.html

    参考资料以及网络更改经验:https://pprp.github.io/2018/06/20/yolo.html

    欢迎在评论区进行讨论,也便于我继续完善该教程。

    代码改变世界

    展开全文
  • 该资源是我的博客《【YOLO初探】之 keras-yolov3训练自己数据集》代码的第三部分的内容。内容包括我自己数据集。加上第二、一部分的内容,就可以之家运行,请参看博客文章
  • 该资源是我的博客《【YOLO初探】之 keras-yolov3训练自己数据集》代码的第二部分的内容。内容包括我自己训练完成的权重。加上第一、三部分的内容,就可以之家运行,请参看博客文章
  • 该资源是我的博客《【YOLO初探】之 keras-yolov3训练自己数据集》代码的第一部分的内容。内容包括图像标记软件labelImg。加上第二、三部分的内容,就可以之家运行,请参看博客文章。
  • pytorch版yolov3训练自己数据集
    展开全文
  • win10+torch+yolov3训练自己数据集

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

    1. 前情说明:

    穷苦学生一枚,恰好最近在学习object detection,用到了yolov3模型,捣鼓了好几天,看了各大论坛、贴吧、CSDN,知乎,博客园等好多大佬前辈们写的文章(吐血.jpg),在这里将自己的过程和结果写出来,希望大家能少走点弯路。

    2. 环境:

    这个很重要!!!!!

    1. window 10
    2. pytorch 1.4.0
    3. opencv-python
    4. tqdm
    5. matplotlib
    6. pycocotools(这个很难装!!,原作者压根没有考虑window环境下的coco tools,真的吐血,具体安装教程可以参考我的博客:https://blog.csdn.net/weixin_45829462/article/details/104787103

    本次使用的是ultralytics-yolov3
    为什么使用这个版本,因为这个版本工业应用的比较多,检测速度也比较快,最重要的是,目前这个版本原作者一直在优化之中。
    在这里插入图片描述

    3. 步骤:

    3.1 制作数据集:
    在制作数据集需要用到一款标注工具,labellmge,安装地址:github:https://github.com/tzutalin/labelImg,使用方法:
    https://www.cnblogs.com/Terrypython/p/9577657.html
    3.2 数据集:
    博主使用的数据集是Voc行人数据集,是已经标注好的数据集,下载地址:
    大家先将数据集下载到桌面,解压,等待使用,数据中有两个文件夹,分别是:
    在这里插入图片描述
    Annotations文件打开后如下:
    在这里插入图片描述
    JPEGImages打开后如下:
    在这里插入图片描述
    3.3 下载模型:
    请大家将模型下载下来,地址:https://github.com/ultralytics/yolov3
    因为博主准备训练关于检测行人的模型,故命名为yolov3-person,下载下来重要的源文件包都有:

    在这里插入图片描述
    3.4 装载数据:
    将数据集Annotations、JPEGImages复制到yolov3-person工程目录下的data文件下;同时新建两个文件夹,分别命名为ImageSetslabels,最后我们将JPEGImages文件夹复制粘贴一下,并将文件夹重命名为images,具体如下注:(data下加上原先的sample文件夹,一共是6个子文件夹):
    在这里插入图片描述
    3.5 建立标签文件:

    在根目录下新建两个文件夹,makeTxt.pyvoc_label.py,将以下代码拷贝进py文件中,如下:

    • makeTxt.py:
    import os
    import random
    
    trainval_percent = 0.1
    train_percent = 0.9
    xmlfilepath = 'data/Annotations'
    txtsavepath = 'data/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('data/ImageSets/trainval.txt', 'w')
    ftest = open('data/ImageSets/test.txt', 'w')
    ftrain = open('data/ImageSets/train.txt', 'w')
    fval = open('data/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:
    import xml.etree.ElementTree as ET
    import os
    from os import listdir, getcwd
    
    sets = ['train', 'test', 'val']
    
    classes = ["person"]  # 我们只检测person这个类别
    
    
    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_annotation(image_id):
        in_file = open('data/Annotations/%s.xml' % (image_id))
        out_file = open('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
            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')
    
    
    wd = getcwd()
    print(wd)
    for image_set in sets:
        if not os.path.exists('data/labels/'):
            os.makedirs('data/labels/')
        image_ids = open('data/ImageSets/%s.txt' % (image_set)).read().strip().split()
        list_file = open('data/%s.txt' % (image_set), 'w')
        for image_id in image_ids:
            list_file.write('data/images/%s.jpg\n' % (image_id))
            convert_annotation(image_id)
        list_file.close()
    

    注:classes=【‘person’】里面的标签并不是我们定的,请大家打开自己数据集的xml文件,类目头标签是是啥填啥:
    在这里插入图片描述
    3.6 运行标签文件:

    • 运行makeTxt.py后,在ImagesSets文件夹里面生成4个文件:
      在这里插入图片描述
    • 运行makeTxt.py后,在Iabels文件夹里面生成文件名以及image中目标的位置信息:
      在这里插入图片描述
      3.7 配置文件:
      data文件下新建person.names文件,内容如下:
    person
    

    data文件下新建person.data文件,内容如下:

    classes=1#只检测一个类,原为80个
    train=data/train.txt
    valid=data/test.txt
    names=data/person.names#读取类目信息
    backup=backup/
    eval=coco#配置标准与coco数据集一致
    

    在这里插入图片描述
    3.8 修改参数文件:
    修改原yolov3-spp.cfg文件为(可直接拷贝):

    [net]
    # Testing
    # batch=1
    # subdivisions=1
    # Training
    batch=64
    subdivisions=16
    width=608
    height=608
    channels=3
    momentum=0.9
    decay=0.0005
    angle=0
    saturation = 1.5
    exposure = 1.5
    hue=.1
    
    
    
    [convolutional]
    size=1
    stride=1
    pad=1
    filters=18
    activation=linear
    
    
    [yolo]
    mask = 6,7,8
    anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    classes=1
    num=9
    jitter=.3
    ignore_thresh = .7
    truth_thresh = 1
    random=1
    
    
    [route]
    layers = -4
    
    [convolutional]
    batch_normalize=1
    filters=256
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [upsample]
    stride=2
    
    [route]
    layers = -1, 61
    
    
    
    [convolutional]
    batch_normalize=1
    filters=256
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    size=3
    stride=1
    pad=1
    filters=512
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    filters=256
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    size=3
    stride=1
    pad=1
    filters=512
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    filters=256
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    size=3
    stride=1
    pad=1
    filters=512
    activation=leaky
    
    [convolutional]
    size=1
    stride=1
    pad=1
    filters=18
    activation=linear
    
    
    [yolo]
    mask = 3,4,5
    anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    classes=1
    num=9
    jitter=.3
    ignore_thresh = .7
    truth_thresh = 1
    random=1
    
    
    
    [route]
    layers = -4
    
    [convolutional]
    batch_normalize=1
    filters=128
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [upsample]
    stride=2
    
    [route]
    layers = -1, 36
    
    
    
    [convolutional]
    batch_normalize=1
    filters=128
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    size=3
    stride=1
    pad=1
    filters=256
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    filters=128
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    size=3
    stride=1
    pad=1
    filters=256
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    filters=128
    size=1
    stride=1
    pad=1
    activation=leaky
    
    [convolutional]
    batch_normalize=1
    size=3
    stride=1
    pad=1
    filters=256
    activation=leaky
    
    [convolutional]
    size=1
    stride=1
    pad=1
    filters=18
    activation=linear
    
    
    [yolo]
    mask = 0,1,2
    anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    classes=1
    num=9
    jitter=.3
    ignore_thresh = .7
    truth_thresh = 1
    random=1
    

    提一下,主要修改的是三个yolo层附近的参数,一共六处地方:

    修改如下:
    ①filters=255改为18:即3*(classes+5),单类的话classes=1
    ②classes=80改为1,只检测person一类
    其他参数根据自己需要进行修改:
    ①如果想修改anchor的值,需要根据kmeans聚类跑自己的数据集得出结果,代码地址:https://github.com/lars76/kmeans-anchor-boxes
    ②如果GPU显存较小,可以设置将random=1设置为0
    ③当单类是cls为0

    3.10 配置预权重:

    预权重需要哪个根据自己修改的cfg文件进行选择,以下附一张图。但要提一点,如果不想在作者训练好的权重再加以训练,想要从头开始训练,选择darknet53.conv.74
    在这里插入图片描述
    3.11 训练模型:

    使用pycharm中的Terminal,输入如下命令:

    python train.py --data data/person.data --cfg cfg/yolov3-spp.cfg --weights weights/darknet53.conv.74 --epochs 100 --batch-size 32
    

    其中,–epochs 10指迭代了10次,batch-size 32指每次处理32张图片。
    ①如果GPU显存不够的,会报出错误:
    ②batch-size 最好在32以上,并且为2的指数倍,不然会不定时出现nan问题:
    在这里插入图片描述
    ③数据集不要包括黑白图片,请保持RBG通道一致,不然会报错:
    在这里插入图片描述
    ④,有条件的,请开启多尺度训练,提高模型精度,具体命令如下:

    python train.py --data data/person.data --cfg cfg/yolov3-spp.cfg --weights weights/darknet53.conv.74 --epochs 100 --batch-size 32 --multi-scale
    

    正常运行如下:
    在这里插入图片描述
    在这里插入图片描述(自己笔记本显存不够,通过Google Colab训练)
    训练结束后得到模型best.ptlast.pt
    在这里插入图片描述

    4. 结果检测:

    在Terminal下输入以下命令:

    python detect.py --names data/person.names --cfg cfg/yolov3-spp.cfg --weights weights/best.pt
    

    结果如下:
    在这里插入图片描述
    在这里插入图片描述
    结果倒是出乎自己的预期

    5. 模型评估与测试

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    模型仍有待优化,近期不定时更新该博文!

    展开全文
  • Yolov-1-TX2上用YOLOv3训练自己数据集的流程(VOC2007-TX2-GPU) Yolov--2--一文全面了解深度学习性能优化加速引擎---TensorRT Yolov--3--TensorRT中yolov3性能优化加速(基于caffe) yolov-5-目标检测:YOLOv2算法...

    Yolov-1-TX2上用YOLOv3训练自己数据集的流程(VOC2007-TX2-GPU)

    Yolov--2--一文全面了解深度学习性能优化加速引擎---TensorRT

    Yolov--3--TensorRT中yolov3性能优化加速(基于caffe)

    yolov-5-目标检测:YOLOv2算法原理详解

    yolov--8--Tensorflow实现YOLO v3

    yolov--9--YOLO v3的剪枝优化

    yolov--10--目标检测模型的参数评估指标详解、概念解析

    yolov--11--YOLO v3的原版训练记录、mAP、AP、recall、precision、time等评价指标计算

    yolov--12--YOLOv3的原理深度剖析和关键点讲解


    TX2上用YOLOv3训练自己数据集的流程(VOC2007数据集-TX2-GPU版本)

    平台:英伟达NVIDIA TX2开发板  环境:python2.7,cuda8.0,cudnn6.0.2,opencv2.4.13.1

    以下2007都改为2009,文件夹修改的原因

    前期准备:

    以防8G的内存不够用,另外开辟4-8G的虚拟内存

    1. 创建8G大小的swapfile

    fallocate -l 8G swapfile

    2. 更改swapfile的权限

    chmod 600 swapfile

    3. 创建swap区

    mkswap swapfile

    4. 激活swap区

    sudo swapon swapfile

    5. 确认swap区在用

    swapon -s

    6、关闭swap区

    sudo swapoff -a

    运行过程中如果遇到内存占用较多,执行以下语句清除部分内存的占用

    sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'
    查看TX2上的CPU情况
    
    $cat /proc/cpuinfo
    or
    $lscpu
    TX2上电的时候,默认最低功耗模式1,即只有4个CPU核心开启,风扇不转;
    
    1、直接运行home下的jetson_clocks.sh,开启最大频率
    
    sudo  ~/jetson_clocks.sh
    然后小风扇就呼啦啦转起来啦。。
    
    在Jetson Xavier上,jetson_clock.sh为当前的nvpmodel模式提供了最佳的性能。nvpmodel配置为任何给定模式定义了最大和最小时钟值。jetson_clocks.sh将时钟值调整到最大值。哦,当你决定全速跑的时候,有时会调整风扇的数值。
    
    jetson_clocks.sh还可以显示CPU、GPU和EMC的当前设置。
    
    $sudo ./jetson_clock.sh --show
     
    
    2、查询当前工作模式,输入
    
    sudo nvpmodel -q verbose
    此时显示的是
    
    NV Power Mode: MAX-P ARM
    3
     3、修改工作模式为0,输入:
    
    sudo nvpmodel -m 0
    再次查询,
    
    $sudo nvpmodel -q verbose
    NV Power Mode: MAXN
    0
    模式0下TX2的6个CPU核心全部开启,即火力全开模式,这样工作模式修改成功。火力全开模式可以有效提高速度!
    
    注意nvpmodel设置更改后,重启后数值会保持。


    1.1    数据集制作:
    A.制作VOC格式的xml文件工具:LabelImg
    将xml文件存放在/darknet/scripts/VOCdevkit/VOC2009/Annotations
    B.将VOC格式的xml文件转换成YOLO格式的txt文件
    用到的脚本:voc_label.py
    执行:cd darknet
    python voc_label.py


    生成:
    1、/darknet/scripts/VOCdevkit/VOC2009/labels
    2、/darknet/scripts/2009_train.txt

    .txt里的数据格式是这样的:


    具体的每一个值的计算方式是这样的:假设一个标注的boundingbox的左下角和右上角坐标分别为(x1,y1)(x2,y2),图像的宽和高分别为w,h

    归一化的中心点x坐标计算公式:((x2+x1) / 2.0)/ w
    归一化的中心点y坐标计算公式:((y2+y1) / 2.0)/ h
    归一化的目标框宽度的计算公式: (x2-x1) / w
    归一化的目标框高度计算公式:((y2-y1)/ h


    1.2    文件修改
    准备好了自己的图像后,需要按VOC数据集的结构放置图像文件。VOC的结构如下
    --VOC2009  
        --Annotations  ---主要存放xml文件
        --ImageSets  
          --Main  -----为train.txt等(需要自己用软件生成)
    作用:
          --Layout  
          --Segmentation  
        --JPEGImages   ---放我们已按统一规则命名好的原始图像
        --SegmentationClass  
        --SegmentationObject  
    这里面用到的文件夹是Annotation、ImageSets和JPEGImages。
    其中文件夹Annotation中主要存放xml文件,每一个xml对应一张图像,并且每个xml中存放的是标记的各个目标的位置和类别信息,命名通常与对应的原始图像一样;而ImageSets我们只需要用到Main文件夹,这里面存放的是一些文本文件,通常为train.txt等,该文本文件里面的内容是需要用来训练或测试的图像的名字(无后缀无路径);JPEGImages文件夹中放我们已按统一规则命名好的原始图像。


          因此,首先
          1.新建文件夹VOC2009(通常命名为这个,也可以用其他命名,但一定是名字+年份,例如MYDATA2016,无论叫什么后面都需要改相关代码匹配这里,本例中以VOC2007为例)
          2.在VOC2009文件夹下新建三个文件夹Annotation、ImageSets和JPEGImages,并把准备好的自己的原始图像放在JPEGImages文件夹下
          3.在ImageSets文件夹中,新建三个空文件夹Layout、Main、Segmentation,然后把写了训练或测试的图像的名字的文本拷到Main文件夹下,按目的命名,我这里所有图像用来训练,故而Main文件夹下只有train.txt文件。

     

    1.3    编译工程
       改配置文件:
      我想要GPU支持的版本,所以在编译工程前需要先修改Makefile文件,根据自己需求改,GPU版本的将GPU=1,CUDNN = 1, OPENCV=1, 


    执行:    
    cd darknet
    make
    如果遇到缺失包报错,将缺失的包装上去以后重新编译,重复下列两个操作,直到所有包都装好,
    make clean
    make


    1.4    配置文件参数修改
    (A)     修改darknet/cfg/voc-1.data
    classes= 80    类别数
    train  = /home/nvidia/darknet/scripts/2009_train.txt    训练数据2009_train.txt的路径
    //valid  = /home/pjreddie/data/voc/2009_test.txt     验证数据2009_test.txt的路径
    names = data/2-voc-1.names      存放类别名
    backup = /home/nvidia/darknet/backup   生成的权重文件存放的路径
    (B)关于cfg修改,以6类目标检测为例,主要有以下几处调整(蓝色标出),也可参考我上传的文件,里面对应的是4类。#表示注释,根据训练和测试,自行修改。
    例如:cfg/yolov3-1.cfg
    [net]
    # Testing
    # batch=1
    # subdivisions=1
    # Training
    batch=1                   
    subdivisions=1
    # 一批训练样本的样本数量,每batch个样本更新一次参数
    # batch/subdivisions作为一次性送入训练器的样本数量
    # 如果内存不够大,将batch分割为subdivisions个子batch
    # 上面这两个参数如果电脑内存小,则把batch改小一点,batch越大,训练效果越好
    # subdivisions越大,可以减轻显卡压力
      

    learning_rate:学习率,训练发散的话可以降低学习率。学习遇到瓶颈,loss不变的话也减低学习率。
    max_batches: 最大迭代次数。
    policy:学习策略,一般都是step这种步进式。
    step,scales:这两个是组合一起的,举个例子:learn_rate: 0.001, step:100,25000,35000   scales: 10, .1, .1 这组数据的意思就是在0-100次iteration期间learning rate为原始0.001,在100-25000次iteration期间learning rate为原始的10倍0.01,在25000-35000次iteration期间learning rate为当前值的0.1倍,就是0.001, 在35000到最大iteration期间使用learning rate为当前值的0.1倍,就是0.0001。随着iteration增加,降低学习率可以是模型更有效的学习,也就是更好的降低train loss。


    最后一层卷积层中filters数值是 5×(类别数 + 5)。
    region里需要把classes改成你的类别数。
    最后一行的random,是一个开关。如果设置为1的话,就是在训练的时候每一batch图片会随便改成320-640(32整倍数)大小的图片。目的和上面的色度,曝光度等一样。如果设置为0的话,所有图片就只修改成默认的大小 416*416。


    1.5    跑模型
    I.5.1    训练
    上面完成了就可以命令训练了,可以在官网上找到一些预训练的模型作为参数初始值,也可以直接训练,训练命令为
    $./darknet detector train ./cfg/voc-1.data cfg/yolov3-1.cfg  
    将权重文件保存在/darknet/backup下
     训练过程中会根据迭代次数保存训练的权重模型,然后就可以拿来测试了。


    Avg IOU:   当前迭代中,预测的box与标注的box的平均交并比,越大越好,期望数值为1;
    Class:        标注物体的分类准确率,越大越好,期望数值为1;
    obj:            越大越好,期望数值为1;
    No obj:      越小越好;
    .5R:            以IOU=0.5为阈值时候的recall; recall = 检出的正样本/实际的正样本
    0.75R:         以IOU=0.75为阈值时候的recall;
    count:        正样本数目。


    I.5.2    测试
    (1)一张图片
    ./darknet detect cfg/yolov3.cfg yolov3.weights data/dog.jpg
    原始图片
    生成的图片保存在darknet下


    (2)一个视频
    ./darknet detector demo cfg/voc-1.data cfg/yolov3-1.cfg yolov3.weights data/test1.flv

     


    (3)批量图片
    ./darknet detector test cfg/voc-2.data cfg/yolov3-1.cfg  yolov3.weights
    Enter Image Path:后面输入你的txt文件路径(你准备好的所有测试图片的路径全部存放在一个txt文件里)
    这里可以输入:/home/nvidia/darknet/scripts/2009_train.txt  
    输出带标记的图片保存在:/darknet /data/out


    (4)验证批量图片,返回评估值
    将要验证的每张图片的路径保存在scripts/2009_valid-1.txt 下
    ./darknet detector valid  cfg/voc-valid-1.data  cfg/yolov3-1.cfg  yolov3.weights
    /*只在./results/det_valid_[类名].txt里保存测试结果,如下:*/


    <image identifier> <confidence> <left> <top> <right> <bottom>
    文件名;每个框中存在该分类物体的概率;框框坐标 xmin;框框坐标 ymin;框框坐标 xmax;框框坐标 ymax
    其中(左,上) - (右,下)定义检测对象的边界框。 图像中左上角的像素具有坐标(1,1)。 更高的置信度值意味着检测结果的正确性。 下面显示了一个示例文件摘录。 请注意,对于图像000006,检测到多个对象:
    复制代码
    //comp3_det_test_car.txt:
    000004 0.702732 89 112 516 466
    000006 0.870849 373 168 488 229
    000006 0.852346 407 157 500 213

    (5)查看训练网络的召回率

    https://www.jianshu.com/p/7ae10c8f7d77/

    https://blog.csdn.net/hysteric314/article/details/54093734

    ./darknet detector recall  cfg/voc-valid-1.data  cfg/yolov3-1.cfg  yolov3.weights (这个命令需修改dectector.c文件)

    • Number表示处理到第几张图片。
    • Correct表示正确的识别除了多少bbox。这个值算出来的步骤是这样的,丢进网络一张图片,网络会预测出很多bbox,每个bbox都有其置信概率,概率大于threshold的bbox与实际的bbox,也就是labels中txt的内容计算IOU,找出IOU最大的bbox,如果这个最大值大于预设的IOU的threshold,那么correct加一。
    • Total表示实际有多少个bbox。
    • Rps/img表示平均每个图片会预测出来多少个bbox。
    • IOU: 这个是预测出的bbox和实际标注的bbox的交集 除以 他们的并集。显然,这个数值越大,说明预测的结果越好。
    • Recall召回率, 意思是检测出物体的个数 除以 标注的所有物体个数。通过代码我们也能看出来就是Correct除以Total的值。

    大雁与飞机
    假设现在有这样一个测试集,测试集中的图片只由大雁和飞机两种图片组成,如下图所示: 


    假设你的分类系统最终的目的是:能取出测试集中所有飞机的图片,而不是大雁的图片。

    现在做如下的定义: 
    True positives : 飞机的图片被正确的识别成了飞机。 
    True negatives: 大雁的图片没有被识别出来,系统正确地认为它们是大雁。 
    False positives: 大雁的图片被错误地识别成了飞机。 
    False negatives: 飞机的图片没有被识别出来,系统错误地认为它们是大雁。

    假设你的分类系统使用了上述假设识别出了四个结果,如下图所示: 


    那么在识别出来的这四张照片中: 
    True positives : 有三个,画绿色框的飞机。 
    False positives: 有一个,画红色框的大雁。

    没被识别出来的六张图片中: 
    True negatives : 有四个,这四个大雁的图片,系统正确地没有把它们识别成飞机。 
    False negatives: 有两个,两个飞机没有被识别出来,系统错误地认为它们是大雁。

    Precision 与 Recall
    Precision其实就是在识别出来的图片中,True positives所占的比率: 

    识别出的飞机数 / 所有识别出来的图片
      
    其中的n代表的是(True positives + False positives),也就是系统一共识别出来多少照片 。 
    在这一例子中,True positives为3,False positives为1,所以Precision值是 3/(3+1)=0.75。 
    意味着在识别出的结果中,飞机的图片占75%。

    Recall 是被正确识别出来的飞机个数与测试集中所有飞机的个数的比值: 

            (识别出的飞机数 / 所有飞机图片数
     
    Recall的分母是(True positives + False negatives),这两个值的和,可以理解为一共有多少张飞机的照片。 
    在这一例子中,True positives为3,False negatives为2,那么Recall值是 3/(3+2)=0.6。 
    意味着在所有的飞机图片中,60%的飞机被正确的识别成飞机.。

    准确率就是找得对,召回率就是找得全。


    I.5.3    注意
    1、测试输出的图片与原图片像素相同,

    2、用yolov3-tiny-1.cfg(288*288), 跑test1.flv,大概30帧左右
    用yolov3-tiny-1.cfg(输入网络图片像素为416*416), 跑test1.flv,大概20帧左右
    用yolov3-tiny-1.cfg(608*608), 跑text1.flv,大概10帧左右
    用yolov3-1.cfg(288*288), 跑test1.flv,大概5帧左右
    用yolov3-1.cfg(416*416), 跑test1.flv,大概3帧左右
    用yolov3-1.cfg(608*608), 跑test1.flv,大概2帧左右


    若加微信请备注下姓名_公司/学校,相遇即缘分,感谢您的支持,愿真诚交流,共同进步,谢谢~ 

     


    参考文献
    [1] https://blog.csdn.net/u012135425/article/details/80294884
    [2] https://blog.csdn.net/lilai619/article/details/79695109
    [3] https://www.cnblogs.com/antflow/p/7350274.html
    [4]https://blog.csdn.net/mieleizhi0522/article/details/79989754

    [5]https://www.cnblogs.com/happyamyhope/p/9110899.html

    展开全文
  • YOLOv3初探】之 keras-yolov3训练自己数据集

    万次阅读 热门讨论 2018-12-22 10:59:45
    如何使用官方数据集参看上一篇文章《【YOLO初探】之 使用官方数据集做目标分类》 传送门:https://blog.csdn.net/plSong_CSDN/article/details/85108256 这里,笔者使用了260张训练数据,完成了人脸中“眼睛”、...
  • 本文主要是简述如何训练自己数据集,这里以FLIR的红外数据集为例,配置运行以及原理不再叙述 1.修改Makefile 这步一般已经在配置运行的时候已经做过了,没什么大问题 2.将自己数据集处理成yolo训练所需的...
  • yolov3 Obj降到0 问题总结:第一阶段:检查配置文件 1、样本类别个数设置错误,yolov3.cfg classes和filters=(classes+5)x3 计算错误 ...6、更换yolov3-tiny.cfg,看看这个是否收敛,收敛的话数据就没问题第
  • 3.keras==2.2;python==3.5 二、Keras保存权重有两种方式: #方式一:权重的参数和网络结构分开保存 1,保存网络结构到json文件 model_json=model.to_json() with open("mosel.json") as file: file.writ
  • (一) yolov3训练voc 数据集
  • YoLov3训练自己数据集(小白手册)

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

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

    2020-08-18 13:50:04
    自己已经用yolov3训练完成的数据集,该数据集大概4000个, yolov3学习使用。 我自己已经用yolov3训练完成的数据集,该数据集大概4000个, yolov3学习使用
  • YOLOV3训练自己数据集(PyTorch版本)

    万次阅读 多人点赞 2019-05-06 15:59:56
    因而接触到yolov3,进行目标检测,具体原理大家可以参考大神的博客目标检测(九)--YOLO v1,v2,v3,我就不细讲了,直接进入正题,如何利用深度学习框架PyTorch对自己的数据进行训练以及最后的预测。 一、数据集 ...
  • win10下yolov3训练自己数据集

    万次阅读 热门讨论 2018-10-09 16:25:17
    在win10下用yolov3训练自己数据集 1. 在darknet-master\build\darknet\x64 新建yolo-obj.cfg文件(可以直接复制yolov3.cfg,然后重命名为yolo-obj.cfg), 然后就是修改这个文件内容了。 将batch 改成64 :batch...
  • YOLOv3训练KITTI数据集

    万次阅读 多人点赞 2019-01-11 22:31:32
    YOLOv3训练KITTI数据集——Wiznote笔记 部分参考SSD: Single Shot MultiBox Detector 训练KITTI数据集(1),感谢博主的贡献。 目录 1 获取KITTI数据集及标签 2 将KITTI的标签格式转换为VOC数据格式的标签xxx.xml ...
  • 你是不是已经被网上繁琐的 Yolov3 训练自己数据集的教程搞晕了? 你是不是还在纠结 xxx.cfg 文件到底怎样改又或者网上参差不齐的训练代码难以调参? 如果你仅仅是为了追求工程上的快速搭建开发,这里使用基于Pytorch...
  • 忙完最近的事情再来看看怎么搞,先弄到这里留一下。 超详细教程:YOLO_V3(yolov3训练自己的数据 Yolov3 训练自己数据集 Pytorch 最简单 最少代码 最易调参 用YOLOV3定制自己数据集检测模型 ...
  • YOLOv3训练自己数据集实现目标检测

    万次阅读 多人点赞 2020-10-29 11:29:44
    YOLO的全称是You Only Look ...YOLO是一个国外开源的目标检测算法,目前流行的YOLO算法分为三个版本,即YOLOv1、YOLOv2、YOLOv3,YOLO的核心思想就是利用整张图作为网络的输入,直接在输出层回归bounding box(边界)的
  • Pytorch实现YOLOv3训练自己数据集

    万次阅读 多人点赞 2019-08-01 09:11:50
    最近一直在研究深度学习框架PyTorch,就想使用pytorch去实现YOLOv3的object detection.在这个过程中也在各大论坛、贴吧、CSDN等中看了前辈们写的文章,在这里由衷的感谢帮助过我的朋友们,真的很感谢!!!! 接下来...

空空如也

空空如也

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

yolov3训练自己的数据集