损失函数理解汇总，结合PyTorch和TensorFlow2

以你之姓@ 2022-11-21 11:35 315阅读 0赞

### 点击下方标题，迅速定位到你感兴趣的内容 ###

*  前言
 *  交叉熵损失（CrossEntropyLoss）
 *  KL散度
 *  平均绝对误差（L1范数损失）
 *  均方误差损失（L2范数损失）
 *  Hinge loss
 *  余弦相似度

--------------------

# 前言 #

> 说明：讲解时会对相关文章资料进行思想、结构、优缺点，内容进行提炼和记录，相关引用会标明出处，引用之处如有侵权，烦请告知删除。  
> 转载请注明：DengBoCong

本文打算讨论在深度学习中常用的十余种损失函数（含变种），结合PyTorch和TensorFlow2对其概念、公式及用途进行阐述，希望能达到看过的伙伴对各种损失函数有个大致的了解以及使用。本文对原理只是浅尝辄止，不进行深挖，感兴趣的伙伴可以针对每个部分深入翻阅资料。

使用版本：

*  TensorFlow2.3
 *  PyTorch1.7.0

# 交叉熵损失（CrossEntropyLoss） #

对于单事件的信息量而言，当事件发生的概率越大时，信息量越小，需要明确的是，信息量是对于单个事件来说的，实际事件存在很多种可能，所以这个时候熵就派上用场了，熵是表示随机变量不确定的度量，是对所有可能发生的事件产生的信息量的期望。**交叉熵用来描述两个分布之间的差距，交叉熵越小，假设分布离真实分布越近，模型越好**。

在分类问题模型中（不一定是二分类），如逻辑回归、神经网络等，在这些模型的最后通常会经过一个sigmoid函数（softmax函数），输出一个概率值（一组概率值），这个概率值反映了预测为正类的可能性（一组概率值反应了所有分类的可能性）。而对于预测的概率分布和真实的概率分布之间，使用交叉熵来计算他们之间的差距，换句不严谨的话来说，交叉熵损失函数的输入，是softmax或者sigmoid函数的输出。交叉熵损失可以从理论公式推导出几个结论（优点），具体公式推导不在这里详细讲解，如下：

*  预测的值跟目标值越远时，参数调整就越快，收敛就越快；
 *  不会陷入局部最优解

交叉熵损失函数的标准形式（也就是二分类交叉熵损失）如下:  
 L = 1 N ∑ i L i = 1 N ∑ i − \[ y i ⋅ l o g ( p i ) + ( 1 − y i ) ⋅ l o g ( 1 − p i ) \] L = \\frac\{1\}\{N\}\\sum\_\{i\}L\_i=\\frac\{1\}\{N\}\\sum\_\{i\}-\[y\_i\\cdot log(p\_i)+(1-y\_i)\\cdot log(1-p\_i)\] L=N1i∑Li=N1i∑−\[yi⋅log(pi)\+(1−yi)⋅log(1−pi)\]  
其中， y i y\_i yi 表示样本  i i i 的标签，正类为1，负类为0， p i p\_i pi 表示样本  i i i 预测为正的概率。  
多分类交叉熵损失如下：  
 L = 1 N ∑ i L i = 1 N ∑ i − ∑ c = 1 M y i c l o g ( p i c ) L=\\frac\{1\}\{N\}\\sum\_\{i\}L\_i=\\frac\{1\}\{N\}\\sum\_\{i\}-\\sum\_\{c=1\}^\{M\}y\_\{ic\}log(p\_\{ic\}) L=N1i∑Li=N1i∑−c=1∑Myiclog(pic)  
其中， M M M 表示类别的数量， y i c y\_\{ic\} yic 表示变量（0或1），如果该类别和样本i的类别相同就是1，否则是0， p i c p\_\{ic\} pic 表示对于观测样本  i i i 属于类别  c c c 的预测概率。

**TensorFlow：**

*  [BinaryCrossentropy][]：二分类，经常搭配Sigmoid使用

tf.keras.losses.BinaryCrossentropy(from_logits=False, label_smoothing=0, reduction=losses_utils.ReductionV2.AUTO, name='binary_crossentropy')
    参数：
    	from_logits：默认False。为True，表示接收到了原始的logits，为False表示输出层经过了概率处理（softmax）
    	label_smoothing：[0,1]之间浮点值，加入噪声，减少了真实样本标签的类别在计算损失函数时的权重，最终起到抑制过拟合的效果。
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [binary\_crossentropy][binary_crossentropy]

tf.keras.losses.binary_crossentropy(y_true, y_pred, from_logits=False, label_smoothing=0)
    参数：
    	from_logits：默认False。为True，表示接收到了原始的logits，为False表示输出层经过了概率处理（softmax）
    	label_smoothing：[0,1]之间浮点值，加入噪声，减少了真实样本标签的类别在计算损失函数时的权重，最终起到抑制过拟合的效果。

*  [CategoricalCrossentropy][]：多分类，经常搭配Softmax使用

tf.keras.losses.CategoricalCrossentropy(from_logits=False, label_smoothing=0, reduction=losses_utils.ReductionV2.AUTO, name='categorical_crossentropy')
    参数：
    	from_logits：默认False。为True，表示接收到了原始的logits，为False表示输出层经过了概率处理（softmax）
    	label_smoothing：[0,1]之间浮点值，加入噪声，减少了真实样本标签的类别在计算损失函数时的权重，最终起到抑制过拟合的效果。
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [categorical\_crossentropy][categorical_crossentropy]

tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=False, label_smoothing=0)
    参数：
    	from_logits：默认False。为True，表示接收到了原始的logits，为False表示输出层经过了概率处理（softmax）
    	label_smoothing：[0,1]之间浮点值，加入噪声，减少了真实样本标签的类别在计算损失函数时的权重，最终起到抑制过拟合的效果。

*  [SparseCategoricalCrossentropy][]：多分类，经常搭配Softmax使用，和CategoricalCrossentropy不同之处在于，CategoricalCrossentropy是one-hot编码，而SparseCategoricalCrossentropy使用一个位置整数表示类别

tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False, reduction=losses_utils.ReductionV2.AUTO, name='sparse_categorical_crossentropy')
    参数：
    	from_logits：默认False。为True，表示接收到了原始的logits，为False表示输出层经过了概率处理（softmax）
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [sparse\_categorical\_crossentropy][sparse_categorical_crossentropy]

tf.keras.losses.sparse_categorical_crossentropy(y_true, y_pred, from_logits=False, axis=-1)
    参数：
    	from_logits：默认False。为True，表示接收到了原始的logits，为False表示输出层经过了概率处理（softmax）
    	axis：默认是-1，计算交叉熵的维度

**PyTorch：**

*  [BCELoss][]

torch.nn.BCELoss(weight: Optional[torch.Tensor] = None, size_average=None, reduce=None, reduction: str = 'mean')
    参数：
    	weight：每个分类的缩放权重，传入的大小必须和类别数量一至
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction：string类型，'none' | 'mean' | 'sum'三种参数值

*  [BCEWithLogitsLoss][]：其实和TensorFlow是的`from_logits`参数很像，在BCELoss的基础上合并了Sigmoid

torch.nn.BCEWithLogitsLoss(weight: Optional[torch.Tensor] = None, size_average=None, reduce=None, reduction: str = 'mean', pos_weight: Optional[torch.Tensor] = None)
    参数：
    	weight：每个分类的缩放权重，传入的大小必须和类别数量一至
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction：string类型，'none' | 'mean' | 'sum'三种参数值
    	pos_weight：正样本的权重, 当p>1，提高召回率，当p<1，提高精确度。可达到权衡召回率(Recall)和精确度(Precision)的作用。

*  [CrossEntropyLoss][]

torch.nn.CrossEntropyLoss(weight: Optional[torch.Tensor] = None, size_average=None, ignore_index: int = -100, reduce=None, reduction: str = 'mean')
    参数：
    	weight：每个分类的缩放权重，传入的大小必须和类别数量一至
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	ignore_index：忽略某一类别，不计算其loss，其loss会为0，并且，在采用size_average时，不会计算那一类的loss，除的时候的分母也不会统计那一类的样本
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction：string类型，'none' | 'mean' | 'sum'三种参数值

# KL散度 #

我们在计算预测和真实标签之间损失时，需要拉近他们分布之间的差距，即模型得到的预测分布应该与数据的实际分布情况尽可能相近。KL散度(相对熵)是用来衡量两个概率分布之间的差异。模型需要得到最大似然估计，乘以负Log以后就相当于求最小值，此时等价于求最小化KL散度(相对熵)。所以得到KL散度就得到了最大似然。又因为KL散度中包含两个部分，第一部分是交叉熵，第二部分是信息熵，即KL=交叉熵−信息熵。信息熵是消除不确定性所需信息量的度量，简单来说就是真实的概率分布，而这部分是固定的，所以优化KL散度就是近似于优化交叉熵。下面是KL散度的公式：  
 D K L ( p ∣ ∣ q ) = ∑ i = 1 N p ( x i ) ⋅ ( l o g p ( x i ) − l o g q ( x i ) ) D\_\{KL\}(p||q)=\\sum\_\{i=1\}^Np(x\_i)\\cdot (logp(x\_i)-logq(x\_i)) DKL(p∣∣q)=i=1∑Np(xi)⋅(logp(xi)−logq(xi))  
联系上面的交叉熵，我们可以将公式简化为（KL散度 = 交叉熵 - 熵）：  
 D K L ( A ∣ ∣ B ) = H ( A , B ) − S ( A ) D\_\{KL\}(A||B)=H(A,B)-S(A) DKL(A∣∣B)=H(A,B)−S(A)  
监督学习中，因为训练集中每个样本的标签是已知的，此时标签和预测的标签之间的KL散度等价于交叉熵。  
**TensorFlow：**

*  [KLD | kullback\_leibler\_divergence][KLD _ kullback_leibler_divergence]

tf.keras.losses.KLD(y_true, y_pred)

*  [KLDivergence][]

tf.keras.losses.KLDivergence(reduction=losses_utils.ReductionV2.AUTO, name='kl_divergence')
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

**Pytorch：**

*  [KLDivLoss][]

torch.nn.KLDivLoss(size_average=None, reduce=None, reduction: str = 'mean', log_target: bool = False)
    参数：
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean
    	log_target：默认False，指定是否在日志空间中传递目标

# 平均绝对误差（L1范数损失） #

L1范数损失函数，也被称为最小绝对值偏差（LAD），最小绝对值误差（LAE）。总的说来，它是把目标值  Y i Y\_i Yi 与估计值  f ( x i ) f(x\_i) f(xi) 的绝对差值的总和  S S S 最小化：  
 S = ∑ i = 1 n ∣ Y i − f ( x i ) ∣ S=\\sum\_\{i=1\}^n|Y\_i-f(x\_i)| S=i=1∑n∣Yi−f(xi)∣  
缺点：

*  梯度恒定，不论预测值是否接近真实值，这很容易导致发散，或者错过极值点。
 *  导数不连续，导致求解困难。这也是L1损失函数不广泛使用的主要原因。

优点：

*  收敛速度比L2损失函数要快，这是通过对比函数图像得出来的，L1能提供更大且稳定的梯度。  
    \+对异常的离群点有更好的鲁棒性，下面会以例子证实。  
    **TensorFlow：**
 *  [MAE | mean\_absolute\_error][MAE _ mean_absolute_error]

tf.keras.losses.MAE(y_true, y_pred)

*  [MeanAbsoluteError][]

tf.keras.losses.MeanAbsoluteError(reduction=losses_utils.ReductionV2.AUTO, name='mean_absolute_error')
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [MeanAbsolutePercentageError][]：平均绝对百分比误差

tf.keras.losses.MeanAbsolutePercentageError(reduction=losses_utils.ReductionV2.AUTO, name='mean_absolute_percentage_error')
    公式：loss = 100 * abs(y_true - y_pred) / y_true
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [MAPE | mean\_absolute\_percentage\_error][MAPE _ mean_absolute_percentage_error]：平均绝对百分比误差

tf.keras.losses.MAPE(y_true, y_pred)
    公式：loss = 100 * mean(abs((y_true - y_pred) / y_true), axis=-1)

*  [Huber][]

tf.keras.losses.Huber(delta=1.0, reduction=losses_utils.ReductionV2.AUTO, name='huber_loss')
    公式：error = y_true - y_pred
    参数：
    	delta：float类型，Huber损失函数从二次变为线性的点。
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

**PyTorch：**

*  [L1Loss][]

torch.nn.L1Loss(size_average=None, reduce=None, reduction: str = 'mean')
    参数：
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean

*  [l1\_loss][l1_loss]

torch.nn.functional.l1_loss(input, target, size_average=None, reduce=None, reduction='mean') → Tensor

*  [SmoothL1Loss][]：平滑版L1损失，也被称为 Huber 损失函数。  
     l o s s ( x , y ) = 1 n ∑ i z i loss(x,y)=\\frac\{1\}\{n\}\\sum\_iz\_i loss(x,y)=n1i∑zi  
    其中，当  ∣ x i − y i ∣ < b e t a |x\_i-y\_i|<beta ∣xi−yi∣<beta 时，  0.5 ( x i − y i ) 2 / b e t a 0.5(x\_i-y\_i)^2/beta 0.5(xi−yi)2/beta，否则  ∣ x i − y i ∣ − 0.5 ∗ b e t a |x\_i-y\_i|-0.5\*beta ∣xi−yi∣−0.5∗beta

torch.nn.SmoothL1Loss(size_average=None, reduce=None, reduction: str = 'mean', beta: float = 1.0)
    参数：
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean
    	beta：默认为1，指定在L1和L2损耗之间切换的阈值

*  [smooth\_l1\_loss][smooth_l1_loss]

torch.nn.functional.smooth_l1_loss(input, target, size_average=None, reduce=None, reduction='mean', beta=1.0)

# 均方误差损失（L2范数损失） #

L2范数损失函数，也被称为最小平方误差（LSE）。总的来说，它是把目标值  Y i Y\_i Yi 与估计值  f ( x i ) f(x\_i) f(xi) 的差值的平方和  S S S 最小化：  
 S = ∑ i = 1 n ( Y i − f ( x i ) ) 2 S=\\sum\_\{i=1\}^n(Y\_i-f(x\_i))^2 S=i=1∑n(Yi−f(xi))2  
缺点：

*  收敛速度比L1慢，因为梯度会随着预测值接近真实值而不断减小。
 *  对异常数据比L1敏感，这是平方项引起的，异常数据会引起很大的损失。

优点：

*  它使训练更容易，因为它的梯度随着预测值接近真实值而不断减小，那么它不会轻易错过极值点，但也容易陷入局部最优。
 *  它的导数具有封闭解，优化和编程非常容易，所以很多回归任务都是用MSE作为损失函数。

**TensorFlow：**

*  [MeanSquaredError][]

tf.keras.losses.MeanSquaredError(reduction=losses_utils.ReductionV2.AUTO, name='mean_squared_error')
    公式：loss = square(y_true - y_pred)
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [MSE | mean\_squared\_error][MSE _ mean_squared_error]

tf.keras.losses.MSE(y_true, y_pred)
    公式：loss = mean(square(y_true - y_pred), axis=-1)

*  [MeanSquaredLogarithmicError][]

tf.keras.losses.MeanSquaredLogarithmicError(reduction=losses_utils.ReductionV2.AUTO, name='mean_squared_logarithmic_error')
    公式：loss = square(log(y_true + 1.) - log(y_pred + 1.))
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [MSLE | mean\_squared\_logarithmic\_error][MSLE _ mean_squared_logarithmic_error]

tf.keras.losses.MSLE(y_true, y_pred)
    公式：loss = mean(square(log(y_true + 1) - log(y_pred + 1)), axis=-1)

**PyTorch：**

*  [MSELoss][]

torch.nn.MSELoss(size_average=None, reduce=None, reduction: str = 'mean')
    参数：
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean

*  [mse\_loss][mse_loss]

torch.nn.functional.mse_loss(input, target, size_average=None, reduce=None, reduction='mean')

# Hinge loss #

有人把hinge loss称为铰链损失函数，它可用于“最大间隔(max-margin)”分类，其最著名的应用是作为SVM的损失函数。hinge loss专用于二分类问题，标签值  y = ± 1 y=\\pm 1 y=±1，预测值  y ^ ∈ R \\hat\{y\}\\in R y^∈R。二分类问题的目标函数的要求如下：当  y ^ \\hat\{y\} y^ 大于等于  ± 1 \\pm 1 ±1或者小于等于  − 1 -1 −1时，都是分类器确定的分类结果，此时的损失函数loss为0。而当预测值  y ^ ∈ ( − 1 , 1 ) \\hat\{y\}\\in(-1,1) y^∈(−1,1) 时，分类器对分类结果不确定，loss不为0。显然，当  y ^ = 0 \\hat\{y\} = 0 y^=0 时，loss达到最大值。对于输出  y = ± 1 y=\\pm 1 y=±1，当前  y ^ \\hat\{y\} y^ 的损失为：  
 L ( y ) = m a x ( 0 , 1 − y ⋅ y ^ ) L(y)=max(0,1-y\\cdot \\hat\{y\}) L(y)=max(0,1−y⋅y^)  
扩展到多分类问题上就需要多加一个边界值，然后叠加起来。公式如下：  
 L i = ∑ j ≠ y i m a x ( 0 , s j − s y i + Δ ) L\_i=\\sum\_\{j\\neq y\_i\}max(0,s\_j-s\_\{y\_i\}+\\Delta) Li=j=yi∑max(0,sj−syi\+Δ)

**Tensorflow：**

*  [CategoricalHinge][]

tf.keras.losses.CategoricalHinge(reduction=losses_utils.ReductionV2.AUTO, name='categorical_hinge')
    公式：loss = maximum(neg - pos + 1, 0) where neg=maximum((1-y_true)*y_pred) and pos=sum(y_true*y_pred)
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [categorical\_hinge][categorical_hinge]

tf.keras.losses.categorical_hinge(y_true, y_pred)
    公式：loss = maximum(neg - pos + 1, 0) where neg=maximum((1-y_true)*y_pred) and pos=sum(y_true*y_pred)

*  [Hinge][]

tf.keras.losses.Hinge(
        reduction=losses_utils.ReductionV2.AUTO, name='hinge'
    )
    公式：loss = maximum(1 - y_true * y_pred, 0)，y_true值应为-1或1。如果提供了二进制（0或1）标签，会将其转换为-1或1
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [hinge][]

tf.keras.losses.hinge(y_true, y_pred)
    公式：loss = mean(maximum(1 - y_true * y_pred, 0), axis=-1)

*  [SquaredHinge][]

tf.keras.losses.SquaredHinge(
        reduction=losses_utils.ReductionV2.AUTO, name='squared_hinge'
    )
    公式：loss = square(maximum(1 - y_true * y_pred, 0))，y_true值应为-1或1。如果提供了二进制（0或1）标签，会将其转换为-1或1。
    参数：
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [squared\_hinge][squared_hinge]

tf.keras.losses.squared_hinge(y_true, y_pred)
    公式：loss = mean(square(maximum(1 - y_true * y_pred, 0)), axis=-1)

**PyTorch：**

*  [HingeEmbeddingLoss][]：当  y n = 1 y\_n=1 yn=1时， l n = x n l\_n=x\_n ln=xn，当  y n = − 1 y\_n=-1 yn=−1 时，  l n = m a x \{ 0 , Δ − x n \} l\_n=max\\\{0,\\Delta-x\_n\\\} ln=max\{ 0,Δ−xn\}

torch.nn.HingeEmbeddingLoss(margin: float = 1.0, size_average=None, reduce=None, reduction: str = 'mean')
    参数：
    	margin：float类型，默认为1.
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean

# 余弦相似度 #

余弦相似度是机器学习中的一个重要概念，在Mahout等MLlib中有几种常用的相似度计算方法，如欧氏相似度，皮尔逊相似度，余弦相似度，Tanimoto相似度等。其中，余弦相似度是其中重要的一种。余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。相比距离度量，余弦相似度更加注重两个向量在方向上的差异，而非距离或长度上。

余弦相似度更多的是从方向上区分差异，而对绝对的数值不敏感，更多的用于使用用户对内容评分来区分用户兴趣的相似度和差异，同时修正了用户间可能存在的度量标准不统一的问题（因为余弦相似度对绝对数值不敏感），公式如下：  
 s i m ( X , Y ) = c o s θ = x ⃗ ⋅ y ⃗ ∣ ∣ x ∣ ∣ ⋅ ∣ ∣ y ∣ ∣ sim(X,Y)=cos\\theta=\\frac\{\\vec\{x\}\\cdot \\vec\{y\}\}\{||x||\\cdot ||y||\} sim(X,Y)=cosθ=∣∣x∣∣⋅∣∣y∣∣x⋅y

**Tensorflow：**

*  [CosineSimilarity][]：请注意，所得值是介于-1和0之间的负数，其中0表示正交性，而接近-1的值表示更大的相似性。 如果y\_true或y\_pred是零向量，则余弦相似度将为0，而与预测值和目标值之间的接近程度无关。

tf.keras.losses.CosineSimilarity(axis=-1, reduction=losses_utils.ReductionV2.AUTO, name='cosine_similarity')
    公式：loss = -sum(l2_norm(y_true) * l2_norm(y_pred))
    参数：
    	axis：默认-1，沿其计算余弦相似度的维
    	reduction：传入tf.keras.losses.Reduction类型值，默认AUTO，定义对损失的计算方式。

*  [cosine\_similarity][cosine_similarity]

tf.keras.losses.cosine_similarity(y_true, y_pred, axis=-1)
    公式：loss = -sum(l2_norm(y_true) * l2_norm(y_pred))
    参数：
    	axis：默认-1，沿其计算余弦相似度的维

**PyTorch：**

*  [CosineEmbeddingLoss][]：当  y = 1 y=1 y=1时， l o s s ( x , y ) 1 − c o s ( x 1 , x 2 ) loss(x,y)1-cos(x\_1,x\_2) loss(x,y)1−cos(x1,x2)，当  y = − 1 y=-1 y=−1 时， l o s s ( x , y ) = m a x ( 0 , c o s ( x 1 , x 2 ) − m a r g i n ) loss(x,y)=max(0,cos(x\_1,x\_2)-margin) loss(x,y)=max(0,cos(x1,x2)−margin)

torch.nn.CosineEmbeddingLoss(margin: float = 0.0, size_average=None, reduce=None, reduction: str = 'mean')
    参数：
    	margin：float类型，应为-1到1之间的数字，建议为0到0.5，默认值为0
    	size_average：bool类型，为True时，返回的loss为平均值，为False时，返回的各样本的loss之和
    	reduce：bool类型，返回值是否为标量，默认为True
    	reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean

[BinaryCrossentropy]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/BinaryCrossentropy
[binary_crossentropy]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/binary_crossentropy
[CategoricalCrossentropy]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalCrossentropy
[categorical_crossentropy]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/categorical_crossentropy
[SparseCategoricalCrossentropy]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/SparseCategoricalCrossentropy
[sparse_categorical_crossentropy]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/sparse_categorical_crossentropy
[BCELoss]: https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html
[BCEWithLogitsLoss]: https://pytorch.org/docs/stable/generated/torch.nn.BCEWithLogitsLoss.html
[CrossEntropyLoss]: https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html
[KLD _ kullback_leibler_divergence]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/KLD
[KLDivergence]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/KLDivergence
[KLDivLoss]: https://pytorch.org/docs/stable/generated/torch.nn.KLDivLoss.html
[MAE _ mean_absolute_error]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MAE
[MeanAbsoluteError]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanAbsoluteError
[MeanAbsolutePercentageError]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanAbsolutePercentageError
[MAPE _ mean_absolute_percentage_error]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MAPE
[Huber]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/Huber
[L1Loss]: https://pytorch.org/docs/stable/generated/torch.nn.L1Loss.html
[l1_loss]: https://pytorch.org/docs/stable/nn.functional.html?highlight=loss#torch.nn.functional.l1_loss
[SmoothL1Loss]: https://pytorch.org/docs/stable/generated/torch.nn.SmoothL1Loss.html
[smooth_l1_loss]: https://pytorch.org/docs/stable/nn.functional.html?highlight=loss#torch.nn.functional.smooth_l1_loss
[MeanSquaredError]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanSquaredError
[MSE _ mean_squared_error]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MSE
[MeanSquaredLogarithmicError]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanSquaredLogarithmicError
[MSLE _ mean_squared_logarithmic_error]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/MSLE
[MSELoss]: https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html
[mse_loss]: https://pytorch.org/docs/stable/nn.functional.html?highlight=loss#torch.nn.functional.mse_loss
[CategoricalHinge]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalHinge
[categorical_hinge]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/categorical_hinge
[Hinge]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/Hinge
[hinge]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/hinge
[SquaredHinge]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/SquaredHinge
[squared_hinge]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/squared_hinge
[HingeEmbeddingLoss]: https://pytorch.org/docs/stable/generated/torch.nn.HingeEmbeddingLoss.html
[CosineSimilarity]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/CosineSimilarity
[cosine_similarity]: https://www.tensorflow.org/api_docs/python/tf/keras/losses/cosine_similarity
[CosineEmbeddingLoss]: https://pytorch.org/docs/stable/generated/torch.nn.CosineEmbeddingLoss.html