（超详细！！）Pytorch循环神经网络（RNN）快速入门与实战

0. 前言

很久没用过Pytorch，忘得差不多了，最近课题需要用，所以整理一下RNN的使用方法。记得去年学这部分一直很迷糊，所以希望这篇博客能对大家有所帮助。

1. 简单循环神经网络结构

先简单聊聊RNN的结构。最简单的一层RNN网络结构如下图所示，其中，每个箭头都表示一个权值，输入为向量$X=[x_1,x_2,...,x_T]$，输出向量为$Y=[y1,y2,...,y_T]$，隐含层向量为$H=[h_1,h_2,...,h_T]$，一层指的是有一层隐含层。

循环神经网络结构也可以表示成下面两图：


其实，这些图都是等价的。

那么循环神经网络的工作流程是怎么样的呢？一般循环神经网络的输入是时序数据，输出可以是由上述$y_1$至$y_n$组成的向量，也可以是$y_1$至$y_n$在连接一个线性层得到的一个数值。
比如，现在要用RNN做房价预测。如果目标是 输入今年1-6月的房价，输出是7-12月的房价，那可以直接将隐含层的输出作为网络输出。如果目标是 输入今年1-12月份的房价，输出是预测的明年1月的房价，那此时循环神经网络经过隐含层后，可以接入一个全连接层，也可以将最后时刻隐含层的输出作为网络输出，分别如下图(a)(b)所示。

另外，上述都只有一层隐含层，也可以根据具体需求设计多层，一般层数取2-10。
所以，网络的输出取哪部分，结构是什么都要看自己怎么设计。模型参数训练的数学推导在此不做证明。

２.Pytorch中RNN Layer的使用

2.1 RNN模块

Pytorch中RNN模块函数为torch.nn.RNN(input_size,hidden_size,num_layers,batch_first)，每个参数的含义如下:

• input_size：输入数据的编码维度，比如前面举例的房价预测，房价都是用一维的数直接表示的，所以此时input_size为1；如果输入的是字符编码，比如一个字符用3维编码表示，那么此时input_size为3；
• hidden_size：隐含层的维数，这个维数要么参考别人的结构设置，要么自行设置，比如可以设置成20；
• num_layers：隐含层的层数，也就是上面几幅图有几个h层，上面都是只有1层，所以 num_layers为1。
• batch_first：当 batch_first设置为True时，输入的参数顺序变为：x：[batch, seq_len, input_size]，h0：[batch, num_layers, hidden_size]。

2.2 输入的表示

输入的表示形式，输入如下图所示，输入主要有向量$x$、初始的$h_0$， 其中x：[seq_len, batch, input_size]，h0：[num_layers, batch, hidden_size]，下面分别介绍每个参数的意义。

• seq_len：输入的长度，即有多少个$x_i$，上述房价预测中，如果输入的是12个月的房价，那么seq_len就为12；
• batch：在训练神经网络时，可以多条数据同时训练，还是以房价预测为例，现在同时拿去年，今年共两年的数据训练网络，也就是将两年的数据batch在了一起，比如输入$x_i$是去年和今年第i月份的房价；一直以来我都不太明白这个 batch是什么意思，直到看了这几篇文章：参考1，参考2，参考3，想了解更多，大家也可以看一下；
• input_size：就是torch.nn.RNN(input_size,hidden_size,num_layers)中的input_size，二者要保持一致；
• num_layers：与torch.nn.RNN中一致；
• hidden_size：与torch.nn.RNN中一致；
  
  
  

2.3 输出的表示

前面也说了，输出可以是Y向量，也可以是最后一个时刻隐含层的输出$h_T$，如果输出是Y向量，如下图所示，那么Y向量的结构为out:[seq_len, batch, hidden_size]，每个参数的意义与2.2中一致。

如果输出是最后一个时刻隐含层的输出$h_T$，如下图所示，那么h_t:[num_layers, batch, hidden_size]，与$h_0$结构完全一样。

2.4 代码验证

比如我现在想设计一个4层的RNN，用来做语音翻译，输入是一段中文，输出是一段英文。假设每个中文字符用100维数据进行编码，每个隐含层的维度是20，有4个隐含层。所以input_size = 100，hidden_size = 20，num_layers = 4。再假设模型已经训练好了，现在有个1个长度为10的句子做输入，那么seq_len = 10，batch_size = 1。代码如下：

import torch import torch.nn as nn input_size = 100 # 输入数据编码的维度 hidden_size = 20 # 隐含层维度 num_layers = 4 # 隐含层层数 rnn = nn.RNN(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers) print("rnn:",rnn) seq_len = 10 # 句子长度 batch_size = 1 x = torch.randn(seq_len,batch_size,input_size) # 输入数据 h0 = torch.zeros(num_layers,batch_size,hidden_size) # 输入数据 out, h = rnn(x, h0) # 输出数据 print("out.shape:",out.shape) print("h.shape:",h.shape) 

• 代码中给输入x赋随机数模拟编码，输出如下，可以发现输出数据的维度与之前分析的一致。
  
  
  

3. RNN做时序数据预测

假设现在有一系列3维飞机航迹数据，我们想预测接下来的航迹数据，那么可以考虑用RNN预测。首先设计网络，每个航迹点都是3维的，所以input_size = 3，隐含层hidden_size = 16，有一个隐含层，所以num_layers = 1。为了更好的利用数据，下面代码实现的是这样的功能：输入第[1,15]个数据，输出第[6,21]个数据，即往后平移5个单位的数据。

3.1 设置全局变量与定义RNN类

设置全局变量# num_time_steps = 16 input_size = 3 hidden_size = 16 output_size = 3 num_layers = 1 lr=0.01 定义RNN类# class Net(nn.Module): def __init__(self, input_size, hidden_size, num_layers): super(Net, self).__init__() self.rnn = nn.RNN( input_size=input_size, hidden_size=hidden_size, num_layers=1, batch_first=True, ) for p in self.rnn.parameters(): nn.init.normal_(p, mean=0.0, std=0.001) self.linear = nn.Linear(hidden_size, output_size) def forward(self, x, hidden_prev): out, hidden_prev = self.rnn(x, hidden_prev) # [b, seq, h] out = out.view(-1, hidden_size) out = self.linear(out)#[seq,h] => [seq,3] out = out.unsqueeze(dim=0) # => [1,seq,3] return out, hidden_prev 

nn.init.normal_的设置为为了预防梯度消失，具体可参考：https://blog.csdn.net/dss_dssssd/article/details/

3.2 网络的训练

开始训练模型 def tarin_RNN(data): model = Net(input_size, hidden_size, num_layers) print('model:\n',model) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr) #初始化h hidden_prev = torch.zeros(1, 1, hidden_size) l = [] # 训练3000次 for iter in range(3000): # loss = 0 start = np.random.randint(10, size=1)[0] end = start + 15 x = torch.tensor(data[start:end]).float().view(1, num_time_steps - 1, 3) # 在data里面随机选择15个点作为输入，预测第16 y = torch.tensor(data[start + 5:end + 5]).float().view(1, num_time_steps - 1, 3) output, hidden_prev = model(x, hidden_prev) hidden_prev = hidden_prev.detach() loss = criterion(output, y) model.zero_grad() loss.backward() optimizer.step() if iter % 100 == 0: print("Iteration: {} loss {}".format(iter, loss.item())) l.append(loss.item()) 绘制损失函数 plt.plot(l,'r') plt.xlabel('训练次数') plt.ylabel('loss') plt.title('RNN损失函数下降曲线') return hidden_prev,model 

3.3 预测

def RNN_pre(model,data,hidden_prev): data_test = data[19:29] data_test = torch.tensor(np.expand_dims(data_test, axis=0),dtype=torch.float32) pred1,h1 = model(data_test,hidden_prev ) print('pred1.shape:',pred1.shape) 

3.4 全部代码

import torch import datetime import numpy as np import torch.nn as nn import torch.optim as optim from matplotlib import pyplot as plt from mpl_toolkits.mplot3d import Axes3D from pylab import mpl mpl.rcParams['font.sans-serif'] = ['FangSong'] mpl.rcParams['axes.unicode_minus'] = False 设置全局变量 num_time_steps = 16 # 训练时时间窗的步长 input_size = 3 # 输入数据维度 hidden_size = 16 # 隐含层维度 output_size = 3 # 输出维度 num_layers = 1 lr=0.01 定义RNN类# class Net(nn.Module): def __init__(self, input_size, hidden_size, num_layers): super(Net, self).__init__() self.rnn = nn.RNN( input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, ) for p in self.rnn.parameters(): nn.init.normal_(p, mean=0.0, std=0.001) self.linear = nn.Linear(hidden_size, output_size) def forward(self, x, hidden_prev): out, hidden_prev = self.rnn(x, hidden_prev) # [b, seq, h] out = out.view(-1, hidden_size) out = self.linear(out)#[seq,h] => [seq,3] out = out.unsqueeze(dim=0) # => [1,seq,3] return out, hidden_prev 初始化训练集 def getdata(): x1 = np.linspace(1,10,30).reshape(30,1) y1 = (np.zeros_like(x1)+2)+np.random.rand(30,1)*0.1 z1 = (np.zeros_like(x1)+2).reshape(30,1) tr1 = np.concatenate((x1,y1,z1),axis=1) # mm = MinMaxScaler() # data = mm.fit_transform(tr1) #数据归一化 return tr1 开始训练模型 def tarin_RNN(data): model = Net(input_size, hidden_size, num_layers) print('model:\n',model) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr) #初始化h hidden_prev = torch.zeros(1, 1, hidden_size) l = [] # 训练3000次 for iter in range(3000): # loss = 0 start = np.random.randint(10, size=1)[0] end = start + 15 x = torch.tensor(data[start:end]).float().view(1, num_time_steps - 1, 3) # 在data里面随机选择15个点作为输入，预测第16 y = torch.tensor(data[start + 5:end + 5]).float().view(1, num_time_steps - 1, 3) output, hidden_prev = model(x, hidden_prev) hidden_prev = hidden_prev.detach() loss = criterion(output, y) model.zero_grad() loss.backward() optimizer.step() if iter % 100 == 0: print("Iteration: {} loss {}".format(iter, loss.item())) l.append(loss.item()) 绘制损失函数 plt.plot(l,'r') plt.xlabel('训练次数') plt.ylabel('loss') plt.title('RNN损失函数下降曲线') return hidden_prev,model 预测 def RNN_pre(model,data,hidden_prev): data_test = data[19:29] data_test = torch.tensor(np.expand_dims(data_test, axis=0),dtype=torch.float32) pred1,h1 = model(data_test,hidden_prev ) print('pred1.shape:',pred1.shape) pred2,h2 = model(pred1,hidden_prev ) print('pred2.shape:',pred2.shape) pred1 = pred1.detach().numpy().reshape(10,3) pred2 = pred2.detach().numpy().reshape(10,3) predictions = np.concatenate((pred1,pred2),axis=0) # predictions= mm.inverse_transform(predictions) print('predictions.shape:',predictions.shape) 预测可视化# fig = plt.figure(figsize=(9, 6)) ax = Axes3D(fig) ax.scatter3D(data[:, 0],data[:, 1],data[:,2],c='red') ax.scatter3D(predictions[:,0],predictions[:,1],predictions[:,2],c='y') ax.set_xlabel('X') ax.set_xlim(0, 8.5) ax.set_ylabel('Y') ax.set_ylim(0, 10) ax.set_zlabel('Z') ax.set_zlim(0, 4) plt.title("RNN航迹预测") plt.show() def main(): data = getdata() start = datetime.datetime.now() hidden_pre, model = tarin_RNN(data) end = datetime.datetime.now() print('The training time: %s' % str(end - start)) plt.show() RNN_pre(model, data, hidden_pre) if __name__ == '__main__': main() 

• 损失函数曲线：
  
  
  
• 航迹预测结果：
  
  最后推荐一篇文章，讲的是Pytorch写LSTM，看懂本文再学LSTM与GRU等都很简单，希望得到点赞！！