1. dirac函数

狄拉克(dirac)函数是一个广义函数，在物理学中常用其表示质点、点电荷等理想模型的密度分布，该函数在除了零以外的点取值都等于零，而其在整个定义域上的积分等于1。

————————————————
原文链接：https://baike.baidu.com/item/%E7%8B%84%E6%8B%89%E5%85%8B%CE%B4%E5%87%BD%E6%95%B0/5760582?fr=aladdin

2. one-hot编码

2.1 one-hot 基本使用

# X shape (60,000 28x28),
X_train.reshape(X_train.shape[0], -1)

保留第一维，其余的维度，重新排列为一维，-1等同于28*28，reshape后的数据是共60000行，每一行784个数据点。
to_categorical就是将类别向量转换为二进制（只有0和1）的矩阵类型表示。其表现为将原有的类别向量转换为独热（onehot）编码的形式。

from keras.utils.np_utils import *
#类别向量定义
b = [0,1,2,3,4,5,6,7,8]
#调用to_categorical将b按照9个类别来进行转换
b = to_categorical(b, 9)
print(b)
 
执行结果如下：
[[1. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 1.]]

————————————————
版权声明：本文为CSDN博主「奔跑的小仙女」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43211132/article/details/96141409

2.2 one-hot在多分类中的不足

在使用softmax进行分类的过程中，输入结果属于某一类的概率为：
$$p(k|x)=\frac{exp(z_k)}{{\sum }_i^{i=K}exp(z_i)}$$
使用的损失函数为：
$$loss=-\sum _{k=1}^{K}q(k|x)log(p(k|x))$$

$z_i$：也为logits，即未被归一化的对数概率；
$p$：predicted probability，预测的example的概率；
$q$：groundtruth probablity，真实的example的label概率；对于one-hot，真实概率为Dirac函数，即$q(k)={\delta }_{k,y}$，其中y是真实类别。
$loss$：Cross Entropy，采用交叉熵损失。

具体的例子：
假设选用softmax交叉熵训练一个三分类模型，某样本经过网络最后一层的输出为向量$x=(1.0,5.0,4.0)$，对x进行softmax转换输出为：
$$p=(\frac{\exp (x_1)}{{\sum }_{i=1}^3}\exp (x_i),\frac{\exp (x_2)}{{\sum }_{i=1}^3}\exp (x_i),\frac{\exp (x_3)}{{\sum }_{i=1}^3}\exp (x_i))=[0.013,0.721,0.265]$$
假设该样本y=[0, 1, 0]，那损失loss:
$$loss=\sum _{i=1}^3-y_i\ast \log (p_i)=0.327$$
按softmax交叉熵优化时，针对这个样本而言，会让0.721越来越接近于1，因为这样会减少loss，但是这有可能造成过拟合。可以这样理解，如果0.721已经接近于1了，那么网络会对该样本十分“关注”，也就是过拟合。

换句话说：对于损失函数，我们需要用预测概率去拟合真实概率，而拟合one-hot的真实概率函数会带来两个问题：

1. 无法保证模型的泛化能力，容易造成过拟合
2. 全概率和0概率鼓励所属类别和其他类别之间的差距尽可能加大，而由梯度有界可知，这种情况很难adapt。会造成模型过于相信预测的类别。

另一种理解：
在分类任务中，我们通常对类别标签的编码使用$[0,1,2,\dots ]$这种形式。在深度学习中，通常在全连接层的最后一层，加入一个softmax来计算输入数据属于每个类别的概率，并把概率最高的作为这个类别的输入，然后使用交叉熵作为损失函数。这会导致模型对正确分类的情况奖励最大，错误分类惩罚最大。如果训练数据能覆盖所有情况，或者是完全正确，那么这种方式没有问题。但事实上，这不可能。所以这种方式可能会带来泛化能力差的问题，即过拟合。

————————————————

• 原文链接：https://www.cnblogs.com/zyrb/p/9699168.html
• 原文链接：https://www.datalearner.com/blog/1051561454844661

3. Lable Smoothing

在2016年，Szegedy等人提出了inception v2的模型（论文：Rethinking the inception architecture for computer vision.）。其中提到了Label Smoothing技术，用以减轻这个问题。
$$y_k^{LS}=y_k(1-\alpha )+\alpha u(K)\text{\hspace{1em}(3.1)}$$
在论文中，作者假定标签分类为均匀分布，故而(3.1)式又写成：
$$y_k^{LS}=y_k(1-\alpha )+\alpha /K\text{\hspace{1em}(3.2)}$$
其中 $K$为类别数, $\alpha$为label smoothing引入的超参数，$y_k$在$K$为正确类别时为 1，其余为0，也就是 y K ∈ { 0 , 1 } y_K \in \{0, 1\} yK​∈{0,1}

那么，公式(3.1)的交叉熵损失为：

可以认为：Loss 函数为分别对【预测label与真实label】【预测label与先验分布】进行惩罚。

3.1 一个具体的例子

我们先来看一下原理。

假设我们的分类只有两个，一个是猫一个不是猫，分别用1和0表示。Label Smoothing的工作原理是对原来的$[01]$这种标注做一个改动，假设我们给定Label Smoothing的值为0.1：
$$[0,1]\times (1-0.1)+0.1/2=[0.05,0.95]$$
可以看到，原来的$[01]$编码变成了$[0.05,0.95]$了。这个label_smoothing的值假设为$ϵ$，那么就是说，原来分类准确的时候，$p=1$，不准确为$p=0$，现在变成了$p_1=1-ϵ,p_0=ϵ$，也就是说对分类准确做了一点惩罚。

————————————————

• 原文链接：https://www.datalearner.com/blog/1051561454844661
• 论文链接：https://arxiv.org/abs/1512.00567
• 原文链接：https://www.cnblogs.com/zyrb/p/9699168.html
• 原文链接：https://www.datalearner.com/blog/1051561454844661

3.2 公式推导

import torch
K = 10
alpha = 0.1
lr = 0.1
a_num = torch.randn((K,)).float()

for i in range(40000):
    a = torch.autograd.Variable(a_num, requires_grad=True)
    b = torch.exp(-a)
    c = alpha / K * a.sum() + torch.log(1 + b.sum())
    c.backward()
    a_num = a_num - lr * a.grad

print(a_num, c)

#output: tensor([4.4995, 4.4995, 4.4995, 4.4995, 4.4995, 4.4995, 4.4995, 4.4995, 4.4995,
#        4.4995]) tensor(0.5553, grad_fn=<AddBackward0>)

• 原文链接：https://zhuanlan.zhihu.com/p/73054583

1. 引言

Label Smoothing 又被称之为标签平滑，常常被用在分类网络中来作为防止过拟合的一种手段，整体方案简单易用，在小数据集上可以取得非常好的效果。
Label Smoothing 做为一种简单的训练trick，可以通过很少的代价（只需要修改target的编码方式），即可获得准确率的提升，本文就其原理和具体实现进行介绍，希望可以帮主大家理解其背后的具体原理。

2. 初识

我们首先来看Label Smoothing的公式，在介绍之前我们先来观察一下传统的 one-hot encoding的公式，如下：

而Label Smoothing 导入了一个factor机制，公式改变如下：

只看公式，多少有些难懂，好嘛！我们来举个栗子瞧瞧啦。。。
不妨假设我们今天有四个类别，分别为dog,cat,bird,turtle，我们对其进行编码，即

dog = 0 , cat = 1 , bird = 2 , turtle = 3

• 我们采用one-hot对其进行编码，结果如下：

dog    = [ 1 , 0 , 0 , 0 ]
cat    = [ 0 , 1,  0 , 0 ]
bird   = [ 0 , 0 , 1 , 0 ]
turtle = [ 0,  0 , 0 , 1 ]

• 采用Label smoothing对其编码，引入一个factor来将其几率分配给其他类别 ，这里假设factor = 0.1，则生成的标签如下：

dog    = [ 0.9 , 0.03 , 0.03 , 0.03 ]
cat    = [ 0.03 , 0.9 , 0.03 , 0.03 ]
bird   = [ 0.03 , 0.03 , 0.9 , 0.03 ]
turtle = [ 0.03 , 0.03 , 0.03 , 0.9 ]

3. 深入

有了上述直观的理解，相必大家对Label Smoothing有了简单的认识，接着我们来思考这样的改变会对损失函数带来什么样的影响。

为此我们先来看一下分类任务中最常见的cross entropy损失函数，如下：

接着我们使用上述四个类别，来看看正确分类时Loss的计算，如下：

观察上图可以看出，如果整体分类呈现正常梯度下降的话，使用Label Smoothing相比不使用的loss下降相对比较小。
那反过来，如果网络越学预测效果越差呢？

通过上图可以看出，就算训练阶段预测错误时使用Label Smoothing的loss也相比之前惩罚的更小（扣得更少）。

4. 实现

我们来对Label Smoothing技术，作如下总结：

• 使用了Label Smoothing损失函数后，在训练阶段预测正确时 loss 不会下降得太快，预测错误的時候 loss 不会惩罚得太多，使其不容易陷入局部最优点，这在一定程度可以抑制网络过拟合的现象。
• 对于分类类别比较接近的场景，网络的预测不会过于绝对，在引入Label Smoothing技巧后，通过分配这些少数的几率也可以使得神经网络在训练的时候不这么绝对。
  接着，我们来用Python对其实现，代码如下：

def label_smoothing(labels, factor=0.1):
    num_labels = labels.get_shape().as_list()[-1]
    labels = ((1-factor) * labels) + (factor/ num_labels)
    return labels

5. 经验分享

在实际调参的一些经验分享如下：

• 不管是在object detection的分类网络或者是多分类网络导入label smoothing皆有不错的效果，基本上算轻松又容易提升准确度的做法
• 当数据量足够多的时候，Label smoothing这个技巧很容易使网络变得欠拟和。
• factor通常设置为0.1，之前做对比实验试过使用0.2，0.3等参数，会发现皆无较好的效果，反而使网络变得难以收敛。
• 可以利用label smoothing的特性来做点微小的改动，比如遇上相似类型的事物时，可以将factor分配给相似的类别，而不是全部类别，这通常会有不错的效果。

6. 总结

本文对Label Smoothing技术进行了简单的介绍，通过简单的例子来增加大家的直观认识，最后分享了该技巧的代码实现。

您学废了吗？

关注公众号《AI算法之道》，获取更多AI算法资讯。

参考： 论文

目录

1.Label smoothing的原理

2.pytorh中如何使用Label smoothing

3.适用场景

1.Label smoothing的原理

交叉熵损失（softmax cross Entropy）中，常用公式：

yi: 表示样本i的label,正类为1，负类为0；

pi:表示样本i预测为正类的概率；

Label Smothing:原来标签是1的位置变为1-a,其他原来是0的位置变为a/(K-1),a通常取0.1;

举个例子：

假设一个6分类任务，之前的标签y=【1，0，0，0，0，0】，经过a=0.1的smoothing 操作后，现在输入代码的标签变为了y=【0.9，0.02，0.02，0.02，0.02，0.02】；

2.pytorh中如何使用Label smoothing

在不加入Label smoothing这个技巧的时候，在pytorch中可以直接调用交叉熵loss：

import torch.nn as nn
criterion = nn.CrossEntropyLoss()

在加入该技巧后，已经有别人写好的代码（调用fast-reid中的代码）：

def cross_entropy_loss(pred_class_outputs, gt_classes, eps, alpha=0.2):
'''
pred_class_outputs:backbone输出结果，如16张数据，95个类别，通过fc后，则该参数维度为【16，95】
gt_classes：真实标签，如16张数据，则该参数维度为【16】
eps：通过判断该参数来决定使用常规的label smoothing,还是使用自适应的label smoothing
alpha：label smoothing的参数；
'''
    num_classes = pred_class_outputs.size(1)

    if eps >= 0:
        smooth_param = eps
    else:
        # Adaptive label smooth regularization
        soft_label = F.softmax(pred_class_outputs, dim=1)
        smooth_param = alpha * soft_label[torch.arange(soft_label.size(0)), gt_classes].unsqueeze(1)

    log_probs = F.log_softmax(pred_class_outputs, dim=1)
    with torch.no_grad():
        targets = torch.ones_like(log_probs) #torch.ones_like返回一个填充了标量值1的张量
        targets *= smooth_param / (num_classes - 1)
        targets.scatter_(1, gt_classes.data.unsqueeze(1), (1 - smooth_param)) #target.scatter(dim, index, src)其将一个源张量（source）中的值按照指定的轴方向（dim）和对应的位置关系（index）逐个填充到目标张量（target）中

    loss = (-targets * log_probs).sum(dim=1)

    with torch.no_grad():
        non_zero_cnt = max(loss.nonzero(as_tuple=False).size(0), 1)

    loss = loss.sum() / non_zero_cnt

    return loss

3.适用场景

label smoothing的作用主要是防止模型过拟合，加速模型收敛；

作者们亲测，label smoothing与mixup以及knowledge distillation一样，都是涨分的，模式识别、目标检测与语义分割，三大权威任务，不骗人。

引用来自：神经网络中的label smooth为什么没有火？ - 知乎

相关论文：《Why dose smoothing help？》 https://arxiv.org/pdf/1906.02629.pdf