bounding box回归的原理学习——yoloV1

参考：
https://zhuanlan.zhihu.com/p/25236464
http://blog.csdn.net/williamyi96/article/details/77530948
http://blog.csdn.net/zijin0802034/article/details/77685438
https://leonardoaraujosantos.gitbooks.io/artificial-inteligence/content/object_localization_and_detection.html

一、逻辑理解

从逻辑上说明对bbox回归的原理的理解。
之前觉得bbox的回归是一个很难理解的地方：这些回归的坐标数字，依据在哪里？
其实回归的输入并不是这些预测的坐标数字，而是预测的坐标对应的feature map中的内容，这个内容与相对于ground truth进行对比，计算，是回归的根本依据。
通过不断的训练，得到了回归的参数，在预测时，网络产生了图像的feature map，对于任意一个预测框，背后对应了一个feature 区域，将学习到的参数与此feature区域进行运算，就会得到调整预测框的参数了。因为同类物体的特征应当相似。

二、yoloＶ1论文学习

(1) resizes the input image to 448 × 448,
(2) runs a single convolutional network on the image, and
(3) thresholds the resulting detections by the model’s confidence.

A single convolutional network simultaneously predicts multiple bounding boxes and class probabilities for those boxes.

对于输入的图片，resize到网络的输入所需要的大小，经过多重卷积处理，得到了7*7大小的feature map。里面的7x7的每个格子就是grid cell。
每个grid cell会负责预测B个bounding box（问题：怎么预测出来的？），以及对于每个类的条件概率。每个bounding box的预测内容包括有：box的信息：x,y,w,h，以及本bounding box包含有某类物体的置信度。含义如下：
—-x,y是相对于grid cell的左上角来说的box的中心位置，w,h是box的宽高，相对于整张图片的款高。
—-confidence的含义：如果这个box包含了任何一种物体，则定义为该box与ground truth中的任何一个box的iou的大小，如果该box不包含任何一个物体，则confidence为0。
—-每个grid cell还会预测C个不同类别的条件概率。即如果这个grid cell是包含有物体的，那么对于可能包含的不同物体的概率情况。
假设每个grid cell会预测2个box，需要检测的物体有20类，那么最后生成的向量size是7x7x(5*2+20)=1470。

loss function如下：

训练过程中的回归是如何进行的呢？
基本的逻辑就是对坐标+iou误差、分类误差进行修正。
在训练的时候，每个样本的ground truth的box是知道的，对应于相当于下采样后的的feature map，也能找到在feature map中对应的格子的位置。如果一个grid cell是该物体的中心位置，则这个grid cell负责预测这个物体;每个grid cell都预测了若干个box，其中会有一个box具有与ground truth的某个box有最大的iou，则由这个box负责调整box的位置（另外的预测的box就忽略了）。
可以想象，一开始的时候，权重是随机的，面对抽象出来的图像的feature信息，其预测的box的信息、confidence的信息、物体类别的条件概率都是随机的，经过了loss函数进行惩罚与优化，使得预测行为越来越好。取极端情况为例子加深理解：总是用同一张图片做训练，每次得到的图像的feature map都是一样的。一开始的时候，权重随机，权重与某个grid cell的运算的结果是随机，即每个grid cell对应的5*b+C的数据是随机的。网络对此情况进行优化，指导权重向某个方向优化。第二次看到还是一样的feature map，新的权重与某个grid cell对应的数据进行计算，就会得到更好的box位置和confidence，物体类别的信息。如此反复进行，直到权重参数调整到这样的情况，面对同样的grid cell，其计算出来的box的信息完全与ground box的位置符合，confidence=1，正确类别的条件概率为1。

问题：
可以看到修正box的时候，是针对训练的时候，权重与训练图片中的feature map的相应部分进行运算来进行调整的，即：如果在实际应用中，有一个物体，其与训练的图片中的物体很像，那么可以进行好的预测，如果是以一个没有见过的角度去看，那么由于训练时没有对这个角度的feature进行计算与优化，就不会预测好，跟遇到一个类别之外的物体没差别。所以，增加训练的样本的多角度很有必要。
同时一个grid cell虽然预测若干个box，但只会由那个与ground truth的任何box有最大交集的预测box来负责预测这个grid cell的情况，那么对于比较密集挨在一起物体的情况就会不能预测的现象出现：两只鸟靠的很近，它们的两个ground truth的box，都与某个grid cell有最大的iou，与其他的grid cell都没有相交，但因为这里有两只鸟，所以，这个gridcell预测的若干个box中，总会与两只鸟分别对应的两个ground truth的box的其中一个有更大的iou值，就会选到这个预测box，负责预测其中的一只鸟，对于另一只鸟，就会忽略。而由于鸟比较小，与其他的grid cell也没有相交，所以这另外的鸟就给忽略掉了，检测就会检测不出来。

yolov1源码学习

分析detection_layer.c

void forward_detection_layer(const detection_layer l, network net)
{
    int locations = l.side*l.side;//7x7,side 是detection 层的参数
    int i,j;
    memcpy(l.output, net.input, l.outputs*l.batch*sizeof(float));
    //if(l.reorg) reorg(l.output, l.w*l.h, size*l.n, l.batch, 1);
    int b;
    if (l.softmax){
        for(b = 0; b < l.batch; ++b){
            int index = b*l.inputs;
            for (i = 0; i < locations; ++i) {
                int offset = i*l.classes;
                softmax(l.output + index + offset, l.classes, 1, 1,
                        l.output + index + offset);
            }
        }
    }
    //l.output的组织方式是：
    //分成3块：第一块统一放置classes的信息，第二块统一放置每个box的confidence信息，
    //第三块统一放置box的坐标信息
    if(net.train){
        float avg_iou = 0;
        float avg_cat = 0;
        float avg_allcat = 0;
        float avg_obj = 0;
        float avg_anyobj = 0;
        int count = 0;
        *(l.cost) = 0;
        int size = l.inputs * l.batch;
        memset(l.delta, 0, size * sizeof(float));
        //一次训练同时处理batch张图片
        for (b = 0; b < l.batch; ++b){
            //某一张图片的开始,上面的make_detection_layer方法的assert方法
            //验证了inputs的情况
            int index = b*l.inputs;
            //每张图片到最后的feature map大小是locations=S*S,如（7×7个）
            for (i = 0; i < locations; ++i) {
                //每个grid cell对应的truth的信息：1个confidence，4个坐标信息，相应的类别信息
                int truth_index = (b*locations + i)*(1+l.coords+l.classes);
                int is_obj = net.truth[truth_index];
                for (j = 0; j < l.n; ++j) {
                    //预测的每个box中的confidence信息。参考l.output的组织方式
                    int p_index = index + locations*l.classes + i*l.n + j;
                    //先默认为该grid cell是no obj的
                    l.delta[p_index] = l.noobject_scale*(0 - l.output[p_index]);
                    *(l.cost) += l.noobject_scale*pow(l.output[p_index], 2);
                    avg_anyobj += l.output[p_index];
                }

                int best_index = -1;
                float best_iou = 0;
                float best_rmse = 20;

                if (!is_obj){
                    //该grid cell没有物体，直接返回
                    //其cost就是那个noobject相应的计算结果
                    continue;
                }

                //第i个grid cell的classes预测信息的开始位置,classes的信息统一排在前面
                int class_index = index + i*l.classes;
                //论文中lossfunction的最后一项：
                //计算该grid cell预测出来的每个class的概率信息与真实信息（对应的类别是1,其余为0.可以看ground truth信息组织的代码）的差值
                for(j = 0; j < l.classes; ++j) {
                    l.delta[class_index+j] = l.class_scale * (net.truth[truth_index+1+j] - l.output[class_index+j]);
                    *(l.cost) += l.class_scale * pow(net.truth[truth_index+1+j] - l.output[class_index+j], 2);
                    if(net.truth[truth_index + 1 + j]) avg_cat += l.output[class_index+j];
                    avg_allcat += l.output[class_index+j];
                }

                //box的信息排在confidence，classes信息后面
                box truth = float_to_box(net.truth + truth_index + 1 + l.classes, 1);
                truth.x /= l.side;
                truth.y /= l.side;

                //判断哪个pred box与ground truth中的任何一个box
                //的iou最大，则由该预测box负责对本grid cell
                //进行预测
                for(j = 0; j < l.n; ++j){
                    //参考l.output的组织方式
                    //跳过前面的classes和每个box的confidence的数据，到达box的坐标数据位置
                    int box_index = index + locations*(l.classes + l.n) + (i*l.n + j) * l.coords;
                    box out = float_to_box(l.output + box_index, 1);
                    //归一化
                    out.x /= l.side;
                    out.y /= l.side;

                    if (l.sqrt){
                        //表示里面的预测值w,h是经过sqrt操作的，
                        out.w = out.w*out.w;
                        out.h = out.h*out.h;
                    }

                    float iou  = box_iou(out, truth);
                    //iou = 0;
                    float rmse = box_rmse(out, truth);
                    if(best_iou > 0 || iou > 0){
                        if(iou > best_iou){
                            best_iou = iou;
                            best_index = j;
                        }
                    }else{
                        if(rmse < best_rmse){
                            best_rmse = rmse;
                            best_index = j;
                        }
                    }
                }

                if(l.forced){
                    if(truth.w*truth.h < .1){
                        best_index = 1;
                    }else{
                        best_index = 0;
                    }
                }
                if(l.random && *(net.seen) < 64000){
                    best_index = rand()%l.n;
                }

                //得到最佳box
                int box_index = index + locations*(l.classes + l.n) + (i*l.n + best_index) * l.coords;
                int tbox_index = truth_index + 1 + l.classes;

                box out = float_to_box(l.output + box_index, 1);
                out.x /= l.side;
                out.y /= l.side;
                if (l.sqrt) {
                    out.w = out.w*out.w;
                    out.h = out.h*out.h;
                }
                float iou  = box_iou(out, truth);

                //printf("%d,", best_index);
                int p_index = index + locations*l.classes + i*l.n + best_index;
                //上面加了默认的无物体的情况
                *(l.cost) -= l.noobject_scale * pow(l.output[p_index], 2);
                *(l.cost) += l.object_scale * pow(1-l.output[p_index], 2);
                //这个avg_obj没看到减去之前默认加的值
                avg_obj += l.output[p_index];
                //预测的每个box的confidence的值代表的是
                //有多肯定这个box包含了一个物体,按论文的定义是
                //期望的等于预测的box与ground truth box的iou.
                //那么走l.rescore的分支是比较合理的。
                l.delta[p_index] = l.object_scale * (1.-l.output[p_index]);

                if(l.rescore){
                    l.delta[p_index] = l.object_scale * (iou - l.output[p_index]);
                }

                l.delta[box_index+0] = l.coord_scale*(net.truth[tbox_index + 0] - l.output[box_index + 0]);
                l.delta[box_index+1] = l.coord_scale*(net.truth[tbox_index + 1] - l.output[box_index + 1]);
                l.delta[box_index+2] = l.coord_scale*(net.truth[tbox_index + 2] - l.output[box_index + 2]);
                l.delta[box_index+3] = l.coord_scale*(net.truth[tbox_index + 3] - l.output[box_index + 3]);
                if(l.sqrt){
                    l.delta[box_index+2] = l.coord_scale*(sqrt(net.truth[tbox_index + 2]) - l.output[box_index + 2]);
                    l.delta[box_index+3] = l.coord_scale*(sqrt(net.truth[tbox_index + 3]) - l.output[box_index + 3]);
                }

                *(l.cost) += pow(1-iou, 2);
                avg_iou += iou;
                ++count;
            }
        }

        if(0){
            float *costs = calloc(l.batch*locations*l.n, sizeof(float));
            for (b = 0; b < l.batch; ++b) {
                int index = b*l.inputs;
                for (i = 0; i < locations; ++i) {
                    for (j = 0; j < l.n; ++j) {
                        int p_index = index + locations*l.classes + i*l.n + j;
                        costs[b*locations*l.n + i*l.n + j] = l.delta[p_index]*l.delta[p_index];
                    }
                }
            }
            int indexes[100];
            top_k(costs, l.batch*locations*l.n, 100, indexes);
            float cutoff = costs[indexes[99]];
            for (b = 0; b < l.batch; ++b) {
                int index = b*l.inputs;
                for (i = 0; i < locations; ++i) {
                    for (j = 0; j < l.n; ++j) {
                        int p_index = index + locations*l.classes + i*l.n + j;
                        if (l.delta[p_index]*l.delta[p_index] < cutoff) l.delta[p_index] = 0;
                    }
                }
            }
            free(costs);
        }


        *(l.cost) = pow(mag_array(l.delta, l.outputs * l.batch), 2);


        printf("Detection Avg IOU: %f, Pos Cat: %f, All Cat: %f, Pos Obj: %f, Any Obj: %f, count: %d\n", avg_iou/count, avg_cat/count, avg_allcat/(count*l.classes), avg_obj/count, avg_anyobj/(l.batch*locations*l.n), count);
        //if(l.reorg) reorg(l.delta, l.w*l.h, size*l.n, l.batch, 0);
    }
}

这里需要对l.output的数据组织方式进行了解，否则阅读其取各种值的代码会无法理解。l.output是包含一批图片的输出结果，每一张的输出紧跟着前一张的输出的后面，对于一张图片的输出数据其组织方式如下：
1、第一部分是每个grid cell预测的指定class的条件概率：
一个grid cell如果预测20个class，则排列方式就是第一个grid cell预测的class_0,class_1..class_19的条件概率值，紧接着是第二个grid cell的预测值，直到所有的grid cell的对于各类别的条件概率值都排列完毕；
2、第二部分是每个grid cell预测的每个box的confidence的值：
同样，如果一个grid cell预测2个box，则就是confidence_box_0,confidence_box_1….
3、第三部分就是预测的各个box的坐标信息了：
按照x,y,w,h的方式排列。

整体的检测流程步骤很清晰：
1、循环处理一批中的每一张图片，对于每一张图片，进行以下处理：
2、先默认当做该grid cell 不包含物体，计算loss情况：lossfunction中的第4项；
3、取出对应的grid cell的truth box的数据
4、计算条件概率的loss情况，该数据只与grid cell有关，与预测的box无关，就是lossfunction中的最后一项
5、找出该grid cell预测的最好的那个box，叫做best_box
6、利用best_box计算box坐标的loss情况：loss function中的前两项，以及confidence的loss情况：loss function中的第3项；

如果某个grid cell不包含任何物体，其loss部分只有一个noobj的；否则会包含其他部分。

对着源码与论文，基本理解了其计算思路，但是对于里面如何进行优化的过程，还不是很清楚，主要是对于反向传播的代码级别的理解不够。