pytorch学习之优化器torch.optim

功能：优化更新深度学习模型的参数
介绍：实现了深度学习中绝大多数的优化方法，例如RMSProp,Adam，SGD等，更便于应用，所以通常不需要手动写上述代码。
示例代码：

import torch.optim as optim
#新建一个优化器，指定需要调整的参数和学习率
optimizer = optim.SGD(net.parameters(), lr=0.01)

#在训练过程中，先梯度清零（与net.zero_grad()效果一样）
optimizer.zero_grad()

#计算损失
output = net(input)
loss = criterion(output, targer)

#反向传播
loss.backward()

#更新参数
optimizer.step()

不同优化方法的结果比较：
示例代码：

import torch
import torch.utils.data as Data
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt
'''
print(torch.__version__)
print(torch.cuda.is_available())
'''
#固定随机数
torch.manual_seed(1)    # reproducible
#print(torch.rand(1))

LR = 0.01 #learing rate
BATCH_SIZE = 32  #样本批次个数
EPOCH = 12   #训练轮次

# fake dataset：torch.unsqueeze：加上一个维度  torch.linspace：线性均匀分割
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
#print(x.size())
#y = x^2+（均值为0,然后拉伸0.1的正态分布）
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

# plot dataset
plt.scatter(x.numpy(), y.numpy())
plt.show()

# 使用上节内容提到的 data loader
#创建元组数据
torch_dataset = Data.TensorDataset(x, y)
#print(torch_dataset.tensors)
#torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
#DataLoader：加载数据，打乱数据，并且加速
#loader = Data.DataLoader(torch_dataset, BATCH_SIZE, shuffle=True, num_workers=2)

loader = Data.DataLoader(torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0,)
#print(loader.dataset)
#创建两层线性全连接网络
# 默认的 network 形式
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 20)   # hidden layer
        self.predict = torch.nn.Linear(20, 1)   # output layer

    def forward(self, x):
        x = F.relu(self.hidden(x))      # activation function for hidden layer
        x = self.predict(x)             # linear output
        return x

# 为每个优化器创建一个 net
net_SGD = Net()
net_Momentum = Net()
net_RMSprop = Net()
net_Adam = Net()
nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

#创建优化方法和loss
# different optimizers
opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)
opt_Momentum= torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
opt_RMSprop= torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
opt_Adam= torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]

loss_func = torch.nn.MSELoss()
losses_his = [[], [], [], []]   # 记录 training 时不同神经网络的 loss

#训练和作图



for epoch in range(EPOCH):
    print('Epoch: ', epoch)
    #print(loader)
    #enumerate:列出索引和元素
    for step, (batch_x, batch_y) in enumerate(loader):
        #print(step)
        #print((batch_x, batch_y))
        b_x = Variable(batch_x)  # 务必要用 Variable 包一下
        b_y = Variable(batch_y)
        #print(b_x)

        # 对每个优化器, 优化属于他的神经网络,各个优化器的loss
        for net, opt, l_his in zip(nets, optimizers, losses_his):
            output = net(b_x)              # get output for every net
            loss = loss_func(output, b_y)  # compute loss for every net
            opt.zero_grad()                # clear gradients for next train
            loss.backward()                # backpropagation, compute gradients
            opt.step()                     # apply gradients
            #print(loss.data)
            l_his.append(loss.data)     # loss recoder
#一共优化了EPOCH*BATCH_SIZE这么多次

#作图

labels = ['net_SGD', 'net_Momentum', 'net_RMSprop', 'net_Adam']
for i, l_hist in enumerate(losses_his):
    print(len(l_hist))
    #len(l_hist) = EPOCH*BATCH_SIZE
    plt.plot(l_hist, label=labels[i])
plt.legend(loc = 'best')
plt.xlabel('steps')
plt.ylabel('loss')
#纵轴坐标范围
plt.ylim((0, 0.2))
plt.show()

测试结果：

SGD 是最普通的优化器, 也可以说没有加速效果,
而 Momentum 是 SGD 的改良版, 它加入了动量原则. 后面的 RMSprop 又是 Momentum 的升级版. 而 Adam 又是 RMSprop 的升级版. 不过从这个结果中我们看到, Adam 的效果似乎比 RMSprop 要差一点. 所以说并不是越先进的优化器, 结果越佳. 我们在自己的试验中可以尝试不同的优化器, 找到那个最适合你数据/网络的优化器.
注：
（1）优化方法的基本使用方法
（2）如何对模型的不同部分设置不同的学习率
（3）如何调整学习率

参考链接：
https://blog.csdn.net/qq_20622615/article/details/83150963
https://www.pytorchtutorial.com/3-6-optimizer/