前言

针对目标检测框Box(x1,y1,x2,y2)的回归学习中,网络损失函数从最早的IoU到GIoU,再到DIoU、CIoU和EIoU,现在出现了SIoU。那么他们都是什么呢?又由哪些优点?

正文

IOU就是交并比,预测框和真实框相交区域面积和合并区域面积的比值,计算公式如下:
优点:1、能够很好的反映重合度;2、具有尺度不变形
缺点:不相交时,值为0,无法反映中心距离

GIoU克服了两个框不相交时IoU恒为0,损失恒为1,没法优化的问题。

infonce损失代码pytorch_目标检测


GIoU引入了一个最小闭包区的概念,即能将预测框和真实框包裹住的最小矩形框,其中,Ac为最小闭包区,u为预测框和真实框的并集,那么GIoU第二项的分子就是上图中白色区域,白色区域与最小闭包区的比值越高,loss越高。

GIoU具有以下特点:

  1. GIoU对scale不敏感
  2. GIoU是IoU的下界,取值为[-1, 1]
  3. GIoU除了关注重叠区域不同,还关注了非重叠区域,能够更好的反应重合度

DIoU paper:https://arxiv.org/pdf/1911.08287.pdf 提出DIOU和CIOU 如下图所示,当出现该场景时,计算各种基于IOU的损失函数值,infonce损失代码pytorch_目标检测_02能够描述检测框与gt框的位置信息。从图中我们可以看到,当处于第三幅图时,检测框和gt都位于中心,IoU=GIoU=DIoU。但位置出现差异,如第一幅图和第二幅图时,明显第二幅图的效果要好一些,此时GIOU降级成为IOU,而DIOU的损失值较大,能够较好的描述当前位置信息。

infonce损失代码pytorch_目标检测_03


基于此场景,作者提出了DIoU。并提出了2个问题,第一:最小化两个边界框中心点的归一化距离能否加快收敛?第二:如何在回归时,能够更好的描述重叠信息,同时使得回归更准确,更快速?

infonce损失代码pytorch_infonce损失代码pytorch_04


infonce损失代码pytorch_深度学习_05infonce损失代码pytorch_ci_06分别代表预测框和gt框的中心点,infonce损失代码pytorch_目标检测_07代表欧氏距离,c代表最小闭包区的对角线距离。

DIoU具有以下特点:

  1. 对scale不敏感
  2. 与GIoU 类似,与目标框不重叠时,仍然可以为边界框提供移动方向。
  3. DIoU可以直接最小化两个目标框的距离,而GIoU 优化的是两个目标框之间的面积。因此,比GIoU loss收敛快得多。
  4. 对于包含两个框在水平方向和垂直方向上这种情况,DIoU损失可以使回归非常快,而GIoU损失几乎退化为IoU损失

CIoU
DIoU解决了上文提到的第一个问题,归一化两个中心点的距离从而加速收敛的问题,但是还未解决第二个问题,即如何在回归时能够更好的描述重叠信息。
paper指出,预测的bbox的三个重要的因素分别是,重叠面积、中心点距离和纵横比(长宽比)。infonce损失代码pytorch_目标检测_08考虑了重叠区域,而GIoU很大程度上依赖了IOU损失,DIoU则同时考虑了重叠区域和中心点距离,更进一步的,边界框的长宽比的一致性也是一个重要的几何因素。因此,基于DIoU,作者通过施加长宽比的一致性来提出了infonce损失代码pytorch_深度学习_09

infonce损失代码pytorch_目标检测_10

EIoU
作者认为CIoU loss有以下两个缺点:

  • 如果预测框和gt框的长宽比是相同的,那么长宽比的惩罚项恒为0,不合理
  • 观察CIoU中w, h相对于v的梯度,发现这两个梯度是一对相反数,也就是说,w和h不能同时增大或减小,这显然也不够合理的。

针对上述问题,作者对于长宽比的惩罚项进行了替换,形成了EIoU,如下式:

infonce损失代码pytorch_infonce损失代码pytorch_11


其中,infonce损失代码pytorch_ci_12infonce损失代码pytorch_目标检测_13是最小闭包的w和h。

SIoU

paper:https://arxiv.org/ftp/arxiv/papers/2205/2205.12740.pdf 作者认为以前的IoU损失都没有考虑角度问题,但框的角度确实可以影响回归,因此提出SIoU loss,其中SIoU使用4组cost组成见下:

  • 角度损失
  • 距离损失
  • 形状损失
  • IoU损失

Angle cost

infonce损失代码pytorch_深度学习_14


infonce损失代码pytorch_ci_15


Distance cost

infonce损失代码pytorch_ci_16


可以看出,当infonce损失代码pytorch_目标检测_17 infonce损失代码pytorch_infonce损失代码pytorch_18 0时,Distance cost的贡献大大降低。相反,infonce损失代码pytorch_目标检测_17越接近infonce损失代码pytorch_infonce损失代码pytorch_20/4,Distance cost贡献越大。随着角度的增大,问题变得越来越难。因此,infonce损失代码pytorch_计算机视觉_21被赋予时间优先的距离值,随着角度的增加。

Shape cost

infonce损失代码pytorch_infonce损失代码pytorch_22

infonce损失代码pytorch_目标检测_23

IoU cost

infonce损失代码pytorch_ci_24


整体infonce损失代码pytorch_深度学习_25计算如下:

infonce损失代码pytorch_深度学习_26


各类IoU损失计算代码如下:

import torch
import math


def iou_loss(pred, target, eps=1e-7, reduction='mean', loss_type='iou'):
    """

    :param pred: [[x1, y1, x2, y2], [x1, y1, x2, y2], ...]
    :param target: [[x1, y1, x2, y2], [x1, y1, x2, y2], ...]
    :param eps:
    :param reduction: "mean" or "sum"
    :param loss_type: "iou", "giou", "diou", "ciou", "eiou" or "siou"
    :return:
    """

    inter_x1 = torch.max(pred[:, 0], target[:, 0])
    inter_y1 = torch.max(pred[:, 1], target[:, 1])
    inter_x2 = torch.min(pred[:, 2], target[:, 2])
    inter_y2 = torch.min(pred[:, 3], target[:, 3])

    outer_x1 = torch.min(pred[:, 0], target[:, 0])
    outer_y1 = torch.min(pred[:, 1], target[:, 1])
    outer_x2 = torch.max(pred[:, 2], target[:, 2])
    outer_y2 = torch.max(pred[:, 3], target[:, 3])

    inter_w = (inter_x2 - inter_x1 + 1.0).clamp(0.)
    inter_h = (inter_y2 - inter_y1 + 1.0).clamp(0.)
    inters = inter_w * inter_h

    pred_w = pred[:, 2] - pred[:, 0] + 1.0
    pred_h = pred[:, 3] - pred[:, 1] + 1.0
    tag_w = target[:, 2] - target[:, 0] + 1.0
    tag_h = target[:, 3] - target[:, 1] + 1.0
    uni = pred_h * pred_w + tag_w * tag_h - inters

    outer_w = (outer_x2 - outer_x1).clamp(min=0.)
    outer_h = (outer_y2 - outer_y1).clamp(min=0.)

    ious = (inters / uni).clamp(min=eps)

    if loss_type == 'iou':
        loss = -ious.log()  # -torch.log(ious)
    elif loss_type == 'giou':
        enclose = outer_w * outer_h + eps
        gious = ious - (enclose - uni) / enclose
        loss = 1 - gious
    elif loss_type == 'diou' or loss_type == 'ciou' or loss_type == 'eiou':
        c2 = outer_w ** 2 + outer_h ** 2
        rho2 = ((pred[:, 0] + pred[:, 2] - target[:, 0] - target[:, 2]) ** 2 +
                (pred[:, 1] + pred[:, 3] - target[:, 1] - target[:, 3]) ** 2) / 4
        dious = ious - rho2 / c2
        if loss_type == 'ciou':
            v = torch.pow((torch.atan(tag_w / tag_h) - torch.atan(pred_w / pred_h)), 2) * (4 / (math.pi ** 2))
            alpha = v / (1 - ious + v)
            cious = dious - alpha * v
            cious = torch.clamp(cious, min=-1.0, max=1.0)
            loss = 1 - cious
        elif loss_type == 'eiou':
            rho_w2 = (tag_w - pred_w) ** 2
            rho_h2 = (tag_h - pred_h) ** 2
            cw2 = outer_w ** 2 + eps
            ch2 = outer_h ** 2 + eps
            eious = dious - rho_w2 / cw2 - rho_h2 / ch2
            loss = 1 - eious
        else:
            loss = 1 - dious
    elif loss_type == 'siou':
        s_cw = (pred[:, 0] + pred[:, 2] - target[:, 0] - target[:, 2]) * 0.5
        s_ch = (pred[:, 1] + pred[:, 3] - target[:, 1] - target[:, 3]) * 0.5
        sigma = torch.pow(s_cw ** 2 + s_ch ** 2, 0.5) + 1.0
        sin_alpha_1 = torch.abs(s_cw) / sigma
        sin_alpha_2 = torch.abs(s_ch) / sigma
        threshold = pow(2, 0.5) / 2
        sin_alpha = torch.where(sin_alpha_1 > threshold, sin_alpha_2, sin_alpha_1)
        angle_cost = torch.cos(torch.arcsin(sin_alpha) * 2 - math.pi / 2)
        rho_x = (s_cw / outer_w) ** 2
        rho_y = (s_ch / outer_h) ** 2
        gamma = angle_cost - 2
        distance_cost = 2 - torch.exp(gamma * rho_x) - torch.exp(gamma * rho_y)
        omiga_w = torch.abs(tag_w - pred_w) / torch.max(tag_w, pred_w)
        omiga_h = torch.abs(tag_h - pred_h) / torch.max(tag_h, pred_h)
        shape_cost = torch.pow(1 - torch.exp(-1 * omiga_w), 4) + torch.pow(1 - torch.exp(-1 * omiga_h), 4)
        sious = ious - 0.5 * (distance_cost + shape_cost)
        loss = 1 - sious
    else:
        raise NotImplementedError

    if reduction == 'mean':
        loss = torch.mean(loss)
    elif reduction == 'sum':
        loss = torch.sum(loss)
    else:
        raise NotImplementedError
    print(f"{loss_type} loss: {loss}")

    return loss


if __name__ == '__main__':
    pred_box = torch.tensor([[2, 4, 6, 8], [5, 9, 13, 12]])
    gt_box = torch.tensor([[3, 4, 7, 9]])
    iou_loss(pred=pred_box, target=gt_box, loss_type='iou')
    iou_loss(pred=pred_box, target=gt_box, loss_type='giou')
    iou_loss(pred=pred_box, target=gt_box, loss_type='diou')
    iou_loss(pred=pred_box, target=gt_box, loss_type='ciou')
    iou_loss(pred=pred_box, target=gt_box, loss_type='eiou')
    iou_loss(pred=pred_box, target=gt_box, loss_type='siou')