24 Pytorch基础模型组件及线性回归

24 Pytorch基础模型组件及线性回归

2020-05-16 20:13:37发布 浏览数:485
概述:24 Pytorch基础模型组件及线性回归

Pytorch基础模型组件

目标

  1. 知道Pytorch中Module的使用方法
  2. 知道Pytorch中优化器类的使用方法
  3. 知道Pytorch中常见的损失函数的使用方法
  4. 知道如何在GPU上运行代码
  5. 能够说出常见的优化器及其原理

1. Pytorch完成模型常用API

在前一部分,我们自己实现了通过torch的相关方法完成反向传播和参数更新,在pytorch中预设了一些更加灵活简单的对象,让我们来构造模型、定义损失,优化损失等

那么接下来,我们一起来了解一下其中常用的API

1.1 nn.Module

nn.Module 是torch.nn提供的一个类,是pytorch中我们自定义网络的一个基类,在这个类中定义了很多有用的方法,让我们在继承这个类定义网络的时候非常简单

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

  1. __init__需要调用super方法,继承父类的属性和方法
  2. forward方法必须实现,用来定义我们的网络的向前计算的过程

用前面的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

注意:

  1. nn.Linear为torch预定义好的线性模型,也被称为全链接层,传入的参数为输入的数量,输出的数量(in_features, out_features),是不算(batch_size的列数)
  2. nn.Module定义了__call__方法,实现的就是调用forward方法,即Lr的实例,能够直接被传入参数调用,实际上调用的是forward方法并传入参数

# 实例化模型

model = Lr()

# 传入数据,计算结果

predict = model(x)

1.2 nn.Sequential

如果模型结构比较简单,在forward函数中没有很复杂的操作。这时可以用nn.Sequential来构建模型,nn.Sequential会自动完成forward函数的创建.

In [163]: model = nn.Sequential(nn.Linear(2,64), nn.Linear(64, 1))

 

 

 

In [164]: x = torch.randn(10,2) # 10个样本,2个特征

 

 

 

In [165]: model(x)

 

Out[165]:

 

tensor([[-0.3507],

 

[-0.3708],

 

[-0.4118],

 

[-0.2604],

 

[-0.4318],

 

[-0.3503],

 

[-0.4953],

 

[-0.5464],

 

[-0.5273],

 

[-0.4542]], grad_fn=<AddmmBackward>)

1.3 优化器类

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

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

  1. torch.optim.SGD(参数,学习率)
  2. torch.optim.Adam(参数,学习率)

注意:

  1. 参数可以使用model.parameters()来获取,获取模型中所有requires_grad=True的参数
  2. 优化类的使用方法
  3. 实例化
  4. 所有参数的梯度,将其值置为0
  5. 反向传播计算梯度
  6. 更新参数值

示例如下:

optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化

optimizer.zero_grad() #2. 梯度置为0

loss.backward() #3. 计算梯度

optimizer.step() #4. 更新参数的值

1.4 损失函数

前面的例子是一个回归问题,torch中也预测了很多损失函数

  1. 均方误差:nn.MSELoss(),常用于回归问题
  2. 交叉熵损失:nn.CrossEntropyLoss(),常用于分类问题

使用方法:

model = Lr() #1. 实例化模型

criterion = nn.MSELoss() #2. 实例化损失函数

optimizer = optim.SGD(model.parameters(), lr=1e-3) #3. 实例化优化器类

for i in range(100):

   y_predict = model(x_true) #4. 向前计算预测值

   loss = criterion(y_true,y_predict) #5. 调用损失函数传入真实值和预测值,得到损失结果

   optimizer.zero_grad() #5. 当前循环参数梯度置为0

   loss.backward() #6. 计算梯度

   optimizer.step() #7. 更新参数的值

Pytorch基础模型

目标

  1. 知道如何使用pytorch模型组件构建模型
  2. 知道如何在GPU上运行代码
  3. 能够说出常见的优化器及其原理

1 使用pytorch模型组件把线性回归完整代码

 

构建模型,最重要的有两个步骤:

  1. 找到合适的计算关系,随即初始化参数来拟合输入和输出的关系(前向计算,从输入得到输出)
  2. 选取合适的损失函数和优化器来减小损失(反向传播,得到合适的参数)
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*3 + 0.8

 

 

 

#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

 

 

 

# 2. 实例化模型,loss,和优化器

 

model = Lr()

 

criterion = nn.MSELoss()

 

optimizer = optim.SGD(model.parameters(), lr=1e-3)

 

#3. 训练模型

 

for i in range(30000):

 

    out = model(x) #3.1 获取预测值

 

    loss = criterion(y,out) #3.2 计算损失

 

    optimizer.zero_grad() #3.3 梯度归零

 

    loss.backward() #3.4 计算梯度

 

    optimizer.step() # 3.5 更新梯度

 

     if (i+1) % 20 == 0:

 

          print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))

 

 

 

#4. 模型评估

 

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()

输出如下:

注意:

model.eval()表示设置模型为评估模式,即预测模式

model.train(mode=True) 表示设置模型为训练模式

在当前的线性回归中,上述并无区别

但是在其他的一些模型中,训练的参数和预测的参数会不相同,到时候就需要具体告诉程序我们是在进行训练还是预测,比如模型中存在Dropout,BatchNorm的时候

2. 在GPU上运行代码

 

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

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

  1. 判断GPU是否可用torch.cuda.is_available()
  2. torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  3. >>device(type='cuda', index=0) #使用gpu
  4. >>device(type='cpu') #使用cpu
  5. 把模型参数和input数据转化为cuda的支持类型
  6. model.to(device)
  7. x_true.to(device)
  8. 在GPU上计算结果也为cuda的数据类型,需要转化为numpy或者torch的cpu的tensor类型
  9. predict = predict.cpu().detach().numpy()
  10. detach()的效果和data的相似,但是detach()是深拷贝,data是取值,是浅拷贝

修改之后的代码如下:

import torch

 

from torch import nn

 

from torch import optim

 

import numpy as np

 

from matplotlib import pyplot as plt

 

import time

 

 

 

# 1. 定义数据

 

x = torch.rand([50,1])

 

y = x*3 + 0.8

 

 

 

#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

 

 

 

# 2. 实例化模型,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)

 

 

 

#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))

 

 

 

#4. 模型评估

 

model.eval() #

 

predict = model(x)

 

predict = predict.cpu().detach().numpy() #转化为numpy数组

 

plt.scatter(x.cpu().data.numpy(),y.cpu().data.numpy(),c="r")

 

plt.plot(x.cpu().data.numpy(),predict,)

 

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优化器刚好可以解决我们所面临的问题,它主要是基于梯度的移动指数加权平均,对网络的梯度进行平滑处理的,让梯度的摆动幅度变得更小。

(注:t+1的的histroy_gradent 为第t次的gradent)

3.5 AdaGrad

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

3.6 RMSProp

Momentum优化算法中,虽然初步解决了优化中摆动幅度大的问题,为了进一步优化损失函数在更新中存在摆动幅度过大的问题,并且进一步加快函数的收敛速度,RMSProp算法对参数的梯度使用了平方加权平均数。

3.7 Adam

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

torch中的api为:torch.optim.Adam()

3.8 效果演示:

4 深度学习避免过拟合/加速训练

4.1 Dropout

为了应对神经网络很容易过拟合的问题,2014年 Hinton 提出了一个神器: Dropout: A Simple Way to Prevent Neural Networks from Overfitting

实验结果:

dropout 是指在深度学习网络的训练过程中,按照一定的概率将一部分神经网络单元暂时从网络中丢弃,相当于从原始的网络中找到一个更瘦的网络

在大规模的神经网络中有这样两个缺点:1. 费时;2. 容易过拟合

对于一个有 N 个节点的神经网络,有了 dropout后,就可以看做是 2^N 个模型的集合了,但此时要训练的参数数目却是不变的,这就缓解了费时的问题。

论文中做了这样的类比,无性繁殖可以保留大段的优秀基因,而有性繁殖则将基因随机拆了又拆,破坏了大段基因的联合适应性,但是自然选择中选择了有性繁殖,物竞天择,适者生存,可见有性繁殖的强大。

dropout 也能达到同样的效果,它强迫一个神经单元,和随机挑选出来的其他神经单元共同工作,消除减弱了神经元节点间的联合适应性,增强了泛化能力。

4.2 Batch Normalization

Batch Normalization, 批标准化, 和普通的数据标准化类似, 是将分散的数据调整分布的一种做法, 也是优化神经网络的一种方法.

Batch Normalization是基于Mini-Batch SGD的一种优化方法。

虽然BN层还解释不清其理论原因,但是实践证明加入BN层可以显著提升模型收敛速度。

机器学习领域有个很重要的假设:样本独立同分布假设,就是假设训练数据和测试数据是满足相同分布的,这是通过训练数据获得的模型能够在测试集获得好的效果的一个基本保障。

但是随着模型的训练,各层网络参数的值一直在变化,各个隐藏层的输入数据的分布也会随之不停的变化,对于每个隐藏层来说,输入就不符合样本独立同分布的假设。

那BatchNorm的作用是什么呢?BatchNorm就是在深度神经网络训练过程中使得每一层神经网络的输入保持相同分布的。

每个隐层神经元的激活值做BN,可以想象成每个隐层又加上了一层BN操作层,它位于A=X*W+B激活值获得之后,非线性函数变换之前,其图示如下

 

请先
登录
后评论
0 条评论
暂时没有评论
最新文章
更多