Pytorch——可视化不同的优化器效果

1.前言

今天主要运用Pytorch实现不同优化器的效果，以可视化的图像形式展现。

2.制造人工数据

为了对比各种优化器的效果, 我们需要有一些数据, 今天我们还是自己编一些伪数据, 这批数据是这样的:

import torch
from torch.utils.data import TensorDataset, DataLoader
import torch.nn.functional as F
import torch.nn as nn

torch.manual_seed(111)

#可人为设定大小的超参数
LR = 0.02
BATCH_SIZE = 8
EPOCHS = 10

x = torch.unsqueeze(torch.linspace(-1,1,100), dim = 1)  #unsqueeze() 是为了体现batch的维度
y = x.pow(2) + 0.08*torch.normal(torch.zeros(x.size()))

plt.scatter(x.numpy(), y.numpy())
plt.show()

3.做DataLoader迭代器

dataset = TensorDataset(x, y)
data_loader = DataLoader(
        dataset,
        batch_size = BATCH_SIZE,
        shuffle = True,
        num_workers = 2)

4.搭建神经网络模型

为了对比每一种优化器, 我们给他们各自创建一个神经网络, 但这个神经网络都来自同一个 NetWork形式

class NetWork(nn.Module):
    
    def __init__(self):
        super(NetWork, self).__init__()
        self.hidden = nn.Linear(1,8)
        self.output = nn.Linear(8,1)
    
    def forward(self,x):
        output = F.relu(self.hidden(x))  #经过一个隐藏层后再用ReLU激活
        output = self.output(output)
        return output
    
#实例化四个模型
network_for_SGD = NetWork()
network_for_Momentum = NetWork()
network_for_RMSprop = NetWork()
network_for_Adam = NetWork()

networks = [network_for_SGD, network_for_Momentum, network_for_RMSprop, network_for_Adam]  #放入list中以便于for循环

5.将神经网络模型放入优化器中

接下来在创建不同的优化器, 用来训练不同的网络. 并创建一个 loss_func 用来计算误差. 我们用几种常见的优化器, SGD, Momentum, RMSprop, Adam.

optimizer_for_SGD = torch.optim.SGD(network_for_SGD.parameters(), lr = LR)
network_for_Momentum = torch.optim.SGD(network_for_Momentum.parameters(), lr = LR, momentum = 0.8)
network_for_RMSprop = torch.optim.RMSprop(network_for_RMSprop.parameters(), lr = LR, alpha = 0.9)
network_for_Adam = torch.optim.Adam(network_for_Adam.parameters(), lr = LR, betas = (0.9,.099))

optimizers = [optimizer_for_SGD, network_for_Momentum, network_for_RMSprop, network_for_Adam]  #把优化器放入list中

loss_func = torch.nn.MSELoss()    #损失函数用均方误差（适用于回归）
loss_list = [[],[],[],[],[]]       #用于记录误差

6.并对比不同优化器

for epoch in range(EPOCHS):
    print('Epoch:',epoch)
    for step, (b_x, b_y) in enumerate(data_loader):
        
        #b_x = Variable(b_x)
        #b_y = Variable(b_y)
        
        for network, optimizer, loss_list in zip(networks, optimizers, loss_lists):  #把三个列表捆在一起再一个一个拿出来
            output = network(b_x)
            loss = loss_func(output, b_y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            loss_list.append(loss.data.numpy())

labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
plt.figure(1, figsize = (10,7))
for i,l_his in enumerate(loss_lists):
    plt.plot(l_his, label = labels[i])
plt.legend(loc = 'best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim(0,0.4)
plt.show()