6.1 自定义损失函数
PyTorch在torch.nn模块为我们提供了许多常用的损失函数,比如:MSELoss,L1Loss,BCELoss… 但是随着深度学习的发展,出现了越来越多的非官方提供的Loss,比如DiceLoss,HuberLoss,SobolevLoss… 这些Loss Function专门针对一些非通用的模型,PyTorch不能将他们全部添加到库中去,因此这些损失函数的实现则需要我们通过自定义损失函数来实现。
另外,在科学研究中,我们往往会提出全新的损失函数来提升模型的表现,这时我们既无法使用PyTorch自带的损失函数,也没有相关的博客供参考,此时自己实现损失函数就显得更为重要了。
经过本节的学习,你将收获:掌握如何自定义损失函数
6.1.1 以函数方式定义
事实上,损失函数仅仅是一个函数而已,因此我们可以通过直接以函数定义的方式定义一个自己的函数,如下所示:
def my_loss(output, target):
loss = torch.mean((output - target)**2)
return loss
6.1.2 以类方式定义
虽然以函数定义的方式很简单,但是以类方式定义更加常用,在以类方式定义损失函数时,我们如果看每一个损失函数的继承关系我们就可以发现Loss函数部分继承自_loss, 部分继承自_WeightedLoss, 而_WeightedLoss继承自_loss, _loss继承自 nn.Module。
我们可以将其当作神经网络的一层来对待,同样地,我们的损失函数类就需要继承自nn.Module类,在下面的例子中我们以DiceLoss为例向大家讲述。
Dice Loss是一种在分割领域常见的损失函数,定义如下:
实现代码如下:
class DiceLoss(nn.Module):
def __init__(self,weight=None,size_average=True):
super(DiceLoss,self).__init__()
def forward(self,inputs,targets,smooth=1):
inputs = F.sigmoid(inputs)
inputs = inputs.view(-1)
targets = targets.view(-1)
intersection = (inputs * targets).sum()
dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)
return 1 - dice
# 使用方法
criterion = DiceLoss()
loss = criterion(input,targets)
除此之外,常见的损失函数还有BCE-Dice Loss,Jaccard/Intersection over Union (IoU) Loss,Focal Loss…
补充
鉴于前面所说的,损失函数的本质也就是“对输入进行函数运算,得到一个输出”,所以我们可以像定义层一样自定义一个损失函数,比如我自己定义一个 MSE 损失函数,代码如下:
class My_loss(nn.Module):
def __init__(self):
super().__init__() #没有需要保存的参数和状态信息
def forward(self, x, y): # 定义前向的函数运算即可
return torch.mean(torch.pow((x - y), 2))
在使用这个巡视函数的时候只需要如下即可:
criterion = My_loss()
loss = criterion(outputs, targets)
自定义损失的案例
第一步:本次通过自定义一个损失函数类来实现
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
# 第一步:自定义损失函数
继承nn.Mdule
class My_loss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
return torch.mean(torch.pow((x - y), 2))
第二步:准备数据
# 第二步:准备数据集,模拟一个线性拟合过程
x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
[9.779], [6.182], [7.59], [2.167], [7.042],
[10.791], [5.313], [7.997], [3.1]], dtype=np.float32)
y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
[3.366], [2.596], [2.53], [1.221], [2.827],
[3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
# 将numpy数据转化为torch的张量
inputs = torch.from_numpy(x_train)
targets = torch.from_numpy(y_train)
第三步:构建模型
input_size = 1
output_size = 1
num_epochs = 60
learning_rate = 0.001
# 第三步: 构建模型,构建一个一层的网络模型
model = nn.Linear(input_size, output_size)
# 与模型相关的配置、损失函数、优化方式
# 使用自定义函数,等价于criterion = nn.MSELoss()
criterion = My_loss()
# 定义迭代优化算法, 使用的是随机梯度下降算法
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
第四步:训练模型
loss_history = []
# 第四步:训练模型,迭代训练
for epoch in range(num_epochs):
# 前向传播计算网络结构的输出结果
outputs = model(inputs)
# 计算损失函数
loss = criterion(outputs, targets)
# 反向传播更新参数,三步策略,归零梯度——>反向传播——>更新参数
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 打印训练信息和保存loss
loss_history.append(loss.item())
if (epoch+1) % 5 == 0:
print ('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
'''运行结果为:
Epoch [5/60], Loss: 33.1027
Epoch [10/60], Loss: 13.5878
Epoch [15/60], Loss: 5.6819
Epoch [20/60], Loss: 2.4788
Epoch [25/60], Loss: 1.1810
Epoch [30/60], Loss: 0.6551
Epoch [35/60], Loss: 0.4418
Epoch [40/60], Loss: 0.3552
Epoch [45/60], Loss: 0.3199
Epoch [50/60], Loss: 0.3055
Epoch [55/60], Loss: 0.2994
Epoch [60/60], Loss: 0.2968
'''
第五步:结果展示
# 第五步:结果展示。画出原y与x的曲线与网络结构拟合后的曲线
predicted = model(torch.from_numpy(x_train)).detach().numpy() #模型输出结果
plt.plot(x_train, y_train, 'ro', label='Original data') #原始数据
plt.plot(x_train, predicted, label='Fitted line') #拟合之后的直线
plt.legend()
plt.show()
# 画loss在迭代过程中的变化情况
plt.plot(loss_history, label='loss for every epoch')
plt.legend()
plt.show()
运行结果为: