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

背景

工作中處理二分類問題，數據大多是長尾分布，即正樣本遠小于負樣本。一般來說，通過調整閾值（置信度），就可以滿足上線需求。但總是有一些正樣本，得分較低，希望找到一些辦法，提高這些得分很低的正例分數，且負樣本得分不被拉高太多。

模型通過梯度更新進行訓練，實際應用中，大部分的樣本是容易區分的，而這些樣本貢獻了主要的loss，模型偏向于這些樣本，在部分難區分的樣本上效果不好。

所以，為提高模型效果，要解決兩個問題：

1. 如何處理樣本不均衡問題？
2. 如何有效處理{正難，負難}的樣本？

Focal Loss

主要應用在目標檢測，實際應用范圍很廣。
分類問題中，常見的loss是cross-entropy：

為了解決正負樣本不均衡,乘以權重：

一般根據各類別數據占比，對進行取值，即當class_1占比為30%時，。

我們希望模型能更關注容易錯分的數據，反向思考，就是讓模型別那么關注容易分類的樣本。因此，Focal Loss的思路就是，把高置信度的樣本損失降低。

多分類樣本：

不同取值情況如下圖：

from paper

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

當樣本被誤分類時，p很小，很大，loss不怎么受影響。當樣本被正確分類，p很大，變小，loss衰減。
比如：當，，p為0.9時，，這個容易分類的樣本，損失和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) # 概率過低，logpt后，loss返回nan
        # 我在gpu上使用時，不加.to(targets.device)，報錯
        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: 類別權重,常數時，類別權重為:[alpha,1-alpha,1-alpha,...]；列表時，表示對應類別權重
        gamma: 難易分類的樣本權重，使得模型更關注難分類的樣本
        優點：幫助區分難分類的不均衡樣本數據
    """
    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)) # 對應類別值
        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對容易分類的樣本進行了損失衰減，讓模型更關注難分樣本，并通過和進行調參。

GHM提到：

1. 有一部分難分樣本就是離群點，不應該給他太多關注；
2. 梯度密度可以直接統計得到，不需要調參。

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

from paper

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

簡而言之：Focal Loss是從置信度p來調整loss，GHM通過一定范圍置信度p的樣本數來調整loss。

梯度模長

梯度模長:原文中用表示真實標簽，這里統一符號，用y表示：

推理：



則：

梯度密度（Gradient Density）

梯度模長分布不均，引入梯度密度：

在N個樣本中，梯度模長分布在范圍的個數：

區間長度:
梯度密度協調參數：
上式分母，可視為對附近樣本進行歸一化。如果梯度分布均勻，則，如果密度過高，則意味著要降級處理。

GHM loss計算

代碼

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)
        
        # 暫時不清楚這個label_weight輸入形式，默認都為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梯度計算
        g = torch.abs(pred.sigmoid().detach() - target)
        # 有效的label的位置
        valid = label_weight > 0
        # 有效的label的數量
        tot = max(valid.float().sum().item(), 1.0)
        n = 0  # n valid bins
        for i in range(self.bins):
            # 將對應的梯度值劃分到對應的bin中， 0-1
            inds = (g >= edges[i]) & (g < edges[i + 1]) & valid
            # 該bin中存在多少個樣本
            num_in_bin = inds.sum().item()
            if num_in_bin > 0:
                if mmt > 0:
                    # moment計算num bin
                    self.acc_sum[i] = mmt * self.acc_sum[i] \
                        + (1 - mmt) * num_in_bin
                    # 權重等于總數/num bin
                    weights[inds] = tot / self.acc_sum[i]
                else:
                    weights[inds] = tot / num_in_bin
                n += 1
        if n > 0:
            # scale系數
            weights = weights / n

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