TensorFlow——循环神经网络基本结构

　　1、导入依赖包，初始化一些常量

import collections

import numpy as np
import tensorflow as tf

TRAIN_DATA = "./data/ptb.train.txt"  # 训练数据路径
TEST_DATA = "./data/ptb.test.txt"  # 测试数据路径
EVAL_DATA = "./data/ptb.valid.txt"  # 验证数据路径

HIDDEN_SIZE = 300  # 隐藏层中cell的个数
NUM_LAYERS = 2  # 深度循环神经网络中LSTM结构的层数
VOCAB_SIZE = 10000  # 词典规模
TRAIN_BATCH_SIZE = 20  # 训练数据batch的大小
TRAIN_NUM_STEP = 35  # 训练数据的截断长度，也可以看作是序列的长度

EVAL_BATCH_SIZE = 1
EVAL_NUM_STEP = 35
NUM_EPOCH = 30  # 使用训练数据的轮数
LSTM_KEEP_PROB = 0.9  # LSTM节点不被dropout的概率
EMBEDDING_KEEP_PROB = 0.9  # 词向量不被dropout的概率
MAX_GRAD_NORM = 5  # 用于控制梯度膨胀的梯度大小上限
SHARE_EMB_AND_SOFTMAX = True  # 在softmax层和词向量层之间共享参数

　　2、处理数据集

def read_data(file_path):
    """
    读取文件数据，将文本中的词转换成词空间中对应的索引
    :param file_path: 文件路径
    :return: 由数值取代后的文本词列表
    """

    # 采用TensorFlow中的读取文件的方法去读取文件
    with tf.gfile.GFile(file_path, "r") as f:
        # 将文本读取出来，并且进行分词，将换行符替换成<eos>,eos的意思就是end of sentence
        word_list = f.read().replace("\n", "<eos>").split()
        # 对分词后的列表进行统计，统计每个单词出现的数量, 返回的数据类型Counter({'jiang': 2, 'zhang': 1})
        counter = collections.Counter(word_list)
        # 对每个词按照词频排序，对于词频相同的按词本身进行排序，返回的数据类型[('jiang', 2), ('zhang', 1)]
        count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))
        # 取出单词元组，返回的数据类型words=('jiang', 'zhang')
        words, _ = list(zip(*count_pairs))
        # 将上面排序后的词（无重复的词空间）标记索引数值，返回的数据类型{'jiang': 0, 'zhang': 1}
        word_to_id = dict(zip(words, range(len(words))))
        # 将文本中所有的单词用索引数值取代，组成新的列表
        id_list = [word_to_id[word] for word in word_list if word in word_to_id]

    return id_list

def make_batches(id_list, batch_size, num_steps):
    """
    将原始的数据集转换成mini-batch进行训练
    :param id_list: 原始的数值文本列表
    :param batch_size:
    :param num_steps: 一个样本的序列长度
    :return: 整个样本转换后的batchs数据
    """
    # 计算总的batch数量。每个batch包含的单词数量是batch_size * num_steps，batch_size为一个batch中样本的数量，
    # num_steps为一个样本的序列长度，因此num_batchs表示整个训练文本能分成的batch的数量
    num_batches = (len(id_list) - 1) // (batch_size * num_steps)

    # 根据上面分配好的num_batchs, batch_size, num_steps参数来构建数据集，先取出能整除的序列长度
    data = np.array(id_list[: num_batches * batch_size * num_steps])
    # reshape取出来的序列（一维数组）成二维数组，因为是序列数据，所以行为batch_size，列为num_batchs * num_steps，之后训练在横向上分割
    data = np.reshape(data, [batch_size, num_batches * num_steps])
    # 将数据在axis=1的轴上分割，分割的数量就是num_batchs
    data_batches = np.split(data, num_batches, axis=1)

    # 因为是根据前面的词预测后面的词，因此输出的值要往后移一位，其余操作和上面的一致
    label = np.array(id_list[1: num_batches * batch_size * num_steps + 1])
    label = np.reshape(label, [batch_size, num_batches * num_steps])
    label_batches = np.split(label, num_batches, axis=1)

    return list(zip(data_batches, label_batches))

　　3、构建模型

　　主要是定义各种变量或者对象，有些变量是经过计算得到的

class PTBModel(object):

    def __init__(self, is_training, batch_size, num_steps):
        # 记录使用的batch大小和截断长度（也就是一个样本的序列长度）
        self.batch_size = batch_size
        self.num_steps = num_steps

        # 定义每一步的输入和预期输出。两者的维度都是[batch_size, num_steps]，batch_size时间上就是指一个batch中样本的数量
        self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps])
        self.targets = tf.placeholder(tf.int32, [batch_size, num_steps])

        # 定义dropout的值，训练时取0.9，否则取1.0，表示不做dropout
        dropout_keep_prob = LSTM_KEEP_PROB if is_training else 1.0

        # 定义lstm cell的结构，dropout相当于装饰器直接包裹在lstm_cell上,此时的cell是垂直方向的，所以for循环中的值是NUM_LAYERS
        lstm_cells = [tf.nn.rnn_cell.DropoutWrapper(tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE),
                                                    output_keep_prob=dropout_keep_prob)
                      for i in range(NUM_LAYERS)]
        # 组合成多层循环
        cell = tf.nn.rnn_cell.MultiRNNCell(lstm_cells)

        # 初始化最初的状态值，即全为0的向量。这个量只在每个epoch初始化第一个batch时使用
        # #返回[batch_size, 2*len(cells)],或者[batch_size, s]，至于为什么是2 * ，这是因为初始值有两个h0和C0
        self.initial_state = cell.zero_state(batch_size, tf.float32)

        # 定义单词的词向量矩阵，这里用get_variable，之后在测试时就可以实现参数共享了
        # VOCAB_SIZE是指词向量空间中词的个数（在这里起始是len(words)的长度，也等于10000），HIDDEN_SIZE是值词嵌入之后的词向量长度
        embedding = tf.get_variable("embedding", [VOCAB_SIZE, HIDDEN_SIZE])

        # 将输入的单词转化为词向量，相当于将每个序列中的单词按照索引（之前转化为了数值在这里就很方便的），直接将序列中的每个词在已经训练好的
        # 词空间中寻找对应的向量，此空间应该是二维的，输出的结果应该是三维的，也就是batch_size * num_steps * HIDDEN_SIZE
        inputs = tf.nn.embedding_lookup(embedding, self.input_data)

        # 只在训练时使用dropout来训练词向量
        if is_training:
            inputs = tf.nn.dropout(inputs, EMBEDDING_KEEP_PROB)

        # 定义输出列表。在这里先将不同时刻LSTM结构的输出收集起来，再一起提供给softmax层，在这里是实现时间序上的cell输出
        outputs = []
        state = self.initial_state
        with tf.variable_scope("RNN"):
            for time_step in range(num_steps):
                if time_step > 0:
                    # 实现在同一个variable_scope下共享参数
                    tf.get_variable_scope().reuse_variables()
                # 从这里就可以看出之前embedding输出的是三维，我们根据时间序取出词来进行训练,
                # cell_output shape=(batch_size, HIDDEN_SIZE)
                cell_output, state = cell(inputs[:, time_step, :], state)
                outputs.append(cell_output)

        # 把输出队列展开成[batch_size, num_steps * hidden_size]，然后再reshape成[batch_size * num_steps, hidden_size]
        output = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE])
        # softmax层：将RNN在每个位置的输出转化为各个单词的logits
        # weight的shape是[HIDDEN_SIZE, VOCAB_SIZE]
        if SHARE_EMB_AND_SOFTMAX:
            weight = tf.transpose(embedding)
        else:
            weight = tf.get_variable("weight", [HIDDEN_SIZE, VOCAB_SIZE])

        bias = tf.get_variable("bias", [VOCAB_SIZE])
        # 算出最终输出的logits，用于之后的交叉熵和softmax计算
        logits = tf.matmul(output, weight) + bias

        # 定义交叉熵损失函数和平均损失函数，返回的loss是和labels、logits相同的shape
        loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.reshape(self.targets, [-1]),
                                                              logits=logits)
        # 求平均损失
        self.cost = tf.reduce_sum(loss) / batch_size
        # 该状态用来存储训练完一个batch之后的状态，在训练下一个batch时，会将该状态作为初始状态，这个在run_epoch函数中控制的
        self.final_state = state

        # 只在训练模型时定义反向传播操作
        if not is_training:
            return
        # 拿到所有的训练参数，用于之后的梯度下降更新参数
        trainable_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=1.0)
        self.train_op = optimizer.apply_gradients(zip(grads, trainable_variables))

　　4、创建run_epoch函数，用来控制模型的训练

def run_epoch(session, model, batches, train_op, output_log, step):
    """
    训练模型和模型预测。使用给定的模型model在数据data上运行train_op并返回在全部数据上的perplexity值。
    :param session:
    :param model:
    :param batches:
    :param train_op:
    :param output_log: 判断是训练过程还是其他过程
    :param step:
    :return:
    """
    # 计算平均perplexity的辅助变量，perplexity表示在模型生成一句话时下一个词有perplexity个合理的选择，认为perplexity小于100都是比较好的
    # 结果，该值越小，说明模型越好，也可以认为模型预测的精确度越高
    total_costs = 0.0  # 存储损失值
    iters = 0
    state = session.run(model.initial_state)
    # 训练一个epoch
    for x, y in batches:
        # 可以在run函数中通过字典的形式给模型输入数据，也可以直接读取出模型的值，session.run（）方法通过驱动三个operation来驱动整个图
        # 其中train_op是只是用来驱动训练过程的
        cost, state, _ = session.run([model.cost, model.final_state, model.train_op],
                                     feed_dict={model.input_data: x, model.targets: y, model.initial_state: state}
                                     )
        total_costs += cost
        iters += model.num_steps

        if output_log and step % 100 == 0:
            print("After {} steps, perplexity id {}".format(step, np.exp(total_costs / iters)))

        step += 1
    # pplx是语言模型perplexity指标
    pplx = np.exp(total_costs / iters)
    return step, pplx

　　5、定义main函数

def main():
    with tf.Graph().as_default():
        # 定义初始化函数, 用于决定之后的variable_scope中的变量的初始值取值范围
        initializer = tf.random_uniform_initializer(-0.05, 0.05)

        # 定义训练用的循环神经网络模型
        with tf.name_scope("train"):
            train_batches = make_batches(read_data(TRAIN_DATA), TRAIN_BATCH_SIZE, TRAIN_NUM_STEP)
　　　　　　　# 利用variable_scope()和get_variable()来实现变量共享
            with tf.variable_scope("language_model", reuse=None, initializer=initializer):
                train_model = PTBModel(True, TRAIN_BATCH_SIZE, TRAIN_NUM_STEP)

        # 定义测试用的循环神经网络模型，它与train_model共享参数，但没有dropout，可以通过is_training来控制
        with tf.name_scope('test'):
            eval_batches = make_batches(read_data(EVAL_DATA), EVAL_BATCH_SIZE, EVAL_NUM_STEP)
            test_batches = make_batches(read_data(TEST_DATA), EVAL_BATCH_SIZE, EVAL_NUM_STEP)
            # 设置同样的名称language_model来实现共享变量，变量共享和name_scope无关
            with tf.variable_scope("language_model", reuse=True, initializer=initializer):
                eval_model = PTBModel(False, EVAL_BATCH_SIZE, EVAL_NUM_STEP)

        # 训练模型
        with tf.Session() as session:

            tf.global_variables_initializer().run()
            step = 0
            for i in range(NUM_EPOCH):
                print("In iteration: {}".format(i + 1))

                step, train_pplx = run_epoch(session, train_model, train_batches, train_model.train_op, True, step)
                print("Epoch: {} Train Perplexity: {}".format(i+1, train_pplx))

                _, eval_pplx = run_epoch(session, eval_model, eval_batches, tf.no_op(), False, 0)
                print("Epoch: {} Eval Perplexity: {}".format(i+1, eval_pplx))

                _, test_pplx = run_epoch(session, eval_model, test_batches, tf.no_op(), False, 0)
                print("Epoch: {} Test Perplexity: {}".format(i+1, test_pplx))