本文转载自：https://www.jianshu.com/p/1a4f7f5b05ae

致谢以及参考

最近在做序列化标注项目，试着理解rnn的设计结构以及tensorflow中的具体实现方法。在知乎中找到这篇文章，具有很大的帮助作用，感谢作者为分享知识做出的努力。

学习目标定位

我主要重点在于理解文中连接所提供的在github上的project代码，一句句理解数据的预处理过程以及rnn网络搭建过程（重点在于代码注释，代码改动很小，实用python3）。（进入下面环节之前，假设你已经阅读了知乎上的关于rnn知识讲解篇幅，project的readme文档）

数据预处理

1. 理解模型大概需要的重要参数：/Char-RNN-TensorFlow-master/train.py

# encoding: utf-8

import tensorflow as tf
from model import CharRNN
import os
import codecs  # 相比自带的open函数 读取写入进行自我转码
from read_utils import TextConverter, batch_generator

FLAGS = tf.flags.FLAGS
#  变量定义 以及 默认值
tf.flags.DEFINE_string('name', 'default', 'name of the model')
tf.flags.DEFINE_integer('num_seqs', 100, 'number of seqs in one batch')    # 一个 batch 可以组成num_seqs个输入信号序列
tf.flags.DEFINE_integer('num_steps', 100, 'length of one seq')             # 一个输入信号序列的长度， rnn网络会更具输入进行自动调整
tf.flags.DEFINE_integer('lstm_size', 128, 'size of hidden state of lstm')  # 隐藏层节点数量，即lstm 的 cell中state数量
tf.flags.DEFINE_integer('num_layers', 2, 'number of lstm layers')          # rnn的深度
tf.flags.DEFINE_boolean('use_embedding', False, 'whether to use embedding')  # 如果中文字符则需要一个word2vec， 字母字符直接采用onehot编码
tf.flags.DEFINE_integer('embedding_size', 128, 'size of embedding')          # 使用word2vec的 中文字符的嵌入维度选取
tf.flags.DEFINE_float('learning_rate', 0.001, 'learning_rate')
tf.flags.DEFINE_float('train_keep_prob', 0.5, 'dropout rate during training')
tf.flags.DEFINE_string('input_file', '', 'utf8 encoded text file')           # --input_file data/shakespeare.txt
tf.flags.DEFINE_integer('max_steps', 100000, 'max steps to train')
tf.flags.DEFINE_integer('save_every_n', 1000, 'save the model every n steps')
tf.flags.DEFINE_integer('log_every_n', 10, 'log to the screen every n steps')
# 不同于英文字符比较短几十个就能解决，中文字符比较多，word2vec层之前输入需要进行onehot编码，根据字符频数降序排列取前面的3500个编码
tf.flags.DEFINE_integer('max_vocab', 3500, 'max char number')

1. 理解main函数中数据预处理部分, 数据预处理主要采用TextConverter类

def main(_):
model_path = os.path.join('model', FLAGS.name)
print("模型保存位置（根据模型命名）", model_path)
if os.path.exists(model_path) is False:
os.makedirs(model_path)
with codecs.open(FLAGS.input_file, encoding='utf-8') as f:
print("建模训练数据来源：", FLAGS.input_file)
text = f.read()
converter = TextConverter(text,  # string     # 返回一个整理文本词典的类
FLAGS.max_vocab)
print("构建该文本的字符集合数量(包含未登录词：)：", converter.vocab_size)
print("建模所用字符保存地址位置（list）： ", os.path.join(model_path, 'converter.pkl'))  # 用来建模词汇的 前max_vocab个
converter.save_to_file(os.path.join(model_path, 'converter.pkl'))

arr = converter.text_to_arr(text)
# batch生成函数：返回一个生成器

• TextConverter类：\Char-RNN-TensorFlow-master\read_utils.py
  比如 莎士比亚训练数据用vocab组成：{v} {'} {[} {t} {u} {R} {W} {x} {?} { } {F} {I} {G} {O} {E} {$} {y} {e} {:} {L} {s} {c} {g} {Y} {]} {h} {w} {-} {a} {S} {J} {q} {V} {3} {X} {p} {T} {!} {C} {n} {;} {r} {M} {j} {f} {U} {d} {Q} {K} {b} {m} {H} {Z} {o} {i} {P} {D} {.} {l} {&} {N} {z} {A} {,} {
  } {B} {k}

class TextConverter(object):
def __init__(self, text=None, max_vocab=5000, filename=None):
"""

:param text: string
:param max_vocab:
:param filename:
"""
if filename is not None:
# 如果存在 字典文件，即将字符集合进行编号的字典
with open(filename, 'rb') as f:
self.vocab = pickle.load(f)
else:
vocab = set(text)  # 组成text的所有字符，比如， i see you， 那么就是 i s e y o u
logging.info('组成文本的字符集合:')
logging.info("数量： %d" % len(vocab))
s = ' '.join(["{%s}" % v for v in vocab])
logging.info("vocab: %s" % s)

# max_vocab_process
vocab_count = defaultdict(int)     # 这里相对原始代码做了小小优化
# 统计所有字符的频数
for word in text:
vocab_count[word] += 1
vocab_count_list = list(vocab_count.items())
vocab_count_list.sort(key=lambda x: x[1], reverse=True)  # 根据频数降序排序
if len(vocab_count_list) > max_vocab:
vocab_count_list = vocab_count_list[:max_vocab]  # 截取最大允许部分
vocab = [x[0] for x in vocab_count_list]  # 截取 前max_vocab
self.vocab = vocab
# 对vocab进行编序
self.word_to_int_table = {c: i for i, c in enumerate(self.vocab)}  # 词汇进行编序号
self.int_to_word_table = dict(enumerate(self.vocab))

@property   # 这个实现直接，将vocab_size作为一个变量成员调用而不是方法
def vocab_size(self):
return len(self.vocab) + 1  # 加上一个未登录词

def word_to_int(self, word):
# 更具给定的字符返回index
if word in self.word_to_int_table:
return self.word_to_int_table[word]
else:
# 未登录词 就是最后一个序号
return len(self.vocab)

def int_to_word(self, index):
# 根据给定indx返回字符
if index == len(self.vocab):
return '<unk>'  # 未登录词
elif index < len(self.vocab):
return self.int_to_word_table[index]
else:
raise Exception('Unknown index!')

def text_to_arr(self, text):
# 将文本序列化：字符转化为index
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)

def save_to_file(self, filename):
# 存储词典
with open(filename, 'wb') as f:
pickle.dump(self.vocab, f)

1. 准备batch用于训练

# batch生成函数：返回一个生成器
print("训练文本长度：", len(arr))
print("num_seqs:", FLAGS.num_seqs)
print("num_steps", FLAGS.num_steps)
g = batch_generator(arr,   # 输入信号文本序列
FLAGS.num_seqs,   # batch 信号序列数量
FLAGS.num_steps)  # 一个信号序列的长度

• 重点在于理解batch_generator函数， 这个过程的理解需要理解生成文本的rnn的输出和输入是什么样的（N vs N， 输出和输入数目是一致的）

• 一个单层的展开如下： 展开后h的节点个数取决于你的输入序列向量的长度，即输入文本的长度，图片来源于简书，这个链接可以帮助你很好从数学公式上理解。
    image.png

一个文本序列输入展示（这里为了直观的展示没有将文本数字化， 例如真正的"床"的输入应该为一个embeding的向量， 而输出“前”也是一个与输入一致的长度向量）


  image.png

/read_utils.py 的batch_generator函数

def batch_generator(arr, n_seqs, n_steps):
"""
生成训练用的batch
:param arr:
:param n_seqs:
:param n_steps:
:return:
"""
arr = copy.copy(arr)                    # 序列
batch_size = n_seqs * n_steps           # 一个batch需要的字符数量
n_batches = int(len(arr) / batch_size)  # 整个文本可以生成的batch总数
arr = arr[:batch_size * n_batches]      # 截取下 以便reshape成array
arr = arr.reshape((n_seqs, -1))         # 将batch， reshape成n_seqs行， 每行为一输入信号序列（序列长度为n_steps）
while True:
np.random.shuffle(arr)  # 打乱文本序列顺序
print(arr)
for n in range(0, arr.shape[1], n_steps):
x = arr[:, n:(n + n_steps)]
y = np.zeros_like(x)
y[:, :-1], y[:, -1] = x[:, 1:], x[:, 0]  #
yield x, y

• 测试下原来的代码的结果

arr = np.arange(27)
for x, y in batch_generator(arr, 4, 3):
print(x)
print(y)
break

• out-put： 以 6 7 8为例， 给出一个6， 生成文本的长度为3。将6对应的输出7作为下一个state的输入，输出8， 然后依次这么进行下去，y应该为7，8， 9。说明一下的是最后一个输出为啥为6 ，前面一个链接存在解释。

0-26序列进行生成序列操作，每批训练batch序列总数为4， 每个写的长度为3
打乱排序的结果
[[ 6  7  8  9 10 11]
[ 0  1  2  3  4  5]
[18 19 20 21 22 23]
[12 13 14 15 16 17]]
x
[[ 6  7  8]
[ 0  1  2]
[18 19 20]
[12 13 14]]
y
[[ 7  8  6]
[ 1  2  0]
[19 20 18]
[13 14 12]]

rnn 模型搭建

为了更好的理解这个过程下面是实际整个rnn的结构展开展示，如有错误请指出:
代码中构建2层的rnn，每个state（方块）的有两个一样的输出h，得到输出前有个softmax处理。

  image.png

• train.py中main函数调用rnn部分代码

model = CharRNN(converter.vocab_size,           # 分类的数量
num_seqs=FLAGS.num_seqs,        # 一个batch可以组成num_seq个信号
num_steps=FLAGS.num_steps,      # 一次信号输入RNN的字符长度，与一层的cell 的数量挂钩
lstm_size=FLAGS.lstm_size,      # 每个cell的节点数量：
num_layers=FLAGS.num_layers,    # RNN 的层数
learning_rate=FLAGS.learning_rate,  # 学习速率
train_keep_prob=FLAGS.train_keep_prob,
use_embedding=FLAGS.use_embedding,
embedding_size=FLAGS.embedding_size)
model.train(g,
FLAGS.max_steps,
model_path,
FLAGS.save_every_n,
FLAGS.log_every_n,)

• 重点在于model.py中的CharRNN类的调用

• 搭建rnn隐藏层
  整个过程的理解在备注带代码里面，暂时不用关注类里面，sample函数

# coding: utf-8

from __future__ import print_function
import tensorflow as tf
import numpy as np
import time
import os

def pick_top_n(preds, vocab_size, top_n=5):
p = np.squeeze(preds)
# 将除了top_n个预测值的位置都置为0
p[np.argsort(p)[:-top_n]] = 0
# 归一化概率
p = p / np.sum(p)
# 随机选取一个字符
c = np.random.choice(vocab_size, 1, p=p)[0]
return c

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()
self.build_loss()
self.build_optimizer()
self.saver = tf.train.Saver()

def build_inputs(self):
# 定义下输入，输出等，占位
with tf.name_scope('inputs'):
# 输入是一个3维度矩阵，但是这里并不要过多关注每个节点输入特征的维度，中文字符额embeding或者因为字符的onehot编码。
# 模型会自动识别和调整，暂时考虑每一个batch被reshape成 num_seqs * num_steps, 每一行为一个序列输入信号
self.inputs = tf.placeholder(tf.int32, shape=(
self.num_seqs, self.num_steps), name='inputs')

# N vs N： 输出与输入一致
self.targets = tf.placeholder(tf.int32, shape=(
self.num_seqs, self.num_steps), name='targets')  # N vs N

self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')

# 对于中文，需要使用embedding层: ???
# 英文字母没有必要用embedding层: ???
if self.use_embedding is False:
# 对字字符进行onehot编号
self.lstm_inputs = tf.one_hot(self.inputs, self.num_classes)
else:
with tf.device("/cpu:0"):
#  嵌入维度层word2vec和RNN连接器；起来同时训练 作为模型的第一层
# 先进行onehot编码然后， word2vec 所以额输入信号维度为num_classes
embedding = tf.get_variable('embedding', [self.num_classes, self.embedding_size])
self.lstm_inputs = tf.nn.embedding_lookup(embedding, self.inputs)

def build_lstm(self):
# 创建单个cell并堆叠多层
def get_a_cell(lstm_size, keep_prob):
"""
返回一个cell
:param lstm_size: cell的states数量
:param keep_prob: 节点保留率
:return:
"""
lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_size)    # state并不是采用普通rnn 而是lstm
drop = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=keep_prob)   # 对每个state的节点数量进行dropout
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)]
)
# 定义h_0
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得到概率
# 每个batch的输出为lstm_outputs: num_seqs * num_steps * state_node_size(中文字符嵌入维度或英文的onehot编码维度)
# 将输出进行拼接 dim=1  # seq out应该为 num_steps * (num_seqs * state_node_size), 即没每个输入信号对应state输出进行拼接。
# 但是在train里面查看发现， dim没有任何改变
seq_output = tf.concat(self.lstm_outputs, 1)

self.seq_output = seq_output  # just for  output in train method

# 将每个batch的每个state拼接成 一个二维的batch_size * state_node_size(lstm_size) 列矩阵
x = tf.reshape(seq_output, [-1, self.lstm_size])

# 构建一个输出层：softmax
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))

# 定义输出：softmax 归一化
self.logits = tf.matmul(x, softmax_w) + softmax_b
self.proba_prediction = tf.nn.softmax(self.logits, name='predictions')

def build_loss(self):
with tf.name_scope('loss'):
# 统一第输出进行non hot编码
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))

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的初始h状态采用上一轮的final_state

batch_loss, new_state, _ , lstm_outputs, seq_output, prp = sess.run([self.loss,
self.final_state,
self.optimizer,
self.lstm_outputs,
self.seq_output,
self.proba_prediction
],
feed_dict=feed)
print('lstm outpts: ', lstm_outputs.shape, self.num_seqs)
print('lstm outpts: ', seq_output.shape)   # ??? 为啥一直没有改变
print(prp.shape)
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)))
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 sample(self, n_samples, prime, vocab_size):
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}
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)

def load(self, checkpoint):
"""
:param checkpoint: 命名
:return:
"""
# 存储 训练好的神经网络模型
self.session = tf.Session()
self.saver.restore(self.session, checkpoint)
print('Restored from: {}'.format(checkpoint))

利用模型生成文本

这个过程依靠调用sample.py脚本

import tensorflow as tf
from read_utils import TextConverter
from model import CharRNN
import os
from IPython import embed

FLAGS = tf.flags.FLAGS

tf.flags.DEFINE_integer('lstm_size', 128, 'size of hidden state of lstm')    # 这里为什么还需要？？？
tf.flags.DEFINE_integer('num_layers', 2, 'number of lstm layers')            # ？？？
tf.flags.DEFINE_boolean('use_embedding', False, 'whether to use embedding')
tf.flags.DEFINE_integer('embedding_size', 128, 'size of embedding')
tf.flags.DEFINE_string('converter_path', '', 'model/name/converter.pkl')
tf.flags.DEFINE_string('checkpoint_path', '', 'checkpoint path')                   # 模型保存路径
tf.flags.DEFINE_string('start_string', '', 'use this string to start generating')  # 给出一个字符开始生成
tf.flags.DEFINE_integer('max_length', 30, 'max length to generate')                # 最大字符

def main(_):
FLAGS.start_string = FLAGS.start_string.decode('utf-8')
converter = TextConverter(filename=FLAGS.converter_path)  # 调用前面训练建立的voctab即可
if os.path.isdir(FLAGS.checkpoint_path):
FLAGS.checkpoint_path =tf.train.latest_checkpoint(FLAGS.checkpoint_path)

model = CharRNN(converter.vocab_size, sampling=True,      # 调模型的保存不能保存节点等相关参数
lstm_size=FLAGS.lstm_size, num_layers=FLAGS.num_layers,
use_embedding=FLAGS.use_embedding,
embedding_size=FLAGS.embedding_size)

model.load(FLAGS.checkpoint_path)   # 载入训练好的模型

start = converter.text_to_arr(FLAGS.start_string)  # 字符转化为idnex
arr = model.sample(FLAGS.max_length, start, converter.vocab_size)
print(converter.arr_to_text(arr))  # 反序列化

if __name__ == '__main__':
tf.app.run()

• 主要调用rnn模型类的sample方法，很简单，注释即可看懂

def sample(self, n_samples, prime, vocab_size):
"""
用一个字符生成一段文本
:param n_samples:
:param prime:
:param vocab_size:
:return:
"""
print("初始字符为：", prime)
samples = [c for c in prime]
sess = self.session
new_state = sess.run(self.initial_state)
preds = np.ones((vocab_size,))  # for prime=[]
# 对给定的初始字符串来，一次feed
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}
preds, new_state = sess.run([self.proba_prediction, self.final_state],
feed_dict=feed)
print(preds)  # 最后一个字符的输出

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)

输出展示：

同样采用莎士比亚文集训练模型：

python sample.py --converter_path model/shakespeare/converter.pkl --checkpoint_path model/shakespeare/ --max_length 30 --start_string He

Heds since
I that what that when
以上为输出结果，并不能成为一句语句， 个人觉得利用word并进行word2vec来生成语句，可能会更好，利用字符 维度太低了。

作者：Kean_L_C
链接：https://www.jianshu.com/p/1a4f7f5b05ae
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。