【深度学习入门篇 ②】Pytorch完成线性回归！

🍊嗨 ，大家好，我是小森( ﹡ˆoˆ﹡ )！ 易编橙·终身成长社群创始团队嘉宾 ，橙似锦计划领衔成员 、阿里云专家博主 、腾讯云内容共创官 、CSDN人工智能领域优质创作者 。

易编橙：一个帮助编程小伙伴少走弯路的终身成长社群！

---

上一部分我们自己通过torch的方法完成反向传播和参数更新，在Pytorch中预设了一些更加灵活简单的对象，让我们来构造模型、定义损失，优化损失等；那么接下来，我们一起来了解一下其中常用的API！

nn.Module

nn.Module 是 PyTorch 框架中用于构建所有神经网络模型的基类。在 PyTorch 中，几乎所有的神经网络模块（如层、卷积层、池化层、全连接层等）都继承自 nn.Module。这个类提供了构建复杂网络所需的基本功能，如参数管理、模块嵌套、模型的前向传播等。

当我们自定义网络的时候，有两个方法需要特别注意：

1. __init__需要调用super方法，继承父类的属性和方法

2. farward方法必须实现，用来定义我们的网络的向前计算的过程

用前面的y = wx+b的模型举例如下：

from torch import nn
class Lr(nn.Module):
    def __init__(self):
        super(Lr, self).__init__()  # 继承父类init的参数
        self.linear = nn.Linear(1, 1) 

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

• nn.Linear为torch预定义好的线性模型，也被称为全链接层 ，传入的参数为输入的数量，输出的数量(in_features, out_features),是不算(batch_size的列数)
• nn.Module定义了__call__方法，实现的就是调用forward方法，即Lr的实例，能够直接被传入参数调用，实际上调用的是forward方法并传入参数
• __init__方法里面的内容就是类创建的时候，跟着自动创建的部分。
• 与之对应的就是__del__方法,在对象被销毁时执行一些清理操作。

# 实例化模型
model = Lr()
# 传入数据，计算结果
predict = model(x)

优化器类

优化器(optimizer)，可以理解为torch为我们封装的用来进行更新参数的方法，比如常见的随机梯度下降(stochastic gradient descent,SGD)。

优化器类都是由torch.optim提供的，例如

1. torch.optim.SGD(参数，学习率)

2. torch.optim.Adam(参数，学习率)

注意：

• 参数可以使用model.parameters()来获取，获取模型中所有requires_grad=True的参数

---

optimizer = optim.SGD(model.parameters(), lr=1e-3) # 实例化
optimizer.zero_grad() # 梯度置为0
loss.backward() #  计算梯度
optimizer.step()  #  更新参数的值

损失函数

1. 均方误差:nn.MSELoss(),常用于回归问题

2. 交叉熵损失：nn.CrossEntropyLoss()，常用于分类问题

model = Lr() # 实例化模型
criterion = nn.MSELoss() # 实例化损失函数
optimizer = optim.SGD(model.parameters(), lr=1e-3) #  实例化优化器类
for i in range(100):
    y_predict = model(x_true) # 预测值
    loss = criterion(y_true,y_predict) # 调用损失函数传入真实值和预测值，得到损失
    optimizer.zero_grad() 
    loss.backward() # 计算梯度
    optimizer.step()  # 更新参数的值

线性回归代码！

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])
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，和优化器
model = Lr()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)
#训练模型
for i in range(30000):
    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,30000,loss.data))

# 模型评估模式，之前说过的
model.eval() 
predict = model(x)
predict = predict.data.numpy()
plt.scatter(x.data.numpy(),y.data.numpy(),c="r")
plt.plot(x.data.numpy(),predict)
plt.show()

• 可以看出经过30000次训练后(相当于看书，一遍遍的回归学习)，基本就可以拟合预期直线了

GPU上运行代码

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

此时我们的代码需要稍作调整：

1.判断GPU是否可用torch.cuda.is_available()

torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
device(type='cuda', index=0)  # 使用GPU

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

model.to(device)
x.to(device)

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

predict = predict.cpu().detach().numpy() 

• predict.cpu() 将predict张量从可能的其他设备（如GPU）移动到CPU上
• predict.detach() .detach()方法会返回一个新的张量，这个张量不再与原始计算图相关联，即它不会参与后续的梯度计算。
• **.numpy()**方法将张量转换为NumPy数组。

GPU代码：

import torch
from torch import nn
from torch import optim
import numpy as np
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


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(300):
    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,30000,loss.data))


model.eval() 
predict = model(x)
predict = predict.cpu().detach().numpy() 
plt.scatter(x.cpu().data.numpy(),y.cpu().data.numpy(),c="r")
plt.plot(x.cpu().data.numpy(),predict,)
plt.show()

💯常见的优化算法

在大多数情况下，我们关注的是最小化损失函数，因为它衡量了模型预测与真实标签之间的差异。

梯度下降算法（batch gradient descent BGD）

每次迭代都需要把所有样本都送入，这样的好处是每次迭代都顾及了全部的样本，做的是全局最优化,但是有可能达到局部最优。

随机梯度下降法(Stochastic gradient descent SGD)

针对梯度下降算法训练速度过慢的缺点，提出了随机梯度下降算法，随机梯度下降算法算法是从样本中随机抽出一组，训练后按梯度更新一次，然后再抽取一组，再更新一次，在样本量及其大的情况下，可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型了。

小批量梯度下降 (Mini-batch gradient descent MBGD）

SGD相对来说要快很多，但是也有存在问题，由于单个样本的训练可能会带来很多噪声，使得SGD并不是每次迭代都向着整体最优化方向，因此在刚开始训练时可能收敛得很快，但是训练一段时间后就会变得很慢。在此基础上又提出了小批量梯度下降法，它是每次从样本中随机抽取一小批进行训练，而不是一组，这样即保证了效果又保证的速度。

AdaGrad

AdaGrad算法就是将每一个参数的每一次迭代的梯度取平方累加后在开方，用全局学习率除以这个数，作为学习率的动态更新，从而达到自适应学习率的效果

Adam

Adam（Adaptive Moment Estimation）算法是将Momentum算法和RMSProp算法结合起来使用的一种算法,能够达到防止梯度的摆幅多大，同时还能够加开收敛速度。