使用torch实现RNN

　　（本文对https://blog.csdn.net/out_of_memory_error/article/details/81456501的结果进行了复现。）

　　在实验室的项目遇到了困难，弄不明白LSTM的原理。到网上搜索，发现LSTM是RNN的变种，那就从RNN开始学吧。

　　带隐藏状态的RNN可以用下面两个公式来表示：使用torch实现RNN-LMLPHP

　　可以看出，一个RNN的参数有W_xh，W_hh，b_h，W_hq，b_q和H(t)。其中H(t)是步数的函数。

　　参考的文章考虑了这样一个问题，对于x轴上的一列点，有一列sin值，我们想知道它对应的cos值，但是即使sin值相同，cos值也不同，因为输出结果不仅依赖于当前的输入值sinx，还依赖于之前的sin值。这时候可以用RNN来解决问题

　　用到的核心函数：torch.nn.RNN() 参数如下：

input_size – 输入x的特征数量。
hidden_size – 隐藏层的特征数量。
num_layers – RNN的层数。
nonlinearity – 指定非线性函数使用tanh还是relu。默认是tanh。
bias – 如果是False，那么RNN层就不会使用偏置权重 $b_ih$和$b_hh$,默认是True
batch_first – 如果True的话，那么输入Tensor的shape应该是[batch_size, time_step, feature],输出也是这样。
dropout – 如果值非零，那么除了最后一层外，其它层的输出都会套上一个dropout层。
bidirectional – 如果True，将会变成一个双向RNN，默认为False。

　　下面是代码：

 # encoding:utf-8

 import torch

 import numpy as np

 import matplotlib.pyplot as plt  # 导入作图相关的包

 from torch import nn

 # 定义RNN模型

 class Rnn(nn.Module):

     def __init__(self, INPUT_SIZE):

         super(Rnn, self).__init__()

         # 定义RNN网络,输入单个数字.隐藏层size为[feature, hidden_size]

         self.rnn = nn.RNN(

                 input_size=INPUT_SIZE,

                 hidden_size=32,

                 num_layers=1,

                 batch_first=True  # 注意这里用了batch_first=True 所以输入形状为[batch_size, time_step, feature]

                 )

         # 定义一个全连接层,本质上是令RNN网络得以输出

         self.out = nn.Linear(32, 1)

     # 定义前向传播函数

     def forward(self, x, h_state):

         # 给定一个序列x,每个x.size=[batch_size, feature].同时给定一个h_state初始状态,RNN网络输出结果并同时给出隐藏层输出

         r_out, h_state = self.rnn(x, h_state)

         outs = []

         for time in range(r_out.size(1)):  # r_out.size=[1,10,32]即将一个长度为10的序列的每个元素都映射到隐藏层上.

             outs.append(self.out(r_out[:, time, :]))  # 依次抽取序列中每个单词,将之通过全连接层并输出.r_out[:, 0, :].size()=[1,32] -> [1,1]

         return torch.stack(outs, dim=1), h_state  # stack函数在dim=1上叠加:10*[1,1] -> [1,10,1] 同时h_state已经被更新

 TIME_STEP = 10

 INPUT_SIZE = 1

 LR = 0.02

 model = Rnn(INPUT_SIZE)

 print(model)

 loss_func = nn.MSELoss()  # 使用均方误差函数

 optimizer = torch.optim.Adam(model.parameters(), lr=LR)  # 使用Adam算法来优化Rnn的参数,包括一个nn.RNN层和nn.Linear层

 h_state = None  # 初始化h_state为None

 for step in range(300):

     # 人工生成输入和输出,输入x.size=[1,10,1],输出y.size=[1,10,1]

     start, end = step * np.pi, (step + 1)*np.pi

     steps = np.linspace(start, end, TIME_STEP, dtype=np.float32)

     x_np = np.sin(steps)

     y_np = np.cos(steps)

     x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])

     y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

     # 将x通过网络,长度为10的序列通过网络得到最终隐藏层状态h_state和长度为10的输出prediction:[1,10,1]

     prediction, h_state = model(x, h_state)

     h_state = h_state.data  # 这一步只取了h_state.data.因为h_state包含.data和.grad 舍弃了梯度

     # 反向传播

     loss = loss_func(prediction, y)

     optimizer.zero_grad()

     loss.backward()

     # 优化网络参数具体应指W_xh, W_hh, b_h.以及W_hq, b_q

     optimizer.step()

 # 对最后一次的结果作图查看网络的预测效果

 plt.plot(steps, y_np.flatten(), 'r-')

 plt.plot(steps, prediction.data.numpy().flatten(), 'b-')

 plt.show()

　　最后一步预测和实际y的结果作图如下：

使用torch实现RNN-LMLPHP

　　可看出，训练RNN网络之后，对网络输入一个序列sinx，能正确输出对应的序列cosx