基於BCEWithLogitsLoss樣本不均衡的處理方案

Posted on by

最近在做deepfake檢測任務（可以將其視為二分類問題，label為1和0），遇到瞭正負樣本不均衡的問題，正樣本數目是負樣本的5倍，這樣會導致FP率較高。

嘗試將正樣本的loss權重增高，看BCEWithLogitsLoss的源碼

Examples::
 
    >>> target = torch.ones([10, 64], dtype=torch.float32)  # 64 classes, batch size = 10
    >>> output = torch.full([10, 64], 0.999)  # A prediction (logit)
    >>> pos_weight = torch.ones([64])  # All weights are equal to 1
    >>> criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
    >>> criterion(output, target)  # -log(sigmoid(0.999))
    tensor(0.3135)
 
Args:
    weight (Tensor, optional): a manual rescaling weight given to the loss
        of each batch element. If given, has to be a Tensor of size `nbatch`.
    size_average (bool, optional): Deprecated (see :attr:`reduction`). By default,
        the losses are averaged over each loss element in the batch. Note that for
        some losses, there are multiple elements per sample. If the field :attr:`size_average`
        is set to ``False``, the losses are instead summed for each minibatch. Ignored
        when reduce is ``False``. Default: ``True``
    reduce (bool, optional): Deprecated (see :attr:`reduction`). By default, the
        losses are averaged or summed over observations for each minibatch depending
        on :attr:`size_average`. When :attr:`reduce` is ``False``, returns a loss per
        batch element instead and ignores :attr:`size_average`. Default: ``True``
    reduction (string, optional): Specifies the reduction to apply to the output:
        ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied,
        ``'mean'``: the sum of the output will be divided by the number of
        elements in the output, ``'sum'``: the output will be summed. Note: :attr:`size_average`
        and :attr:`reduce` are in the process of being deprecated, and in the meantime,
        specifying either of those two args will override :attr:`reduction`. Default: ``'mean'``
    pos_weight (Tensor, optional): a weight of positive examples.
            Must be a vector with length equal to the number of classes.

對其中的參數pos_weight的使用存在疑惑，BCEloss裡的例子pos_weight = torch.ones([64]) # All weights are equal to 1，不懂為什麼會有64個class，因為BCEloss是針對二分類問題的loss，後經過檢索，得知還有多標簽分類，

多標簽分類就是多個標簽，每個標簽有兩個label（0和1），這類任務同樣可以使用BCEloss。

現在講一下BCEWithLogitsLoss裡的pos_weight使用方法

比如我們有正負兩類樣本，正樣本數量為100個，負樣本為400個，我們想要對正負樣本的loss進行加權處理，將正樣本的loss權重放大4倍，通過這樣的方式緩解樣本不均衡問題。

criterion = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([4]))
 
# pos_weight (Tensor, optional): a weight of positive examples.
#            Must be a vector with length equal to the number of classes.

pos_weight裡是一個tensor列表，需要和標簽個數相同，比如我們現在是二分類，隻需要將正樣本loss的權重寫上即可。

如果是多標簽分類，有64個標簽，則

Examples::
 
    >>> target = torch.ones([10, 64], dtype=torch.float32)  # 64 classes, batch size = 10
    >>> output = torch.full([10, 64], 0.999)  # A prediction (logit)
    >>> pos_weight = torch.ones([64])  # All weights are equal to 1
    >>> criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
    >>> criterion(output, target)  # -log(sigmoid(0.999))
    tensor(0.3135)

補充：Pytorch —— BCEWithLogitsLoss()的一些問題

一、等價表達

1、pytorch：

torch.sigmoid() + torch.nn.BCELoss()

2、自己編寫

def ce_loss(y_pred, y_train, alpha=1):
    
    p = torch.sigmoid(y_pred)
    # p = torch.clamp(p, min=1e-9, max=0.99)  
    loss = torch.sum(- alpha * torch.log(p) * y_train \
           - torch.log(1 - p) * (1 - y_train))/len(y_train)
    return loss~

3、驗證

import torch
import torch.nn as nn
torch.cuda.manual_seed(300)       # 為當前GPU設置隨機種子
torch.manual_seed(300)            # 為CPU設置隨機種子
def ce_loss(y_pred, y_train, alpha=1):
   # 計算loss
   p = torch.sigmoid(y_pred)
   # p = torch.clamp(p, min=1e-9, max=0.99)
   loss = torch.sum(- alpha * torch.log(p) * y_train \
          - torch.log(1 - p) * (1 - y_train))/len(y_train)
   return loss
py_lossFun = nn.BCEWithLogitsLoss()
input = torch.randn((10000,1), requires_grad=True)
target = torch.ones((10000,1))
target.requires_grad_(True)
py_loss = py_lossFun(input, target)
py_loss.backward()
print("*********BCEWithLogitsLoss***********")
print("loss: ")
print(py_loss.item())
print("梯度: ")
print(input.grad)
input = input.detach()
input.requires_grad_(True)
self_loss = ce_loss(input, target)
self_loss.backward()
print("*********SelfCELoss***********")
print("loss: ")
print(self_loss.item())
print("梯度: ")
print(input.grad)

測試結果:

在這裡插入圖片描述

– 由上結果可知，我編寫的loss和pytorch中提供的j基本一致。

– 但是僅僅這樣就可以瞭嗎？NO! 下面介紹BCEWithLogitsLoss()的強大之處：

– BCEWithLogitsLoss()具有很好的對nan的處理能力，對於我寫的代碼（四層神經網絡，層之間的激活函數采用的是ReLU，輸出層激活函數采用sigmoid(），由於數據處理的問題，所以會導致我們編寫的CE的loss出現nan：原因如下：

–首先神經網絡輸出的pre_target較大，就會導致sigmoid之後的p為1，則torch.log(1 – p)為nan；

– 使用clamp(函數雖然會解除這個nan，但是由於在迭代過程中，網絡輸出可能越來越大（層之間使用的是ReLU），則導致我們寫的loss陷入到某一個數值而無法進行優化。但是BCEWithLogitsLoss()對這種情況下出現的nan有很好的處理，從而得到更好的結果。

– 我此實驗的目的是為瞭比較CE和FL的區別，自己編寫FL，則必須也要自己編寫CE，不能使用BCEWithLogitsLoss()。

二、使用場景

二分類 + sigmoid()

使用sigmoid作為輸出層非線性表達的分類問題（雖然可以處理多分類問題，但是一般用於二分類，並且最後一層隻放一個節點）

三、註意事項

輸入格式

要求輸入的input和target均為float類型

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

推薦閱讀：