损失函数：DIOU loss手写实现

已于 2022-06-28 13:29:30 修改
阅读量900 收藏 3
点赞数 1
分类专栏： 显著/伪装目标检测-SOD/COD顶会算法总结 文章标签： 计算机视觉 人工智能
于 2022-06-28 13:22:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjc910997316/article/details/125500138
版权

下面是纯diou代码

            '''
              计算两个box的中心点距离d
            '''
            # d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
            d = math.sqrt((pred[:, -1] - target[:, -1]) ** 2 + (pred[:, -2] - target[:, -2]) ** 2)

            # 左边x
            pred_l = pred[:, -1] - pred[:, -1] / 2
            target_l = target[:, -1] - target[:, -1] / 2
            # 上边y
            pred_t = pred[:, -2] - pred[:, -2] / 2
            target_t = target[:, -2] - target[:, -2] / 2
            # 右边x
            pred_r = pred[:, -1] + pred[:, -1] / 2
            target_r = target[:, -1] + target[:, -1] / 2
            # 下边y
            pred_b = pred[:, -2] + pred[:, -2] / 2
            target_b = target[:, -2] + target[:, -2] / 2

            '''
              计算两个box的bound的对角线距离
            '''
            bound_l = torch.min(pred_l, target_l)  # left
            bound_r = torch.max(pred_r, target_r)  # right
            bound_t = torch.min(pred_t, target_t)  # top
            bound_b = torch.max(pred_b, target_b)  # bottom
            c = math.sqrt((bound_r - bound_l) ** 2 + (bound_b - bound_t) ** 2)
            dloss = iou - (d ** 2) / (c ** 2)
            loss = 1 - dloss.clamp(min=-1.0, max=1.0)

第一步 计算两个box的中心点距离d

首先要知道pred和target的输出结果是什么
pred[:,:2]第一个：表示多个图片，第二个:2表示前两个数值，代表矩形框中心点(Y，X)
pred[:,2:]第一个：表示多个图片，第二个2:表示后两个数值，代表矩形框长宽(H，W)
target[:,:2]同理，
d =
 

根据上面的分析来计算左右上下坐标lrtb

 然后计算内部2个矩形的最小外接矩形的对角线长度c

 d是两个预测矩形中心点的距离

 下面接受各种极端情况
A 两个框中心对齐时候，d/c=0，iou可能0-1

 A 两个框相距很远时，d/c=1，iou=0

 所以d/c属于0-1
dloss=iou-d/c属于-1到1
因此设置loss=1-dloss属于0-2

 

展示iou\giou\diou代码，这是YOLOX自带的损失函数，其中dloss是我自己写的
YOLOX是下载自
GitHub - Megvii-BaseDetection/YOLOX: YOLOX is a high-performance anchor-free YOLO, exceeding yolov3~v5 with MegEngine, ONNX, TensorRT, ncnn, and OpenVINO supported. Documentation: https://yolox.readthedocs.io/YOLOX is a high-performance anchor-free YOLO, exceeding yolov3~v5 with MegEngine, ONNX, TensorRT, ncnn, and OpenVINO supported. Documentation: https://yolox.readthedocs.io/ - GitHub - Megvii-BaseDetection/YOLOX: YOLOX is a high-performance anchor-free YOLO, exceeding yolov3~v5 with MegEngine, ONNX, TensorRT, ncnn, and OpenVINO supported. Documentation: https://yolox.readthedocs.io/https://github.com/Megvii-BaseDetection/YOLOX

class IOUloss(nn.Module):
    def __init__(self, reduction="none", loss_type="iou"):
        super(IOUloss, self).__init__()
        self.reduction = reduction
        self.loss_type = loss_type

    def forward(self, pred, target):
        assert pred.shape[0] == target.shape[0]

        pred = pred.view(-1, 4)
        target = target.view(-1, 4)
        tl = torch.max(
            (pred[:, :2] - pred[:, 2:] / 2), (target[:, :2] - target[:, 2:] / 2)
        )
        # pred target都是[H,W,Y,X]
        # (Y,X)-(H,W) 左上角
        br = torch.min(
            (pred[:, :2] + pred[:, 2:] / 2), (target[:, :2] + target[:, 2:] / 2)
        )
        # (X,Y)+(H,W) 右下角


        area_p = torch.prod(pred[:, 2:], 1)  # HxW
        area_g = torch.prod(target[:, 2:], 1)

        en = (tl < br).type(tl.type()).prod(dim=1)
        area_i = torch.prod(br - tl, 1) * en
        area_u = area_p + area_g - area_i
        iou = (area_i) / (area_u + 1e-16)

        if self.loss_type == "iou":
            loss = 1 - iou ** 2
        elif self.loss_type == "giou":
            c_tl = torch.min(
                (pred[:, :2] - pred[:, 2:] / 2), (target[:, :2] - target[:, 2:] / 2)
            )
            c_br = torch.max(
                (pred[:, :2] + pred[:, 2:] / 2), (target[:, :2] + target[:, 2:] / 2)
            )
            area_c = torch.prod(c_br - c_tl, 1)
            giou = iou - (area_c - area_u) / area_c.clamp(1e-16)
            loss = 1 - giou.clamp(min=-1.0, max=1.0)

            # pred[:, :2]  pred[:, 2:]
            # (Y,X)        (H,W)
            # target[:, :2]  target[:, 2:]
            # (Y,X)        (H,W)

        elif self.loss_type == "diou":
            '''
              计算两个box的中心点距离d
            '''
            # d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
            d = math.sqrt((pred[:, -1] - target[:, -1]) ** 2 + (pred[:, -2] - target[:, -2]) ** 2)

            # 左边x
            pred_l = pred[:, -1] - pred[:, -1] / 2
            target_l = target[:, -1] - target[:, -1] / 2
            # 上边y
            pred_t = pred[:, -2] - pred[:, -2] / 2
            target_t = target[:, -2] - target[:, -2] / 2
            # 右边x
            pred_r = pred[:, -1] + pred[:, -1] / 2
            target_r = target[:, -1] + target[:, -1] / 2
            # 下边y
            pred_b = pred[:, -2] + pred[:, -2] / 2
            target_b = target[:, -2] + target[:, -2] / 2

            '''
              计算两个box的bound的对角线距离
            '''
            bound_l = torch.min(pred_l, target_l)  # left
            bound_r = torch.max(pred_r, target_r)  # right
            bound_t = torch.min(pred_t, target_t)  # top
            bound_b = torch.max(pred_b, target_b)  # bottom
            c = math.sqrt((bound_r - bound_l) ** 2 + (bound_b - bound_t) ** 2)
            dloss = iou - (d ** 2) / (c ** 2)
            loss = 1 - dloss.clamp(min=-1.0, max=1.0)

            # Step1
            # def DIoU(a, b):
            # d = a.center_distance(b)
            # c = a.bound_diagonal_distance(b)
            # return IoU(a, b) - (d ** 2) / (c ** 2)

            # Step2-1
            # def center_distance(self, other):
            #    '''
            #    计算两个box的中心点距离
            #    '''
            #    return euclidean_distance(self.center, other.center)

            # Step2-2
            # def euclidean_distance(p1, p2):
            #    '''
            #    计算两个点的欧式距离
            #    '''
            #     x1, y1 = p1
            #    x2, y2 = p2
            #    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

            # Step3
            # def bound_diagonal_distance(self, other):
            #    '''
            #    计算两个box的bound的对角线距离
            #    '''
            #    bound = self.boundof(other)
            #    return euclidean_distance((bound.x, bound.y), (bound.r, bound.b))

            # Step3-2
            # def boundof(self, other):
            #    '''
            #    计算box和other的边缘外包框，使得2个box都在框内的最小矩形
            #    '''
            #    xmin = min(self.x, other.x)
            #    ymin = min(self.y, other.y)
            #    xmax = max(self.r, other.r)
            #    ymax = max(self.b, other.b)
            #    return BBox(xmin, ymin, xmax, ymax)

            # Step3-3
            # def euclidean_distance(p1, p2):
            #    '''
            #    计算两个点的欧式距离
            #    '''
            #     x1, y1 = p1
            #    x2, y2 = p2
            #    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)




        if self.reduction == "mean":
            loss = loss.mean()
        elif self.reduction == "sum":
            loss = loss.sum()

        return loss

GitHub - Megvii-BaseDetection/YOLOX: YOLOX is a high-performance anchor-free YOLO, exceeding yolov3~v5 with MegEngine, ONNX, TensorRT, ncnn, and OpenVINO supported. Documentation: https://yolox.readthedocs.io/

计算机视觉-Archer
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
IoU的进化之路——IoU、GIoU、DIoU、CIoU四种损失函数总结
chase
08-06 6510
IoU、GIoU、DIoU、CIoU四种损失函数总结
目标检测算法常用Loss——DIoU GIoU CIoU
AI_eNyu的博客
05-07 2771
目标检测算法常用Loss 文章目录目标检测算法常用Loss1. 差值平方损失2. IoU Loss3. GIoU Loss4. DIoU Loss5. CIoU Loss6. 说明和补充6.1说明6.2 补充 1. 差值平方损失 在YOLOv3及YOLOv1,v2版本均采用的均值平方损失，也称为L2损失。L2损失在目标检测问题上不能很好的表现出ground truth 和预测框之间的位置，重合等关键信息。所以衍生出一系列关于IoU的损失。 2. IoU Loss 如下图三种不同的情况，明显第三个预测框与
【YOLO改进】换遍IoU损失函数之DIoU Loss（基于MMYOLO）
最新发布
Vlone_pp的博客
04-30 896
在针对YOLO的改进中，通过替换损失函数常常可以达到“无痛提点”的效果，本文将基于MMYOLO框架介绍如何用DIoU损失函数替换YOLO中常用的CIoU损失函数。
目标检测中的损失函数：IOU_Loss、GIOU_Loss、DIOU_Loss和CIOU_Loss
JulyLi2019的博客
12-04 2617
之前在项目中存在目标检测框内嵌的情况（目标检测框存在内嵌情况分析与解决），正好趁这个机会记录下目标检测中常用的几种IOU_loss函数。IOU_Loss作为传统的衡量标准，为我们提供了一个基础,而GIOU_Loss、DIOU_Loss和CIOU_Loss则在其基础上引入了更多的信息，如目标框的形状和相对位置等，从而使得模型更加准确地学习目标的位置和形状。！！2023年12月4日20:03:02。
目标检测中的回归损失函数系列四：DIoU Loss / CIoU Loss
梦坠凡尘
05-12 1万+
论文：https://arxiv.org/pdf/1911.08287.pdf YOLOv-DIoU开源代码：https://github.com/Zzh-tju/DIoU-darknet
YOLOV3-损失函数及其源代码理解
01-06
YOLOV3-损失函数及其源代码理解（yolo_layer.c） 讲得好 https://github.com/AlexeyAB/darknet/issues/821 x,y,w,h 损失 原版的bbox损失为MSE，其后又GIOU，DIOU… delta即为求完损失的梯度 公式对应图 思路及具体...
L1 LOSS -- EIoU loss 一览 .pdf
02-03
从简单的L1或L2损失函数出发，研究人员不断探索更为有效的损失函数形式，最终演化出了EIoU Loss这一较为先进的损失函数。 #### L1/L2 Loss - **定义**： - **L1 Loss**：绝对误差的平均值，适用于处理异常值较多...
【AlexeyAB DarkNet框架解析】九，YOLOV3损失函数代码详解(yolo_layer.c)
01-20
此外，他还引入了Focal Loss，这是一种在类别不平衡问题上表现更好的分类损失函数，特别适合于那些背景类占比大的情况，因为它可以减轻易分类样本的权重，使模型更加关注难以分类的样本。 在代码层面，YOLO层（`...
matlab计算目标面积代码-DIoU:距离-IoU损失：更快更好地了解边界框回归（AAAI2020）
05-22
[Distance-IoU损失：更快更好的边界框回归学习] [] [] @Inproceedings{zheng2020distance, author = {Zhaohui Zheng, Ping Wang, Wei Liu, Jinze Li, Rongguang Ye, Dongwei Ren}, title = {Distance-IoU Loss: ...
YoloV8改进策略：将CIoU替换成Wise-IoU，幸福涨点，值得拥有，还支持EIoU、GIoU、DIoU、SIoU无缝替换
08-04
总之，YOLOv8通过引入Wise-IoU作为损失函数的一部分，实现了对目标检测性能的显著提升。这种改进不仅增强了模型的定位准确性，还增强了其适应不同目标形状和大小的能力。结合其他IoU变体的支持，YOLOv8成为了一个...
IOU、GIOU、DIOU、CIOU详解及代码实现
qq_52302919的博客
01-13 1万+
一、IOU Loss 旷视在2016文章《UnitBox: An Advanced Object Detection Network》中提出了IOU Loss将4个点构成的box看成一个整体做回归。 文章链接：https://arxiv.org/pdf/1608.01471.pdf 1. 函数特性 IOU Loss的定义是先求出预测框和真实框之间的交集和并集之比，再求负对数，但是在实际使用中我们常常将IOU Loss写成1-IOU。如果两个框重合则交并比等于1，Loss为0说明重合度非常高。IOU满足非负性
学习笔记2——交并比 IOU Loss、GIOU Loss、DIOU Loss、CIOU Loss
daige123的博客
11-29 3897
学习笔记2——交并比 IOU Loss、GIOU Loss、DIOU Loss、CIOU Loss 参考：https://blog.csdn.net/c2250645962/article/details/106071294 https://zhuanlan.zhihu.com/p/97340657 https://blog.csdn.net/u014061630/article/details/82818112 https://blog.csdn.net/weixin_41735859/article/d
目标检测 IoU、GIoU、DIoU、CIoU、EIoU
scott198512的博客
04-04 7071
目标检测常用边界框IOU对比
DIoU Loss论文阅读
陈建驱的博客
08-19 2255
论文：Distance-IoU Loss: Faster and Better Learning for Bounding Box Regression. Zhao hui Zheng1,Ping Wang1 , Wei Liu2 , Jinze Li3 , Rongguang Ye1 , Dongwei Ren*2 摘要 边界框回归是目标检测中的关键步骤。当前方法采用ln-norm loss作为边界框回归的损失，但是它不是为评估指标（IoU）量身定做的。最近适合IoU评估指标的IoU los.
【深度学习】锚框损失 IoU Loss、GIoU Loss、 DIoU Loss 、CIoU Loss、 CDIoU Loss、 F-EIoU Loss
q742971636的博客
03-26 5196
文章目录IoU Los （Intersection over Union）GIoU Loss（考虑重叠面积）Generalized Intersection over UnionDIoU Loss（考虑重叠面积，中心点距离）Distance IoUCIoU Loss（考虑重叠面积，中心点距离，宽高比）Complete IoU LossCDIoU Loss (Control Distance IoU Loss)F-EIoU Loss（Focal and Efficient IOU Loss）在模型上的效果评
损失函数：IoU、GIoU、DIoU、CIoU、EIoU、alpha IoU、SIoU、WIoU超详细精讲及Pytorch实现
热门推荐
路人贾的博客
06-20 2万+
一文带你了解IoU、GIoU、DIoU、CIoU、EIoU、alpha IoU、SIoU、WIoU。超级详细的解读，包含代码实现，适合小白！
目标检测--边框回归损失函数(IoU, GIoU, DIoU, CIoU)原理详解及代码实现
Gthan
07-12 4125
对目标检测边框回归的IoU, GIoU, DIoU, CIoU损失函数进行原理详解及代码实现
【Pytorch】 Dice系数与Dice Loss损失函数实现
lynnhgwang的博客
03-31 2万+
由于Dice系数是图像分割中常用的指标，而在Pytoch中没有官方的实现，下面结合网上的教程进行详细实现。 先来看一个我在网上经常看到的一个版本。 def diceCoeff(pred, gt, smooth=1, activation='sigmoid'): r""" computational formula： dice = (2 * (pred ∩ gt)) ...
PolyLoss：一种将分类损失函数加入泰勒展开式的损失函数
lc_love_ty的博客
06-12 747
前两天实习生给我推了一篇针对损失函数进行优化的论文，一种将分类损失函数加入泰勒展开式的损失函数-PolyLoss，全名《POLYLOSS: A POLYNOMIAL EXPANSION PERSPECTIVE OF CLASSIFICATION LOSS FUNCTIONS》。由于该篇论文是在图像任务上进行实验的，抱着试一试的心态，在NLP的AFQMC数据上进行了实验，发现是有提升的，因此分享给大家。...
yolov7损失函数改进diou
07-28
其中，IoU Loss是传统的IoU损失函数，DIoU是距离信息，λ是一个权重系数。通过在计算IoU损失时减去DIoU，可以补偿预测框与真实框之间的距离。 通过引入DIoU损失函数改进Yolov7模型的训练过程，可以提升目标检测的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

计算机视觉-Archer

图像分割没有团队的同学可加群

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值