深度学习开发框架PyTorch（5）-- 神经网络训练

更新于
搭建好了模型，选好了损失函数和优化器就可以执行训练了。

一、损失函数

在深度学习中要用到各种各样的损失函数（Loss Function），这些损失函数可以看作一种特殊的layer，PyTorch也将这些损失函数实现为nn.Module的子类。

1
2
3
4
5
6
7
8
9
10
11
12
# 绝对值损失
criterion = nn.L1Loss()
# Huber损失
criterion = nn.SmoothL1Loss()
# 平方损失
criterion = nn.MSELoss()
# 交叉熵损失
criterion = nn.CrossEntropyLoss()
# 负对数似然损失
criterion = nn.NLLLoss()
# 带泊松分布的负对数似然损失
criterion = nn.PoissonNLLLoss()

更多损失函数

二、优化器

PyTorch将深度学习中常用的优化方法全部封装在torch.optim中，其设计十分灵活，能够很方便地扩展成自定义的优化方法。
SGD 是最普通的优化器, 也可以说没有加速效果, 而 Momentum 是 SGD 的改良版, 它加入了动量原则. 后面的 RMSprop 又是 Momentum 的升级版. 而 Adam 又是 RMSprop 的升级版。 

1
2
3
4
5
6
7
8
# SGD 就是随机梯度下降
opt_SGD = torch.optim.SGD(net.parameters(), lr=LR)
# momentum 动量加速,在SGD函数里指定momentum的值即可
opt_Momentum = torch.optim.SGD(net.parameters(), lr=LR, momentum=0.8)
# RMSprop 指定参数alpha
opt_RMSprop = torch.optim.RMSprop(net.parameters(), lr=LR, alpha=0.9)
# Adam 参数betas=(0.9, 0.99)
opt_Adam = torch.optim.Adam(net.parameters(), lr=LR, betas=(0.9, 0.99))

更多优化器

三、神经网络的训练

搭建好了模型，选好了损失函数和优化器就可以执行训练了。每个epoch首先要获得模型前馈得到的预测值，然后通过损失函数来比较预测和真实值之间的差异。在运行优化器之前，要运行一下zero_grad()，它可以清除所有的梯度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
# coding=utf-8
import torch as t
import torch.nn as nn
from torch.autograd import Variable as V
import torch.optim as opt

import matplotlib.pyplot as plt

#########################################################
# 生成待拟合数据
#########################################################

x = t.unsqueeze(t.linspace(-1, 1, 100), dim=1)
y = x.pow(2) + 0.2 * t.rand(x.size())
 
x, y = V(x), V(y)

#########################################################
# 构建模型
#########################################################

class myNet(nn.Module):
    def __init__(self, n_features, n_hidden, n_output):
        super(myNet, self).__init__()
        self.hidden = nn.Linear(n_features, n_hidden)
        self.predict = nn.Linear(n_hidden, n_output)
 
    def forward(self, x):
        x = self.hidden(x)
        x = self.predict(nn.ReLU()(x))
        return x
 
net = myNet(1, 10, 1)
print(net)

#########################################################
# 实例化损失函数和优化器
#########################################################

criterion = nn.MSELoss()
optimaizer = opt.SGD(net.parameters(), lr=0.5)

#########################################################
# 模型训练
#########################################################

for t in range(100):
    optimaizer.zero_grad()  # 清除梯度
	
    prediction = net(x)
    loss = criterion(prediction, y)
    loss.backward()
    optimaizer.step()
 
    if t % 5 == 0:
        plt.cla()
        plt.scatter(x.data.numpy(), y.data.numpy())
        plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data, fontdict={'size': 20, 'color': 'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()
0%