tf.nn.dynamic_rnn的输出outputs和state含义

 代码解释：https://blog.csdn.net/u010960155/article/details/81707498

lsmt解释：https://blog.csdn.net/demons__/article/details/79208268

代码直接可用的，不懂的看注释，最好先看 LSTM 的结构解释

import tensorflow as tf
import numpy as np
import math

def dynamic_rnn(rnn_type='lstm'):
    # 创建输入数据,3代表batch size,6代表输入序列的最大步长(max time),8代表每个序列的维度
    X = np.random.randn(3, 6, 4)

    # 第二个输入的实际长度为4
    X[1, 4:] = 0

    # 记录三个输入的实际步长
    X_lengths = [6, 4, 6]

    rnn_hidden_size = 5
    if rnn_type == 'lstm':
        cell = tf.contrib.rnn.BasicLSTMCell(num_units=rnn_hidden_size, state_is_tuple=True)
    else:
        cell = tf.contrib.rnn.GRUCell(num_units=rnn_hidden_size)

    outputs, last_states = tf.nn.dynamic_rnn(
        cell=cell,
        dtype=tf.float64,
        sequence_length=X_lengths,
        inputs=X)

    with tf.Session() as session:
        session.run(tf.global_variables_initializer())
        o1, s1 = session.run([outputs, last_states])
        print(np.shape(o1))
        print(o1)
        print(np.shape(s1))
        print(s1)
# https://blog.csdn.net/u010960155/article/details/81707498



# 输入层 大小 加上 输出层的大小，然后开方
#  embeding_inputs： shape=(100, 50, 16)
embeding_inputs_x = np.random.randn(3, 6, 4)
embeding_inputs = tf.placeholder(tf.float32,shape=[3, 6, 4])
num_embedding_size = 4
num_timesteps = 6   # 在一个sentence中 有 50 个词语
num_lstm_layers = 2  # 和上句的len 是一致的
num_lstm_nodes = [5, 5]  # 每一层的size是多少
# 有 两层 神经单元，每一层都是 32 个 神经单元
scale = 1.0 / math.sqrt(num_embedding_size + num_lstm_nodes[-1]) / 3.0
# xavier初始化方法，均匀分布在【-a,+a】
# a = -根号 6/(n_k + n_k+1)
lstm_init = tf.random_uniform_initializer(-scale, scale)

with tf.variable_scope('lstm_nn', initializer = lstm_init):
    cells = [] # 保存两个lstm层
    # 循环这两层 lstm
    for i in range(num_lstm_layers):
        # BasicLSTMCell类是最基本的LSTM循环神经网络单元。
        # 输入参数和BasicRNNCell差不多， 设置一层 的 lstm 神经元

        cell = tf.contrib.rnn.BasicLSTMCell(
            num_lstm_nodes[i], # 每层的 节点个数
            state_is_tuple = True # 中间状态是否是一个元组
        )
        # cell = tf.contrib.rnn.DropoutWrapper( #　进行　dropout
        #     cell,
        #     output_keep_prob = 0.5 # dropout 的 比例
        # )
        cells.append(cell)

    cell = tf.contrib.rnn.MultiRNNCell(cells)
    # 该方法的作用是：将两层的lstm 连到一起，比如：上层的输出是下层的输入
    # 此时的cell，已经是一个多层的lstm，但是可以当做单层的来操作，比较简单

    # 保存中间的一个隐含状态，隐含状态在初始化的时候初始化为0，也就是零矩阵
    initial_state = cell.zero_state(3,  tf.float32)

    #　rnn_outputs: [batch_size, num_timesteps, lstm_outputs[-1](最后一层的输出)]
    # _ 代表的是隐含状态
    rnn_outputs, rnn_state  = tf.nn.dynamic_rnn(
        cell, embeding_inputs, initial_state = initial_state  #  embeding_inputs： shape=(100, 50, 16)
    ) # 现在的rnn_outputs 代表了每一步的输出

    # 获得最后一步的输出，也就是说，最后一个step的最后一层的输出
    last = rnn_outputs[:, -1, :]
    # print(last) Tensor("lstm_nn/strided_slice:0", shape=(100, 32), dtype=float32)
# tf.train.AdamOptimizer( 0.01).apply_gradients()
with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    o1, s1 = session.run([rnn_outputs, rnn_state], feed_dict={embeding_inputs:embeding_inputs_x})
    print(np.shape(o1))
    print(o1)
    print(np.shape(s1))
    print(s1)

if __name__ == '__main__':
    dynamic_rnn(rnn_type='lstm')