LSTM

class LSTM(*args, **kwargs)[源代码]

将多层 LSTM 应用于输入序列。

对于输入序列中的每个元素,每层都计算以下函数:

\[\begin{split}\begin{array}{ll} \\ i_t = \sigma(W_{ii} x_t + b_{ii} + W_{hi} h_{t-1} + b_{hi}) \\ f_t = \sigma(W_{if} x_t + b_{if} + W_{hf} h_{t-1} + b_{hf}) \\ g_t = \tanh(W_{ig} x_t + b_{ig} + W_{hg} h_{t-1} + b_{hg}) \\ o_t = \sigma(W_{io} x_t + b_{io} + W_{ho} h_{t-1} + b_{ho}) \\ c_t = f_t \odot c_{t-1} + i_t \odot g_t \\ h_t = o_t \odot \tanh(c_t) \\ \end{array}\end{split}\]

其中 \(h_t\) 是时间 t 的 hidden state, \(c_t\) 是时间 t 的 cell state, \(x_t\) 是时间 t 的输入, :math: h_{t-1} 是时间 t-1 的层的 hidden state 或时间 0 的初始 hidden state, \(i_t\), \(f_t\), \(g_t\), \(o_t\) 分别是输入、遗忘、单元和输出门。 \(\sigma\) 是sigmoid函数, \(\odot\) 是 Hadamard 积。

在多层LSTM中, \(l\) 层(\(l >= 2\))的输入 \(x^{(l)}_t\) 是前一层的 hidden state \(h^{(l-1)}_t\) 乘以 dropout \(delta^{(l-1)}_t\),其中每个 \(delta^{(l-1)}_t\) 是一个伯努利随机变量,其概率 dropout\(0\).

如果指定 proj_size > 0,将使用带投影的LSTM。这将以下列方式改变LSTM单元。首先, \(h_t\) 的维度将从 hidden_size 改为 ``proj_size``( \(W_{hi}\)。请注意,这样做的结果是,LSTM网络的输出也将是不同的形状。所有变量的确切维度见下面的输入/输出部分。你可以在 https://arxiv.org/abs/1402.1128 中找到更多细节。

参数
  • input_size – 输入 `x ` 中的预期特征的数量

  • hidden_size – Hidden state h 中特征的数量

  • num_layers – Recurrent 层的数量。例如,设置 num_layers=2 意味着将两个LSTM堆叠在一起,形成一个 stacked LSTM,第二个LSTM接收第一个LSTM的输出并计算最终结果。默认值:1

  • bias – 如果 False,那么该层不使用偏置权重 b_ihb_hh。默认值: True

  • batch_first – 如果 True,那么输入和输出 tesnor 被提供为 (batch, seq, feature),而不是 (seq, batch, feature)。注意,这不适用于 hidden state 或 cell state. 详见下面的输入/输出部分。 默认值: False

  • dropout – 如果非零,在每个LSTM层的输出上引入一个 dropout 层,除了最后一层,dropout 概率等于 dropout。默认值:0

  • bidirectional – 如果是 True,则成为一个双向LSTM。默认值: False

  • proj_size – 如果 > 0,将为LSTM设置相应大小的投影。默认值:0

Inputs: input, (h_0, c_0)
  • input:当 batch_first=False 时,形状为 \((L, N, H_{in})\) 的tensor;当 batch_first=True 时,形状为:math:(N, L, H_{in}) 的tensor,该tensor包含输入序列的特征。 输入也可以是一个打包的可变长度序列。详见 torch.nn.utils.rnn.pack_padded_sequencetorch.nn.utils.rnn.pack_sequence.

  • h_0:包含 batch 中每个元素的初始 hidden state 的形状为 \((D *\text{num\_layers}, N, H_{out})\) 的 tensor. 如果没有提供(h_0, c_0),则默认为零。

  • c_0:包含 batch 中每个元素的初始 cell state 的形状为 \((D *\text{num\_layers}, N, H_{cell})\) 的 tensor. 如果没有提供(h_0, c_0),则默认为零。

其中:

\[\begin{split}\begin{aligned} N ={} & \text{batch size} \\ L ={} & \text{sequence length} \\ D ={} & 2 \text{ if bidirectional=True otherwise } 1 \\ H_{in} ={} & \text{input\_size} \\ H_{cell} ={} & \text{hidden\_size} \\ H_{out} ={} & \text{proj\_size if } \text{proj\_size}>0 \text{ otherwise hidden\_size} \\ \end{aligned}\end{split}\]
Outputs: output, (h_n, c_n)
  • output:当 batch_first=False 时,形状为 \((L, N, D * H_{out})\) 的tensor;当 batch_first=True 时,形状为 \((N, L, D * H_{out})\) 的tensor,该tensor包含LSTM最后一层的关于每个 t 的输出特征 (h_t)。如果一个 torch.nn.utils.rnn.PackedSequence 被作为输入,输出也将是一个打包序列。

  • h_n:形状为 \((D *\text{num\_layers}, N, H_{out})\),包含 batch 中每个元素的最终 hidden state 的 tensor.

  • c_n:形状为 \((D *\text{num\_layers}, N, H_{cell})\),包含 batch 中每个元素的最终 cell state 的 tensor.

实际案例

import numpy as np
import megengine as mge
import megengine.module as M

m = M.LSTM(10, 20, 2, batch_first=False, bidirectional=True, bias=True)
inp = mge.tensor(np.random.randn(6, 30, 10), dtype=np.float32)
hx = mge.tensor(np.random.randn(4, 30, 20), dtype=np.float32)
cx = mge.tensor(np.random.randn(4, 30, 20), dtype=np.float32)
out, (hn, cn) = m(inp,(hx,cx))
print(out.numpy().shape)

输出:

(6, 30, 40)