Pytorch深度学习实践（b站刘二大人）_05讲（用Pytorch实现线性回归）

Pytorch Fashion（具有很强的扩展性）：
1.准备数据集
2.设计模型
3.构造损失函数和优化器
4.训练周期（前馈、反馈、更新）
　　
　　在本次代码的编写中，我尝试了很多种优化器的使用，包括 SGD，Adagrad ，Adam ，ASGD, RMSprop ,Rprop，Adamax,以及LBFGS，每个优化器所对应的Loss下降图也会在文章的最后给出。
　　其中LBFGS的使用和以上其他的优化器有一些不同，LBFGS需要重复多次计算函数，因此你需要传入一个闭包去允许它们重新计算你的模型，这个闭包应当清空梯度， 计算损失，然后返回，即optimizer.step(closure)；其他的优化器支持简化的版本即optimizer.step()。
下面介绍一下两种方式使用的模板：
optimizer.step(closure)

for input, target in dataset:

　　def closure():

　　　　optimizer.zero_grad()

　　　　output = model(input)

　　　　loss = loss_fn(output, target)

　　　　loss.backward()

　　return loss optimizer.step(closure)

optimizer.step()

for input, target in dataset:

　　optimizer.zero_grad()

　　output = model(input)

　　loss = loss_fn(output, target)

　　loss.backward()

　　optimizer.step()

代码如下：

import torch
import matplotlib.pyplot as plt
# 1.准备数据集           2.设计模型
# 3.构造损失函数和优化器   4.训练周期（前馈、反馈、更新）

x_data = torch.Tensor([[1.0],[2.0],[3.0]])
y_data = torch.Tensor([[2.0],[4.0],[6.0]])

class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel,self).__init__()
        self.linear = torch.nn.Linear(1,1)# torch.nn.Linear(in,out,bias=true)
                                          #in: 输入的维度
                                          #out：输出的维度
                                          #bias： 布尔类型，是否需要偏置量，默认为True
    def forward(self,x):
        y_pred = self.linear(x)     #
        return y_pred

model =LinearModel()

#critersion = torch.nn.MSELoss(size_average=False)
critersion = torch.nn.MSELoss(reduction='sum')

#optimizer = torch.optim.SGD(model.parameters(),lr=0.01)
#optimizer = torch.optim.Adagrad(model.parameters(),lr=0.9)  
#optimizer = torch.optim.Adam(model.parameters(),lr=0.05)
#optimizer = torch.optim.ASGD(model.parameters(),lr=0.01)
#optimizer = torch.optim.RMSprop(model.parameters(),lr=0.01)
#optimizer = torch.optim.Rprop(model.parameters(),lr=0.01) 
#optimizer = torch.optim.Adamax(model.parameters(),lr=0.0５)
optimizer = torch.optim.LBFGS(model.parameters(),lr=0.01) #使用该方法时，step（）需传入closure参数


epoch_list = []
loss_list = []
# for epoch in range(1000):
#     y_pred = model(x_data)
#     loss = critersion(y_pred,y_data)
#     print(epoch,loss)
#     epoch_list.append(epoch)
#     loss_list.append(loss)
#     optimizer.zero_grad()
#     loss.backward()
#     optimizer.step()        #更新参数，即更新w和b的值

# LBFGS 方法
for epoch in range(1000):
    def closure():
        #Forward
        optimizer.zero_grad()
        y_pred = model(x_data)
        loss = critersion(y_pred, y_data)
        print(epoch, loss)
        epoch_list.append(epoch)
        loss_list.append(loss)
        #Backward
        loss.backward()
        return loss
     #Update   
    optimizer.step(closure)        #更新参数，即更新w和b的值

# Output weight and bias

print('w = ',model.linear.weight.item())
print('b = ',model.linear.bias.item())

#Test Model
x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print('y_pred',y_test.data)

plt.plot(epoch_list,loss_list)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.grid()
plt.show()

运行结果（使用的LBFGS优化器）图：
　　　　　　　　
　以下是各个优化器所对应的Loss下降图，其中一开始使用Adagrad优化器的训练结果和目标结果出人有点大，后来发现它的lr（学习率）的参数包括其它优化器使用的都是 lr=0.01,然后我将参数改为 lr=0.9之后，优化效果就变好了，包括使用其他的优化器得到的结果不理想时，都可以试试不同的参数。
　　　　　　　　　　
　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　SGD:　y_pred tensor([[7.9993]])
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　y_pred tensor([[8.0000]])
　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　y_pred tensor([[8.0000]])
　　　　　　　　　　　　　　　
　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　y_pred tensor([[7.9991]])
　　　　　　　　　
　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　y_pred tensor([[7.9999]])
　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　y_pred tensor([[8.0000]])
　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　y_pred tensor([[7.9772]])

参考文章：pytorch的优化器optimizer使用方法
　　　　　PyTorch学习（四）–用PyTorch实现线性回归