我发现，手写损失函数一般都会运用到很多稍微复杂一些的张量操作，很适合用来学习pytorch张量操作，所以这里分析几个常用损失函数练习一下。

1. Binary Cross Entropy Loss

BCELoss的计算公式很简单：

BCE公式

这里我们按照公式简单实现一下就可以：

class BCELosswithLogits(nn.Module):
    def __init__(self, pos_weight=1, reduction='mean'):
        super(BCELosswithLogits, self).__init__()
        self.pos_weight = pos_weight
        self.reduction = reduction

    def forward(self, logits, target):
        # logits: [N, *], target: [N, *]
        logits = F.sigmoid(logits)
        loss = - self.pos_weight * target * torch.log(logits) - \
               (1 - target) * torch.log(1 - logits)
        if self.reduction == 'mean':
            loss = loss.mean()
        elif self.reduction == 'sum':
            loss = loss.sum()
        return loss

输入target为ground truth，logits为未经过sigmoid激活的网络输出，运用公式计算出的loss形状和logits相同，运用mean或sum方法将其变为一个数值。self.pos_weight调整正样本的计算比例。
pytorch官方提供了BCEWithLogitsLoss类，除了二分类之外，还可以用于多标签分类，此时target形状为N * C，logits形状也是N * C。这种用法通常见于multi-label任务中，类间没有竞争关系。

2. Cross Entropy Loss

Cross Entropy Loss一般用于多分类任务，其计算公式如下图所示，其中yi等于1（第i个样本是否属于每一类，不属于的都等于0了，不会算到loss里），log括号里一大堆（不想写了）表示第i个样本对应logits中，其gt所属那一类的分类置信度，比如第i个样本是第5类，一共有C个类别，那么括号里的一堆就是一个C维向量里的第5个元素。
因此，交叉熵损失计算的其实就是每个样本所属实际类别对应分类置信度的负对数，也就是模型分对的可能性有多高。交叉熵损失只能用于标签唯一的分类任务，因为类间是要做softmax归一化的，那么如果其中一类的置信度很高，对应的其他类别的置信度就变低了，类间存在竞争关系。

class CrossEntropyLoss(torch.nn.Module):
    def __init__(self, reduction='mean'):
        super(CrossEntropyLoss, self).__init__()
        self.reduction = reduction
    def forward(self, logits, target):
        # logits: [N, C, H, W], target: [N, H, W]
        # loss = sum(-y_i * log(c_i))
        if logits.dim() > 2:
            logits = logits.view(logits.size(0), logits.size(1), -1)  # [N, C, HW]
            logits = logits.transpose(1, 2)   # [N, HW, C]
            logits = logits.contiguous().view(-1, logits.size(2))    # [NHW, C]
        target = target.view(-1, 1)    # [NHW，1]

        logits = F.log_softmax(logits, 1)
        logits = logits.gather(1, target)   # [NHW, 1]
        loss = -1 * logits

        if self.reduction == 'mean':
            loss = loss.mean()
        elif self.reduction == 'sum':
            loss = loss.sum()
        return loss

3. Focal BCE Loss

二分类的focal loss计算公式如下图所示，与BCE loss的区别在于，每一项前面乘了(1-pt)^gamma，也就是该样本的分类难度，值越大，说明模型分的越不准，需要增大其loss权重；并且为了进一步平衡正负样本，还乘了alpha来调节。

二分类的focal loss代码实现跟bceloss差不多。

class BCEFocalLosswithLogits(nn.Module):
    def __init__(self, gamma=0.2, alpha=0.6, reduction='mean'):
        super(BCEFocalLosswithLogits, self).__init__()
        self.gamma = gamma
        self.alpha = alpha
        self.reduction = reduction

    def forward(self, logits, target):
        # logits: [N, H, W], target: [N, H, W]
        logits = F.sigmoid(logits)
        alpha = self.alpha
        gamma = self.gamma
        loss = - alpha * (1 - logits) ** gamma * target * torch.log(logits) - \
               (1 - alpha) * logits ** gamma * (1 - target) * torch.log(1 - logits)
        if self.reduction == 'mean':
            loss = loss.mean()
        elif self.reduction == 'sum':
            loss = loss.sum()
        return loss

4. Focal CE Loss

代码参考：https://github.com/clcarwin/focal_loss_pytorch/blob/master/focalloss.py

class CrossEntropyFocalLoss(nn.Module):
    def __init__(self, alpha=None, gamma=0.2, reduction='mean'):
        super(CrossEntropyFocalLoss, self).__init__()
        self.reduction = reduction
        self.alpha = alpha
        self.gamma = gamma

    def forward(self, logits, target):
        # logits: [N, C, H, W], target: [N, H, W]
        # loss = sum(-y_i * log(c_i))
        if logits.dim() > 2:
            logits = logits.view(logits.size(0), logits.size(1), -1)  # [N, C, HW]
            logits = logits.transpose(1, 2)   # [N, HW, C]
            logits = logits.contiguous().view(-1, logits.size(2))    # [NHW, C]
        target = target.view(-1, 1)    # [NHW，1]

        pt = F.softmax(logits, 1)
        pt = pt.gather(1, target).view(-1)   # [NHW]
        log_gt = torch.log(pt)

        if self.alpha is not None:
            # alpha: [C]
            alpha = self.alpha.gather(0, target.view(-1))   # [NHW]
            log_gt = log_gt * alpha
            
        loss = -1 * (1 - pt) ** self.gamma * log_gt

        if self.reduction == 'mean':
            loss = loss.mean()
        elif self.reduction == 'sum':
            loss = loss.sum()
        return loss

一些比较不常用的张量操作

• torch.gather
  torch.gather(input, dim, index, *, sparse_grad=False, out=None) → Tensor
  输入input，利用index选择input中的元素，并组成out输出。这里假设input是一个d1 * d2 * d3的张量：
  dim=0，即在第0维进行选择，则index的尺寸应该为1 * d2 * d3，每次在d1个元素中选择一个，输出out尺寸也为1 * d2 * d3；
  dim=1或2也类似，下面是pytorch官方文档的描述，out和index的形状是一样的。
  

• torch.cumsum
  torch.cumsum(input, dim, *, dtype=None, out=None) → Tensor
  输入input，对指定维度进行累加。比如：
  

  
  通常

• torch.full
  torch.full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
  创建size大小的张量，张量的每个元素都为fill_value。

• torch.empty(size).random_(N)：生成size大小的张量，每个张量值为不超过N的随机int。

• torch.diag()：求矩阵的对角元素