60、RNN的各种结构(多层、双向)的实现与效果对比_笔记

东方耀

60、RNN的各种结构(多层、双向)的实现与效果对比_笔记


2层LSTM Cell 单向 网络 效果：
INFO:tensorflow:Step:   450, loss: 0.224, accuracy: 0.910
INFO:tensorflow:Step:   460, loss: 0.153, accuracy: 0.960
INFO:tensorflow:Step:   470, loss: 0.138, accuracy: 0.950
INFO:tensorflow:Step:   480, loss: 0.066, accuracy: 0.980
INFO:tensorflow:Step:   490, loss: 0.049, accuracy: 0.980
测试集准确率：0.9580000042915344

2层LSTM Cell 单向 网络 效果：use_peepholes=True
INFO:tensorflow:Step:   450, loss: 0.208, accuracy: 0.950
INFO:tensorflow:Step:   460, loss: 0.045, accuracy: 0.980
INFO:tensorflow:Step:   470, loss: 0.181, accuracy: 0.940
INFO:tensorflow:Step:   480, loss: 0.083, accuracy: 0.970
INFO:tensorflow:Step:   490, loss: 0.022, accuracy: 1.000
测试集准确率：0.9570000171661377

2层GRU Cell 单向 网络 效果：
INFO:tensorflow:Step:   450, loss: 0.195, accuracy: 0.920
INFO:tensorflow:Step:   460, loss: 0.104, accuracy: 0.960
INFO:tensorflow:Step:   470, loss: 0.105, accuracy: 0.970
INFO:tensorflow:Step:   480, loss: 0.184, accuracy: 0.960
INFO:tensorflow:Step:   490, loss: 0.062, accuracy: 0.990
测试集准确率：0.9559999704360962


单层GRU Cell 单向 网络 效果：
INFO:tensorflow:Step:   450, loss: 0.191, accuracy: 0.920
INFO:tensorflow:Step:   460, loss: 0.060, accuracy: 0.980
INFO:tensorflow:Step:   470, loss: 0.076, accuracy: 0.950
INFO:tensorflow:Step:   480, loss: 0.095, accuracy: 0.960
INFO:tensorflow:Step:   490, loss: 0.057, accuracy: 0.990
测试集准确率：0.9616666436195374

单层LSTM Cell 单向 网络 效果：
INFO:tensorflow:Step:   450, loss: 0.178, accuracy: 0.940
INFO:tensorflow:Step:   460, loss: 0.126, accuracy: 0.960
INFO:tensorflow:Step:   470, loss: 0.122, accuracy: 0.940
INFO:tensorflow:Step:   480, loss: 0.141, accuracy: 0.950
INFO:tensorflow:Step:   490, loss: 0.085, accuracy: 0.960
测试集准确率：0.9493333101272583


单层 LSTM与GRU Cell 双向 网络 效果：
INFO:tensorflow:Step:   450, loss: 0.219, accuracy: 0.920
INFO:tensorflow:Step:   460, loss: 0.119, accuracy: 0.960
INFO:tensorflow:Step:   470, loss: 0.123, accuracy: 0.950
INFO:tensorflow:Step:   480, loss: 0.161, accuracy: 0.960
INFO:tensorflow:Step:   490, loss: 0.085, accuracy: 0.970
测试集准确率：0.95333331823349


多层 LSTM与GRU Cell 双向 网络 效果：
INFO:tensorflow:Step:   450, loss: 0.206, accuracy: 0.950
INFO:tensorflow:Step:   460, loss: 0.156, accuracy: 0.940
INFO:tensorflow:Step:   470, loss: 0.174, accuracy: 0.950
INFO:tensorflow:Step:   480, loss: 0.083, accuracy: 0.960
INFO:tensorflow:Step:   490, loss: 0.034, accuracy: 0.990
测试集准确率：0.9553333520889282

1. def bidirectional_dynamic_rnn(
   
2.         cell_fw: 前向的rnn cell
   
3.         , cell_bw：反向的rnn cell
   
4.         , inputs：输入的序列
   
5.         , sequence_length=None # 输入序列的实际长度（可选，默认为输入序列的最大长度）
   
6.         , initial_state_fw=None：前向rnn_cell的初始状态（可选）
   
7.         , initial_state_bw=None：反向rnn_cell的初始状态（可选）
   
8.         , dtype=None # 初始化和输出的数据类型（可选）
   
9.         , parallel_iterations=None
   
10.         , swap_memory=False,
    
11.         # 决定了输入输出tensor的格式：如果为true, 向量的形状必须为 `[max_time, batch_size, depth]`.
    
12.         # 如果为false, tensor的形状必须为`[batch_size, max_time, depth]`.
    
13.         time_major=False,
    
14.         scope=None)
    
15. 
    
16. API返回值：(outputs, output_states) => outputs存储网络的输出信息，output_states存储网络的细胞状态信息
    
17. outputs: 是一个二元组, (output_fw, output_bw)构成，output_fw对应前向的rnn_cell的执行结果，
    
18. 结构为：[batch_size, time_steps, output_size];
    
19. output_bw对应反向的rnn_cell的执行结果，结果和output_bw一样
    
20. output_states：是一个二元组，(output_state_fw, output_state_bw) 构成，
    
21. output_state_fw和output_state_bw是dynamic_rnn API输出的状态值信息

复制代码

1. # -*- coding: utf-8 -*-
   
2. __author__ = u'东方耀 微信：dfy_88888'
   
3. __date__ = '2019/4/15 11:48'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'rnn_mnist_demo'
   
6. 
   
7. 
   
8. """
   
9.    59、RNN实战案例：手写数字图片识别(分类)
   
10.    tf开发 三个模块：
    
11.    1、数据提供者  api: next_batch(batch_size)
    
12.    2、构建数据流图  模型结构 input LSTM fc output  metric(loss accuracy)  train_op
    
13.    3、执行训练的代码 sess.run()
    
14.    
    
15.    def bidirectional_dynamic_rnn(
    
16.         cell_fw: 前向的rnn cell
    
17.         , cell_bw：反向的rnn cell
    
18.         , inputs：输入的序列
    
19.         , sequence_length=None # 输入序列的实际长度（可选，默认为输入序列的最大长度）
    
20.         , initial_state_fw=None：前向rnn_cell的初始状态（可选）
    
21.         , initial_state_bw=None：反向rnn_cell的初始状态（可选）
    
22.         , dtype=None # 初始化和输出的数据类型（可选）
    
23.         , parallel_iterations=None
    
24.         , swap_memory=False,
    
25.         # 决定了输入输出tensor的格式：如果为true, 向量的形状必须为 `[max_time, batch_size, depth]`.
    
26.         # 如果为false, tensor的形状必须为`[batch_size, max_time, depth]`.
    
27.         time_major=False,
    
28.         scope=None)
    
29. 
    
30. API返回值：(outputs, output_states) => outputs存储网络的输出信息，output_states存储网络的细胞状态信息
    
31. outputs: 是一个二元组, (output_fw, output_bw)构成，output_fw对应前向的rnn_cell的执行结果，
    
32. 结构为：[batch_size, time_steps, output_size];
    
33. output_bw对应反向的rnn_cell的执行结果，结果和output_bw一样
    
34. output_states：是一个二元组，(output_state_fw, output_state_bw) 构成，
    
35. output_state_fw和output_state_bw是dynamic_rnn API输出的状态值信息
    
36. """
    
37. 
    
38. import tensorflow as tf
    
39. from tensorflow.examples.tutorials.mnist import input_data
    
40. import numpy as np
    
41. import math
    
42. import matplotlib.pyplot as plt
    
43. 
    
44. tf.logging.set_verbosity(tf.logging.INFO)
    
45. 
    
46. tf.random.set_random_seed(10)
    
47. 
    
48. 
    
49. # 第一步：导入数据
    
50. # 数据加载
    
51. mnist = input_data.read_data_sets('mnist_data/', one_hot=True)
    
52. 
    
53. # 样本数 55000
    
54. print(mnist.train.num_examples)
    
55. # images 特征矩阵 784个特征属性
    
56. print(mnist.train.images.shape)
    
57. # labels 目标属性10个 刚好是10个数字 进行了哑编码
    
58. print(mnist.train.labels.shape)
    
59. 
    
60. print('测试集shape：{}'.format(mnist.test.images.shape))
    
61. print('验证集shape：{}'.format(mnist.validation.images.shape))
    
62. 
    
63. # 手写数字识别的数据集主要包含三个部分：训练集(5.5w, mnist.train)、测试集(1w, mnist.test)、验证集(0.5w, mnist.validation)
    
64. # 手写数字图片大小是28*28*1像素的图片(黑白)，也就是每个图片由784维的特征描述
    
65. 
    
66. 
    
67. # 第二步：设置超参并定义学习率调整策略
    
68. learn_rate_base = 0.01
    
69. # 时序长度 t1 t2 t3... t28  28个时刻
    
70. num_timesteps = 28
    
71. # 每个时刻输入的数据维度大小(像素值个数)
    
72. input_size = 28
    
73. # 一个LSTM的FP过程完成后 刚好就是处理了一张图片
    
74. # （图片内部的像素点之间是有一定的依赖关系的）上下文关系 就可以用RNN
    
75. 
    
76. num_lstm_layers = 2
    
77. num_lstm_nodes = [128, 256]
    
78. # 控制lstm梯度的大小 1.0是梯度的上限 如果梯度大于1.0就设为1.0 截断
    
79. clip_lstm_grads = 1.0
    
80. # 展示信息的间隔大小
    
81. display_step = 10
    
82. # 输入的样本维度大小信息 784 = 28*28
    
83. input_dim = mnist.train.images.shape[1]
    
84. # 输出的维度大小信息 10
    
85. class_num = mnist.train.labels.shape[1]
    
86. 
    
87. tf.logging.info('input_dim : %d' % input_dim)
    
88. tf.logging.info('class_num : %d' % class_num)
    
89. 
    
90. # 查看手写图片数据 10张图片数据与对应的y值
    
91. # train_images, train_labels = mnist.train.next_batch(10)
    
92. # print(train_images.shape)
    
93. # print(train_labels.shape)
    
94. # train_image = train_images[0]
    
95. # train_label = train_labels[0]
    
96. # print('实际值：', train_label)
    
97. #
    
98. # train_image = np.array(train_image)
    
99. # train_image = train_image.reshape(28, 28)
    
100. # fig = plt.figure()
     
101. # plt.imshow(train_image, cmap='binary')
     
102. # plt.show()
     
103. 
     
104. 
     
105. def learn_rate_func(epoch):
     
106.     """
     
107.     根据给定的迭代批次，更新产生一个学习率的值 均匀分布策略
     
108.     :param epoch:
     
109.     :return:
     
110.     """
     
111.     return max(0.001, learn_rate_base * (0.9 ** int(epoch / 10)))
     
112. 
     
113. 
     
114. #
     
115. # 第三步：开始构建模型 设置输入数据的占位符
     
116. _X = tf.placeholder(dtype=tf.float32, shape=[None, input_dim], name='X_origianl')
     
117. y = tf.placeholder(tf.int32, [None, class_num], name='y')
     
118. # batch_size是一个int32类型的标量tensor的占位符，
     
119. # 使用batch_size可以让我们在训练和测试的时候使用不同的数据量
     
120. batch_size = tf.placeholder(tf.int32, [])
     
121. # # dropout的时候，保留率多少
     
122. keep_prob = tf.placeholder(tf.float32, [])
     
123. learn_rate = tf.placeholder(tf.float32, [])
     
124. 
     
125. 
     
126. # 第四步：构建RNN LSTM 网络（直接将网络结构翻译成为这个代码）
     
127. # 1. 输入的数据格式转换
     
128. # X格式：[batch_size, num_timesteps, input_size]
     
129. X = tf.reshape(_X, [-1, num_timesteps, input_size])
     
130. 
     
131. # LSTM层
     
132. # 开方(输入层size + 输出层size)
     
133. # 初始化方法 仿照了
     
134. scale = 1.0 / math.sqrt(input_size + num_lstm_nodes[-1]) / 3.0
     
135. lstm_initializer = tf.random_uniform_initializer(minval=-scale, maxval=scale)
     
136. with tf.variable_scope(name_or_scope='lstm_nn', initializer=lstm_initializer):
     
137.     cells_fw = []
     
138.     for i in range(num_lstm_layers):
     
139.         cell = tf.nn.rnn_cell.LSTMCell(num_units=num_lstm_nodes[i], name='lstm_cell')
     
140.         # cell = tf.nn.rnn_cell.LSTMCell(num_units=num_lstm_nodes[i], use_peepholes=True, name='lstm_cell')
     
141.         cell = tf.nn.rnn_cell.DropoutWrapper(cell, output_keep_prob=keep_prob)
     
142.         cells_fw.append(cell)
     
143.     # 多层的LSTM 将两层的cell合并封装成一个MultiRNNCell
     
144.     # 将多层RNN当作单层RNN来操作了
     
145.     # tf.nn.rnn_cell
     
146.     cell_fw = tf.nn.rnn_cell.MultiRNNCell(cells_fw, state_is_tuple=True)
     
147. 
     
148.     cells_bw = []
     
149.     for i in range(num_lstm_layers):
     
150.         # cell = tf.nn.rnn_cell.LSTMCell(num_units=num_lstm_nodes[i], name='lstm_cell')
     
151.         cell = tf.nn.rnn_cell.GRUCell(num_units=num_lstm_nodes[i], name='gru_cell')
     
152.         # cell = tf.nn.rnn_cell.LSTMCell(num_units=num_lstm_nodes[i], use_peepholes=True, name='lstm_cell')
     
153.         cell = tf.nn.rnn_cell.DropoutWrapper(cell, output_keep_prob=keep_prob)
     
154.         cells_bw.append(cell)
     
155.     # 多层的LSTM 将两层的cell合并封装成一个MultiRNNCell
     
156.     # 将多层RNN当作单层RNN来操作了
     
157.     # tf.nn.rnn_cell
     
158.     cell_bw = tf.nn.rnn_cell.MultiRNNCell(cells_bw, state_is_tuple=True)
     
159. 
     
160. 
     
161. 
     
162.     # cell_fw = tf.nn.rnn_cell.LSTMCell(num_units=num_lstm_nodes[0], name='gru_cell')
     
163.     # cell_bw = tf.nn.rnn_cell.GRUCell(num_units=num_lstm_nodes[1], name='gru_cell')
     
164.     # 初始的中间的隐含状态 state=0
     
165.     initial_state_fw = cell_fw.zero_state(batch_size=batch_size, dtype=tf.float32)
     
166.     initial_state_bw = cell_bw.zero_state(batch_size=batch_size, dtype=tf.float32)
     
167.     # 让cell去处理或计算输入的序列 rnn_outputs包含了每一步的输出
     
168.     # rnn_outputs shape : [batch_size, num_timesteps, hps.num_lstm_nodes[-1]]
     
169.     # rnn_outputs, middle_hidden_state = tf.nn.dynamic_rnn(cell=cell, inputs=X, initial_state=initial_state)
     
170.     rnn_outputs, middle_hidden_state = tf.nn.bidirectional_dynamic_rnn(cell_fw=cell_fw,
     
171.                                                                        cell_bw=cell_bw,
     
172.                                                                        inputs=X,
     
173.                                                                        initial_state_fw=initial_state_fw,
     
174.                                                                        initial_state_bw=initial_state_bw)
     
175. 
     
176.     rnn_outputs_fw, rnn_outputs_bw = rnn_outputs
     
177.     middle_hidden_state_fw, middle_hidden_state_bw = middle_hidden_state
     
178. 
     
179. 
     
180.     print('rnn_outputs_fw shape:', rnn_outputs_fw.shape)
     
181.     print('rnn_outputs_bw shape:', rnn_outputs_bw.shape)
     
182.     # last shape [batch_size, hps.num_lstm_nodes[-1]]
     
183.     # shape : [batch_size, 128]
     
184.     last_fw = rnn_outputs_fw[:, -1, :]
     
185.     # shape : [batch_size, 256]
     
186.     last_bw = rnn_outputs_bw[:, -1, :]
     
187. 
     
188.     last = tf.concat([last_fw, last_bw], axis=1)
     
189.     # shape : [batch_size, 128+256]
     
190.     print('last shape: ', last.shape)
     
191. 
     
192. 
     
193. # fc
     
194. # fc_initializer = tf.uniform_unit_scaling_initializer(factor=1.0, dtype=tf.float32)
     
195. fc_initializer = tf.random_uniform_initializer(-1.0, 1.0, seed=10)
     
196. with tf.variable_scope(name_or_scope='fc', initializer=fc_initializer):
     
197.     logits = tf.layers.dense(last, class_num, name='fc')
     
198. 
     
199. #
     
200. # 第五步：构建模型的损失函数
     
201. # 第六步：构建梯度下降的优化方法（一般用Adam 动量GD）
     
202. # 第七步：计算模型正确率
     
203. # metrics (loss accuracy)
     
204. # metrics度量层（loss 与 accuracy）
     
205. # 这一层并没有变量或参数需要训练 也就不需要初始化器 所以使用name_scope
     
206. with tf.name_scope(name='metrics'):
     
207.     # sparse_ 用这个：强大一些
     
208.     # softmax_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=outputs, logits=logits)
     
209.     # 计算_交叉熵损失函数值 用第二个版本
     
210.     softmax_loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=y, logits=logits)
     
211.     loss = tf.reduce_mean(softmax_loss)
     
212.     # argmax [0, 2, 1, 5, 8, 2]  ---> 4
     
213.     y_pred = tf.argmax(tf.nn.softmax(logits), axis=1, output_type=tf.int32)
     
214.     y_true = tf.argmax(y, axis=1, output_type=tf.int32)
     
215.     correct_pred = tf.equal(y_pred, y_true)
     
216.     accuracy = tf.reduce_mean(tf.cast(correct_pred, dtype=tf.float32))
     
217. 
     
218. 
     
219. # train_op 训练层
     
220. with tf.name_scope(name='train_op'):
     
221.     # 需要对训练变量的梯度进行clip  hps.clip_lstm_grads
     
222.     # 获取所有训练的变量
     
223.     # train_op = tf.train.AdamOptimizer(hps.learning_rate).minimize(loss, global_step=global_step)
     
224.     train_vars = tf.trainable_variables()
     
225.     for var in train_vars:
     
226.         tf.logging.info('train variable name : %s' % var.name)
     
227.     # tf.gradients(loss, train_vars) 损失值对所有变量的梯度
     
228.     # grads得到截断后的梯度
     
229.     grads, _ = tf.clip_by_global_norm(t_list=tf.gradients(loss, train_vars), clip_norm=clip_lstm_grads)
     
230.     # 普通梯度下降 BGD SGD MBGD  动量（有速度） 冲量
     
231.     # 将梯度应用到所有的变量
     
232.     optimizer = tf.train.AdamOptimizer(learn_rate)
     
233.     train_op = optimizer.apply_gradients(grads_and_vars=zip(grads, train_vars), name='train_op')
     
234. 
     
235. 
     
236. 
     
237. # 第八步：会话中执行阶段（模型的训练与迭代）
     
238. 
     
239. init_op = tf.global_variables_initializer()
     
240. 
     
241. num_train_steps = 500
     
242. batch_size_train = 100
     
243. batch_size_test = 3000
     
244. keep_prob_train = 0.8
     
245. keep_prob_test = 1.0
     
246. 
     
247. 
     
248. with tf.Session() as sess:
     
249.     sess.run(init_op)
     
250.     for step in range(num_train_steps):
     
251.         batch_xs, batch_labels = mnist.train.next_batch(batch_size_train)
     
252.         loss_val, accuracy_val, _ = sess.run(fetches=[loss, accuracy, train_op], feed_dict={
     
253.             _X: batch_xs,
     
254.             y: batch_labels,
     
255.             keep_prob: keep_prob_train,
     
256.             batch_size: batch_size_train,
     
257.             learn_rate: learn_rate_func(step)
     
258.         })
     
259.         if step % display_step == 0:
     
260.             tf.logging.info('Step: %5d, loss: %3.3f, accuracy: %3.3f' % (step, loss_val, accuracy_val))
     
261.     # test
     
262.     accuracy_test = sess.run(fetches=accuracy, feed_dict={
     
263.         _X: mnist.test.images[:3000],
     
264.         y: mnist.test.labels[:3000],
     
265.         keep_prob: keep_prob_test,
     
266.         batch_size: batch_size_test,
     
267.     })
     
268.     print('测试集准确率：{}'.format(accuracy_test))
     
269.     pass
     
270. 
     
271. 
     
272. 
     
273. 
     
274. 
     
275. 
     
276. 
     

复制代码

gzqreder

多谢分享

touxian

多谢分享