stream回归回归的loss

转载

mob6454cc7c0428 2024-08-21 10:36:27

文章标签 stream回归 ci 权重深度学习 文章分类 机器学习人工智能

深度学习loss大体上分成两类分类loss和回归loss。

回归loss：平均绝对误差L1loss，平均平方误差L2loss， smooth L1 loss
分类loss ： 0-1损失， logistic loss, hinge loss 铰链损失， exponential loss（指数损失）， KL散度。

回归loss

L1 loss

$MAE= \frac{1}{n}\sum \left | f(x_{i} )-y_{i}) \right |$

在loss为0处不可导，求解效率比较低
梯度比较稳定，在损失很小的时候梯度也是稳定的不利于收敛
由于没有平方对于异常不敏感。

L2 loss

$MAE= \frac{1}{n}\sum ( f(x_{i} )-y_{i})^{2}$

平滑处处可导，在反向传播的时候有利于梯度计算。
随着loss下降，梯度也进行下降，可以很快的收敛。
由于有平方项所以有异常值的情况下会影响比较大。
误差很大的时候梯度很大，一开始的时候容易梯度爆炸。

Smooth L1 loss

if |f(x_{i} - y_{i}|<1

$Smooth L1 = \frac{1}{n}\sum (0.5\cdot (f(x_{i} - y_{i})^{2} )$

else

$Smooth L1 = \frac{1}{n}\sum (|f(x_{i} - y_{i}|-0.5 )$

在loss比较大的时候，梯度不至于过大。
差别很小的时候梯度又比较小，有利于收敛。

分类loss

0-1 loss

stream回归回归的loss_ci_05

对每一个点都时相同的权重，对误差大的点不会过多关注。
离散点不利于优化。

logistic loss

$L_{log} = \frac{1}{n}\sum log(1+e^{-y_{i}f(x_{i})})$

high loss

$L_{hinge} = \frac{1}{n}\sum max(0, {1-y_{i}f(x_{i})})$

Exponential loss

$L_{log} = \frac{1}{n}\sum e^{-y_{i}f(x_{i})}$

其他常用的loss

softmax cross-entropy loss

$f(x) = \frac{e^{w_{c}^{t}x}}{\sum e^{w_{k}^{T}x}}$

$Lce = -\frac{1}{n}\sum log(f(x_{i}))$

y表示的是标签的one-hot编码

Weighted cross-entropy loss

通过权重可以解决样本不平衡的问题。

Focal loss

yi =1:

$L_{f1}=-\alpha (1-f(x_{i}))^{\gamma }logf(x_{i})$

yi=0:

$L_{f1}=-(1-\alpha) (f(x_{i}))^{\gamma }log(1-f(x_{i}))$

stream回归回归的loss_深度学习_13

传统的CE loss，当为正样本时，概率越大loss 越低，负样本时，概率越小loss越低。

为了使得网络更关注于困难样本，以参数

$\gamma =2 \alpha =0.25$

为例子

当目标是正样本时希望概率越大的，它的loss抑制得更低，

概率为0.8 时，正常的CE loss为0.096，而focus loss 为0.003

概率为0.4时，正常的CE loss为0.39，而focus loss为0.14

可以很明显看出容易样本loss被抑制了30倍，而困难样本才抑制了不到3倍，这样网络就会更关注困难样本。

同理当目标为负样本的时候是一样的，网络会更关注概率比较大的困难样本。

$\alpha$

是作为权重是为了平衡正负样本。

所以focus loss既可以解决简单和困难样本，同时还能平衡样本不均衡。

Triplet loss

$L = \frac{1}{n}\sum max(\left \| f(x_{i}^{a} - f(x_{i}^{b} ) \right \| - \left \| f(x_{i}^{a} - f(x_{i}^{n} ) \right \| +margin, 0)$

用于训练差异比较小的样本，比如人脸，a和b为同类， a和n为异类。这样可以保证同类的差异小于不同类别的loss。

Contrastive loss

$L = \frac{1}{2n}\sum y_{i}\left \| f(x_{i}^{a}) - f(x_{i}^{b}) \right \| + (1-y_{i})max(margin-||f(x_{i}^{a})-f(x_{i}^{a}) ||, 0)^{2}$

用于处理孪生网络

Center loss

$L = L_{ce} + \gamma L_{center} = -\sum log(f(x_{i})) + \frac{\lambda }{2}\sum \left \| x_{i} -c_{yj}\right \|^{2}$

这个是为了解决人脸识别中同一个人脸内部的差距较大的问题。

IOU loss

IOU存在的问题

如果两个框没有相交，根据定义IOU=0，不能反映两个框的距离，loss=0梯度为0，不能训练
IOU不能很好的反映两者重合的状况

stream回归回归的loss_stream回归_19

三张图IOU一样，但是左边的IOU最好，右边最差。

GIOU

$GIOU=IOU-\frac{A_{c}-U}{A_{c}}$

U 表示的是两个框的并集合

$A_{c}$

表示的是两个框的外接矩形

代码：

def Giou(rec1,rec2):
    #分别是第一个矩形左右上下的坐标
    x1,x2,y1,y2 = rec1 
    x3,x4,y3,y4 = rec2
    iou = Iou(rec1,rec2)
    area_C = (max(x1,x2,x3,x4)-min(x1,x2,x3,x4))*(max(y1,y2,y3,y4)-min(y1,y2,y3,y4))
    area_1 = (x2-x1)*(y1-y2)
    area_2 = (x4-x3)*(y3-y4)
    sum_area = area_1 + area_2

    w1 = x2 - x1   #第一个矩形的宽
    w2 = x4 - x3   #第二个矩形的宽
    h1 = y1 - y2
    h2 = y3 - y4
    W = min(x1,x2,x3,x4)+w1+w2-max(x1,x2,x3,x4)    #交叉部分的宽
    H = min(y1,y2,y3,y4)+h1+h2-max(y1,y2,y3,y4)    #交叉部分的高
    Area = W*H    #交叉的面积
    add_area = sum_area - Area    #两矩形并集的面积

    end_area = (area_C - add_area)/area_C    #闭包区域中不属于两个框的区域占闭包区域的比重
    giou = iou - end_area
    return giou

DIOU

$DIOU=IOU - \frac{\rho ^{2}(b, b^{gt})}{c^{2}}$

$\rho$

表示欧式距离， b和

$b^{gt}$

表示的是预测框和真实框之间的中心点， c表示的是最小包围圈的对角距离。

stream回归回归的loss_stream回归_25

优点：

与GIOU类似在与目标框不重叠的时候可以提供移动方向。
直接最小化两个框之间的距离，收敛速度更快。
在一个框包含在另外一个框的情况下，GIOU会退化成IOU，而DIOU还可以保持好的迭代速度。
DIOU还可以作为NMS的时候使用，使得NMS效果更好。

def Diou(bboxes1, bboxes2):
    rows = bboxes1.shape[0]
    cols = bboxes2.shape[0]
    dious = torch.zeros((rows, cols))
    if rows * cols == 0:#
        return dious
    exchange = False
    if bboxes1.shape[0] > bboxes2.shape[0]:
        bboxes1, bboxes2 = bboxes2, bboxes1
        dious = torch.zeros((cols, rows))
        exchange = True
    # #xmin,ymin,xmax,ymax->[:,0],[:,1],[:,2],[:,3]
    w1 = bboxes1[:, 2] - bboxes1[:, 0]
    h1 = bboxes1[:, 3] - bboxes1[:, 1] 
    w2 = bboxes2[:, 2] - bboxes2[:, 0]
    h2 = bboxes2[:, 3] - bboxes2[:, 1]
    
    area1 = w1 * h1
    area2 = w2 * h2

    center_x1 = (bboxes1[:, 2] + bboxes1[:, 0]) / 2 
    center_y1 = (bboxes1[:, 3] + bboxes1[:, 1]) / 2 
    center_x2 = (bboxes2[:, 2] + bboxes2[:, 0]) / 2
    center_y2 = (bboxes2[:, 3] + bboxes2[:, 1]) / 2

    inter_max_xy = torch.min(bboxes1[:, 2:],bboxes2[:, 2:]) 
    inter_min_xy = torch.max(bboxes1[:, :2],bboxes2[:, :2]) 
    out_max_xy = torch.max(bboxes1[:, 2:],bboxes2[:, 2:]) 
    out_min_xy = torch.min(bboxes1[:, :2],bboxes2[:, :2])

    inter = torch.clamp((inter_max_xy - inter_min_xy), min=0)
    inter_area = inter[:, 0] * inter[:, 1]
    inter_diag = (center_x2 - center_x1)**2 + (center_y2 - center_y1)**2
    outer = torch.clamp((out_max_xy - out_min_xy), min=0)
    outer_diag = (outer[:, 0] ** 2) + (outer[:, 1] ** 2)
    union = area1+area2-inter_area
    dious = inter_area / union - (inter_diag) / outer_diag
    dious = torch.clamp(dious,min=-1.0,max = 1.0)
    if exchange:
        dious = dious.T
    return dious

CIOU

DIOU没有将长宽比考虑进去，因此需要加入：

$CIOU=IOU - \frac{\rho ^{2}(b, b^{gt})}{c^{2}}-\alpha \frac{4}{\pi ^{2}}(arctan(\frac{w_{gt}}{h_{gt}}) - arctan(\frac{w}{h}))$

代码：

def bbox_overlaps_ciou(bboxes1, bboxes2):
    rows = bboxes1.shape[0]
    cols = bboxes2.shape[0]
    cious = torch.zeros((rows, cols))
    if rows * cols == 0:
        return cious
    exchange = False
    if bboxes1.shape[0] > bboxes2.shape[0]:
        bboxes1, bboxes2 = bboxes2, bboxes1
        cious = torch.zeros((cols, rows))
        exchange = True

    w1 = bboxes1[:, 2] - bboxes1[:, 0]
    h1 = bboxes1[:, 3] - bboxes1[:, 1]
    w2 = bboxes2[:, 2] - bboxes2[:, 0]
    h2 = bboxes2[:, 3] - bboxes2[:, 1]

    area1 = w1 * h1
    area2 = w2 * h2

    center_x1 = (bboxes1[:, 2] + bboxes1[:, 0]) / 2
    center_y1 = (bboxes1[:, 3] + bboxes1[:, 1]) / 2
    center_x2 = (bboxes2[:, 2] + bboxes2[:, 0]) / 2
    center_y2 = (bboxes2[:, 3] + bboxes2[:, 1]) / 2

    inter_max_xy = torch.min(bboxes1[:, 2:],bboxes2[:, 2:])
    inter_min_xy = torch.max(bboxes1[:, :2],bboxes2[:, :2])
    out_max_xy = torch.max(bboxes1[:, 2:],bboxes2[:, 2:])
    out_min_xy = torch.min(bboxes1[:, :2],bboxes2[:, :2])

    inter = torch.clamp((inter_max_xy - inter_min_xy), min=0)
    inter_area = inter[:, 0] * inter[:, 1]
    inter_diag = (center_x2 - center_x1)**2 + (center_y2 - center_y1)**2
    outer = torch.clamp((out_max_xy - out_min_xy), min=0)
    outer_diag = (outer[:, 0] ** 2) + (outer[:, 1] ** 2)
    union = area1+area2-inter_area
    u = (inter_diag) / outer_diag
    iou = inter_area / union
    with torch.no_grad():
        arctan = torch.atan(w2 / h2) - torch.atan(w1 / h1)
        v = (4 / (math.pi ** 2)) * torch.pow((torch.atan(w2 / h2) - torch.atan(w1 / h1)), 2)
        S = 1 - iou
        alpha = v / (S + v)
        w_temp = 2 * w1
    ar = (8 / (math.pi ** 2)) * arctan * ((w1 - w_temp) * h1)
    cious = iou - (u + alpha * ar)
    cious = torch.clamp(cious,min=-1.0,max = 1.0)
    if exchange:
        cious = cious.T
    return cious

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Android app logback 打印日志 logback日志不打印

下一篇：win7虚拟机使用ios

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯