loss函数之L1Loss，MSELoss，SmoothL1Loss, HuberLoss

L1Loss

平均绝对误差（MAE），用于回归模型

对于包含$N$个样本的batch数据 $D(x,y)$，$x$为神经网络的输出，$y$是真实的得分，$x$与$y$同维度。

第$n$个样本的损失值$l_n$计算如下:

$$l_n=\left|x_n-y_n\right|$$

其中，$y_n$代表第$n$样本的真实得分，可能对应一个值，也可能多个值，代表样本不同方面的得分，所以$l_n$可能是一个值，也可能是一个向量。

class L1Loss(_Loss):
    def __init__(self, size_average=None, reduce=None, reduction='mean'):
        super(L1Loss, self).__init__(size_average, reduce, reduction)
    def forward(self, input, target):
        return F.l1_loss(input, target, reduction=self.reduction)

pytorch中通过torch.nn.L1Loss类实现，也可以直接调用F.l1_loss 函数，代码中的size_average与reduce已经弃用。reduction有三种取值mean, sum, none，对应不同的返回$\ell (x,y)$。 默认为mean，对$L$中所有元素求平均，对应于一般情况下的$loss$的计算。

L = { l 1 , … , l N } L=\left\{l_{1}, \ldots, l_{N}\right\} L={l1​,…,lN​}

$$\ell (x,y)=\{\begin{array}{ll}L,& \text{ if reduction }=\text{ ’none’ }\\ \mathrm{mean}(L),& \text{ if reduction }=\text{ ’mean’ }\\ \mathrm{sum}(L),& \text{ if reduction }=\text{ ’sum’ }\end{array}$$

MSELoss

均方误差（MSE），用于回归模型

对于包含$N$个样本的batch数据 $D(x,y)$，$x$为神经网络的输出，$y$是真实的得分。

第$n$个样本的损失值$l_n$计算如下:

$$l_n={\left(x_n-y_n\right)}^2$$

其中，$y_n$代表第$n$样本的真实得分，可能对应一个值，也可能多个值，代表样本不同方面的得分，所以$l_n$可能是一个值，也可能是一个向量。

class MSELoss(_Loss):
    def __init__(self, size_average=None, reduce=None, reduction='mean'):
        super(MSELoss, self).__init__(size_average, reduce, reduction)
    def forward(self, input, target):
        return F.mse_loss(input, target, reduction=self.reduction)

pytorch中通过torch.nn.MSELoss类实现，也可以直接调用F.mse_loss 函数。代码中的size_average与reduce已经弃用。reduction有三种取值mean, sum, none，对应不同的返回$\ell (x,y)$。默认为mean，对$L$中所有元素求平均，对应于一般情况下的$loss$的计算。

L = { l 1 , … , l N } L=\left\{l_{1}, \ldots, l_{N}\right\} L={l1​,…,lN​}

$$\ell (x,y)=\{\begin{array}{ll}L,& \text{ if reduction }=\text{ ’none’ }\\ \mathrm{mean}(L),& \text{ if reduction }=\text{ ’mean’ }\\ \mathrm{sum}(L),& \text{ if reduction }=\text{ ’sum’ }\end{array}$$

SmoothL1Loss

分段使用均方误差和平均绝对误差，用于回归模型

对于包含$N$个样本的batch数据 $D(x,y)$，$x$为神经网络的输出，$y$是真实的得分。

第$n$个样本的损失值$l_n$计算如下:

$$l_n=\{\begin{array}{ll}0.5{\left(x_n-y_n\right)}^2/\text{ beta },& \text{ if }\left|x_n-y_n\right|<\text{ beta }\\ \left|x_n-y_n\right|-0.5\ast \text{ beta },& \text{ otherwise }\end{array}$$

其中，$y_n$代表第$n$样本的真实得分，可能对应一个值，也可能多个值，代表样本不同方面的得分，所以$l_n$可能是一个值，也可能是一个向量。

相比平均绝对误差，SmoothL1Loss平滑了$\left|x_n-y_n\right|$趋近于0时的误差。相比均方误差函数，SmoothL1Loss对离群点更不敏感。在一定程度上可以防止梯度爆炸问题。Fast R-CNN论文有详细论述。

class SmoothL1Loss(_Loss):
    def __init__(self, size_average=None, reduce=None, reduction: str = 'mean', beta: float = 1.0) -> None:
        super(SmoothL1Loss, self).__init__(size_average, reduce, reduction)
        self.beta = beta
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
        return F.smooth_l1_loss(input, target, reduction=self.reduction, beta=self.beta)

pytorch中通过torch.nn.SmoothL1Loss类实现，也可以直接调用F.smooth_l1_loss 函数。代码中的size_average与reduce已经弃用。reduction有三种取值mean, sum, none，对应不同的返回$\ell (x,y)$。默认为mean，对$L$中所有元素求平均，对应于一般情况下的$loss$的计算。

L = { l 1 , … , l N } L=\left\{l_{1}, \ldots, l_{N}\right\} L={l1​,…,lN​}

$$\ell (x,y)=\{\begin{array}{ll}L,& \text{ if reduction }=\text{ ’none’ }\\ \mathrm{mean}(L),& \text{ if reduction }=\text{ ’mean’ }\\ \mathrm{sum}(L),& \text{ if reduction }=\text{ ’sum’ }\end{array}$$

参数$beta>=0$，默认为1

HuberLoss

分段使用均方误差和平均绝对误差，用于回归模型

对于包含$N$个样本的batch数据 $D(x,y)$，$x$为神经网络的输出，$y$是真实的得分。

第$n$个样本的损失值$l_n$计算如下:

$$l_n=\{\begin{array}{ll}0.5{\left(x_n-y_n\right)}^2,& \text{ if }\left|x_n-y_n\right|<\text{ beta }\\ \text{ beta }\ast (\left|x_n-y_n\right|-0.5\ast \text{ beta }),& \text{ otherwise }\end{array}$$

对比SmoothL1Loss和HuberLoss公式可知，$\text{HuberLoss}=\text{beta}\ast \text{SmoothL1Loss}$，两者有如下区别：

• 当$beta$趋于0时，SmoothL1Loss收敛于L1Loss, HuberLoss收敛于常数0
• 当$beta$趋于无穷时，SmoothL1Loss收敛于常数0，HuberLoss收敛于MSELoss
• 随着$beta$的变化，SmoothL1Loss中平均绝对误差段的斜率恒定为1；而HuberLos中平均绝对误差段的斜率是$beta$

SmoothL1Loss 例子：

import torch
import torch.nn as nn
import math


def validate_loss(output, target, beta):
    val = 0
    for li_x, li_y in zip(output, target):
        for i, xy in enumerate(zip(li_x, li_y)):
            x, y = xy
            if math.fabs(x - y) < beta:
                loss_val = 0.5 * math.pow(x - y, 2) / beta
            else:
                loss_val = math.fabs(x - y) - 0.5 * beta
            val += loss_val
    return val / output.nelement()


beta = 1
loss_fct = nn.SmoothL1Loss(reduction="mean", beta=beta)
input_src = torch.Tensor([[0.8, 0.8], [0.9, 0.9], [0.3, 0.3]])
target = torch.Tensor([[0.6, 0.6], [0.7, 0.8], [0.4, 0.5]])
print(input_src.size())
print(target.size())
loss = loss_fct(input_src, target)
print(loss.item())

validate = validate_loss(input_src, target, beta)
print(validate)

loss_fct = nn.SmoothL1Loss(reduction="none", beta=beta)
loss = loss_fct(input_src, target)
print(loss)

输出结果：

torch.Size([3, 2])
torch.Size([3, 2])
0.01499999687075615
0.014999997715155441
tensor([[0.0200, 0.0200],
        [0.0200, 0.0050],
        [0.0050, 0.0200]])