最简单的RNN回归模型入门(PyTorch)

版权声明：本文为博主原创文章，转载请注明原文出处！
写作时间：2019-03-02 12:46:15

本文部分图片素材来自互联网，如有侵权，请联系作者删除！

最简单的RNN回归模型入门（PyTorch版）

RNN入门介绍

至于RNN的能做什么，擅长什么，这里不赘述。如果不清楚，请先维基一下，那里比我说得更加清楚。

我们首先来来看一张经典的RNN模型示意图！

图分左右两边：左边给出的RNN是一个抽象的循环结构，右边是左边RNN展开以后的形式。先来看右边的结构，从下往上依次是序列数据的输入X（图中的绿色结构，可以是时间序列，也可以是文本序列等等）。对于t时刻的x经过一个线性变换（U是变换的权重），然后与t-1时刻经过线性变换V的h相加，再经过一个 非线性激活（一般使用tanh或者relu函数）以后，形成一个t时刻的中间状态h，然后再经过一个线性变换（W）输出o ，最后再经过一个非线性激活（可以是sigmoid函数或者softmax等函数）形成最后的输出y。

上面的文字描述，可以形式化表示为下面的公式：

$$\begin{gathered} a^t=V{h}^{t-1}+U{x}^t+b \\ {h}^t=tanh(a^t) \\ {o}^t=W{h}^t+c \\ {y}^t=sigmoid(o^t) \end{gathered}$$

是不是公式能比文字更加说明问题！

再来说左边的结构，坐标的结构表明后面地展开网络中的U，V，W参数都是在共享的，就是说不管我们的序列有多长，都是共享这一套参数的。这是RNN很重要的一个特性。

RNN的隐藏层可以有多层，但是RNN中我们的隐藏层一般不会设置太多，因为在横向上有很长的序列扩展形成的网络，这部分特征是我们更加关注的。最后，需要说明的是RNN可以是单向的，也可以是双向的。

PyTorch中的RNN

下面我们以一个最简单的回归问题使用正弦sin函数预测余弦cos函数，介绍如何使用PyTorch实现RNN模型。

先来看一下PyTorch中RNN类的原型：

• 必选参数input_size指定输入序列中单个样本的大小尺寸，比如在NLP中我们可能用用一个10000个长度的向量表示一个单词，则这个input_size就是10000。在咱们的回归案例中，一个序列中包含若干点，而每个点的所代表的函数值（Y）作为一个样本，则咱们案例中的input_size为1。这个参数需要根据自己的实际问题确定。
• 必选参数hidden_size指的是隐藏层中输出特征的大小，这个是自定义的超参数。
• 必选参数num_layers指的是纵向的隐藏层的个数，根据实际问题我们一般可以选择1~10层。
• 可选参数batch_first指定是否将batch_size作为输入输出张量的第一个维度，如果是，则输入的尺寸为（batch_size， seq_length，input_size），否则，默认的顺序是（seq_length，batch_size， input_size）。
• 可选参数bidirectional指定是否使用双向RNN。

下面再来说说RNN输入输出尺寸的问题，了解了这个可以让我们我们调试代码的时候更加清晰。下面是PyTorch官方的说明：

对于RNN的输入包括输入序列和一个初始化的隐藏状态$h_0$。输入序列尺寸默认是（sequence_length，batch_size， input_size），所以如果我们的数据形式不是这样的，则需要手动调整为这种类型的格式。

隐藏状态$h_i$的尺寸是（num_layers * num_directions， batch_size，hidden_size）。单向RNN的num_directions为1，双向RNN的num_directions为2。

他们的尺寸为什么是这样的呢？这得根据本文开头的那个公式计算，即就是矩阵的相乘需要满足矩阵尺寸的关系，聪明的你想明白了吗？

输出的尺寸为 （sequence_length， batch_size， num_directions * hidden_size）

每一次RNN运行结果输出中还会附带输出中间隐藏状态$h_i$，当然这个尺寸和初始的隐藏状态相同。

下面以一个简单的例子说明怎么在程序中查看他们的尺寸：

import torch
import torch.nn as nn

rnn = nn.RNN(10, 20, 2)
inputs = torch.randn(5, 3, 10)  # (time_step, batch_size, input_size)
h0 = torch.randn(2, 3, 20)  # (num_layers, batch_size, hidden_size)
output, hn = rnn(inputs, h0)
print(output.shape)  # (time_step, batch_size, hidden_size)

for name, param in rnn.named_parameters():
    if param.requires_grad:
        print(name, param.size())

其输出结果如下：

torch.Size([5, 3, 20])
weight_ih_l0 torch.Size([20, 10])
weight_hh_l0 torch.Size([20, 20])
bias_ih_l0 torch.Size([20])
bias_hh_l0 torch.Size([20])
weight_ih_l1 torch.Size([20, 20])
weight_hh_l1 torch.Size([20, 20])
bias_ih_l1 torch.Size([20])
bias_hh_l1 torch.Size([20])

这里的weight_ih_l0表示的是RNN隐藏层第一层的权重U，weight_hh_l0表示的隐藏层第一层的权重V，类似的bias开头的表示偏置或者叫增益（我不知道中文如何翻译），以l数字结尾的表示第几层的权重或者偏置。

代码实现与结果分析

好了，搞清楚了RNN的基本原理以及PyTorch中RNN类的输入输出参数要求，我们下面实现我们的回归案例。

比较重要的几个超参数是：TIME_STEP指定输入序列的长度（一个序列中包含的函数值的个数），INPUT_SIZE是1，表示一个序列中的每个样本包含一个函数值。

我们自定义的RNN类包含两个模型：一个nn.RNN层，一个nn.Linear层，注意forward函数的实现，观察每个变量的尺寸（注释中给出了答案）。

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

torch.manual_seed(2019)

# 超参设置
TIME_STEP = 10  # RNN时间步长
INPUT_SIZE = 1  # RNN输入尺寸
INIT_LR = 0.02  # 初始学习率
N_EPOCHS = 100  # 训练回数


class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()
        self.rnn = nn.RNN(
            input_size=INPUT_SIZE,
            hidden_size=32,  # RNN隐藏神经元个数
            num_layers=1,  # RNN隐藏层个数
        )
        self.out = nn.Linear(32, 1)

    def forward(self, x, h):
        # x (time_step, batch_size, input_size)
        # h (n_layers, batch, hidden_size)
        # out (time_step, batch_size, hidden_size)
        out, h = self.rnn(x, h)
        prediction = self.out(out)
        return prediction, h


rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(), lr=INIT_LR)
loss_func = nn.MSELoss()
h_state = None  # 初始化隐藏层

plt.figure()
plt.ion()
for step in range(N_EPOCHS):
    start, end = step * np.pi, (step + 1) * np.pi  # 时间跨度
    # 使用Sin函数预测Cos函数
    steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)
    x_np = np.sin(steps)
    y_np = np.cos(steps)
    x = torch.from_numpy(x_np[:, np.newaxis, np.newaxis])  # 尺寸大小为(time_step, batch, input_size)
    y = torch.from_numpy(y_np[:, np.newaxis, np.newaxis])

    prediction, h_state = rnn(x, h_state)  # RNN输出（预测结果，隐藏状态）
    h_state = h_state.detach()  # 这一行很重要，将每一次输出的中间状态传递下去(不带梯度)
    loss = loss_func(prediction, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # 绘制中间结果
    plt.cla()
    plt.plot(steps, y_np, 'r-')
    plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
    plt.draw()
    plt.pause(0.1)
plt.ioff()
plt.show()

最后的结果如下：

最后放一个当TIME_STEP分别等于10和20的最终预测结果的对比图：

第一张是TIME_STEP=10的预测结果，第二张是TIME_STEP=20的预测结果。为什么当TIME_STEP=20的预测结果差得十万八千里呢？

这是因为经典的RNN存在梯度爆炸和梯度弥散问题（我尝试修剪了梯度可是结果还是很差，不知道是不是其它原因），对长时序的预测表现很不好，所以才有了后来的LSTM和GRU等RNN变种。实际现在已经很少使用经典RNN了。有时间在说说LSTM吧，欢迎关注！