基于深度学习的目标检测的IOU损失函数介绍

前言

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

正文

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

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

GIoU引入了一个最小闭包区的概念，即能将预测框和真实框包裹住的最小矩形框，其中，A^c为最小闭包区，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的损失函数值，$L_{diou}$能够描述检测框与gt框的位置信息。从图中我们可以看到，当处于第三幅图时，检测框和gt都位于中心，IoU=GIoU=DIoU。但位置出现差异，如第一幅图和第二幅图时，明显第二幅图的效果要好一些，此时GIOU降级成为IOU，而DIOU的损失值较大，能够较好的描述当前位置信息。

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

$b$和$b^{gt}$分别代表预测框和gt框的中心点，$\rho$代表欧氏距离，c代表最小闭包区的对角线距离。
DIoU具有以下特点：

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

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

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

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

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

其中，$C_w$和$C_h$是最小闭包的w和h。

SIoU

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

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

Angle cost

Distance cost

可以看出，当$\alpha$ $\to$ 0时，Distance cost的贡献大大降低。相反，$\alpha$越接近$\pi$/4，Distance cost贡献越大。随着角度的增大，问题变得越来越难。因此，$\gamma$被赋予时间优先的距离值，随着角度的增加。

Shape cost

IoU cost

整体$Loss$计算如下：

---

各类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')