使用Pytorch写简单线性回归

1.代码框架

2.引用

import torch        
from torch import nn
from torch import optim

3.继续模型

  继承模型主要都是在nn.Module类里

(1)要定义一个模型，需要继承nn.Module：

class EIModel(nn.Module):
    def __init__(self):
        super(EIModel,self).__init__()   #等价于super().__init__()  
        self.linear=nn.Linear(in_features=1,out_features=1)   #创建线性层

    def forward(self,inputs):
        logits=self.linear(inputs)
        return logits   

  注：forward()的return切记要写上

(2)如果函数的参数不具体指定，那么就需要在__init__函数中添加未指定的变量：

class EIModel(nn.Module):
    def __init__(self,in_features,out_features):
        super(EIModel,self).__init__()
        self.linear=nn.Linear(in_features,out_features)  

    def forward(self,inputs):
        logits=self.linear(inputs)
        return logits

  注：这时在实例化模型时，函数内要指定参数：

model = EIModel(in_features=1,out_features=1)

2.定义数据

x_list=[0,1,2,3,4]
y_list=[2,3,4,5,8]

x_numpy=np.array(x_list,dtype=np.float32)
x=torch.from_numpy(x_numpy.reshape(-1,1))
y_numpy=np.array(y_list,dtype=np.float32)
y=torch.from_numpy(y_numpy.reshape(-1,1))

3.实例化模型

model = EIModel()

  直接调用模型

import torchvision.models as models
models.resnet50()

  测试模型预测结果

outputs=model(x)
print(outputs)

  结果：

tensor([[-0.9462],
        [-1.4654],
        [-1.9846],
        [-2.5038],
        [-3.0230]], grad_fn=<AddmmBackward>)

4.损失函数

  nn.MSELoss()定义均方误差损失计算函数
(1)loss_f=nn.MSELoss()
(2)loss_f=nn.CrossEntropyLoss()

5.优化器

  torch.optim.SGD()是一个内置的优化器
  它的第一个参数是需要优化的变量，可以通过model.parameters()方法获取模型中所有变量
lr=0.0001定义学习率
  (1)opt=torch.optim.SGD(model.parameters(),lr=0.0001)
  (2)optimizer_ft=optim.Adam(params_to_update,lr=1e-2)
  Adam优点：可以自动调整学习效率

6.模型训练

  (1)因为pytorch会累积每次计算的梯度，所以需要将上一循环中的计算的梯度归零
将全部数据训练一遍称为一个epoch，这里训练了500个epoch

for epoch in range(500):
    for x_index,y_index in zip(x,y): #同时对x和y迭代
        y_pred=model(x_index)        #等价于model.forward(inputs)
        loss=loss_f(y_pred,y_index)  #根据模型预测输出与实际值y_index计算损失
        opt.zero_grad()              #将累计的梯度清0
        loss.backward()              #反向传播损失，计算损失与模型参数之间的梯度
        opt.step()                   #根据计算得到梯度优化模型参数

  (2)将损失误差打印出来

for epoch in range(500):
    for x_index,y_index in zip(x,y):   
        y_pred=model(x_index)
        loss=loss_f(y_pred,y_index)
        opt.zero_grad()     #将累计的梯度清0
        loss.backward()     #反向传播损失，计算损失与模型参数之间的梯度
        opt.step()          #根据计算得到梯度优化模型参数

    if (epoch + 1) % 50 == 0:
        print(f'epoch:{epoch + 1}, loss = {loss.item():.4f}')

  结果：

epoch:50, loss = 12.1212
epoch:100, loss = 7.1772
epoch:150, loss = 4.4344
epoch:200, loss = 2.8781
epoch:250, loss = 1.9724
epoch:300, loss = 1.4308
epoch:350, loss = 1.0978
epoch:400, loss = 0.8877
epoch:450, loss = 0.7521
epoch:500, loss = 0.6629

  参数名称和值：
model.named_parameters()可以以生成器的形式返回模型参数的名称和值

print(list(model.named_parameters()))

  结果：

[('linear.weight', Parameter containing:tensor([[1.4773]], requires_grad=True)), 
('linear.bias', Parameter containing:tensor([1.2792], requires_grad=True))]

  单独查看权重/偏置：

print(model.linear.weight)
print(model.linear.bias)

7.绘制数据

  使用tensor.detach()方法获得具有相同内容但不需要跟踪运算的新张量，可以认为是获取张量的值

plt.scatter(x_list,y_list,label='scatter plot')
plt.plot(x,model(x).detach().numpy(),c='r',label='line plot')
plt.legend()
plt.show()

  结果：