YOLOV3 学习笔记 --- YOLOv3: An Incremental Improvement

YOLOv3: An Incremental Improvement

论文链接：https://pjreddie.com/media/files/papers/YOLOv3.pdf

Yolov3是yolo系列的巅峰之作，现广泛应用于工业目标检测中。
整体框架图如下：

                                                                     图1 yolo_v3结构图
Yolov3 相比v2有以下几个改进：

• Backbone的改变，yolov3提出一个新的backbone—darknet53，该backbone与yolov2的backbone—darknet19相比如下：
  
  
  没有全连接层和池化层，使用卷积步长stride=2的卷积操作做下采样，一共有5组block共23个shortcut。yolo_v2中对于前向过程中张量尺寸变换，都是通过最大池化来进行，一共有5次。而v3是通过卷积核增大步长来进行，也是5次。yolo_v3也和v2一样，backbone都会将输出特征图缩小到输入的1/32。

darknet53 对标的是resnet152，如下图。

• 多尺度预测，借鉴了FPN(feature pyramid networks)，采用多尺度来对不同size的目标进行检测，越精细的grid cell就可以检测出越精细的物体。
  由图1可看出，yolov3有3个detect header。每个单元格的输出维度是3 * （80 + 5），每个单元格设置3个anchor，每个anchor输出类别数（80种类别）和bbox坐标（x,y），宽高（w,h），置信度（confidence）。

• 损失函数的改变。分类损失由v2的softmax loss变成logistic loss损失binary cross-entropy loss（BCE），原因（1）是考虑到样本的多标签问题。Softmax使得每个框分配一个类别(score最大的一个)，而对于Open Images这种数据集,目标可能有重叠的类别标签,因此softmax不适用于多标签分类。（2）Softmax可被独立的多个logistic分类器替代，且准确率不会下降。

• anchor bbox prior不同。yolov2使用聚类得到每个单元格5个bbox，而v3一共有9个不同的anchor，每个detect header的单元格都设置为3个anchor。这样提高了IOU，和召回率。

现在有很多yolov3的改进，包括损失函数的改进，所以上述不是绝对的，是原版yolov3的loss。
这里看下keras-yolov3的损失函数code，如下：

def yolo_loss(args, anchors, num_classes, ignore_thresh=.5, print_loss=False):
    '''Return yolo_loss tensor

    Parameters
    ----------
    yolo_outputs: list of tensor, the output of yolo_body or tiny_yolo_body
    y_true: list of array, the output of preprocess_true_boxes
    anchors: array, shape=(N, 2), wh
    num_classes: integer
    ignore_thresh: float, the iou threshold whether to ignore object confidence loss

    Returns
    -------
    loss: tensor, shape=(1,)

    '''
    num_layers = len(anchors)//3 # default setting
    yolo_outputs = args[:num_layers]
    y_true = args[num_layers:]
    anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]]
    input_shape = K.cast(K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))
    grid_shapes = [K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0])) for l in range(num_layers)]
    loss = 0
    m = K.shape(yolo_outputs[0])[0] # batch size, tensor
    mf = K.cast(m, K.dtype(yolo_outputs[0]))

    for l in range(num_layers):
        object_mask = y_true[l][..., 4:5]
        true_class_probs = y_true[l][..., 5:]

        grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
             anchors[anchor_mask[l]], num_classes, input_shape, calc_loss=True)
        pred_box = K.concatenate([pred_xy, pred_wh])

        # Darknet raw box to calculate loss.
        raw_true_xy = y_true[l][..., :2]*grid_shapes[l][::-1] - grid
        raw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] * input_shape[::-1])
        raw_true_wh = K.switch(object_mask, raw_true_wh, K.zeros_like(raw_true_wh)) # avoid log(0)=-inf
        box_loss_scale = 2 - y_true[l][...,2:3]*y_true[l][...,3:4]

        # Find ignore mask, iterate over each of batch.
        ignore_mask = tf.TensorArray(K.dtype(y_true[0]), size=1, dynamic_size=True)
        object_mask_bool = K.cast(object_mask, 'bool')
        def loop_body(b, ignore_mask):
            true_box = tf.boolean_mask(y_true[l][b,...,0:4], object_mask_bool[b,...,0])
            iou = box_iou(pred_box[b], true_box)
            best_iou = K.max(iou, axis=-1)
            ignore_mask = ignore_mask.write(b, K.cast(best_iou<ignore_thresh, K.dtype(true_box)))
            return b+1, ignore_mask
        _, ignore_mask = K.control_flow_ops.while_loop(lambda b,*args: b<m, loop_body, [0, ignore_mask])
        ignore_mask = ignore_mask.stack()
        ignore_mask = K.expand_dims(ignore_mask, -1)

        # K.binary_crossentropy is helpful to avoid exp overflow.
        xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, raw_pred[...,0:2], from_logits=True)
        wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh-raw_pred[...,2:4])
        confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True)+ \
            (1-object_mask) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) * ignore_mask
        class_loss = object_mask * K.binary_crossentropy(true_class_probs, raw_pred[...,5:], from_logits=True)

        xy_loss = K.sum(xy_loss) / mf
        wh_loss = K.sum(wh_loss) / mf
        confidence_loss = K.sum(confidence_loss) / mf
        class_loss = K.sum(class_loss) / mf
        loss += xy_loss + wh_loss + confidence_loss + class_loss
        if print_loss:
            loss = tf.Print(loss, [loss, xy_loss, wh_loss, confidence_loss, class_loss, K.sum(ignore_mask)], message='loss: ')
    return loss

由code可以看出，yolov3一共有4种损失，类别损失（BCE），xy坐标损失（BCE），wh宽高损失（MSE），置信度损失（BCE）。

注意的是，这是kera-yolov3版本的损失函数，在其它版本的yolov3版本中，损失函数可能有稍微的不同。

参考：
https://blog.csdn.net/leviopku/article/details/82660381