pytorch模型构建（四）——常用的回归损失函数

2023年7月23日上午7:27 • 人工智能 • 阅读 52

一、简介

损失函数的作用： 主要用于深度学习中predict与True label “距离”度量或者”相似度度量”，并通过反向传播求梯度，进而通过梯度下降算法更新网络参数，周而复始，通过损失值和评估值反映模型的好坏。
损失函数的分类： 主要分为回归损失函数和分类损失函数。
回归损失函数： reg_loss(回归预测一个具体的数值，真实的一个具体值)，比如我要预测一个矩形框的宽高，一般来说可以使任意值。一般的回归会将预测的值设计到一个较小的范围比如 0~1范围内，这样可以加速模型收敛，要不然模型前期预测的数值”乱跳”，出现波动的情况。一般有 L1 Loss、 L2 Loss、 Smooth L1 Loss，以及在一些任务如目标检测中根据场景设置的loss如， IOU Loss、 GIOU Loss、 DIOU Loss、 CIOU Loss。
分类损失函数： reg_loss(回归预测一个具体的数值，真实的一个具体值)，比如我要预测一个矩形框的宽高，一般来说可以使任意值。一般的回归会将预测的值设计到一个较小的范围比如 0~1范围内，这样可以加速模型收敛，要不然模型前期预测的数值”乱跳”，出现波动的情况。一般有 CrossEntropy Loss、 NLL Loss、 KLDiv Loss、 BCE Loss、 BCE With Logits Loss、 Margin Ranking Loss、 Hinge Embedding Loss、 Huber Loss等。

需要注意的：
pytorch损失函数中一般有 size_average、 size_average、 reduction这三个参数。
这三个参数决定损失函数是1.只求是loss； 2. 对loss求和；3. 对loss求平均。
（ deprecated表示此方法已废弃、暂时可用，但以后该方法不会再更新，建议后来人不要调用此方法。）

size_average 和 reduce 是deprecated，两个之间是有关系的。目前使用的 reduction。

Reducesize_averageresultFalse-1. 只是求loss（忽略size_average参数）TrueFalse2. 对loss求和TrueTrue3. 对loss求平均值 Reduceresult’None’1. 只是求loss（忽略size_average参数）’sum’2. 对loss求和’mean’3. 对loss求平均值

二、回归损失函数

回归问题就是预测出具体的数值，比如我要预测电池电压的具体值，具体值不是固定的，分类问题就是我要预测电池电压值处于故障状态类别还是正常状态类别，类别数目是固定的。

`1. L1 Loss（绝对值损失）`

介绍

L1 Loss即平均绝对误差（Mean Absolute Error， MAE），公式为：
l ( x , y ) = 1 N ∑ i = 1 N ∣ x i − y i ∣ l(x,y) = \frac{1}{N}\sum_{i=1}^{N}|x_i-y_i|l (x ,y )=N 1 i =1 ∑N ∣x i −y i ∣
就是求预测值和真实值误差的绝对值。

代码

torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')

from torch import nn
loss = nn.L1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
output.backward()

`2. L2 Loss (MSE Loss)（平方损失）`

介绍：

L2 Loss即均方差（Mean Squred Error， MSE），公式为：
l ( x , y ) = 1 N ∑ i = 1 N ( x i − y i ) 2 l(x,y) = \frac{1}{N}\sum_{i=1}^{N}(x_i-y_i)^2 l (x ,y )=N 1 i =1 ∑N (x i −y i )2
就是求预测值和真实值误差的绝对值。

代码：

torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')

from torch import nn
loss = nn.MSELoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
output.backward()

小结： 1. L1 Loss：0处导数不连续，收敛速度慢。对异常值不敏感，因为是求平均，会忽略掉异常值的作用，一般可用于有少许数据错误的值，这样就可以忽略掉这些错误的离群值。
2. 1. L2 Loss：收敛速度快，对异常值敏感，如果是需要进行异常检测，就不能忽略掉离群值。
假如数据集多数为1000，少数为10，那么L1会偏向1000（因为更偏向于平均），L2则会偏向于10，因为对离群值更敏感，所以实际中这两种都不太可取，所以Smooth L1 Loss可以同时利用两者的优点。

`3. Smooth L1 Loss`

介绍：

平滑的L1损失（Smooth L1 Loss， SLL），在Faster RCNN中被提出来，公式为：
l ( x , y ) = { 0.5 ( x i − y i ) 2 b e t a , i f ∣ x i − y i ∣ < b e t a ∣ x i − y i ∣ − 0.5 ∗ b e t a , o t h e r w i s e l(x,y)=\left{ \begin{aligned} \frac{0.5(x_i – y_i)^2}{beta}, if |x_i – y_i| < beta \ |x_i-y_i|-0.5*beta, otherwise \end{aligned} \right.l (x ,y )=⎩⎨⎧b e t a 0 .5 (x i −y i )2 ,i f ∣x i −y i ∣<b e t a ∣x i −y i ∣−0 .5 ∗b e t a ,o t h e r w i s e

代码：

torch.nn.SmoothL1Loss(size_average=None, reduce=None, reduction='mean', beta=1.0)
beta的作用：控制什么范围的误差使用MSE，什么范围内的误差内使用MAE。
Smooth L1 Loss的优点：

结合了L1 Loss对离群点、异常值不敏感的优点。
结合了L2 Loss在0处可导数，收敛速度快、训练不容易跑飞的优点。

; `4. Huber L1 Loss`

介绍：

H u b e r L 1 L o s s = b e t a ∗ S m o o t h L 1 L o s s Huber L1 Loss = betaSmoothL1Loss H u b e r L 1 L o s s =b e t a ∗S m o o t h L 1 L o s s，公式为：
l ( x , y ) = { 0.5 ( x i − y i ) 2 , i f ∣ x i − y i ∣ < b e t a b e t a ∗ ( ∣ x i − y i ∣ − 0.5 ∗ b e t a ) , o t h e r w i s e l(x,y)=\left{ \begin{aligned} {0.5(x_i – y_i)^2}, if |x_i – y_i| < beta \ beta(|x_i-y_i|-0.5*beta), otherwise \end{aligned} \right.l (x ,y )={0 .5 (x i −y i )2 ,i f ∣x i −y i ∣<b e t a b e t a ∗(∣x i −y i ∣−0 .5 ∗b e t a ),o t h e r w i s e

代码：

torch.nn.HuberLoss(reduction='mean', delta=1.0)
SmoothL1Loss和HuberLoss区别：

当beta趋于0时， SmoothL1Loss收敛于 L1Loss, HuberLoss收敛于常数0;
当beta趋于无穷时， SmoothL1Loss收敛于常数0， HuberLoss收敛于 MSELoss
随着beta的变化， SmoothL1Loss中平均绝对误差段的斜率恒定为1；而 HuberLos中平均绝对误差段的斜率是beta

`4. IOU Loss`

介绍:

在之前的目标检测中，回归损失都是回归矩形框的四个变量，这样做就默认将四个变量认为是相互独立的，这样”粗暴”的直接回归效果往往不会太好，引入交并比损失（IOU Loss）则可以把四个变量关联起来。
公式：
L ( i o u ) = − l n ( i o u ) L(iou) = -ln(iou)L (i o u )=−l n (i o u )
通常也是用如下公式：
L ( i o u ) = 1 − i o u L(iou) = 1-iou L (i o u )=1 −i o u

代码:

先将bbox坐标转换为x 1 y 1 x_1y_1 x 1 y 1 x 2 y 2 x_2y_2 x 2 y 2
求出交集区域面积：
宽=两个bbox中最小的x 2 x_2 x 2 – 两个bbox中最大的x 1 x_1 x 1 （需要使用clamp成0，防止越界）
高 = 两个bbox中最小的y 2 y_2 y 2 – 两个bbox中最大的y 1 y_1 y 1 （需要使用clamp成0，防止越界）
然后交集区域面积i n t e r = 宽 ∗ 高 inter=宽*高i n t e r =宽∗高
求出并集区域面积：
union = (w1 _h1 + w2_h2) – inter，因为并集union要作为分母，所以要考虑是0的情况，所以需要加一个很小的常数e p s eps e p s
计算iou，i o u = i n t e r u n i o n iou=\frac{inter}{union}i o u =u n i o n i n t e r

import torch
def bbox_iou(box1, box2, x1y1x2y2=True, eps=1e-7):
   """用计算回归损失
   :params box1: 预测框      shape:(4, n)
   :params box2: 预测框      shape:(n, 4)
   :return box1和box2的IoU   shape:(1, n)
"""
   box2 = box2.T

   if x1y1x2y2:
       b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
       b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
   else:
       b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
       b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
       b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
       b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2

   inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
           (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)

   w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
   w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
   union = w1 * h1 + w2 * h2 - inter + eps

   iou = inter / union

   return iou

`5. GIOU Loss（Generalized-IoU Loss）`

介绍

IOU Loss的缺点：

1 两box无相交，IOU=0，不能反映两者的距离大小（重合度），同时Loss为0，没有梯度回传，无法进行训练。
2 IOU在一些情况下无法精确反映两box的重合度大小。比如，IOU相同的情况下，有的效果好，有的效果差，但是使用IOU则无法进行精确的区分哪个更好，因为IOU都一致。

GIOU：

公式：
G I O U = I O U − ∣ A c − U ∣ ∣ A c ∣ GIOU = IOU – \frac{|A_c-U|}{|A_c|}G I O U =I O U −∣A c ∣∣A c −U ∣

其中A c A_c A c 为两个框最小闭包区域面积，U = 两个框的并集 U=两个框的并集U =两个框的并集。总体来说为：IOU-闭包区域中不属于两个框的区域闭包区域 \frac{闭包区域中不属于两个框的区域}{闭包区域}闭包区域闭包区域中不属于两个框的区域
L ( G I O U ) = 1 − G I O U L(GIOU) = 1-GIOU L (G I O U )=1 −G I O U

特性：
GIOU有对称区间，取值范围为[-1, 1]。两者重合时取最大值1，无交集且无限远时候取最小值-1。
IOU只关注重叠区域，GIOU不仅关注重叠区域，还关注其他非重合区域。

代码

def bbox_GIoU(box1, box2, x1y1x2y2=True, eps=1e-7):
    """用计算回归损失
    :params box1: 预测框      shape:(4, n)
    :params box2: 预测框      shape:(n, 4)
    :return box1和box2的GIoU   shape:(1, n)
"""
    box2 = box2.T

    if x1y1x2y2:
        b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
        b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
    else:
        b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
        b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
        b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
        b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2

    inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
            (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)

    w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
    union = w1 * h1 + w2 * h2 - inter + eps

    iou = inter / union

    cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1)

    ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1)

    c_area = cw * ch + eps

    return iou - (c_area - union) / c_area

`6. DIOU Loss(Distance-IoU Loss)`

介绍:

DIoU的优点：

1 保留了GIoU不重叠时仍能度量的优点。
2 DIoU Loss可以直接优化两个目标的距离，因此比GIoU Loss收敛速度更快。
3 在GT_Box包含预测框的情况下，DIoU Loss可以收敛的更快，而GIoU Loss退化成IoU Loss收敛速度较慢。

DIOU：

公式：
D I o U = I o U − ρ 2 ( b , b g t ) c 2 DIoU = IoU – \frac{\rho^{2}(b, b^{gt})}{c^2}D I o U =I o U −c 2 ρ2 (b ,b g t )

其中b b b和b g t b^{gt}b g t分别代表了预测框和真实框的中心点，ρ \rho ρ为计算欧式距离，c代表最小闭包区域的对角线距离。（PS：减号后面称为惩罚项，可直观的理解为两框的距离与最小闭包区域距离平方的比值）

L ( D I o U ) = 1 − I o U + ρ 2 ( b , b g t ) c 2 L(DIoU) = 1-IoU + \frac{\rho^{2}(b, b^{gt})}{c^2}L (D I o U )=1 −I o U +c 2 ρ2 (b ,b g t )

; 代码:

def bbox_DIoU(box1, box2, x1y1x2y2=True, eps=1e-7):
    """用计算回归损失
    :params box1: 预测框      shape:(4, n)
    :params box2: 预测框      shape:(n, 4)
    :return box1和box2的DIoU   shape:(1, n)
"""
    box2 = box2.T

    if x1y1x2y2:
        b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
        b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
    else:
        b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
        b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
        b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
        b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2

    inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
            (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)

    w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
    union = w1 * h1 + w2 * h2 - inter + eps

    iou = inter / union

    cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1)

    ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1)

    c2 = cw ** 2 + ch ** 2 + eps

    rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 +
            (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4

    return iou - rho2 / c2

`7. C-IoU Loss(Complete-IoU Loss)`

介绍:

CIoU的优点：

1将长宽比考虑到计算中去

CIoU：

公式：

; 代码

def bbox_CIoU(box1, box2, x1y1x2y2=True, eps=1e-7):
    """用计算回归损失
    :params box1: 预测框      shape:(4, n)
    :params box2: 预测框      shape:(n, 4)
    :return box1和box2的CIoU   shape:(1, n)
"""
    box2 = box2.T

    if x1y1x2y2:
        b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
        b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
    else:
        b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
        b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
        b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
        b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2

    inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
            (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)

    w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
    union = w1 * h1 + w2 * h2 - inter + eps

    iou = inter / union

    cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1)

    ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1)

    c2 = cw ** 2 + ch ** 2 + eps

    rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 +
            (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4

    import math
    v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)

    with torch.no_grad():
        alpha = v / (v - iou + (1 + eps))
    return iou - (rho2 / c2 + v * alpha)

小结

目标检测回归框三要素：重叠面积（IoU、GIoU）、中心点距离（DIoU）、长宽比（CIoU）

Original: https://blog.csdn.net/weixin_39263657/article/details/121780642
Author: 要坚持写博客呀
Title: pytorch模型构建（四）——常用的回归损失函数

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/710260/

转载文章受原作者版权保护。转载请注明原作者出处！

人工智能

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

Django定时任务四种实现方法总结

Django定时任务四种实现方法总结一、使用django-crontab插件来实现定时任务 * 一、附件部分（Linux 中的定时任务crontab的语法如下）二、使用djan…

人工智能 2023年7月6日
00124
文献学习01-Neural Relation Extraction for Knowledge Base Enrichment

论文信息：Proceedings of the 57th Annual Meeting of the Association for Computational Linguisti…

人工智能 2023年6月10日
0072
二十、文本情感分类

1. 文本情感倾向性分析 1.1 情感分析的概念简单的说，我们可以将情感分析（sentiment classification）任务定义为一个分类问题，即指定一个文本输入，机器通…

人工智能 2023年7月1日
0059
如何计算电机极数和无刷电机的Kv值?

介绍如果您正在制造无人机、遥控车或任何使用无刷直流(BLDC)电机的机器，您可能会遇到电机极数和电机Kv值的概念。这两个参数对于表征您的电机和估计其性能都很有帮助。在本文中，我…

人工智能 2023年6月16日
00178
ChatGPT帮你写代码？人工智能ChatGPT之于Web3的几点思考

人工智能AI有人热情膜拜，有人畏惧如虎，AI的发展已经进入高层面的快车道，技术更新迭代日新夜异，技术无罪也无善恶，曾经科幻未来的人机交流，共生共存如今在我们的脑海中已经有了轮廓的意…

人工智能 2023年7月28日
0041
Transformer课程第39章：面向Knowledge-intensive任务的Transformer模型RAG的架构及完整源码实现

1，为何Transformer网络能够存储factual knowledge信息？ 2，pretrained dense retrieval数学原理分析 3，sequence-to…

人工智能 2023年5月30日
0076
ubuntu20.04安装rocm教程，AMD深度学习，6800xt配置pytorch、CUDA（已更新）本地安装torch

官方文档对应torch下载地址 ROCm安装配置踩坑遇到的问题安装ubuntu系统更新内核，但是在win和Ubuntu双系统的前提下（可能）导致内核更新不成功,我安装成功的内…

人工智能 2023年6月16日
00440
机器学习——随机森林（Random forest）

相关文章链接：机器学习——人工神经网络（NN）机器学习——卷积神经网络（CNN）机器学习——循环神经网络（RNN）机器学习——长短期记忆（LSTM）机器学习——决策树（d…

人工智能 2023年6月16日
0073
学习率设置

在我们刚刚接触深度学习时，对学习率只有一个很基础的认知，当学习率过大的时候会导致模型难以收敛，过小的时候会收敛速度过慢，其实学习率是一个十分重要的参数，合理的学习率才能让模型收敛到…

人工智能 2023年6月16日
0056
torch-geometric安装, 以及解决pycharm每次加载(updating skeletons)其第三方依赖库塞爆C盘的问题

文章目录一、torch-geometric安装二、问题描述三. 问题解决方案四. 更新一、torch-geometric安装 torch-geometric是用于图神经网…

人工智能 2023年7月6日
0045
深度学习入门（九）——深度学习框架概览

深度学习框架概览 Caffe Theano TensorFlow Torch Pytorch MXNet cuda-convnet2 Neon Deeplearning4j CNT…

人工智能 2023年6月26日
0076
安装python库报错：Consider using the `–user` option or check the permissions.

昨天在服务器上训练ResNet，导包出现了一些小问题：1)安装tqdm库的时候，出现 Consider using the ‘–user’ option o…

人工智能 2023年5月26日
0074
多元线性回归问题——波士顿房价预测

波士顿房价预测数据集包括506个样本，每个样本包括12个特征变量和该地区的平均房价（单价）显然和多个特征变量相关，不是单变量线性回归（一元线性回归）问题，选择多个特征变量来建立线性…

人工智能 2023年5月26日
0080
鲍鱼数据案例（岭回归、LASSO回归）

鲍鱼数据集案例实战）数据集探索性分析鲍鱼数据预处理对sex特征进行OneHot编码，便于后续模型纳入哑变量筛选特征将鲍鱼数据集划分为训练集和测试集实现线性回归和岭回归 …

人工智能 2023年6月16日
0057
智能足球裁判，能否突破专业运动的技术瓶颈

如果说随便在街头抓一个人来问，全球最受欢迎的运动是哪个？那么你所能得到的结论十有八九是足球。2022作为世界杯再次到来的一年，今年的初冬也势必会由足球点燃我们沉寂许久的激情。我们…

人工智能 2023年5月28日
0078
tensorflow安装步骤（CPU版本，Anaconda环境下，Windows10）

本文主要讲述了在Anaconda环境下，CPU版本tensorflow2.3.0的安装步骤，Windows10系统中Anaconda的安装步骤可以阅读此篇博客：Anaconda安装…

人工智能 2023年7月25日
0060

2024 年 4 月
一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

pytorch模型构建（四）——常用的回归损失函数

1. L1 Loss&#xFF08;&#x7EDD;&#x5BF9;&#x503C;&#x635F;&#x5931;&#xFF09;

介绍

代码

2. L2 Loss (MSE Loss)&#xFF08;&#x5E73;&#x65B9;&#x635F;&#x5931;&#xFF09;

介绍：

代码：

3. Smooth L1 Loss

介绍：

代码：

; 4. Huber L1 Loss

介绍：

代码：

4. IOU Loss

介绍:

代码:

5. GIOU Loss&#xFF08;Generalized-IoU Loss&#xFF09;

介绍

代码

6. DIOU Loss(Distance-IoU Loss)

介绍: