【深度学习】——深度学习中基本的网络结构(2)

本节主要复习一下深度学习中这些常见的网络结构在tensorflow(1.x)中的使用,便于后续tensorflow的学习。

1. 全连接网络结构

全连接网络就是后层的每一个神经元均与前一层的神经元有关,按照上一节的推导,zl=w*al-1+b,然后再经过激活函数记得到了第l层的神经元al:

【深度学习】——深度学习中基本的网络结构(2)插图

那么在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 + b
z_l = tf.add(tf.matmal(x, w),  b)
# al = sigmoid(z_l)
a_l = tf.nn.sigmoid(z_l)

这样就完成了1个全连接层,其中w,b是参数需要事先进行定义。

2. 卷积神经网络

卷积神经网络在【机器学习】中有一定的介绍,在那边主要使用的keras进行简单的实现,这里结合更多的例子,用tensorflow来进行实现。

首先定义几个输入图片的尺寸:

# shape依次为:batch_size, height, width, channel
inputs = 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_channel
height, width表示filter的大小, channel表示通道数,这个通道数与input的channel是一致的,也就是inputs的第四维,
output_channel为输出的feature map个数,也就是filter的个数
"""
# 第一个filter 大小2*2,只有1个filter
filter1 = tf.Variable(tf.constant([-1.0, 0, 0, -1], shape=[2, 2, 1, 1]))
# 第二个filter 大小2*2,有2个filter
filter2 = tf.Variable(tf.constant([-1.0, 0, 0, -1, -1, 0, 0, -1], shape=[2, 2, 1, 2]))
# 第三个filter 大小2*2,有3个filter
filter3 = 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为2
filter4 = 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为1
filter5 = 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”情况时:

  【深度学习】——深度学习中基本的网络结构(2)插图1

  当padding为“SAME”时,输出大小与卷积核的大小没有关系,只与stride有关:

  【深度学习】——深度学习中基本的网络结构(2)插图2

  use_cuda_on_gpu表示是否在gpu上加速,默认为True。

  那么接下来就根据上面的输入,根据不同的filter进行卷积:

# 输入5*5*1的图片,经过1个2*2的filter,步长为2, 那么输出为1个3*3的feature map
op1 = 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 map
op2 = 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 map
op3 = 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 map
op4 = 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 map
op5 = 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=2
v_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=2
op6 = 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=2
v_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依旧是2
pooling1 = 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依旧为2
pooling2 = 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=4
pooling3 = 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=1
pooling4 = 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

# 同样定义bias
def 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*3
x = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
# 输出占位符,10个类别
y = tf.placeholder(tf.float32, [batch_size, 10])

# 第一个卷积层的卷积核参数,有64个5*5*3的filter
w_conv1 = weight_variable([5, 5, 3, 64])
# 卷积后需要加上一个bias, 卷积后为64个feature map,所以bias维度为64
b_conv1 = bias_variable([64])
# 卷积操作,一般卷积层后会接RELU,输出的尺寸为24/1=24,channel为64
h_conv1 = tf.relu(conv2d(x, w_conv1) + b_conv1)
# 然后是池化操作,池化后尺寸为12*12*64
h_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*64
h_conv2 = tf.relu(conv2d(h_pool1, w_conv2) + b_conv2)
# 第二次池化,池化后尺寸6*6*64
h_pool2, mask2 = max_pool_with_argmax(h_conv2, 2)

# 接下来反池化操作,对h_pool2进行反池化,得到第二次卷积后的结果
t_conv2 = unpool(h_pool2, mask2, 2)
# 然后是反卷积,反卷积后,与第一次池化结果对应
# 反卷积操作中要减掉bias
t_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)
# 再次反卷积,反卷积后即回到初始的x
t_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为10
h_conv3 = tf.nn.relu(conv2d(h_pool2, w) + b_conv3)
# 最后经过一个6*6的avg_pool,输出为1*1,channel为10
h_pool3 = tf.nn.avg_pool(h_conv3, [1, 6, 6, 1], strides=[1, 6, 6, 1], padding="SAME")

# 将h_pool3展开,输入到softmax
h_pool3_flat = tf.reshape(h_pool3, [-1, 10])

# 可以再接几层fc
fc1 = 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的

3. RNN

  RNN中有多种结构,除了基本的basic RNN,还有LSTM、GRU。在使用RNN时,需要预先定义好cell,然后再将cell连接起来,构成RNN网络。

  tensorflow中包含了上面几种cell的定义:

3.1basic RNN

  首先是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)

3.2 LSTM

  然后是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的高级版本版本,除了上面的参数外,还有一些其他的参数:

【深度学习】——深度学习中基本的网络结构(2)插图3

 

 

 

 

 

3.3 GRU

  GRU的定义也是一样的:

tf.contrib.rnn.GRUCell(num_units, input_size=None, activation=tanh)

  basic_gru = tf.contrib.rnn.GRUCell(n_hidden)

3.4 MultiRNN

  上面就是几个基本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])

 3.5 RNN的连接

  上面构建出基本的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的实现方式:

3.5.1 单向的RNN:

 ① 单层静态单向RNN

# 输入x为n_step*n_input,即n_step个时间点,每个时间点的维度为n_input
x = tf.placeholder(tf.float32, [None, n_steps, n_input])

# 先创建一个lstm cell
lstm_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])

# 先创建多层的cells
cells = []
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)
# 多层静态单向RNN
outputs, 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 cell
lstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden)

# 动态单层单向RNN
outputs, 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 cell
lstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden*2)

gru_cell = tf.contrib.rnn.GRUCell(n_hidden)
# 构建多层cell
multi_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell, gru_cell])

# 多层动态单向RNN
outputs, 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, ......]

3.5.2 双向的RNN

  双向的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])
# 对于静态的而言,输入要调整为list
x1 = tf.unstack(x, n_stpes, 1)
# 先创建basic cell,前向和反向
cell_fw = tf.contrib.rnn.BasicLSTMCell(n_hidden)
cell_bw = tf.contrib.rnn.GRUCell(n_hidden)

# 单层静态双向RNN
outputs, _, _ = 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 cell
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))

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))

# 多层动态双向RNN

outputs, _, _ = 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 cell
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_dynamic_rnn([multi_cells_fw], [multi_cells_bw], x, dtype=tf.float32)
......

   以上就是RNN的基本结构的实现过程,下面利用MNIST数据集,使用RNN训练一个模型:

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data

# 读取数据
mnist = input_data.read_data_sets("/data/", ont_hot=True)

# 参数设置
learning_rate = 0.001
traning_iters = 100000
batch_size = 128
display_step = 10

# 网络的参数
# 图片尺寸28*28,当做序列长度为28,每一个时刻的维度为28
n_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 cells
stack_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_cells
multi_cells_fw = rnn.MultiRNNCell(stack_cells_fw)
multi_cells_bw = rnn.MultiRNNCell(stack_cells_bw)

# 创建多层双向动态RNN
outputs, _, _ = rnn.stack_bidirectional_dynamic_rnn([multi_cells_fw], [multi_cells_bw], x, dtype=tf.float32)

outputs = tf.transpose(outputs, [1, 0, 2])

# 输出值后接一个全连接网络,输出为10维,classes
pred = tf.contrib.layers.fully_connected(outputs[-1], n_classes, activation_fn=None)

# 计算loss,采用cross_entropy
loss = 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 

【深度学习】——深度学习中基本的网络结构(2)插图4 

文章来源于互联网:【深度学习】——深度学习中基本的网络结构(2)

THE END
分享
二维码