Ref:

1. https://openaccess.thecvf.com/content_ICCV_2017/papers/Lin_Focal_Loss_for_ICCV_2017_paper.pdf
2. https://zhuanlan.zhihu.com/p/80594704
3. https://arxiv.org/pdf/1811.05181.pdf

背景

工作中處理二分類問(wèn)題，數(shù)據(jù)大多是長(zhǎng)尾分布，即正樣本遠(yuǎn)小于負(fù)樣本。一般來(lái)說(shuō)，通過(guò)調(diào)整閾值（置信度），就可以滿足上線需求。但總是有一些正樣本，得分較低，希望找到一些辦法，提高這些得分很低的正例分?jǐn)?shù)，且負(fù)樣本得分不被拉高太多。

模型通過(guò)梯度更新進(jìn)行訓(xùn)練，實(shí)際應(yīng)用中，大部分的樣本是容易區(qū)分的，而這些樣本貢獻(xiàn)了主要的loss，模型偏向于這些樣本，在部分難區(qū)分的樣本上效果不好。

所以，為提高模型效果，要解決兩個(gè)問(wèn)題：

1. 如何處理樣本不均衡問(wèn)題？
2. 如何有效處理{正難，負(fù)難}的樣本？

Focal Loss

主要應(yīng)用在目標(biāo)檢測(cè)，實(shí)際應(yīng)用范圍很廣。
分類問(wèn)題中，常見的loss是cross-entropy：

為了解決正負(fù)樣本不均衡,乘以權(quán)重：

一般根據(jù)各類別數(shù)據(jù)占比，對(duì)進(jìn)行取值，即當(dāng)class_1占比為30%時(shí)，。

我們希望模型能更關(guān)注容易錯(cuò)分的數(shù)據(jù)，反向思考，就是讓模型別那么關(guān)注容易分類的樣本。因此，F(xiàn)ocal Loss的思路就是，把高置信度的樣本損失降低。

多分類樣本：

不同取值情況如下圖：

from paper

模型是如何通過(guò)控制損失的衰減的呢？

當(dāng)樣本被誤分類時(shí)，p很小，很大，loss不怎么受影響。當(dāng)樣本被正確分類，p很大，變小，loss衰減。
比如：當(dāng)，，p為0.9時(shí)，，這個(gè)容易分類的樣本，損失和cross-entropy相比，衰減了100倍。

代碼

# 二分類
class BCEFocalLoss(torch.nn.Module):
    """
    https://github.com/louis-she/focal-loss.pytorch/blob/master/focal_loss.py
    二分類的Focalloss alpha 固定
    """
    def __init__(self, gamma=2, alpha=0.25, reduction='sum'):
        super().__init__()
        self.gamma = gamma
        self.alpha = alpha
        self.reduction = reduction
 
    def forward(self, preds, targets):
        "preds:[B,C],targets:[B]"
        pt = torch.sigmoid(preds)
        pt = pt.clamp(min=0.0001,max = 1.0) # 概率過(guò)低，logpt后，loss返回nan
        # 我在gpu上使用時(shí)，不加.to(targets.device)，報(bào)錯(cuò)
        targets = torch.zeros(targets.size(0),2).to(targets.device).scatter_(1,targets.view(-1,1),1) 
        loss = - self.alpha * (1 - pt) ** self.gamma * targets * torch.log(pt) - \
               (1 - self.alpha) * pt ** self.gamma * (1 - targets) * torch.log(1 - pt)
        if self.reduction == 'elementwise_mean':
            loss = torch.mean(loss)
        elif self.reduction == 'sum':
            loss = torch.sum(loss)
        return loss

# 多分類
class FocalLoss(nn.Module):
    """ 
        Ref: https://github.com/yatengLG/Focal-Loss-Pytorch/blob/master/Focal_Loss.py
        FL(pt) = -alpha_t(1-pt)^gamma log(pt)
        alpha: 類別權(quán)重,常數(shù)時(shí)，類別權(quán)重為:[alpha,1-alpha,1-alpha,...]；列表時(shí)，表示對(duì)應(yīng)類別權(quán)重
        gamma: 難易分類的樣本權(quán)重，使得模型更關(guān)注難分類的樣本
        優(yōu)點(diǎn)：幫助區(qū)分難分類的不均衡樣本數(shù)據(jù)
    """
    def __init__(self, num_classes, alpha=0.25,gamma=2,reduce=True):

        super(FocalLoss,self).__init__()

        self.num_classes = num_classes
        self.gamma = gamma
        self.reduce = reduce 

        if alpha is None:
            self.alpha = torch.ones(self.num_classes,1)
        else:
            self.alpha = torch.zeros(num_classes)
            self.alpha[0] = alpha 
            self.alpha[1:] += (1-alpha)
    
    def forward(self,preds,targets):
        "preds:[B,C],targets:[B]"
        preds = preds.view(-1,preds.size(-1)) #[B,C]
        self.alpha = self.alpha.to(preds.device)
        logpt = F.log_softmax(preds,dim=1) 
        pt = F.softmax(preds).clamp(min=0.0001,max=1.0) 

        logpt = logpt.gather(1,targets.view(-1,1)) # 對(duì)應(yīng)類別值
        pt = pt.gather(1,targets.view(-1,1)) 
        self.alpha = self.alpha.gather(0,targets.view(-1))

        loss = -(1-pt) **self.gamma *logpt
        loss = self.alpha*loss.t()

        if self.reduce:
            return loss.mean()
        else:
            return loss.sum(）

GHM - gradient harmonizing mechanism

Focal Loss對(duì)容易分類的樣本進(jìn)行了損失衰減，讓模型更關(guān)注難分樣本，并通過(guò)和進(jìn)行調(diào)參。

GHM提到：

1. 有一部分難分樣本就是離群點(diǎn)，不應(yīng)該給他太多關(guān)注；
2. 梯度密度可以直接統(tǒng)計(jì)得到，不需要調(diào)參。

GHM認(rèn)為，類別不均衡可總結(jié)為難易分類樣本的不均衡，而這種難分樣本的不均衡又可視為梯度密度分布的不均衡。假設(shè)一個(gè)正樣本被正確分類，它就是正易樣本，損失不大，模型不能從中獲益。而一個(gè)錯(cuò)誤分類的樣本，更能促進(jìn)模型迭代。實(shí)際應(yīng)用中，大量的樣本都是屬于容易分類的類型，這種樣本一個(gè)起不了太大作用，但量級(jí)過(guò)大，在模型進(jìn)行梯度更新時(shí)，起主要作用，使得模型朝這類數(shù)據(jù)更新。

from paper

• 圖示左，樣本梯度分布。
  梯度模長(zhǎng)（gradient norm）在很小和很大時(shí)，密度較大。前者，表示了大量容易分類的樣本，所以梯度很低。而后者，文中認(rèn)為是離群點(diǎn)，即便模型收斂，損失仍然很大。
• 圖示中，經(jīng)過(guò)修正后的梯度分布。
  和CE,FL相比，GHM-C根據(jù)梯度密度，大量容易分類的樣本和離群點(diǎn)的累計(jì)梯度被降級(jí)，達(dá)到樣本均衡，使得模型更加有效穩(wěn)定。
• 圖示右，樣本集梯度貢獻(xiàn)。
  經(jīng)過(guò)GHM-C的梯度密度調(diào)整，各種難易分類的樣本分布更加平滑。

簡(jiǎn)而言之：Focal Loss是從置信度p來(lái)調(diào)整loss，GHM通過(guò)一定范圍置信度p的樣本數(shù)來(lái)調(diào)整loss。

梯度模長(zhǎng)

梯度模長(zhǎng):原文中用表示真實(shí)標(biāo)簽，這里統(tǒng)一符號(hào)，用y表示：

推理：



則：

梯度密度（Gradient Density）

梯度模長(zhǎng)分布不均，引入梯度密度：

在N個(gè)樣本中，梯度模長(zhǎng)分布在范圍的個(gè)數(shù)：

區(qū)間長(zhǎng)度:
梯度密度協(xié)調(diào)參數(shù)：
上式分母，可視為對(duì)附近樣本進(jìn)行歸一化。如果梯度分布均勻，則，如果密度過(guò)高，則意味著要降級(jí)處理。

GHM loss計(jì)算

代碼

def _expand_binary_labels(labels,label_weights,label_channels):
    bin_labels = labels.new_full((labels.size(0), label_channels),0)
    inds = torch.nonzero(labels>=1).squeeze()
    if inds.numel() >0:
        bin_labels[inds,labels[inds]] = 1
    bin_label_weights = label_weights.view(-1,1).expand(label_weights.size(0),label_channels)
    return bin_labels, bin_label_weights
class GHMC(nn.Module):
    """GHM Classification Loss.
    Ref:https://github.com/libuyu/mmdetection/blob/master/mmdet/models/losses/ghm_loss.py
    Details of the theorem can be viewed in the paper
    "Gradient Harmonized Single-stage Detector".
    https://arxiv.org/abs/1811.05181

    Args:
        bins (int): Number of the unit regions for distribution calculation.
        momentum (float): The parameter for moving average.
        use_sigmoid (bool): Can only be true for BCE based loss now.
        loss_weight (float): The weight of the total GHM-C loss.
    """

    def __init__(self, bins=10, momentum=0, use_sigmoid=True, loss_weight=1.0,alpha=None):
        super(GHMC, self).__init__()
        self.bins = bins
        self.momentum = momentum
        edges = torch.arange(bins + 1).float() / bins
        self.register_buffer('edges', edges)
        self.edges[-1] += 1e-6
        if momentum > 0:
            acc_sum = torch.zeros(bins)
            self.register_buffer('acc_sum', acc_sum)
        self.use_sigmoid = use_sigmoid
        if not self.use_sigmoid:
            raise NotImplementedError
        self.loss_weight = loss_weight

        self.label_weight = alpha

    def forward(self, pred, target, label_weight =None, *args, **kwargs):
        """Calculate the GHM-C loss.
          
        Args:
            pred (float tensor of size [batch_num, class_num]):
                The direct prediction of classification fc layer.
            target (float tensor of size [batch_num, class_num]):
                Binary class target for each sample.
            label_weight (float tensor of size [batch_num, class_num]):
                the value is 1 if the sample is valid and 0 if ignored.
        Returns:
            The gradient harmonized loss.
        """
        # the target should be binary class label

        # if pred.dim() != target.dim():
        #     target, label_weight = _expand_binary_labels(
        #     target, label_weight, pred.size(-1))

        # 我的pred輸入為[B,C]，target輸入為[B]
        target = torch.zeros(target.size(0),2).to(target.device).scatter_(1,target.view(-1,1),1)
        
        # 暫時(shí)不清楚這個(gè)label_weight輸入形式，默認(rèn)都為1
        if label_weight is None:
            label_weight = torch.ones([pred.size(0),pred.size(-1)]).to(target.device)

        target, label_weight = target.float(), label_weight.float()
        edges = self.edges
        mmt = self.momentum
        weights = torch.zeros_like(pred)

        # gradient length
        # sigmoid梯度計(jì)算
        g = torch.abs(pred.sigmoid().detach() - target)
        # 有效的label的位置
        valid = label_weight > 0
        # 有效的label的數(shù)量
        tot = max(valid.float().sum().item(), 1.0)
        n = 0  # n valid bins
        for i in range(self.bins):
            # 將對(duì)應(yīng)的梯度值劃分到對(duì)應(yīng)的bin中， 0-1
            inds = (g >= edges[i]) & (g < edges[i + 1]) & valid
            # 該bin中存在多少個(gè)樣本
            num_in_bin = inds.sum().item()
            if num_in_bin > 0:
                if mmt > 0:
                    # moment計(jì)算num bin
                    self.acc_sum[i] = mmt * self.acc_sum[i] \
                        + (1 - mmt) * num_in_bin
                    # 權(quán)重等于總數(shù)/num bin
                    weights[inds] = tot / self.acc_sum[i]
                else:
                    weights[inds] = tot / num_in_bin
                n += 1
        if n > 0:
            # scale系數(shù)
            weights = weights / n

        loss = F.binary_cross_entropy_with_logits(
            pred, target, weights, reduction='sum') / tot
        return loss * self.loss_weight