深度学习 | 【04】Pytorch实现简单的线性回归

常用API

1、nn.Module

nn.Modul 是 torch.nn 提供的一个类，是pytorch中自定义网络的一个基类。

• 需要继承父类的属性和方法；
• farword必须实现，用来定义我们的网络的向前计算的过程。

注意

• nn.Linear 为torch预定义好的线性模型 - 【全连接层】，传入的参数为输入的数量，输出的数量(in_features, out_feature)，是不算(batch_size的列数)
• nn.Module 定义了__call__ 方法，实现的就是调用foeward 方法，即Lr 的实例，能够直接被传入参数调用，实际上调用的是foeward方法并传入参数。

2、优化器类

• 优化器( optimizer)，可以理解为torch为我们封装的用来进行更新参数的方法，比如常见的随机梯度下降(stochastic gradient descent,sGD )
• 优化器类都是由torch. optim提供的，例如
  • torch.optim.SGD(参数，学习率)
  • torch.optim.Adam(参数，学习率)

注意:

• 1.参数可以使用model.parameters()来获取，获取模型中所有requires_grad=True的参数
• 2.优化类的使用方法Ⅰ
  • 实例化：optimizer = optim.SGD(model.parameters(), lr=le03)
  • 所有参数的梯度，将其值置为0：optimizer.zero_grad()
  • 反向传播计算梯度：loss.backward()
  • 更新参数值：optimizer.step()

3、损失函数

• 均方误差：nn.MSELoss() 分类问题；
• 交叉熵损失：nn.CrossEntropyLoss() 逻辑回归。

4、预测与训练

• model.eval()表示为评估模式，【预测模式】
• model.train(mode=true)训练模式
• 在线性回归中，他们并没有区别。但在其他的模型训练中参数会各不相同。

model = Lr() # 1. 实例化模型
criterion = nn.MSELoss() # 2.实例化损失函数
optimizer = optim.SGD(model.parameters(), lr=le-3)	# 3. 实例化优化器类
for i in range(50):
	y_pre = model(x_true) # 4. 向前计算预测值
	loss = criterion(y_true, y_pre) #5. 调用损失函数传入真实值和预测值，得到损失结果
	optimizer.zero_grad() # 6. 当前循环参数梯度置为0
	loss.backward() # 7. 计算梯度
	optimizer.step() # 8. 更新参数的值

4、完整代码

# -*- coding: utf-8 -*-
""" @Time : 2021/5/16 10:35
 @Author : XXX
 @Site : 
 @File : Demolinear.py
 @Software: PyCharm 
"""
import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt

# 1. 构建数据
x = torch.rand([50, 1])
y = x*4 + 0.3

# 2. 定义模型
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

# 3.创建模型实例，损失函数，优化器
model = Lr()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)

# 4.训练模型
for i in range(31000):
    out = model(x)  # 获取预测值
    loss = criterion(y, out)    # 计算损失值
    optimizer.zero_grad()       # 梯度归0
    loss.backward()         # 反向传播
    optimizer.step()        # 更新梯度

    if i%50 == 0:
        print("Epoch[{}/{}], loss: {}".format(i,31000, loss.data))

# 5.模型评估
model.eval()
pre = model(x)  # 预测值
pre = pre.data.numpy()
plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
plt.plot(x.data.numpy(), pre)
plt.show()

运行结果

5、GPU上运行代码

当模型太大，或者参数太多的情况下，为了加快训练速度，就会使用GPU来训练模型。

• 判断GPU是否可用

torch.device("cuda:0" if torch.cuda.is_available() else "cpu")	

• 把模型参数和input数据转化为cuda的支持类型

model.to(device)
x_true.to(device)

• 在GPU上计算结果也为cuda的数据类型，需要转化为numpy或者torch的cpu的tensor类型

predict = predict().cpu().datach().numpy()
# datach为深拷贝
# data为浅拷贝

GPU类型代码

# -*- coding: utf-8 -*-
""" @Time : 2021/5/16 10:35
 @Author : XXX
 @Site : 
 @File : Demolinear.py
 @Software: PyCharm 
"""
import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt

device = torch,device("cuda:0" if torch.cuda.is_available() else "cpu")	
# 1. 构建数据
x = torch.rand([50, 1]).to(device)
y = x*4 + 0.3

# 2. 定义模型
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

# 3.创建模型实例，损失函数，优化器
model = Lr().to(device)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)

# 4.训练模型
for i in range(31000):
    out = model(x)  # 获取预测值
    loss = criterion(y, out)    # 计算损失值
    optimizer.zero_grad()       # 梯度归0
    loss.backward()         # 反向传播
    optimizer.step()        # 更新梯度

    if i%50 == 0:
        print("Epoch[{}/{}], loss: {}".format(i,31000, loss.data))

# 5.模型评估
model.eval()
pre = model(x)  # 预测值
pre = pre.data.numpy()
plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
plt.plot(x.data.numpy(), pre)
plt.show()