$\displaystyle \frac{1}{n}  \sum_{i=1}^{i=n}{ \big(a_i-b_i\big)^2}$

官方示例

 
import torch
from torch import nn 

loss = nn.MSELoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
output.backward()

output
tensor(1.0446, grad_fn=MseLossBackward0)

 
nn.MSELoss(size_average=None, reduce=None, reduction: str = 'mean') -> None
    
Creates a criterion that measures the mean squared error (squared L2 norm) 
between each element in the input :math:`x` and target :math:`y`.

 
where :math:`N` is the batch size. 
If :attr:`reduction` is not ``'none'`` (default ``'mean'``), then:

Shape

 
- Input: :math:`(*)`, where :math:`*` means any number of dimensions.
- Target: :math:`(*)`, same shape as the input.

MSELoss要求模型输出与标签的shape一致，
并不像交叉熵那样，标签支持索引的格式
也没什么，就是遇到MSE加一个标签与模型输出的shape是否一致的判断就可以了 

 
loss_fn = nn.MSELoss()

for X,y in trainDataLoader:
    y_out  = transformer(X)
    print(y_out.shape,y.shape)            # torch.Size([64, 100, 1]) torch.Size([64, 100, 1]) 
    loss = loss_fn(y_out,y)
    loss.backward()
    print(round(loss.item(),5))  #5.5041
    break 
    

 
与前面官方的例子不同的是，这里输入的数据没有设置 requires_grad=True 

输入的数据X是常量，模型中的参数由模型内部自动设置 requires_grad=True 
- requires_grad隐藏在台后了，时间长了，会让人认为不需要requires_grad了
- 实际上，真实改变的就是参数，参数的改变有两步：
- 1-求导，2- w -= learning_rate*w.grad作差  
  
另外，这只是个示例，梯度没有下降，即没有加优化器 

 
在PyTorch中，并没有直接提供名为RMSELoss的API来计算均方根误差（Root Mean Square Error, RMSE）。
不过，RMSE可以通过均方误差（Mean Squared Error, MSE）损失函数计算后开平方得到。
以下是实现RMSE的步骤和代码示例：
  

 
import torch
import torch.nn as nn

# 假设我们有一些预测值和目标值
predictions = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
targets = torch.tensor([1.5, 2.5, 3.5])

# 定义MSE损失函数
mse_loss = nn.MSELoss()

# 计算MSE
mse = mse_loss(predictions, targets)

# 计算RMSE
rmse = torch.sqrt(mse)

print("MSE:", mse.item())    #MSE: 0.25
print("RMSE:", rmse.item())  #RMSE: 0.5
  

 
当损失函数小于1时，RMSE是大于MSE的
  

自定义RMSE损失函数

 
import torch
import torch.nn as nn
import torch.nn.functional as F

# 假设我们有一些预测值和目标值
predictions = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
targets = torch.tensor([1.5, 2.5, 3.5])

class RMSELoss(nn.Module):
    def __init__(self):
        super(RMSELoss, self).__init__()
        self.mse = nn.MSELoss()
        
    def forward(self, predictions, targets):
        mse = self.mse(predictions, targets)
        rmse = torch.sqrt(mse)
        return rmse

# 使用自定义的RMSE损失函数
rmse_loss = RMSELoss()
loss = rmse_loss(predictions, targets)
print("Custom RMSE Loss:", loss.item())  #Custom RMSE Loss: 0.5