损失函数理解汇总，结合PyTorch1.7和TensorFlow2

2020-11-12 563

作者丨DengBoCong@知乎

来源丨https://zhuanlan.zhihu.com/p/271911178

编辑丨极市平台

本文仅用于学术分享，如有侵权，请联系后台作删文处理。

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

使用版本：

TensorFlow2.3
PyTorch1.7.0

01 交叉熵损失（CrossEntropyLoss）

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

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

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

交叉熵损失函数的标准形式（也就是二分类交叉熵损失）如下:

其中，

表示样本

的标签，正类为1，负类为0，

表示样本

预测为正的概率。

多分类交叉熵损失如下：

其中，

表示类别的数量，

表示变量（0或1），如果该类别和样本

的类别相同就是1，否则是0，

表示对于观测样本

属于类别

的预测概率。

Tensorflow：

BinaryCrossentropy[1]：二分类，经常搭配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[2]

  
  
  
   
   
   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[3]：多分类，经常搭配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[4]

  
  
  
   
   
   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[5]：多分类，经常搭配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[6]

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[7]

  
  
  
   
   
   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[8]：其实和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[9]

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'三种参数值

02 KL散度

我们在计算预测和真实标签之间损失时，需要拉近他们分布之间的差距，即模型得到的预测分布应该与数据的实际分布情况尽可能相近。KL散度(相对熵)是用来衡量两个概率分布之间的差异。模型需要得到最大似然估计，乘以负Log以后就相当于求最小值，此时等价于求最小化KL散度(相对熵)。所以得到KL散度就得到了最大似然。又因为KL散度中包含两个部分，第一部分是交叉熵，第二部分是信息熵，即KL=交叉熵−信息熵。信息熵是消除不确定性所需信息量的度量，简单来说就是真实的概率分布，而这部分是固定的，所以优化KL散度就是近似于优化交叉熵。下面是KL散度的公式：

联系上面的交叉熵，我们可以将公式简化为（KL散度 = 交叉熵 - 熵）：

监督学习中，因为训练集中每个样本的标签是已知的，此时标签和预测的标签之间的KL散度等价于交叉熵。

TensorFlow：

KLD | kullback_leibler_divergence[10]

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

KLDivergence[11]

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

Pytorch：

KLDivLoss[12]

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，指定是否在日志空间中传递目标

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

L1范数损失函数，也被称为最小绝对值偏差（LAD），最小绝对值误差（LAE）。总的说来，它是把目标值

与估计值

的绝对差值的总和

最小化：

缺点：

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

优点：

收敛速度比L2损失函数要快，这是通过对比函数图像得出来的，L1能提供更大且稳定的梯度。
对异常的离群点有更好的鲁棒性，下面会以例子证实。

TensorFlow：

MAE | mean_absolute_error[13]

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

MeanAbsoluteError[14]

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

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

  
  
  
   
   
   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[16]：平均绝对百分比误差

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

Huber[17]

  
  
  
   
   
   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[18]

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[19]

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

SmoothL1Loss[20]：平滑版L1损失，也被称为 Huber 损失函数。

其中，当

时，

，否则

  
  
  
   
   
   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[21]

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

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

L2范数损失函数，也被称为最小平方误差（LSE）。总的来说，它是把目标值

与估计值

的差值的平方和

最小化：

缺点：

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

优点：

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

TensorFlow：

MeanSquaredError[22]

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[23]

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

MeanSquaredLogarithmicError[24]

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[25]

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

PyTorch：

MSELoss[26]

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[27]

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

05 Hinge loss

有人把hinge loss称为铰链损失函数，它可用于“最大间隔(max-margin)”分类，其最著名的应用是作为SVM的损失函数。hinge loss专用于二分类问题，标签值

，预测值

。二分类问题的目标函数的要求如下：当

大于等于

或者小于等于

时，都是分类器确定的分类结果，此时的损失函数loss为0。而当预测值

时，分类器对分类结果不确定，loss不为0。显然，当

时，loss达到最大值。对于输出

，当前

的损失为：

扩展到多分类问题上就需要多加一个边界值，然后叠加起来。公式如下：

Tensorflow：

CategoricalHinge[28]

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[29]

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[30]

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[31]

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

SquaredHinge[32]

  
  
  
   
   
   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[33]

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

PyTorch：

HingeEmbeddingLoss[34]：当时，，当时，

  
  
  
   
   
   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

06 余弦相似度

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

余弦相似度更多的是从方向上区分差异，而对绝对的数值不敏感，更多的用于使用用户对内容评分来区分用户兴趣的相似度和差异，同时修正了用户间可能存在的度量标准不统一的问题（因为余弦相似度对绝对数值不敏感），公式如下：

Tensorflow：

CosineSimilarity[35]：请注意，所得值是介于-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[36]

  
  
  
   
   
       
    
    
     
     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[37]：当时，，当时，

  
  
  
   
   
   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

7 总结

上面这些损失函数是我们在日常中经常使用到的，我将TensorFlow和PyTorch相关的API都贴出来了，也方便查看，可以作为一个手册文章，需要的时候点出来看一下。还有一些其他的损失函数，后续也会都加进来。

外链地址：

[1] https://www.tensorflow.org/api_docs/python/tf/keras/losses/BinaryCrossentropy

[2] https://www.tensorflow.org/api_docs/python/tf/keras/losses/binary_crossentropy

[3] https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalCrossentropy

[4] https://www.tensorflow.org/api_docs/python/tf/keras/losses/categorical_crossentropy

[5] https://www.tensorflow.org/api_docs/python/tf/keras/losses/SparseCategoricalCrossentropy

[6] https://www.tensorflow.org/api_docs/python/tf/keras/losses/sparse_categorical_crossentropy

[7] https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html

[8] https://pytorch.org/docs/stable/generated/torch.nn.BCEWithLogitsLoss.html

[9] https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html

[10] https://www.tensorflow.org/api_docs/python/tf/keras/losses/KLD

[11] https://www.tensorflow.org/api_docs/python/tf/keras/losses/KLDivergence

[12] https://pytorch.org/docs/stable/generated/torch.nn.KLDivLoss.html

[13] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MAE

[14] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanAbsoluteError

[15] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanAbsolutePercentageError

[16] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MAPE

[17] https://www.tensorflow.org/api_docs/python/tf/keras/losses/Huber

[18] https://pytorch.org/docs/stable/generated/torch.nn.L1Loss.html

[19] https://pytorch.org/docs/stable/nn.functional.html?highlight=loss#torch.nn.functional.l1_loss

[20] https://pytorch.org/docs/stable/generated/torch.nn.SmoothL1Loss.html

[21] https://pytorch.org/docs/stable/nn.functional.html?highlight=loss#torch.nn.functional.smooth_l1_loss

[22] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanSquaredError

[23] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MSE

[24] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MeanSquaredLogarithmicError

[25] https://www.tensorflow.org/api_docs/python/tf/keras/losses/MSLE

[26] https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html

[27] https://pytorch.org/docs/stable/nn.functional.html?highlight=loss#torch.nn.functional.mse_loss

[28] https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalHinge

[29] https://www.tensorflow.org/api_docs/python/tf/keras/losses/categorical_hinge

[30] https://www.tensorflow.org/api_docs/python/tf/keras/losses/Hinge

[31] https://www.tensorflow.org/api_docs/python/tf/keras/losses/hinge

[32] https://www.tensorflow.org/api_docs/python/tf/keras/losses/SquaredHinge

[33] https://www.tensorflow.org/api_docs/python/tf/keras/losses/squared_hinge

[34] https://pytorch.org/docs/stable/generated/torch.nn.HingeEmbeddingLoss.html

[35] https://www.tensorflow.org/api_docs/python/tf/keras/losses/CosineSimilarity

[36] https://www.tensorflow.org/api_docs/python/tf/keras/losses/cosine_similarity

[37] https://pytorch.org/docs/stable/generated/torch.nn.CosineEmbeddingLoss.html

觉得有用麻烦给个在看啦~

本文分享自微信公众号 - 视学算法（visualAlgorithm）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

微信关注我们

原文链接：https://my.oschina.net/u/4586369/blog/4714373

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

一口气说出 6种延时队列的实现方案

下边会介绍多种实现延时队列的思路，文末提供有几种实现方式的 github地址。其实哪种方式都没有绝对的好与坏，只是看把它用在什么业务场景中，技术这东西没有最好的只有最合适的。一、延时队列的应用什么是延时队列？顾名思义：首先它要具有队列的特性，再给它附加一个延迟消费队列消息的功能，也就是说可以指定队列中的消息在哪个时间点被消费。延时队列在项目中的应用还是比较多的，尤其像电商类平台： 1、订单成功后，在30分钟内没有支付，自动取消订单 2、外卖平台发送订餐通知，下单成功后60s给用户推送短信。 3、如果订单一直处于某一个未完结状态时，及时处理关单，并退还库存 4、淘宝新建商户一个月内还没上传商品信息，将冻结商铺等。。。。上边的这些场景都可以应用延时队列解决。二、延时队列的实现我个人一直秉承的观点：工作上能用JDK自带API实现的功能，就不要轻易自己重复造轮子，或者引入三方中间件。一方面自己封装很容易出问题（大佬除外），再加上调试验证产生许多不必要的工作量；另一方面一旦接入三方的中间件就会让系统复杂度成倍的增加，维护成本也大大的增加。 1、DelayQueue 延时队列 JDK...

2020-11-12

483

NewBeeNLP原创出品公众号专栏作者@蘑菇先生知乎|蘑菇先生学习记前情提要：四万字全面详解 | 深度学习中的注意力机制目前深度学习中热点之一就是注意力机制（Attention Mechanisms）。Attention源于人类视觉系统，当人类观察外界事物的时候，一般不会把事物当成一个整体去看，往往倾向于根据需要选择性的去获取被观察事物的某些重要部分，比如我们看到一个人时，往往先Attend到这个人的脸，然后再把不同区域的信息组合起来，形成一个对被观察事物的整体印象。「同理，Attention Mechanisms可以帮助模型对输入的每个部分赋予不同的权重，抽取出更加关键及重要的信息，使模型做出更加准确的判断，同时不会对模型的计算和存储带来更大的开销，这也是Attention Mechanism应用如此广泛的原因」在上一篇文章中，我们分享了seq2seq以及普通attention网络，今天来看看Attention机制的各种变体。另外，我们建立了自然语言处理、深度学习大方向的讨论组，欢迎大家加入讨论（人数达到上限，添加下方好友手动邀请） Attention Variant...

2020-11-12

1104

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

损失函数理解汇总，结合PyTorch1.7和TensorFlow2

01 交叉熵损失（CrossEntropyLoss）

02 KL散度

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

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

05 Hinge loss

06 余弦相似度

7 总结

外链地址：

一口气说出 6种延时队列的实现方案

四万字全面详解 | 深度学习中的注意力机制（二）

相关文章

发表评论

资源下载

优质分享App

Mario

Nacos

Rocky Linux

欢迎您来访！

损失函数理解汇总，结合PyTorch1.7和TensorFlow2

01 交叉熵损失（CrossEntropyLoss）

02 KL散度

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

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

05 Hinge loss

06 余弦相似度

7 总结

外链地址：

一口气说出 6种 延时队列的实现方案

四万字全面详解 | 深度学习中的注意力机制（二）

相关文章

发表评论

资源下载

优质分享App

Mario

Nacos

Rocky Linux

欢迎您来访！

一口气说出 6种延时队列的实现方案