PyTorch nn.MSELoss() 均方误差损失函数详解和要点提醒

nn.MSELoss() 均方误差损失函数

torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')

Creates a criterion that measures the mean squared error (squared L2 norm) between each element in the input $x$ and target $y$.

计算输入和目标之间每个元素的均方误差（平方 L2 范数）。

参数

• size_average (bool, 可选):
  • 已弃用。请参阅 reduction 参数。
  • 默认情况下，损失在批次中的每个损失元素上取平均（True）；否则（False），在每个小批次中对损失求和。
  • 当 reduce 为 False 时忽略该参数。
  • 默认值是 True。
• reduce (bool, 可选):
  • 已弃用。请参阅 reduction 参数。
  • 默认情况下，损失根据 size_average 参数进行平均或求和。
  • 当 reduce 为 False 时，返回每个批次元素的损失，并忽略 size_average 参数。
  • 默认值是 True。
• reduction (str, 可选):
  • 指定应用于输出的归约方式。
  • 可选值为 'none'、'mean'、'sum'。
    • 'none'：不进行归约。
    • 'mean'：输出的和除以输出的元素总数。
    • 'sum'：输出的元素求和。
  • 注意：size_average 和 reduce 参数正在被弃用，同时指定这些参数中的任何一个都会覆盖 reduction 参数。
  • 默认值是 'mean'。

数学公式

附录部分会验证下述公式和代码的一致性。

假设有 $N$ 个样本，每个样本的输入为 $x_n$，目标为 $y_n$。均方误差损失的计算步骤如下：

1. 单个样本的损失：
   计算每个样本的均方误差：
   $$l_n=(x_n-y_n{)}^2$$
   其中 $l_n$ 是第 $n$ 个样本的损失。
2. 总损失：
   计算所有样本的平均损失（reduction 参数默认为 'mean'）：
   $$\mathcal{L}=\frac{1}{N}\sum _{n=1}^N{l}_n=\frac{1}{N}\sum _{n=1}^N(x_n-y_n{)}^2$$
   如果 reduction 参数为 'sum'，总损失为所有样本损失的和：
   $$\mathcal{L}=\sum _{n=1}^N{l}_n=\sum _{n=1}^N(x_n-y_n{)}^2$$
   如果 reduction 参数为 'none'，则返回每个样本的损失 $l_n$ 组成的张量：
   $$\mathcal{L}=[l_1,l_2,\dots ,l_N]=[(x_1-y_1{)}^2,(x_2-y_2{)}^2,\dots ,(x_N-y_N{)}^2]$$

元素版本

假设输入张量 $\mathbf{x}$ 和目标张量 $\mathbf{y}$ 具有相同的形状，每个张量包含 $N$ 个元素。均方误差损失的计算步骤如下：

1. 单个元素的损失：
   计算每个元素的均方误差：
   $$l_{ij}=(x_{ij}-y_{ij}{)}^2$$
   其中 $l_{ij}$ 是输入张量和目标张量在位置 $(i,j)$ 的元素损失。
2. 总损失：
   计算所有元素的平均损失（reduction 参数默认为 'mean'）：
   $$\mathcal{L}=\frac{1}{N}\sum _{i,j}{l}_{ij}=\frac{1}{N}\sum _{i,j}(x_{ij}-y_{ij}{)}^2$$
   如果 reduction 参数为 'sum'，总损失为所有元素损失的和：
   $$\mathcal{L}=\sum _{i,j}{l}_{ij}=\sum _{i,j}(x_{ij}-y_{ij}{)}^2$$
   如果 reduction 参数为 'none'，则返回每个元素的损失 $l_{ij}$ 组成的张量：
   L = { l i j } = { ( x i j − y i j ) 2 } \mathcal{L} = \{l_{ij}\} = \{(x_{ij} - y_{ij})^2 \} L={lij​}={(xij​−yij​)2}

要点

1. nn.MSELoss() 接受的输入和目标应具有相同的形状和类型。
   使用示例

   import torch
   import torch.nn as nn
   
   # 定义输入和目标张量
   input = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
   target = torch.tensor([[1.5, 2.5], [3.5, 4.5]])
   
   # 使用 nn.MSELoss 计算损失
   criterion = nn.MSELoss()
   loss = criterion(input, target)
   
   print(f"Loss using nn.MSELoss: {loss.item()}")
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

   >>> Loss using nn.MSELoss: 0.25
   1

2. nn.MSELoss() 的 reduction 参数指定了如何归约输出损失。默认值是 'mean'，计算的是所有样本的平均损失。
   • 如果 reduction 参数为 'mean'，损失是所有样本损失的平均值。
   • 如果 reduction 参数为 'sum'，损失是所有样本损失的和。
   • 如果 reduction 参数为 'none'，则返回每个样本的损失组成的张量。
     代码示例

   import torch
   import torch.nn as nn
   
   # 定义输入和目标张量
   input = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
   target = torch.tensor([[1.5, 2.5], [3.5, 4.5]])
   
   # 使用 nn.MSELoss 计算损失（reduction='mean'）
   criterion_mean = nn.MSELoss(reduction='mean')
   loss_mean = criterion_mean(input, target)
   print(f"Loss with reduction='mean': {loss_mean.item()}")
   
   # 使用 nn.MSELoss 计算损失（reduction='sum'）
   criterion_sum = nn.MSELoss(reduction='sum')
   loss_sum = criterion_sum(input, target)
   print(f"Loss with reduction='sum': {loss_sum.item()}")
   
   # 使用 nn.MSELoss 计算损失（reduction='none'）
   criterion_none = nn.MSELoss(reduction='none')
   loss_none = criterion_none(input, target)
   print(f"Loss with reduction='none': {loss_none}")
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21

   >>> Loss with reduction='mean': 0.25
   >>> Loss with reduction='sum': 1.0
   >>> Loss with reduction='none': tensor([[0.2500, 0.2500],
           [0.2500, 0.2500]], grad_fn=<MseLossBackward0>)
   1
   2
   3
   4

附录

用于验证数学公式和函数实际运行的一致性

import torch
import torch.nn.functional as F

# 假设有两个样本，每个样本有两个维度
input = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
target = torch.tensor([[1.5, 2.5], [3.5, 4.5]])

# 根据公式实现均方误差损失
def mse_loss(input, target):
    return ((input - target) ** 2).mean()

# 使用 nn.MSELoss 计算损失
criterion = torch.nn.MSELoss(reduction='mean')
loss_torch = criterion(input, target)

# 使用根据公式实现的均方误差损失
loss_custom = mse_loss(input, target)

# 打印结果
print("PyTorch 计算的均方误差损失:", loss_torch.item())
print("根据公式实现的均方误差损失:", loss_custom.item())

# 验证结果是否相等
assert torch.isclose(loss_torch, loss_custom), "数学公式验证失败"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

>>> PyTorch 计算的均方误差损失: 0.25
>>> 根据公式实现的均方误差损失: 0.25
1
2

输出没有抛出 AssertionError，验证通过。

参考链接

MSELoss - Docs