廉江市 临西县 孟连 南江县 河南省 固原市 福海县 收藏 昭平县 民县 大同县 苍梧县 金华市 翁牛特旗 尉犁县 石首市

米奇妙妙屋_第十四章——循环神经网络(Recurrent Neural Networks)(第一部分)

标签:流浪 信阳市

由于本章过长,分为两个部分,这是第一部分。

这几年提到RNN,一般指Recurrent Neural Networks,至于翻译成循环神经网络还是递归神经网络都可以。wiki上面把Recurrent Neural Networks叫做时间递归神经网络,与之对应的还有一个结构递归神经网络(recursive neural network)。本文讨论的是前者。

RNN是一种可以预测未来(在某种程度上)的神经网络,可以用来分析时间序列数据(比如分析股价,预测买入点和卖出点)。在自动驾驶中,可以预测路线来避免事故。更一般的,它可以任意序列长度作为输入,而不是我们之前模型使用的固定序列长度。例如RNN可以将句子、文档、语音作为输入,进行自动翻译、情感分析、语音转文字。此外,RNN还用于作曲(谷歌Magenta项目作出的the one)、作文、图片自动生成标题。

14.1 周期神经元(Recurrent Neurons)

此前介绍的大部分是前馈神经网络,激活流只有一个方向,从输入层流向输出层。RNN和前馈神经网络很相似,不过也会向后连接。我们来看一个最简单的RNN,只有一个神经元接受输入,只产生一个输出,然后再将输出传递给自己,如图14-1(左侧)。在每一个time step $t$(也叫做一帧),循环神经元接受输入$x_{(t)}$和前一步的输出$y_{(t-1)}$。可以将这一神经元随时间展开,如图14-1(右)。

图14-1 一个循环神经元(左),随时间展开(右)

创建一层循环神经元也很简单,只不过在一个time step,输入和输出都是向量,如图14-2。

图14-2 一层循环神经元(左),随时间展开(右)

每个神经元都有两套权重:一个用于本层输入$x_{(t)}$,一个用于上层输出$y_{(t-1)}$。我们分别记为$w_x$和$w_y$。

一个循环神经元关于一个实例的输出:

egin{align*}
y_{(t)} = phi(x_{(t)}^T cdot w_x + y_{(t-1)}^T cdot w_y + b)
end{align*}

其中,$b$是偏置项,$phi(cdot)$是激活函数,比如ReLU(许多研究者更喜欢使用hyperbolic tangent (tanh)作为RNN的激活函数。例如,可以参考Vu Pham等人的Dropout Improves Recurrent Neural Networks for Handwriting Recognition。不过,基于ReLU的RNN也是可以的,比如Quoc V. Le等人的论文A Simple Way to Initialize Recurrent Networks of Rectified Linear Units。)。

一层循环神经元关于整个mini-batch的输出:

egin{align*}
Y_{(t)} &= phi(X_{(t)}^T cdot W_x + Y_{(t-1)}^T cdot W_y + extbf{b}) \
&= phi([X_{(t)} quad Y_{(t)}] cdot W + extbf{b}) quad mbox{with} quad
W = egin{bmatrix}
W_x \
W_y
end{bmatrix}
end{align*}

  • $Y_{(t)}$是一个$m imes n_{mbox{neurons}}$矩阵,包含该层在time step $t$关于整个mini-batch实例的输出($m$是mini-batch的实例数,$n_{mbox{neurons}}$是神经元数量)。
  • $X_{(t)}$是一个$m imes n_{mbox{inputs}}$矩阵,包含该time step $t$所有实例的输入($n_{mbox{inputs}}$是特征数)。
  • $W_x$是一个$n_{mbox{inputs}} imes n_{mbox{neurons}}$矩阵,包含当前time step输入到输出的连接权重。
  • $W_y$是一个$n_{mbox{neurons}} imes n_{mbox{neurons}}$矩阵,包含上个time step输出到当前time step输出的连接权重。
  • $W$的形状是$(n_{mbox{inputs}} + n_{mbox{neurons}}) imes n_{mbox{neurons}}$
  • $ extbf{b}$是一个大小为$n_{mbox{neurons}}$的向量,包含所有神经元的偏置项。

可以看到,$Y_{(t)}$是关于$X_{(t)}$和$Y_{(t-1)}$的函数,$Y_{(t-1)}$又是关于$X_{(t-1)}$和$Y_{(t-2)}$的函数,等等。这使得$Y_{(t)}$其实是关于$X_{(0)},X_{(1)},cdots ,X_{(t)}$的函数。

14.1.1Memory Cells

由于神经网络在第$t$个time step的输出是一个关于前$t$个time step所有输入的函数,这可以理解为一种形式的记忆(memory)。神经网络中保存前面时刻状态的部分称为memory cell(或者简单称为cell)。一个单独的周期神经元,或者一层周期神经元,就是一个很基础的cell。随后我们会看到更加复杂和强大的cell。

一般一个cell在时刻$t$(姑且把time step称作时刻把,不然太麻烦)的状态,记做$ extbf{h}_{(t)}$(“h”代表“hidden”),这是一个关于当前时刻输入和前一时刻状态的函数:$ extbf{h}_{(t)} = f( extbf{h}_{(t-1)}, extbf{x}_t)$。在$t$时刻的输出,记做$ extbf{y}_{(t)}$,这也是一个关于当前时刻输入和前一时刻状态的函数。在前面讨论的基本cell中,状态和输出是一致的,但在复杂的模型中这是不一致的,如图14-3。

图14-3 一个cell的隐状态可能与它的输出不一致

14.1.2 输入和输出序列

RNN可以一个序列作为输入,再同时输出一个序列(如图14-4左上)。该模型可用于股价预测,输入前$N$天的股价,输出每一天的股价,知道第$N+1$天。每增加一天的输入,就预测下一天的输出。

此外,还可以序列作为输入,忽略除了最后一个之外所有的输出(如图右上)。例如用于情感分析,可以将电影评论作为输入,输出情感分值。

相反的,也可以输入单一的样本,输出一个序列(如图左下)。例如,输入可以是一幅图像,输出是该图像的标题。

最后,右下角的神经网络就是一个翻译系统了。这是序列到向量神经网络(称为encoder)和向量到序列神经网络(称为decoder)的组合。比如,输入可以是一种语言的一句话,encoder将这句话转换为向量表示,decoder再把这个向量表示转换成另一种语言的一句话。这是一个two-step模型,称为Encoder–Decoder,执行翻译任务时,效果比一个序列序列的神经网络好得多。因为原文的最后一个词可能会影响译文的第一个词,所以需要读完全句后再进行翻译。

图14-4 序列到序列(左上),序列到向量(右上),向量到序列(左下),延时的序列到序列(右下)

14.2 基本RNN的TensorFlow实现

首先,我们来实现一个很简单的RNN模型,不使用TensorFlow的任何运算,以便了解底层原理。我们会创建一层有5个训练神经元的RNN(如图14-2),使用tanh激活函数。假设这一RNN有两个时刻,每一时刻的输入是大小为3的向量。下面的代码创建这一RNN,并随时间展开:

n_inputs = 3
n_neurons = 5

X0 = tf.placeholder(tf.float32, [None, n向世界出发_2018年最新新闻网_inputs])
X1 = tf.placeholder(tf.float32, [None, n_inputs])

Wx = tf.Variable(tf.random_normal(shape=[n_inputs, n_neurons],dtype=tf.float32))
Wy = tf.Variable(tf.random_normal(shape=[n_neurons,n_neurons],dtype=tf.float32))
b = tf.Variable(tf.zeros([1, n_neurons], dtype=tf.float32))

Y0 = tf.tanh(tf.matmul(X0, Wx) + b)
Y1 = tf.tanh(tf.matmul(Y0, Wy) + tf.matmul(X1, Wx) + b)

init = tf.global_variables_initializer()

输入训练数据并运行:

import numpy as np

# Mini-batch:         instance 0,instance 1,instance 2,instance 3
X0_batch = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 0, 1]]) # t = 0
X1_batch = np.array([[9, 8, 7], [0, 0, 0], [6, 5, 4], [3, 2, 1]]) # t = 1

with tf.Session() as sess:
    init.run()
    Y0_val, Y1_val = sess.run([Y0, Y1], feed_dict={X0: X0_batch, X1: X1_batch})

这一mini-batch有4个实例,每个实例都是包含两个输入的序列。最后Y0_val和Y1_val包含神经网络在两个时刻关于所有实例的输出:

>>> print(Y0_val) # output at t = 0
[[-0.2964572 0.82874775 -0.34216955 -0.75720584 0.19011548] # instance 0
[-0.12842922 0.99981797 0.84704727 -0.99570125 0.38665548] # instance 1
[ 0.04731077 0.99999976 0.99330056 -0.999933 0.55339795] # instance 2
[ 0.70323634 0.99309105 0.99909431 -0.85363263 0.7472108 ]] # instance 3
>>> print(Y1_val) # output at t = 1
[[ 0.51955646 1. 0.99999022 -0.99984968 -0.24616946] # instance 0
[-0.70553327 -0.11918639 0.48885304 0.08917919 -0.26579669] # instance 1
[-0.32477224 0.99996376 0.99933046 -0.99711186 0.10981458] # instance 2
[-0.43738723 0.91517633 0.97817528 -0.91763324 0.11047263]] # instance 3

下面我们看一下,如何使用TensorFlow的RNN运算来实现相同的模型。

14.2.1 随时间静态展开

static_rnn()函数可以创建一个展开的RNN。以下代码可创建与先前相同的模型:

X0 = tf.placeholder(tf.float32, [None, n_inputs])
X1 = tf.placeholder(tf.float32, [None, n_inputs])

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
output_化物语_2018年最新新闻网seqs, states = tf.contrib.rnn.static_rnn(basic_cell, [X0, X1], dtype=tf.float32)

Y0, Y1 = output_seqs

首先我们创建了输入占位符,然后是BasicRNNCell,可以将其看作cell工厂。static_rnn()函数调用cell工厂的__call__()函数,为每一时刻创建一个cell,并共享权重和偏置项。static_rnn()返回两个对象,第一个是包含每一时刻输出张量的Python list,另一个是整个网络最终的状态。由于我们使用了最基本的cell,最终的状态其实与第二时刻的输出是一致的。

如果有50个时刻,操作50个输入占位符和50个输出张量实在太繁琐了,需要简化这一过程。下面的代码创建同样的模型,但输出占位符的形状是[None, n_steps, n_inputs],第一个维度是mini-batch的尺寸。X_seqs是一个大小为n_steps的Python list,该list每个元素都是形状为[None, n_inputs]的张量,第一维同样是mini-batch尺寸。为了得到X_seqs,我们首先使用transpose()转置函数交换前两个维度,转置之后时刻就位于第一维度了。然后使用unstack()关于第一维度提取张量list。随后的两行与之前一样。最后再将输出转换成一个形状为[None, n_steps, n_neurons]的张量。

X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
X_seqs = tf.unstack(tf.transpose(X, perm=[1, 0, 2]))

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
output_seqs, states = tf.contrib.rnn.static_rnn(basic_cell, X_seqs, dtype=tf.float32)

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

然后输入训练数据,运行这一网络:

X_batch = np.array([
    # t = 0      t = 1
    [[0, 1, 2], [9, 8, 7]], # instance 0
    [[3, 4, 5], [0, 0, 0]], # instance 1
    [[6, 7, 8], [6, 5, 4]], # instance 2
    [[9, 0, 1], [3, 2, 1]], 围棋少年_2018年最新新闻网# instance 3
])
with tf.Session() as sess:
    init.run()
    outputs_val = outputs.eval(feed_dict={X: X_batch})

最终的outputs_val是一个包含所有实例、任一时刻、所有神经元的输出的张量。

然而,这一过程所创建的图仍然是每一时刻包含一个cell。如果有50个时刻,这个图看起来就很丑陋。这就像是写程序而不使用循环(比如Y0=f(0, X0); Y1=f(Y0, X1); Y2=f(Y1, X2); ...;Y50=f(Y49, X50))。图这么大,在反向传播时也很容易造成内存溢出(尤其是运行与GPU内存时),因为需要记录前向传播时每层的所有输出,以便反向传播时计算梯度。

幸运的是,还有更好的解决方案,那就是dynamic_rnn()函数。

14.2.2 随时间动态展开

dynamic_rnn()函数通过while_loop()对cell运算适当地次数。还可以设置swap_memory=True,在反向传播时交换GPU内存和CPU内存来防止OOM错误。更方便的是,它可以接受形状为[None, n_steps, n_inputs])的张量,这就不需要stack,unstack,以及transpose。下面简洁的代码实现了相同的模型:

X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)

14.2.3 处理变长输入序列

前面我们使用的输入序列都是定长的(都是两个时刻),如果输入序列是变长的呢(比如句子)?这样的话,在调用dynamic_rnn()(或者static_rnn())时,就要使用sequence_length参数了。这是一个1D张量,指明了每个实例的序列长度。例如:

seq_length = tf.placeholder(tf.int32, [None])

[...]
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32, sequence_length=seq_length)

假设我们的第二个实例只有一个时刻的输入,表示该实例张量的第二维需要补零,如下所示:

X_batch = np.array([
    # step 0 step 1
    [[0, 1, 2], [9, 8, 7]], # instance 0
   排队摸霍去病雕像_2018年最新新闻网 [[3, 4, 5], [0, 0, 0]], # instance 1 (padded with a zero vector)
    [[6, 7, 8], [6, 5, 4]], # instance 2
    [[9, 0, 1], [3, 2, 1]], # instance 3
])
seq_length_batch = np.array([2, 1, 2, 2])

with tf.Session() as sess:
    init.run()
    outputs_val, states_val = sess.run([outputs, states], feed_dict={X: X_batch, seq_length: seq_length_batch})

14.2.4 处理变长输出

如果输出序列是变长的怎么办呢?如果你预先知道输出序列的长度(比如输出序列与输入序列等长),那就可以像先前那样定义一个类似的sequence_length参数。不幸的是,一般无法预测输出的序列长度。这种情况下,最常见的做法是定义一个end-of-sequence token (EOS token)的特殊输出(这将后面自然语言处理的小节进行讨论)。

14.3 训练模型

训练RNN,技巧就是随时间展开,然后应用常规的反向传播(如图14-5)。这一策略称作随时间反向传播(backpropagation through time,BPTT)。

图14-5 随时间反向传播

和常规的反向传播类似,首先展开神经网络前向传播(如上图虚箭头所示),然后使用损失函数$C(Y_{(t_{min})},Y_{(t_{min} + 1)},cdots,Y_{(t_{max})})$(其中,$t_{min}$、$t_{max}$是第一个和最后一个输出,并且不计算被忽略的输出)对输出进行评估。最后使用梯度更新参数。上图中,损失函数用到了$Y_{(2)}$、$Y_{(3)}$、$Y_{(4)}$三个输出,并没有使用$Y_{(0)}$、$Y_{(1)}$。

14.3.1 训练一个序列分类器

我们来训练一个RNN对MNIST图片进行分类。虽然CNN更适合做图像分类,这里只是使用这个例子来熟悉RNN。可以将MNIST中的每一个图像都看作是28行的序列,每一行又有28个像素点。我们使用150个循环神经元,加上一个全连接层,与输出层连接。最后是softmax层。如图14-6:

图14-6 序列分类器

构建过程是很直接的,并且和第十章的MNIST分类器很相似,只是用RNN的展开替换掉了之前的隐层。与输出层进行全连接的是states张量,只包含最后一个时刻的输出。$y$是目标类别的占位符。

from tensorflow.contrib.layers import fully_connected

n_steps = 28
n_inputs = 28
n_neurons = 150
n_outputs = 10

learning_rate = 0.001

X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
y = tf.placeholder(tf.int32, [None])

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float发帖辱骂城管被拘_2018年最新新闻网32)

logits = fully_connected(states, n_outputs, activation_fn=None)
xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)

loss = tf.reduce_mean(xentropy)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
training_op = optimizer.minimize(loss)
correct = tf.nn.in_top_k(logits, y, 1)
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

init = tf.global_variables_initializer()

然后加载MNIST数据,并将训练数据转换为[batch_size, n_steps, n_inputs]的形状。

from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("/tmp/data/")
X_test = mnist.test.images.reshape((-1, n_steps, n_inputs))
y_test = mnist.test.labels

接着是模型的训练,这与第十章是类似的,只不过要改下训练数据的形状:

n_epochs = 100
batch_size = 150

with tf.Session() as sess:
    init.run()
    for epoch in range(n_epochs):
        for iteration in range(mnist.train.num_examples // batch_size):
            X_batch, y_batch = mnist.train.next_batch(batch_size)
            X_batch = X_batch.reshape((-1, n_steps, n_inputs))
            sess.run(training_op, feed_dict=nba中国赛_2018年最新新闻网{X: X_batch, y: y_batch})
        acc_train = accuracy.eval(feed_dict={X: X_batch, y: y_batch})
        acc_test = accuracy.eval(feed_dict={X: X_test, y: y_test})
        print(epoch, "Train accuracy:", acc_train, "Test accuracy:", acc_test)

14.3.2 训练时序数据

这次我们处理时序数据,比如股价、气温、脑电波等等。每一个训练实例都是从时序中随机选出20个时刻(如图14-7左侧)。目标序列与训练序列是相同的,只不是目标序列始终比训练序列晚一个时刻(如图14-7右侧,最下角的实心篮圈,是$t_0$时刻的输入。紧接着的空心篮圈,是$t_1$时刻的输入同时也是$t_0$时刻的目标值。依此类推)。

图14-7 时序数据(左),从时序中选出的一个实例(右)

首先,我们来创建RNN。它包含100个循环神经元,并展开为20个时刻。每个时刻的输入只有一个特征。目标值也是同样的20个时刻。代码如下:

n_steps = 20
n_inputs = 1
n_neurons = 100
n_outputs = 1

X = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
y = tf.placeholder(tf.float32, [None, n_steps, n_outputs])
cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons, activation=tf.nn.relu)
outputs, states = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)

一般情况下,每一时刻的输入可能不止一个特征。比如,进行股价预测时,可能还会使用专家评级等信息,来提高预测准确性。我们这里是对模型进行了简化。

在这个模型中,每一时刻都会输出一个大小为100的向量。但我们需要在每一时刻的输出是个标量。最简单的解决方案是使用OutputProjectionWrapper,将cell封装起来。OutputProjectionWrapper在每一时刻的输出之上增加一层全连接的线性神经元(比如不使用激活函数),而且不会影响cell状态。所有这些全连接层共享同样的权重的偏置项(可训练),如图14-8:

图14-8 使用输出投影的RNN cells

封装cell很容易,简单改变之前的代码即可:

cell = tf.contrib.rnn.OutputProjectionWrapper(
    tf.contrib.rnn.BasicRNNCell(num_units=n_neurons, activation=tf.nn.relu),
    output_size=n_outputs)

然后就是定义损失函数,创建Adam优化器,等等:

learning_rate = 0.001

loss = tf.reduce_mean(tf.square(outputs - y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
training_op = optimizer.minimize(loss)

init = tf.global_variables_initializer()

接着就可以执行了:

n_iterations = 10000
batch_size = 50

with tf.Session() as sess:
    init.run()
    for iteration in range(n_iterations):
        X_batch, y_batch = [...] # fetch the next training batch
        sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
        if iteration % 100 == 0:
            mse = loss.eval(feed_dict={X: X_batch, y: y_batch})
            print(iteration, "	MSE:", mse)

程序的输出如下:

0   MSE: 379.586
100 MSE: 14.58426
200 MSE: 7.14066
300 MSE: 3.98528
400 MSE: 2.00254
[...]

训练好之后,就可以预测了:

X_new = [...] # New sequences
y_pred = sess.run(outputs, feed_dict={X: X_new})

图14-9显示了迭代训练1000次之后的预测序列:

图14-9 时序预测

虽然OutputProjectionWrapper是一种解决方案,但还有一种更高效的方案:首先将RNN的输出从[batch_size, n_steps, n_neurons]转换成[batch_size * n_steps, n_neurons],然后使用一个全连接层给下恰当的输出个数(在我们的例子中,输出1个标量)。然后再将计算结果从[batch_size * n_steps, n_outputs]转换回[batch_size, n_steps, n_outputs],如图14-10所示:

图14-10 堆叠所有输出,应用投影,最后再展开

为实现这一方案,我们首先将代码还原成基本的cell,不再使用OutputProjectionWrapper:

cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons, activation=tf.nn.relu)
rnn_outputs, states = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)

然后就是改变RNN输出数据的形状,做映射,再改变回原来的形状:

stacked_rnn_outputs = tf.reshape(rnn_outputs, [-1, n_neurons])
stacked_outputs = fully_connected(stacked_rnn_outputs, n_outputs, activation_fn=None)
outputs = tf.reshape(stacked_outputs, [-1, n_steps, n_outputs])

剩下的代码就和之前的一样了。

14.3.3 创造性的RNN

既然我们有了一个可以预测未来的模型,当然也可以用它来产生一些创造性的东西,正如本章开头所提到的。我们只需提供一个包含n_steps个值的种子序列(该种子序列可以全是0),模型就可以预测下一时刻值。将预测出的值在作为输入,又能得到一个预测值,如此循环下去。代码如下:

sequence = [0.] * n_steps
for iteration in range(300):
    X_batch = np.array(sequence[-n_steps:]).reshape(1, n_steps, 1)
    y_pred = sess.run(outputs, feed_dict={X: X_batch})
    sequence.append(y_pred[0, -1, 0])

可以得到一个新的时序,并且与原来的时序有相似之处,如图14-11

图14-11 创造性的序列,左侧种子是0,右侧种子是一个实例

本文较长,剩下的将写在一篇新的博客中。

当前文章:http://uwaog-chulimo-com.diangeneral.cn/fytp3gp7/8b1aa_151390.html

发布时间:2019-04-24 02:36:28

银河娱乐手机版yh163am.com  澳门银河真人在线娱乐  919银河优越会千斤小龙虾翻车 遭过往车辆碾压成  澳门银河官网yh163am.com  世界杯官网  澳门银河www66356com  澳门银河yh7788.bet  银河优越会会员申请  澳门银河娱乐yh163am.com  银河娱乐官网yh163am.com  

用手机访问
下载APP
appicon 下载
扫一扫,手机浏览
code
休闲娱乐
综合热点资讯
单机游戏下载

精彩专栏
游民星空联运游戏