task6

【Task6(2天)】PyTorch理解更多神经网络优化方法
参考：
1.了解不同优化器
神经网络的学习的目的是找到使损失函数的值尽可能小的参数。这是寻找最优参数的问题，解决这个问题的过程称为最优化
神经网络优化器，主要是为了优化我们的神经网络，使他在我们的训练过程中快起来，节省社交网络训练的时间。在pytorch中提供了torch.optim方法优化我们的神经网络，torch.optim是实现各种优化算法的包。最常用的方法都已经支持，接口很常规，所以以后也可以很容易地集成更复杂的方法。

2.书写优化器代码
要构造一个Optimizer，你必须给它一个包含参数（必须都是Variable对象）进行优化。然后，您可以指定optimizer的参 数选项，比如学习率，权重衰减等。具体参考torch.optim中文文档
optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr = 0.0001)
3.Momentum
4.二维优化，随机梯度下降法进行优化实现
5.Ada自适应梯度调节法
6.RMSProp
7.Adam
Stochastic Gradient Descent (SGD) SGD是最基础的优化方法，普通的训练方法,
需要重复不断的把整套数据放入神经网络NN中训练, 这样消耗的计算资源会很大.当我们使用SGD会把数据拆分后再分批不断放入 NN 中计算.
每次使用批数据, 虽然不能反映整体数据的情况, 不过却很大程度上加速了 NN 的训练过程, 而且也不会丢失太多准确率.
momentum是模拟物理里动量的概念，积累之前的动量来替代真正的梯度。
特点
下降初期时，使用上一次参数更新，下降方向一致，乘上较大的\mu能够进行很好的加速。由于下降方向和梯度方向一致，而使t时刻的动量变大和t时刻的变化量变大，从而达到加速的目的
下降中后期时，在局部最小值来回震荡的时候，KaTeX parse error: Expected 'EOF', got '&' at position 10: gradient-&̲gt;t_0使得更新幅度增大，跳出陷阱
在梯度改变方向的时候，\mu能够减少更新 总而言之，momentum项能够在相关方向加速SGD，抑制振荡，从而加快收敛
AdaGrad 优化学习率，使得每一个参数更新都会有自己与众不同的学习率。与momentum类似，不过不是给喝醉酒的人安排另一个下坡,
而是给他一双不好走路的鞋子, 使得他一摇晃着走路就脚疼, 鞋子成为了走弯路的阻力, 逼着他往前直着走.
RMSProp 有了 momentum 的惯性原则 , 加上 adagrad 的对错误方向的阻力, 我们就能合并成这样. 让
RMSProp同时具备他们两种方法的优势. 不过细心的同学们肯定看出来了, 似乎在 RMSProp 中少了些什么. 原来是我们还没把Momentum合并完全, RMSProp 还缺少了 momentum 中的 这一部分. 所以, 我们在 Adam 方法中补上了这种想法.
Adam 计算m 时有 momentum 下坡的属性, 计算 v 时有 adagrad 阻力的属性, 然后再更新参数时 把 m 和 V
都考虑进去. 实验证明, 大多数时候, 使用 adam 都能又快又好的达到目标, 迅速收敛. 所以说, 在加速神经网络训练的时候,一个下坡, 一双破鞋子, 功不可没.

SGD 就是随机梯度下降

opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)

momentum 动量加速,在SGD函数里指定momentum的值即可

opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)

RMSprop 指定参数alpha

opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)

Adam 参数betas=(0.9, 0.99)

opt_Adam = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))

8.PyTorch种优化器选择

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

# super param
LR = 0.01
BATCH_SIZE=32
EPOCH=12

x = torch.unsqueeze(torch.linspace(-1,1,1000),dim = 1)  #压缩为2维，因为torch 中 只会处理二维的数据
y = x.pow(2) + 0.2 * torch.rand(x.size())
print(x.numpy(),y.numpy())

torch_dataset = Data.TensorDataset(x, y)

loader = Data.DataLoader(
    dataset = torch_dataset,
    batch_size = BATCH_SIZE,
    shuffle = True,# true表示数据每次epoch是是打乱顺序抽样的
    num_workers = 2, # 每次训练有两个线程进行的？？？？？ 改成 1 和 2 暂时没看出区别
)

class Net(torch.nn.Module):  # 继承 torch 的 Module
    def __init__(self):
        super(Net, self).__init__()     # 继承 __init__ 功能
        # 定义每层用什么样的形式
        self.hidden = torch.nn.Linear(1,20)   # 隐藏层线性输出
        self.predict = torch.nn.Linear(20,1)   # 输出层线性输出

    def forward(self, x):   # 这同时也是 Module 中的 forward 功能
        # 正向传播输入值, 神经网络分析出输出值
        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] # 一个比一个高级

opt_SGD = torch.optim.SGD(net_SGD.parameters(),lr=LR)
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(),lr = LR,momentum=0.8) # 是SGD的改进，加了动量效果
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]
# 比较这4个优化器会发现，并不一定越高级的效率越高，需要自己找适合自己数据的优化器

loss_func = torch.nn.MSELoss()
losses_his = [[],[],[],[]]

if __name__ == '__main__': # EPOCH + win10 需要if main函数才能正确运行，
    for epoch in range(EPOCH):
        print(epoch)
        for step,(batch_x,batch_y) in enumerate(loader):
            b_x = Variable(batch_x)
            b_y = Variable(batch_y)

            for net,opt,l_his in zip(nets, optimizers, losses_his):
                output = net(b_x)  # get_out for every net
                loss = loss_func(output,b_y)  # compute loss for every net
                opt.zero_grad()
                loss.backward()
                opt.step() # apply gradient
                l_his.append(loss.data[0]) # 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()