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

Dear 丶 2022-03-15 13:30 576阅读 0赞

### 文章目录 ###

*  最简单的RNN回归模型入门（PyTorch版）
 *   *  RNN入门介绍
     *  PyTorch中的RNN
     *  代码实现与结果分析

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

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

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

## RNN入门介绍 ##

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

我们首先来来看一张经典的RNN模型示意图！  
![Recurrent Neural Network][]

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

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

a t = V h t − 1 + U x t + b h t = t a n h ( a t ) o t = W h t + c y t = s i g m o i d ( o t ) a^t = Vh^\{t-1\} + Ux^t + b \\\\ h^t=tanh(a^t) \\\\ o^t=Wh^t + c\\\\ y^t=sigmoid(o^t) at=Vht−1\+Uxt\+bht=tanh(at)ot=Wht\+cyt=sigmoid(ot)

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

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

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

## PyTorch中的RNN ##

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

先来看一下PyTorch中[RNN][]类的原型：  
![torch.nn.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的输入输出][RNN 1]

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

隐藏状态 h i h\_i hi的尺寸是（`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 h\_i hi，当然这个尺寸和初始的隐藏状态相同。

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

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

最后的结果如下：  
![RNN使用Sin预测Cos][RNN_Sin_Cos]

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

![RNN TIME\_STEP等于10][RNN TIME_STEP_10]  
![RNN TIME\_STEP=20][RNN TIME_STEP_20]

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

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

[Recurrent Neural Network]: /images/20220315/322aeb0fc0db41d5a6cbc83c43c251a8.png
[RNN]: https://pytorch.org/docs/stable/nn.html#rnn
[torch.nn.RNN]: /images/20220315/af75c18dcedf4a7c97bc3c0d5f61612c.png
[RNN 1]: /images/20220315/c0a24e5648d5422ab54fb5d88a761b83.png
[RNN_Sin_Cos]: /images/20220315/8d8e0e551eff4ddbac573d48d4afc03d.png
[RNN TIME_STEP_10]: /images/20220315/38a18f65c72e4010a058f62df8482cb8.png
[RNN TIME_STEP_20]: /images/20220315/379721ddbab34fc0a88c126cb148bd71.png