当前位置：网站首页>目标检测中的Classificition Loss

目标检测中的Classificition Loss

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

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

目标检测中的Bounding Box Regression Loss

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

1 Cross Entropy

交叉熵表示成真实概率分布p的函数和预测概率分布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 Loss一种用于评估两个样本之间相似性度量的函数，取值范围为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

称为调制系（modulating factor）。

优点：

当一个样本被分错的时候，pt是很小的（请结合公式2，比如当y=1时，p要小于0.5才是错分类，此时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系数。

因此，我们只需控制 α 和 β 便可以控制假阴性和假阳性之间的平衡。如增大 β 的取值，可以增大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.