word2vec模型与LSTM模型联合使用

```python
# region 加载库,基础参数配置
# 运行前下载数据集
# wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz
# tar xvf simple-examples.tgz
# 下载PTB，借助reader读取数据内容，将单词转为唯一的数字编码
# git clone https://github.com/tensorflow/models.git
# 如果代码运行时出现TypeError: a bytes-like object is required, not 'str'
# 则将models/tutorials/rnn/ptb/reader.py中的return f.read().replace("\n", "<eos>").split() 改成f.read().decode("utf-8").replace("\n", "<eos>")

import time
import numpy as np
import tensorflow as tf
from tensorflow.contrib import rnn
# 把解压后的ptb路径添加进系统路径，这样这样系统才能找到并载入reader
import sys
# 本程序文件能够运行，说明本文件夹正是系统路径之一，所以系统会把这个相对路径附加到本程序路径下。
sys.path.append('models/tutorials/rnn/ptb')
import reader
# endregion

# region 模型参数类,用于配置构建和执行计算图的参数
# 封装好参数，方便训练前选择配置。
# 小模型。本代码用到的模型参数。
class SmallConfig(object):
  init_scale = 0.1      # 网络中权重值的初始scale
  learning_rate = 1.0   # 学习速率的初始值
  max_grad_norm = 5     # 梯度的最大范数
  num_layers = 2        # LSTM可以堆叠的层数
  num_steps = 20        # LSTM梯度反向传播的展开步数
  hidden_size = 200     # LSTM内的隐含节点数
  max_epoch = 1#4         # 初始学习速率可训练的epoch数，在此之后需要调整学习速率
  max_max_epoch = 13    # 总共可以训练的epoch数
  keep_prob = 1.0       # 保留节点的比率
  lr_decay = 0.5        # 学习速率的衰减速度
  batch_size = 20       # 每个batch中样本的数量
  vocab_size = 10000

# 中型模型
class MediumConfig(object):
  init_scale = 0.05     # 减小了init_scale,即希望权重初值不要过大，小一些有利于温和的训练.被tf.random_uniform_initializer()调用
  learning_rate = 1.0
  max_grad_norm = 5
  num_layers = 2
  num_steps = 35        # 从20增大到了35
  hidden_size = 650     # 伴随num_steps,也相应地增大了约3倍
  max_epoch = 6
  max_max_epoch = 39
  keep_prob = 0.5       # 引入dropout
  lr_decay = 0.8        # 因为学习的迭代次数增大，所以学习速率的衰减速度减小了。
  batch_size = 20
  vocab_size = 10000

# 大型模型
class LargeConfig(object):
  init_scale = 0.04     # 进一步缩小init_scale
  learning_rate = 1.0
  max_grad_norm = 10    # 放宽范数到10
  num_layers = 2
  num_steps = 35
  hidden_size = 1500    # 提升到1500
  max_epoch = 14        # 增大
  max_max_epoch = 55    # 增大
  keep_prob = 0.35      # 模型复杂度上升，keep_prob调小
  lr_decay = 1 / 1.15   # 学习速率的衰减速度进一步减小。
  batch_size = 20
  vocab_size = 10000

# 测试用，所有的参数都尽量使用最小值，为了测试可以完整运行模型
class TestConfig(object):
  init_scale = 0.1
  learning_rate = 1.0
  max_grad_norm = 1
  num_layers = 1
  num_steps = 2
  hidden_size = 2
  max_epoch = 1
  max_max_epoch = 1
  keep_prob = 1.0
  lr_decay = 0.5
  batch_size = 20
  vocab_size = 10000

# 配置参数，供下文的tf.Graph()和sv.managed_session()中使用。
config = SmallConfig()       # 配置训练时（广义的训练，包括train和valid）的参数
eval_config = SmallConfig()  # 配置测试时（即test）的参数。除了以下两个参数设为1，其他的参数全部与训练时相同。
eval_config.batch_size = 1   # 一个batch中样本的数量
eval_config.num_steps = 1    # LSTM的展开步数（unrolled steps of LSTM）

# endregion

# region 0 原始数据读入
# 包含三类。用于下文的tf.Graph()中调用输入数据类PTBInput()初始化出三种数据对象
# 本程序文件能够运行，说明本文件夹正是系统路径之一，所以可以直接填相对路径
# 从raw_data中得到训练数据，验证数据，测试数据。
raw_data = reader.ptb_raw_data('simple-examples/data/')
train_data, valid_data, test_data, _ = raw_data
# endregion

# region 1 计算图构建类

# region 1.1 参数配置/数据装载类
# 定义输入数据类
# 将在tf.Graph()中用于实例化三个数据对象：train_input、valid_input、test_input
# 注意，每个数据对象均包含input＿data和targets
class PTBInput(object):
    def __init__(self, config, data, name=None):
        self.batch_size = batch_size = config.batch_size
        # LSTM的展开步数（unrolled steps of LSTM）
        self.num_steps = num_steps = config.num_steps
        # 每一个epoch内需要的多少轮迭代
        self.epoch_size = ((len(data) // batch_size) - 1) // num_steps
        #  获取特征数据input_data，label数据targets，每次执行获取一个batch的数据。
        #
        # self.targets的shape是[batch_size,num_steps]
        self.input_data, self.targets = reader.ptb_producer(data, batch_size, num_steps, name=name)
# endregion

# region 1.2 模型类
# 定义语言模型类
# 将在tf.Graph()中被实例化了三次，生成三个模型对象：m、mvalid、mtest
# 例如m=PTBModel(is_training=True, config=config, input_=train_input)，
# 其中，train_input是PTBInput()类传入原始数据完成实例化后的对象。
#　包含３类方法:模型初始化方法__init__(),学习速率更新的执行方法assign_lr(),属性读取方法(6个)
class PTBModel(object):

    def __init__(self, is_training, config, input_):

        # region 配置参数
        self._input = input_              # self._input仅被用于这个类的属性返回方法．在这个初始化方法内部直接用input＿
        batch_size = input_.batch_size
        num_steps = input_.num_steps
        # hidden_size是LSTM的节点数
        size = config.hidden_size
        # vocab_size是词汇表的大小
        vocab_size = config.vocab_size
        # endregion

        # region 输入数据向量化
        # 词嵌入embedding部分
        # 将one-hot格式的单词转化为向量形式
        with tf.device("/cpu:0"):
            # 初始化embedding矩阵，行数设为词汇表vocab_size，列数（即每个单词的向量表达的维数）设为hidden_size（即LSTM单元中的隐含节点数）。
            embedding = tf.get_variable("embedding", [vocab_size, size], dtype=tf.float32)
            # 查询单词对应的向量表达式inputs。
            # input_是在该类被外部实例化时传入的，因此不需要占位符
            # input_.input_data shape=[batch_size]
            inputs = tf.nn.embedding_lookup(embedding, input_.input_data)
            # inputs的shape =[batch_size,embedding_size]
        # 如果处于训练状态，且keep_prob小于1，则再添一个Dropout层
        if is_training and config.keep_prob < 1:
            inputs = tf.nn.dropout(inputs, config.keep_prob)
        # endregion

        # region 定义LSTM结构
        # 设置默认的LSTM单元个数。利用tf.contrib.rnn.BasicLSTMCell()
        def lstm_cell():
            #传入的size为是LSTM的节点数，forget_bias即为forget gate的bias，state_is_tuple=True表示接收和返回的state是2-tuple形式
            return rnn.BasicLSTMCell(
                size, forget_bias=0.0, state_is_tuple=True)
        # 如果是训练中,则这句没意义,因为之后的if语句会重新定义attn_cell()就成了一个后接dropout 的cell层
        # 如果不是训练中,则这句就起到承前启后,跳过if语句,使cell层顺利堆叠.
        attn_cell = lstm_cell
        # 如果处于训练状态，且keep_prob小于1，则在lstm_cell之后接一个Dropout层
        if is_training and config.keep_prob < 1:
            def attn_cell():
                return rnn.DropoutWrapper(lstm_cell(), output_keep_prob=config.keep_prob)
        # 设置LSTM的堆叠层数
        # 使用RNN堆叠函数将前面构造的lstm_cell多层堆叠成cell，堆叠次数为config.num_layers
        # 如果num_layers是2，则结果形如[attn_cell() attn_cell()]
        cell = rnn.MultiRNNCell(
            [attn_cell() for _ in range(config.num_layers)], state_is_tuple=True)
        # 有了LSTM cell，初始化cell为0。
        # LSTM单元读入一个单词并结合之前储存的状态state计算下一个单词出现的概率分布，每次读取一个单词后它的状态state会被更新。
        # 经过初始化，这里的self._initial_state就表征cell的初始状态，会由m.inital_state拿出来供外部使用，也会在本类下文中拿来初始化state。
        # state的shape是[batch_size,size*num_layers]
        self._initial_state = cell.zero_state(batch_size, tf.float32)
        # endregion

        # region 定义前向计算和cost

        # 设置LSTM的时间序列的深度num_step.
        inputs = tf.unstack(inputs, num=num_steps, axis=1)
        # state的shape是[batch_size,size*num_layers]
        # outputs的shape就是[batch_size,num_steps,size]
        outputs, state = rnn.static_rnn(cell, inputs,
                                   initial_state=self._initial_state)
        '''
        # 定义输出outputs
        outputs = []
        state = self._initial_state
        with tf.variable_scope("RNN"):
            # 将接下来的操作名称设为RNN
            # 限制梯度在反向传播时可以展开的步数为一个固定值，即步数num_steps
            for time_step in range(num_steps):
                # 从第二次循环开始，设置复用变量
                if time_step > 0:
                    tf.get_variable_scope().reuse_variables()
                # 每次循环内，传入inputs和state到堆叠的LSTM单元（即cell）中
                # inputs有三个维度，含义依次是：batch中第几个样本，样本中第几个单词，单词的向量表达的维度。
                # inputs[:, time_step, :]代表所有样本的第time_step个单词。
                # 得到输出cell_output和更新后的state。
                (cell_output, state) = cell(inputs[:, time_step, :], state)
                # 将time_step这个时间点的cell_output(shape是[batch_size,size])添加到输出列表中。
                outputs.append(cell_output)
            ＃当循环结束，outputs是一个有num_steps个元素的列表，每个元素的shape就是[batch_size,size]
        '''

        # 将outputs的内容串联起来，并转换为一维向量。
        # tf.concat(outputs, 1)的shape就是[batch_size*num_steps,size]
        # [-1,size]就表示每行必须是第二维必须是size个元素，然后第一维度是多少就是多少．
        # 结果就是output的shape就是[batch_size*num_steps,size]，相当于不变．
        output = tf.reshape(tf.concat(outputs, 1), [-1, size])
        # softmax层
        softmax_w = tf.get_variable(
            "softmax_w", [size, vocab_size], dtype=tf.float32)
        softmax_b = tf.get_variable("softmax_b", [vocab_size], dtype=tf.float32)
        # 输出的logits的shape是[batch_size*num_steps,vocab_size]　
        logits = tf.matmul(output, softmax_w) + softmax_b
        # 损失函数，计算输出logits和targets的偏差
        # 这里的sequence_loss即target words的average negative log probability,
        # 其定义是loss=-(1/N)*[lnP(target_1)+lnP(target_2)+...+lnP(target_N)],其中P(target_N)是target N的概率。
        # tf.contrib.legacy_seq2seq.sequence_loss_by_example返回一个序列的交叉熵的和
        loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(
            [logits],# 预测值
            [tf.reshape(input_.targets, [-1])],
            # 把标签值的shape[batch_size,num_steps]二维数组压缩成一维数组
            [tf.ones([batch_size * num_steps], dtype=tf.float32)]
            # 损失的权重，在这里所有的权重都为1，也就是说不同batch和不同时刻的重要程度是一样的
        )
        # 汇总batch的误差，计算平均到每个样本的平均损失
        self._cost = cost = tf.reduce_sum(loss) / batch_size
        # 保留最终的状态为final_state
        self._final_state = state
        # endregion

        # region 定义训练操作
        # 只有训练模型时，才会执行这部分
        if not is_training:
            return
        # 定义学习速率_lr
        # 并将其设为不可训练
        self._lr = tf.Variable(0.0, trainable=False)
        # 定义优化器SGD
        optimizer = tf.train.GradientDescentOptimizer(self._lr)
        # 定义训练op
        # minimize分两步，先取compute_gradient,再用apply_gradient
        # 获取全部可训练参数tvars
        tvars = tf.trainable_variables()
        # 针对前面得到的cost，计算tvars的梯度，并设置梯度的最大范数max_grad_norm
        # 这就是Gradient Clipping方法，控制梯度的最大范数，某种程度上起到正则化的效果，可防止梯度爆炸。
        grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars),config.max_grad_norm)
        #　apply_gradients()将前面clip过的梯度应用到所有可训练的参数tvars上。
        # 使用get_or_create_global_step()生成全局统一的训练步数。
        self._train_op = optimizer.apply_gradients(
            zip(grads, tvars),
            global_step=tf.contrib.framework.get_or_create_global_step())
        # 定义学习率更新op
        # 以下两句的意思是：如果传入了新的学习速率self._new_lr，那么就把新的学习速率self._new_lr赋给self._lr
        self._new_lr = tf.placeholder(
            tf.float32, shape=[], name="new_learning_rate")
        # 定义操作_lr_update,它使用tf.assign()将_new_lr的值赋给当前的学习速率_lr
        self._lr_update = tf.assign(self._lr, self._new_lr)
        # endregion

    # region 学习速率更新方法
    # 只需要调用 模型m的m.assign_lr(session,新的学习速率值)，assign_lr()内部就把新的学习速率值feed给self._new_lr，执行session._lr_update张量。
    # 相当于调用了上面的这两句，实现了在外部就可以控制模型的学习速率
    def assign_lr(self, session, lr_value):
        # session.run(tf.assign(self._lr, lr_value))
        session.run(self._lr_update, feed_dict={self._new_lr: lr_value})
    # endregion

    # region 6个属性读取方法
    # 用@property装饰器将返回变量设为只读，防止修改变量引发的问题，方便外部访问。
    # 因为被当做属性使用，访问时不用带括号，如果模型名为m，则访问的形式可以是 m.lr或m.cost或m.initial_state
    @property
    def input(self):
        return self._input
    @property
    def initial_state(self):
        return self._initial_state
    @property
    def cost(self):
        return self._cost
    @property
    def final_state(self):
        return self._final_state
    @property
    def lr(self):
        return self._lr
    @property
    def train_op(self):
        return self._train_op
    # endregion

# endregion

# endregion

# region 2 计算图执行函数
# 训练一个epoch数据的模型执行函数
# 训练时从外部调用run_epoch(session, m, eval_op=m.train_op,verbose=True)，输出epoch的进度 + perplexity + 训练速度 ，并返回训练结果perplexity。
# 验证或测试时从外部调用run_epoch(session, model），只返回验证或测试结果perplexity。
# 本函数体内，执行了两次session，分别是session.run(model.initial_state)和session.run(fetches, feed_dict)
def run_epoch(session, model, eval_op=None, verbose=False):
  start_time = time.time()
  costs = 0.0
  iters = 0
  # 执行model.initial_state获得初始状态，即PTBModel的cell.zero_state(batch_size, tf.float32)值
  state = session.run(model.initial_state)

  # region 以下是拿到cost和state
  fetches = {
      "cost": model.cost,               # 即张量m.cost
      "final_state": model.final_state, # 即张量m.final_state
  }
  # 只有在训练时才能进入这句if语句
  if eval_op is not None:
    fetches["eval_op"] = eval_op        # 传入的是m.train_op,即m内的张量self._train_op
  # 以下的for循环，是为了计算perplexity
  for step in range(model.input.epoch_size):  # 次数为epoch_size
    # 每次循环前，生成训练用的空feed_dict
    feed_dict = {}
    for i, (c, h) in enumerate(model.initial_state):
      feed_dict[c] = state[i].c
      feed_dict[h] = state[i].h
    # 通过上面这个for循环，将全部的LSTM单元的state加入到feed_dict中
    # 传入feed_dict,执行fetches，对网络进行一次训练
    # fetches之所以能被且必须被执行，是因为fetches字典里每个元素的value都是tensor，
    vals = session.run(fetches, feed_dict)
    cost = vals["cost"]
    state = vals["final_state"]
  # endregion

    costs += cost
    iters += model.input.num_steps
    # 只有训练时（传入的verbose才是True），才能进入下面的if和print语句，即每完成10%的epoch，就进行一次结果的展示。
    # 如果不是训练，则跳过if+print，结束本次循环，进入下一个step循环，直到epoch_size跑完。
    if verbose and step % (model.input.epoch_size // 10) == 10:
      # perplexity即平均cost的自然常数指数，越低代表模型的输出概率分布在预测样本上越好
      print("%.3f perplexity: %.3f speed: %.0f wps" %
             (step * 1.0 / model.input.epoch_size,                       # 当前epoch的进度
             np.exp(costs / iters),                                      # perplexity
             iters * model.input.batch_size / (time.time() - start_time) # 训练速度（每秒的单词数）
             )
           )
  # 返回perplexity，作为本函数run_epoch()结果。
  return np.exp(costs / iters)
# endregion

# tf.Graph()内部调用PTBInput()和PTBModel()，初始化三种数据对象和模型对象，为下文sv的训练测试做好了准备。
with tf.Graph().as_default():

    # region 3 构建计算图
    # 设置参数的初始化器，参数范围在-init_scale,init_scale之间。
    initializer = tf.random_uniform_initializer(-config.init_scale,
                                              config.init_scale)
    # region 3.1 构建训练模型m
    with tf.name_scope("Train"):
        train_input = PTBInput(config=config, data=train_data, name="TrainInput")
    with tf.variable_scope("Model", reuse=None, initializer=initializer):# 注意reuse
        m = PTBModel(is_training=True, config=config, input_=train_input)
        #tf.scalar_summary("Training Loss", m.cost)
        #tf.scalar_summary("Learning Rate", m.lr)
    # endregion

    # region 3.2 构建验证模型mvalid
    with tf.name_scope("Valid"):
        valid_input = PTBInput(config=config, data=valid_data, name="ValidInput")
    with tf.variable_scope("Model", reuse=True, initializer=initializer):
        # 运用之前训练好的模型的参数来测试他们的效果，故定义reuse = True。
        mvalid = PTBModel(is_training=False, config=config, input_=valid_input)
        #tf.scalar_summary("Validation Loss", mvalid.cost)
    # endregion

    # region 3.3 构建测试模型mtest
    with tf.name_scope("Test"):
        test_input = PTBInput(config=eval_config, data=test_data, name="TestInput")
    with tf.variable_scope("Model", reuse=True, initializer=initializer):
        # 运用之前训练好的模型的参数来测试他们的效果，故定义reuse=True。
        mtest = PTBModel(is_training=False, config=eval_config,
                       input_=test_input)
    # endregion
    # endregion

    # region 4 执行计算图
    # 创建训练的管理器sv
    # 在sv里，主要负责输出：每轮的学习率，每轮训练后的自然常数指数（run_epoch()返回值），每轮验证时的自然常数指数（run_epoch()返回值）。
    # 在max_max_epoch（例如13轮）结束后，输出测试的自然常数指数。
    # 在训练阶段，run_epoch()会输出“当前epoch的进度   perplexity  训练速度（每秒的单词数）”。
    sv = tf.train.Supervisor()
    with sv.managed_session() as session:# 创建默认的session
        for i in range(config.max_max_epoch):# 前面config = SmallConfig()里max_max_epoch=13，即总共可以训练的epoch数

          # region 执行更新学习速率，并输出显示
          # 先计算累计的学习速率衰减值。
          # max_epoch被初始化为4，则前4轮lr_decay=1,只有当到第5轮（i=4）时，lr_decay=0.5**1=0.5,之后以0.5倍加速衰减。
          lr_decay = config.lr_decay ** max(i + 1 - config.max_epoch, 0.0)
          # 更新学习速率。用初始学习速率×累计的衰减
          # m是tf.Graph()中定义的训练模型，assigh_lr()是PTBModel()函数中的方法。
          m.assign_lr(session, config.learning_rate * lr_decay)
          # 执行一个epoch的训练，并输出当前的学习速率。
          # 例如第2轮，即输出 Epoch: 2 Learning rate: 1.000
          print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr))) # 即通过PTBModel()中@property修饰的lr()来获取
          # endregion

          # region 4.1 执行训练
          # 输出训练集上的perplexity，即平均cost的自然常数指数
          train_perplexity = run_epoch(session, m, eval_op=m.train_op,
                                       verbose=True)
          print("Epoch: %d Train Perplexity: %.3f" % (i + 1, train_perplexity))
          # endregion

          # region 4.2 执行验证
          # 输出验证集上的perplexity
          valid_perplexity = run_epoch(session, mvalid)
          print("Epoch: %d Valid Perplexity: %.3f" % (i + 1, valid_perplexity))
          # endregion

    # region 4.3 执行测试
    #完成所有循环后，计算并输出测试集上的perplexity
    test_perplexity = run_epoch(session, mtest)
    print("Test Perplexity: %.3f" % test_perplexity)
    # endregion

    # endregion