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在概念及結構上相差無幾。