损失函数及优化算法汇总

损失函数（loss function）又叫做代价函数（cost function），是用来评估模型的预测值与真实值不一致的程度，也是神经网络中优化的目标函数，神经网络训练或者优化的过程就是最小化损失函数的过程，损失函数越小，说明模型的预测值就越接近真是值，模型的健壮性也就越好。

1. 常用损失函数

1.1 0-1损失函数(0-1 lossfunction)

0-1损失函数是最为简单的一种损失函数，多适用于分类问题中，如果预测值与目标值不相等，说明预测错误，输出值为1；如果预测值与目标值相同，说明预测正确，输出为0，言外之意没有损失。
$$L\left(y,f(x)\right)=\{\begin{array}{c}1,y\ne f(x)\\ 0,y=f(x)\end{array}$$

1.2 感知损失函数（Perceptron Loss）

感知损失函数是对0-1损失函数的改进，它并不会像0-1损失函数那样严格，哪怕预测值为0.99，真实值为1，都会认为是错误的；而是给一个误差区间，只要在误差区间内，就认为是正确的。其数学公式可表示为：
$$L\left(y_i,\widehat{y_i}\right)=\{\begin{array}{c}1,|y_i-\widehat{y_i}|>t\\ 0,|y_i-\widehat{y_i}|\le t\end{array}$$

1.3 平方损失函数（Quadratic Loss Function）

顾名思义，平方损失函数是指预测值与真实值差值的平方。损失越大，说明预测值与真实值的差值越大。平方损失函数多用于线性回归任务中。
单样本数学公式可表示为：
$$L\left(y,f\left(x\right)\right)={(y-f(x))}^2$$
多样本数学公式可表示为：
$$L\left(y,f\left(x\right)\right)=\sum _{i=1}^n{(y-f(x))}^2$$

1.4 Hinge损失函数（Hinge Loss Function）

Hinge损失函数通常适用于二分类的场景中，可以用来解决间隔最大化的问题，常应用于著名的SVM算法中。其数学公式为：
$$L(y)=max(0,1-t\bullet y)$$
t是目标值{-1，+1}，y为预测值的输出，取值范围在（-1，1）之间。

1.5 对数损失函数（Log Loss Function）

对数损失函数也是常见的一种损失函数，常用于逻辑回归问题中，其标准形式为：
$$L\left(y,P\left(y|x\right)\right)=-logP\left(y|x\right)$$
y为已知分类的类别，x为样本值，我们需要让概率p(y|x)达到最大值，也就是说我们要求一个参数值，使得输出的目前这组数据的概率值最大。因为概率P(Y|X)的取值范围为[0,1]，log(x)函数在区间[0,1]的取值为负数，所以为了保证损失值为正数要在log函数前加负号。

1.6 交叉熵损失函数（Cross-entropy Loss Function）

交叉熵损失函数本质上也是一种对数损失函数，常用于多分类问题中。其数学公式为：
$$L=-[ylog\hat{y}+(1-y)log(1-\hat{y})]$$
x表示样本，y代表预测的输出，a为实际输出，n表示样本总数量。交叉熵损失函数常用于当sigmoid函数作为激活函数的情景，因为它可以完美解决平方损失函数权重更新过慢的问题。

1.7 回归损失函数（Huber Loss Function）

一种使用鲁棒性回归的损失函数，它相比均方误差来说，它对异常值不敏感。常常被用于分类问题上。
$$L\left(y,f(x)\right)=\{\begin{array}{c}{\frac{1}{2}\left(y-f(x)\right)}^2,for|y-f(x)|\le \delta \\ \delta |y-f(x)|-\frac{1}{2}{\delta }^2,otherwise\end{array}$$
Huber Loss 是对均方误差（Mean Square Error）和平均绝对误差（Mean Absolute Error）的综合，包含了一个超参数$\delta$。$\delta$值的大小决定了 Huber Loss 对 MSE 和 MAE 的侧重性，当 |y−f(x)| ≤ $\delta$ 时，变为 MSE；当 |y−f(x)| > $\delta$ 时，则变成类似于 MAE，因此 Huber Loss 同时具备了 MSE 和 MAE 的优点，减小了对离群点的敏感度问题，实现了处处可导的功能。

2. 人工智能常用损失函数

2.1 L1范数损失 L1Loss

计算 output 和 target 之差的绝对值。

torch.nn.L1Loss(reduction='mean')

参数：
reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean。

2.2 平滑版L1损失 SmoothL1Loss

也被称为 Huber 损失函数。

torch.nn.SmoothL1Loss(reduction='mean')

$$L\left(x,y\right)=\frac{1}{n}\sum _i{z}_i$$
$$z_i=\{\begin{array}{c}0.5{\left(x_i-y_i\right)}^2,if|x_i-y_i|<1\\ |x_i-y_i|-0.5,otherwise\end{array}$$

2.3 均方误差损失 MSELoss

计算 output 和 target 之差的均方差。

torch.nn.MSELoss(reduction='mean')

参数：
reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean。

2.4 交叉熵损失 CrossEntropyLoss

当训练有 C 个类别的分类问题时很有效. 可选参数 weight 必须是一个1维 Tensor, 权重将被分配给各个类别. 对于不平衡的训练集非常有效。
在多分类任务中，经常采用 softmax 激活函数+交叉熵损失函数，因为交叉熵描述了两个概率分布的差异，然而神经网络输出的是向量，并不是概率分布的形式。所以需要 softmax激活函数将一个向量进行“归一化”成概率分布的形式，再采用交叉熵损失函数计算 loss。

torch.nn.CrossEntropyLoss(weight=None,ignore_index=-100, reduction='mean')

参数：
weight (Tensor, optional) – 自定义的每个类别的权重. 必须是一个长度为 C 的 Tensor
ignore_index (int, optional) – 设置一个目标值, 该目标值会被忽略, 从而不会影响到 输入的梯度。
reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean。

2.5 KL 散度损失 KLDivLoss

计算 input 和 target 之间的 KL 散度。KL 散度可用于衡量不同的连续分布之间的距离, 在连续的输出分布的空间上(离散采样)上进行直接回归时很有效。

torch.nn.KLDivLoss(reduction='mean')

参数：
reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean。

2.6 二进制交叉熵损失 BCELoss

二分类任务时的交叉熵计算函数。用于测量重构的误差, 例如自动编码机. 注意目标的值 t[i] 的范围为0到1之间。

torch.nn.BCELoss(weight=None, reduction='mean')

参数：
weight (Tensor, optional) – 自定义的每个 batch 元素的 loss 的权重. 必须是一个长度为 “nbatch” 的 的 Tensor

2.7 BCEWithLogitsLoss

BCEWithLogitsLoss损失函数把 Sigmoid 层集成到了 BCELoss 类中. 该版比用一个简单的 Sigmoid 层和 BCELoss 在数值上更稳定, 因为把这两个操作合并为一个层之后, 可以利用 log-sum-exp 的 技巧来实现数值稳定。

torch.nn.BCEWithLogitsLoss(weight=None, reduction='mean', pos_weight=None)

参数：
weight (Tensor, optional) – 自定义的每个 batch 元素的 loss 的权重. 必须是一个长度 为 “nbatch” 的 Tensor

2.8 MarginRankingLoss

torch.nn.MarginRankingLoss(margin=0.0, reduction='mean')

对于 mini-batch(小批量) 中每个实例的损失函数如下：
$$L\left(x,y\right)=max(0,-y\ast (x1-x2)+margin$$

2.9 HingeEmbeddingLoss

torch.nn.HingeEmbeddingLoss(margin=1.0,  reduction='mean')

对于 mini-batch(小批量) 中每个实例的损失函数如下:
L n = { x n ,   i f   y n = 1 m a x { 0 , Δ − x n } ,   i f   y n = − 1 ) L_{n} = \left\{ \begin{matrix} {x_{n},~if~y_{n} = 1} \\ {max\left\{ 0,\mathrm{\Delta} - x_{n} \right\}\left. ,~if~y_{n} = - 1 \right)} \\ \end{matrix} \right. Ln​={xn​, if yn​=1max{0,Δ−xn​}, if yn​=−1)​
参数：
margin:默认值1

2.10 多标签分类损失 MultiLabelMarginLoss

torch.nn.MultiLabelMarginLoss(reduction='mean')

对于mini-batch(小批量) 中的每个样本按如下公式计算损失:
$$L\left(x,y\right)=\sum _{ij}\frac{max\left(0,1-\left(x\lfloor y\lfloor j\rfloor \rfloor -x\lfloor i\rfloor \right)\right)}{x.size(0)}$$

2.11 二分类的logistic损失 SoftMarginLoss

torch.nn.SoftMarginLoss(reduction='mean')

$$L\left(x,y\right)=\sum _i\frac{log(1+exp\left(-y[i]\ast x[i]\right)}{x.nelement()}$$

2.12 多标签one-versus-all损失 MultiLabelSoftMarginLoss

torch.nn.MultiLabelSoftMarginLoss(weight=None, reduction='mean')

$$L\left(x,y\right)=-\frac{1}{C}\sum _{i}y[i]\ast log\left({\left(1+exp\left(-x[i]\right)\right)}^{-1}\right)+\left(1-y[i]\right)\ast log\left(\frac{exp\left(-x[i]\right)}{1+exp\left(-x[i]\right)}\right)$$

2.13 cosine 损失 CosineEmbeddingLoss

torch.nn.CosineEmbeddingLoss(margin=0.0, reduction='mean')

$$L(x,y)=\{\begin{array}{c}1-cos\left(x_1,x_2\right),ify==1\\ max\left(0,cos\left(x_1,x_2\right)-margin\right),ify==-1\end{array}$$
参数：
margin:默认值0

2.14 多类别分类的hinge损失 MultiMarginLoss

torch.nn.MultiMarginLoss(p=1, margin=1.0, weight=None,  reduction='mean')

$$L\left(x,y\right)=\frac{{\sum }_i{max(0,w\left[y\right]\ast (margin-x\left[y\right]+x\left[i\right]))}^p}{x.size()}$$
参数：
p=1或者2 默认值：1
margin:默认值1

2.15 三元组损失 TripletMarginLoss

给一个A，然后再给B、C，看看B、C谁和A更像。

torch.nn.TripletMarginLoss(margin=1.0, p=2.0, eps=1e-06, swap=False, reduction='mean')

$$L\left(a,p,n\right)=max\left(d\left(a_i,p_i\right)-d\left(a_i,n_i\right)+margin,0\right)$$
$$d\left(x_i,y_i\right)={\Vert x_i-y_i\Vert }_p$$

2.16 连接时序分类损失 CTCLoss

CTC连接时序分类损失，可以对没有对齐的数据进行自动对齐，主要用在没有事先对齐的序列化数据训练上。比如语音识别、ocr识别等等。

torch.nn.CTCLoss(blank=0, reduction='mean')

参数：
reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean。

2.17 负对数似然损失 NLLLoss

负对数似然损失. 用于训练 C 个类别的分类问题。

torch.nn.NLLLoss(weight=None, ignore_index=-100,  reduction='mean')

参数：
weight (Tensor, optional) – 自定义的每个类别的权重. 必须是一个长度为 C 的 Tensor
ignore_index (int, optional) – 设置一个目标值, 该目标值会被忽略, 从而不会影响到 输入的梯度.

2.18 NLLLoss2d

对于图片输入的负对数似然损失. 它计算每个像素的负对数似然损失。

torch.nn.NLLLoss2d(weight=None, ignore_index=-100, reduction='mean')

参数：
weight (Tensor, optional) – 自定义的每个类别的权重. 必须是一个长度为 C 的 Tensor
reduction-三个值，none: 不使用约简；mean:返回loss和的平均值；sum:返回loss的和。默认：mean。

2.19 PoissonNLLLoss

目标值为泊松分布的负对数似然损失。

torch.nn.PoissonNLLLoss(log_input=True, full=False,  eps=1e-08,  reduction='mean'

参数：
log_input (bool, optional) – 如果设置为 True , loss 将会按照公 式 exp(input) - target * input 来计算, 如果设置为 False , loss 将会按照 input - target * log(input+eps) 计算.
full (bool, optional) – 是否计算全部的 loss, i. e. 加上 Stirling 近似项 target * log(target) - target + 0.5 * log(2 * pi * target).
eps (float, optional) – 默认值: 1e-8

3 优化算法

3.1 随机梯度下降算法 SGD算法

torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

参数：
params (iterable) ：待优化参数的iterable或者是定义了参数组的dict
lr (float) ：学习率
momentum (float, 可选) ：动量因子（默认：0）
weight_decay (float, 可选) ：权重衰减（L2惩罚）（默认：0）
dampening (float, 可选) :动量的抑制因子（默认：0）
nesterov (bool, 可选) :使用Nesterov动量（默认：False）
可实现 SGD 优化算法，带动量 SGD 优化算法，带 NAG(Nesterov accelerated gradient)动量 SGD 优化算法,并且均可拥有 weight_decay 项。

对于训练数据集，我们首先将其分成n个batch，每个batch包含m个样本。我们每次更新都利用一个batch的数据，而非整个数据集。这样做使得训练数据太大时，利用整个数据集更新往往时间上不现实。batch的方法可以减少机器的压力，并且可以快速收敛。
当训练集有冗余时，batch方法收敛更快。
优缺点：
SGD完全依赖于当前batch的梯度，所以η可理解为允许当前batch的梯度多大程度影响参数更新。对所有的参数更新使用同样的learning rate，选择合适的learning rate比较困难，容易收敛到局部最优。

3.2 平均随机梯度下降算法 ASGD算法

ASGD 就是用空间换时间的一种 SGD。

torch.optim.ASGD(params, lr=0.01, lambd=0.0001, alpha=0.75, t0=1000000.0, weight_decay=0)

参数：
params (iterable) ：待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) ： 学习率（默认：1e-2）
lambd (float, 可选) ：衰减项（默认：1e-4）
alpha (float, 可选) ：eta更新的指数（默认：0.75）
t0 (float, 可选) ：指明在哪一次开始平均化（默认：1e6）
weight_decay (float, 可选) ：权重衰减（L2惩罚）（默认: 0）

3.3 Adagrad算法

AdaGrad算法就是将每一个参数的每一次迭代的梯度取平方累加后在开方，用全局学习率除以这个数，作为学习率的动态更新。
其中，r为梯度累积变量，r的初始值为0。ε为全局学习率，需要自己设置。δ为小常数，为了数值稳定大约设置为10^-7 。

torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0)

参数：
params (iterable) ：待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) ：学习率（默认: 1e-2）
lr_decay (float, 可选) ：学习率衰减（默认: 0）
weight_decay (float, 可选) ： 权重衰减（L2惩罚）（默认: 0）
优缺点：
Adagrad 是一种自适应优化方法，是自适应的为各个参数分配不同的学习率。这个学习率的变化，会受到梯度的大小和迭代次数的影响。梯度越大，学习率越小；梯度越小，学习率越大。缺点是训练后期，学习率过小，因为 Adagrad 累加之前所有的梯度平方作为分母。随着算法不断迭代，r会越来越大，整体的学习率会越来越小。所以，一般来说AdaGrad算法一开始是激励收敛，到了后面就慢慢变成惩罚收敛，速度越来越慢。在深度学习算法中，深度过深会造成训练提早结束。

3.4 自适应学习率调整 Adadelta算法

Adadelta是对Adagrad的扩展，主要针对三个问题：
学习率后期非常小的问题；
手工设置初始学习率；
更新xt时，两边单位不统一
针对以上的三个问题，Adadelta提出新的Adag解决方法。Adagrad会累加之前所有的梯度平方，而Adadelta只累加固定大小的项，并且也不直接存储这些项，仅仅是近似计算对应的平均值。

torch.optim.Adadelta(params, lr=1.0, rho=0.9, eps=1e-06, weight_decay=0)

参数：
params (iterable) ：待优化参数的iterable或者是定义了参数组的dict
rho (float, 可选) ： 用于计算平方梯度的运行平均值的系数（默认：0.9）
eps (float, 可选)： 为了增加数值计算的稳定性而加到分母里的项（默认：1e-6）
lr (float, 可选)： 在delta被应用到参数更新之前对它缩放的系数（默认：1.0）
weight_decay (float, 可选) ：权重衰减（L2惩罚）（默认: 0）
优缺点：
Adadelta已经不依赖于全局学习率。训练初中期，加速效果不错，很快，训练后期，反复在局部最小值附近抖动。

3.5 RMSprop算法

RMSprop 和 Adadelta 一样，也是对 Adagrad 的一种改进。 RMSprop 采用均方根作为分
母，可缓解 Adagrad 学习率下降较快的问题， 并且引入均方根，可以减少摆动。

torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)

参数：
params (iterable) ：待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) ：学习率（默认：1e-2）
momentum (float, 可选) : 动量因子（默认：0）
alpha (float, 可选) : 平滑常数（默认：0.99）
eps (float, 可选) : 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）
centered (bool, 可选):如果为True，计算中心化的RMSProp，并且用它的方差预测值对梯度进行归一化
weight_decay (float, 可选)：权重衰减（L2惩罚）（默认: 0）

3.6 自适应矩估计 Adam算法

基于低阶矩的自适应估计的随机目标函数一阶梯度优化算法。

torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)

参数：
params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) – 学习率（默认：1e-3）
betas (Tuple[float, float], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数（默认：0.9，0.999）
eps (float, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）
weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认: 0）
优缺点：
Adam的优点主要在于经过偏置校正后，每一次迭代学习率都有个确定范围，使得参数比较平稳。
Adam结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点。

3.7 Adamax算法（Adamd的无穷范数变种）

Adamax 是对 Adam 增加了一个学习率上限的概念，所以也称之为 Adamax。

torch.optim.Adamax(params, lr=0.002, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)

参数：
params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) – 学习率（默认：2e-3）
betas (Tuple[float, float], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数
eps (float, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）
weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认: 0）
优缺点：

Adamax是Adam的一种变体，此方法对学习率的上限提供了一个更简单的范围。
Adamax学习率的边界范围更简单。

3.8 SparseAdam算法

针对稀疏张量的一种“阉割版”Adam 优化方法。

torch.optim.SparseAdam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08)

参数：
params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) – 学习率（默认：2e-3）
betas (Tuple[float, float], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数
eps (float, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）

3.9 L-BFGS算法

L-BFGS 属于拟牛顿算法。 L-BFGS 是对 BFGS 的改进，特点就是节省内存。

torch.optim.LBFGS(params, lr=1, max_iter=20, max_eval=None, 
tolerance_grad=1e-05, tolerance_change=1e-09, 
history_size=100, line_search_fn=None)

参数：
lr (float) – 学习率（默认：1）
max_iter (int) – 每一步优化的最大迭代次数（默认：20）)
max_eval (int) – 每一步优化的最大函数评价次数（默认：max * 1.25）
tolerance_grad (float) – 一阶最优的终止容忍度（默认：1e-5）
tolerance_change (float) – 在函数值/参数变化量上的终止容忍度（默认：1e-9）
history_size (int) – 更新历史的大小（默认：100）

3.10 弹性反向传播算法 Rprop算法

该优化方法适用于 full-batch，不适用于 mini-batch。不推荐。

torch.optim.Rprop(params, lr=0.01, etas=(0.5, 1.2), step_sizes=(1e-06, 50))

参数：
params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) – 学习率（默认：1e-2）
etas (Tuple[float, float], 可选) – 一对（etaminus，etaplis）, 它们分别是乘法的增加和减小的因子（默认：0.5，1.2）
step_sizes (Tuple[float, float], 可选) – 允许的一对最小和最大的步长（默认：1e-6，50）
优缺点：
该优化方法适用于 full-batch，不适用于 mini-batch。