经典目标检测YOLO系列(一)复现YOLOV1(2)反解边界框及后处理

经典目标检测YOLO系列(一)复现YOLOV1(2)反解边界框及后处理

在上个博客，我们提出了新的YOLOV1架构，这次我们解决前向推理过程中的两个问题。
经典目标检测YOLO系列(一)YOLOV1的复现(1)总体架构

1、边界框的计算

1.1 反解边界框公式的改变

1.1.1 原版YOLOV1的中心点量化误差的计算公式

如下图，目标狗的中心点所在网格为黄色部分，中心点为图中红点。

在原版的YOLOV1中，我们发现中心点【红点】距离黄色网格左上角处【坐标为(1, 4)】是有差距的，这其实就是由于降采样带来的量化误差，因此，我们只要获得了这个量化误差，就能获得中心点的准确坐标了。

YOLOv1原版中计算这个量化误差的过程如下：

在上图中计算出grid_x，grid_y的坐标，我们可以用矩阵进行表示，我们不妨称这个矩阵为G，矩阵的值如下

[
  [0., 0.],[1., 0.],[2., 0.],[3., 0.],[4., 0.],[5., 0.],[6., 0.],
  [0., 1.],[1., 1.],[2., 1.],[3., 1.],[4., 1.],[5., 1.],[6., 1.],
  [0., 2.],[1., 2.],[2., 2.],[3., 2.],[4., 2.],[5., 2.],[6., 2.],
  [0., 3.],[1., 3.],[2., 3.],[3., 3.],[4., 3.],[5., 3.],[6., 3.],
  [0., 4.],[1., 4.],[2., 4.],[3., 4.],[4., 4.],[5., 4.],[6., 4.],
  [0., 5.],[1., 5.],[2., 5.],[3., 5.],[4., 5.],[5., 5.],[6., 5.],
  [0., 6.],[1., 6.],[2., 6.],[3., 6.],[4., 6.],[5., 6.],[6., 6.]
]

计算出来的量化误差，其实就是中心点【红点】距离【黄色网格左上角点】的X轴和Y轴方向的偏移量。

1.1.2 原版YOLOV1反解边界框的公式

YOLOv1原版中根据预测值反解边界框的过程如下：
c e n t e r x = ( g r i d x + c x ) × s t r i d e c e n t e r y = ( g r i d y + c y ) × s t r i d e w = w p r e d × w i m a g e h = h p r e d × h i m a g e center_x = (grid_x + c_x)×stride \\ center_y = (grid_y + c_y)×stride \\ w = w_{pred} × w_{image} \\ h = h_{pred} × h_{image} centerx=(gridx+cx)×stridecentery=(gridy+cy)×stridew=wpred×wimageh=hpred×himage

1.1.3 改进YOLOV1

在原版的YOLOv1中，bbox预测主要包括目标中心点的偏移量 cx,cy 和归一化的边界框的宽高 w,h ，但是不论是哪个量，原版的YOLOv1均使用线性函数来输出，未加任何约束限制，很明显会有以下两点问题：

• 由于偏移量 cx,cy是介于01范围内的数，因此，其本身就是有上下界的，而线性输出并没有上下界，这就容易导致在学习的初期，网络可能预测的值非常大，导致bbox分支学习不稳定。

• 边界框的宽高显然是个非负数，而线性输出不能保证这一点，这也可能造成训练过程中的不稳定，一些输出一些不合理的数值（比如负数）。

因此对于这两个问题，我们进行改进：

• 第一个问题：假设模型的输出为 tx,ty ，我们使用sigmoid函数将其映射到0～1的范围内，保证网络的输出值是合理的，使得训练更加稳定。

• 第二个问题：采用log-exp方法来处理。

  • YOLOv1所要预测的不是归一化的边界框宽高，而是经过log函数压缩后的宽高。
  • 由于log函数的指数级的压缩特性，在一定程度上可以拉近大目标和小目标之间的尺寸量级，因此，对于平衡不同尺度的目标的检测问题还能起到一定的缓解作用。
  • 为了更好地学习这一标签，会将目标框的坐标先映射到网格的尺度上：ws=w/stride,hs=h/stride ，然后再做log处理

  t w = l o g ( w s ) t h = l o g ( h s ) t_w = log(w_s) \\ t_h = log(h_s) tw=log(ws)th=log(hs)

  • 在推理阶段，使用exp函数即可将预测恢复到正常的尺度上。
    w = e ( t w ) ∗ s t r i d e h = e ( t h ) ∗ s t r i d e w = e^{(t_w)}*stride \\ h = e^{(t_h)}*stride w=e(tw)∗strideh=e(th)∗stride

因此，改进后根据预测值反解边界框的公式如下：
c e n t e r x = ( g r i d x + c x ) × s t r i d e c e n t e r y = ( g r i d y + c y ) × s t r i d e w = e ( t w ) ∗ s t r i d e h = e ( t h ) ∗ s t r i d e center_x = (grid_x + c_x)×stride \\ center_y = (grid_y + c_y)×stride \\ w = e^{(t_w)}*stride \\ h = e^{(t_h)}*stride centerx=(gridx+cx)×stridecentery=(gridy+cy)×stridew=e(tw)∗strideh=e(th)∗stride

1.2 反解边界框代码实现

前向推理过程中，我们通过yoloV1网络得到置信度、分类以及回归的预测值。然后，对其进行一些调整，方便后续处理。

    # RT-ODLab/models/detectors/yolov1/yolov1.py  
    @torch.no_grad()
    def inference(self, x):
        # 测试阶段的前向推理代码

        # 主干网络
        feat = self.backbone(x)

        # 颈部网络
        feat = self.neck(feat)

        # 检测头
        cls_feat, reg_feat = self.head(feat)

        # 预测层
        obj_pred = self.obj_pred(cls_feat)
        cls_pred = self.cls_pred(cls_feat)
        reg_pred = self.reg_pred(reg_feat)
        fmp_size = obj_pred.shape[-2:]

        # 对 pred 的size做一些view调整，便于后续的处理
        # [B, C, H, W] -> [B, H, W, C] -> [B, H*W, C]
        obj_pred = obj_pred.permute(0, 2, 3, 1).contiguous().flatten(1, 2)
        cls_pred = cls_pred.permute(0, 2, 3, 1).contiguous().flatten(1, 2)
        reg_pred = reg_pred.permute(0, 2, 3, 1).contiguous().flatten(1, 2)

        # 测试时，笔者默认batch是1，
        # 因此，我们不需要用batch这个维度，用[0]将其取走。
        obj_pred = obj_pred[0]       # [H*W, 1]
        cls_pred = cls_pred[0]       # [H*W, NC]
        reg_pred = reg_pred[0]       # [H*W, 4]

        # 每个边界框的得分
        scores = torch.sqrt(obj_pred.sigmoid() * cls_pred.sigmoid())
        
        # 解算边界框, 并归一化边界框: [H*W, 4]
        bboxes = self.decode_boxes(reg_pred, fmp_size)
        
        ......

然后，我们通过回归参数，反解边界框。要想反解边界框，首先，我们需要一个由grid_x，grid_y组成的矩阵G。

    # RT-ODLab/models/detectors/yolov1/yolov1.py  
    def create_grid(self, fmp_size):
        """ 
            用于生成G矩阵，其中每个元素都是特征图上的像素坐标。
        """
        # 特征图的宽和高
        ws, hs = fmp_size

        # 生成网格的x坐标和y坐标
        grid_y, grid_x = torch.meshgrid([torch.arange(hs), torch.arange(ws)])

        # 将xy两部分的坐标拼起来：[H, W, 2]
        grid_xy = torch.stack([grid_x, grid_y], dim=-1).float()

        # [H, W, 2] -> [HW, 2] -> [HW, 2]
        grid_xy = grid_xy.view(-1, 2).to(self.device)
        
        return grid_xy

不了解torch.meshgrid()函数的可以参考：

np.meshgrid()和torch.meshgrid()函数解析

然后，我们按照改进后的公式，得到边界框中心坐标以及宽高，最后转换为(xmin,ymin,xmax,ymax)的格式。

    # RT-ODLab/models/detectors/yolov1/yolov1.py  
    def decode_boxes(self, pred, fmp_size):
        """
            将txtytwth转换为常用的x1y1x2y2形式。

            pred：回归预测参数
            fmp_size：特征图宽和高
        """
        # 生成网格坐标矩阵
        grid_cell = self.create_grid(fmp_size)

        # 计算预测边界框的中心点坐标和宽高
        pred_ctr = (torch.sigmoid(pred[..., :2]) + grid_cell) * self.stride
        pred_wh = torch.exp(pred[..., 2:]) * self.stride

        # 将所有bbox的中心带你坐标和宽高换算成x1y1x2y2形式
        pred_x1y1 = pred_ctr - pred_wh * 0.5
        pred_x2y2 = pred_ctr + pred_wh * 0.5
        pred_box = torch.cat([pred_x1y1, pred_x2y2], dim=-1)

        return pred_box

2、后处理

反解边界框后，我们会遇到两个问题：

• 一些边界框的score过低，我们需要剔除。
• 边界框有很多冗余，即多个box检测到了同一个物体，而我们对于每一个物体只需要一个框就够了。因此，我们有必要去剔除掉多余的结果（通过非极大值抑制nms）。

2.1 非极大值抑制

非极大值抑制的步骤：

1. 首先挑选出得分score最高的框；

2. 依次计算其他框与这个得分最高的框的 IoU ，超过给定 IoU 阈值的框舍掉。

3. 对每一类别都进行以上的操作，直到无框可剔除为止。

非极大值抑制的python实现:

def nms(bboxes, scores):
    # 1、将xmin,ymin,xmax,ymax拿出
    xmin = bboxes[:, 0]
    ymin = bboxes[:, 1]
    xmax = bboxes[:, 2]
    ymax = bboxes[:, 3]

    # 2、置信度从大到小的下标
    order = scores.argsort()[::-1]
    print(order)

    # 3、每个bbox的面积
    area = (ymax - ymin) * (xmax - xmin)
    print(area)
    keep = [] # 保存框的索引
    while order.size > 0:
        i = order[0]
        keep.append(i)

        # 4、求当前置信度最大的bbox与其他bbox的iou
        # 4.1 计算交集的坐上角的点 和  右下角的点
        x1 = np.maximum(xmin[i], xmin[order[1:]])
        y1 = np.maximum(ymin[i], ymin[order[1:]])
        x2 = np.minimum(xmax[i], xmax[order[1:]])
        y2 = np.minimum(ymax[i], ymax[order[1:]])

        # 4.2 计算交集的宽和高
        w = np.maximum(1e-10, x2 - x1)
        h = np.maximum(1e-10, y2 - y1)

        # 4.3 计算iou
        inter = w * h
        iou = inter / (area[i] + area[order[1:]]  - inter)
        print('iou = ', iou)

        # 滤除超过nms阈值的检测框
        nms_thresh = 0.4
        inds = np.where(iou <= nms_thresh)[0]
        print(inds + 1)
        order = order[inds + 1]
    return keep


if __name__ == '__main__':
    bboxes = np.asarray([
        [1, 1, 3, 3],
        [1, 1, 4, 4],
        [0, 0, 1.9, 1.9],
        [0, 0, 2, 2],
    ]) * 100
    scores = np.asarray([0.6, 0.7, 0.9, 0.1])
    keep = nms(bboxes, scores)
    print(keep)
    print(bboxes[[2, 1]])

[2, 1]
[[  0.   0. 190. 190.]
 [100. 100. 400. 400.]]

2.2 后处理代码实现

了解非极大值后，我们就可以进行后处理了。

    # RT-ODLab/models/detectors/yolov1/yolov1.py    
    
    def postprocess(self, bboxes, scores):
        """
        后处理代码，包括阈值筛选和非极大值抑制

        1、滤掉低得分（边界框的score低于给定的阈值）的预测边界框；
        2、滤掉那些针对同一目标的冗余检测。
        Input:
            bboxes: [HxW, 4]
            scores: [HxW, num_classes]
        Output:
            bboxes: [N, 4]
            score:  [N,]
            labels: [N,]
        """
        # 获取最大分数
        labels = np.argmax(scores, axis=1)
        scores = scores[(np.arange(scores.shape[0]), labels)]
        
        # threshold
        # 1、滤掉低得分（边界框的score低于给定的阈值）的预测边界框；
        keep = np.where(scores >= self.conf_thresh)
        bboxes = bboxes[keep]
        scores = scores[keep]
        labels = labels[keep]

        # nms
        # 2、滤掉那些针对同一目标的冗余检测。
        scores, labels, bboxes = multiclass_nms(
            scores, labels, bboxes, self.nms_thresh, self.num_classes, self.nms_class_agnostic)

        return bboxes, scores, labels

# RT-ODLab/utils/misc.py


# ---------------------------- NMS ----------------------------
## basic NMS
def nms(bboxes, scores, nms_thresh):
    """"Pure Python NMS."""
    x1 = bboxes[:, 0]  #xmin
    y1 = bboxes[:, 1]  #ymin
    x2 = bboxes[:, 2]  #xmax
    y2 = bboxes[:, 3]  #ymax

    areas = (x2 - x1) * (y2 - y1)
    order = scores.argsort()[::-1]

    keep = []
    while order.size > 0:
        i = order[0]
        keep.append(i)
        # compute iou
        xx1 = np.maximum(x1[i], x1[order[1:]])
        yy1 = np.maximum(y1[i], y1[order[1:]])
        xx2 = np.minimum(x2[i], x2[order[1:]])
        yy2 = np.minimum(y2[i], y2[order[1:]])

        w = np.maximum(1e-10, xx2 - xx1)
        h = np.maximum(1e-10, yy2 - yy1)
        inter = w * h

        iou = inter / (areas[i] + areas[order[1:]] - inter + 1e-14)
        #reserve all the boundingbox whose ovr less than thresh
        inds = np.where(iou <= nms_thresh)[0]
        order = order[inds + 1]

    return keep

## class-agnostic NMS
def multiclass_nms_class_agnostic(scores, labels, bboxes, nms_thresh):
    # nms
    # 在所有的检测结果上执行的，不会考虑类别的差异
    keep = nms(bboxes, scores, nms_thresh)
    scores = scores[keep]
    labels = labels[keep]
    bboxes = bboxes[keep]

    return scores, labels, bboxes

## class-aware NMS 
def multiclass_nms_class_aware(scores, labels, bboxes, nms_thresh, num_classes):
    # nms
    # 逐类别地去做NMS操作，不同类别之间的检测不会相互影响
    keep = np.zeros(len(bboxes), dtype=np.int32)
    for i in range(num_classes):
        inds = np.where(labels == i)[0]
        if len(inds) == 0:
            continue
        c_bboxes = bboxes[inds]
        c_scores = scores[inds]
        c_keep = nms(c_bboxes, c_scores, nms_thresh)
        keep[inds[c_keep]] = 1
    keep = np.where(keep > 0)
    scores = scores[keep]
    labels = labels[keep]
    bboxes = bboxes[keep]

    return scores, labels, bboxes

## multi-class NMS 
def multiclass_nms(scores, labels, bboxes, nms_thresh, num_classes, class_agnostic=False):
    if class_agnostic:
        return multiclass_nms_class_agnostic(scores, labels, bboxes, nms_thresh)
    else:
        return multiclass_nms_class_aware(scores, labels, bboxes, nms_thresh, num_classes)

如此，yolov1的推理过程就已经介绍完毕。

接下来，在训练过程中，我们需要改进损失函数，训练过程中，如何确定正负样本呢？