使用TensorFlow动手实现一个Char-RNN

朴灿烈づ我的快乐病毒、 2021-11-10 03:24 221阅读 0赞

https://blog.csdn.net/thriving\_fcl/article/details/72565455

## 前言 ##

学习RNN的时候很多人应该都有看过Andrej Karpathy写的[The Unreasonable Effectiveness of Recurrent Neural Networks][]，使用基于字符粒度的RNN让机器学会自己生成文本，比如令自己训练的RNN学会写歌词、写代码、写小说、写诗，听着就很新奇。

github上虽然已经有实现好的Char RNN，比如   
1. [https://github.com/karpathy/char-rnn][https_github.com_karpathy_char-rnn]   
2. [https://github.com/crazydonkey200/tensorflow-char-rnn][https_github.com_crazydonkey200_tensorflow-char-rnn]

但是想要学习，最好的方式就是自己动手实现一遍。自己写一遍好处还是很多的，比如加深对RNN(LSTM)的理解，可以熟悉深度学习的框架。因为我主要用tensorflow，所以就基于tensorflow实现了一遍Char-RNN。

注：本文使用的tensorflow版本为1.0.0

个人经验，在实现的过程中最好是抛开别人代码的影响，只根据基本理论以及所用的框架的API文档一步步把代码写出来跑通，这样自己的收益才是最大的。

## 模型选择 ##

要让机器生成文本，本质上是需要一个语言模型。语言模型可以用来评估一句话是自然语言的概率，即根据一句话中已观测到的词，预测下一个词出现的概率。也就是要能够处理序列数据，根据已有的序列数据，推断接下来可能的数据。如一句话“已经到了午餐时间，我正准备去吃\{?\}”，根据前面的描述，可以推断“吃”字背后是要接上可食用的东西，并且是可以作为午餐的，可能是“饭”、“面”等等，通常不可能是“汽车”、“树木”之类…因此我们需要一个能够处理序列数据，并且能够抽象出过去序列与任务相关方面的信息，再根据这些信息预测未来的模型。

神经网络中，RNN天然适合用于处理序列数据，它可以提取任意长度序列(x(t),x(t−1),...,x(1))(x(t),x(t−1),...,x(1))的摘要，选择性地精确保留过去序列的某些方面。而保留这些信息的方式则是通过RNN内部的隐藏状态。

但是RNN又有很多变体，因为基本RNN只有一个隐藏状态，对长距离的记忆效果不好，在模型参数迭代优化的时候存在梯度弥散的问题，因此又有了采用LSTM单元的RNN以及其他的变体，如GRU等等。

因此，在Char RNN的实践当中，就选用LSTM作为基本的模型。

因为tensorflow中已经实现了LSTM的单元，如果不是为了学习LSTM的原理，可以不需要自己去实现它。相应的API为

tf.contrib.rnn.LSTMCell()

*  1

## 模型定义 ##

我们需要定义一个class用来定义网络的结构，以及实现inference的接口。如果初次接触RNN，刚开始动手写的时候可能会一头雾水，我们已经有了LSTM的API，怎么把它拓展成可以接受文本的训练数据进行训练，最后再根据输入的一些文字，输出接下来文字的模型呢？

我的做法是先明确输入与输出，以及我所知道的必备要素，然后再把它们衔接拼凑起来。

### 基本LSTM单元 ###

首先我们要用到LSTMCell，它的必填参数是num\_units，也就是每个LSTM Cell中的单元数，与输入向量的维度是一致的。我们的输入是词向量，维度是我们自己定义的，这里用一个参数`rnn_size`来表示。定义基本LSTM Cell的代码如下

# 定义基本lstm单元 lstm_cell_list = [tf.contrib.rnn.LSTMCell(rnn_size) for _ in xrange(layer_size)] # 使用MultiRNNCell 接口连接多层lstm， 并加上dropout self.cell = tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.MultiRNNCell(lstm_cell_list), output_keep_prob=output_keep_prob)

*  1
 *  2
 *  3
 *  4

### 明确输入 ###

在训练的过程中，每次都feed进一个batch的数据，batch的大小也是我们定义的，用`batch_size`表示，因此LSTM模型所接受输入的shape为`(batch_size, rnn_size)`。

如果我们使用预训练好的词向量作为输入，那么这里就可以写成

tf.input_data = tf.placeholder(tf.float32, shape=[batch_size, rnn_size], name='input_data')

*  1

但我们希望词向量可以在train的过程中被改变，更适应我们的训练数据。那就要用`Variable`来表示词向量矩阵。因此我们要定义一个变量来表示，词向量矩阵的维度应该是 `vocab_size * rnn_size`。 即每一行代表一个词，列数就是我们需要自己定义的词向量维度。定义了词向量矩阵的变量，每次输入的时候，还需要为输入的词找到对应的词向量，这些tensorflow都为我们封装好了，代码如下

embedding = tf.Variable(tf.truncated_normal([vocab_size, rnn_size], stddev=0.1), name='embedding') inputs = tf.nn.embedding_lookup(embedding, self.input_data)

*  1
 *  2

`tf.nn.embedding_lookup`这个函数就是用于返回所查找的词向量Tensor的。

> embedding\_lookup(params, ids, partition\_strategy=’mod’, name=None, validate\_indices=True, max\_norm=None)

其中`params`是词向量矩阵，`ids`是需要需要查找的词的id。举个简单的例子如下

# 假设有词向量空间x x = [[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]] vx = tf.Variable(x, name='vx') ids = tf.placeholder(tf.int32, name='ids') inputs = tf.nn.embedding_lookup(vx, ids) # 假如每个batch有3个句子，每个句子有两个词，词的id如下 input_data = [[0,1],[1,2],[0,2]] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) sess.run(inputs, feed_dict={ids:input_data}) # 输出结果如下 >>> array([[[ 1., 2., 3.], [ 4., 5., 6.]], [[ 4., 5., 6.], [ 7., 8., 9.]], [[ 1., 2., 3.], [ 7., 8., 9.]]], dtype=float32) 输出结果的shape为(3,2,3)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25

用上述方式就可以查出来一个batch中每个句子的每个词对应的词向量。所以我们原始输入的batch中，每个元素是一个sequence，sequence中的元素又是每个词对应的id。

这部分的完整代码如下

self.input_data = tf.placeholder(tf.int32, shape=[batch_size, sequence_length], name='input_data') # 指定这部分使用CPU进行计算 with tf.device('/cpu:0'): embedding = tf.Variable(tf.truncated_normal([vocab_size, rnn_size], stddev=0.1), name='embedding') inputs = tf.nn.embedding_lookup(embedding, self.input_data)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

### 明确输出 ###

因为在Char RNN中，每一时刻的输出都是下一时刻的输入，因此LSTM的输出otot与输入xtxt维度是一样的。但otot并不是Char RNN模型的输出，otot之后还需要跟全连接层以及softmax层来判断每个词出现的概率。每一时刻都有一个输出，在训练的阶段，需要收集每一时刻的输出，以便与targets进行比较来计算loss。因此需要有一个循环来展开整个lstm。展开的这部分tensorflow也有API可以调用，但是为了更好的理解，还是自己实现一遍比较好。代码如下

# 定义初始状态 self.initial_state = self.cell.zero_state(batch_size, tf.float32) with tf.variable_scope('RNN'): for time_step in xrange(sequence_length): # 因为LSTM Cell调用__call__()方法时，会使用到get_variable()获取内部变量 # 如果reuse的flag是False，调用get_variable()后会查找该variable_scope中有没有重名的变量，如果有就报错 # 如果reuse的flag是True，调用get_variable()后则是在当前的variable_scope找不到变量时报错 # 因此在这部分需要reuse的时候要定义一个variable_scope，否则之后想用get_variable()定义新变量都会报错 if time_step > 0: tf.get_variable_scope().reuse_variables() if time_step == 0: output, state = self.cell(inputs[:, time_step, :], self.initial_state) else: output, state = self.cell(inputs[:, time_step, :], state) outputs.append(output) self.final_state = state softmax_w = tf.Variable(tf.truncated_normal([rnn_size, vocab_size], stddev=0.1), name='softmax_w') softmax_b = tf.Variable(tf.zeros([vocab_size]), name='softmax_b') # 执行完循环以后，outputs的shape=(sequence_length, batch_size, rnn_size) # 而matmul接受的矩阵的rank必须是2，因此还需要做一下转换 # tf.concat()转换后的outputs的shape为(batch_size * sequence_size, rnn_size) outputs = tf.concat(outputs, 0) self.logits = tf.matmul(outputs, softmax_w) + softmax_b self.prob = tf.nn.softmax(self.logits)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27

### 定义loss与train\_op ###

要定义loss函数首先要有正确的输入，因此先定义targets。在实际feed的时候，要注意targets中的顺序必须与outputs中预测结果是对应的。这个之后写一个辅助函数来对输入的targets进行转换。

loss函数的定义使用cross\_entropy，tensorflow中有相应的API `tf.losses.softmax_cross_entropy`， 这个API封装了softmax步骤，因此应该传入logits而不是把softmax之后的prob传进去。

定义完loss之后就需要定义optimizer与train\_op。

通常可以直接`train_op = tf.train.AdamOptimizer(self.lr).minimize(self.cost)`。但是RNN的训练中很有可能因为梯度过大导致训练过程不稳定而不收敛，因此需要对计算出的梯度做一步裁剪，再手动更新梯度。

这部分的代码如下

self.targets = tf.placeholder(tf.int32, shape=[None, vocab_size], name='targets') self.cost = tf.losses.softmax_cross_entropy(self.targets, self.logits) self.lr = tf.Variable(0.0, trainable=False) tvars = tf.trainable_variables() grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars), grad_clip) optimizer = tf.train.AdamOptimizer(self.lr) self.train_op = optimizer.apply_gradients(zip(grads, tvars))

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9

到这里为止Char RNN的主要部分，即模型的结构及其训练所需的op都定义完成了，train与inference部分的代码都大同小异，就不特别说明了。

转载于:https://www.cnblogs.com/DjangoBlog/p/9504807.html

[The Unreasonable Effectiveness of Recurrent Neural Networks]: http://karpathy.github.io/2015/05/21/rnn-effectiveness/
[https_github.com_karpathy_char-rnn]: https://github.com/karpathy/char-rnn
[https_github.com_crazydonkey200_tensorflow-char-rnn]: https://github.com/crazydonkey200/tensorflow-char-rnn