莫烦pytorch（9）——optimizer

1.画图

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)   #（1000,1）
y=x.pow(2)+0.1*torch.normal(torch.zeros(x.size()))      #这里用torch.power(x,2)一样
plt.scatter(x.data.numpy(),y.data.numpy())
plt.show()

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

3.主函数

介绍了4种常用的优化器,SGD, Momentum, RMSprop, Adam，他们都在torch.optim里面。

1.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)

params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) – 学习率（默认：1e-3）
betas (Tuple[float, float], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数（默认：0.9，0.999）
eps (float, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）
weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认: 0）

需要momentum可以自己在参数加上

2.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float) – 学习率
momentum (float, 可选) – 动量因子（默认：0）
weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认：0）
dampening (float, 可选) – 动量的抑制因子（默认：0）
nesterov (bool, 可选) – 使用Nesterov动量（默认：False）

3.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)

params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
lr (float, 可选) – 学习率（默认：1e-2）
momentum (float, 可选) – 动量因子（默认：0）
alpha (float, 可选) – 平滑常数（默认：0.99）
eps (float, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8）
centered (bool, 可选) – 如果为True，计算中心化的RMSProp，并且用它的方差预测值对梯度进行归一化
weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认: 0）

if __name__=="__main__":
    net_SGD=Net()
    net_Momentum = Net()
    net_RMSprop = Net()
    net_Adam = Net()
    nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]  # 将4个网络放到一个list中

    # 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]  # 将4个优化器放到一个list中
    loss_func=torch.nn.MSELoss()
    loss_his=[[],[],[],[]]

    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,loss_his):
                output=net(b_x)
                loss=loss_func(output,b_y)
                opt.zero_grad()
                loss.backward()
                opt.step()
                l_his.append(loss.data.numpy())

    labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
    for i, l_his in enumerate(loss_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()

可以看出Adam和RMsprop比别的都快并且表现的好
————————————————————————————————————————————————我是一名机器学习的初学者，是万千小白中努力学习中的一员