设置 RNN 的参数 ¶
这次我们会使用 RNN 来进行分类的训练 (Classification). 会继续使用到手写数字 MNIST 数据集. 让 RNN 从每张图片的第一行像素读到最后一行, 然后再进行分类判断. 接下来我们导入 MNIST 数据并确定 RNN 的各种参数(hyper-parameters):
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
tf.set_random_seed(1) # set random seed
# 导入数据
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# hyperparameters
lr = 0.001 # learning rate
training_iters = 100000 # train step 上限
batch_size = 128
n_inputs = 28 # MNIST data input (img shape: 28*28)
n_steps = 28 # time steps
n_hidden_units = 128 # neurons in hidden layer
n_classes = 10 # MNIST classes (0-9 digits)
接着定义 x
, y
的 placeholder
和 weights
, biases
的初始状况.
# x y placeholder
x = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
y = tf.placeholder(tf.float32, [None, n_classes])
# 对 weights biases 初始值的定义
weights = {
# shape (28, 128)
'in': tf.Variable(tf.random_normal([n_inputs, n_hidden_units])),
# shape (128, 10)
'out': tf.Variable(tf.random_normal([n_hidden_units, n_classes]))
}
biases = {
# shape (128, )
'in': tf.Variable(tf.constant(0.1, shape=[n_hidden_units, ])),
# shape (10, )
'out': tf.Variable(tf.constant(0.1, shape=[n_classes, ]))
}
定义 RNN 的主体结构
接着开始定义 RNN 主体结构, 这个 RNN 总共有 3 个组成部分 ( input_layer
, cell
, output_layer
). 首先我们先定义 input_layer
:
def RNN(X, weights, biases):
# 原始的 X 是 3 维数据, 我们需要把它变成 2 维数据才能使用 weights 的矩阵乘法
# X ==> (128 batches * 28 steps, 28 inputs)
X = tf.reshape(X, [-1, n_inputs])
# X_in = W*X + b
X_in = tf.matmul(X, weights['in']) + biases['in']
# X_in ==> (128 batches, 28 steps, 128 hidden) 换回3维
X_in = tf.reshape(X_in, [-1, n_steps, n_hidden_units])
接着是 cell
中的计算, 有两种途径:
- 使用
tf.nn.rnn(cell, inputs)
(不推荐原因). 但是如果使用这种方法, 可以参考原因; - 使用
tf.nn.dynamic_rnn(cell, inputs)
(推荐). 这次的练习将使用这种方式.
因 Tensorflow 版本升级原因, state_is_tuple=True
将在之后的版本中变为默认. 对于 lstm
来说, state
可被分为(c_state, h_state)
.
# 使用 basic LSTM Cell.
lstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden_units, forget_bias=1.0, state_is_tuple=True)
init_state = lstm_cell.zero_state(batch_size, dtype=tf.float32) # 初始化全零 state
如果使用tf.nn.dynamic_rnn(cell, inputs)
, 我们要确定 inputs
的格式. tf.nn.dynamic_rnn
中的 time_major
参数会针对不同 inputs
格式有不同的值.
- 如果
inputs
为 (batches, steps, inputs) ==>time_major=False
; - 如果
inputs
为 (steps, batches, inputs) ==>time_major=True
;
outputs, final_state = tf.nn.dynamic_rnn(lstm_cell, X_in, initial_state=init_state, time_major=False)
最后是 output_layer
和 return
的值. 因为这个例子的特殊性, 有两种方法可以求得 results
.
方式一: 直接调用final_state
中的 h_state
(final_state[1]
) 来进行运算:
results = tf.matmul(final_state[1], weights['out']) + biases['out']
方式二: 调用最后一个 outputs
(在这个例子中,和上面的final_state[1]
是一样的):
# 把 outputs 变成 列表 [(batch, outputs)..] * steps
outputs = tf.unstack(tf.transpose(outputs, [1,0,2]))
results = tf.matmul(outputs[-1], weights['out']) + biases['out'] #选取最后一个 output
在 def RNN()
的最后输出 result
return results
定义好了 RNN 主体结构后, 我们就可以来计算 cost
和 train_op
:
pred = RNN(x, weights, biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
train_op = tf.train.AdamOptimizer(lr).minimize(cost)
训练 RNN
训练时, 不断输出 accuracy
, 观看结果:
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# init= tf.initialize_all_variables() # tf 马上就要废弃这种写法
# 替换成下面的写法:
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
step = 0
while step * batch_size < training_iters:
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
batch_xs = batch_xs.reshape([batch_size, n_steps, n_inputs])
sess.run([train_op], feed_dict={
x: batch_xs,
y: batch_ys,
})
if step % 20 == 0:
print(sess.run(accuracy, feed_dict={
x: batch_xs,
y: batch_ys,
}))
step += 1
最终 accuracy
的结果如下:
0.1875
0.65625
0.726562
0.757812
0.820312
0.796875
0.859375
0.921875
0.921875
0.898438
0.828125
0.890625
0.9375
0.921875
0.9375
0.929688
0.953125
完整代码:
#!/usr/bin/env python
# encoding: utf-8
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# hyperparameters
lr = 0.001
training_iters = 100000
batch_size = 128 # 每次训练只使用mnist中128个数据
# display_step = 10
n_inputs = 28 # Mnist data input(img shape:28X28) # 每次输入一行有28个像素点
n_steps = 28 # time steps,输出28次,因为有28行
n_hidden_units = 128 # neurons in hidden layer
n_classes = 10 # Mnist classes (0-9 digits)
# tf Graph input
x = tf.placeholder(tf.float32, [None, n_steps, n_inputs])
y = tf.placeholder(tf.float32, [None, n_classes])
# define weight
weights = {
# (28, 128)
'in': tf.Variable(tf.random_normal([n_inputs, n_hidden_units])),
# (128, 10)
'out': tf.Variable(tf.random_normal([n_hidden_units, n_classes]))
}
biases = {
# (128,)
'in': tf.Variable(tf.constant(0.1, shape=[n_hidden_units, ])),
# (10,)
'out': tf.Variable(tf.constant(0.1, shape=[n_classes, ]))
}
def RNN(X, weights, biases):
# hidden layer for input to cell
# X (128 batch, 28 steps, 28 inputs)
# 将X转换成(128*28,28 inputs)
X = tf.reshape(X, [-1, n_inputs])
# X_in (128 batch*28 steps, 128 hidden)
X_in = tf.matmul(X, weights['in']) + biases['in']
# x_in (128 batch, 28 steps, 128 hidden)
X_in = tf.reshape(X_in, [-1, n_steps, n_hidden_units])
# cell
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(n_hidden_units, forget_bias=1.0, state_is_tuple=True)
# lstm_cell = tf.nn.rnn_cell.LSTMCell(name='basic_lstm_cell', n_hidden_units, forget_bias=1.0, state_is_tuple=True)
# lstm cell is divided into two parts (c_state, m_state)
# c_state是细胞状态,存着过去的信息,m_state是当前细胞的输出,本来是要传给下一个细胞
# rnn会保留每一步计算的结果,即state;LSTM分为主线c_state,和分线m_state;
# 再init时会生成两个tuple,state_is_tuple=True就是判断生成的是否为元组。
_init_state = lstm_cell.zero_state(batch_size, dtype=tf.float32)
# lstm 就会产生两个state,一般的rnn只会产生一个m_state
# outputs是一个list,每一步的结果都保存在这里,states仅为最后一个state
# 有两种rnn:dynamic_rnn和rnn,dynamic_rnn优点在于对尺度不相同的数据处理上,会减少计算量
# time_major判断时间步的维度是不是放在主要维度(stepps的位置,此处是1的位置,不是主要位置0,故而为False)
outputs, states = tf.nn.dynamic_rnn(lstm_cell, X_in, initial_state=_init_state, time_major=False)
# hidden layer for output as the final results
# 此例中states[1]=outputs[-1]
## 方法一:
# results = tf.matmul(states[1], weights,['out']) + biases['out']
## 方法二:
# [1,01,2]表示第一个维度和第二个维度交换
# outputs被unstack后,变成一列数值或者向量,列数等于steps的值,即cell的数量
outputs = tf.unstack(tf.transpose(outputs, [1, 0, 2])) # state is the last outputs
results = tf.matmul(outputs[-1], weights['out']) + biases['out']
return results
pred = RNN(x, weights, biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
train_op = tf.train.AdamOptimizer(lr).minimize(cost)
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
step = 0
while step * batch_size < training_iters:
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
batch_xs = batch_xs.reshape([batch_size, n_steps, n_inputs])
sess.run([train_op], feed_dict={
x: batch_xs,
y: batch_ys,
})
if step % 20 == 0:
print(sess.run(accuracy, feed_dict={
x: batch_xs,
y: batch_ys,
}))
step += 1