通俗LSTM长短时记忆循环神经网络介绍

原创

卡尔曼和玻尔兹曼谁曼

发布于 2019-03-03 08:48:35

2.3K0

发布于 2019-03-03 08:48:35

文章被收录于专栏：给永远比拿愉快给永远比拿愉快

写作时间：2019-03-02 18:20:11

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

通俗LSTM长短时记忆循环神经网络介绍

LSTM图解

处理流程

在上一篇文章中简单介绍了经典RNN模型，并提到了RNN的一些缺点。LSTM（Long Short-Term Memory）解决了经典RNN不能很好地保存长时序信息的缺点，得到了更加广泛地应用。下面简单说说LSTM的流程。

通过对比我们可以发现，LSTM和经典RNN有如下的区别：

除了中间状态H，还多了一个C
每个循环网络的单元（Cell）变得复杂了（多了所谓的三道门“遗忘门”（forget gate），“输入门”（input gate）和“输出门”（output gate））

这里所谓的“门”其实就是选择性地对信息进行过滤，在实践中用sigmoid函数（在图中用\sigma表示）实现。

首先，t-1时刻的输入h_{t-1}和x_t经过一个线性变换+sigmoid激活以后（这就是所谓的遗忘门），输出f_t。f_t再与c_{t-1}进行相乘（element-wise multiplication）得到一个中间结果。

然后，t-1时刻的输入h_{t-1}和x_t经过另外一个线性变换+sigmoid激活以后（这就是所谓的输入门），输出l_t。同时，h_{t-1}和x_t经过再另外一个线性变换+tanh激活以后），与l_t相乘得到一个中间结果。这个中间结果和上一步的中间结果相加（element-wise addition）得到c_t。

最后，t-1时刻的输入h_{t-1}和x_t经过另外一个线性变换+sigmoid激活以后（这就是所谓的输出门），输出o_t。o_t与经过tanh的c_t相乘得到h_t。

至此，所有的状态更新完毕。

流程图解

下面给出上面文字描述的步骤所对应的数学公式：

总结说明

上图的左子图给出了对于每个门的输入和输出，右子图说明了每个门的作用。

PyTorch实战

我们还是以《最简单的RNN回归模型入门》中的使用Sin预测Cos的例子进行演示，代码跟之间的没有太大的区别，唯一的不同就是在中间状态更新的时候，现在有C和H两种中间状态需要更新。

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

torch.manual_seed(2019)

# 超参设置
TIME_STEP = 20  # 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.LSTM(
            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[0].detach(), h_state[1].detach())  # 注意这里和原来的RNN的不同
    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设置为20的时候，输出结果如下：