Task6.PyTorch理解更多神经网络优化方法

1.了解不同优化器

2.书写优化器代码
3.Momentum
4.二维优化，随机梯度下降法进行优化实现
5.Ada自适应梯度调节法
6.RMSProp
7.Adam
8.PyTorch种优化器选择

梯度下降法：

1.标准梯度下降法：GD
每个样本都下降一次，参考当前位置的最陡方向迈进容易得到局部最优，且训练速度慢

2.批量下降法：BGD
不再是一次输入样本调整一次，而是一批量数据后进行调整，模型参数的调整更新与全部输入样本的代价函数的和有关，即下山前掌握附近地势，选择最优方向。

3.随机梯度下降法SGD
在一批数据里随机选取一个样本。如盲人下山，并与用走一次计算一次梯度，总能到山底。但引入的噪声可能使得权值更新放下错误。，没法单独克服局部最优解。

动量优化法
标准动量优化momentum
当前权值的改变会受到上一次权值改变得影响。类似小球下滚得时候带上惯性，加快滚动速度。

NAG牛顿加速梯度

NAG牛顿加速梯度 施加当前速度后 ，往标准动量中添加一个校正因子。momentun小球盲目跟从梯度，但nag小球指走到坡底时速度慢下来，知道下一位置大致在哪，来更新当前位置参数。

Ada自适应梯度调节法: Adagrad：该算法的特点是自动调整学习率，适用于稀疏数据。梯度下降法在每一步对每一个参数使用相同的学习率，这种一刀切的做法不能有效的利用每一个数据集自身的特点。 Adadelta(Adagrad的改进算法)：Adagrad的一个问题在于随着训练的进行，学习率快速单调衰减。Adadelta则使用梯度平方的移动平均来取代全部历史平方和。

RMSProp：RMSprop也是一种学习率调整的算法。Adagrad会累加之前所有的梯度平方，而RMSprop仅仅是计算对应的平均值，因此可缓解Adagrad算法学习率下降较快的问题。

Adam：如果把Adadelta里面梯度的平方和看成是梯度的二阶矩，那么梯度本身的求和就是一阶矩。Adam算法在Adadelta的二次矩基础之上又引入了一阶矩。而一阶矩，其实就类似于动量法里面的动量。

 import torch
 import torch.utils.data as Data
 import torch.nn.functional as F
 import matplotlib.pyplot as plt

 LR = 0.01
 BATCH_SIZE = 32
 EPOCH = 12

 x = torch.unsqueeze(torch.linspace(-1,1,1000),dim=1)
 y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

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

 torch_dataset = Data.TensorDataset(x,y)
 loader = Data.DataLoader(dataset=torch_dataset,batch_size=BATCH_SIZE,shuffle=True,num_workers=2)

 torch_dataset = Data.TensorDataset(x,y)
 loader = Data.DataLoader(
     dataset=torch_dataset,
     batch_size=BATCH_SIZE,
     shuffle=True,
     num_workers=2,
 )

 class Net(torch.nn.Module):
     def __init__(self):
         super(Net,self).__init__()

         self.hidden = torch.nn.Linear(1,20)
         self.predict = torch.nn.Linear(20,1)

     def forward(self,x):
         x = F.relu(self.hidden(x))
         x = self.predict(x)
         return x

 net_SGD         = Net()
 net_Momentum    = Net()
 net_RMSprop     = Net()
 net_Adam        = Net()
 nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

 # 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 = [[], [], [], []]   # record loss

 # training
 for epoch in range(EPOCH):
     print('Epoch: ', epoch)
     for step, (b_x, b_y) in enumerate(loader):          # for each training step
         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
             l_his.append(loss.data.numpy())     # loss recoder

 labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
 for i, l_his in enumerate(losses_his):
     plt.plot(l_his, label=labels[i])
 plt.legend(loc='best')
 plt.xlabel('Steps')
 plt.ylabel('Loss')
 plt.ylim((0, 0.2))
 plt.show()

参考：https://blog.csdn.net/qingxuanmingye/article/details/90514018