长短时记忆神经网络(LSTM)——【torch学习笔记】

长短时记忆(LSTM)

引用翻译：《动手学深度学习》

在潜变量模型中解决长期信息保存和短期输入跳过的挑战已经存在很长时间了。最早解决这个问题的方法之一是Hochreiter和Schmidhuber的LSTM，1997179。它与门控递归单元（GRU）的许多特性相同，并且比它早了近二十年。它的设计稍微复杂一些。可以说，它的灵感来自于计算机的逻辑门。为了控制一个存储单元，我们需要一些门。其中一个门需要从单元中读出条目（相对于读取任何其他单元而言）。我们将把它称为输出门。第二个门需要决定何时将数据读入单元。我们把它称为输入门。最后，我们需要一个机制来重置单元的内容，由一个遗忘门来管理。这样设计的动机和以前一样，即能够通过一个专门的机制来决定何时记住和何时忽略进入潜伏状态的输入。让我们看看这在实践中是如何运作的。

一、门控记忆单元

LSTM中引入了三个门：输入门、遗忘门和输出门。除此之外，我们还引入了记忆单元，其形状与隐藏状态相同。严格来说，这只是隐藏状态的一个花哨版本，是为记录额外信息而定制的。

二、输入门、遗忘门和输出门

就像GRU一样，输入LSTM门的数据是当前时间步骤的输入和前一个时间步骤的隐藏状态。这些输入被一个全连接层和一个sigmoid激活函数处理，以计算出输入、遗忘和输出门的值。因此，三个门元素的值范围都是[0, 1]。

我们假设有h个隐藏单元，并且minibatch的大小为n，因此输入为 ∈ ×（例子数：n，输入数：d），最后一个时间步骤的隐藏状态为-1 ∈ ×ℎ。相应的门定义如下：输入门为 ∈ ×ℎ ，遗忘门为 ∈ ×ℎ ，输出门为 ∈ × 。它们的计算方式如下:

$$I_t=\sigma (X_t{W}_{xi}+H_{t-1}{W}_{hi}+b_i)$$
$$F_t=\sigma (X_t{W}_{xf}+H_{t-1}{W}_{hf}+b_f)$$
$$O_t=\sigma (X_t{W}_{xo}+H_{t-1}{W}_{ho}+b_o)$$
$W_{xi}$, $W_{xf}$, $W_{xo}$ ∈ $R^{d\times h}$ and $W_{hi}$, $W_{hf}$, $W_{ho}$ ∈ $R^{h\times h}$ 是权重参数， $B_i$, $b_f$ , $b_o$ ∈ $R^{1\times h}$ 是偏置参数。

三、候选的存储单元

接下来设计一个存储单元。由于还没有指定各种门的动作，首先介绍一个候选记忆单元 ~ ∈ ×ℎ 。它的计算方法与上面描述的三个门类似，但使用的是tanh函数。

Fig. 10.9.1: LSTM中输入、遗忘和输出门的计算。

激活函数为[-1, 1]的值范围。这导致了在时间步骤t的以下方程。

$$\widetilde{C_t}=tanh(X_t{W}_{xc}+H_{t-1}{W}_{hc}+b_c)$$

$W_{xc}$ ∈ $R^{d\times h}$ 和 $W_{hc}$ ∈ $R^{h\times h}$ 是权重，并且 $b_c$ ∈ $R^{1\times h}$ 是偏置.

四、记忆细胞

在GRU中，我们有一个单一的机制来管理输入和遗忘。在这里，我们有两个参数，控制我们通过~考虑新数据的程度，而遗忘参数解决我们保留多少旧的记忆单元内容-1∈×ℎ。使用与之前相同的点乘法技巧，我们得出以下更新方程。

$$Ct=F_t\odot C_{t-1}+I_t\odot \widetilde{C_t}.$$

如果遗忘门总是近似于1，而输入门总是近似于0，那么过去的记忆单元将随着时间的推移被保存下来，并传递到当前的时间步骤。这种设计是为了缓解梯度消失的问题，并更好地捕捉具有长距离依赖性的时间序列的依赖性。因此，我们得出了以下流程图。

五、隐藏状态

最后我们需要定义如何计算隐藏状态 ∈ ×ℎ 。这就是输出门发挥作用的地方。在LSTM中，它只是存储单元的tanh的门控版本。这保证了的值总是在[-1, 1]的区间内。每当输出门为1时，我们有效地将所有记忆信息传递给预测器，而输出为0时，我们只保留记忆单元中的所有信息，不做进一步处理。下图是数据流的图形说明。

$$H_t=O_t\odot tanh(C_t).$$

Fig. 10.9.2:LSTM中候选记忆单元的计算。

Fig. 10.9.3: LSTM中存储单元的计算。这里，乘法是按元素进行的。

Fig. 10.9.4: 隐藏状态的计算。乘法是逐元的。

def train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                          corpus_indices, vocab, device, is_random_iter,
                          num_epochs, num_steps, lr, clipping_theta,
                          batch_size, prefixes):
    """Train an RNN model and predict the next item in the sequence."""
    if is_random_iter:
        data_iter_fn = data_iter_random
    else:
        data_iter_fn = data_iter_consecutive
    params = get_params()
    loss =  nn.CrossEntropyLoss()
    start = time.time()
    for epoch in range(num_epochs):
        if not is_random_iter:
            # 如果使用相邻采样，隐藏状态在历时开始时被初始化
            state = init_rnn_state(batch_size, num_hiddens, device)
        l_sum, n = 0.0, 0
        data_iter = data_iter_fn(corpus_indices, batch_size, num_steps, device)
        for X, Y in data_iter:
            if is_random_iter:
                # 如果使用随机抽样，则在每次小批量更新前初始化隐藏状态
                state = init_rnn_state(batch_size, num_hiddens, device)
            else:
                # 否则，需要使用detach函数将隐藏状态从计算图中分离出来，以避免反向传播超出当前样本的范围。
                for s in state:
                    s.detach_()
            inputs = to_onehot(X, len(vocab))
            # 输出是num_steps个（batch_size, len(vocab)）形状的形式。
            (outputs, state) = rnn(inputs, state, params)
            # 缝合后是（num_steps * batch_size, len(vocab)）。
            outputs = torch.cat(outputs, dim=0)
            # Y的形状是（batch_size，num_steps），然后变成一个长度为batch * num_steps的转置后的向量。这使它与输出行有一对一的对应关系
            y = Y.t().reshape((-1,))
            # 通过交叉熵损失的平均分类误差
            l = loss(outputs, y.long()).mean()
            l.backward()
            with torch.no_grad():
                grad_clipping(params, clipping_theta, device)  # Clip the gradient
                sgd(params, lr, 1)
            # 由于误差是平均值，这里不需要对梯度进行平均。
            l_sum += l.item() * y.numel()
            n += y.numel()
        if (epoch + 1) % 50 == 0:
            print('epoch %d, perplexity %f, time %.2f sec' % (
                epoch + 1, math.exp(l_sum / n), time.time() - start))
            start = time.time()
        if (epoch + 1) % 100 == 0:
            for prefix in prefixes:
                print(' -',  predict_rnn(prefix, 50, rnn, params,
                                         init_rnn_state, num_hiddens,
                                         vocab, device))

def train_and_predict_rnn_nn(model, num_hiddens, init_gru_state, corpus_indices, vocab,
                                device, num_epochs, num_steps, lr,
                                clipping_theta, batch_size, prefixes, num_layers=1):
    """Train a RNN model and predict the next item in the sequence."""
    loss =  nn.CrossEntropyLoss()
    optm = torch.optim.SGD(model.parameters(), lr=lr)
    start = time.time()
    for epoch in range(1, num_epochs+1):
        l_sum, n = 0.0, 0
        data_iter = data_iter_consecutive(
            corpus_indices, batch_size, num_steps, device)
        state = model.begin_state(batch_size=batch_size, num_hiddens=num_hiddens, device=device ,num_layers=num_layers)
        for X, Y in data_iter:
            for s in state:
                s.detach()
            X = X.to(dtype=torch.long)
            (output, state) = model(X, state)
            y = Y.t().reshape((-1,))
            l = loss(output, y.long()).mean()
            optm.zero_grad()
            l.backward(retain_graph=True)
            with torch.no_grad():
                # Clip the gradient
                grad_clipping_nn(model, clipping_theta, device)
                # Since the error has already taken the mean, the gradient does not need to be averaged
                optm.step()
            l_sum += l.item() * y.numel()
            n += y.numel()

        if epoch % (num_epochs // 4) == 0:
            print('epoch %d, perplexity %f, time %.2f sec' % (
                epoch, math.exp(l_sum / n), time.time() - start))
            start = time.time()
        if epoch % (num_epochs // 2) == 0:
            for prefix in prefixes:
                print(' -', predict_rnn_nn(prefix, 50, batch_size, num_hiddens, num_layers, model, vocab, device))

class RNNModel(nn.Module):
    """RNN model."""

    def __init__(self, rnn_layer, num_inputs, vocab_size, **kwargs):
        super(RNNModel, self).__init__(**kwargs)
        self.rnn = rnn_layer
        self.vocab_size = vocab_size
        self.Linear = nn.Linear(num_inputs, vocab_size)

    def forward(self, inputs, state):
        """Forward function"""
        X = F.one_hot(inputs.long().transpose(0,-1), self.vocab_size)
        X = X.to(torch.float32)
        Y, state = self.rnn(X, state)
        output = self.Linear(Y.reshape((-1, Y.shape[-1])))
        return output, state

    def begin_state(self, num_hiddens, device, batch_size=1, num_layers=1):
        """Return the begin state"""
        if num_layers == 1:
          return  torch.zeros(size=(1, batch_size, num_hiddens), dtype=torch.float32, device=device)
        else:
          return (torch.zeros(size=(1, batch_size, num_hiddens), dtype=torch.float32, device=device),
                  torch.zeros(size=(1, batch_size, num_hiddens), dtype=torch.float32, device=device))

六、从零开始实现

现在是实现LSTM的时候了。我们以一个从零开始的模型开始。和前面的实验一样，我们首先需要加载数据。我们使用The Time Machine来完成。

import sys
sys.path.insert(0, '..')

import d2l
import torch
import torch.nn as nn
from d2l import RNNModel 
from d2l import load_data_time_machine
from d2l import train_and_predict_rnn
from d2l import train_and_predict_rnn_nn
torch.set_default_tensor_type('torch.cuda.FloatTensor')

corpus_indices, vocab = load_data_time_machine()

1、初始化模型参数

接下来我们需要定义和初始化模型参数。

如前所述，超参数num_hiddens定义了隐藏单元的数量。我们用方差为0.01的高斯值初始化权重，并将偏置设置为0。

num_inputs, num_hiddens, num_outputs = len(vocab), 256, len(vocab)
device = d2l.try_gpu()
print('Using', device)

Using cpu

def get_params():
    def _one(shape):
        return torch.randn(shape, device=device).normal_(std=0.01)
    
    def _three():
        return (_one((num_inputs, num_hiddens)),
                _one((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))
    W_xi,W_hi,b_i = _three() # 输入门参数
    W_xf,W_hf,b_f = _three() # 遗忘门参数
    W_xo,W_ho,b_o = _three() # 隐藏层输出参数
    W_xc,W_hc,b_c = _three() # 候选的细胞参数
    # 输出层参数
    W_hq = _one((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 创建梯度
    params = [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

2、定义模型

在初始化函数中，LSTM的隐藏状态需要返回一个额外的存储单元，其值为0，形状为（批处理大小，隐藏单元的数量）。因此，我们得到以下的状态初始化。

def init_lstm_state(batch_size, num_hiddens, device):
    return  (torch.zeros(size=(batch_size, num_hiddens), device=device),
             torch.zeros(size=(batch_size, num_hiddens), device=device))

实际模型的定义就像我们之前讨论的那样，有三个门和一个辅助的存储单元。请注意，只有隐藏状态被传递到输出层。存储单元不直接参与计算。

def lstm(inputs, state, params):
    [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q] = params
    (H, C) = state 
    outputs = []
    for X in inputs:
        sigmoid = nn.Sigmoid()
        I = sigmoid(torch.matmul(X.float(), W_xi) + torch.matmul(H.float(), W_hi) + b_i)
        F = sigmoid(torch.matmul(X.float(), W_xf) + torch.matmul(H.float(), W_hf) + b_f)
        O = sigmoid(torch.matmul(X.float(), W_xo) + torch.matmul(H.float(), W_ho) + b_o)
        tanh = nn.Tanh()
        C_tilda = tanh(torch.matmul(X.float(), W_xc) + torch.matmul(H.float(), W_hc) + b_c)
        C = F * C + I * C_tilda
        H = O * C.tanh()
        Y = torch.matmul(H.float(), W_hq) + b_q
        outputs.append(Y)
    return outputs, (H, C)

3、训练和预测

和上一节一样，在模型训练期间，我们只使用相邻的采样。设置好超参数后，我们进行训练和建模，并根据前缀 "旅行者 "和 "时间旅行者 "创建一串50个字符的文本。

num_epochs, num_steps, batch_size, lr, clipping_theta = 100, 35, 32, 3, 1
prefixes = ['traveller', 'time traveller']
train_and_predict_rnn(lstm, get_params, init_lstm_state, num_hiddens, 
                      corpus_indices, vocab, device, False, num_epochs,
                      num_steps, lr, clipping_theta, batch_size, prefixes)

epoch 50, perplexity 10.275354, time 581.96 sec
epoch 100, perplexity 5.878237, time 599.81 sec
 - traveller the time travelly the time travelly the time trav
 - time traveller the time travelly the time travelly the time trav

4、简洁的实现

我们可以直接调用rnn模块中的LSTM类来实例化该模型。

lstm_layer = nn.LSTM(input_size=num_inputs, hidden_size=num_hiddens)
model = RNNModel(lstm_layer, num_hiddens, len(vocab))
model.to(device)
train_and_predict_rnn_nn(model, num_hiddens, init_lstm_state, corpus_indices, vocab,
                         device, num_epochs*5, num_steps, lr,
                         clipping_theta, batch_size, prefixes, 2)

七、摘要

• LSTM有三种类型的门：输入门、遗忘门和输出门，控制信息的流动。

• LSTM的隐藏层输出包括隐藏状态和记忆单元。只有隐藏状态被传递到输出层。记忆单元完全是内部的。

• LSTM可以帮助应对由于长距离依赖和短距离不相关数据导致的消失和爆炸性梯度。

• 在许多情况下，LSTM的表现比GRU略好，但由于潜伏状态大小较大，它们的训练和执行成本较高。

• LSTM是典型的潜伏变量自回归模型，具有非简单的状态控制。多年来，人们提出了许多变体，如多层、剩余连接、不同类型的正则化。

• 由于序列的长期依赖性，训练LSTM和其他序列模型的成本相当高。稍后我们会遇到一些替代模型，如在某些情况下可以使用的转化器。

八、练习

1、调整超参数。观察并分析其对运行时间、困惑度和生成的输出的影响。

2、你需要如何改变模型以生成适当的词，而不是字符序列？

3、比较GRU、LSTM和常规RNN在给定隐藏维度下的计算成本。请特别注意训练和推理成本

4、既然候选存储单元使用tanh函数确保值范围在-1和1之间，为什么隐藏状态需要再次使用tanh函数来确保输出值范围在-1和1之间？

5、实现一个LSTM用于时间序列预测而不是字符序列