当前位置：网站首页>Classificition Loss in target detection

Classificition Loss in target detection

2022-08-08 10:32:00 【51CTO】

Classificition Loss
PyTorch: https://github.com/shanglianlm0525/CvPytorch

目标检测中的Bounding Box Regression Loss

目标检测中的Classificition Loss

目标检测任务的损失函数由Classificition Loss和Bounding Box Regeression Loss两部分构成.本文介绍目标检测任务中近几年来Classificition Loss的演变过程

1 Cross Entropy

Cross-entropy is expressed as a true probability distributionp的函数和预测概率分布q的函数.

目标检测中的Classificition Loss_深度学习

其中p表示真实值,在这个公式中是one-hot形式;q是预测值,在这里假设已经是经过softmax后的结果了.

PyTorch代码：

       
       nn.
       
       CrossEntropyLoss()
      
1.

2 K-L Divergence

Kullback-Leibler Divergence,即K-L散度,是一种量化两种概率分布P和Q之间差异的方式,又叫相对熵.

目标检测中的Classificition Loss_目标检测_02

KL散度 = 交叉熵 - 熵

PyTorch代码：

       
       nn.
       
       functional.
       
       kl_div(
       
       input, 
       
       target, 
       
       size_average
       
       =
       
       None, 
       
       reduce
       
       =
       
       None, 
       
       reduction
       
       =
       
       'mean')
      
1.

3 Dice Loss

Dice LossA function for evaluating a measure of similarity between two samples,取值范围为0~1,值越大表示两个值的相似度越高.

目标检测中的Classificition Loss_人工智能_03

Laplace smoothing：为了防止分母项为0,一般我们会在分子和分母处同时加入一个很小的数作为平滑系数,也称为拉普拉斯平滑项.

目标检测中的Classificition Loss_机器学习_04

优点：

有益于正负样本不均衡的情况,侧重于对前景的挖掘;
训练过程中,在有较多小目标的情况下容易出现振荡;
极端情况下会出现梯度饱和的情况

PyTorch代码：

       
       import 
       
       torch.
       
       nn 
       
       as 
       
       nn
       
       import 
       
       torch.
       
       nn.
       
       functional 
       
       as 
       
       F
       
       class 
       
       SoftDiceLoss(
       
       nn.
       
       Module):
       
       def 
       
       __init__(
       
       self, 
       
       weight
       
       =
       
       None, 
       
       size_average
       
       =
       
       True):
       
       super(
       
       SoftDiceLoss, 
       
       self).
       
       __init__()
       
       def 
       
       forward(
       
       self, 
       
       logits, 
       
       targets):
       
       num 
       
       = 
       
       targets.
       
       size(
       
       0)
       
       smooth 
       
       = 
       
       1
       
       probs 
       
       = 
       
       F.
       
       sigmoid(
       
       logits)
       
       m1 
       
       = 
       
       probs.
       
       view(
       
       num, 
       
       -
       
       1)
       
       m2 
       
       = 
       
       targets.
       
       view(
       
       num, 
       
       -
       
       1)
       
       intersection 
       
       = (
       
       m1 
       
       * 
       
       m2)
       
       score 
       
       = 
       
       2. 
       
       * (
       
       intersection.
       
       sum(
       
       1) 
       
       + 
       
       smooth) 
       
       / (
       
       m1.
       
       sum(
       
       1) 
       
       + 
       
       m2.
       
       sum(
       
       1) 
       
       + 
       
       smooth)
       
       score 
       
       = 
       
       1 
       
       - 
       
       score.
       
       sum() 
       
       / 
       
       num
       
       return
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

4 Focal loss

Focal loss则是聚焦于训练一个困难样本的稀疏集,通过直接在标准的交叉熵损失基础上做改进,引进了两个惩罚因子,来减少易分类样本的权重,使得模型在训练过程中更专注于困难样本.

目标检测中的Classificition Loss_人工智能_05

γ称作focusing parameter,γ>=0.

目标检测中的Classificition Loss_深度学习_06

called the modulation system（modulating factor）.

优点：

当一个样本被分错的时候,pt是很小的（Please combine the formula2,比如当y=1时,p要小于0.5is misclassification,此时pt就比较小,反之亦然）,因此调制系数就趋于1,也就是说相比原来的loss是没有什么大的改变的.当pt趋于1的时候（此时分类正确而且是易分类样本）,调制系数趋于0,也就是对于总的loss的贡献很小.
当γ=0的时候,focal loss就是传统的交叉熵损失,当γ增加的时候,调制系数也会增加.

PyTorch代码：

       
       class 
       
       FocalLoss(
       
       nn.
       
       Module):
       
       def 
       
       __init__(
       
       self, 
       
       weight
       
       =
       
       None, 
       
       reduction
       
       =
       
       'mean', 
       
       gamma
       
       =
       
       0, 
       
       eps
       
       =
       
       1e-7):
       
       super(
       
       FocalLoss, 
       
       self).
       
       __init__()
       
       self.
       
       gamma 
       
       = 
       
       gamma
       
       self.
       
       eps 
       
       = 
       
       eps
       
       self.
       
       ce 
       
       = 
       
       torch.
       
       nn.
       
       CrossEntropyLoss(
       
       weight
       
       =
       
       weight, 
       
       reduction
       
       =
       
       reduction)
       
       def 
       
       forward(
       
       self, 
       
       input, 
       
       target):
       
       logp 
       
       = 
       
       self.
       
       ce(
       
       input, 
       
       target)
       
       p 
       
       = 
       
       torch.
       
       exp(
       
       -
       
       logp)
       
       loss 
       
       = (
       
       1 
       
       - 
       
       p) 
       
       *
       
       * 
       
       self.
       
       gamma 
       
       * 
       
       logp
       
       return 
       
       loss.
       
       mean()
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

5 Tversky loss

Tversky系数主要用于描述两个特征（集合）之间的相似度.

目标检测中的Classificition Loss_深度学习_07

其中,α + β 的取值我们一般会令其1.

当设置α=β=0.5,此时Tversky系数就是Dice系数.

当设置α=β=1时,此时Tversky系数就是Jaccard系数.

因此,我们只需控制 α 和 β The balance between false negatives and false positives can be controlled.如增大 β 的取值,可以增大Recall值.

PyTorch代码：

       
       def 
       
       tversky(
       
       y_true, 
       
       y_pred):
       
       y_true_pos 
       
       = 
       
       K.
       
       flatten(
       
       y_true)
       
       y_pred_pos 
       
       = 
       
       K.
       
       flatten(
       
       y_pred)
       
       true_pos 
       
       = 
       
       K.
       
       sum(
       
       y_true_pos 
       
       * 
       
       y_pred_pos)
       
       false_neg 
       
       = 
       
       K.
       
       sum(
       
       y_true_pos 
       
       * (
       
       1
       
       -
       
       y_pred_pos))
       
       false_pos 
       
       = 
       
       K.
       
       sum((
       
       1
       
       -
       
       y_true_pos)
       
       *
       
       y_pred_pos)
       
       alpha 
       
       = 
       
       0.7
       
       return (
       
       true_pos 
       
       + 
       
       smooth)
       
       /(
       
       true_pos 
       
       + 
       
       alpha
       
       *
       
       false_neg 
       
       + (
       
       1
       
       -
       
       alpha)
       
       *
       
       false_pos 
       
       + 
       
       smooth)
       
       def 
       
       tversky_loss(
       
       y_true, 
       
       y_pred):
       
       return 
       
       1 
       
       - 
       
       tversky(
       
       y_true,
       
       y_pred)
       
       def 
       
       focal_tversky(
       
       y_true,
       
       y_pred):
       
       pt_1 
       
       = 
       
       tversky(
       
       y_true, 
       
       y_pred)
       
       gamma 
       
       = 
       
       0.75
       
       return 
       
       K.
       
       pow((
       
       1
       
       -
       
       pt_1), 
       
       gamma)
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.