RNN静态与动态

静态、多层RNN：

import numpy as np

import tensorflow as tf

# 导入 MINST 数据集

from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("/data/", one_hot=True)

#网络模型参数

n_input = 28 # MNIST data 输入 (img shape: 28*28)

n_steps = 28 # timesteps

n_hidden = 128 # hidden layer num of features

n_classes = 10  # MNIST 列别 (0-9 ，一共10类)

#训练参数

batch_size = 128

learning_rate = 0.001

training_iters = 10000

display_step = 10

# tf Graph input

x = tf.placeholder("float", [None, n_steps, n_input])

y = tf.placeholder("float", [None, n_classes])

#构建网络

stacked_rnn = []

for _ in range(3):

    stacked_rnn.append(tf.contrib.rnn.LSTMCell(n_hidden))

mcell = tf.contrib.rnn.MultiRNNCell(stacked_rnn)

x1=tf.unstack(x,n_steps,1)#在axis=1进行解包分解。

outputs, states = tf.contrib.rnn.static_rnn(mcell, x1, dtype=tf.float32)#inputs must be a sequence



#最后一层全连接 outputs[-1]

pred = tf.contrib.layers.fully_connected(outputs[-1],n_classes,activation_fn = None)

# Define loss and optimizer

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# Evaluate model

correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))

accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# 启动session

with tf.Session() as sess:

    sess.run(tf.global_variables_initializer())

    step = 1

    # Keep training until reach max iterations

    while step * batch_size < training_iters:

        batch_x, batch_y = mnist.train.next_batch(batch_size)

        # Reshape data to get 28 seq of 28 elements

        batch_x = batch_x.reshape((batch_size, n_steps, n_input))

        # Run optimization op (backprop)

        sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})

        if step % display_step == 0:

            # 计算批次数据的准确率

            acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})

            # Calculate batch loss

            loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})

            print ("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \

                  "{:.6f}".format(loss) + ", Training Accuracy= " + \

                  "{:.5f}".format(acc))

        step += 1

    print (" Finished!")



    # 计算准确率 for 128 mnist test images

    test_len = 100

    test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))

    test_label = mnist.test.labels[:test_len]

    print ("Testing Accuracy:", sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

在学习RNN这一章的时候，遇到static_rnn中输入数据 x 的格式：

[None, n_steps, n_input] 进行变换→ x1=tf.unstack(x,n_steps,1)

之后再传入：outputs, states = tf.contrib.rnn.static_rnn(mcell, x1, dtype=tf.float32)

很难理解，为什么要这样做，数据又进行了怎样的变换。

以下，为stack和unstack的详细举例：

tf.stack(values, axis=0, name=’stack’)
以指定的轴axis，将一个维度为R的张量数组转变成一个维度为R+1的张量。即将一组张量以指定的轴，提高一个维度。

假设要转变的张量数组values的长度为N,其中的每个张量的形状为(A, B, C)。
如果轴axis=0，则转变后的张量的形状为(N, A, B, C)。
如果轴axis=1，则转变后的张量的形状为(A, N, B, C)。
如果轴axis=2，则转变后的张量的形状为(A, B, N, C)。其它情况依次类推。

举例如下：
‘x’ is [1, 4]，形状是(2)，维度为1
‘y’ is [2, 5]，形状是(2)，维度为1
‘z’ is [3, 6]，形状是(2)，维度为1
stack([x, y, z]) => [[1, 4], [2, 5], [3, 6]] # axis的值默认为0。输出的形状为(3, 2)
stack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]] # axis的值为1。输出的形状为(2, 3)

‘x’ is [[1,1,1,1],[2,2,2,2],[3,3,3,3]]，形状是(3,4)，维度为2
‘y’ is [[4,4,4,4],[5,5,5,5],[6,6,6,6]]，形状是(3,4)，维度为2
stack([x,y]) => [[[1,1,1,1],[2,2,2,2],[3,3,3,3]], [[4,4,4,4],[5,5,5,5],[6,6,6,6]]] # axis的值默认为0。输出的形状为(2, 3, 4)
stack([x,y],axis=1) => [[[1,1,1,1],[4,4,4,4]],[[2,2,2,2],[5,5,5,5]],[[3,3,3,3],[6,6,6,6]]] # axis的值为1。输出的形状为(3, 2, 4)
stack([x,y],axis=2) => [[[1,4],[1,4],[1,4],[1,4]],[[2,5],[2,5],[2,5],[2,5]],[[3,6],[3,6],[3,6],[3,6]]]# axis的值为2。输出的形状为(3, 4, 2)

axis可这样理解：stack就是要将一组相同形状的张量提高一个维度。axis就是这些张量里，将axis指定的维度用所有这些张量数组代替。如axis=2，表示指定在第2个维度，原来的元素用整个张量数组里的元素代替，即从(A, B, C)转变为(A, B, N, C)

参数:
values: 一个有相同形状与数据类型的张量数组。
axis: 以轴axis为中心来转变的整数。默认是第一个维度即axis=0。支持负数。取值范围为[-(R+1), R+1)
name: 这个操作的名字（可选）
返回:被提高一个维度后的张量
异常: ValueError: 如果轴axis超出范围[-(R+1), R+1).

tf.unstack()

tf.unstack(value, num=None, axis=0, name=’unstack’)
以指定的轴axis，将一个维度为R的张量数组转变成一个维度为R-1的张量。即将一组张量以指定的轴，减少一个维度。正好和stack()相反。

将张量value分割成num个张量数组。如果num没有指定，则是根据张量value的形状来指定。如果value.shape[axis]不存在，则抛出ValueError的异常。

假如一个张量的形状是(A, B, C, D)。
如果axis == 0，则输出的张量是value[i, :, :, :],i取值为[0,A)，每个输出的张量的形状为(B,C,D)。
如果axis == 1，则输出的张量是value[:, i, :, :],i取值为[0,B)，每个输出的张量的形状为(A,C,D)。
如果axis == 2，则输出的张量是value[:, :, i, :],i取值为[0,C)，每个输出的张量的形状为(A,B,D)。依次类推。

举例如下：
‘x’ is [[1,1,1,1],[2,2,2,2],[3,3,3,3]] # 形状是(3,4)，维度为2
unstack(x,axis=0) =>以指定的维度0为轴，转变成3个形状为(4)张量[1,1,1,1],[2,2,2,2],[3,3,3,3]
unstack(x,axis=1) =>以指定的维度1为轴，转变成4个形状为(3)张量[1,2,3],[1,2,3],[1,2,4],[1,2,3]

axis可这样理解：unstack就是要将一个张量降低为低一个维度的张量数组。axis就是将axis指定的维度，用所有这个张量里同维度的数据代替。

参数:
value: 一个将要被降维的维度大于0的张量。
num: 整数。指定的维度axis的长度。如果设置为None(默认值),将自动求值。
axis: 整数.以轴axis指定的维度来转变默认是第一个维度即axis=0。支持负数。取值范围为[-R, R)
name: 这个操作的名字（可选）
返回:
从张量value降维后的张量数组。
异常:
ValueError: 如果num没有指定并且无法求出来。
ValueError: 如果axis超出范围 [-R, R)。

经过下面的例子理解后，上面的1对应axis=1, nsteps对应函数中的num参数，表示axis=1的长度。该操作将数据 x 按照序列数目切开。我们传入的 x 是个3维tensor，将其按照序列数切开，得到了n_steps个二维的tensor, [batchsize, n_input]