【TensorFlow】LSTM（基于PTB的自然语言建模）

项目已上传至 GitHub —— nl-modeling

1. 下载 PTB 数据集

官方下载地址的速度可能比较慢，这里提供了其他两种下载途径：

原下载地址（速度可能较慢）
百度网盘密码: 4gup（速度可能被恶意限制）
CSDN下载（现在最低2积分）

需要的 PTB 数据集就在解压之后的 data/ 文件夹下，data/ 文件夹下有 7 个文件，要用的只有 3 个：

ptb.test.txt
ptb.train.txt
ptb.valid.txt

要读取 PTB 数据集需要用到 reader.py，在 GitHub 上面有源码，可以下载或者直接复制下来。reader.py 提供了两个函数用于读取和处理 PTB 数据集：

ptb_raw_data(DATA_PATH)：读取原始数据
ptb_producer(raw_data,batch_size,num_steps)：用于将数据组织成大小为 batch_size，长度为 num_steps 的数据组

原书中的代码没有将这两个函数的操作对象视为 tensor，而根据 reader.py 中的源码说明，它是对 tensor 进行操作的。并且 ptb_producer() 函数中使用了 tf.train.range_input_producer() 函数，所以需要开启多线程。

以下代码示范了如何使用这两个函数：

import reader
import tensorflow as tf# 数据路径
DATA_PATH = 'simple-examples/data/'# 读取原始数据
train_data, valid_data, test_data, _ = reader.ptb_raw_data(DATA_PATH)# 将数据组织成batch大小为4，截断长度为5的数据组，要放在开启多线程之前
batch = reader.ptb_producer(train_data, 4, 5)with tf.Session() as sess:tf.global_variables_initializer().run()# 开启多线程coord = tf.train.Coordinator()threads = tf.train.start_queue_runners(coord=coord)# 读取前两个batch，其中包括每个时刻的输入和对应的答案，ptb_producer()会自动迭代for i in range(2):x, y = sess.run(batch)print('x:', x)print('y:', y)# 关闭多线程coord.request_stop()coord.join(threads)

运行结果如下：

x: [[9970 9971 9972 9974 9975][ 332 7147  328 1452 8595][1969    0   98   89 2254][   3    3    2   14   24]]
y: [[9971 9972 9974 9975 9976][7147  328 1452 8595   59][   0   98   89 2254    0][   3    2   14   24  198]]
x: [[9976 9980 9981 9982 9983][  59 1569  105 2231    1][   0  312 1641    4 1063][ 198  150 2262   10    0]]
y: [[9980 9981 9982 9983 9984][1569  105 2231    1  895][ 312 1641    4 1063    8][ 150 2262   10    0  507]]

2. 完整代码

该代码实现自《TensorFlow：实战Google深度学习框架》

整个代码的结构如下：

PTBModel 类用于创建 LSTM 网络结构及维护其状态
run_epoch() 函数使用给定的 model 在数据集上运行 train_op 并返回 perplexity 值
main() 函数定义图的运行

由于原书中的代码是基于 1.0，而我用的是 1.5，所以出现了很多错误，我将所遇到的错误的解决方法都记录在了文末。源码如下：

import reader
import numpy as np
import tensorflow as tf# 数据参数
DATA_PATH = 'simple-examples/data/'  # 数据存放路径
VOCAB_SIZE = 10000  # 单词数量# 神经网络参数
HIDDEN_SIZE = 200  # LSTM隐藏层规模
NUM_LAYERS = 2  # LSTM结构层数
LEARNING_RATE = 1.0  # 学习速率
KEEP_PROB = 0.5  # 节点不被dropout的概率
MAX_GRAD_NORM = 5  # 用于控制梯度膨胀的参数# 训练参数
TRAIN_BATCH_SIZE = 20  # 训练数据batch大小
TRAIN_NUM_STEP = 35  # 训练数据截断长度# 测试参数
EVAL_BATCH_SIZE = 1  # 测试数据batch大小
EVAL_NUM_STEP = 1  # 测试数据截断
NUM_EPOCH = 2  # 使用训练数据的轮数# 通过PTBModel描述模型，方便维护循环神经网络中的状态
class PTBModel():def __init__(self, is_training, batch_size, num_steps):# 记录batch和截断长度self.batch_size = batch_sizeself.num_steps = num_steps# 定义输入层self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps])# 定义预期输出self.targets = tf.placeholder(tf.int32, [batch_size, num_steps])# 定义LSTM为使用dropout的两层网络lstm_cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE)if is_training:lstm_cell = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=KEEP_PROB)cell = tf.contrib.rnn.MultiRNNCell([lstm_cell] * NUM_LAYERS)# 初始化stateself.initial_state = cell.zero_state(batch_size, tf.float32)# 将单词ID转为单词向量。每个单词都是HIDDEN_SIZE维embedding = tf.get_variable('embedding', [VOCAB_SIZE, HIDDEN_SIZE])# 将原本batch_size*num_steps的输入层转化为batch_size*num_steps*HIDDEN_SIZEinputs = tf.nn.embedding_lookup(embedding, self.input_data)# 只在训练时使用dropoutif is_training:inputs = tf.nn.dropout(inputs, KEEP_PROB)# 定义输出列表outputs = []state = self.initial_statewith tf.variable_scope('RNN'):for time_step in range(num_steps):if time_step > 0:tf.get_variable_scope().reuse_variables()cell_output, state = cell(inputs[:, time_step, :],state)  # 将当前时刻的数据和状态传入LSTMoutputs.append(cell_output)  # 将当前输出加入输出列表# 将输出列表展开成[batch,hidden_size*num_steps]# 再reshape成[batch*num_steps,hidden_size]output = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE])# 将输出传入全连接层，每个时刻的输出都是长度为VOCAB_SIZE的数组weight = tf.get_variable('weight', [HIDDEN_SIZE, VOCAB_SIZE])bias = tf.get_variable('bias', [VOCAB_SIZE])logits = tf.matmul(output, weight) + bias# 定义交叉熵损失函数，sequence_loss_by_example计算一个序列的交叉熵的和loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example([logits],  # 预测结果[tf.reshape(self.targets, [-1])],  # 预期结果。将[batch_size,num_steps]压缩成一维[tf.ones([batch_size * num_steps], dtype=tf.float32)]  # 损失的权重。这里所有的权重都为1，表示不同batch和不同时刻的重要程度都一样)# 计算得到每个batch的平均损失self.cost = tf.reduce_sum(loss) / batch_sizeself.final_state = state# 只在训练时反向传播if not is_training:returntrainable_variables = tf.trainable_variables()grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, trainable_variables),MAX_GRAD_NORM)  # 控制梯度大小。避免梯度膨胀# 定义优化方法optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE)# 定义训练步骤self.train_op = optimizer.apply_gradients(zip(grads, trainable_variables))# 使用给定的model在data上运行train_op并返回在全部数据上的perplexity
def run_epoch(session, model, data_queue, train_op, output_log, epoch_size):# 计算perplexity的辅助变量total_costs = 0.0iters = 0state = session.run(model.initial_state)# 使用当前数据训练或测试模型for step in range(epoch_size):# 生成输入和答案feed_dict = {}x, y = session.run(data_queue)feed_dict[model.input_data] = xfeed_dict[model.targets] = y# 将状态转为字典for i, (c, h) in enumerate(model.initial_state):feed_dict[c] = state[i].cfeed_dict[h] = state[i].h# 获取损失值和下一个状态cost, state, _ = session.run([model.cost, model.final_state, train_op], feed_dict=feed_dict)  # 在当前batch上运行train_op并计算损失值。交叉熵损失函数计算的是下一个单词为给定单词的概率total_costs += costiters += model.num_steps# 训练时输出日志if output_log and step % 100 == 0:print('After %d steps,perplexity is %.3f' %(step, np.exp(total_costs / iters)))return np.exp(total_costs / iters)def main(_):# 原始数据train_data, valid_data, test_data, _ = reader.ptb_raw_data(DATA_PATH)# 计算一个epoch需要训练的次数train_data_len = len(train_data)  # 数据集的大小train_batch_len = train_data_len // TRAIN_BATCH_SIZE  # batch的个数train_epoch_size = (train_batch_len - 1) // TRAIN_NUM_STEP  # 该epoch的训练次数valid_data_len = len(valid_data)valid_batch_len = valid_data_len // EVAL_BATCH_SIZEvalid_epoch_size = (valid_batch_len - 1) // EVAL_NUM_STEPtest_data_len = len(test_data)test_batch_len = test_data_len // EVAL_BATCH_SIZEtest_epoch_size = (test_batch_len - 1) // EVAL_NUM_STEP# 生成数据队列，必须放在开启多线程之前train_queue = reader.ptb_producer(train_data, train_model.batch_size,train_model.num_steps)valid_queue = reader.ptb_producer(valid_data, eval_model.batch_size,eval_model.num_steps)test_queue = reader.ptb_producer(test_data, eval_model.batch_size,eval_model.num_steps)# 定义初始化函数initializer = tf.random_uniform_initializer(-0.05, 0.05)# 定义训练用的模型with tf.variable_scope('language_model', reuse=None, initializer=initializer):train_model = PTBModel(True, TRAIN_BATCH_SIZE, TRAIN_NUM_STEP)# 定义评估用的模型with tf.variable_scope('language_model', reuse=True, initializer=initializer):eval_model = PTBModel(False, EVAL_BATCH_SIZE, EVAL_NUM_STEP)with tf.Session() as sess:tf.global_variables_initializer().run()# 开启多线程从而支持ptb_producer()使用tf.train.range_input_producer()coord = tf.train.Coordinator()threads = tf.train.start_queue_runners(sess=sess, coord=coord)# 使用训练数据训练模型for i in range(NUM_EPOCH):print('In iteration: %d' % (i + 1))run_epoch(sess, train_model, train_queue, train_model.train_op,True, train_epoch_size)  # 训练模型valid_perplexity = run_epoch(sess, eval_model, valid_queue,tf.no_op(), False,valid_epoch_size)  # 使用验证数据评估模型print('Epoch: %d Validation Perplexity: %.3f' % (i + 1,valid_perplexity))# 使用测试数据测试模型test_perplexity = run_epoch(sess, eval_model, test_queue,tf.no_op(), False, test_epoch_size)print('Test Perplexity: %.3f' % test_perplexity)# 停止所有线程coord.request_stop()coord.join(threads)if __name__ == '__main__':tf.app.run()

运行结果如下：

$ python train.pyIn iteration: 1
After 0 steps,perplexity is 10054.757
After 100 steps,perplexity is 1403.731
......
After 1200 steps,perplexity is 460.833
After 1300 steps,perplexity is 442.765
Epoch: 1 Validation Perplexity: 270.200
In iteration: 2
After 0 steps,perplexity is 371.624
After 100 steps,perplexity is 266.044
......
After 1200 steps,perplexity is 248.459
After 1300 steps,perplexity is 245.637
Epoch: 2 Validation Perplexity: 215.167
Test Perplexity: 206.910

perplexity 运行结果为 207，表示预测下一个单词的范围是 207 个，可以通过调整 LSTM 隐藏层的节点个数和大小以及训练迭代的轮数降低。

3. 错误总结

新版本 TensorFlow 改了很多地方，下面是运行原书中的代码时出现的问题

3.1 没有 rnn_cell

出现如下错误：

module 'tensorflow.python.ops.nn' has no attribute 'rnn_cell'

是因为 tf.nn.rnn_cell 改成了 tf.contrib.rnn：

# 原代码
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)
if is_training:lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=KEEP_PROB)
cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * NUM_LAYERS)# 修改为
lstm_cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE)
if is_training:lstm_cell = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=KEEP_PROB)
cell = tf.contrib.rnn.MultiRNNCell([lstm_cell] * NUM_LAYERS)

3.2 tf.concat()参数位置

出现如下错误：

TypeError: Expected int32, got list containing Tensors of type '_Message' instead.

是因为 tf.concat 函数的参数位置换了一下：

# 原代码
output = tf.reshape(tf.concat(1, outputs), [-1, HIDDEN_SIZE])# 修改为
output = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE])

3.3 没有 seq2seq

出现如下错误：

AttributeError: module 'tensorflow.python.ops.nn' has no attribute 'seq2seq'

是因为 tf.nn.seq2seq.sequence_loss_by_example 修改成了 tf.contrib.legacy_seq2seq.sequence_loss_by_example：

# 原代码
loss = tf.nn.seq2seq.sequence_loss_by_example([logits],  [tf.reshape(self.targets, [-1])], [tf.ones([batch_size * num_steps], dtype=tf.float32)])# 修改为
loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example([logits],  [tf.reshape(self.targets, [-1])], [tf.ones([batch_size * num_steps], dtype=tf.float32)])

3.4 没有 ptb_iterator

出现如下错误：

AttributeError: module 'reader' has no attribute 'ptb_iterator'

是因为读取 PTB 数据集的 reader 将 ptb_iterator() 修改成了 ptb_producer()：

# 原代码
for step, (x, y) in enumerate(reader.ptb_iterator(data, model.batch_size, model.num_steps)):# 修改为
for step, (x, y) in enumerate(reader.ptb_producer(data, model.batch_size, model.num_steps)):

之后运行的时候，还会出现如下错误：

`Tensor` objects are not iterable when eager execution is not

可能是因为 ptb_producer() 返回的是 Tensor，所以不能用 numerate() 进行迭代，所以需要将获取 (x,y) 的操作抽取出来单独运行。

要修改代码，需要解决三个问题：

训练的次数。即 epoch_size 值的计算
(x,y) 的获取。即 reader.ptb_producer() 返回结果的格式
开启多线程。ptb_producer() 中使用了 tf.train.range_input_producer() 控制 (x,y) 的迭代

这些问题的答案都可以从 ptb_producer() 的源码中找到，以下是该函数的源码：

def ptb_producer(raw_data, batch_size, num_steps, name=None):"""Iterate on the raw PTB data.This chunks up raw_data into batches of examples and returns Tensors thatare drawn from these batches.Args:raw_data: one of the raw data outputs from ptb_raw_data.batch_size: int, the batch size.num_steps: int, the number of unrolls.name: the name of this operation (optional).Returns:A pair of Tensors, each shaped [batch_size, num_steps]. The second elementof the tuple is the same data time-shifted to the right by one.Raises:tf.errors.InvalidArgumentError: if batch_size or num_steps are too high."""with tf.name_scope(name, "PTBProducer", [raw_data, batch_size, num_steps]):raw_data = tf.convert_to_tensor(raw_data, name="raw_data", dtype=tf.int32)data_len = tf.size(raw_data)batch_len = data_len // batch_sizedata = tf.reshape(raw_data[0 : batch_size * batch_len],[batch_size, batch_len])epoch_size = (batch_len - 1) // num_stepsassertion = tf.assert_positive(epoch_size,message="epoch_size == 0, decrease batch_size or num_steps")with tf.control_dependencies([assertion]):epoch_size = tf.identity(epoch_size, name="epoch_size")i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue()x = tf.strided_slice(data, [0, i * num_steps],[batch_size, (i + 1) * num_steps])x.set_shape([batch_size, num_steps])y = tf.strided_slice(data, [0, i * num_steps + 1],[batch_size, (i + 1) * num_steps + 1])y.set_shape([batch_size, num_steps])return x, y

首先解决循环次数的问题，即计算 epoch_size。可以看到源码中的 epoch_size 即我们要求的循环次数：

......
data_len = tf.size(raw_data)
batch_len = data_len // batch_size
data = tf.reshape(raw_data[0 : batch_size * batch_len],[batch_size, batch_len])epoch_size = (batch_len - 1) // num_steps
......

所以我们也可以类似地求出训练、验证和测试的 epoch_size，如下所示：

# 计算一个epoch需要训练的次数
train_data_len = len(train_data)  # 数据集的大小
train_batch_len = train_data_len // TRAIN_BATCH_SIZE  # batch的个数
train_epoch_size = (train_batch_len - 1) // TRAIN_NUM_STEP  # 该epoch的训练次数valid_data_len = len(valid_data)
valid_batch_len = valid_data_len // EVAL_BATCH_SIZE
valid_epoch_size = (valid_batch_len - 1) // EVAL_NUM_STEPtest_data_len = len(test_data)
test_batch_len = test_data_len // EVAL_BATCH_SIZE
test_epoch_size = (test_batch_len - 1) // EVAL_NUM_STEP

然后解决第二个问题，即 (x,y) 的获取，从源码中可以看到直接返回的 x,y 元组，所以直接接收即可，如下所示：

x, y = reader.ptb_producer(data, model.batch_size, model.num_steps)

最后解决第三个问题，即开启多线程从而支持 ptb_producer() 使用 tf.train.range_input_producer()，如下所示：

# 开启多线程从而支持 ptb_producer() 使用 tf.train.range_input_producer()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)......# 停止所有线程
coord.request_stop()
coord.join(threads)

完整代码已经在文章中给出，也可以去 nl-modeling 查看。经历了这个问题之后，知道了要关注工具接口的改变，以免遇到不必要的麻烦，共勉。

3.5 不能压平字典，键不唯一

出现如下错误：

ValueError: Could not flatten dictionary: key Tensor("language_model/MultiRNNCellZeroState
/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros:0", shape=(20, 200), dtype=float32) is not unique.

这个问题我搜了很久都没找到答案，最后通过查看 GitHub 上 ptb_word_lm.py 的源码，和打印出 state 的值才发现了问题所在。

在程序中添加一行打印 state 的代码，然后查看输出：

# 打印state的值
print(state)# 输出如下
(LSTMStateTuple(c=array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],...,[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.]], dtype=float32), h=array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],...,[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.]], dtype=float32)), LSTMStateTuple(c=array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],...,[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.]], dtype=float32), h=array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],...,[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.],[ 0.,  0.,  0., ...,  0.,  0.,  0.]], dtype=float32)))

从输出中可以看到，state 是 LSTMStateTuple 的元组，而 LSTMStateTuple 里面包含了数组 c 和 h，简化一下就是：

(LSTMState(c,h),LSTMState(c,h)
)

这个 LSTMState 就是 LSTM 层中的状态的元组，再来输出它的结构看看是什么样的：

# 输出state的长度
print(len(state))# 输出LSTMState中c的形状
print(state[0].c.shape)# 输出LSTMState中h的形状
print(state[0].h.shape)# 输出结果
2
(20, 200)
(20, 200)

从输出中可以看到 state 包含了两层 LSTM 的状态，每个 LSTMState 都是 20×200 的数组。

因为我们设置一个 LSTM 隐藏层的规模为 200，所以每层 LSTM 的状态向量的大小是 200。而一个数据 batch 大小为 20，所以一共有 20×200 个参数。

而错误原因在于 feed_dict 中给出的键是不唯一，这句话没怎么看懂，可以输出 model.initial_state 看看到底怎么回事：

# 输出initial_state的值
print(model.initial_state)# 输出结果整理之后如下
(LSTMStateTuple(c=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros:0' shape=(20, 200) dtype=float32>, h=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros_1:0' shape=(20, 200) dtype=float32>), LSTMStateTuple(c=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros:0' shape=(20, 200) dtype=float32>, h=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros_1:0' shape=(20, 200) dtype=float32>)
)

可以看到两个 c 和两个 h 的名字是一样的，所以出现的上述错误。

目前我们现在要解决的问题有三个：

生成数据队列
将 x，y 放入 feed_dict
分别将 c，h 放入 feed_dict

首先生成数据队列，必须要将数据队列的声明放在启动多线程之前，不然会出现队列一直等待出队的状态，如下所示：

......
# 生成数据队列，必须放在开启多线程之前
train_queue = reader.ptb_producer(train_data, train_model.batch_size,train_model.num_steps)
valid_queue = reader.ptb_producer(valid_data, eval_model.batch_size,eval_model.num_steps)
test_queue = reader.ptb_producer(test_data, eval_model.batch_size,eval_model.num_steps)......# 开启多线程从而支持ptb_producer()使用tf.train.range_input_producer()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
......

然后生成 x，y 并放入 feed_dict 中，如下所示：

# 生成输入和答案
feed_dict = {}
x, y = session.run(data_queue)
feed_dict[model.input_data] = x
feed_dict[model.targets] = y

最后需要分别将 c，h 放入 feed_dict 中，可以从 ptb_word_lm.py 找到方法，如下所示：

# 将状态转为字典
for i, (c, h) in enumerate(model.initial_state):feed_dict[c] = state[i].cfeed_dict[h] = state[i].h# 获取损失值和下一个状态
cost, state, _ = session.run([model.cost, model.final_state, train_op], feed_dict=feed_dict)

完整代码已经在文章中给出，也可以去 nl-modeling 查看。这个问题网上目前没有详细的错误描述，也没有解决方法，连出现这个错误的人都很少，所以不太清楚错误的根本原因是什么。