目标检测损失函数实战：CIoU与WIoU的对比分析与最佳实践

1次阅读

共计 2846 个字符，预计需要花费 8 分钟才能阅读完成。

在目标检测任务中，IoU（Intersection over Union）是衡量预测框与真实框重合度的重要指标。传统的 IoU 损失函数直接使用 1 -IoU 作为损失值，但存在两个明显缺陷：

当预测框与真实框没有重叠时，IoU 为 0，无法提供梯度方向
对框的对齐方式不敏感，不同对齐方式可能得到相同的 IoU 值

GIoU（Generalized IoU）通过引入最小包围框部分解决了这些问题，但在一些复杂场景下仍表现不佳：

对于长宽比差异大的目标优化效果有限
在密集目标场景下容易产生误导性梯度

指标	CIoU	WIoU
中心点距离	$\rho^2(b,b^{gt})/c^2$	动态调整权重
长宽比	$\alpha v$	无显式考虑
权重策略	固定	动态调整

其中 CIoU 的完整公式为：
$$\mathcal{L}_{CIoU} = 1 – IoU + \frac{\rho^2(b,b^{gt})}{c^2} + \alpha v$$

遮挡场景 ：WIoU 通过动态权重调整表现更好
小目标检测 ：CIoU 对中心点距离的惩罚更有效
密集场景 ：WIoU 的权重机制可以减少误匹配

import torch
import math

class CIoULoss:
    def __init__(self, eps=1e-7):
        self.eps = eps

    def __call__(self, pred, target):
        """
        pred: [N,4] (x1,y1,x2,y2)
        target: [N,4] (x1,y1,x2,y2)
        """
        # 计算交集面积
        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])

        inter_area = torch.clamp(inter_x2 - inter_x1, min=0) * \
                     torch.clamp(inter_y2 - inter_y1, min=0)

        # 计算并集面积
        pred_area = (pred[:,2]-pred[:,0]) * (pred[:,3]-pred[:,1])
        target_area = (target[:,2]-target[:,0]) * (target[:,3]-target[:,1])
        union_area = pred_area + target_area - inter_area + self.eps

        # 计算 IoU
        iou = inter_area / union_area

        # 计算中心点距离
        pred_center = torch.stack([(pred[:,0]+pred[:,2])/2, 
                                  (pred[:,1]+pred[:,3])/2], dim=1)
        target_center = torch.stack([(target[:,0]+target[:,2])/2, 
                                    (target[:,1]+target[:,3])/2], dim=1)
        center_dist = torch.sum((pred_center - target_center)**2, dim=1)

        # 计算最小包围框对角线距离
        enclose_x1 = torch.min(pred[:,0], target[:,0])
        enclose_y1 = torch.min(pred[:,1], target[:,1])
        enclose_x2 = torch.max(pred[:,2], target[:,2])
        enclose_y2 = torch.max(pred[:,3], target[:,3])
        c_sq = torch.sum((enclose_x2 - enclose_x1)**2 + 
                        (enclose_y2 - enclose_y1)**2, dim=0) + self.eps

        # 计算长宽比惩罚项
        with torch.no_grad():
            arctan = torch.atan((target[:,2]-target[:,0]) / 
                               (target[:,3]-target[:,1]+self.eps)) - \
                    torch.atan((pred[:,2]-pred[:,0]) / 
                              (pred[:,3]-pred[:,1]+self.eps))
            v = 4 / (math.pi ** 2) * torch.pow(arctan, 2)
            alpha = v / (1 - iou + v + self.eps)

        loss = 1 - iou + center_dist/c_sq + alpha * v
        return loss.mean()

class WIoULoss:
    def __init__(self, eps=1e-7, momentum=0.9):
        self.eps = eps
        self.momentum = momentum
        self.register_buffer('running_mean', torch.zeros(1))

    def __call__(self, pred, target):
        # 计算基础 IoU（同 CIoU 前半部分）iou = compute_iou(pred, target)  # 伪代码

        # 动态权重计算
        with torch.no_grad():
            mean_iou = self.running_mean
            if self.training:
                self.running_mean = \
                    self.momentum * self.running_mean + \
                    (1 - self.momentum) * iou.detach().mean()

            weight = torch.exp((mean_iou - iou.detach()) / mean_iou)

        return (weight * (1 - iou)).mean()

我们在 COCO 2017 验证集上进行了对比实验，结果如下：