NLP笔记（4）——Pytorch基础模块

一、向前计算和梯度运算

1.向前计算

对于pytorch中的一个tensor，如果设置它的属性 .requires_grad为True，那么它将会追踪对于该张量的所有操作。或者可以理解为，这个tensor是一个参数，后续会被计算梯度，更新该参数。

import torch
x = torch.ones(2, 2, requires_grad=True)  #初始化参数x并设置requires_grad=True用来追踪其计算历史
print(x)
y = x+2
print(y)
z = y*y*3  #平方x3
print(x)
out = z.mean() #求均值
print(out)

 从上述代码可以看出：x的requires_grad属性为True。之后的每次计算都会修改其grad_fn属性，用来记录做过的操作通过这个函数和grad_fn能够组成一个和前一小节类似的计算图

a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)  #False
a.requires_grad_(True)  #就地修改
print(a.requires_grad)  #True
b = (a * a).sum()
print(b.grad_fn) # <SumBackward0 object at 0x4e2b14345d21>
with torch.no_gard():
    c = (a * a).sum()  #tensor(151.6830),此时c没有gard_fn
print(c.requires_grad) #False

为了防止跟踪历史记录（内存），可以将代码块包装在`with torch.no_grad():中。在评估模型时特别有用，因为模型可能具有requires_grad = True的可训练的参数，但是我们不需要在此过程中对他们进行梯度计算。

2.梯度计算

可以使用backward方法来进行反向传播，计算梯度out.backward(),此时便能够求出导数,调用x.gard能够获取导数值。在输出为一个标量的情况下，我们可以调用输出tensor的backword() 方法，但是在数据是一个向量的时候，调用backward()的时候还需要传入其他参数。很多时候我们的损失函数都是一个标量，所以这里就不再介绍损失为向量的情况。loss.backward()就是根据损失函数，对参数（requires_grad=True）的去计算他的梯度，并且把它累加保存到x.gard，此时还并未更新其梯度。

3.线性回归实现

下面，我们使用一个自定义的数据，来使用torch实现一个简单的线性回归假设我们的基础模型就是y = wx+b，其中w和b均为参数，我们使用y = 3x+0.8来构造数据x、y，所以最后通过模型应该能够得出w和b应该分别接近3和0.8

import torch
import numpy as np
from matplotlib import pyplot as plt
#1. 准备数据 y = 3x+0.8，准备参数
x = torch.rand([50])
y = 3*x + 0.8
w = torch.rand(1,requires_grad=True)
b = torch.rand(1,requires_grad=True)
def loss_fn(y,y_predict):
    loss = (y_predict-y).pow(2).mean()
    for i in [w,b]:
    #每次反向传播前把梯度置为0
        if i.grad is not None:
            i.grad.data.zero_()
    # [i.grad.data.zero_() for i in [w,b] if i.grad is not None]
    loss.backward()
    return loss.data
def optimize(learning_rate):
    # print(w.grad.data,w.data,b.data)
    w.data -= learning_rate* w.grad.data
    b.data -= learning_rate* b.grad.data
for i in range(3000):
    #2. 计算预测值
    y_predict = x*w + b
    #3.计算损失，把参数的梯度置为0，进行反向传播 
    loss = loss_fn(y,y_predict)
    if i%500 == 0:
        print(i,loss)
    #4. 更新参数w和b
    optimize(0.01)
# 绘制图形，观察训练结束的预测值和真实值
predict =  x*w + b  #使用训练后的w和b计算预测值
plt.scatter(x.data.numpy(), y.data.numpy(),c = "r")
plt.plot(x.data.numpy(), predict.data.numpy())
plt.show()
print("w",w)
print("b",b)

输出：

w tensor([2.9280], requires_grad=True)
b tensor([0.8372], requires_grad=True)

二、PyTorch常用API

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()
# 传入数据，计算结果
predict = model(x)

2.优化器

优化器(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. 更新参数的值

3.损失函数

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

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

交叉熵损失：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. 更新参数的值

4.线性回归实现 

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的时候。

三、常见优化算法

1.梯度下降法

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

2.随机梯度下降法

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

torch.optim.SGD()

3.小批量梯度下降法

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

4.动量法

mini-batch SGD算法虽然这种算法能够带来很好的训练速度，但是在到达最优点的时候并不能够总是真正到达最优点，而是在最优点附近徘徊。另一个缺点就是mini-batch SGD需要我们挑选一个合适的学习率，当我们采用小的学习率的时候，会导致网络在训练的时候收敛太慢；当我们采用大的学习率的时候，会导致在训练过程中优化的幅度跳过函数的范围，也就是可能跳过最优点。我们所希望的仅仅是网络在优化的时候网络的损失函数有一个很好的收敛速度同时又不至于摆动幅度太大。所以Momentum优化器刚好可以解决我们所面临的问题，它主要是基于梯度的移动指数加权平均，对网络的梯度进行平滑处理的，让梯度的摆动幅度变得更小。

5.AdaGrad

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

6.RMSProp

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

7.Adam

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

torch.optim.Adam()

8.不同优化方法的动态学习

图片版权:https://twitter.com/alecrad

损失函数的等高线：

 鞍点处的学习情况:

四、如何在GPU上运行

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

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

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

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

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

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

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

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

修改之后的代码如下：

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

最后：

如果你想要进一步了解更多的相关知识，可以关注下面公众号联系~会不定期发布相关设计内容包括但不限于如下内容:信号处理、通信仿真、算法设计、matlab appdesigner，gui设计、simulink仿真......希望能帮到你！