本节主要复习一下深度学习中这些常见的网络结构在tensorflow（1.x）中的使用，便于后续tensorflow的学习。
全连接网络就是后层的每一个神经元均与前一层的神经元有关，按照上一节的推导，zl=w*al-1+b，然后再经过激活函数记得到了第l层的神经元al：
那么在tensorflow中的实现如下：
# w为权重，b为偏置，x为第l-1层的输出，这些均为tensor# 假设x输入[100]，al-1输出[10]，事先定义w和b变量w = tf.Variable(tf.randon_normal([100， 10]))b = tf.Variable(tf.zeros([10]))# z = w*x + bz_l = tf.add(tf.matmal(x, w), b)# al = sigmoid(z_l)a_l = tf.nn.sigmoid(z_l)这样就完成了1个全连接层，其中w，b是参数需要事先进行定义。
卷积神经网络在【机器学习】中有一定的介绍，在那边主要使用的keras进行简单的实现，这里结合更多的例子，用tensorflow来进行实现。
首先定义几个输入图片的尺寸：
# shape依次为：batch_size, height, width, channelinputs = tf.Variable(tf.constant(1.0, shape=[1, 5, 5, 1]))input2 = tf.Variable(tf.constant(1.0, shape=[1, 5, 5, 2]))input3 = tf.Variable(tf.constant(1.0, shape=[1, 4, 4, 1]))然后是filter，有以下几种filter：
"""filter的shape依次为：height, width, channel, output_channelheight, width表示filter的大小, channel表示通道数，这个通道数与input的channel是一致的，也就是inputs的第四维，output_channel为输出的feature map个数，也就是filter的个数"""# 第一个filter 大小2*2，只有1个filterfilter1 = tf.Variable(tf.constant([-1.0, 0, 0, -1], shape=[2, 2, 1, 1]))# 第二个filter 大小2*2，有2个filterfilter2 = tf.Variable(tf.constant([-1.0, 0, 0, -1, -1, 0, 0, -1], shape=[2, 2, 1, 2]))# 第三个filter 大小2*2，有3个filterfilter3 = tf.Variable(tf.constant([-1.0, 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1], shape=[2, 2, 1, 3]))# 第四个filter 大小2*2，有2个filter，输入的channel为2filter4 = tf.Variable(tf.constant([-1.0, 0, 0, -1.0, -1.0, 0, 0, -1, -1.0, 0, 0, -1, -1.0, 0, 0, -1], shape=[2, 2, 2, 2]))# 第五个filter，大小2*2，有1个filter，输入的channel为1filter5 = tf.Variable(tf.constant([-1.0, 0, 0, -1, -1.0, 0, 0, -1], shape=[2, 2, 2, 1]))在tensorflow中卷积层的定义如下：
tf.nn.conv2d(input, filter, strides, padding, use_cuda_on_gpu)??input和filter说过了，strides是在卷积时在每一维上的步长，也就是1个四维的向量，一般在batch_size和output_channel上都是1。
??padding是否填充边缘的元素，只能取“SAME”和“VALID”，“SAME”表示边缘补0，而“VALID”表示不补0，只有当stride为1时，“SAME”才能生成与输入一致的尺寸。
??关于padding不同取值，决定着输出图片尺寸的大小，当为“VALID”情况时：
??
??当padding为“SAME”时，输出大小与卷积核的大小没有关系，只与stride有关：
??
??use_cuda_on_gpu表示是否在gpu上加速，默认为True。
??那么接下来就根据上面的输入，根据不同的filter进行卷积:
# 输入5*5*1的图片，经过1个2*2的filter，步长为2, 那么输出为1个3*3的feature mapop1 = tf.nn.conv2d(inputs, filter1, strides=[1, 2, 2, 1], padding="SAME")# output: shape=(1, 3, 3, 1)# 输入5*5*1的图片，经过2个2*2的filter，步长为2，那么输出为2个3*3的feature mapop2 = tf.nn.conv2d(inputs, filter2, strides=[1, 2, 2, 1], padding="SAME")# output: shape=(1, 3, 3, 2)# 输入依旧5*5*1，经过3个2*2的filter，步长为2，输出则为3个3*3的feature mapop3 = tf.nn.conv2d(inputs, filter3, strides=[1, 2, 2, 1], padding="SAME")# output： shape=(1, 3, 3, 3)# 输入为5*5*1, 但经过filter的channel为2，与输入的维度不一致，会报错op_s = tf.nn.conv2d(inputs, filter4, strides=[1, 2, 2, 1], padding="SAME")# ValueError: Depth of input (1) is not a multiple of input depth of filter (2) for 'Conv2D_2' (op: 'Conv2D') with input shapes: [1,5,5,1], [2,2,2,2].# 输入5*5*2的图片，有2个channel，经过2个2*2的filter，输出则为2个3*3的feature mapop4 = tf.nn.conv2d(input2, filter4, strides=[1, 2, 2, 1], padding="SAME")# output: shape=(1, 3, 3, 2)# 输入5*5*2, 经过1个2*2的有2个channel的filter，输出则为1个3*3的feature mapop5 = tf.nn.conv2d(input2, filter5, strides=[1, 2, 2, 1], padding="SAME")# output: shape=(1, 3, 3, 1)# 输入5*5*1，经过1个2*2的filter，padding=VALID，输出为（5-2+1）/2=2v_op1 = tf.nn.conv2d(inputs, filter1, strides=[1, 2, 2, 1], padding="VALID")# output: shape=(1, 2, 2, 1)# 输入4*4*1，经过1个2*2的filter， padding=SAME，输出为4/2=2op6 = tf.nn.conv2d(input3, filter1, strides=[1, 2, 2, 1], padding="SAME")# output: shape=(1, 2, 2, 1)# 输入4*4*1，经过1个2*2的filter， padding=VALID，输出为(4-2+1)/2=2v_op6 = tf.nn.conv2d(input3, filter1, strides=[1, 2, 2, 1], padding="VALID")# output: shape=(1, 2, 2, 1)??卷积之后一般还有池化，下面是池化的方法：
tf.nn.max_pool(input, ksize, strides, padding, name)
tf.nn.avg_pool(input, ksize, strides, padding, name)
??input是输入，ksize跟卷积中的filter一样，这里需要注意的是，第一维和第四维一般为1，因为一般不在batch和channel上做池化，输出channel一般与输出一致。其它与卷积中的参数一致。
??下面举个例子，输入图片为：
img = tf.constant([[[0.0, 4.0], [0.0, 4.0], [0.0, 4.0], [0.0, 4.0]], [[1.0, 5.0], [1.0, 5.0], [1.0, 5.0], [1.0, 5.0]], [[2.0, 6.0], [2.0, 6.0], [2.0, 6.0], [2.0, 6.0]], [[3.0, 7.0], [3.0, 7.0], [3.0, 7.0], [3.0, 7.0]]])img = tf.reshape(img, [1, 4, 4, 2])# 输入均为4*4*2# filter大小为2*2，步长为2，输出为(4-2+1)/2=2，输出channel依旧是2pooling1 = tf.nn.max_pool(img, [1, 2, 2, 1], [1, 2, 2, 1], padding='VALID')# output: shape=(1, 2, 2, 2)# filter大小为2*2，步长为1，输出为(4-2+1)/1=3，输出channel依旧为2pooling2 = tf.nn.max_pool(img, [1, 2, 2, 1], [1, 1, 1, 1], padding='VALID')# output: shape=(1, 3, 3, 2)# avg_pool跟max_pool类似，filter大小4*4，步长1，"SAME"与卷积核无关，输出为4/1=4pooling3 = tf.nn.avg_pool(img, [1, 4, 4, 1], [1, 1, 1, 1], padding='SAME')# output: shape=(1, 4, 4, 2)# filter4*4，步长为4，"SAME"与卷积核无关，输出为4/4=1pooling4 = tf.nn.avg_pool(img, [1, 4, 4, 1], [1, 4, 4, 1], padding='SAME')# output: shape=(1, 1, 1, 2)?? 此外还有反卷积操作和反池化操作，首先是反卷积，在【机器学习基础】中说过，其实反卷积就是一种卷积，不过是在边缘补0之后再进行卷积，在tensorflow中有函数来实现：
tf.nn.conv2d_transpose(input, filter, output_shape, strides, padding)??input表示输入；
??filter是指在原图在卷积时所使用的filter；
??output_shape反卷积后的尺寸大小，也就是原图经过卷积前的尺寸；
??strides表示原图经过卷积时的strides；
??padding表示原图在卷积时使用的padding
??下面是示例：
# 原图片，并经过卷积img = tf.Variable(tf.constant(1.0, shape=[1, 4, 4, 1]))filter = tf.Variable(tf.constant([1.0, 0, -1, -2], shape=[2, 2, 1, 1]))conv = tf.nn.conv2d(img, filter, strides=[1, 2, 2, 1], padding='VALID')cons = tf.nn.conv2d(img, filter, strides=[1, 2, 2, 1], padding='SAME')# 反卷积过程,所有参数与卷积过程保持一致,输出则为img的尺寸contv = tf.nn.conv2d_transpose(conv, filter, [1, 4, 4, 1], strides=[1, 2, 2, 1], padding="VALID")conts = tf.nn.conv2d_transpose(cons, filter, [1, 4, 4, 1], strides=[1, 2, 2, 1], padding="SAME")??然后接下来是反池化，在【机器学习】基础中，反池化的原理也已经过了，这里就不再赘述。
??这里直说实现，对于反池化的操作，有一点比较麻烦的在池化过程中，我们要知道哪一个元素被选为最大，在反池化时，要将对应的元素还原，其他元素置为0。因此，池化时还需要记录被选中的那一个元素。
??因此，这里需要对池化操作重新写，tensorflow中提供了记录最大值的方法tf.nn.max_pool_with_argmax方法，下面是修改后的池化操作，放在这里后面可以直接用：
# 返回值是池化后的网络以及对应的索引值def max_pool_with_argmax(net, stride): _, mask = tf.nn.max_pool_with_argmax(net, ksize=[1, stride, stride, 1], strides=[1, stride, stride, 1], padding='SAME') mask = tf.stop_gradient(mask) net = tf.nn.max_pool(net, ksize=[1, stride, stride, 1], strides=[1, stride, stride, 1], padding='SAME') return net, mask??有了返回的索引，就可以进行反池化操作了，反池化没有现成的函数，需要自己实现，下面是实现过程，记下便于后续使用：
def unpool(net, mask, stride): ksize = [1, stride, stride, 1] input_shape = net.get_shape().as_list() # 计算new_shape output_shape = (input_shape[0], input_shape[1] * ksize[1], input_shape[2]*ksize[2], input_shape[3]) one_like_mask = tf.ones_like(mask) batch_range = tf.reshape(tf.range(output_shape[0], dtype=tf.int64), shape=[input_shape[0], 1, 1, 1]) b = one_like_mask * batch_range y = mask // (output_shape[2] * output_shape[3]) x = mask % (output_shape[2] * output_shape[3]) // output_shape[3] feature_range = tf.range(output_shape[3], dtype=tf.int64) f = one_like_mask * feature_range update_size = tf.size(net) indices = tf.transpose(tf.reshape(tf.stack([b, y, x, f]), [4, update_size])) values = tf.reshape(net, [update_size]) ret = tf.scatter_nd(indices, values, output_shape) return ret??下面举个例子来进行池化和反池化操作：
img = tf.constant([[[0.0, 4.0], [0.0, 4.0], [0.0, 4.0], [0.0, 4.0]], [[1.0, 5.0], [1.0, 5.0], [1.0, 5.0], [1.0, 5.0]], [[2.0, 6.0], [2.0, 6.0], [2.0, 6.0], [2.0, 6.0]], [[3.0, 7.0], [3.0, 7.0], [3.0, 7.0], [3.0, 7.0]]])img = tf.reshape(img, [1, 4, 4, 2])# 池化操作，stride=2，一般在max_pool时设定步长与stride一致pool, mask = max_pool_with_argmax(img, 2)# 反池化img2 = unpool(pool, mask, 2)with tf.Session() as sess: print('img', img) result = sess.run(img2) print('img2', result) ??可以看到img2和img在尺寸上是一致的，但是数值不太一样，这在前面说过，对与不是最大值的部分填充0。
??有了上面的基本结构，就可以构建一个简单的CNN深度网络了，下面是是一个基本的网络结构示例：
# 先定义初始化参数的函数，不必每次遇到参数定义就初始化一次，直接调用def weight_variable(shape): initial = tf.Variable(tf.truncated_normal(shape, std=0.1)) return initial# 同样定义biasdef bias_variable(shape): initial = tf.Variable(tf.constant(0.1, shape=shape)) return initial# 定义卷积函数，每次直接调用即可def conv2d(x, w): return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding="SAME")# 输入占位符，图片大小24*24*3x = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])# 输出占位符，10个类别y = tf.placeholder(tf.float32, [batch_size, 10])# 第一个卷积层的卷积核参数，有64个5*5*3的filterw_conv1 = weight_variable([5, 5, 3, 64])# 卷积后需要加上一个bias, 卷积后为64个feature map，所以bias维度为64b_conv1 = bias_variable([64])# 卷积操作，一般卷积层后会接RELU,输出的尺寸为24/1=24，channel为64h_conv1 = tf.relu(conv2d(x, w_conv1) + b_conv1)# 然后是池化操作,池化后尺寸为12*12*64h_pool1, mask1 = max_pool_with_argmax(h_conv1, 2)# 第二层卷积的卷积核参数，有64个5*5*64的w_conv2 = weight_varibale([5, 5, 64, 64])b_conv2 = bias_varibale([64])# 第二次卷积操作，卷积后依旧12*12*64h_conv2 = tf.relu(conv2d(h_pool1, w_conv2) + b_conv2)# 第二次池化，池化后尺寸6*6*64h_pool2, mask2 = max_pool_with_argmax(h_conv2, 2)# 接下来反池化操作，对h_pool2进行反池化，得到第二次卷积后的结果t_conv2 = unpool(h_pool2, mask2, 2)# 然后是反卷积，反卷积后，与第一次池化结果对应# 反卷积操作中要减掉biast_pool1 = tf.nn.conv2d_transpose(t_conv2 - b_conv2, w_conv2, h_pool1.shape, [1, 1, 1, 1])# 再次反池化，返回到第一次卷积后的结果t_conv1 = unpool(t_pool1, mask1, 2)# 再次反卷积，反卷积后即回到初始的xt_x = tf.nn.conv2d_transpose(t_conv1 - b_conv1, w_conv1, x.shape, [1, 1, 1, 1])# 紧接着在第二次池化后，在进行一次卷积池化操作w_conv3 = weight_varibale([5, 5, 64, 10])b_conv3 = bias_variable([10])# 第三次卷积后的输出为6*6，channel为10h_conv3 = tf.nn.relu(conv2d(h_pool2, w) + b_conv3)# 最后经过一个6*6的avg_pool,输出为1*1，channel为10h_pool3 = tf.nn.avg_pool(h_conv3, [1, 6, 6, 1], strides=[1, 6, 6, 1], padding="SAME")# 将h_pool3展开，输入到softmaxh_pool3_flat = tf.reshape(h_pool3, [-1, 10])# 可以再接几层fcfc1 = tf.layers.dense(h_pool3_flat, 64, activation=tf.nn.tanh)fc2 = tf.layers.dense(fc1, 64, activation=tf.nn.tanh)y_pred = tf.layers.dense(fc2, 10, activation=tf.nn.softmax)??这样，一个三层的卷积神经网络就好了，在卷积后的三层其实可以再接几层fc层。
??以上就是一个较为完整的网络的实现了。
??这里需要注意：反卷积和反池化的作用主要是为了实现可视化、或者还原原图像分辨率的问题，并没有参与训练。
??另外，关于卷积后需要加bias的问题，当卷积后接Bath Normalization（后面会说）时，是不需要加bias的。
??RNN中有多种结构，除了基本的basic RNN，还有LSTM、GRU。在使用RNN时，需要预先定义好cell，然后再将cell连接起来，构成RNN网络。
??tensorflow中包含了上面几种cell的定义：
??首先是basic RNN，该cell的定义如下：
tf.contrib.rnn.BasicRNNCell(num_units, input_size=None, activation=tanh)??num_units表示隐藏节点的个数，也就是ht的维度，input_size废弃了不再使用。
??定义一个basic RNN cell也比较简单，只需指定好n_hidden的大小即可：
??basic_rnn_cell = tf.contrib.rnn.BasicRNNCell(n_hidden)
??然后是LSTM，也是类似，LSTM定义为：
tf.contrib.rnn.BasicLSTMCell(num_units, forget_bias=1.0, state_in_tuple, activation)??num_units一样表示隐藏层节点的个数，forget_bias是添加到遗忘门的偏置，表示保留多少信息，默认为1。
??state_in_tuple是否将记忆c和h以tuple的形式分开，当为True时输出tuple(c=array(), h=array())，当为False时两个连接起来[batch, 2n]，该参数即将废弃。
??定义一个basic LSTMcell：
??basic_lstm = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
??这样就定义好了一个基本的LSTM结构。
??还有另一个LSTM的高级版本版本，除了上面的参数外，还有一些其他的参数：
??GRU的定义也是一样的：
tf.contrib.rnn.GRUCell(num_units, input_size=None, activation=tanh)??basic_gru = tf.contrib.rnn.GRUCell(n_hidden)
??上面就是几个基本cell的定义，当然，cell不单单是某一种，可以是多种组合起来的多层cell，其定义：
tf.contrib.rnn.MultiRNNCell(cells, state_in_tuple)??cells就是一个cell的列表，该列表为一系列basic cell组成，cells=[cell1, cell2]就表示有两层数据经过cell1后还要经过cell2.
??state_in_tuple于basic rnn中类似，将记忆cell与隐藏状态输出h组成一个tuple。
??注意：在使用MultiCell时，cells不能直接用[cell]×n的写法，如果不使用作用域会报错，而是要用append的写法。
??创建一个多层的cell：
cell1 = tf.contrib.rnn.BasicLSTMCell(n_hidden)cell2 = tf.contrib.rnn.GRUCell(n_hidden)#如果两个cell的n_hidden,则输出以最后一个节点为准multi_rnn = tf.contrib.rnn.MultiRNNCell([cell1, cell2])??上面构建出基本的RNN cell时只是某一个时刻的状态，接下来还要把Cell连接起来，才能构成完整的RNN网络。
??RNN的连接方式可以分为静态、动态，单向RNN和双向RNN，再结合上面的单层的cell和多层的cell，那么RNN各种条件自由组合，可以有8中不同的连接。
??这里所谓的静态和动态，是指在创建RNN时，RNN预先创建好的结构，这时需要输入的长度要与该结构保持一致；
??因此静态的因为预先创建好，会花费较多的时间和占用空间，但其优点是可以查看任一时刻的输出，便于调试；
??而动态则是指比较灵活地根据输入去创建cell，通过循环来创建的。
??因此动态的创建快，节省内存，便于不同长度的输入的批处理，但缺点是只能查看序列最终状态，不方便调试。
??静态的创建方式：
??tf.contrib.rnn.static_rnn(cells, input, initial_state=None, sequence_length=None, scope=None)
??cells为前面说的cell；
??input为输入；
??initial_state初始化状态参数，一般初始化为0时，不需刻意指定，要是想要初始化指定的值用initial_state=LSTMStateTuple(c_state, h_state)
??sequence_lenght一般不需要指定，会根据输入自动识别；
??scope：命名空间。
??动态的创建方式：
??tf.contrib.rnn.dynamic_rnn(cells, input, initial_state=None, sequence_length=None, time_major, scope=None)
??参数基本与静态的一致，这里多了一个time_major，默认为False时，input_shape=[batch_size, max_time, .....], 当为True时，input_shape=[max_time, batch_size, ....]
??接下来就是各种RNN的实现方式：
??① 单层静态单向RNN
# 输入x为n_step*n_input,即n_step个时间点，每个时间点的维度为n_inputx = tf.placeholder(tf.float32, [None, n_steps, n_input])# 先创建一个lstm celllstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden)# 静态单层RNN# 需要先转换x的形状为预设形状x1 = tf.unstack(x, n_steps, 1)outputs, states = tf.contrib.rnn.static_rnn(lstm_cell, x1, dtype=tf.float32)# outputs包括结果和cell的状态，只需关注结果，最后一维才是结果pred = tf.contrib.layers.fully_connected(couputs[-1], 10, activation_fn=None)??②多层静态单向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])# 先创建多层的cellscells = []for i in range(3): cells.append(tf.contrib.rnn.BasicLSTMCell(n_hidden)) multi_cell = tf.contrib.rnn.MultiRNN(cells)x1 = tf.unstack(x, n_steps, 1)# 多层静态单向RNNoutputs, states = tf.contrib.rnn.static_rnn(multi_cell, x1, dtype=tf.float32)pred = tf.contrib.layers.fully_connected(outputs[-1], 10, activation_fn=None)??③单层动态单向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])# 先创建basic celllstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden)# 动态单层单向RNNoutputs, state = tf.contrib.rnn.dynamic_rnn(lstm_cell, x, dtype=tf.float32)outputs = tf.transpose(outputs, [1, 0, 2])pred = tf.contrib.layers.fully_connected(outputs[-1], 10, activation_fn=None)??④多层动态单向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])# basic celllstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden*2)gru_cell = tf.contrib.rnn.GRUCell(n_hidden)# 构建多层cellmulti_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell, gru_cell])# 多层动态单向RNNoutputs, state = tf.contrib.rnn.dynamic_rnn(multi_cells, x, dtype=tf.float32)outputs = tf.transpose(outputs, [1, 0, 2])pred = tf.contrib.layers.fully_connected(outputs[-1], 10, activation_fn=None)??从上面的代码可以看到，静态和动态的区别再输入和输出的格式转化，主要有两点：
??1、静态的输入需要将输入转换成list的形式，而动态网络不需要转换。这是因为静态是预先设定好的，必须按照设定的输入；
??2、动态的输出需要进行转置操作，而静态的则不需要。这是因为动态网络输出形式为[batch_size, max_time, ...]，
??? 转置[1, 0, 2]是将第0维max_time放在后面，将batch_size放在第1维，这样转换后变为[max_time, batch_size,.....], 取最后一维时就是最后一个时间点的数据[batch_size, ......]
??双向的RNN在单层和多层之间的定义还是有所差别的，对于单层的CELL的静态RNN定义：
??tf.contrib.rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs)
??对于单层的动态RNN定义如下：
??tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs)
??而对于多层的静态RNN定义：
??tf.contrib.rnn.stack_bidirectional_rnn(cells_fw, cells_bw, inputs)
??对于多层动态的RNN定义：
??tf.contrib.rnn.stack_bidirectional_dynamic_rnn(cells_fw, cells_bw, inputs)
??从上面的四个定义可以看出：
??无论是单层还是多层，均需一个前向的cell和一个反向的cell，且前向的cell和反向的cell的结构必须保持一致；??
??对于单层的定义没有“stack”，多层的需要带“stack”，其中单层动态的来自于tf.nn模块；
??而对于多层的cells可以接受列表的形式，也可以接受Multi形式的cell，后面举例说明。
??① 单层静态双向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])# 对于静态的而言，输入要调整为listx1 = tf.unstack(x, n_stpes, 1)# 先创建basic cell，前向和反向cell_fw = tf.contrib.rnn.BasicLSTMCell(n_hidden)cell_bw = tf.contrib.rnn.GRUCell(n_hidden)# 单层静态双向RNNoutputs, _, _ = tf.contrib.rnn.static_bidirectional_rnn(cell_fw, cell_bw, x1)pred = tf.contrib.layers.fully_connected(outputs[-1], 10, activation_fn=None)??②单层动态双向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])cell_fw = tf.contrib.rnn.BasicLSTMCell(n_hidden)cell_bw = tf.contrib.rnn.GRUCell(n_hidden)outputs, _, _ = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, x, dtype=tf.float32)# 动态rnn的输出需要进行转化为[max_time, batch_size, ....]outputs = tf.transpose(outputs, [1, 0, 2])pred = tf.contrin.layers.fully_connected(outputs[-1], 10, activation_fn=None)??③多层静态双向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])x1 = tf.unstack(x, n_steps, 1)cell_fw = tf.contrib.rnn.BasicLSTMCell(n_hidden)cell_bw = tf.contrib.rnn.GRUCell(n_hidden)# 创建多层静态双向RNN，多层的只需将cell放入列表即可，但必须保证前向与后向结构一致outputs, _, _ = tf.contrib.rnn.stack_bidirectional_rnn([cell_fw], [cell_bw], x1, dtype=tf.float32)pred = tf.contrib.layers.fully_connected(outputs[-1], 10, activation_fn=None)# 多层的也接受multi cellstack_cells_fw = []stack_cells_bw = []for i in range(3): stack_cells_fw.append(tf.contrib.rnn.BasicLSTMCell(n_hidden)) stack_cells_bw.append(tf.contrib.rnn.BasicLSTMCell(n_hidden)) multi_cells_fw = tf.contrib.rnn.MultiRNNCell(stack_cells_fw)multi_cells_bw = tf.contrib.rnn.MultiRNNCell(stack_cells_bw)outputs, _, _ = tf.contrib.rnn.stack_bidirectional_rnn([multi_cells_fw], [multi_cells_bw], x1, dtype=tf.float32)......?? ④多层动态双向RNN
x = tf.placeholder(tf.float32, [None, n_steps, n_input])stack_cells_fw = []stack_cells_bw = []for i in range(3): stack_cells_fw.append(tf.contrib.rnn.BasicLSTMCell(n_hidden)) stack_cells_bw.append(tf.contrib.rnn.BasicLSTMCell(n_hidden)) # 多层动态双向RNNoutputs, _, _ = tf.contrib.rnn.stack_bidirectional_dynamic_rnn(stack_cells_fw, stack_cells_bw, x, dtype=tf.float32)outputs = tf.transpose(outputs, [1, 0, 2])pred = tf.contrib.layers.fully_connected(outputs[-1], 10, activation_fn=None)# 也接受Multi cellmulti_cells_fw = tf.contrib.rnn.MultiRNNCell(stack_cells_fw)multi_cells_bw = tf.contrib.rnn.MultiRNNCell(stack_cells_bw)outputs, _, _ = tf.contrib.rnn.stack_bidirectional_dynamic_rnn([multi_cells_fw], [multi_cells_bw], x, dtype=tf.float32)......??以上就是RNN的基本结构的实现过程，下面利用MNIST数据集，使用RNN训练一个模型：
import tensorflow as tffrom tensorflow.contrib import rnnfrom tensorflow.examples.tutorials.mnist import input_data# 读取数据mnist = input_data.read_data_sets("/data/", ont_hot=True)# 参数设置learning_rate = 0.001traning_iters = 100000batch_size = 128display_step = 10# 网络的参数# 图片尺寸28*28，当做序列长度为28，每一个时刻的维度为28n_inputs = 28 # 每一个序列的维度n_steps = 28 # 序列长度n_hidden = 128 # 隐藏层的输出维度n_classes = 10 # 0~9 10个类别# 初始化图tf.reset_default_graph()# 输入、输出的占位符x = tf.placeholder("float", [None, n_steps, n_input])y = tf.placeholder("float", [None, n_classes])# 这里采用多层双向动态RNN# 定义前向、后向basic cellsstack_cells_fw = []stack_cells_bw = []for i in range(3): stack_cells_fw.append(rnn.BasicLSTMCell(n_hidden)) stack_cells_bw.append(rnn.GURCell(n_hidden)) # 转为multi_cellsmulti_cells_fw = rnn.MultiRNNCell(stack_cells_fw)multi_cells_bw = rnn.MultiRNNCell(stack_cells_bw)# 创建多层双向动态RNNoutputs, _, _ = rnn.stack_bidirectional_dynamic_rnn([multi_cells_fw], [multi_cells_bw], x, dtype=tf.float32)outputs = tf.transpose(outputs, [1, 0, 2])# 输出值后接一个全连接网络，输出为10维，classespred = tf.contrib.layers.fully_connected(outputs[-1], n_classes, activation_fn=None)# 计算loss,采用cross_entropyloss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))# 梯度下降optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)# 估计正确率correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))accuracy = tf.reduce_mean(tf.cast(corrected_pred, tf.float32))# 启动session开始训练with tf.Session() as sess: # 初始化 sess.run(tf.global_variables_initializer()) step = 1 while step * batch_size < training_iters: # 批数据 batch_x, batch_y = mnist.train.next_batch(batch_size) # 将batch_x 转成x的形状 batch_x = batch_x.reshape([batch_size, n_steps, n_input]) 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}) # 计算损失 cost = sess.run(loss, feed_dict={x: batch_x, y: batch_y}) print('Iter' + str(step * batch_size) + ', Mini-batch loss= ', + '{:.6f}'.format(cost) + ', Training Accuracy=' + '{:.5f}'.format(acc)) step += 1 print('Finished') # 计算在测试集上的准确率 test_len = 128 test_data = mnist.test.images[:test_len].reshape([-1, n_steps, n_input]) test_labels = mnist.test.labels[:test_len] print('Testing Accuracy：', sess.run(acc, feed_dict={x: test_data, y: test_labels}))