超详细的语义分割中的Loss大盘点

#二值交叉熵，这里输入要经过sigmoid处理import torchimport torch.nn as nnimport torch.nn.functional as Fnn.BCELoss(F.sigmoid(input), target)#多分类交叉熵, 用这个 loss 前面不需要加 Softmax 层nn.CrossEntropyLoss(input, target)

class FocalLoss(nn.Module):    def __init__(self, gamma=0, alpha=None, size_average=True):        super(FocalLoss, self).__init__()        self.gamma = gamma        self.alpha = alpha        if isinstance(alpha,(float,int,long)): self.alpha = torch.Tensor([alpha,1-alpha])        if isinstance(alpha,list): self.alpha = torch.Tensor(alpha)        self.size_average = size_average
    def forward(self, input, target):        if input.dim()>2:            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C        target = target.view(-1,1)
        logpt = F.log_softmax(input)        logpt = logpt.gather(1,target)        logpt = logpt.view(-1)        pt = Variable(logpt.data.exp())
        if self.alpha is not None:            if self.alpha.type()!=input.data.type():                self.alpha = self.alpha.type_as(input.data)            at = self.alpha.gather(0,target.data.view(-1))            logpt = logpt * Variable(at)
        loss = -1 * (1-pt)**self.gamma * logpt        if self.size_average: return loss.mean()        else: return loss.sum()

import torch.nn as nnimport torch.nn.functional as F
class SoftDiceLoss(nn.Module):    def __init__(self, weight=None, size_average=True):        super(SoftDiceLoss, self).__init__()
    def forward(self, logits, targets):        num = targets.size(0)        // 为了防止除0的发生        smooth = 1
        probs = F.sigmoid(logits)        m1 = probs.view(num, -1)        m2 = targets.view(num, -1)        intersection = (m1 * m2)
        score = 2. * (intersection.sum(1) + smooth) / (m1.sum(1) + m2.sum(1) + smooth)        score = 1 - score.sum() / num        return score

def tversky(y_true, y_pred):    y_true_pos = K.flatten(y_true)    y_pred_pos = K.flatten(y_pred)    true_pos = K.sum(y_true_pos * y_pred_pos)    false_neg = K.sum(y_true_pos * (1-y_pred_pos))    false_pos = K.sum((1-y_true_pos)*y_pred_pos)    alpha = 0.7    return (true_pos + smooth)/(true_pos + alpha*false_neg + (1-alpha)*false_pos + smooth)
def tversky_loss(y_true, y_pred):    return 1 - tversky(y_true,y_pred)

def generalized_dice_coeff(y_true, y_pred):    Ncl = y_pred.shape[-1]    w = K.zeros(shape=(Ncl,))    w = K.sum(y_true, axis=(0,1,2))    w = 1/(w**2+0.000001)    # Compute gen dice coef:    numerator = y_true*y_pred    numerator = w*K.sum(numerator,(0,1,2,3))    numerator = K.sum(numerator)    denominator = y_true+y_pred    denominator = w*K.sum(denominator,(0,1,2,3))    denominator = K.sum(denominator)    gen_dice_coef = 2*numerator/denominator    return gen_dice_coefdef generalized_dice_loss(y_true, y_pred):    return 1 - generalized_dice_coeff(y_true, y_pred)

c'=0(c为常数）(x^a)'=ax^(a-1),a为常数且a≠0(a^x)'=a^xlna(e^x)'=e^x(logax)'=1/(xlna),a>0且 a≠1(lnx)'=1/x(sinx)'=cosx(cosx)'=-sinx(tanx)'=(secx)^2(secx)'=secxtanx(cotx)'=-(cscx)^2(cscx)'=-csxcotx(arcsinx)'=1/√(1-x^2)(arccosx)'=-1/√(1-x^2)(arctanx)'=1/(1+x^2)(arccotx)'=-1/(1+x^2)(shx)'=chx(chx)'=shx（uv)'=uv'+u'v(u+v)'=u'+v'(u/)'=(u'v-uv')/^2

#coding=utf-8import numpy as np
def softmax_loss_native(W, X, y, reg):    '''    Softmax_loss的暴力实现，利用了for循环    输入的维度是D，有C个分类类别，并且我们在有N个例子的batch上进行操作    输入:    - W: 一个numpy array，形状是(D, C)，代表权重    - X: 一个形状为(N, D)为numpy array，代表输入数据    - y: 一个形状为(N,)的numpy array，代表类别标签    - reg: (float)正则化参数    f返回:    - 一个浮点数代表Loss    - 和W形状一样的梯度    '''    loss = 0.0    dW = np.zeros_like(W) #dW代表W反向传播的梯度    num_classes = W.shape[1]    num_train = X.shape[0]    for i in xrange(num_train):        scores = X[i].dot(W)        shift_scores = scores - max(scores) #防止数值不稳定        loss_i = -shift_scores[y[i]] + np.log(sum(np.exp(shift_scores)))        loss += loss_i        for j in xrange(num_classes):            softmax_output = np.exp(shift_scores[j]) / sum(np.exp(shift_scores))            if j == y[i]:                dW[:, j] += (-1 + softmax_output) * X[i]            else:                dW[:, j] += softmax_output * X[i]    loss /= num_train    loss += 0.5 * reg * np.sum(W * W)    dW = dW / num_train + reg * W    return loss, dW
def softmax_loss_vectorized(W, X, y, reg):    loss = 0.0    dW = np.zeros_like(W)    num_class = W.shape[1]    num_train = X.shape[0]    scores = X.dot(W)    shift_scores = scores - np.max(scores, axis=1).reshape(-1, 1)    softmax_output  = np.exp(shift_scores) / np.sum(np.exp(shift_scores), axis=1).reshape(-1, 1)    loss = -np.sum(np.log(softmax_output[range(num_train), list(y)]))    loss /= num_train    loss += 0.5 * reg * np.sum(W * W)    dS = softmax_output.copy()    dS[range(num_train), list(y)] += -1    dW = (x.T).dot(dS)    dW = dW/num_train + reg*W    return loss, dW