tensorflow的写诗代码分析【转】

本文转载自：https://dongzhixiao.github.io/2018/07/21/so-hot/

    今天周六，早晨出门吃饭，全身汗湿透。天气真的是太热了！我决定一天不出门，在屋子里面休息！
晚上，腾飞给我说了他暑假的计划，决定去长沙、成都去转一圈，并邀请我去，还顺便叫我晚上去吃饭。
最后我们就一起吃了一顿饭，不过我估计我休息的时间是下下周，因此可能不能和他一起去了。

今天总结一下本周学习到的知识：

周一

在进行神经网络序列输入的时候，发现了一个很好的文件代码用来数据预处理。

注意：后面使用“数据单元”代表数据的一个最小单元，比如训练英文数据就可以代表一个字符——’a’，训练中文数据就可以代表一个汉字——’王’etc

文件名字叫做read_utils.py。该文件中实现了一个类TextConverter和一个工具函数batch_generator。

该文件是一个工具类，用于把一个输入文件根据编码输出对应的一批一批的数据用于RNN/LSTM之类的文本处理神经网络训练， 用法是先使用TextConverter类编码所有的内容为数据单元对应数字，然后使用batch_generator函数将编码好的数字分批返回 比如：

text = f.read()  #f是open后得到的文件指针
converter = TextConverter(text)
arr = converter.text_to_arr(text)
g = batch_generator(arr,num_seqs,num_steps)   #如果输入本来就是编码好的数据，则直接使用这个函数即可

下面让我们来一个一个学习一下。

TextConverter类

TextConverter类是用来将传入的文件中所有数据 首先，我们看看该类的构造函数。

class TextConverter(object): def __init__(self, text=None, max_vocab=5000, filename=None): if filename is not None: with open(filename, 'rb') as f: self.vocab = pickle.load(f) else: vocab = set(text) #存储读取文件中的数据单元所有类型的集合，比如英文文件会是：{'\n','A','b',...,'\r'} print(len(vocab)) #打印数据单元的种类的数目 # max_vocab_process vocab_count = {} #存储每一个数据单元在整个读入的文本中出现的次数的字典 for word in vocab: vocab_count[word] = 0 for word in text: vocab_count[word] += 1 vocab_count_list = [] #存储元组(数据单元，对应数量)组成的列表，然后按照数量的大小排序，比如[('a',100),('d',20),...,('x',3)] for word in vocab_count: vocab_count_list.append((word, vocab_count[word])) vocab_count_list.sort(key=lambda x: x[1], reverse=True) if len(vocab_count_list) > max_vocab: #根据传入的最大数量的数据单元数截断前max_vocab大的数据单元，基本上不可能，除非遇到汉字之类的文本 vocab_count_list = vocab_count_list[:max_vocab] vocab = [x[0] for x in vocab_count_list] self.vocab = vocab #vocab仅仅存储数据单元按照出现数量从大到小的列表，例如：['a','d',...,'x'] self.word_to_int_table = {c: i for i, c in enumerate(self.vocab)} # 数据单元到数字字典{' ':0,'e':1,...,'c':20,...} self.int_to_word_table = dict(enumerate(self.vocab)) # 数字到数据单元字典{0:‘ ’，1:'e',...,20:'c',..} 

可以看出，该构造函数的输入是(文本内容，最大词限制，文件名)。可以看出最后一个关键字参数filename是用来判断文件是否为空，从而直接读取 不用进入后面的处理环节，这个地方跟后面的保存模块对应的：

    def save_to_file(self, filename): #仅仅存储数据单元按照出现数量从大到小的列表到指定文件filename处，例如：['a','d',...,'x'] with open(filename, 'wb') as f: pickle.dump(self.vocab, f) 

保存后，以后就可以直接使用这个词表了。 如果没有传入文件名，则说明需要进行后续的处理，我们仔细看一下后面的代码，发现实际上做的工作就是：

• 找到所有数据中“数据单元”
• 遍历文件记录每个“数据单元”出现的次数，根据次数大小对“数据单元”排序
• 根据传入参数max_vocab截断数据单元，只去前max_vocab个“数据单元”
• 将留下的数据单元一一映射到自然数0,1,2…上

注意传入的text是一个列表或者列表生成器之类的数据结构，因为后面的代码把它这样子用了(比如去text的集合，用for迭代text等)。

在构造函数中已经实现了“数据单元”到自然数列的映射，因此互相转换的函数就显而易见了，如下所示：

    def word_to_int(self, word): #返回数据单元对应的整数 if word in self.word_to_int_table: return self.word_to_int_table[word] else: return len(self.vocab) #如果出现了没有出现的词，则变为<unk>对应的标记 def int_to_word(self, index): #返回整数对应的数据单元 if index == len(self.vocab): return '<unk>' #没有出现的词被标记为unknown的缩写 elif index < len(self.vocab): return self.int_to_word_table[index] else: raise Exception('Unknown index!') 

由上面的函数可知，在映射的时候如果词没有出现在词表中，则标记为<unk>返回，这个是非常重要的一个处理，因为在实际进行数据 输入的时候，由于截断引起的超出数据记录的词，或者在进行测试集的时候很有可能出现这种情况！

既然有了单个“数据单元”和自然数的映射，多个“数据单元”组成的列表当然也能相互转化：

    def text_to_arr(self, text): #将输入的text根据word_to_int返回得到对应的编码数，并构成np.ndarray并返回，例如：输入' a\n'，则返回类似array([ 0, 0, 4, 10]) arr = [] for word in text: arr.append(self.word_to_int(word)) return np.array(arr) def arr_to_text(self, arr): #输入列表类型的数据，返回对应的数据单元的组合 words = [] for index in arr: words.append(self.int_to_word(index)) return "".join(words) 

batch_generator

有了数据编码的类，下面就需要一个样本生成的函数了。 根据输入的数据(这个输入一般就是全部样本组成的文本，并且已经根据所有数据单元编码成为了数字列表)， 返回对应的生成器，满足输入的序列个数和序列长度

def batch_generator(arr, n_seqs, n_steps): #根据输入的arr(这个输入一般就是全部样本组成的文本，并且已经根据所有数据单元编码成为了数字列表)，返回对应的生成器，满足输入的序列个数和序列长度 arr = copy.copy(arr) batch_size = n_seqs * n_steps #计算没次输入需要使用的数据单元 n_batches = int(len(arr) / batch_size) #一共可以得到多少组输入数据 arr = arr[:batch_size * n_batches] #直接忽略了后面不能构成一组输入的数据！ arr = arr.reshape((n_seqs, -1)) while True: np.random.shuffle(arr) #将所有行打乱顺序 for n in range(0, arr.shape[1], n_steps): x = arr[:, n:n + n_steps] #每次选择对应n_seqs行，n_steps列的数据 y = np.zeros_like(x) #返回跟x同形状的n维数组，数据全部都是0 y[:, :-1], y[:, -1] = x[:, 1:], x[:, 0] yield x, y 

可以看出，该函数根据输入的所有训练数据，和对应的序列一批的个数(n_seqs)和每个输入的序列的长度(n_steps)，然后 通过生成器函数不断的迭代取出来数据用于训练。每一个输入和输出的序列刚错开一位，比如：

#如果输入的x是[[48 49 50]
#             [ 0  1  2]]
# 则输出的y是[[49 50 48]
#            [ 1  2  0]]

周二

文件名字叫做model.py。该文件中实现了一个类CharRNN和一个工具函数pick_top_n。

CharRNN

下面介绍模型类，这个模型使用的是TensorFlow模块，然后进行网络的搭建，首先看构造函数：

class CharRNN:
    def __init__(self, num_classes, num_seqs=64, num_steps=50, lstm_size=128, num_layers=2, learning_rate=0.001, grad_clip=5, sampling=False, train_keep_prob=0.5, use_embedding=False, embedding_size=128): if sampling is True: num_seqs, num_steps = 1, 1 else: num_seqs, num_steps = num_seqs, num_steps self.num_classes = num_classes self.num_seqs = num_seqs #序列个数 self.num_steps = num_steps #序列长度 self.lstm_size = lstm_size self.num_layers = num_layers self.learning_rate = learning_rate self.grad_clip = grad_clip self.train_keep_prob = train_keep_prob self.use_embedding = use_embedding self.embedding_size = embedding_size tf.reset_default_graph() self.build_inputs() #构建输入层 self.build_lstm() #构建LSTM层 self.build_loss() #构建损失函数 self.build_optimizer() #构建优化器 self.saver = tf.train.Saver() #保存设置 #下面测试，增加总结 tf.summary.scalar('loss',self.loss) for var in tf.trainable_variables(): tf.summary.histogram(var.op.name, var) self.merge_summary = tf.summary.merge_all() self.train_writer = tf.summary.FileWriter('./model') self.train_writer.add_graph(tf.get_default_graph()) 

可以看出，该构造函数根据输入的参数，搭建了一个R输入-R输出的神经网络，隐状态用的是LSTM模型。 首先先保存各个输入的设定，然后分别构建各个层和优化保存相关的设置，我们一个一个看：

    def build_inputs(self): with tf.name_scope('inputs'): self.inputs = tf.placeholder(tf.int32, shape=( self.num_seqs, self.num_steps), name='inputs') self.targets = tf.placeholder(tf.int32, shape=( self.num_seqs, self.num_steps), name='targets') self.keep_prob = tf.placeholder(tf.float32, name='keep_prob') # 对于中文，需要使用embedding层 # 英文字母没有必要用embedding层 if self.use_embedding is False: self.lstm_inputs = tf.one_hot(self.inputs, self.num_classes) else: with tf.device("/cpu:0"): embedding = tf.get_variable('embedding', [self.num_classes, self.embedding_size]) self.lstm_inputs = tf.nn.embedding_lookup(embedding, self.inputs) 

上面的函数就是输入层，可以看出，根据输入的参数embedding来确定输入层是否增加一个嵌入层，显然，如果数据的词表 比较大，比如中文，就需要嵌入层降维，如果比较小，就可以不用嵌入层。

然后是LSTM层：

    def build_lstm(self): # 创建单个cell并堆叠多层 def get_a_cell(lstm_size, keep_prob): lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_size) drop = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=keep_prob) return drop with tf.name_scope('lstm'): cell = tf.nn.rnn_cell.MultiRNNCell( [get_a_cell(self.lstm_size, self.keep_prob) for _ in range(self.num_layers)] ) self.initial_state = cell.zero_state(self.num_seqs, tf.float32) # 通过dynamic_rnn对cell展开时间维度 self.lstm_outputs, self.final_state = tf.nn.dynamic_rnn(cell, self.lstm_inputs, initial_state=self.initial_state) # 通过lstm_outputs得到概率 seq_output = tf.concat(self.lstm_outputs, 1) x = tf.reshape(seq_output, [-1, self.lstm_size]) with tf.variable_scope('softmax'): softmax_w = tf.Variable(tf.truncated_normal([self.lstm_size, self.num_classes], stddev=0.1)) softmax_b = tf.Variable(tf.zeros(self.num_classes)) self.logits = tf.matmul(x, softmax_w) + softmax_b self.proba_prediction = tf.nn.softmax(self.logits, name='predictions') 

可以看出，LSTM层使用的是多层，层数根据参数self.num_layers确定LSTM的隐层的层数。然后得到输出使用的是softmax激活函数，可以 得到输出的每一个类别的概率。

之后是损失和优化：

 def build_loss(self): with tf.name_scope('loss'): y_one_hot = tf.one_hot(self.targets, self.num_classes) y_reshaped = tf.reshape(y_one_hot, self.logits.get_shape()) loss = tf.nn.softmax_cross_entropy_with_logits(logits=self.logits, labels=y_reshaped) self.loss = tf.reduce_mean(loss) def build_optimizer(self): # 使用clipping gradients tvars = tf.trainable_variables() grads, _ = tf.clip_by_global_norm(tf.gradients(self.loss, tvars), self.grad_clip) train_op = tf.train.AdamOptimizer(self.learning_rate) self.optimizer = train_op.apply_gradients(zip(grads, tvars)) 

损失使用的就是一般常用的交叉熵损失，优化则使用的是比较著名的自适应优化器adam

之后就可以开始训练了：

    def train(self, batch_generator, max_steps, save_path, save_every_n, log_every_n): self.session = tf.Session() with self.session as sess: sess.run(tf.global_variables_initializer()) # Train network step = 0 new_state = sess.run(self.initial_state) for x, y in batch_generator: step += 1 start = time.time() feed = {self.inputs: x, self.targets: y, self.keep_prob: self.train_keep_prob, self.initial_state: new_state} batch_loss, new_state, _ , train_summary = sess.run([self.loss, self.final_state, self.optimizer, self.merge_summary], feed_dict=feed) end = time.time() # control the print lines if step % log_every_n == 0: print('step: {}/{}... '.format(step, max_steps), 'loss: {:.4f}... '.format(batch_loss), '{:.4f} sec/batch'.format((end - start))) self.train_writer.add_summary(train_summary, step) if (step % save_every_n == 0): self.saver.save(sess, os.path.join(save_path, 'model'), global_step=step) if step >= max_steps: break self.saver.save(sess, os.path.join(save_path, 'model'), global_step=step) 

可以看出，训练就是根据前面搭建的网络和生成的样本，往里面不断的喂数据。然后将结果不断保存。

训练好模型后，我们就可以读取保存好的模型：

    def load(self, checkpoint): self.session = tf.Session() self.saver.restore(self.session, checkpoint) print('Restored from: {}'.format(checkpoint)) 

读取了保存好模型中的各种参数后，就看一通过这个网络生成样本：

    def sample(self, n_samples, prime, vocab_size): #n_samples：一共输出多少个基本单元；prime：开始的几个基本单元；vocab_size：一共有多少个类型的基本单元+1(未知数据编码) samples = [c for c in prime] sess = self.session new_state = sess.run(self.initial_state) preds = np.ones((vocab_size, )) # for prime=[] for c in prime: #根据输入的“基本单元”的多少，不断更新状态，直到最后的输入为止！真好的实现！ x = np.zeros((1, 1)) # 输入单个字符 x[0, 0] = c feed = {self.inputs: x, self.keep_prob: 1., self.initial_state: new_state} #每次输入时更新状态即可达到连续的效果，对应LSTM状态是元组(c,h) preds, new_state = sess.run([self.proba_prediction, self.final_state], feed_dict=feed) c = pick_top_n(preds, vocab_size) # 添加字符到samples中 samples.append(c) # 不断生成字符，直到达到指定数目 for i in range(n_samples): x = np.zeros((1, 1)) x[0, 0] = c feed = {self.inputs: x, self.keep_prob: 1., self.initial_state: new_state} preds, new_state = sess.run([self.proba_prediction, self.final_state], feed_dict=feed) c = pick_top_n(preds, vocab_size) samples.append(c) return np.array(samples) 

注意这个函数是根据输入的前几个自然数序列(已经通过“基本单元”映射为自然数了)，预测下一个输出的对应自然数。 其中第一个for循环出色的使用了权重共享的思想，使用sample这个函数的时候使得在构造函数时sample这个参数为True。 然后一个一个的将“基本单元”映射后的自然数输入，这样每次仅更新隐状态输出的状态参数。 之后第二个for循环依次生成后续的一个一个自然数。

pick_top_n

在上一小节的最后一个sample函数中，用到了pick_top_n函数，这个函数的内容如下：

def pick_top_n(preds, vocab_size, top_n=5): p = np.squeeze(preds) #squeeze函数从数组的形状中删除单维度条目，即把shape中为1的维度去掉 # 将除了top_n个预测值的位置都置为0 p[np.argsort(p,kind = 'mergesort')[:-top_n]] = 0 #argsort函数可以按照给定方法排序 # 归一化概率 p = p / np.sum(p) # 随机选取一个字符 c = np.random.choice(vocab_size, 1, p=p)[0] return c 

可以看出，该函数通过输入的各个序列的概率，然后根据n取得概率前几个最大的概率，之后通过这些概率进行归一化，然后得到留下来 的数字序列对应的概率分布律，最后通过np.random.choice按照各个字符的分布律来随机选择一个字符并返回。

周三

预测和精度

今天，通过前两天的代码的学习，我今天将我需要用到的数据序列通过read_utils.py预处理，之后放到model.py里面进行训练。 之后设置了20000步的训练，结果发现可以成功运行并根据输入生成一系列新的输出，但是我希望能够直接得到下一个字符的概率，因此 可以按照如下的方式进行实现：

也可以通过这个网络预测下一个出现的“数据单元”的概率：

    def prediction_next_n(self,prime,vocab_size,next_n =3 , **k): #prime：开始的几个基本单元；vocab_size：一共有多少个类型的基本单元+1(未知数据编码) # samples = [c for c in prime] sess = self.session new_state = sess.run(self.initial_state) preds = np.ones((vocab_size,)) # for prime=[] for c in prime: # 根据输入的“基本单元”的多少，不断更新状态，直到最后的输入为止！真好的实现！ x = np.zeros((1, 1)) # 输入单个字符 x[0, 0] = c feed = {self.inputs: x, self.keep_prob: 1., self.initial_state: new_state} # 每次输入时更新状态即可达到连续的效果，对应LSTM状态是元组(c,h) preds, new_state = sess.run([self.proba_prediction, self.final_state], feed_dict=feed) p = np.squeeze(preds) #squeeze函数从数组的形状中删除单维度条目，即把shape中为1的维度去掉 # 将next_n个最大的概率的位置得到 next_n_num = np.argsort(p,kind = 'mergesort')[-next_n:] #argsort函数可以按照给定方法排序 #返回的应该是标号和对应的概率值 s_p_d = [] for i in next_n_num: s_p_d.append((i,p[i])) return s_p_d 

返回的这个各个自然数的概率，就可以进行预测生成新的数据对应的结果了。

为了后续的测试，我需要得到精度，因此实现一个计算精度的函数：

    def get_accuracy(self,dualList,vocab_size,next_n =3): #输入的序列满足有开始的标记，没有结尾的标记 success_num = 0 for one_session in dualList: if one_session[-1] in self.prediction_next_n(one_session[:-1],vocab_size,next_n): success_num = success_num + 1 print(success_num,len(dualList)) print('精度是:%.4f' % (success_num/len(dualList)) ) 

TensorBoard的使用

为了将所有数据都显示出来，我使用了TensorBoard进行显示。