YOLO源码详解(一)-训练

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


本系列文章会持续更新,主要会分以下几个部分: 
1、darknet下的yolo源代码解读 
2、将yolo移植到mxnet下 
3、模型压缩与加速 
白天需要工作,只有晚上时间写,所以可能更新速度有点慢,还有就是该系列博文不一定会严格按照以上三点的顺序来写,也可能移植到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下,就需要了解其具体函数的实现过程,请看下一节内容。

<think>我们被要求回答关于如何获取YOLO项目源码的问题。根据用户引用的内容,用户可能对YOLO的多个版本(如YOLOv1到YOLOv8)的源码感兴趣,并且特别提到了易语言实现的Yolo自瞄源码(引用[1])以及YOLOv5的源码(引用[3])。同时,引用[2]提到了YOLO源码解读的资源。 由于YOLO有多个版本,且由不同的作者和团队维护,因此获取源码的途径可能不同。以下将分别说明: 1. **YOLO(原始版本,由Joseph Redmon等人开发)**: - 最早的YOLO版本(v1-v3)的源代码可以在Joseph Redmon的GitHub上找到:https://github.com/pjreddie/darknet - 这个仓库使用C语言编写,并提供了详细的文档和预训练权重。 2. **YOLOv4**: - YOLOv4由Alexey Bochkovskiy等人开发,源码同样在Darknet框架下:https://github.com/AlexeyAB/darknet 3. **YOLOv5**: - YOLOv5由Ultralytics公司开发,使用PyTorch框架。这是目前非常流行的版本,引用[3]中提到的YOLOv5s、m、l、x等版本都在此仓库中。 - 源码地址:https://github.com/ultralytics/yolov5 4. **YOLOv6、YOLOv7、YOLOv8**: - YOLOv6:由美团团队开发,源码地址:https://github.com/meituan/YOLOv6 - YOLOv7:由Chien-Yao Wang等人开发,源码地址:https://github.com/WongKinYiu/yolov7 - YOLOv8:同样由Ultralytics公司开发,是YOLOv5的延续,源码地址:https://github.com/ultralytics/ultralytics 5. **易语言实现的Yolo自瞄源码**(如引用[1]中所述): - 用户提供了个项目地址:https://gitcode.com/open-source-toolkit/227d3 - 注意:这个项目是用易语言编写的,针对特定的自瞄应用场景。 此外,用户还可以通过以下途径获取YOLO相关资源: - 论文:YOLO各版本的论文通常包含算法的详细描述,可以在arXiv等平台获取。 - 源码解读:如引用[2]中提到的资源,可以帮助理解YOLO的实现细节。 **获取源码的步骤**: 1. 访问上述GitHub或GitCode链接。 2. 在仓库页面,通常会有“Code”按钮(绿色按钮),点击后可以复制仓库的URL。 3. 使用Git克隆到本地:`git clone <仓库URL>` 4. 或者直接下载ZIP文件(在仓库页面有“Download ZIP”选项)。 **注意事项**: - 下载源码后,请仔细阅读README.md文件,了解如何安装依赖、运行程序以及使用预训练模型。 - 不同版本的YOLO依赖环境可能不同(如Darknet需要C和CUDA,而YOLOv5/v8需要PyTorch)。 如果用户需要的是特定版本的YOLO源码,请根据版本选择对应的仓库。对于学习目的,建议从YOLOv5或YOLOv8开始,因为它们的文档和社区支持较好。 最后,用户引用的易语言项目(引用[1])是个特定应用(自瞄)的实现,可能不适合通用目标检测,但可以作为易语言调用YOLO的参考。 §§相关问题§§ 1. YOLOv5和YOLOv8在模型结构上有哪些主要区别? 2. 如何使用易语言调用YOLO模型进行目标检测? 3. 在Windows系统上如何配置YOLOv5的运行环境?</think>### YOLO源码获取方法 根据您的需求,以下是获取YOLO项目源码的详细方法和资源: --- ### **、官方源码仓库(推荐)** 1. **YOLOv5(Ultralytics维护)** - 官方GitHub仓库:https://github.com/ultralytics/yolov5 - 包含完整代码、预训练权重和文档 - 支持多种版本:YOLOv5s/m/l/x(模型深度和宽度不同)[^3] - 获取命令: ```bash git clone https://github.com/ultralytics/yolov5 ``` 2. **YOLOv8(最新版本)** - 官方仓库:https://github.com/ultralytics/ultralytics - 支持目标检测/实例分割/姿态估计 - 安装方式: ```bash pip install ultralytics ``` --- ### **二、历史版本源码** 1. **YOLOv1-v3(Darknet框架)** - 原始作者Joseph Redmon的仓库: ```bash git clone https://github.com/pjreddie/darknet ``` 2. **YOLOv4(AlexeyAB维护)** - 优化版Darknet: ```bash git clone https://github.com/AlexeyAB/darknet ``` --- ### **三、特定实现版本** 1. **易语言YOLO自瞄源码** - 项目地址:https://gitcode.com/open-source-toolkit/227d3 [^1] - 特点: - 针对游戏目标快速定位设计 - 易语言编写的轻量级实现 - 包含自动瞄准逻辑 2. **TensorFlow/Keras实现** - 热门复现项目: ```bash git clone https://github.com/zzh8829/yolov3-tf2 ``` --- ### **四、源码学习资源** 1. **源码解读教程** - YOLO系列架构详解(含V1-V4核心模块分析)[^2] - 关键组件解读: - Anchor机制 - FPN特征金字塔 - Focal Loss实现 2. **实践指南** - YOLOv5超详细教程(含代码注释): - 模型结构可视化 - 数据增强实现 - 训练流程解析[^3] --- ### **五、获取注意事项** 1. **版本选择建议** | 版本 | 适用场景 | 硬件要求 | |-----------|-------------------------|-------------| | YOLOv5n/s | 移动端/边缘设备 | 低(2GB显存)| | YOLOv8m/l | 服务器/高性能GPU | 高(8GB+显存)| | 易语言版 | Windows环境快速部署 | CPU即可 | 2. **验证源码完整性** - 检查仓库的`Star`数量(>10k通常更可靠) - 确认最新commit时间(建议选择6个月内有更新的仓库) - 查看`issues`区活跃度 --- ### **六、快速验证方法** 克隆后运行检测示例: ```bash # YOLOv5示例 cd yolov5 pip install -r requirements.txt python detect.py --source data/images/bus.jpg ``` > 输出结果将保存在`runs/detect/exp`目录下[^3] ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值