Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺
基本概念
均方误差（mean square error, MSE），是反应估计量与被估计量之间差异程度的一种度量，设 t t t是根据子样确定的总体参数 θ \theta θ的一个估计量， ( θ − t ) 2 (\theta-t)^{2} (θ−t)2的数学期望，称为估计量 t t t的均方误差。
pytorch中MSELoss函数介绍
t o r c h . n n . M S E L o s s ( s i z e _ a v e r a g e = T r u e , r e d u c e = T r u e , r e d u c t i o n = ′ m e a n ′ ) torch.nn.MSELoss(size\_average=True, reduce=True, reduction=’mean’) torch.nn.MSELoss(size_average=True,reduce=True,reduction=′mean′)
创建一个度量：输入 x x x（模型预测输出）和目标 y y y之间的均方误差标准。
l o s s ( x , y ) = 1 n ∑ ( x i − y i ) 2 loss(x,y)=\frac{1}{n}\sum(x_i-y_i)^2 loss(x,y)=n1∑(xi−yi)2
其实按照我们习惯的写法，预测值是 y ^ \hat{y} y^，真值是 y y y,那么公式为：
l o s s ( y ^ , y ) = 1 n ∑ ( y ^ i − y i ) 2 loss(\hat{y},y)=\frac{1}{n}\sum(\hat{y}_i-y_i)^2 loss(y^,y)=n1∑(y^i−yi)2
- y ^ \hat{y} y^和 y y y可以是任意形状，每个包含 n n n个元素。
- 对 n n n个元素对应差值的平方求和，得到的结果再除以 n n n。
- 如果在创建 M S E L o s s MSELoss MSELoss实例的时候，在构造函数中传入 s i z e _ a v e r a g e = F a l s e size\_average=False size_average=False，那么求出来的平方和将不会除以 n n n。
- 如果 r e d u c e = F a l s e reduce=False reduce=False，那么 s i z e _ a v e r a g e size\_average size_average参数失效，直接返回向量形式 l o s s loss loss。
实验(使用jupyter notebook进行实验)
预测值和真值都是形状为 ( 2 , 5 ) (2, 5) (2,5)的张量，使用 r a n d n randn randn函数随机产生。
import torch
import torch.nn as nn
import math
import numpy as np
#默认求的是平均值、
input = torch.randn(2, 5, requires_grad=True)#预测值
target = torch.randn(2, 5)#真值
print('input is', input)
print('target is', target)
输出：
input is tensor([[-0.8038, -1.0976, -0.2270, -0.6983, -0.2839],
[-0.3291, -0.6583, -1.1446, -0.0108, -0.4827]], requires_grad=True)
target is tensor([[-1.4185, 0.5586, 0.3662, 0.9048, 1.5899],
[ 1.5777, 0.7461, 2.4658, -0.3369, 0.7868]])
1、实例化MSELoss，使用默认设置(输出的loss为标量形式，并且是平均值)：
loss = nn.MSELoss()
output = loss(input, target)
print('output is', output)
输出：
output is tensor(2.9916, grad_fn=<MseLossBackward>)
验证（自己使用公式计算loss值，公式为 l o s s = 1 n ∑ ( y i ^ − y i ) 2 loss=\frac{1}{n}\sum(\hat{y_i}-y_i)^2 loss=n1∑(yi^−yi)2）：
sum_1 = []
harm = 0
for i in range(2):
for j in range(5):
subtract = input[i][j] - target[i][j]
square = subtract * subtract
harm += square
sum_1.append(harm)
harm = 0
# print(sum_1)
rows ,cols = input.size()
he = 0
for i in range(2):
he += sum_1[i]
# print('')
L = he / (rows * cols)
print('自己计算loss：', L)
输出：
自己计算loss： tensor(2.9916, grad_fn=<DivBackward0>)
2、实例化MSELoss，不使用平均值（size_average=False）
loss = nn.MSELoss(size_average = False)
output = loss(input, target)
print('output is', output)
输出：
output is tensor(29.9156, grad_fn=<MseLossBackward>)
3、实例化MSELoss， 输出为向量形式（reduce=False）
loss = nn.MSELoss(reduce = False)
output = loss(input, target)
print('output is', output)
输出：
output is tensor([[ 0.3779, 2.7431, 0.3519, 2.5697, 3.5111],
[ 3.6359, 1.9726, 13.0353, 0.1064, 1.6118]],
grad_fn=<MseLossBackward>)
4、验证使用reduce=False时，size_average失效。
- 1、 r e d u c e = F a l s e , s i z e _ a v e r a g e = F a l s e reduce=False, size\_average=False reduce=False,size_average=False
loss = nn.MSELoss(reduce = False, size_average = False)
output = loss(input, target)
print('output is', output)
输出：
output is tensor([[ 0.3779, 2.7431, 0.3519, 2.5697, 3.5111],
[ 3.6359, 1.9726, 13.0353, 0.1064, 1.6118]],
grad_fn=<MseLossBackward>)
- 2、 r e d u c e = F a l s e , s i z e _ a v e r a g e = T r u e reduce=False, size\_average=True reduce=False,size_average=True
loss = nn.MSELoss(reduce = False, size_average = True)
output = loss(input, target)
print('output is', output)
输出：
output is tensor([[ 0.3779, 2.7431, 0.3519, 2.5697, 3.5111],
[ 3.6359, 1.9726, 13.0353, 0.1064, 1.6118]],
grad_fn=<MseLossBackward>)
发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/192066.html原文链接：https://javaforall.net
