只看一眼学习笔记（一）

yolo的作者不久前发表了yolov3，网络结构变深了，但是速度依然非常快，准确度也得到了提升。

yolov项目地址：https://pjreddie.com/darknet/yolo/

自己的工作需要使用yolo检测目标，记录一下学习内容以备日后翻阅。查看了新的yolov3.cfg，其中有一些新的参数，如[upsample]和[yolo]等，根据AlexeyAB在github上的解答（https://github.com/AlexeyAB/darknet/issues/504#issuecomment-377290060）upsample层实现的是类似yolov2中reorg层的功能，查看代码后，我的理解是当forward输入的一个特征图上每个点用它的scale倍（默认为1，可以在cfg里设置）扩充为4个点，最后输出的w和h都成为原来的2倍。这里是为了使高层特征的维度和低层特征的维度相同，然后concatenate起来提高细粒度特征的提取能力。

yolo层是新的检测器层，替代region层使用了多尺度预测的方法。下面是解析cfg文件中yolo层的代码。

layer parse_yolo(list *options, size_params params)
{
	int classes = option_find_int(options, "classes", 20);    // 检测任务的目标类别数
	int total = option_find_int(options, "num", 1);            // anchor的总个数
	int num = total;                                

	char *a = option_find_str(options, "mask", 0);         // 该层使用的anchor的索引，yolov3使用多尺度预测，每个尺度使用3个anchor
	int *mask = parse_yolo_mask(a, &num);              // 把a字符串中以,分隔得数字转换为整形保存在mask数组中，num更新为a中数字的个数
	layer l = make_yolo_layer(params.batch, params.w, params.h, num, total, mask, classe);
	assert(l.outputs == params.inputs);

	l.max_boxes = option_find_int_quiet(options, "max", 90);
	l.jitter = option_find_float(options, "jitter", .2);        // 数据抖动范围，默认0~0.2

	l.ignore_thresh = option_find_float(options, "ignore_thresh", .5);    // 决定是否需要计算IOU误差的参数
	l.truth_thresh = option_find_float(options, "truth_thresh", 1);
	l.random = option_find_int_quiet(options, "random", 0);    // 如果为1每次迭代图片大小随机，为0训练大小与输入大小一致

	char *map_file = option_find_str(options, "map", 0);
	if (map_file) l.map = read_map(map_file);

	a = option_find_str(options, "anchors", 0);
	if (a) {
		int len = strlen(a);
		int n = 1;
		int i;
		for (i = 0; i < len; ++i) {
			if (a[i] == ',') ++n;        // 统计anchor宽和高的总和
		}
		for (i = 0; i < n; ++i) {
			float bias = atof(a);
			l.biases[i] = bias;
			a = strchr(a, ',') + 1;     // 定位a到下一个，后面第一个位置
		}
	}
	return l;
}

下面是make_yolo_layer函数的代码：

layer make_yolo_layer(int batch, int w, int h, int n, int total, int *mask, int classes)
{
    int i;
    layer l = {0};
    l.type = YOLO;

    l.n = n;                        // 该层使用的anchor数
    l.total = total;                // yolov3的总anchor数
    l.batch = batch;
    l.h = h;
    l.w = w;
    l.c = n*(classes + 4 + 1);    
    l.out_w = l.w;
    l.out_h = l.h;
    l.out_c = l.c;
    l.classes = classes;
    l.cost = calloc(1, sizeof(float));
    l.biases = calloc(total*2, sizeof(float));
    if(mask) l.mask = mask;
    else{
        l.mask = calloc(n, sizeof(int));
        for(i = 0; i < n; ++i){
            l.mask[i] = i;
        }
    }
    l.bias_updates = calloc(n*2, sizeof(float));
    l.outputs = h*w*n*(classes + 4 + 1);            
    l.inputs = l.outputs;
    l.truths = 90*(4 + 1);            // max boxes默认90，即每张图像中目标的最大个数
    l.delta = calloc(batch*l.outputs, sizeof(float));
    l.output = calloc(batch*l.outputs, sizeof(float));
    for(i = 0; i < total*2; ++i){
        l.biases[i] = .5;
    }

    l.forward = forward_yolo_layer;
    l.backward = backward_yolo_layer;
#ifdef GPU
    l.forward_gpu = forward_yolo_layer_gpu;
    l.backward_gpu = backward_yolo_layer_gpu;
    l.output_gpu = cuda_make_array(l.output, batch*l.outputs);
    l.delta_gpu = cuda_make_array(l.delta, batch*l.outputs);
#endif

    fprintf(stderr, "detection\n");
    srand(0);

    return l;
}

定义了一些输入输出维度和anchor个数以及分配内存后，主要还是forward和backward函数，首先需要了解一些存储结构，才能读懂源码中的索引。

首先是net.truth，其实是target的存储格式：x，y，w，h，class，x，y，w，h，class...

然后是output数组的存储格式：w×h×entry×n×batch，entry对应每个anchor生成的向量维度，长度是（4+1+classes），依次存储box的（x,y,w,h）和有无目标的confidence以及类别class。

void forward_yolo_layer(const layer l, network net)
{
    int i,j,b,t,n;
    memcpy(l.output, net.input, l.outputs*l.batch*sizeof(float));

#ifndef GPU
    for (b = 0; b < l.batch; ++b){
        for(n = 0; n < l.n; ++n){
            int index = entry_index(l, b, n*l.w*l.h, 0);
            activate_array(l.output + index, 2*l.w*l.h, LOGISTIC);
            index = entry_index(l, b, n*l.w*l.h, 4);
            activate_array(l.output + index, (1+l.classes)*l.w*l.h, LOGISTIC);
        }
    }
#endif

    memset(l.delta, 0, l.outputs * l.batch * sizeof(float));            // 梯度清零
    if(!net.train) return;                
    float avg_iou = 0;            // 平均IOU
    float recall = 0;            // 召回
    float recall75 = 0;            // IOU大于.75的召回
    float avg_cat = 0;            // 平均类别辨识率
    float avg_obj = 0;
    float avg_anyobj = 0;
    int count = 0;                // 检测到的target数
    int class_count = 0;
    *(l.cost) = 0;                // 损失
    for (b = 0; b < l.batch; ++b) {
        for (j = 0; j < l.h; ++j) {
            for (i = 0; i < l.w; ++i) {
                for (n = 0; n < l.n; ++n) {
                    int box_index = entry_index(l, b, n*l.w*l.h + j*l.w + i, 0);    
                    // 带入 entry_index, 由output tensor的存储格式可以知道这里是第n类anchor在(i,j)上对应box的首地址
                    box pred = get_yolo_box(l.output, l.biases, l.mask[n], box_index, i, j, l.w, l.h, net.w, net.h, l.w*l.h);
                    // 在（i，j）上预测的box的x和y相对于l.w和l.h的值及w和h相对于原图w和h的值
                    float best_iou = 0;
                    int best_t = 0;
                    for(t = 0; t < l.max_boxes; ++t){
                        box truth = float_to_box(net.truth + t*(4 + 1) + b*l.truths, 1);
                        // 从gt中提取一个真实目标框
                        if(!truth.x) break;
                        float iou = box_iou(pred, truth);    // 计算IOU
                        if (iou > best_iou) {
                            best_iou = iou;            // 找到与当前预测box的最大IOU
                            best_t = t;
                        }
                    }
                    int obj_index = entry_index(l, b, n*l.w*l.h + j*l.w + i, 4);
                    // 找到第n个anchor在（i,j）处的confidence的首地址
                    avg_anyobj += l.output[obj_index];    // 有目标的概率
                    l.delta[obj_index] = 0 - l.output[obj_index];    
                    if (best_iou > l.ignore_thresh) {
                        l.delta[obj_index] = 0;                // 预测框中有目标
                    }
                    if (best_iou > l.truth_thresh) {            // l.truth_thresh = 1
                        l.delta[obj_index] = 1 - l.output[obj_index];

                        int class = net.truth[best_t*(4 + 1) + b*l.truths + 4];
                        if (l.map) class = l.map[class];
                        int class_index = entry_index(l, b, n*l.w*l.h + j*l.w + i, 4 + 1);
                        delta_yolo_class(l.output, l.delta, class_index, class, l.classes, l.w*l.h, 0);
                        box truth = float_to_box(net.truth + best_t*(4 + 1) + b*l.truths, 1);
                        delta_yolo_box(truth, l.output, l.biases, l.mask[n], box_index, i, j, l.w, l.h, net.w, net.h, l.delta, (2-truth.w*truth.h), l.w*l.h);
                    }
                }
            }
        }
        for(t = 0; t < l.max_boxes; ++t){
            box truth = float_to_box(net.truth + t*(4 + 1) + b*l.truths, 1);
             // 把truth转成box类型，x，y，w，h，都是归一化后的真实值

            if(!truth.x) break;
            float best_iou = 0;
            int best_n = 0;
            i = (truth.x * l.w);            // 计算该truth所在的cell的i，j坐标
            j = (truth.y * l.h);
            box truth_shift = truth;
            truth_shift.x = truth_shift.y = 0;
            for(n = 0; n < l.total; ++n){        
                                            // 找出与该truth的IOU最大的是哪一种anchor
                box pred = {0};
                pred.w = l.biases[2*n]/net.w;
                pred.h = l.biases[2*n+1]/net.h;
                float iou = box_iou(pred, truth_shift);
                if (iou > best_iou){
                    best_iou = iou;
                    best_n = n;
                }
            }

            int mask_n = int_index(l.mask, best_n, l.n);    // 求对应于当前mask中anchor标号的下标，没有返回-1
            if(mask_n >= 0){                                // 如果不是当前层的mask数组中的，不执行
                int box_index = entry_index(l, b, mask_n*l.w*l.h + j*l.w + i, 0);    // 第mask_n个anchor的在i，j位置预测的box 
                float iou = delta_yolo_box(truth, l.output, l.biases, best_n, box_index, i, j, l.w, l.h, net.w, net.h, l.delta, (2-truth.w*truth.h), l.w*l.h);
                // 用第mask_n个anchor得到预测box，然后计算与该truth的IOU，得到IOU同时更新梯度数组：用真正需要平移的量和缩放量减去预测的box

                int obj_index = entry_index(l, b, mask_n*l.w*l.h + j*l.w + i, 4);
                avg_obj += l.output[obj_index];            // obj_index就是i，j位置是否有目标confidence的首地址
                l.delta[obj_index] = 1 - l.output[obj_index];

                int class = net.truth[t*(4 + 1) + b*l.truths + 4];    // target：x，y，w，h，class
                if (l.map) class = l.map[class];
                int class_index = entry_index(l, b, mask_n*l.w*l.h + j*l.w + i, 4 + 1);
                                                        // 第mask_n个anchor在i，j位置预测的class的首地址，4+1是坐标加confidence

                delta_yolo_class(l.output, l.delta, class_index, class, l.classes, l.w*l.h, &avg_cat);
                                                        // 更新预测class的梯度和avg_cat的值

                ++count;
                ++class_count;
                if(iou > .5) recall += 1;
                if(iou > .75) recall75 += 1;
                avg_iou += iou;
            }
        }
    }
    *(l.cost) = pow(mag_array(l.delta, l.outputs * l.batch), 2);        // MSE loss
    printf("Region %d Avg IOU: %f, Class: %f, Obj: %f, No Obj: %f, .5R: %f, .75R: %f,  count: %d\n", net.index, avg_iou/count, avg_cat/class_count, avg_obj/count, avg_anyobj/(l.w*l.h*l.n*l.batch), recall/count, recall75/count, count);
}

参考：

https://github.com/AlexeyAB/darknet

https://www.cnblogs.com/makefile/p/YOLOv3.html

http://www.cnblogs.com/YiXiaoZhou/p/7429481.html

https://www.cnblogs.com/zf-blog/p/7142463.html