文章目录
Pytorch完成基础的线性模型
目标
- 知道Pytorch中Module的使用方法
- 知道Pytorch中优化器类的使用方法
- 知道Pytorch中常见的损失函数的使用方法
- 知道如何在GPU上运行代码
- 能够说出常见的优化器及其原理
1. Pytorch完成模型常用API
在前一部分，我们自己实现了通过torch的相关方法完成反向传播和参数更新，在pytorch中预设了一些更加灵活简单的对象，让我们来构造模型、定义损失，优化损失等
那么接下来，我们一起来了解一下其中常用的API
1.1 nn.Module
nn.Modul是torch.nn提供的一个类，是pytorch中我们自定义网络的一个基类，在这个类中定义了很多有用的方法，让我们在继承这个类定义网络的时候非常简单
当我们自定义网络的时候，有两个方法需要特别注意：
__init__需要调用super方法，继承父类的属性和方法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方法并传入参数
# 实例化模型
model = Lr()
# 传入数据，计算预测结果
y_predict = model(x)
1.2 优化器类torch.optim
优化器(
optimizer)，可以理解为torch为我们封装的用来进行更新参数的方法，比如常见的随机梯度下降(stochastic gradient descent,SGD)
优化器类都是由torch.optim提供的，例如
torch.optim.SGD(参数，学习率)torch.optim.Adam(参数，学习率)
注意：
- 参数可以使用
model.parameters()来获取，获取模型中所有requires_grad=True的参数- 优化类的使用方法：
- 实例化优化器
- 所有参数的梯度，将其值置为0
- 反向传播计算梯度
- 更新参数值
示例如下：
optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化
optimizer.zero_grad() #2. 梯度置为0
loss.backward() #3. 计算梯度
optimizer.step() #4. 更新参数的值
1.3 损失函数nn.xxxLoss()
前面的例子是一个回归问题，torch中也预制了很多损失函数，如下
- 均方误差:
nn.MSELoss(),常用于回归问题- 交叉熵损失：
nn.CrossEntropyLoss()，常用于分类问题
使用方法：
criterion = nn.MSELoss() # 实例化损失函数
loss = criterion(y_true,y_predict) # 调用损失函数传入真实值和预测值，得到损失结果
1.4 线性回归模型构建及训练完整代码
pytorch完成一个基础模型整体流程：
- 1、准备数据集即样本和标签
- 2.、定义模型，重写__init__和forward方法
- 3、实例化模型（参数继承在模型中），实例化优化器类，实例化损失函数
- 4、循环训练：预测真实值，计算损失函数，优化器中梯度清零，损失函数反向传播，用优化器进行参数更新
- 5、模型评估
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
# 1、准备数据集即样本和标签
x = torch.rand([50, 1])
y_true = x * 3 + 0.8
# 2、定义线性回归模型
class Lr(nn.Module):
def __init__(self):
super(Lr, self).__init__()
self.linear = nn.Linear(1, 1) # 继承父类init的参数
def forward(self, input):
out = self.linear(input)
return out
# 3、实例化模型（参数继承在模型中），实例化优化器，实例化损失函数
linear_model = Lr()
optimizer = optim.SGD(linear_model.parameters(), lr=1e-3)
criterion = nn.MSELoss()
for i in range(20000):
# 4、预测真实值，计算损失函数，优化器中梯度清零，损失函数反向传播，用优化器进行参数更新
y_predict = linear_model(x)
loss = criterion(y_true, y_predict)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if not(i % 2000):
para = list(linear_model.parameters())
print('loss:{:>20} \t para1:{} \t para2:{}'.format(
loss.item(), para[0].item(), para[1].item()))
# 5、模型评估及可视化
linear_model.eval()
plt.scatter(x.data.numpy(), y_true.data.numpy(), color='red')
y_predict = linear_model(x).detach().numpy()
plt.plot(x.data.numpy(), y_predict, color='blue')
plt.show()
输出如下：
注意：
model.eval()表示设置模型为评估模式，即预测模式
或
model.train(mode=False)表示设置模型为预测模式,默认为True训练模式
在当前的线性回归中，上述并无区别
但是在其他的一些模型中，训练的参数和预测的参数会不相同，到时候就需要具体告诉程序我们是在进行训练还是预测，比如模型中存在Dropout，BatchNorm的时候，训练需要，预测则不需要
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tI2Jq1fl-1607140687559)(../images/1.2/线性回归2.png)]](https://i-blog.csdnimg.cn/blog_migrate/23ec863d85a64eaf1928c19f603d083f.png)
2. 在GPU上运行代码
当模型太大，或者参数太多的情况下，为了加快训练速度，经常会使用GPU来进行训练
此时我们的代码需要稍作调整：
- 判断GPU是否可用
torch.cuda.is_available()device = torch.device("cuda" if torch.cuda.is_available() else "cpu") device >>device(type='cuda', index=0) #使用gpu >>device(type='cpu') #使用cpu
- 把input数据和模型（模型参数）和转化为cuda的支持类型
x, y_true = x.to(device), y_true.to(device) model = Lr().to(device) # 模型转化为cuda类型后，除非自定义的模型参数外，否则其继承的模型参数也会自动转化为cuda类型
- 在GPU上计算结果也为cuda的数据类型，需要转化为numpy或者torch的cpu的tensor类型
y_predict = model(x).cpu().data.detach().numpy()注：
detach()的效果和data的相似，但是detach()是深拷贝，data是取值，是浅拷贝
修改之后的代码如下：
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
device = 'gpu' if torch.cuda.is_available() else 'cpu'
# 1、准备数据集即样本和标签
x = torch.rand([50, 1])
y_true = x * 3 + 0.8
x, y_true = x.to(device), y_true.to(device)
# 2、定义线性回归模型
class Lr(nn.Module):
def __init__(self):
super(Lr, self).__init__()
self.linear = nn.Linear(1, 1) # 继承父类init的参数
def forward(self, input):
out = self.linear(input)
return out
# 3、实例化模型（参数继承在模型中），实例化优化器，实例化损失函数
linear_model = Lr().to(device)
optimizer = optim.SGD(linear_model.parameters(), lr=1e-3)
criterion = nn.MSELoss()
for i in range(20000):
# 4、预测真实值，计算损失函数，优化器中梯度清零，损失函数反向传播，用优化器进行参数更新
y_predict = linear_model(x)
loss = criterion(y_true, y_predict)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if not(i % 2000):
para = list(linear_model.parameters())
print('loss:{:>20} \t para1:{} \t para2:{}'.format(
loss.item(), para[0].item(), para[1].item()))
# 5、模型评估及可视化
linear_model.eval()
plt.scatter(x.cpu().data.numpy(), y_true.cpu().data.numpy(), color='red')
y_predict = linear_model(x).cpu().detach().numpy()
plt.plot(x.cpu().data.numpy(), y_predict, color='blue')
plt.show()
3. 常见的优化算法介绍
3.1 梯度下降算法（batch gradient descent BGD）
每次迭代都需要把所有样本都送入，这样的好处是每次迭代都顾及了全部的样本，做的是全局最优化,但是有可能达到局部最优。
3.2 随机梯度下降法 (Stochastic gradient descent SGD)
针对梯度下降算法训练速度过慢的缺点，提出了随机梯度下降算法，随机梯度下降算法算法是从样本中随机抽出一组，训练后按梯度更新一次，然后再抽取一组，再更新一次，在样本量及其大的情况下，可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型了。
torch中的api为：torch.optim.SGD()
3.3 小批量梯度下降 (Mini-batch gradient descent MBGD）
SGD相对来说要快很多，但是也有存在问题，由于单个样本的训练可能会带来很多噪声，使得SGD并不是每次迭代都向着整体最优化方向，因此在刚开始训练时可能收敛得很快，但是训练一段时间后就会变得很慢。在此基础上又提出了小批量梯度下降法，它是每次从样本中随机抽取一小批进行训练，而不是一组，这样即保证了效果又保证的速度。
3.4 动量法
mini-batch SGD算法虽然这种算法能够带来很好的训练速度，但是在到达最优点的时候并不能够总是真正到达最优点，而是在最优点附近徘徊。
另一个缺点就是mini-batch SGD需要我们挑选一个合适的学习率，当我们采用小的学习率的时候，会导致网络在训练的时候收敛太慢；当我们采用大的学习率的时候，会导致在训练过程中优化的幅度跳过函数的范围，也就是可能跳过最优点。我们所希望的仅仅是网络在优化的时候网络的损失函数有一个很好的收敛速度同时又不至于摆动幅度太大。
所以Momentum优化器刚好可以解决我们所面临的问题，它主要是基于梯度的移动指数加权平均，对网络的梯度进行平滑处理的，让梯度的摆动幅度变得更小。
g r a d e n t = 0.8 ∇ w + 0.2 h i s t o r y _ g r a d e n t ， ∇ w 表 示 当 前 一 次 的 梯 度 w = w − α ∗ g r a d e n t ， α 表 示 学 习 率 \begin{aligned} &gradent = 0.8\nabla w + 0.2 history\_gradent &，\nabla w 表示当前一次的梯度\\ &w = w - \alpha* gradent &，\alpha表示学习率 \end{aligned} gradent=0.8∇w+0.2history_gradentw=w−α∗gradent，∇w表示当前一次的梯度，α表示学习率
（注：t+1的的histroy_gradent 为第t次的gradent，0.8和0.2为超参数）
eg：
w 1 = w 1 w 2 = 0.8 w 2 + 0.2 w 1 w 3 = 0.8 w 3 + 0.2 w 2 = 0.8 w 3 + 0.2 ( 0.8 w 2 + 0.2 w 1 ) = 0.8 w 3 + 0.2 ∗ 0.8 w 2 + 0.2 ∗ 0.2 w 1 w 4 = 0.8 w 4 + 0.2 w 3 = 0.8 w 4 + 0.2 ( 0.8 w 3 + 0.2 ∗ 0.8 w 2 + 0.2 ∗ 0.2 w 1 ) . . . \begin{aligned} &w_1 = w_1\\ &w_2 = 0.8w_2 + 0.2w_1 &\\ &w_3 = 0.8w_3 + 0.2w_2 = 0.8w_3 + 0.2(0.8w_2 + 0.2w_1) = 0.8w_3 + 0.2 * 0.8w_2 + 0.2 * 0.2w_1 &\\ &w_4 = 0.8w_4 + 0.2w_3 = 0.8w_4 + 0.2(0.8w_3 + 0.2 * 0.8w_2 + 0.2 * 0.2w_1) & \\ &... \end{aligned} w1=w1w2=0.8w2+0.2w1w3=0.8w3+0.2w2=0.8w3+0.2(0.8w2+0.2w1)=0.8w3+0.2∗0.8w2+0.2∗0.2w1w4=0.8w4+0.2w3=0.8w4+0.2(0.8w3+0.2∗0.8w2+0.2∗0.2w1)...
3.5 AdaGrad
AdaGrad算法就是将每一个参数的每一次迭代的梯度取平方累加后在开方，用全局学习率除以这个数，作为学习率的动态更新，从而达到自适应学习率的效果
g r a d e n t = h i s t o r y _ g r a d e n t + ( ∇ w ) 2 w = w − α g r a d e n t + δ ∇ w , δ 为 小 常 数 ， 为 了 数 值 稳 定 大 约 设 置 为 1 0 − 7 \begin{aligned} &gradent = history\_gradent + (\nabla w)^2 \\ &w = w - \frac{\alpha}{\sqrt{gradent}+\delta} \nabla w ,&\delta为小常数，为了数值稳定大约设置为10^{-7} \end{aligned} gradent=history_gradent+(∇w)2w=w−gradent+δα∇w,δ为小常数，为了数值稳定大约设置为10−7
3.6 RMSProp
Momentum优化算法中，虽然初步解决了优化中摆动幅度大的问题,为了进一步优化损失函数在更新中存在摆动幅度过大的问题，并且进一步加快函数的收敛速度，RMSProp算法对参数的梯度使用了平方加权平均数。
g r a d e n t = 0.8 ∗ h i s t o r y _ g r a d e n t + 0.2 ∗ ( ∇ w ) 2 w = w − α g r a d e n t + δ ∇ w \begin{aligned} & gradent = 0.8*history\_gradent + 0.2*(\nabla w)^2 \\ & w = w - \frac{\alpha}{\sqrt{gradent}+\delta} \nabla w \end{aligned} gradent=0.8∗history_gradent+0.2∗(∇w)2w=w−gradent+δα∇w
3.7 Adam
Adam（Adaptive Moment Estimation）算法是将Momentum算法和RMSProp算法结合起来使用的一种算法,能够达到防止梯度的摆幅多大，同时还能够加开收敛速度
1. 需 要 初 始 化 梯 度 的 累 积 量 和 平 方 累 积 量 v w = 0 , s w = 0 2. 第 t 轮 训 练 中 ， 我 们 首 先 可 以 计 算 得 到 M o m e n t u m 和 R M S P r o p 的 参 数 更 新 ： v w = 0.8 v + 0.2 ∇ w , M o m e n t u m 计 算 的 梯 度 s w = 0.8 ∗ s + 0.2 ∗ ( ∇ w ) 2 , R M S P r o p 计 算 的 梯 度 3. 对 其 中 的 值 进 行 处 理 后 ， 得 到 ： w = w − α s w + δ v w \begin{aligned} & 1. 需要初始化梯度的累积量和平方累积量 \\ & v_w = 0,s_w = 0 \\ & 2. 第 t 轮训练中，我们首先可以计算得到Momentum和RMSProp的参数更新：\\ & v_w = 0.8v + 0.2 \nabla w \qquad,Momentum计算的梯度\\ & s_w = 0.8*s + 0.2*(\nabla w)^2 \qquad,RMSProp计算的梯度\\ & 3. 对其中的值进行处理后，得到：\\ & w = w - \frac{\alpha}{\sqrt{s_w}+\delta} v_w \end{aligned} 1.需要初始化梯度的累积量和平方累积量vw=0,sw=02.第t轮训练中，我们首先可以计算得到Momentum和RMSProp的参数更新：vw=0.8v+0.2∇w,Momentum计算的梯度sw=0.8∗s+0.2∗(∇w)2,RMSProp计算的梯度3.对其中的值进行处理后，得到：w=w−sw+δαvw
torch中的api为：torch.optim.Adam()
扫一扫
287
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
