这次，彻底懂了！

在构建深度神经网络时，尤其是使用Keras等更高级框架构建时，我们常常不了解每一层中到底发生了什么事情。

时序模型确实可以带给我们更多的帮助，但是当需要做一些更复杂或更有趣的事情时，就需要深入研究细节。

在本文中，我将通过PyTorch的示例来详细解释当通过LSTM层传递一批数据时经历了什么。希望这可以帮助你了解该层的机制，并允许让你更加充分利用它们，而无需花费大量时间去盲目调试未知错误，例如：

本文重点是讲解LSTM层发生的事情，对于一些基础知识，例如梯度消失等无法全面概括。如果对这部分知识有疑惑，可以自行查阅文献深入研究一下。

数据

任何LSTM层的输入都是三维张量，如下所示：

t_0到t_6代表“窗口”：这可以是句子的长度，也可以是时间序列中的一个窗口；v_1至v_6代表“特征”：如果是单变量时间序列，则只有v1；如果您使用嵌入，则v_1至v_N代表嵌入，其中N为嵌入尺寸；对于多维时间序列，每个v代表一个特征；上面的图像代表一个“批次”：将值的时间序列重新排列为窗口大小的特征批次；

例如，1000个样本、6个特征：[1000, 6]，如果窗口大小为6，则为[1000, 6, 6]。

如果我们想象一个时间序列，那么这个过程看起来像这样：

这是数据，接下来，沿着网络层继续探索。

实现和探索LSTM

相对于Keras这些更为高级的框架，PyTorch具有更强的灵活性，这里，通过PyTorch实现一个最原始的LSTM，不加入任何嵌入和复杂操作。为了了解LSTM在做什么，我们需要从头到尾“追踪”我们的Tensor。

这意味着了解批处理中每个张量发生的变换，直到最终输出（或预测）为止。

术语

单元（cell）是LSTM单位（请参见下图）。因为Tensorflow使用num_units来指定每个单元中隐藏状态的大小，所以，这里有些混乱。

对于LSTM中的每一层，单元数等于窗口的大小。

使用上面的示例，单元数为6。

第一步是将每个观察结果按时间间隔送入到到我们的单元中。

每个单元都用一个单元状态初始化， 还有一个隐藏状态需要初始化。

然后，每个单元格都传递一个隐藏状态，并将该单元格状态传递到下一个单元格（循环）。

t_n-1的隐藏状态与t_n处的观察状态连接在一起。

每个像元的输出是大小为（1，n_hidden）的张量。

因此，对于每个观察，我们得到大小为（window_size，n_hidden）的输出，对于每个批次，我们得到大小为（batch_size，window_size，n_hidden）的输出。

我们通常采用最后一个单元的输出：

示例

为了更加清晰的认识LSTM，本文用Python代码结合PyTorch框架实现了最原始的LSTM，这样有助于大家的理解。

import torch
from torch import nn
from torch.autograd import Variable


class SimpleLSTM(nn.Module):
  """implements a 'simple' lstm - a single/multilayer uni/bi directional lstm with a single output"""
  def __init__(self, n_features, window_size, 
               output_size, h_size, n_layers=1, 
               bidirectional=False, device=torch.device('cpu')):
    super().__init__()
    self.n_features = n_features
    self.window_size = window_size
    self.output_size = output_size
    self.h_size = h_size
    self.n_layers = n_layers
    self.directions = 2if bidirectional else1
    self.device = device

    # our layer of interest
    self.lstm = nn.LSTM(input_size=n_features, hidden_size=h_size, 
                        num_layers=n_layers, bidirectional=bidirectional, batch_first=True)
    self.hidden = None
    
    self.linear = nn.Linear(self.h_size * self.directions, self.output_size)
    

  def init_hidden(self, batch_size):
    
    hidden_state  = torch.randn(self.n_layers * self.directions,
                            batch_size ,self.h_size).to(self.device)
    cell_state  = torch.randn(self.n_layers * self.directions, 
                           batch_size,self.h_size).to(self.device)
    
    hidden_state = Variable(hidden_state)
    cell_state = Variable(cell_state)

    return (hidden_state, cell_state) 

  def forward(self, input):
    batch_size = list(input.size())[0]
    self.hidden = self.init_hidden(batch_size)
    lstm_output, self.hidden = self.lstm(input, self.hidden)
    last_hidden_states = torch.index_select(lstm_output, 1,  index=torch.LongTensor(([self.window_size-1])))
    predictions = self.linear(last_hidden_states)
    return predictions


model = VanillaLSTM(n_features=23, window_size=6, output_size=1, h_size=256)

data = torch.rand((100,6, 23))

print(model.forward(data).shape)

上述就是利用Python代码重述了一下前面所讲的LSTM实现过程。

结合代码与前面的讲解来进行学习，能够帮助大家更加轻松的认识LSTM的原理。

---

往期精选

太酷了！一款强大的机器学习可视化IDE

太好用！教你几招Python魔法方法的妙用

GitHub万赞！这个神仙资源一定能够让你的Python技能更上一层楼