LSTM输入输出详解，tensorflow.nn.bidirectional_dynamic_rnn()函数的用法

灰太狼 2022-05-18 08:57 245阅读 0赞

### LSTM结构 ###

![这里写图片描述][70]  
参数介绍：  
![这里写图片描述][70 1]  
分步介绍：  
![这里写图片描述][SouthEast]

遗忘门 (forget gates)  
![这里写图片描述][SouthEast 1]  
传入门 (input gates)  
![这里写图片描述][SouthEast 2]  
更新 cell 状态  
![这里写图片描述][SouthEast 3]  
cell 输出  
LSTM 的变种 GRU：  
![这里写图片描述][SouthEast 4]  
GRU

数学原理：  
![这里写图片描述][2db2cba6a0d878e13932fa27ce6f3fb71ad99cf1]

公式参数：  
xt∈Rd  x t ∈ R d : input vector to the LSTM unit  
ft∈Rhft∈Rh  f t ∈ R h f t ∈ R h : forget gate’s activation vector  
it∈Rhit∈Rh  i t ∈ R h i t ∈ R h : input gate’s activation vector  
ot∈Rhot∈Rh  o t ∈ R h o t ∈ R h : output gate’s activation vector  
ht∈Rhht∈Rh  h t ∈ R h h t ∈ R h : output vector of the LSTM unit  
ct∈Rhct∈Rh  c t ∈ R h c t ∈ R h : cell state vector  
W∈Rh×dW∈Rh×d,U∈Rh×hU∈Rh×handb∈Rhb∈Rh  W ∈ R h × d W ∈ R h × d , U ∈ R h × h U ∈ R h × h a n d b ∈ R h b ∈ R h : weight matrices and bias vector parameters which need to be learned during training

### tensorflow.nn.bidirectional\_dynamic\_rnn()函数的用法 ###

def bidirectional_dynamic_rnn( cell_fw, # 前向RNN cell_bw, # 后向RNN inputs, # 输入 sequence_length=None,# 输入序列的实际长度（可选，默认为输入序列的最大长度） initial_state_fw=None, # 前向的初始化状态（可选） initial_state_bw=None, # 后向的初始化状态（可选） dtype=None, # 初始化和输出的数据类型（可选） parallel_iterations=None, swap_memory=False, time_major=False, # 决定了输入输出tensor的格式：如果为true, 向量的形状必须为 `[max_time, batch_size, depth]`. # 如果为false, tensor的形状必须为`[batch_size, max_time, depth]`. scope=None )

返回值：  
元组： `(outputs, output_states)`

其中，

`outputs`为(output\_fw, output\_bw)，是一个包含前向cell输出tensor和后向cell输出tensor组成的元组。假设 time\_major=false, 而且tensor的shape为\[batch\_size, max\_time, depth\]。实验中使用tf.concat(outputs, 2)将其拼接。  
`output_states`为(output\_state\_fw, output\_state\_bw)，包含了前向和后向最后的隐藏状态的组成的元组。  
`output_state_fw`和`output_state_bw`的类型为LSTMStateTuple。  
LSTMStateTuple由（c，h）组成，分别代表memory cell和hidden state。

### LSTM应用到双向RNN中 ###

而cell\_fw和cell\_bw的定义是完全一样的。如果这两个cell选LSTM cell整个结构就是双向`LSTM`了。

# lstm模型正方向传播的RNN
    lstm_fw_cell = tf.nn.rnn_cell.BasicLSTMCell(embedding_size, forget_bias=1.0)
    # 反方向传播的RNN
    lstm_bw_cell = tf.nn.rnn_cell.BasicLSTMCell(embedding_size, forget_bias=1.0)

但是看来看去，输入两个cell都是相同的啊？  
其实在bidirectional\_dynamic\_rnn函数的内部，会把反向传播的cell使用array\_ops.reverse\_sequence的函数将输入的序列逆序排列，使其可以达到反向传播的效果。  
在实现的时候，我们是需要传入两个cell作为参数就可以了：

(outputs, output_states) = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell, lstm_bw_cell, embedded_chars,  dtype=tf.float32)

embedded\_chars为输入的tensor，\[batch\_szie, max\_time, depth\]。batch\_size为模型当中batch的大小，应用在文本中时，max\_time可以为句子的长度（一般以最长的句子为准，短句需要做padding），depth为输入句子词向量的维度。

### 代码示例 ###

import tensorflow as tf
    import numpy as np
    
    X = np.random.randn(2, 10, 8)
    # The second example is of length 6
    X[1, 6:] = 0
    X_lengths = [10, 6]
    
    cell = tf.nn.rnn_cell.LSTMCell(num_units=5, state_is_tuple=True)
    
    outputs, states = tf.nn.bidirectional_dynamic_rnn(
        cell_fw=cell, cell_bw=cell, dtype=tf.float64, sequence_length=X_lengths, inputs=X
    )
    
    output_fw, output_bw = outputs
    states_fw, states_bw = states
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        states_shape = tf.shape(states)
        print(states_shape.eval())
        c, h = states_fw
        o = output_fw
        print('c\n', sess.run(c))
        print('h\n', sess.run(h))
        print('o\n', sess.run(o))

### 输出结果 ###

![这里写图片描述][70 2]

### 讨论 ###

`LSTMStateTuple`, `LSTM state tuple`是tensorflow用来表示state的一种格式定义，tensorflow的state\_size, zero\_state, and output state都是用LSTMStateTuple表示的。LSTMStateTuple包括(c, h) => c 是hidden state，h是output state,如果不清楚可以和上面`LSTM结构`图片对比。

#### c和h长什么样？ ####

代码中以前向LSTM(`states_fw`)为例，输出了的`c`, 和 `h`。

c, h都是`(2, 5)`，2是因为有两个batch input，5是因为cell unit is 5。所以每对于一个batch input，lstm 都给一个`forward state`，forwarding state分成c (hidden state), 和h (output state). 然后分别是unit size的vector。backward state也是一样。

#### Output长什么样 ####

Output也分为forward cell和backward\_cell的，我们就看`forward cell`

output\_fw的size是(2, 10, 5)。所以对于一个batch中的每一个input vector (本例中每一个batch是10 × 8，所以有10个vector)，lstm都输出一个5的vector(5 is unit size)。

然后我们可以发现，`之前state中的h，就是output中的最后一组vector！`第二组h不是0， 是因为sequance\_length参数 (也就是走了6个lstm就结束了)！

所以如果只需要take lstm中的final output，而不在乎中间过程(比如建一个classifier，而不是seq2seq)。直接take state output就可以了。

[70]: /images/20220518/88cc21c5f009462396e4c3ee0ca9cbbf.png
[70 1]: /images/20220518/90b45146b2d040f8946963b10dde3875.png
[SouthEast]: /images/20220518/7cb534f3bf8a4fe599b433f7b4a3b6df.png
[SouthEast 1]: /images/20220518/99e36efbb8254e2c81d33c5ffbf44a3b.png
[SouthEast 2]: /images/20220518/195d6648ca1e4272a51dadda7757b2c1.png
[SouthEast 3]: /images/20220518/60b22e5ce26640608b05f467dea49f77.png
[SouthEast 4]: /images/20220518/94bd2e8fa4024e4bbdfb45ac9d2a74ec.png
[2db2cba6a0d878e13932fa27ce6f3fb71ad99cf1]: https://wikimedia.org/api/rest_v1/media/math/render/svg/2db2cba6a0d878e13932fa27ce6f3fb71ad99cf1
[70 2]: /images/20220518/66e7f318da2f433cb42061e5278c4aa5.png