头歌之动手学人工智能-Pytorch 之优化

第1关：如何使用optimizer

任务描述

编程要求

测试说明

真正的科学家应当是个幻想家；谁不是幻想家，谁就只能把自己称为实践家。 —— 巴尔扎克开始你的任务吧，祝你成功！

第2关：optim.SGD

任务描述

编程要求

测试说明

真正的科学家应当是个幻想家；谁不是幻想家，谁就只能把自己称为实践家。 —— 巴尔扎克开始你的任务吧，祝你成功！

第3关：RMSprop

任务描述

编程要求

测试说明

真正的科学家应当是个幻想家；谁不是幻想家，谁就只能把自己称为实践家。 —— 巴尔扎克开始你的任务吧，祝你成功！

第4关：Adam

任务描述

编程要求

测试说明

知识有如人体血液一样的宝贵。人缺少了血液，身体就要衰弱，人缺少了知识，头脑就要枯竭。——高士其开始你的任务吧，祝你成功！

第5关：优化器总结

任务描述

编程要求

测试说明

开始你的任务吧，祝你成功！

第1关：如何使用optimizer

torch.optim是一个实现了各种优化算法的库。大部分常用的方法得到支持，并且接口具备足够的通用性，使得未来能够集成更加复杂的方法。

任务描述

本关任务：

本关卡要求同学们声明一个 SGD 优化器 optimizer，按照要求传入优化器的参数。同时，为了便于观察，利用optimizer.param_groups方法查看优化器的各项参数并输出。

编程要求

本关涉及的代码文件为optimizer.py，本次编程任务是补全右侧代码片段中Begin至End中间的代码。其中，本关声明了一个线性模型 linear，将该模型的相关参数进行操作，具体要求如下：

声明一个 SGD 优化器 optimizer，将 linear 的参数作为优化器的参数传入其中，其学习率lr设为0.1；
利用optimizer.param_groups即可查看优化器的各项参数并输出lr的值。
具体请参见后续测试样例。

测试说明

测试过程：

本关涉及的测试文件为optimizerTest.py，运行用户填写后的程序判断正误。
根据程序是否包含创建正则化的关键语句来判断程序是否正确，如是否含有optimizer.param_groups、optim.SGD等语句。
若正确则输出下面的预期输出，否则报错，打印 Sorry ! Check again please!。
以下是测试样例：

测试输入：
预期输出：
lr: 0.1

Congratulation!

真正的科学家应当是个幻想家；谁不是幻想家，谁就只能把自己称为实践家。 —— 巴尔扎克
开始你的任务吧，祝你成功！

import torch.nn as nn
import torch.optim
import torch
from torch.autograd import Variable

# Linear Regression Model
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(2, 2)  # input and output is 2 dimension
    
    def forward(self, x):
        out = self.linear(x)
        return out
model = LinearRegression()



#/********** Begin *********/

#声明一个 SGD优化器 optimizer，传入参数

#利用optimizer.param_groups查看优化器的各项参数并输出lr的值。

#/********** End *********/

第2关：optim.SGD

任务描述

本关任务：

本次关卡要求同学们声明一个 SGD优化器 optimizer，掌握为不同的子网络参数设置不同的学习率，并按照相关格式要求输出相应语句。

编程要求

本关涉及的代码文件为 SGDoptimizer.py，本次编程任务是补全右侧代码片段中Begin至End中间的代码，其中，程序提前声明了一个线性模型为model，按照要求利用该模型完成实验，具体要求如下：

声明一个 SGD优化器 optimizer，其中，模型model中的linear层学习率为默认值1e-5，linear2层的学习率为0.01；

按照“The len of param_groups list:...”格式输出 optimizer.param _groups的长度；

按照“linear's lr:...”格式输出linear层的lr；

按照“linear2's lr:...”格式输出linear2层的lr；

具体请参见后续测试样例。

测试说明

测试过程：

本关涉及的测试文件为SGDoptimizerTest.py，运行用户填写后的程序判断正误。

根据程序是否包含创建正则化的关键语句来判断程序是否正确，如是否含有optim.SGD，len()，optimizer.param_groups等语句。

若正确则输出下面的预期输出，否则报错，打印 Sorry ! Check again please!。
注意，在声明变量时请按照提示命名，否则将会报错。
以下是测试样例：

测试输入：
预期输出：
The len of param_groups list: 2
linear's lr: 1e-05
linear2's lr: 0.01

Congratulation!

真正的科学家应当是个幻想家；谁不是幻想家，谁就只能把自己称为实践家。 —— 巴尔扎克
开始你的任务吧，祝你成功！

import torch.nn as nn
import torch.optim
import torch
from torch.autograd import Variable


# Linear Regression Model
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(2, 2)  # input and output is 1 dimension
        self.linear2 = nn.Linear(2, 2)
    
    def forward(self, x):
        out = self.linear(x)
        out = self.linear2(out)
        return out
model = LinearRegression()



#/********** Begin *********/

#声明一个 SGD优化器 optimizer， 按要求设置 lr 的值
optimizer = torch.optim.SGD([
                {'params': model.linear.parameters(), 'lr': 1e-5},
                {'params':model.linear2.parameters()}
            ], lr=0.01, momentum=0.9)
#按照格式输出optimizer.param_groups的长度
print('The len of param_groups list:',len(optimizer.param_groups))
#按照格式输出linear层的lr
print("linear's lr:",optimizer.param_groups[0]['lr'])
#按照格式输出linear2层的lr
print("linear2's lr:",optimizer.param_groups[1]['lr'])

#/********** End *********/

第3关：RMSprop

任务描述

本关任务：

本关要求同学们声明一个 RMSprop优化器optimizer，设置其lr和alpha的数值。并补充优化器基本使用方法的相关步骤：清空梯度和更新参数。最后，按照格式输出相关信息。

编程要求

本关涉及的代码文件为RMSprop.py，本次编程任务是补全右侧代码片段中Begin至End中间的代码。其中，程序提前声明了一个线性模型为model，和训练数据x_train、y_train，按照要求利用这些信息完成实验，具体要求如下：

声明一个 RMSprop优化器optimizer，设置 lr为0.1，alpha为 0.9；
补充优化器基本使用方法的相关步骤：清空梯度，计算Loss，反向传播，更新参数。其中，计算Loss，反向传播两步骤的相关代码已给出；
按照格式“optimizer's lr:... ”输出optimizer的lr；
按照格式“optimizer's alpha:... ”输出optimizer的alpha。
具体请参见后续测试样例。

测试说明

测试过程：

本关涉及的测试文件为RMSpropTest.py，运行用户填写后的程序判断正误。
根据程序是否包含创建正则化的关键语句来判断程序是否正确，如是否含有 optim.SGD ，len()，optimizer.param_groups等语句。
若正确则输出下面的预期输出，否则报错，打印 Sorry ! Check again please!。注意，在声明变量时请按照提示命名，否则将会报错。
以下是测试样例：

测试输入：
预期输出：
optimizer's lr: 0.1
optimizer's alpha: 0.9

Congratulation!

真正的科学家应当是个幻想家；谁不是幻想家，谁就只能把自己称为实践家。 —— 巴尔扎克
开始你的任务吧，祝你成功！

import torch
from torch import nn, optim
from torch.autograd import Variable
import numpy as np
# Linear Regression Model
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1,1)  # input and output is 1 dimension
    
    def forward(self, x):
        out = self.linear(x)
        return out

x_train = Variable(torch.randn(1,1))
y_train = Variable(torch.randn(1,1))
criterion = nn.MSELoss()

model = LinearRegression()

#/********** Begin *********/

#声明一个 RMSprop 优化器 optimizer， 按要求设置 lr,alpha 的值
optimizer = torch.optim.RMSprop(model.parameters(), lr=0.1, alpha=0.9)  
#清空梯度
optimizer.zero_grad()
#计算Loss
loss = criterion(model(x_train), y_train)
#反向传播
loss.backward()
#更新参数
optimizer.step()
#按照格式输出optimizer的lr
print("optimizer's lr:",optimizer.param_groups[0]['lr'])
##按照格式输出optimizer的alpha
print("optimizer's alpha:",optimizer.param_groups[0]['alpha'])

#/********** End *********/

第4关：Adam

任务描述

本关任务：

本关要求同学们声明两个 Adam 优化器optimizer1和 optimizer2，分别传入程序提前声明好的线性模型model_Adam1和model_Adam2的参数值，分别设置他们lr和beats的数值。并对每个优化器，优化属于他的神经网络。从而，根据 loss的值判断哪个优化器表现较好，按照格式输出相关信息。

编程要求

本关涉及的代码文件为adam.py，本次编程任务是补全右侧代码片段中Begin至End中间的代码，其中，程序提前声明好的线性模型model_Adam1和model_Adam2，和训练数据x_train、y_train，按照要求利用这些信息完成实验，具体要求如下：

声明一个Adam优化器 optimizer1，传入model_Adam1的属性值，设置 lr为0.2，betas为(0.9,0.9)；
声明一个Adam优化器 optimizer2，传入model_Adam2的属性值，设置 lr为0.001， betas为(0.9,0.9)；
程序对迭代十次的loss值求和。要求同学们按要求输出相应语句。
若 loss1小于loss2，输出“opt_Adam1 is better than opt_Adam2”；
否则输出“opt_Adam2 is better than opt_Adam1”。
具体请参见后续测试样例。

测试说明

测试过程：

本关涉及的测试文件为adamTest.py，运行用户填写后的程序判断正误。
根据程序是否包含创建正则化的关键语句来判断程序是否正确，如是否含有Adam，if，else，lr，betas等语句。
若正确则输出下面的预期输出，否则报错，打印 Sorry ! Check again please!。注意，在声明变量时请按照提示命名，否则将会报错。
以下是测试样例：

测试输入：
预期输出：
opt_Adam1 is better than opt_Adam2

Congratulation!

知识有如人体血液一样的宝贵。人缺少了血液，身体就要衰弱，人缺少了知识，头脑就要枯竭。——高士其
开始你的任务吧，祝你成功！

import torch
from torch import nn, optim
from torch.autograd import Variable
import numpy as np
# Linear Regression Model
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(2,2)  # input and output is 2 dimension
    
    def forward(self, x):
        out = self.linear(x)
        return out

x_train = Variable(torch.from_numpy(np.array([[1,2],[3,4]], dtype=np.float32)))
y_train = Variable(torch.from_numpy(np.array([[1,5],[2,8]], dtype=np.float32)))

model_Adam1 = LinearRegression()
model_Adam2 = LinearRegression()
models = [model_Adam1,model_Adam2]
#/********** Begin *********/

#声明一个Adam优化器 optimizer1， 设置 lr为0.2，betas为(0.9,0.9)
opt_Adam1 = torch.optim.Adam(model_Adam1.parameters(),lr=0.2,betas=(0.9,0.9))
#声明一个Adam优化器 optimizer2， 设置 lr为0.001，betas为(0.9,0.9)
opt_Adam2 = torch.optim.Adam(model_Adam2.parameters(),lr=0.001,betas=(0.9,0.9))

optimizers = [opt_Adam1,opt_Adam2]
losses_his = [[],[]]
loss_func = nn.MSELoss()

for epoch in range(10):
    # 对每个优化器, 优化属于他的神经网络
    for model,opt, l_his in zip(models,optimizers, losses_his):
        output = model(x_train)
        loss = loss_func(output, y_train)
        opt.zero_grad()
        loss.backward()
        opt.step()
        l_his.append(loss.item())
loss1 = sum(losses_his[0])
loss2 = sum(losses_his[1])

#利用 if-else 结构判断 loss1、loss2的大小
#若loss1小于loss2，输出“opt_Adam1 is better than opt_Adam2”；
#否则输出“opt_Adam2 is better than opt_Adam1”。
if loss1 > loss2:
    print("opt_Adam2 is  better than opt_Adam1")
else:
    print("opt_Adam1 is  better than opt_Adam2")

#/********** End *********/

第5关：优化器总结

任务描述

本关任务：

本关要求同学们掌握不同优化器的特点，根据提示，利用不同的优化器进行训练，并利用loss 画图。

编程要求

本关涉及的代码文件为compare.py，本次编程任务是补全右侧代码片段中Begin至End中间的代码。根据提示，计算并利用loss 画图。

测试说明

我会对你编写的代码进行测试：
测试过程：

本关涉及的测试文件为compareTest.py，运行用户填写后的程序判断正误。
根据程序是否包含创建正则化的关键语句来判断程序是否正确。
若正确则输出下面的预期输出，否则报错。
注意，在声明变量时请按照提示命名，否则将会报错。
测试输入：
预期输出：

Congratulation!

开始你的任务吧，祝你成功！

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


import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

import warnings
warnings.filterwarnings('ignore')

import os,sys
path = os.path.split(os.path.abspath(os.path.realpath(sys.argv[0])))[0] + os.path.sep
print("validation path:" ,path)

#定义参数
LR = 0.01
BATCH_SIZE = 32
EPOCH = 10

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
y = x.pow(2) + 0.1*torch.randn(x.size())
# torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
torch_dataset = Data.TensorDataset(x, y) 
loader = Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2,)

# 默认的 network 形式
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 40)
        self.predict = torch.nn.Linear(40, 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]

#/********** Begin *********/

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

# 声明优化器opt_Momentum，传入对应的模型参数，lr 赋值为 LR，momentum为0.7
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(),lr=LR,momentum=0.7)
# 声明优化器opt_RMSprop，传入对应的模型参数，lr 赋值为 LR，alpha为0.9
opt_RMSprop = torch.optim.RMSprop(net_RMSprop.parameters(),lr=LR,alpha=0.9)
# 声明优化器opt_Adam，传入对应的模型参数，lr 赋值为 LR，betas为(0.9, 0.99)
opt_Adam = torch.optim.Adam(net_Adam.parameters(),lr=LR,betas=(0.9,0.99))

#/********** End *********/
optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]
loss_func = torch.nn.MSELoss()

losses_his = [[], [], [], []]

#训练循环
for epoch in range(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)
            loss = loss_func(output, b_y)

            #/********** Begin *********/
            opt.zero_grad()
            # 反向传播
            loss.backward()
            # 更新参数 
            opt.step()
            # 记录损失    
            l_his.append(loss.item())   
            #/********** End *********/
         
         
#画图
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.savefig(path + "outputimages/mylossTest.png")