YOLO源码详解（一）-训练

最新推荐文章于 2023-08-04 23:30:36 发布
最新推荐文章于 2023-08-04 23:30:36 发布
阅读量1k 收藏 1
点赞数
分类专栏： YOLO源码阅读 文章标签： YOLO源码阅读

本系列作者：木凌 
时间：2016年11月。 
文章连接：http://blog.csdn.net/u014540717 
QQ交流群：554590241

本系列文章会持续更新，主要会分以下几个部分： 
１、darknet下的yolo源代码解读 
２、将yolo移植到mxnet下 
３、模型压缩与加速 
白天需要工作，只有晚上时间写，所以可能更新速度有点慢，还有就是该系列博文不一定会严格按照以上三点的顺序来写，也可能移植到caffe下，在caffe下进行压缩和加速。

一、训练

我用的是VOC2007的数据集，下载指令如下：

$curl -O http://pjreddie.com/media/files/VOCtrainval_06-Nov-2007.tar
$curl -O http://pjreddie.com/media/files/VOCtest_06-Nov-2007.tar
$tar xf VOCtrainval_06-Nov-2007.tar
$tar xf VOCtest_06-Nov-2007.tar
  • 1
  • 2
  • 3
  • 4

运行以下代码，将.xml 文件转换成.txt 文件，以备YOLO训练时数据解析：

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')]

classes = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]


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(year, image_id):
    in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))
    out_file = open('VOCdevkit/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('VOCdevkit/VOC%s/labels/'%(year)):
        os.makedirs('VOCdevkit/VOC%s/labels/'%(year))
    image_ids = open('VOCdevkit/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('%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg\n'%(wd, year, image_id))
        convert_annotation(year, 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

在yolo.c中找到以下代码，并修改：

//指向你刚才生成的train.txt文件
char *train_images = "/data/voc/train.txt";
//新建个文件夹，然后指向这里就可以，训练生成的模型文件会保存在这里
char *backup_directory = "/home/pjreddie/backup/";
  • 1
  • 2
  • 3
  • 4

运行以下指令开始训练：

./darknet yolo train cfg/yolo.train.cfg extraction.conv.weights
  • 1

二、源码解读

1.首先我们看一下训练的数据流，从main函数开始看，该函数在darknet.c 文件中：

//darknet.c
int main(int argc, char **argv)
{
    //test_resize("data/bad.jpg");
    //test_box();
    //test_convolutional_layer();
    if(argc < 2){
        fprintf(stderr, "usage: %s <function>\n", argv[0]);
        return 0;
    }
    gpu_index = find_int_arg(argc, argv, "-i", 0);
    if(find_arg(argc, argv, "-nogpu")) {
        gpu_index = -1;
    }

#ifndef GPU
    gpu_index = -1;
#else
    if(gpu_index >= 0){
        cuda_set_device(gpu_index);
    }
#endif

    if (0 == strcmp(argv[1], "average")){
        average(argc, argv);
    } else if (0 == strcmp(argv[1], "yolo")){
        //第一个参数是yolo，所以跳转到run_yolo函数
        run_yolo(argc, argv);
    } else {
        fprintf(stderr, "Not an option: %s\n", argv[1]);
    }
    return 0;
}
  • 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
//yolo.c
void run_yolo(int argc, char **argv)
{
    char *prefix = find_char_arg(argc, argv, "-prefix", 0);
    float thresh = find_float_arg(argc, argv, "-thresh", .2);
    int cam_index = find_int_arg(argc, argv, "-c", 0);
    int frame_skip = find_int_arg(argc, argv, "-s", 0);
    if(argc < 4){
        fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
        return;
    }

    char *cfg = argv[3];
    char *weights = (argc > 4) ? argv[4] : 0;
    char *filename = (argc > 5) ? argv[5]: 0;
    if(0==strcmp(argv[2], "test")) test_yolo(cfg, weights, filename, thresh);
    //第二个参数是train，所以跳转到了train_yolo函数
    else if(0==strcmp(argv[2], "train")) train_yolo(cfg, weights);
    voc_names, 20, frame_skip, prefix);
}


void train_yolo(char *cfgfile, char *weightfile)
{
    char *train_images = "/data/voc/train.txt";
    char *backup_directory = "/home/pjreddie/backup/";
    /*srand函数是随机数发生器的初始化函数。
    srand和rand()配合使用产生伪随机数序列。rand函数在产生随机数前，需要系统提供的生成伪随机数序列的
    种子，rand根据这个种子的值产生一系列随机数。如果系统提供的种子没有变化，每次调用rand函数生成的伪
    随机数序列都是一样的。*/
    srand(time(0));
    /*第三个参数是：`cfg/yolo.train.cfg`，`basecfg()`这个函数把`cfg/yolo.train.cfg`变成了
    `yolo0train.cfg`，然后用base指针指向`yolo0train.cfg`*/
    char *base = basecfg(cfgfile);
    //打印"yolo"字样
    printf("%s\n", base);
    float avg_loss = -1;
    //解析网络构架，下面会仔细分析该函数
    network net = parse_network_cfg(cfgfile);
    //加载预训练参数，下面会仔细分析该函数
    if(weightfile){
        load_weights(&net, weightfile);
    }
    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);
    /*imgs是一次加载到内存的图像数量，如果占内存太大的话可以把subdivisions或者batch调小一点
    详细可以参考知乎：[深度机器学习中的batch的大小对学习效果有何影响？](https://www.zhihu.com/question/32673260)*/
    int imgs = net.batch*net.subdivisions;
    //net.seen就是已经经过网络训练（看）的图片数量，算出的i就是已经经过了多少次训练
    int i = *net.seen/imgs;
    data train, buffer;


    layer l = net.layers[net.n - 1];
    //side就是论文中的7
    int side = l.side;
    int classes = l.classes;
    //jitter是什么意思呢？可以参考这篇博客：[非均衡数据集处理：利用抖动(jittering)生成额外数据](http://weibo.com/1402400261/EgMr4vCC2?type=comment#_rnd1478833653326)
    float jitter = l.jitter;

    list *plist = get_paths(train_images);
    //int N = plist->size;
    char **paths = (char **)list_to_array(plist);

    load_args args = {0};
    args.w = net.w;
    args.h = net.h;
    args.paths = paths;
    //n就是一次加载到内存中的图片数量
    args.n = imgs;
    //m是待训练图片的总数量
    args.m = plist->size;
    args.classes = classes;
    args.jitter = jitter;
    //7*7个网格
    args.num_boxes = side;
    args.d = &buffer;
    args.type = REGION_DATA;

    //调节图片旋转角度、曝光度、饱和度、色调等，来增加图片数量
    args.angle = net.angle;
    args.exposure = net.exposure;
    args.saturation = net.saturation;
    args.hue = net.hue;
    //声明线程ID
    pthread_t load_thread = load_data_in_thread(args);
    clock_t time;
    //while(i*imgs < N*120){
    while(get_current_batch(net) < net.max_batches){
        i += 1;
        time=clock();
        /*pthread_join()函数，以阻塞的方式等待thread指定的线程结束。当函数返回时，被等待线程的资源被
        收回。如果线程已经结束，那么该函数会立即返回。*/
        pthread_join(load_thread, 0);
        train = buffer;
        load_thread = load_data_in_thread(args);

        printf("Loaded: %lf seconds\n", sec(clock()-time));

        time=clock();
        //开始训练
        float loss = train_network(net, train);
        if (avg_loss < 0) avg_loss = loss;
        avg_loss = avg_loss*.9 + loss*.1;

        printf("%d: %f, %f avg, %f rate, %lf seconds, %d images\n", i, loss, avg_loss, get_current_rate(net), sec(clock()-time), i*imgs);
        //每100次或者1000次保存一次权重
        if(i%1000==0 || (i < 1000 && i%100 == 0)){
            char buff[256];
            sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i);
            save_weights(net, buff);
        }
        free_data(train);
    }
    char buff[256];
    sprintf(buff, "%s/%s_final.weights", backup_directory, base);
    save_weights(net, buff);
}
  • 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
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117

看到这里，我想你已经能可以自己来训练VOC数据集了。但这只是刚刚开始，我们要想将YOLO移植到mxnet下，就需要了解其具体函数的实现过程，请看下一节内容。

YDQN
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YOLOV5 部署：QT的可视化界面推理（创建UI，并编译成py文件）
Henry的博客
03-14 810
之前用YOLOV5 做了一个猫和老鼠的实战检测项目，本章将根据之前训练好的权重进行部署，搭建一个基于QT的可视化推理界面，可以检测图片和视频。
yolov3的java调用示例
12-06
通过java代码使用yolov3的示例代码，yolov3是先进的图片内物品识别的神经网络。由于目前通过jvm运行神经网络效率较低，项目的示例意义大于实用意义。 此项目参考了yolov2的java项目：https://github.com/szaza/android-yolo-v2，是在这个项目的基础上改造成的yolov3示例。 此项目使用springboot和maven，下载项目和依赖后运行起来访问localhost:8080即可使用。项目内的模型和依赖比较重，下载需要一段时间。
YOLOv8目标检测实战：Android手机部署
05-24
YOLOv8 目标检测基于先前 YOLO 版本的成功，引入了新功能和改进，进一步提升了性能和灵活性。本课程在Windows上手把手演示YOLOv8（YOLOv8n和YOLOv8s）目标检测在Android（安卓）手机进行部署的过程。内容包括：安装软件环境、安装PyTorch，克隆和安装YOLOv8，导出onnx模型，onnx转换成NCNN文件，安装Android Studio，准备Android项目文件(下载项目文件、放置ncnn文件、放置ncnn和opencv的android文件)，手机连接电脑并编译软件(安装投屏软件、手机连接电脑配置、编译和调试、导出签名apk)，自己数据集训练模型的部署，项目代码解析（安卓的JNI机制、C++代码、Java代码）。
使用Java调用Yolo模型的方法与步骤
m0_61789994的博客
05-16 5283
Yolo（You Only Look Once）是一种基于深度学习的目标检测算法，它可以在一张图像中同时检测出多个目标，并给出它们的位置和类别。相比于传统的目标检测算法，Yolo算法具有检测速度快、精度高等优点，因此在实际应用中得到了广泛的应用。Yolo模型是一种高效的目标检测算法，具有快速、准确、实时等优点。通过使用Java调用Yolo模型，我们可以在Java应用程序中实现目标检测功能，从而满足各种应用场景的需求。
使用Java调用Yolo模型的准备工作与输入输出
m0_61789994的博客
06-11 3083
Yolo是一种基于深度学习的目标检测算法，通过将目标检测任务转化为一个回归问题，直接在图像级别上预测边界框和类别信息。相比于传统的两步检测方法（如R-CNN系列），Yolo算法具有更快的速度和更好的实时性能。Yolo（You Only Look Once）是一种流行的实时目标检测算法，具有高效性和准确性。Yolo算法的主要思想是将目标检测问题转化为一个回归问题，并使用单个卷积神经网络同时预测目标的位置和类别。本文介绍了如何使用Java调用Yolo目标检测模型，并给出了相关示例代码。
Java 实现 YoloV7 人体姿态识别
meng_xin_true的博客
04-27 2813
Java使用OnnxRuntime及OpenCV实现YoloV7姿态识别
yolo3-pytorch-master_pytorch_yolo_yolo3pytorch_yolo3_
10-01
利用pytorch的平台搭建了yolo3目标检测算法，实用性很强
yolo3-pytorch-master.zip
05-15
pytorch的平台搭建了yolo3目标检测算法
YOLO系列结构图-visio
03-08
1.YOLOV3 2.YOLOV4 3.YOLOV5
yolo3 源码 2019-1-23镜像版本
01-23
yolo3 源码 2019-1-23镜像版本。 看过yolov3论文的应该都知道，这篇论文写得很随意，很多亮点都被作者都是草草描述。很多骚年入手yolo算法都是从v3才开始，这是不可能掌握yolo精髓的，因为v3很多东西是保留v2甚至v1...
yolo资料.txt-yolo
最新发布
03-02
yolo资料.txt-yoloyolo资料.txt-yolo
YOLO目标检测+摔倒检测数据集已标注可以直接使用（5700张图像+对应已标注txt和xml文件）.rar
05-10
1、资源描述： 2、资源内容：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 3、适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 4、更多数据集合和仿真源码下载列表（自行寻找自己需要的）：https://blog.csdn.net/m0_62143653?type=download 5、作者介绍：某大厂资深算法工程师，从事Matlab、Python、C/C++、Java、YOLO算法仿真工作10年；擅长计算机视觉、目标检测模型、智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、智能控制、路径规划、无人机等多种领域的算法仿真实验，欢迎交流学习。
DeepLearning4j-使用Java训练YOLO模型
01-27
本文来自于csdn，文章介绍了数据集、模型训练中读取训练数据以及模型检测可视化等相关内容。在这个Yolov3发布的大好日子。 Deeplearning4j终于迎来了新的版本更新1.0.0-alpha，在zoomodel中引入TinyYolo模型可以训练自己的数据用于目标检测。 不得不说，在Yolov3这种性能和准确率上面都有大幅度提升的情况下，dl4j才引入TinyYolo总有一种49年加入国军的感觉 数据来源自
Java 实现 YoloV7 目标检测
meng_xin_true的博客
04-27 2410
基于JAVA实现YOLOv7目标检测
基于Java 实现的 YOLO 对象检测
m0_75176907的博客
08-04 673
一个基于 java 的模板，用于仅使用 YOLO 权重进行基于流视频的对象检测
yolov5+opencv+java：通过DJL在maven项目中使用yolov5的小demo
热门推荐
xzq1207105685的博客
05-30 1万+
目录前言环境导出yolov5s模型编写Maven项目编写pom.xml文件引入opencv依赖下载opencv获取opencv的jar包和动态链接库dll文件将lib文件夹添加为Library将yolov5权重文件放到资源文件编写代码运行程序 前言 这篇博客主要是介绍如何通过djl在java中调用yolov5进行推理，顺便也学习了一下在java上的opencv api。 Deep Java Library是由亚马逊（Amazon）提供的一个深度学习工具包，能够让java开发者在java上调用目前主流的深度学
Yolov5+Java+Python
KevinJee_
07-19 2017
训练两个测试集，鸟类和工具包。使用yolov5算法能够精准识别对应的信息
YOLOv2训练时参数调整情况及分析
xiaomifanhxx的博客
07-18 5244
    在进行YOLOv2训练的时候，我们想要更直观的看到模型的情况，那我们可以使用模型训练可视化得到模型的参数随时间变化的情况，这样我们也能判断出模型的好坏。(并不是训练时间越长，模型越好，我们通过可视化来找到较为理想的参数)     在检测各项指标的时候(如loss，IOU等)，我们可以使用验证集来判断我们模型的好坏，但这个判断只能使用保存好的参数，我们并不能实时的查看模型的好坏。因此，我们...
yolo-fastestv1-xl对训练数据集的要求
07-08
YOLO-Fastest V1-XL对训练数据集的要求与其他目标检测模型类似。以下是一些常见的要求： 1. 标注格式：训练数据集需要使用特定的标注格式，如Pascal VOC、COCO或YOLO格式。每个图像需要标注目标的类别和边界框信息...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值