深度学习（五）yolov2代码分析

Darknet代码详解：

上文配置好环境之后，进入darknet.c,接着进入run_detector(argc,argv)

if (0 == strcmp(argv[1], "average")){
        average(argc, argv);
    } else if (0 == strcmp(argv[1], "yolo")){
        run_yolo(argc, argv);
    } else if (0 == strcmp(argv[1], "voxel")){
        run_voxel(argc, argv);
    } else if (0 == strcmp(argv[1], "super")){
        run_super(argc, argv);
    } else if (0 == strcmp(argv[1], "detector")){
        run_detector(argc, argv);  //detector.c
    } else if (0 == strcmp(argv[1], "detect")){
        float thresh = find_float_arg(argc, argv, "-thresh", .24);
        char *filename = (argc > 4) ? argv[4]: 0;
        test_detector("cfg/coco.data", argv[2], argv[3], filename, thresh, .5);
    } else if (0 == strcmp(argv[1], "cifar")){
        run_cifar(argc, argv);
    } else if (0 == strcmp(argv[1], "go")){
        run_go(argc, argv);
    } else if (0 == strcmp(argv[1], "rnn")){
        run_char_rnn(argc, argv);
    } else if (0 == strcmp(argv[1], "vid")){
        run_vid_rnn(argc, argv);
    } else if (0 == strcmp(argv[1], "coco")){
        run_coco(argc, argv);
    } else if (0 == strcmp(argv[1], "classify")){
        predict_classifier("cfg/imagenet1k.data", argv[2], argv[3], argv[4], 5);

下面分别对train，test, visualize做详细分析：

if(0==strcmp(argv[2], "test")) test_detector(datacfg, cfg, weights, filename, thresh, hier_thresh);
    else if(0==strcmp(argv[2], "train")) train_detector(datacfg, cfg, weights, gpus, ngpus, clear);  //
    else if(0==strcmp(argv[2], "valid")) validate_detector(datacfg, cfg, weights, outfile);

对训练部分做分析：

进入train_detector（datacfg,cfg, weights,......）：

void train_detector(char *datacfg, char *cfgfile, char *weightfile, int *gpus, int ngpus, int clear)
{
    //读取相应数据文件
    list *options = read_data_cfg(datacfg);
    char *train_images = option_find_str(options, "train", "data/train.list");
    char *backup_directory = option_find_str(options, "backup", "/backup/");
    //srand()与rand()结合产生随机数
    srand(time(0)); 
    char *base = basecfg(cfgfile); //读取网络配置文件
    printf("%s\n", base);
    float avg_loss = -1;
    network *nets = calloc(ngpus, sizeof(network));
    srand(time(0));
    int seed = rand();
    int i;
    //根据gpu个数解析网络结构
    for(i = 0; i < ngpus; ++i){
        srand(seed);
#ifdef GPU
        cuda_set_device(gpus[i]);
#endif
        nets[i] = parse_network_cfg(cfgfile); //解析网络结构，下文会对该函数做分析
       //如果命令包含权重文件，则装载权重文件
        if(weightfile){
            load_weights(&nets[i], weightfile); 
        }
        if(clear) *nets[i].seen = 0; //清空记录训练次数
        nets[i].learning_rate *= ngpus;
    }
    srand(time(0));
    network net = nets[0];
    //一次载入到显存的图片数量
    int imgs = net.batch * net.subdivisions * ngpus;
    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);
    data train, buffer;
    layer l = net.layers[net.n - 1];
    int classes = l.classes;
    //抖动产生额外数据
    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;
    args.n = imgs;
    args.m = plist->size;
    args.classes = classes;
    args.jitter = jitter;
    args.num_boxes = l.max_boxes;
    args.d = &buffer;
    args.type = DETECTION_DATA;
    args.threads = 8;
   //数据扩增，角度，曝光，饱和，灰度
    args.angle = net.angle; 
    args.exposure = net.exposure;
    args.saturation = net.saturation;
    args.hue = net.hue;
    pthread_t load_thread = load_data(args);
    clock_t time;
    int count = 0;
    //while(i*imgs < N*120){
    while(get_current_batch(net) < net.max_batches){  //current number of iterations < the max number of iterations
        if(l.random && count++%10 == 0){   // the random initiation of layer equals zero or the number of iteration equals 10X
            printf("Resizing\n");
   //根据训练图片的大小调节下面10,5,20参数，该处图片防缩范围在100-280之间
            int dim = (rand() % 10 + 5) * 20;
  //最后200次迭代,图片大小为280*280
            if (get_current_batch(net)+200 > net.max_batches) dim = 280;
            //int dim = (rand() % 4 + 16) * 32;
            printf("%d\n", dim);
            args.w = dim;
            args.h = dim;
          //线程相关 
	  pthread_join(load_thread, 0);
            train = buffer;
            free_data(train);
            load_thread = load_data(args);
          //放缩网络的大小进行训练  
	 for(i = 0; i < ngpus; ++i){
                resize_network(nets + i, dim, dim);
            }
	 //net得到某一个gpu处理的结构，每个GPU处理网络结构大小相同
            net = nets[0];
        }
        //可视化网络权重和特征图（仅CPU可看特征图）
	visualize_network(net);
        time=clock();
        pthread_join(load_thread, 0);
        train = buffer;
        load_thread = load_data(args);
        //可视化数据扩增之后训练样本  
	 int k;
           image im = float_to_image(args.w, args.h, 3, train.X.vals[10]);
           for(k = 0; k < l.max_boxes; ++k){
           box b = float_to_box(train.y.vals[10] + k*5);      //train.y.vals[10] +1 + k*5
//           printf("%f %f %f %f %f\n", *(train.y.vals[10] + 1+ k*5), *(train.y.vals[10] + 2+ k*5), *(train.y.vals[10] + 3+ k*5),
//                   *(train.y.vals[10] + 4+ k*5),*(train.y.vals[10] + 5+ k*5));
           if(!b.x) break;
           printf("loaded: %f %f %f %f\n", b.x, b.y, b.w, b.h);                    
           draw_bbox(im, b, 8, 1,0,0);
           }
           save_image(im, "sample");
        printf("Loaded: %lf seconds\n", sec(clock()-time));
        time=clock();
        float loss = 0;
//训练网络
#ifdef GPU
        if(ngpus == 1){
            loss = train_network(net, train);
        } else {
            loss = train_networks(nets, ngpus, train, 4);
        }
#else
        loss = train_network(net, train);
#endif
        if (avg_loss < 0) avg_loss = loss;
        avg_loss = avg_loss*.9 + loss*.1;
        i = get_current_batch(net);
        printf("%d: %f, %f avg, %f rate, %lf seconds, %d images\n", get_current_batch(net), loss, avg_loss, get_current_rate(net), sec(clock()-time), i*imgs);
      //每隔多少次保存权重
        if(i%1000==0 || (i < 1000 && i%100 == 0)){
#ifdef GPU
            if(ngpus != 1) sync_nets(nets, ngpus, 0);
#endif
            char buff[256];
            sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i);
            save_weights(net, buff);
        }
        free_data(train);
    }
//迭代次数达到最大值，保存最后权重
#ifdef GPU
    if(ngpus != 1) sync_nets(nets, ngpus, 0);
#endif
    char buff[256];
    sprintf(buff, "%s/%s_final.weights", backup_directory, base);
    save_weights(net, buff);
}

//对parse_network_cfg(cfgfile)分析

free_section(s);
    fprintf(stderr, "layer     filters    size              input output\n");
//解析所有网络
    while(n){
        params.index = count;
        fprintf(stderr, "%5d ", count);
        s = (section *)n->val;
        options = s->options;
        layer l = {0};
        LAYER_TYPE lt = string_to_layer_type(s->type);
        if(lt == CONVOLUTIONAL){
            l = parse_convolutional(options, params);
        }else if(lt == LOCAL){
            l = parse_local(options, params);
        }else if(lt == ACTIVE){
            l = parse_activation(options, params);
        }

/
//parse_convolutional(options, params);
/

 if(!(h && w && c)) error("Layer before convolutional layer must output image.");
    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
    int binary = option_find_int_quiet(options, "binary", 0);
    int xnor = option_find_int_quiet(options, "xnor", 0);
    convolutional_layer layer = make_convolutional_layer(batch,h,w,c,n,size,stride,padding,activation, batch_normalize, binary, xnor, params.net.adam);
    layer.flipped = option_find_int_quiet(options, "flipped", 0);
    layer.dot = option_find_float_quiet(options, "dot", 0);

/
//make_convolutional_layer(batch,h,w,c,n,size,stride,padding,activation, batch_normalize, binary, xnor, params.net.adam);

//载入权重文件时，已经对卷积网络做了初始化处理
for(i = 0; i < c*n*size*size; ++i) l.weights[i] = scale*rand_uniform(-1, 1);

///
//训练网络train_network(network net, data d)
//

        get_next_batch(d, batch, i*batch, X, y);
        float err = train_network_datum(net, X, y);//训练网络
        sum += err;

/
//train_network_datum(net, X, y);//训练网络
/
#ifdef GPU //使用GPU时训练网络
    if(gpu_index >= 0) return train_network_datum_gpu(net, x, y);
#endif
    network_state state;

/
//接着在network_kernels.cu找到train_network_datum_gpu
/
    *net.seen += net.batch;
    forward_backward_network_gpu(net, x, y); //前向后向传播
    float error = get_network_cost(net); //网络代价
    if (((*net.seen) / net.batch) % net.subdivisions == 0) update_network_gpu(net); //更新网络

/
// forward_backward_network_gpu(net, x, y)
/
    forward_network_gpu(net, state); //前向传播
    backward_network_gpu(net, state); //后向传播


//forward_network_gpu(net, state); //前向传播

        l.forward_gpu(l, state); //use function forward_convolutional_layer_gpu in convolutional_kernels.cu
        state.input = l.output_gpu;

///接着进入convolutional_kernels.cu
///找到与 l.forward_gpu(l, state);对应的函数
///void forward_convolutional_layer_gpu(convolutional_layer l, network_state state)
    for(i = 0; i < l.batch; ++i){
        im2col_ongpu(state.input + i*l.c*l.h*l.w, l.c,  l.h,  l.w,  l.size,  l.stride, l.pad, state.workspace); //直接将feature map和输入图像矩阵拉成列向量
        float * a = l.weights_gpu;
        float * b = state.workspace;
        float * c = l.output_gpu;
        gemm_ongpu(0,0,m,n,k,1.,a,k,b,n,1.,c+i*m*n,n); //进行卷积运算，函数在gemm.c里面
    }

//进入im2col_kernels.cu
//将输入图片或者前面feature map 拉伸，从左向右，从上到下，如果3*3卷积核，输入彩色3通道图片大小480*480=230400,所以一个卷积核拉伸为3*3*3个230400列向量的大小
void im2col_ongpu(float *im,
         int channels, int height, int width,
         int ksize, int stride, int pad, float *data_col){
    // We are going to launch channels * height_col * width_col kernels, each
    // kernel responsible for copying a single-channel grid.
    int height_col = (height + 2 * pad - ksize) / stride + 1;
    int width_col = (width + 2 * pad - ksize) / stride + 1;
    int num_kernels = channels * height_col * width_col;
    //use num_kernels+BLOCK-1)/BLOCK block and BLOCK thread to run kernel.
    im2col_gpu_kernel<<<(num_kernels+BLOCK-1)/BLOCK,
        BLOCK>>>(
                num_kernels, im, height, width, ksize, pad,
                stride, height_col,
                width_col, data_col); //cuda block 和thread 的个数，调用 im2col_gpu_kernel函数
}

对测试部分做分析：

进入test_detector(datacfg, cfg, weights, filename, thresh, hier_thresh);

//对文件名字读取，输入参数有文件直接进行下一步，没有提示输入
if(filename){
            strncpy(input, filename, 256);
        } else {
            printf("Enter Image Path: ");
            fflush(stdout);
            input = fgets(input, 256, stdin);
            if(!input) return;
            strtok(input, "\n");
        }
        image im = load_image_color(input,0,0);
        image sized = resize_image(im, net.w, net.h); //resize image to net.w and net.h
        /************/
        //the last layer uses to produce box and probs
        layer l = net.layers[net.n-1];
        box *boxes = calloc(l.w*l.h*l.n, sizeof(box));
        float **probs = calloc(l.w*l.h*l.n, sizeof(float *));
        for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = calloc(l.classes + 1, sizeof(float *));
        /************/
        float *X = sized.data;
        time=clock();
        network_predict(net, X);
        visualize_network(net);
//        get_network_image(net);
        printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
//预测盒子
        get_region_boxes(l, 1, 1, thresh, probs, boxes, 0, 0, hier_thresh);
//进行非极大抑制
        if (l.softmax_tree && nms) do_nms_obj(boxes, probs, l.w*l.h*l.n, l.classes, nms);
        else if (nms) do_nms_sort(boxes, probs, l.w*l.h*l.n, l.classes, nms);
//画检测框
        draw_detections(im, l.w*l.h*l.n, thresh, boxes, probs, names, alphabet, l.classes);
        save_image(im, "predictions");
//        show_image(im, "predictions");

对可视化做分析：

} else if (0 == strcmp(argv[1], "oneoff")){
        oneoff(argv[2], argv[3], argv[4]);
    } else if (0 == strcmp(argv[1], "partial")){
        partial(argv[2], argv[3], argv[4], atoi(argv[5]));
    } else if (0 == strcmp(argv[1], "average")){
        average(argc, argv);
    } else if (0 == strcmp(argv[1], "visualize")){ //visualize the weights of conv filter only, the values of feature map equals to 0
        visualize(argv[2], (argc > 3) ? argv[3] : 0);
    } else if (0 == strcmp(argv[1], "imtest")){
        test_resize(argv[2]);

分析visualize(argv[2], (argc > 3) ? argv[3] : 0);
///
    network net = parse_network_cfg(cfgfile); // parse net
    if(weightfile){
        load_weights(&net, weightfile); // load weights
    }
    visualize_network(net); //visualize

分析 visualize_network(net); 

    image *prev = 0;
    int i;
    char buff[256];
    //layer 0-n visualization
    for(i = 0; i < net.n; ++i){
        sprintf(buff, "Layer %d", i);
        layer l = net.layers[i]; //layer ith
        if(l.type == CONVOLUTIONAL){  //if layer is conv, visualize conv layer
            prev = visualize_convolutional_layer(l, buff, prev);
        }
    } 

//
分析：visualize_convolutional_layer(l, buff, prev);
    image *single_weights = get_weights(l);
    show_images(single_weights, l.n, window); // visualize conv layer l.n
    //visualize feature map according to layer l.n
    image delta = get_convolutional_image(l);
    image dc = collapse_image_layers(delta, 1);
    char buff[256];
    sprintf(buff, "%s: Output", window);
    save_image(dc, buff);
//    show_image(dc, buff);
    free_image(dc);
    return single_weights;

深度学习（五）yolov2代码分析

继续阅读

简单文档分类——朴素贝叶斯算法朴素贝叶斯算法简单文档分类实例步骤总结朴素贝叶斯分类调用(sklearn)

考证大全 | 证券从业资格考试

敲黑板！2021年证券从业考试考点预测

2021年银行从业考试考情介绍,果断收藏!

证券从业合格证书什么时候打印？有哪些注意事项？

【干货满满】初级银行从业考试《个人理财》重点梳理

2020年经济师考试，难吗？

初级银行从业资格证有什么用？

MBA提前面试纯干货分享

MBA值得学么

吴恩达logistic回归实现

【人工智能行业大师访谈1】吴恩达采访 Geoffery Hinton

深度学习模型分析人类复杂疾病的准确性

【趋高机器视觉】机器视觉技术原理解析及解决方案

解码器用于语义分割：数据依赖的解码可以实现灵活的特征聚合

cs231n斯坦福基于卷积神经网络的CV学习笔记（一）KNN和线性分类器/分类器损失/反向传播一，KNN图像分类算法二，线性分类器三，线性分类器损失四，反向传播五，神经网络