Tensorflow--RNN-LSTM循环神经网络，三
network.py:
# -*- coding: UTF-8 -*-
"""
神经网络模型相关
RNN-LSTM 循环神经网络
大家之后可以加上各种的 name_scope（命名空间）
用 TensorBoard 来可视化
==== 一些术语的概念 ====
# Batch size : 批次(样本)数目。一次迭代（Forword 运算（用于得到损失函数）以及 BackPropagation 运算（用于更新神经网络参数））所用的样本数目。Batch size 越大，所需的内存就越大
# Iteration : 迭代。每一次迭代更新一次权重（网络参数），每一次权重更新需要 Batch size 个数据进行 Forward 运算，再进行 BP 运算
# Epoch : 纪元/时代。所有的训练样本完成一次迭代
# 假如 : 训练集有 1000 个样本，Batch_size=10
# 那么 : 训练完整个样本集需要： 100 次 Iteration，1 个 Epoch
# 但一般我们都不止训练一个 Epoch
==== 超参数（Hyper parameter）====
init_scale : 权重参数（Weights）的初始取值跨度，一开始取小一些比较利于训练
learning_rate : 学习率，训练时初始为 1.0
num_layers : LSTM 层的数目（默认是 2）
num_steps : LSTM 展开的步（step）数，相当于每个批次输入单词的数目（默认是 35）
hidden_size : LSTM 层的神经元数目，也是词向量的维度（默认是 650）
max_lr_epoch : 用初始学习率训练的 Epoch 数目（默认是 10）
dropout : 在 Dropout 层的留存率（默认是 0.5）
lr_decay : 在过了 max_lr_epoch 之后每一个 Epoch 的学习率的衰减率，训练时初始为 0.93。让学习率逐渐衰减是提高训练效率的有效方法
batch_size : 批次(样本)数目。一次迭代（Forword 运算（用于得到损失函数）以及 BackPropagation 运算（用于更新神经网络参数））所用的样本数目
（batch_size 默认是 20。取比较小的 batch_size 更有利于 Stochastic Gradient Descent（随机梯度下降），防止被困在局部最小值）
"""
import tensorflow as tf
# 神经网络的模型
class Model(object):
# 构造函数
def __init__(self, input_obj, is_training, hidden_size, vocab_size, num_layers,
dropout=0.5, init_scale=0.05):
self.is_training = is_training
self.input_obj = input_obj
self.batch_size = input_obj.batch_size
self.num_steps = input_obj.num_steps
self.hidden_size = hidden_size
# 让这里的操作和变量用 CPU 来计算，因为暂时（貌似）还没有 GPU 的实现
with tf.device("/cpu:0"):
# 创建 词向量（Word Embedding），Embedding 表示 Dense Vector（密集向量）
# 词向量本质上是一种单词聚类（Clustering）的方法
embedding = tf.Variable(tf.random_uniform([vocab_size, self.hidden_size], -init_scale, init_scale))
# embedding_lookup 返回词向量
inputs = tf.nn.embedding_lookup(embedding, self.input_obj.input_data)
# 如果是 训练时 并且 dropout 率小于 1，使输入经过一个 Dropout 层
# Dropout 防止过拟合
if is_training and dropout < 1:
inputs = tf.nn.dropout(inputs, dropout)
# 状态（state）的存储和提取
# 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：
# 一个是 前一时刻 LSTM 的输出 h(t-1)
# 一个是 前一时刻的单元状态 C(t-1)
# 这个 C 和 h 是用于构建之后的 tf.contrib.rnn.LSTMStateTuple
self.init_state = tf.placeholder(tf.float32, [num_layers, 2, self.batch_size, self.hidden_size])
# 每一层的状态
state_per_layer_list = tf.unstack(self.init_state, axis=0)
# 初始的状态（包含 前一时刻 LSTM 的输出 h(t-1) 和 前一时刻的单元状态 C(t-1)），用于之后的 dynamic_rnn
rnn_tuple_state = tuple(
[tf.contrib.rnn.LSTMStateTuple(state_per_layer_list[idx][0], state_per_layer_list[idx][1])
for idx in range(num_layers)]
)
# 创建一个 LSTM 层，其中的神经元数目是 hidden_size 个（默认 650 个）
cell = tf.contrib.rnn.LSTMCell(hidden_size)
# 如果是训练时 并且 Dropout 率小于 1，给 LSTM 层加上 Dropout 操作
# 这里只给 输出 加了 Dropout 操作，留存率(output_keep_prob)是 0.5
# 输入则是默认的 1，所以相当于输入没有做 Dropout 操作
if is_training and dropout < 1:
cell = tf.contrib.rnn.DropoutWrapper(cell, output_keep_prob=dropout)
# 如果 LSTM 的层数大于 1, 则总计创建 num_layers 个 LSTM 层
# 并将所有的 LSTM 层包装进 MultiRNNCell 这样的序列化层级模型中
# state_is_tuple=True 表示接受 LSTMStateTuple 形式的输入状态
if num_layers > 1:
cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_layers)], state_is_tuple=True)
# dynamic_rnn（动态 RNN）可以让不同迭代传入的 Batch 可以是长度不同的数据
# 但同一次迭代中一个 Batch 内部的所有数据长度仍然是固定的
# dynamic_rnn 能更好处理 padding（补零）的情况，节约计算资源
# 返回两个变量：
# 第一个是一个 Batch 里在时间维度（默认是 35）上展开的所有 LSTM 单元的输出，形状默认为 [20, 35, 650]，之后会经过扁平层处理
# 第二个是最终的 state（状态），包含 当前时刻 LSTM 的输出 h(t) 和 当前时刻的单元状态 C(t)
output, self.state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32, initial_state=rnn_tuple_state)
# 扁平化处理，改变输出形状为 (batch_size * num_steps, hidden_size)，形状默认为 [700, 650]
output = tf.reshape(output, [-1, hidden_size]) # -1 表示 自动推导维度大小
# Softmax 的权重（Weight）
softmax_w = tf.Variable(tf.random_uniform([hidden_size, vocab_size], -init_scale, init_scale))
# Softmax 的偏置（Bias）
softmax_b = tf.Variable(tf.random_uniform([vocab_size], -init_scale, init_scale))
# logits 是 Logistic Regression（用于分类）模型（线性方程： y = W * x + b ）计算的结果（分值）
# 这个 logits（分值）之后会用 Softmax 来转成百分比概率
# output 是输入（x）， softmax_w 是 权重（W），softmax_b 是偏置（b）
# 返回 W * x + b 结果
logits = tf.nn.xw_plus_b(output, softmax_w, softmax_b)
# 将 logits 转化为三维的 Tensor，为了 sequence loss 的计算
# 形状默认为 [20, 35, 10000]
logits = tf.reshape(logits, [self.batch_size, self.num_steps, vocab_size])
# 计算 logits 的序列的交叉熵（Cross-Entropy）的损失（loss）
loss = tf.contrib.seq2seq.sequence_loss(
logits, # 形状默认为 [20, 35, 10000]
self.input_obj.targets, # 期望输出，形状默认为 [20, 35]
tf.ones([self.batch_size, self.num_steps], dtype=tf.float32),
average_across_timesteps=False,
average_across_batch=True)
# 更新代价（cost）
self.cost = tf.reduce_sum(loss)
# Softmax 算出来的概率
self.softmax_out = tf.nn.softmax(tf.reshape(logits, [-1, vocab_size]))
# 取最大概率的那个值作为预测
self.predict = tf.cast(tf.argmax(self.softmax_out, axis=1), tf.int32)
# 预测值和真实值（目标）对比
correct_prediction = tf.equal(self.predict, tf.reshape(self.input_obj.targets, [-1]))
# 计算预测的精度
self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 如果是 测试，则直接退出
if not is_training:
return
# 学习率。trainable=False 表示“不可被训练”
self.learning_rate = tf.Variable(0.0, trainable=False)
# 返回所有可被训练（trainable=True。如果不设定 trainable=False，默认的 Variable 都是可以被训练的）
# 也就是除了不可被训练的 学习率 之外的其他变量
tvars = tf.trainable_variables()
# tf.clip_by_global_norm（实现 Gradient Clipping（梯度裁剪））是为了防止梯度爆炸
# tf.gradients 计算 self.cost 对于 tvars 的梯度（求导），返回一个梯度的列表
grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars), 5)
# 优化器用 GradientDescentOptimizer（梯度下降优化器）
optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)
# apply_gradients（应用梯度）将之前用（Gradient Clipping）梯度裁剪过的梯度 应用到可被训练的变量上去，做梯度下降
# apply_gradients 其实是 minimize 方法里面的第二步，第一步是 计算梯度
self.train_op = optimizer.apply_gradients(
zip(grads, tvars),
global_step=tf.train.get_or_create_global_step())
# 用于更新 学习率
self.new_lr = tf.placeholder(tf.float32, shape=[])
self.lr_update = tf.assign(self.learning_rate, self.new_lr)
# 更新 学习率
def assign_lr(self, session, lr_value):
session.run(self.lr_update, feed_dict={self.new_lr: lr_value})