object detection[YOLOv2]

接着扯YOLO v2
相比较于YOLO v1，作者在之前模型上，先修修补补了一番，提出了YOLO v2模型。并基于imagenet的分类数据集和coco的对象检测数据集，提出了wordnet模型，并成功的提出了YOLO9000模型。这里暂时只讲YOLO v2.
作者说yolo v1相比较其他基于区域的模型比如faster r-cnn还是有些不足的，比如更多定位错误，更低召回率，所以第二个版本开始主要解决这两个问题。

0 - 作者对yolo v1的补丁

1 - 在所有卷积层上用BN，并扔掉dropout
2 - yolo 的训练过程（两个版本都是）为：分类模型的预训练和检测模型的微调。作者觉得yolo v1的预训练不够好，所以这里直接拿imagenet的分辨率为\(448*448\)的图片微调10个epoch，然后在将前面的卷积层留待检测模型用。
3 - 使用anchor box（而这几个anchor box是基于训练集数据的标签中\(w,h\)聚类出来的），加快模型收敛
4 - 去掉全连接层，扔掉最后一层池化层，并且将网络的输入端resize为\(416*416\)，从而输出的是一个\(13*13*channel\)的卷积层
5 - 在预测\(x,y,w,h\)的时候是基于anchor box,且与RPN略有不同的方法去预测。
6 - 加了一个passthrough层

1 - 基础网络

为了结合Googlenet和VGG的优势，作者提出了图1这样一种网络结构，将其作为yolo分类模型的基础模型。

图1.darknet-19
上图就是darknet-19，作者先在imagenet上以\(224*224\)先初始化训练，然后用\(448*448\)的分辨率图片跑10个epoch。跑完之后，丢弃最后的卷积层和全局池化层，换上3个\(3*3*1024\)的卷积层，然后跟一层1*1的卷积层，最后输出\(13*13*125\),如下图所示

图2.yolov2网络结构图
上图是通过官网darknet命令生成的网络结构，从中可以发现有几点疑惑，比如论文中的passthrough到底是什么操作？

图2中layer0-layer22层就是darknet-19的前面部分，，具体对照如下图：

图3.darknet19到yolov2结构的示意图

2 - 训练

yolov2模型的训练基本就分下面三步：
i）首先拿darknet19在imagenet上以分辨率\(224*224\)跑160回，然后以分辨率\(448*448\)跑10回;
ii）然后如上面所示，将darknet19网络变成yolov2网络结构，并resize输入为\(416*416\)
iii）对增加的层随机初始化，并接着在对象检测数据集上训练160回，且在【60，90】的时候降低学习率
而第三步中，因为v2的目标函数和增加的anchor box，而与v1在概念上有所不同。

3 - v2中较难理解的补丁

如图2所示，最后会输出一个\(13*13*125\)的张量,其中的\(13*13\)如yolo v1一样，是表示网格划分的意思，后面的125就是当前网格的操作所在。之前yolov1时，作者拿了B=2，而这里B=5，且这里的5个预测候选框是事先得到的（下面待续），也就是给定了5个框的\(w,h\)，预测得到的是\(5(4+1+20)\)，分别为\(x,y,w,h\);\(confidence\);\(class\)。
没错，在yolo1的时候是出现2个候选框，然后只有一条20维度表示类别，这里是每个anchor box都会有预测类别，所以相对的目标函数会略有改动，作者说了在v2还是预测\(IOU_{truth}{pred}\)和基于当前有对象基础上预测类别\(P(class|object)\)。

3.1 anchor box的生成

如论文中所说，相对其他rpn网络，yolo v2的事先准备的几个预测候选框（也叫做anchor box）大小是基于训练集算出来的。如作者代码
中：

[region]
anchors = 1.08,1.19,  3.42,4.41,  6.63,11.38,  9.42,5.11,  16.62,10.52
bias_match=1
classes=20
coords=4
num=5

上述代码中anchors保存的就是各自的width和height，也就是论文中的符号\(p_w,p_h\)。
原理就是基于所有训练集的标签中，先计算得出所有的width和对应的height，将其作为样本，采用kmean的方法，只不过距离函数换成了\(d(box,center)=1-IOU(box,center)\)
这里需要5个anchor，那么就会得到5个不同样本中心，记得乘以（32/416）；假设锚点值为x，则\(\frac{x}{centerids}=\frac{32}{416}\)
如5个样本中心：

[[ 103.84071465   29.09785553]
 [  40.14028782   21.66632026]
 [ 224.79420059  102.18148749]
 [  61.79184575   39.21399017]
 [ 126.37797981   60.03186796]]

对应的锚点：

 7.98774728074, 2.23829657922,      3.08771444772, 1.66664002,     17.2918615841, 7.86011442226,     4.75321890422, 3.01646078194,     9.72138306269, 4.61783599681

3.2 坐标预测

作者先引用了下faster r-cnn的rpn网络，然后罗列的2个式子\(x = (t_x*w_a) +x_a\);\(y = (t_y*h_a) +y_a\),并说直接Anchor Box回归导致模型不稳定，该公式没有任何约束，中心点可能会出现在图像任何位置，这就有可能导致回归过程震荡，甚至无法收敛，然后作者基于此稍微改进了下：
$b_x = \sigma(t_x) + c_x \( \)b_y = \sigma(t_y) + c_y\( \)b_w = p_we^{t_w}\( \)b_h = p_he^{t_h}\( 其中\)t_w=log(\frac{w}{w_p})\(;\)t_h=log(\frac{h}{h_p})\( 如下图：  图4.论文中图3 如上图所示，模型预测输出的坐标系中四个值分别为\)t_x,t_y,t_w,t_h\(： （1）通过计算当前网格本身的偏移量，加上在当前网格内部所在的比例，即为第0层输入层图片上预测框的中心坐标； （2）而预测的\)t_w,t_h\(是相对当前候选框的一个缩放比例，通过公式\)t_w=log(\frac{w}{w_p})\(;\)t_h=log(\frac{h}{h_p})\(反推回去，即为\)b_w = p_we^{t_w}\(；\)b_h = p_he^{t_h}$

3.3 passthrough操作

通过github找到star最多的yolo 2-pytorch，研读了部分代码，找到如下部分：

#darknet.py
        self.reorg = ReorgLayer(stride=2)   # stride*stride times the channels of conv1s

#reorg_layer.py
    def forward(self, x): 
        stride = self.stride

        bsize, c, h, w = x.size()
        out_w, out_h, out_c = int(w / stride), int(h / stride), c * (stride * stride)
        out = torch.FloatTensor(bsize, out_c, out_h, out_w)

        if x.is_cuda:
            out = out.cuda()
            reorg_layer.reorg_cuda(x, out_w, out_h, out_c, bsize, stride, 0, out)
        else:
            reorg_layer.reorg_cpu(x, out_w, out_h, out_c, bsize, stride, 0, out)

        return out 

//reorg_cpu.c
int reorg_cpu(THFloatTensor *x_tensor, int w, int h, int c, int batch, int stride, int forward, THFloatTensor *out_tensor)
{
    // Grab the tensor
    float * x = THFloatTensor_data(x_tensor);
    float * out = THFloatTensor_data(out_tensor);

    // https://github.com/pjreddie/darknet/blob/master/src/blas.c
    int b,i,j,k;
    int out_c = c/(stride*stride);

    for(b = 0; b < batch; ++b){
        //batch_size
        for(k = 0; k < c; ++k){
           //channel
            for(j = 0; j < h; ++j){
                //height
                for(i = 0; i < w; ++i){
                    //width
                    int in_index  = i + w*(j + h*(k + c*b));
                    int c2 = k % out_c;
                    int offset = k / out_c;
                    int w2 = i*stride + offset % stride;
                    int h2 = j*stride + offset / stride;
                    int out_index = w2 + w*stride*(h2 + h*stride*(c2 + out_c*b));
                    if(forward) out[out_index] = x[in_index];
                    else out[in_index] = x[out_index];
                }
            }
        }
    }

    return 1;
}

从上述c代码可以看出，这里ReorgLayer层就是将\(26*26*512\)的张量中\(26*26\)切割成4个\(13*13\)然后连接起来，使得原来的512通道变成了2048。

3.4 目标函数计算

同样通过github上现有的最多stars的那份代码，找到对应的损失计算部分

#darknet.py
    def loss(self):
        #可以看出，损失值也是基于预测框bbox，预测的iou，分类三个不同的误差和
        return self.bbox_loss + self.iou_loss + self.cls_loss

    def forward(self, im_data, gt_boxes=None, gt_classes=None, dontcare=None):
        conv1s = self.conv1s(im_data)
        conv2 = self.conv2(conv1s)
        conv3 = self.conv3(conv2)
        conv1s_reorg = self.reorg(conv1s)
        cat_1_3 = torch.cat([conv1s_reorg, conv3], 1)
        conv4 = self.conv4(cat_1_3)
        conv5 = self.conv5(conv4)   # batch_size, out_channels, h, w
        ……
        ……
        # tx, ty, tw, th, to -> sig(tx), sig(ty), exp(tw), exp(th), sig(to)
        '''预测tx ty'''
        xy_pred = F.sigmoid(conv5_reshaped[:, :, :, 0:2])
        '''预测tw th '''
        wh_pred = torch.exp(conv5_reshaped[:, :, :, 2:4])
        bbox_pred = torch.cat([xy_pred, wh_pred], 3)
        '''预测置信度to '''
        iou_pred = F.sigmoid(conv5_reshaped[:, :, :, 4:5])
        '''预测分类class  '''
        score_pred = conv5_reshaped[:, :, :, 5:].contiguous()
        prob_pred = F.softmax(score_pred.view(-1, score_pred.size()[-1])).view_as(score_pred)

        # for training
        if self.training:
            bbox_pred_np = bbox_pred.data.cpu().numpy()
            iou_pred_np = iou_pred.data.cpu().numpy()
            _boxes, _ious, _classes, _box_mask, _iou_mask, _class_mask = self._build_target(
                                         bbox_pred_np, gt_boxes, gt_classes, dontcare, iou_pred_np)
            _boxes = net_utils.np_to_variable(_boxes)
            _ious = net_utils.np_to_variable(_ious)
            _classes = net_utils.np_to_variable(_classes)
            box_mask = net_utils.np_to_variable(_box_mask, dtype=torch.FloatTensor)
            iou_mask = net_utils.np_to_variable(_iou_mask, dtype=torch.FloatTensor)
            class_mask = net_utils.np_to_variable(_class_mask, dtype=torch.FloatTensor)

            num_boxes = sum((len(boxes) for boxes in gt_boxes))

            # _boxes[:, :, :, 2:4] = torch.log(_boxes[:, :, :, 2:4])
            box_mask = box_mask.expand_as(_boxes)
            #计算预测的平均bbox损失值
            self.bbox_loss = nn.MSELoss(size_average=False)(bbox_pred * box_mask, _boxes * box_mask) / num_boxes
           #计算预测的平均iou损失值
            self.iou_loss = nn.MSELoss(size_average=False)(iou_pred * iou_mask, _ious * iou_mask) / num_boxes
           #计算预测的平均分类损失值
            class_mask = class_mask.expand_as(prob_pred)
            self.cls_loss = nn.MSELoss(size_average=False)(prob_pred * class_mask, _classes * class_mask) / num_boxes

        return bbox_pred, iou_pred, prob_pred

可以从上述代码窥见一斑，yolo v2的目标函数和yolo v1在概念及结构上相差无几。