TensorFlow的多层LSTM实践

TensorFlow的多层LSTM实践

上一篇文章我们探索了下LSTM,这篇文章我们动手来实践一下,轮子我们还是用tensorflow的吧。

话说今天好像是个特殊的日子,Theano的宣布终止维护与开发,对这个框架没有怎么了解过,不过可以看看知乎中的相关问题:

Theano's Dead!Yoshua Bengio宣布停止Theano维护与开发

如何看待Theano宣布终止开发 ?

Theano退役,Bengio发出告别信


扯到这个主要是想说说自己的感想吧,其中有一个答案说到,现在的框架拼的是算法和模型,这个听起来挺有道理的,那对于我们这个做机器学习的人来说,我们应该怎么做呢?我们使用框架的时候,肯定是尽量用框架里面的模型和算法吧,这样才把框架最大化的利用起来。

那么我们接下来看看怎么用tensorflow实现多层LSTM吧。

TensorFlow官网用MNIST数据集合做了几个机器学习教材,为了节省时间,我们也用这个数据集。有了数据集,我们就可以开始尽情地在键盘上舞动双手啦!!!

一、我们先来导入会使用到的包和数据。

# -*- coding:utf-8 -*-
%matplotlib inline
import tensorflow as tf
import numpy as np
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
from PIL import Image
import numpy as np
# import scipy
import matplotlib.pyplot as plt
import numpy as np
import pylab
config = tf.ConfigProto()
sess = tf.Session(config=config)
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
print mnist.train.images.shape


二、设置好模型会用到的各个超参数

lr = 1e-3
# 在训练和测试的时候,我们想用不同的 batch_size.所以采用占位符的方式
batch_size = tf.placeholder(tf.int32, [])
# 每个时刻的输入特征是28维的,就是每个时刻输入一行,一行有 28 个像素
input_size = 28
# 时序持续长度为28,即每做一次预测,需要先输入28行
timestep_size = 28
# 每个隐含层的节点数
hidden_size = 64
# LSTM layer 的层数
layer_num = 2
# 最后输出分类类别数量,如果是回归预测的话应该是 1
class_num = 10
_X = tf.placeholder(tf.float32, [None, 784])
y = tf.placeholder(tf.float32, [None, class_num])
keep_prob = tf.placeholder(tf.float32)

三、搭建LSTM 模型

# 把784个点的字符信息还原成 28 * 28 的图片
# 下面几个步骤是实现 RNN / LSTM 的关键
X = tf.reshape(_X, [-1, 28, 28])
def unit_lstm():
    # 定义一层 LSTM_cell,只需要说明 hidden_size, 它会自动匹配输入的 X 的维度
    lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)
    #添加 dropout layer, 一般只设置 output_keep_prob
    lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    return lstm_cell
#调用 MultiRNNCell 来实现多层 LSTM
mlstm_cell = rnn.MultiRNNCell([unit_lstm() for i in range(3)], state_is_tuple=True)

#用全零来初始化state
init_state = mlstm_cell.zero_state(batch_size, dtype=tf.float32)
outputs, state = tf.nn.dynamic_rnn(mlstm_cell, inputs=X, initial_state=init_state, time_major=False)
h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]

四、设置 loss function 和 优化器

W = tf.Variable(tf.truncated_normal([hidden_size, class_num], stddev=0.1), dtype=tf.float32)
bias = tf.Variable(tf.constant(0.1,shape=[class_num]), dtype=tf.float32)
y_pre = tf.nn.softmax(tf.matmul(h_state, W) + bias)
# 损失和评估函数
cross_entropy = -tf.reduce_mean(y * tf.log(y_pre))
train_op = tf.train.AdamOptimizer(lr).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

五、开始训练。

sess.run(tf.global_variables_initializer())
for i in range(1000):
    _batch_size = 128
    batch = mnist.train.next_batch(_batch_size)
    if (i+1)%200 == 0:
        train_accuracy = sess.run(accuracy, feed_dict={
            _X:batch[0], y: batch[1], keep_prob: 1.0, batch_size: _batch_size})
        # 已经迭代完成的 epoch 数: mnist.train.epochs_completed
        print "Iter%d, step %d, training accuracy %g" % ( mnist.train.epochs_completed, (i+1), train_accuracy)
    
    sess.run(train_op, feed_dict={_X: batch[0], y: batch[1], keep_prob: 0.5, batch_size: _batch_size})

六、计算测试数据准确率

images=mnist.test.images
labels=mnist.test.labels
print "test accuracy %g"% sess.run(accuracy, feed_dict={
    _X: images, y: labels, keep_prob: 1.0, batch_size:mnist.test.images.shape[0]})


到此处,我们就用tensorflow实现了多层的LSTM啦,不过我们还可以做个好玩的事情,用代码追踪一下,看学习出来的模型是怎么去分类的。

我们随便取一个训练数据出来。

import matplotlib.pyplot as plt
current_y= mnist.train.labels[5]
current_x=mnist.train.images[5]
print current_y
show(current_x)

结果如下:


然后我们把原始数据变换一下,变成模型能识别的样子。

current_x.shape = [-1, 784]
current_y.shape = [-1, class_num]
current_outputs = np.array(sess.run(outputs, feed_dict={
            _X: current_x, y:current_y, keep_prob: 1.0, batch_size: 1}))
current_outputs.shape = [28, hidden_size]

然后把模型里面相关变量算出来。

h_W = sess.run(W, feed_dict={
            _X:current_x, y: current_y, keep_prob: 1.0, batch_size: 1})
h_bias = sess.run(bias, feed_dict={
            _X:current_x, y: current_y, keep_prob: 1.0, batch_size: 1})
h_bias.shape = [-1, 10]

然后我们来看识别的过程:

bar_index = range(class_num)
for i in xrange(current_outputs.shape[0]):
    plt.subplot(7, 4, i+1)
    current_h_shate = current_outputs[i, :].reshape([-1, hidden_size])

    current_formula=tf.nn.softmax(tf.matmul(current_h_shate, h_W) + h_bias)
    pro = sess.run(current_formula)  
    plt.bar(bar_index, pro[0], width=0.2 , align='center')
    plt.axis('off')
plt.show()

结果如下:

这个图什么意思呢?在上面的图中,为了更清楚地看到线条的变化,坐标都去了,每一行显示了 4 个图,共有 7 行,表示了一行一行读取过程中,模型对字符的识别。可以看到,在只看到前面的几行像素时,模型根本认不出来是什么字符,随着看到的像素越来越多,最后就基本确定了它是字符 4.

对了,上面的代码用的是1.3.0版本的tensorflow,1.2之前和之后的版本中api的调用方式有些区别,千万要注意下,别掉坑里面了。

今天就先到这里,晚安。



参考资料:

1.TensorFlow入门(五)多层 LSTM 通俗易懂版

2.aymericdamien/TensorFlow-Examples

3.github.com/tensorflow/m

编辑于 2017-09-30

文章被以下专栏收录