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