loss函数之L1Loss，MSELoss，SmoothL1Lo

L1Loss

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

对于包含个样本的batch数据 ，为神经网络的输出，是真实的得分，与同维度。

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

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

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，对应不同的返回。 默认为mean，对中所有元素求平均，对应于一般情况下的的计算。

MSELoss

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

对于包含个样本的batch数据 ，为神经网络的输出，是真实的得分。

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

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

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，对应不同的返回。默认为mean，对中所有元素求平均，对应于一般情况下的的计算。

SmoothL1Loss

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

对于包含个样本的batch数据 ，为神经网络的输出，是真实的得分。

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

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

相比平均绝对误差，SmoothL1Loss平滑了趋近于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，对应不同的返回。默认为mean，对中所有元素求平均，对应于一般情况下的的计算。

参数，默认为1

HuberLoss

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

对于包含个样本的batch数据 ，为神经网络的输出，是真实的得分。

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

对比SmoothL1Loss和HuberLoss公式可知，，两者有如下区别：

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

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