小白科研笔记：深入理解mmDetection框架——损失函数

1. 前言

这篇博客主要分析mmDetection框架中常见的损失函数，以及它们的具体实现。

2. 目标检测中常见的损失函数

2.1 平滑L1范数

平滑L1范数用于描述目标框回归中的损失函数：

$\text{Smooth}\_L1(x,x_{gt})=\{\begin{array}{rlr}& 0.5\Vert x-x_{gt}{\Vert }_2^2/\beta ,& \Vert x-x_{gt}{\Vert }_1<\beta \\ & \Vert x-x_{gt}{\Vert }_1-0.5\beta ,& \Vert x-x_{gt}{\Vert }_1\ge \beta \end{array}$

平滑L1范数的优势可以参考这篇简书笔记。如果预测变量$x$的误差很大，为了避免给网络反向传递一个非常大的梯度导致训练震荡，就使用L1范数；如果预测变量$x$的误差很小，需要给网络反向传递一个比较小的梯度，就使用L2范数。这是平滑L1范数的优势所在。它在Pytorch下实现的代码如下所示：

def smooth_l1_loss(pred, target, beta=1.0, reduction='mean'):
    assert beta > 0
    assert pred.size() == target.size() and target.numel() > 0
    diff = torch.abs(pred - target)
    # 使用 torch.where 用于区分两种情况
    loss = torch.where(diff < beta, 0.5 * diff * diff / beta,
                       diff - 0.5 * beta)
    reduction_enum = F._Reduction.get_enum(reduction)
    # none: 0, mean:1, sum: 2
    if reduction_enum == 0:
        return loss
    # loss 是个向量，这里对 loss 内各个元素做平均，得到标量 loss
    elif reduction_enum == 1:
        return loss.sum() / pred.numel() 
    elif reduction_enum == 2:
        return loss.sum()

平滑L1范数还能推广为加权平滑L1范数（每个样本点的权重不一样）：

$\text{Loss}={\sum }_{i=1}^N{w}_i\ast \text{Smooth}\_L1(x_i,x_{i,gt});{\sum }_{i=1}^N{w}_i=1$

它在Pytorch下实现的代码如下所示：

def weighted_smoothl1(pred, target, weight, beta=1.0, avg_factor=None):
    if avg_factor is None:
        avg_factor = torch.sum(weight > 0).float().item() + 1e-6
    loss = smooth_l1_loss(pred, target, beta, reduction='none')
    return torch.sum(loss * weight)[None] / avg_factor

2.2 交叉熵损失函数

交叉熵损失函数用于表示目标检测中目标分类问题。单分类情形下交叉熵损失函数表示为：

$\text{Cross\_Entropy}(p_i,y_i)=\{\begin{array}{rlr}& -\log (p_i),& y_i=1\\ & -\log (1-p_i),& y_i=0\end{array}$

其中$p_i$表示预测二分类概率，而$y_i$表示真值。单分类情形下，它们都是标量。

多分类情形下（类别个数为$C$）交叉熵损失函数表示为：

$\text{Multi\_Cross\_Entropy}(p_i,y_i)=-y_i\cdot log(p_i)$

其中$y_i$是一个one-hot类型$C\times 1$的向量，表示为$y_i=(0,...,0,1,0,...,0{)}^T$。如果$y_i$属于第$k$类，那么向量$y_i$中只有第$k$个位置是$1$。$p_i$是网络模型预测和Softmax作用的结果，它是一个$C\times 1$的向量，表示为$p_i=(p_{i,0},...,p_{i,C}{)}^T$，指各个类别的概率。它满足归一化的条件：${\sum }_{j=1}^C{p}_{i,j}=1$。上式中$“\cdot ”$表示向量之间各个元素的点乘。

此外，交叉熵损失函数可以推广为加权交叉熵损失函数（每个样本点的权重不一样）：

$\text{Loss}={\sum }_{i=1}^N{w}_i\ast \text{Multi\_Cross\_Entropy}(p_i,y_i);{\sum }_{i=1}^N{w}_i=1$

它在Pytorch下实现的代码如下所示：

def weighted_cross_entropy(pred, label, weight, avg_factor=None, reduce=True):
    if avg_factor is None:
        avg_factor = max(torch.sum(weight > 0).float().item(), 1.)
    raw = F.cross_entropy(pred, label, reduction='none')
    if reduce:
        return torch.sum(raw * weight)[None] / avg_factor
    else:
        return raw * weight / avg_factor

上述代码中交叉熵计算的代码放在下面讨论：

def cross_entropy(input, target, weight=None, size_average=None, ignore_index=-100,
                  reduce=None, reduction='mean'):

    if size_average is not None or reduce is not None:
        reduction = _Reduction.legacy_get_string(size_average, reduce)
    # nll_loss 相当于是交叉熵损失函数中的负号
    # 原始数据需要先做 softmax 归一化再去 log，合在一起就是 log_softmax
    return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)

简单地讲，nll_loss相当于是交叉熵损失函数中的负号，可以看看这篇知乎笔记。

2.3 Focal Loss

Focal loss是交叉熵损失函数的改进版，用于解决不同类别之间样本不均衡，以及难易样本差异大的情况。在我之前的博客讨论过。单分类情形下Focal Loss损失函数表示为：

$\text{Focal\_loss}(p_i,y_i)=\{\begin{array}{rlr}& -\alpha (1-p_i{)}^{\gamma }\log (p_i),& y_i=1\\ & -(1-\alpha )p_i^{\gamma }\log (1-p_i),& y_i=0\end{array}$

其中$p_i$表示预测二分类概率，而$y_i$表示真值。单分类情形下，它们都是标量。$\alpha$表示正负样本之间的数量比例。$\gamma$表示难易参数，会设置$\gamma >1$表示重视困难样本的损失误差。

多分类情形下（类别个数为$C$）Focal Loss损失函数表示为：

$\text{Multi\_Focal\_Loss}(p_i,y_i)=-(\text{1}-\alpha )\cdot (\text{1}-y_i{)}^{\gamma }\cdot y_i\cdot log(p_i)$

其中$y_i$是一个one-hot类型$C\times 1$的向量，表示为$y_i=(0,...,0,1,0,...,0{)}^T$。如果$y_i$属于第$k$类，那么向量$y_i$中只有第$k$个位置是$1$。$p_i$是网络模型预测和Softmax作用的结果，它是一个$C\times 1$的向量，表示为$p_i=(p_{i,0},...,p_{i,C}{)}^T$，指各个类别的概率。它满足归一化的条件：${\sum }_{j=1}^C{p}_{i,j}=1$。上式中$“\cdot ”$表示向量之间各个元素的点乘。$\text{1}$表示$C\times 1$的向量，填充元素的值都是$1$。$\alpha =({\alpha }_1,...,{\alpha }_C{)}^T$是$C\times 1$的向量，表示各个类别的占比。

从编程角度讲，Focal Loss相比于交叉熵损失函数，仅仅多了$(\text{1}-\alpha )\cdot (\text{1}-y_i{)}^{\gamma }$项而已。对于二分类的Focal Loss，它在Pytorch下实现的代码如下所示：

def sigmoid_focal_loss(pred,
                       target,
                       weight, # 表示各个样本点的权重
                       gamma=2.0,
                       alpha=0.25,
                       reduction='mean'):
    pred_sigmoid = pred.sigmoid()
    target = target.type_as(pred)
    # pt 和 weight 的计算方式很精妙，节省了 if 语句
    pt = (1 - pred_sigmoid) * target + pred_sigmoid * (1 - target)
    weight = (alpha * target + (1 - alpha) * (1 - target)) * weight
    weight = weight * pt.pow(gamma)
    loss = F.binary_cross_entropy_with_logits(
        pred, target, reduction='none') * weight
    reduction_enum = F._Reduction.get_enum(reduction)
    # none: 0, mean:1, sum: 2
    if reduction_enum == 0:
        return loss
    elif reduction_enum == 1:
        return loss.mean()
    elif reduction_enum == 2:
        return loss.sum()

其中函数binary_cross_entropy专指二分类问题的交叉熵损失函数。

此外，Focal loss损失函数可以推广为加权Focal loss损失函数（每个样本点的权重不一样）：

$\text{Loss}={\sum }_{i=1}^N{w}_i\ast \text{Multi\_Focal\_Loss}(p_i,y_i);{\sum }_{i=1}^N{w}_i=1$

它在Pytorch下实现的代码如下所示：

def weighted_sigmoid_focal_loss(pred,
                                target,
                                weight,
                                gamma=2.0,
                                alpha=0.25,
                                avg_factor=None,
                                num_classes=80):
    if avg_factor is None:
        avg_factor = torch.sum(weight > 0).float().item() / num_classes + 1e-6
    return sigmoid_focal_loss(
        pred, target, weight, gamma=gamma, alpha=alpha,
        reduction='sum')[None] / avg_factor

3. 结束语

至此，讨论了目标检测中常见的损失函数的数学表达式和编程实现。最后用一张图概括这篇博客所讨论的内容。

图1：目标检测识别中常用的损失函数