教你从零开始在 TensorFlow 上搭建 RNN(完整代码)!

RNN 是什么?

递归神经网络,或者说 RNN,在数据能被按次序处理、数据点的不同排列亦会产生影响时就可以使用它。更重要的是,该次序可以是任意长度。

最直接的例子大概是一组数字的时间序列,根据此前的数值来预测接下来的数值。每个时间步(time-step)上,RNN 的输入是当前数值以及一个静态矢量,后者用来表示神经网络在此前的不同时间步所 “看到” 的东西。该静态矢量是 RNN 的编码存储,初始值设为零。

RNN 处理系列数据的过程图解

设置

我们会创建一个简单的 Echo-RNN,它能记住输入数据并在几个时间步之后与之呼应。首先要设置一些我们需要的限制,它们的意义下面会解释。

  1. from __future__ import print_function, division
  2. import numpy as np
  3. import tensorflow as tf
  4. import matplotlib.pyplot as plt
  5. num_epochs = 100
  6. total_series_length = 50000
  7. truncated_backprop_length = 15
  8. state_size = 4
  9. num_classes = 2
  10. echo_step = 3
  11. batch_size = 5
  12. num_batches = total_series_length//batch_size//truncated_backprop_length

生成数据

现在生成训练数据,输入在本质上是一个随机的二元矢量。输出会是输入的 “回响”(echo),把 echo_step 步骤移到右边。

  1. def generateData():
  2. x = np.array(np.random.choice(2, total_series_length, p=[0.5, 0.5]))
  3. y = np.roll(x, echo_step)
  4. y[0:echo_step] = 0
  5. x = x.reshape((batch_size, -1)) # The first index changing slowest, subseries as rows
  6. y = y.reshape((batch_size, -1))
  7. return (x, y)

注意数据整形(data reshaping)步骤,这是为了将其装入有 batch_size 行的矩阵。神经网络根据神经元权重来逼近损失函数的梯度,通过这种方式来进行训练;该过程只会利用数据的一个小子集,即 mini-batch。数据整形把整个数据集装入矩阵,然后分割为这些 mini-batch。

整形后的数据矩阵图解。曲线箭头用以表示换了行的相邻时间步。浅灰色代表 0,深灰色代表 1。

创建计算图

TensorFlow 的工作方式会首先创建一个计算图,来确认哪些操作需要完成。计算图的输入和输出一般是多维阵列,即张量(tensor)。计算图或其中一部分,将被迭代执行。这既可以在 CPU、GPU,也可在远程服务器上执行。

变量和 placeholder

本教程中使用的两个最基础的 TensorFlow 数据结构是变量和 placeholder。每轮运行中,batch 数据会被喂给 placeholder,而后者是计算图的 “起始点”。另外,前一轮输出的 RNN-state 会在 placeholder 中提供。

  1. batchX_placeholder = tf.placeholder(tf.float32, [batch_size, truncated_backprop_length])
  2. batchY_placeholder = tf.placeholder(tf.int32, [batch_size, truncated_backprop_length])
  3. init_state = tf.placeholder(tf.float32, [batch_size, state_size])

神经网络的权重和偏差,被作为 TensorFlow 变量。这使得它们在每轮运行中保持一致,并对每次 batch 渐进式地更新。

  1. W = tf.Variable(np.random.rand(state_size+1, state_size), dtype=tf.float32)
  2. b = tf.Variable(np.zeros((1,state_size)), dtype=tf.float32)
  3. W2 = tf.Variable(np.random.rand(state_size, num_classes),dtype=tf.float32)
  4. b2 = tf.Variable(np.zeros((1,num_classes)), dtype=tf.float32)

下图展示的是作为输入的数据矩阵,现有的 batch——batchX_placeholder 在虚线长方形里。正如我们后来看到的,这一 ”batch 窗口 “在每轮运行向右移动了 truncated_backprop_length 规定的步数,这便是箭头的意义。在下面的例子中,batch_size = 3, truncated_backprop_length = 3, and total_series_length = 36。注意这些数字只是出于可视化目的,代码中的数值并不一样。在几个数据点中,series order 指数以数字表示。

Unpacking

这一步,要做的是搭建计算图中类似于真正的 RNN 计算的部分。首先,我们希望把 batch 数据分割为邻近的时间步。

  1. # Unpack columns
  2. inputs_series = tf.unpack(batchX_placeholder, axis=1)
  3. labels_series = tf.unpack(batchY_placeholder, axis=1)

如同下图所示,这通过把 batch 中的列(axis = 1)解压到 Python 列表来实现。RNN 同时在时间序列的不同部分上训练;在现有 batch 例子中,是 4-6、16-18、28-30 步。使用以 “plural”_”series” 为名的变量,是为了强调该变量是一个列表——代表了在每一个时间步有多个 entry 的时间序列。

现有 batch 被分成列的图示,每个数据点上的数字是顺序指数,牵头指示相邻时间步。

在我们的时间序列中,训练同时在三个地方完成。这需要在前馈是时同时保存三个 instances of states。这已经被考虑到了:你看得到的 init_state placeholder 有 batch_size 行。

Forward pass

下一步,我们会创建进行真实 RNN 运算的计算图部分。

  1. # Forward pass
  2. current_state = init_state
  3. states_series = []
  4. for current_input in inputs_series:
  5. current_input = tf.reshape(current_input, [batch_size, 1])
  6. input_and_state_concatenated = tf.concat(1, [current_input, current_state]) # Increasing number of columns
  7. next_state = tf.tanh(tf.matmul(input_and_state_concatenated, W) + b) # Broadcasted addition
  8. states_series.append(next_state)
  9. current_state = next_state

注意第六行的串联(concatenation),我们实际上想要做的,是计算两个仿射变形(affine transforms)的 current_input * Wa + current_state *Wbin,见下图。通过串联这两个张量,你会 = 只会使用一个矩阵乘法。偏差 b 的加法,会在 batch 里的所有样本上传播。

上面代码示例中矩阵第八行的计算,非线性变形的反正切(arctan)被忽略。

你也许会好奇变量 truncated_backprop_length 其名称的含义。当一个 RNN 被训练,事实上它被作为是一个深度神经网络的特殊情况:在每一层有重复出现的权重。这些层不会展开到一开始的时候,这么干的计算成本太高,因而时间步的数量被截为有限的数目。在上面的图示中,误差在 batch 中被反向传播三步。

计算损失

这是计算图的最后一步,一个从状态到输出的全连接 softmax 层,让 classes 以 one-hot 格式编码, 然后计算 batch 的损失。

  1. logits_series = [tf.matmul(state, W2) + b2 for state in states_series] #Broadcasted addition
  2. predictions_series = [tf.nn.softmax(logits) for logits in logits_series]
  3. losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels) for logits, labels in zip(logits_series,labels_series)]
  4. total_loss = tf.reduce_mean(losses)
  5. train_step = tf.train.AdagradOptimizer(0.3).minimize(total_loss)

最后一行加入的是训练功能。TensorFlow 会自动运行反向传播——对每一个 mini-batch,计算图会执行一次;网络权重会渐进式更新。

注意 API 调用 ”sparse_softmax_cross_entropy_with_logits“,它在内部自动计算 softmax,然后计算 cross-entropy。在我们的例子里,这些 class 是互相排斥的,要么是 1 要么是 0,这便是使用 “Sparse-softmax” 的原因。你可以在 API 中了解更多。

训练可视化

这里面有可视化函数,所以我们能在训练时看到神经网络中发生了什么。它会不断绘制损失曲线,展示训练输入、训练输出,以及在一个训练 batch 的不同样本序列上神经网络的现有预测。

  1. def plot(loss_list, predictions_series, batchX, batchY):
  2. plt.subplot(2, 3, 1)
  3. plt.cla()
  4. plt.plot(loss_list)
  5. for batch_series_idx in range(5):
  6. one_hot_output_series = np.array(predictions_series)[:, batch_series_idx, :]
  7. single_output_series = np.array([(1 if out[0] < 0.5 else 0) for out in one_hot_output_series])
  8. plt.subplot(2, 3, batch_series_idx + 2)
  9. plt.cla()
  10. plt.axis([0, truncated_backprop_length, 0, 2])
  11. left_offset = range(truncated_backprop_length)
  12. plt.bar(left_offset, batchX[batch_series_idx, :], width=1, color="blue")
  13. plt.bar(left_offset, batchY[batch_series_idx, :] * 0.5, width=1, color="red")
  14. plt.bar(left_offset, single_output_series * 0.3, width=1, color="green")
  15. plt.draw()
  16. plt.pause(0.0001)

运行训练环节

到了把一切归总、训练网络的时候了。在 TensorFlow 中,计算图要在一个大环节中执行。新数据在每个小环节生成(并不是通常的方式,但它在这个例子中有用。以为所有东西都是可预测的)。

  1. with tf.Session() as sess:
  2. sess.run(tf.initialize_all_variables())
  3. plt.ion()
  4. plt.figure()
  5. plt.show()
  6. loss_list = []
  7. for epoch_idx in range(num_epochs):
  8. x,y = generateData()
  9. _current_state = np.zeros((batch_size, state_size))
  10. print("New data, epoch", epoch_idx)
  11. for batch_idx in range(num_batches):
  12. start_idx = batch_idx * truncated_backprop_length
  13. end_idx = start_idx + truncated_backprop_length
  14. batchX = x[:,start_idx:end_idx]
  15. batchY = y[:,start_idx:end_idx]
  16. _total_loss, _train_step, _current_state, _predictions_series = sess.run(
  17. [total_loss, train_step, current_state, predictions_series],
  18. feed_dict={
  19. batchX_placeholder:batchX,
  20. batchY_placeholder:batchY,
  21. init_state:_current_state
  22. })
  23. loss_list.append(_total_loss)
  24. if batch_idx%100 == 0:
  25. print("Step",batch_idx, "Loss", _total_loss)
  26. plot(loss_list, _predictions_series, batchX, batchY)
  27. plt.ioff()
  28. plt.show()

你可以看到,我们在每次迭代把 truncated_backprop_length 步骤向前移(第 15–19 行),但设置不同的移动幅度是可能的。该话题在下面进一步讨论。据雷锋网了解,这么做的坏处是,truncated_backprop_length 需要比 time dependencies 大很多(在我们的例子中是三步),才能隔离相关训练数据。否则可能会有许多 “丢失”,如下图。

方块时间序列,升起的黑块代表 echo-output,在 echo input(黑块)三步之后激活。滑动 batch 窗口每次也移动三步,在我们的例子中,这意味着没有 batch 会隔离 dependency,所以它无法训练。

AI 研习社提醒,这只是一个解释 RNN 工作原理的简单例子,该功能可以很容易地用几行代码编写出来。该神经网络将能够准确地学习 echo 行为,所以没有必要用测试数据。

该程序会随训练更新图表。请见下面的图例。蓝条代表训练输入信号(二元),红条表示训练输出的 echo,绿条是神经网络产生的 echo。不同的条形块代表了当前 batch 的不同样本序列。

我们的算法能够相当快速地学习该任务。左上角的图展示了随时函数的输出,但图中的尖刺是怎么回事?你可以好好想一想,答案在下面。

损失、输入、输出训练数据(蓝、红)以及预测(绿)的可视化。

形成尖刺的原因是:我们正在开始一个新的小环节,生成新数据。由于矩阵被整形过,每一行的新单元与上一行的最后一个单元临近。除了第一行,所有行的开头几个单元有不会被包括在状态(state)里的 dependency,因此神经网络在第一个 batch 上的表现永远不怎么样。

整个系统

以下便是整个可运行的系统,你只需要复制粘贴然后运行。

  1. from __future__ import print_function, division
  2. import numpy as np
  3. import tensorflow as tf
  4. import matplotlib.pyplot as plt
  5. num_epochs = 100
  6. total_series_length = 50000
  7. truncated_backprop_length = 15
  8. state_size = 4
  9. num_classes = 2
  10. echo_step = 3
  11. batch_size = 5
  12. num_batches = total_series_length//batch_size//truncated_backprop_length
  13. def generateData():
  14. x = np.array(np.random.choice(2, total_series_length, p=[0.5, 0.5]))
  15. y = np.roll(x, echo_step)
  16. y[0:echo_step] = 0
  17. x = x.reshape((batch_size, -1)) # The first index changing slowest, subseries as rows
  18. y = y.reshape((batch_size, -1))
  19. return (x, y)
  20. batchX_placeholder = tf.placeholder(tf.float32, [batch_size, truncated_backprop_length])
  21. batchY_placeholder = tf.placeholder(tf.int32, [batch_size, truncated_backprop_length])
  22. init_state = tf.placeholder(tf.float32, [batch_size, state_size])
  23. W = tf.Variable(np.random.rand(state_size+1, state_size), dtype=tf.float32)
  24. b = tf.Variable(np.zeros((1,state_size)), dtype=tf.float32)
  25. W2 = tf.Variable(np.random.rand(state_size, num_classes),dtype=tf.float32)
  26. b2 = tf.Variable(np.zeros((1,num_classes)), dtype=tf.float32)
  27. # Unpack columns
  28. inputs_series = tf.unpack(batchX_placeholder, axis=1)
  29. labels_series = tf.unpack(batchY_placeholder, axis=1)
  30. # Forward pass
  31. current_state = init_state
  32. states_series = []
  33. for current_input in inputs_series:
  34. current_input = tf.reshape(current_input, [batch_size, 1])
  35. input_and_state_concatenated = tf.concat(1, [current_input, current_state]) # Increasing number of columns
  36. next_state = tf.tanh(tf.matmul(input_and_state_concatenated, W) + b) # Broadcasted addition
  37. states_series.append(next_state)
  38. current_state = next_state
  39. logits_series = [tf.matmul(state, W2) + b2 for state in states_series] #Broadcasted addition
  40. predictions_series = [tf.nn.softmax(logits) for logits in logits_series]
  41. losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels) for logits, labels in zip(logits_series,labels_series)]
  42. total_loss = tf.reduce_mean(losses)
  43. train_step = tf.train.AdagradOptimizer(0.3).minimize(total_loss)
  44. def plot(loss_list, predictions_series, batchX, batchY):
  45. plt.subplot(2, 3, 1)
  46. plt.cla()
  47. plt.plot(loss_list)
  48. for batch_series_idx in range(5):
  49. one_hot_output_series = np.array(predictions_series)[:, batch_series_idx, :]
  50. single_output_series = np.array([(1 if out[0] < 0.5 else 0) for out in one_hot_output_series])
  51. plt.subplot(2, 3, batch_series_idx + 2)
  52. plt.cla()
  53. plt.axis([0, truncated_backprop_length, 0, 2])
  54. left_offset = range(truncated_backprop_length)
  55. plt.bar(left_offset, batchX[batch_series_idx, :], width=1, color="blue")
  56. plt.bar(left_offset, batchY[batch_series_idx, :] * 0.5, width=1, color="red")
  57. plt.bar(left_offset, single_output_series * 0.3, width=1, color="green")
  58. plt.draw()
  59. plt.pause(0.0001)
  60. with tf.Session() as sess:
  61. sess.run(tf.initialize_all_variables())
  62. plt.ion()
  63. plt.figure()
  64. plt.show()
  65. loss_list = []
  66. for epoch_idx in range(num_epochs):
  67. x,y = generateData()
  68. _current_state = np.zeros((batch_size, state_size))
  69. print("New data, epoch", epoch_idx)
  70. for batch_idx in range(num_batches):
  71. start_idx = batch_idx * truncated_backprop_length
  72. end_idx = start_idx + truncated_backprop_length
  73. batchX = x[:,start_idx:end_idx]
  74. batchY = y[:,start_idx:end_idx]
  75. _total_loss, _train_step, _current_state, _predictions_series = sess.run(
  76. [total_loss, train_step, current_state, predictions_series],
  77. feed_dict={
  78. batchX_placeholder:batchX,
  79. batchY_placeholder:batchY,
  80. init_state:_current_state
  81. })
  82. loss_list.append(_total_loss)
  83. if batch_idx%100 == 0:
  84. print("Step",batch_idx, "Loss", _total_loss)
  85. plot(loss_list, _predictions_series, batchX, batchY)
  86. plt.ioff()
  87. plt.show()

via medium,原作者 Erik Hallström,雷锋网编译

原文发布于微信公众号 - AI研习社(okweiwu)

原文发表时间:2017-04-28

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Coding迪斯尼

深度学习:将新闻报道按照不同话题性质进行分类

12420
来自专栏量子位

想打造一个神经网络,自动给黑白照片上色?这儿有一份超详细教程

王小新 编译自 FloydHub Blog 量子位 出品 | 公众号 QbitAI ? 昨天,你可能惊喜地看到了Adobe做了个给人像上色的软件,然后伤心地发现...

47150
来自专栏AI科技大本营的专栏

AI技术讲座精选:神经结构搜索和强化学习

摘 要 神经网络模型不仅功能强大,而且特别灵活,在许多困难的学习任务中均发挥着良好的作用,如图像、声音和自然语言的理解等。尽管神经网络获得了一系列的成功,但是...

343110
来自专栏Python疯子

python人工智能:完整的图片识别(非图片验证码),以及模型的使用

这个可以说是一个绝对的福利中的福利。一整套的AI图片识别以及模型的使用。 一直都在说人工智能,图像识别,又有几个人会呢,网上文章成山,前一段时间因工作需要,我...

21610
来自专栏PaddlePaddle

转载|使用PaddleFluid和TensorFlow训练RNN语言模型

在图像领域,最流行的 building block 大多以卷积网络为主。上一篇我们介绍了转载|使用PaddleFluid和TensorFlow实现图像分类网络S...

16330
来自专栏AI科技大本营的专栏

如何在Python中用LSTM网络进行时间序列预测

Matt MacGillivray 拍摄,保留部分权利 翻译 | AI科技大本营(rgznai100) 长短记忆型递归神经网络拥有学习长观察值序列的潜力。它似...

1.2K40
来自专栏IT派

实战|TensorFlow 实践之手写体数字识别!

本文的主要目的是教会大家运用google开源的深度学习框架tensorflow来实现手写体数字识别,给出两种模型,一种是利用机器学习中的softmax regr...

15000
来自专栏机器学习之旅

Python:SMOTE算法

17.11.28更新一下:最近把这个算法集成到了数据预处理的python工程代码中了,不想看原理想直接用的,有简易版的python开发:特征工程代码模版 ,进...

35040
来自专栏AI科技大本营的专栏

AI 技术讲座精选:Python中使用LSTM网络进行时间序列预测

长短记忆型递归神经网络拥有学习长观察值序列的潜力。 它似乎是实现时间序列预测的完美方法,事实上,它可能就是。 在此教程中,你将学习如何构建解决单步单变量时间序...

49140
来自专栏CVer

TensorFlow和深度学习入门教程

英文原文:https://codelabs.developers.google.com/codelabs/cloud-tensorflow-mnist/#0 C...

40580

扫码关注云+社区

领取腾讯云代金券