pytorch实现线性回归

"""
目标：
知道如何手动完成线性回归

假设我们的基础模型就是y = wx+b，其中w和b均为参数，我们使用y = 3x+0.8来构造数据x、y，所以最后通过模型应该能够得出w和b应该分别接近3和0.8

步骤：
1、准备数据
2、计算预测值
3、计算损失，把参数的梯度值置为0，进行反向传播
4、更新参数
"""

# import torch
# import numpy
# from matplotlib import pyplot as plt
#
# # 1、准备数据
# x = torch.rand([50])
# y = 3 * x + 0.8
#
# w = torch.rand(1,requires_grad=True)
# b = torch.rand(1,requires_grad=True)
#
# def loss_fn(y,y_predict):
#     loss = (y_predict - y).pow(2).mean()
#     for i in [w,b]:
#         # 每次反向传播前把梯度置为0
#         if i.grad is not None:
#             i.grad.data.zero_()
#     loss.backward()
#     return loss.data
#
# def optimize(learning_rate):
#     w.data -= learning_rate * w.grad.data
#     b.data -= learning_rate * b.grad.data
#
# for i in range(3000):
#     # 计算预测值
#     y_predict = x * w + b
#
#     # 计算损失值，把参数的梯度置为0，进行反向传播
#     loss = loss_fn(y,y_predict)
#
#     if i % 500 == 0:
#         print(i,loss)
#     # 更新参数w和b
#     optimize(0.01)
#
# # 绘制图像，观察训练值和预测值
# predict = x * w + b  # 这里的w和b是经过训练得到的
# plt.scatter(x.data.numpy(),y.data.numpy(),c = 'r')  # 将数据表示在图上
# plt.plot(x.data.numpy(),predict.data.numpy())
# plt.show()
#
# print('w:',w)
# print('b:',b)






# pytorch基础模型
"""
目标：
知道如何使用pytorch模型组件构建模型
知道如何在GPU上运行代码
能够说出常见的优化器及其原理
"""

# 1、使用pytorch模型组件把线性回归完成代码
"""
构建模型，最重要的有两个步骤：

找到合适的计算关系，随即初始化参数来拟合输入和输出的关系（前向计算，从输入得到输出）
选取合适的损失函数和优化器来减小损失（反向传播，得到合适的参数）
"""

# import torch
# from torch import nn
# from torch import optim
# import numpy as np
# from matplotlib import pyplot as plt
#
# # 定义数据
# x = torch.rand([50,1])
# print(x.shape)
# y = x * 3 + 0.8
#
# # 定义模型：
# class Lr(nn.Module):
#     def __init__(self):
#         super(Lr,self).__init__()
#         self.linear = nn.Linear(1,1)
#
#     def forward(self,x):
#         out = self.linear(x)
#         return out
#
# # 实例化模型
# model = Lr()
# citerion = nn.MSELoss()
# optimizer = optim.SGD(model.parameters(),lr = 1e-3)
#
# # 训练模型
# for i in range(50000):
#     out = model(x)  # 获取预测值
#     loss = citerion(y,out)  # 计算损失值
#     optimizer.zero_grad()  # 梯度清零
#     loss.backward()  # 计算梯度
#     optimizer.step()  # 更新梯度
#     if (i+1) % 20 == 0:
#         print('Epoch[{}/{}],loss:{:.6f}'.format(i,50000,loss.data))
#
# # 模型评估
# model.eval()  # 设置模式为评估模式，即预测模式
# predict = model(x)
# predict = predict.data.numpy()
# plt.scatter(x.data.numpy(),y.data.numpy(),c='b')
# plt.plot(x.data.numpy(),predict)
# plt.show()

# 注意：
"""
model.eval()表示设置模型为评估模式，即预测模式
model.train(mode=True) 表示设置模型为训练模式
"""




# 在GPU上运行代码:当模型太大，或者参数太多的情况下，为了加快训练速度，经常会使用GPU来进行训练
"""
判断GPU是否可用torch.cuda.is_available():
    torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    >>device(type='cuda', index=0)  #使用gpu
    >>device(type='cpu') #使用cpu
    
把模型参数和input数据转化为cuda的支持类型:
    model.to(device)
    x_true.to(device)
    
在GPU上计算结果也为cuda的数据类型，需要转化为numpy或者torch的cpu的tensor类型:
    predict = predict.cpu().detach().numpy()
detach()的效果和data的相似，但是detach()是深拷贝，data是取值，是浅拷贝
"""
import torch
import numpy as np
from torch import nn
from torch import optim
from matplotlib import pyplot as plt
import time

# 定义数据
x = torch.rand([50,1])
y = x * 3 + 0.8

# 定义模型
class Lr(nn.Module):
    def __init__(self):
        super(Lr, self).__init__()
        self.linear = nn.Linear(1,1)

    def forward(self,x):
        out = self.linear(x)
        return out

# 实例化模型，loss，和优化器
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
x,y = x.to(device),y.to(device)

model = Lr().to(device)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(),lr = 1e-3)

# 训练模型
for i in range(50000):
    out = model(x)
    loss = criterion(y,out)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (i + 1) % 20 == 0:
        print("Epoch[{}/{}],loss:{:.6f}".format(i,50000,loss.data))

# 模型评估
model.eval()
predict = model(x)
predict = predict.cpu().detach().numpy()  # 转换为numpy】数组
plt.scatter(x.cpu().data.numpy(),y.cpu().data.numpy(),c = 'b')
plt.plot(x.cpu().data.numpy(),predict)
plt.show()