1.交叉熵损失

交叉熵损失在pytorch中有直接的实现
一般我们搜索交叉熵损失都会搜到二分类的交叉熵损失

y'是经过sigmoid激活函数的输出，所以在0-1之间,对应预测样本为类别1的概率，1-y'就是对应预测样本为类别0的概率。
普通的交叉熵对于正样本而言，输出概率越大损失越小。对于负样本而言，输出概率越小则损失越小。
但上面的公式并不对应pytorch中的交叉熵损失
因为上面公式认为y'就一个值，而实际网络输出有多少类对应于有多少个y'，可以说是
然后交叉熵损失就是

现在看看pytorch的交叉熵损失实现

只看部分
和上面也不一样
其实括号里面的一堆就是 ，只不过是对网络输出做了一个softmax，让其值在0-1之间，对应预测样本为类别 的概率

loss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.empty(3, dtype=torch.long).random_(5)
output = loss(input, target)

存在的问题：
当负样本数量太大，占总的loss的大部分，而且多是容易分类的，因此使得模型的优化方向并不是我们所希望的那样。
改进：加权重
nn.CrossEntropyLoss()有一个参数weight

2.Focal Loss

Focal loss主要是为了解决正负样本比例严重失衡的问题。该损失函数降低了大量简单负样本在训练中所占的权重，也可理解为一种困难样本挖掘

原文写作：

Focal Loss

Focal Loss加权重

class FocalLoss(nn.Module):
    def __init__(self, gamma=2, alpha=None, ignore_index=255, size_average=True):
        super(FocalLoss, self).__init__()
        self.gamma = gamma
        self.size_average = size_average
        self.CE_loss = nn.CrossEntropyLoss(ignore_index=ignore_index, weight=alpha)

    def forward(self, output, target):
        logpt = self.CE_loss(output, target)
        pt = torch.exp(-logpt)
        loss = ((1 - pt) ** self.gamma) * logpt
        if self.size_average:
            return loss.mean()
        return loss.sum()

3.DiceLoss

Dice系数，是一种集合相似度度量函数，通常用于计算两个样本的相似度（范围为[0, 1]）

dice coefficient

dice loss

image.png

image.png

image.png

image.png

def make_one_hot(labels, classes):
    one_hot = torch.FloatTensor(labels.size()[0], classes, labels.size()[2], labels.size()[3]).zero_().to(labels.device)
    target = one_hot.scatter_(1, labels.data, 1)
    return target


class DiceLoss(nn.Module):
    def __init__(self, smooth=1., ignore_index=255):
        super(DiceLoss, self).__init__()
        self.ignore_index = ignore_index
        self.smooth = smooth

    def forward(self, output, target):
        if self.ignore_index not in range(target.min(), target.max()):
            if (target == self.ignore_index).sum() > 0:
                target[target == self.ignore_index] = target.min()
        target = make_one_hot(target.unsqueeze(dim=1), classes=output.size()[1])
        output = F.softmax(output, dim=1)
        output_flat = output.contiguous().view(-1)
        target_flat = target.contiguous().view(-1)
        intersection = (output_flat * target_flat).sum()
        loss = 1 - ((2. * intersection + self.smooth) /
                    (output_flat.sum() + target_flat.sum() + self.smooth))
        return loss

LovaszLoss

1

参考：
https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html#torch.nn.CrossEntropyLoss
https://www.cnblogs.com/king-lps/p/9497836.html
https://zhuanlan.zhihu.com/p/57008984
https://zhuanlan.zhihu.com/p/94326225
https://blog.csdn.net/xijuezhu8128/article/details/111164936