探秘最炙手可热的人工智能框架TensorFlow

Alan

6 年前

环境搭建可参考Django环境搭建及开发的环境搭建部分，也可参照TensorFlow官网

pip install --upgrade tensorflow
# 其它所需包
pip install --upgrade numpy pandas matplotlib

pip install --upgrade tensorflow

# 其它所需包

pip install --upgrade numpy pandas matplotlib

本文主要内容

TensorFlow的基础知识

TensorFlow经典的数据流图
TensorFlow的Hello World
TensorBoard
TensorFlow的操作(Operations)

TensorFlow的使用案例

梯度下降解决线性回归
激活函数(Activation Function)
实现CNN(Convolution Neural Network)卷积神经网络
RNN-LSTM循环神经网络

TensorFlow的基础知识

TensorFlow经典的数据流图

图中的各个节点是操作(Operation)，中间的线是张量(Tensor)

TensorFlow的Hello World

import tensorflow as tf

# 创建一个常量Operation
hw = tf.constant("Hello World!")
# 启动会话
sess = tf.Session()
# 运行Graph（计算图）
print(sess.run(hw))
# 关闭会话
sess.close()

import tensorflow as tf

# 创建一个常量Operation

hw = tf.constant("Hello World!")

# 启动会话

sess = tf.Session()

# 运行Graph（计算图）

print(sess.run(hw))

# 关闭会话

sess.close()

Tensor有以下几种：constant(常量), Variable(变量), placeholder(占位符),SparseTensor(稀疏张量)

TensorBoard

# 1.用TensorFlow保存图的消息到日志中
tf.summary.FileWriter(path, sess.graph)
# 2.用TensorBoard读取并展示日志（命令行）
tensorboard --logdir=日志所在路径

# 1.用TensorFlow保存图的消息到日志中

tf.summary.FileWriter(path, sess.graph)

# 2.用TensorBoard读取并展示日志（命令行）

tensorboard --logdir=日志所在路径

如以下是后面卷积神经网络示例的TensorBoard

Playground

TensorFlow的操作(Operations)

TensorFlow的使用案例

梯度下降解决线性回归

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf


# 构建数据
points_num = 100
vectors = []
# 用Numpy的正态随机分页函数生成100个点
# 这些点的(x,y)坐标值对应线性方程 y = 0.1 * x + 0.2
for i in range(points_num):
    x1 = np.random.normal(0.0, 0.66)
    y1 = x1 * 0.1 + 0.2 + np.random.normal(0.0, 0.04)
    vectors.append([x1, y1])


x_data = [v[0] for v in vectors] # 真实点的x坐标
y_data = [v[1] for v in vectors] # 真实点的y坐标

# 图像1：展示100个随机数据点
plt.plot(x_data, y_data, 'r*', label="Original data") # 红色星形的点
plt.title("Linear Regression using Gradient Descent")
plt.legend()
plt.show()

# 构建线性回归模型
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0)) # 初始化 Weight
b = tf.Variable(tf.zeros([1])) # 初始化 Bias
y = W * x_data + b # 模型计算出来的y

# 定义 loss function(损失函数) 或 cost function(代价函数)
# 对 Tensor的所有维度计算 ((y - y_data) ^ 2)之和 / N
loss = tf.reduce_mean(tf.square(y - y_data))

# 用梯度下降的优化器来优化我们的 loss function
optimizer = tf.train.GradientDescentOptimizer(0.5) # 设置学习率0.5
train = optimizer.minimize(loss)

# 创建会话
sess = tf.Session()

# 初始化数据流图中的所有变量
init = tf.global_variables_initializer()
sess.run(init)

# 训练 20 步
for step in range(20):
    # 优化每一步
    sess.run(train)
    # 打印出每一步的损失、权重和偏差
    print("Step=%d, Loss=%f, [Weight=%f Bias=%f]" % (step, sess.run(loss), sess.run(W), sess.run(b)) )

# 图像2： 绘制所有的点并且绘制出最佳拟合的直线
plt.plot(x_data, y_data, 'r*', label="Original data") # 红色星形的点
plt.title("Linear Regression using Gradient Descent")
plt.plot(x_data, sess.run(W) * x_data + sess.run(b), label="Fitted line") # 拟合的线
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.show()

# 关闭会话
sess.close()

import numpy as np

import matplotlib.pyplot as plt

import tensorflow as tf

# 构建数据

points_num = 100

vectors = []

# 用Numpy的正态随机分页函数生成100个点

# 这些点的(x,y)坐标值对应线性方程 y = 0.1 * x + 0.2

for i in range(points_num):

x1 = np.random.normal(0.0, 0.66)

y1 = x1 * 0.1 + 0.2 + np.random.normal(0.0, 0.04)

vectors.append([x1, y1])

x_data = [v[0] for v in vectors] # 真实点的x坐标

y_data = [v[1] for v in vectors] # 真实点的y坐标

# 图像1：展示100个随机数据点

plt.plot(x_data, y_data, 'r*', label="Original data") # 红色星形的点

plt.title("Linear Regression using Gradient Descent")

plt.legend()

plt.show()

# 构建线性回归模型

W = tf.Variable(tf.random_uniform([1], -1.0, 1.0)) # 初始化 Weight

b = tf.Variable(tf.zeros([1])) # 初始化 Bias

y = W * x_data + b # 模型计算出来的y

# 定义 loss function(损失函数) 或 cost function(代价函数)

# 对 Tensor的所有维度计算 ((y - y_data) ^ 2)之和 / N

loss = tf.reduce_mean(tf.square(y - y_data))

# 用梯度下降的优化器来优化我们的 loss function

optimizer = tf.train.GradientDescentOptimizer(0.5) # 设置学习率0.5

train = optimizer.minimize(loss)

# 创建会话

sess = tf.Session()

# 初始化数据流图中的所有变量

init = tf.global_variables_initializer()

sess.run(init)

# 训练 20 步

for step in range(20):

# 优化每一步

sess.run(train)

# 打印出每一步的损失、权重和偏差

print("Step=%d, Loss=%f, [Weight=%f Bias=%f]" % (step, sess.run(loss), sess.run(W), sess.run(b)) )

# 图像2：绘制所有的点并且绘制出最佳拟合的直线

plt.plot(x_data, y_data, 'r*', label="Original data") # 红色星形的点

plt.title("Linear Regression using Gradient Descent")

plt.plot(x_data, sess.run(W) * x_data + sess.run(b), label="Fitted line") # 拟合的线

plt.legend()

plt.xlabel('x')

plt.ylabel('y')

plt.show()

# 关闭会话

sess.close()

激活函数(Activation Function)

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# 创建输入数据
x = np.linspace(-7, 7, 180) # (-7, 7)之间等间隔的180个点

#激活函数的原始实现
def sigmoid(inputs):
    y = [1 / float(1 + np.exp(-x))  for x in inputs]
    return y

def relu(inputs):
    y = [x * (x>0) for x in inputs]
    return y

def tanh(inputs):
    y = [(np.exp(x) - np.exp(-x)) / float(np.exp(x) + np.exp(-x)) for x in inputs]
    return y

def softplus(inputs):
    y = [np.log(1 + np.exp(x)) for x in inputs]
    return y

# 经过 TensorFlow的激活函数处理的各个 Y值
y_sigmoid = tf.nn.sigmoid(x)
y_relu = tf.nn.relu(x)
y_tanh = tf.nn.tanh(x)
y_softplus = tf.nn.softplus(x)

# 创建会话
sess = tf.Session()

# 运行
y_sigmoid, y_relu, y_tanh, y_softplus = sess.run([y_sigmoid, y_relu, y_tanh, y_softplus])

# 创建各个激活函数的图像
plt.subplot(221)
plt.plot(x, y_sigmoid, c="red", label="Sigmoid")
plt.ylim(-0.2, 1.2)
plt.legend(loc="best")

plt.subplot(222)
plt.plot(x, y_relu, c="red", label="Relu")
plt.ylim(-1, 6)
plt.legend(loc="best")

plt.subplot(223)
plt.plot(x, y_tanh, c="red", label="Tanh")
plt.ylim(-1.3, 1.3)
plt.legend(loc="best")

plt.subplot(224)
plt.plot(x, y_softplus, c="red", label="Softplus")
plt.ylim(-1, 6)
plt.legend(loc="best")

# 显示图像
plt.show()

#关闭会话
sess.close()

import numpy as np

import matplotlib.pyplot as plt

import tensorflow as tf

# 创建输入数据

x = np.linspace(-7, 7, 180) # (-7, 7)之间等间隔的180个点

#激活函数的原始实现

def sigmoid(inputs):

y = [1 / float(1 + np.exp(-x)) for x in inputs]

return y

def relu(inputs):

y = [x * (x>0) for x in inputs]

return y

def tanh(inputs):

y = [(np.exp(x) - np.exp(-x)) / float(np.exp(x) + np.exp(-x)) for x in inputs]

return y

def softplus(inputs):

y = [np.log(1 + np.exp(x)) for x in inputs]

return y

# 经过 TensorFlow的激活函数处理的各个 Y值

y_sigmoid = tf.nn.sigmoid(x)

y_relu = tf.nn.relu(x)

y_tanh = tf.nn.tanh(x)

y_softplus = tf.nn.softplus(x)

# 创建会话

sess = tf.Session()

# 运行

y_sigmoid, y_relu, y_tanh, y_softplus = sess.run([y_sigmoid, y_relu, y_tanh, y_softplus])

# 创建各个激活函数的图像

plt.subplot(221)

plt.plot(x, y_sigmoid, c="red", label="Sigmoid")

plt.ylim(-0.2, 1.2)

plt.legend(loc="best")

plt.subplot(222)

plt.plot(x, y_relu, c="red", label="Relu")

plt.ylim(-1, 6)

plt.legend(loc="best")

plt.subplot(223)

plt.plot(x, y_tanh, c="red", label="Tanh")

plt.ylim(-1.3, 1.3)

plt.legend(loc="best")

plt.subplot(224)

plt.plot(x, y_softplus, c="red", label="Softplus")

plt.ylim(-1, 6)

plt.legend(loc="best")

# 显示图像

plt.show()

#关闭会话

sess.close()

深度学习的三大模型：

CNN（Convolution Neural Network）卷积神经网络
RNN（Recurrent Neural Network）循环神经网络
DBN（Deep Belief Network）深度信念网络

实现CNN(Convolution Neural Network)卷积神经网络

import numpy as np
import tensorflow as tf
# 下载并载入 MNIST 手写数字库(55000张28*28像素的图片)
from tensorflow.examples.tutorials.mnist import input_data

# mnist_data可自定义的数据存储目录，one_hot是独热码的编码形式：0-9的表示形式为0: 1000000000, 1: 0100000000...
mnist = input_data.read_data_sets('mnist_data', one_hot=True)

# None 表示张量(Tensor)的第一个维度可以是任何长度
input_x = tf.placeholder(tf.float32, [None, 28 * 28]) / 255 # 除255是因为有0-255的灰度值
output_y = tf.placeholder(tf.int32, [None, 10]) # 输出: 10个数字的标签
input_x_images = tf.reshape(input_x, [-1, 28, 28 ,1]) # 改变形状之后的输入

# 从 Test测试数据集中选取3000全手写数字的图片和对应标签
test_x = mnist.test.images[:3000] # 图片
test_y = mnist.test.labels[:3000] # 标签

# 构建卷积神经网络
# 第 1 层卷积
# output_size =1+ (input_size+2*padding-kernel_size)/stride
conv1 = tf.layers.conv2d(
    inputs=input_x_images, # 形状 [28, 28, 1]
    filters=32,            # 32个过滤器，输出的深度是32
    kernel_size=[5, 5],    # 过滤器在二维的大小是5 * 5
    strides=1,             # 步长是1
    padding='same',        # same表示输出的大小不变，需要在外围补0（需补0两圈）
    activation=tf.nn.relu  # 激活函数使用 Relu
) # 形状 [28, 28, 32]

# 第 1 层池化（亚采样）
pool1 = tf.layers.max_pooling2d(
    inputs=conv1,          # 形状 [28, 28, 32]
    pool_size=[2, 2],      # 过滤器在二维的大小是2 * 2
    strides=2,             # 步长是2
) # 形状 [14, 14, 32]

# 第 2 层卷积
conv2 = tf.layers.conv2d(
    inputs=pool1,          # 形状 [14, 14, 32]
    filters=64,            # 64个过滤器，输出的深度是64
    kernel_size=[5, 5],    # 过滤器在二维的大小是5 * 5
    strides=1,             # 步长是1
    padding='same',        # same表示输出的大小不变，需要在外围补0（需补0两圈）
    activation=tf.nn.relu  # 激活函数使用 Relu
) # 形状 [14, 14, 64]

# 第 2 层池化（亚采样）
pool2 = tf.layers.max_pooling2d(
    inputs=conv2,          # 形状 [14, 14, 64]
    pool_size=[2, 2],      # 过滤器在二维的大小是2 * 2
    strides=2,             # 步长是2
) # 形状 [7, 7, 64]

# 平坦化（Flat）
flat = tf.reshape(pool2, [-1, 7 * 7 * 64]) # 形状 7 * 7 * 64

# 1024 个神经元的全连接层
dense = tf.layers.dense(inputs=flat, units=1024, activation=tf.nn.relu)

# Dropout: 丢弃 50%, rate=0.5
dropout = tf.layers.dropout(inputs=dense, rate=0.5)

# 10 个神经元的全连接层，此处无需激活函数来做非线性化
logits = tf.layers.dense(inputs=dropout, units=10) # 输入形状 1 * 1 * 10

# 计算误差（计算 Cross entropy交叉熵，再用Softmax计算百分比概率）
loss = tf.losses.softmax_cross_entropy(
    onehot_labels=output_y,
    logits=logits
)

# Adam优化器来最小化误差，学习率0.001
train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

# 精度：计算预测值和实际标签的匹配程度
# 返回(accuracy, update_op),会创建两个局部变量
accuracy = tf.metrics.accuracy(
    labels=tf.argmax(output_y, axis=1),
    predictions=tf.argmax(logits, axis=1),)[1]

# 创建会话
sess = tf.Session()
# 初始化全局变量和局部变量
init = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer())
sess.run(init)

for i in range(20000):
    batch = mnist.train.next_batch(50) # 从 Train训练数据集取一组50个样本
    train_loss, train_op_ = sess.run([loss, train_op], {input_x: batch[0], output_y: batch[1]})
    if i % 100 == 0:
        test_accuracy = sess.run(accuracy, {input_x: test_x, output_y: test_y})
        print("Step=%d, Train loss=%.4f, [Test accuracy=%.2f]" % (i, train_loss, test_accuracy))

# 测试：打印20个预测值和真实值对
test_output = sess.run(logits, {input_x: test_x[:20]})
inferenced_y = np.argmax(test_output, 1)
print(inferenced_y, 'Inferenced numbers') # 推测的数字
print(np.argmax(test_y[:20], 1), 'Real numbers') # 真实的数字

import numpy as np

import tensorflow as tf

# 下载并载入 MNIST 手写数字库(55000张28*28像素的图片)

from tensorflow.examples.tutorials.mnist import input_data

# mnist_data可自定义的数据存储目录，one_hot是独热码的编码形式：0-9的表示形式为0: 1000000000, 1: 0100000000...

mnist = input_data.read_data_sets('mnist_data', one_hot=True)

# None 表示张量(Tensor)的第一个维度可以是任何长度

input_x = tf.placeholder(tf.float32, [None, 28 * 28]) / 255 # 除255是因为有0-255的灰度值

output_y = tf.placeholder(tf.int32, [None, 10]) # 输出: 10个数字的标签

input_x_images = tf.reshape(input_x, [-1, 28, 28 ,1]) # 改变形状之后的输入

# 从 Test测试数据集中选取3000全手写数字的图片和对应标签

test_x = mnist.test.images[:3000] # 图片

test_y = mnist.test.labels[:3000] # 标签

# 构建卷积神经网络

# 第 1 层卷积

# output_size =1+ (input_size+2*padding-kernel_size)/stride

conv1 = tf.layers.conv2d(

inputs=input_x_images, # 形状 [28, 28, 1]

filters=32, # 32个过滤器，输出的深度是32

kernel_size=[5, 5], # 过滤器在二维的大小是5 * 5

strides=1, # 步长是1

padding='same', # same表示输出的大小不变，需要在外围补0（需补0两圈）

activation=tf.nn.relu # 激活函数使用 Relu

) # 形状 [28, 28, 32]

# 第 1 层池化（亚采样）

pool1 = tf.layers.max_pooling2d(

inputs=conv1, # 形状 [28, 28, 32]

pool_size=[2, 2], # 过滤器在二维的大小是2 * 2

strides=2, # 步长是2

) # 形状 [14, 14, 32]

# 第 2 层卷积

conv2 = tf.layers.conv2d(

inputs=pool1, # 形状 [14, 14, 32]

filters=64, # 64个过滤器，输出的深度是64

kernel_size=[5, 5], # 过滤器在二维的大小是5 * 5

strides=1, # 步长是1

padding='same', # same表示输出的大小不变，需要在外围补0（需补0两圈）

activation=tf.nn.relu # 激活函数使用 Relu

) # 形状 [14, 14, 64]

# 第 2 层池化（亚采样）

pool2 = tf.layers.max_pooling2d(

inputs=conv2, # 形状 [14, 14, 64]

pool_size=[2, 2], # 过滤器在二维的大小是2 * 2

strides=2, # 步长是2

) # 形状 [7, 7, 64]

# 平坦化（Flat）

flat = tf.reshape(pool2, [-1, 7 * 7 * 64]) # 形状 7 * 7 * 64

# 1024 个神经元的全连接层

dense = tf.layers.dense(inputs=flat, units=1024, activation=tf.nn.relu)

# Dropout: 丢弃 50%, rate=0.5

dropout = tf.layers.dropout(inputs=dense, rate=0.5)

# 10 个神经元的全连接层，此处无需激活函数来做非线性化

logits = tf.layers.dense(inputs=dropout, units=10) # 输入形状 1 * 1 * 10

# 计算误差（计算 Cross entropy交叉熵，再用Softmax计算百分比概率）

loss = tf.losses.softmax_cross_entropy(

onehot_labels=output_y,

logits=logits

)

# Adam优化器来最小化误差，学习率0.001

train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

# 精度：计算预测值和实际标签的匹配程度

# 返回(accuracy, update_op),会创建两个局部变量

accuracy = tf.metrics.accuracy(

labels=tf.argmax(output_y, axis=1),

predictions=tf.argmax(logits, axis=1),)[1]

# 创建会话

sess = tf.Session()

# 初始化全局变量和局部变量

init = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer())

sess.run(init)

for i in range(20000):

batch = mnist.train.next_batch(50) # 从 Train训练数据集取一组50个样本

train_loss, train_op_ = sess.run([loss, train_op], {input_x: batch[0], output_y: batch[1]})

if i % 100 == 0:

test_accuracy = sess.run(accuracy, {input_x: test_x, output_y: test_y})

print("Step=%d, Train loss=%.4f, [Test accuracy=%.2f]" % (i, train_loss, test_accuracy))

# 测试：打印20个预测值和真实值对

test_output = sess.run(logits, {input_x: test_x[:20]})

inferenced_y = np.argmax(test_output, 1)

print(inferenced_y, 'Inferenced numbers') # 推测的数字

print(np.argmax(test_y[:20], 1), 'Real numbers') # 真实的数字

训练结果如下

Step=0, Train loss=2.3087, [Test accuracy=0.22]
Step=100, Train loss=0.1605, [Test accuracy=0.57]
...
Step=19800, Train loss=0.0000, [Test accuracy=0.98]
Step=19900, Train loss=0.0067, [Test accuracy=0.98]
[7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 3 4] Inferenced numbers
[7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 3 4] Real numbers

Step=0, Train loss=2.3087, [Test accuracy=0.22]

Step=100, Train loss=0.1605, [Test accuracy=0.57]

...

Step=19800, Train loss=0.0000, [Test accuracy=0.98]

Step=19900, Train loss=0.0067, [Test accuracy=0.98]

[7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 3 4] Inferenced numbers

[7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 3 4] Real numbers

RNN-LSTM循环神经网络

RNN问题：梯度消失、梯度爆炸

LSTM: Long Short-Term Memory

扩展阅读：Understanding LSTM Networks

LSTM神经元的“三重门”机制

PTB数据集：

wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz

本例中使用data文件夹下的ptb.test.txt，ptb.train.txt，ptb.valid.txt三个文件

utils.py

import os, sys
import argparse
import datetime
import collections

import numpy as np
import tensorflow as tf

"""
==== 超参数（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（随机梯度下降），防止被困在局部最小值）
"""

# 数据集目录
data_path = "/Users/alan/Desktop/demo/simple-examples/data"
# 保存训练所得的模型参数文件的目录
save_path = "./save"
# 测试时读取模型参数文件的名称
load_file = "train-checkpoint-69"

parser = argparse.ArgumentParser()
parser.add_argument('--data_path', type=str, default=data_path, help='Path to data for training and testing')
parser.add_argument('--load_file', type=str, default=load_file, help='Path to checkpoint file of model variables during training')

args = parser.parse_args()
# 判断是否 Python3 版本
Py3 = sys.version_info[0] == 3

# 将文件根据语句结束标识符(<eos>)来分割
def read_words(filename):
    with tf.gfile.GFile(filename, "r") as f:
        if Py3:
            return f.read().replace("\n", "<eos>").split()
        else:
            return f.read().decode("utf-8").replace("\n", "<eos>").split()

# 构造从单词到唯一整数值的映射
def build_vocab(filename):
    data = read_words(filename)

    # 用counter统计单词出现次数，并进行排序，如the最多对应整数为0，依此类推
    counter = collections.Counter(data)
    count_pairs = sorted(counter.items(), key= lambda x: (-x[1], x[0]))
    words, _ = list(zip(*count_pairs))

    # 单词到整数的映射
    word_to_id = dict(zip(words, range(len(words))))
    return word_to_id

# 将文件里的单词都替换成独一的整数
def file_to_word_ids(filename, word_to_id):
    data = read_words(filename)
    return [word_to_id[word] for word in data if word in word_to_id]

# 加载所有数据，读取所有单词，把将转成唯一对应的整数值
def load_data(data_path):
    # 三个数据集的路径
    train_path = os.path.join(data_path, "ptb.train.txt")
    valid_path = os.path.join(data_path, "ptb.valid.txt")
    test_path = os.path.join(data_path, "ptb.test.txt")

    # 建立词汇表，将所有单词转为唯一对应的整数值
    word_to_id = build_vocab(train_path)

    train_data = file_to_word_ids(train_path, word_to_id)
    valid_data = file_to_word_ids(valid_path, word_to_id)
    test_data = file_to_word_ids(test_path, word_to_id)
    # 所胡独五词汇的个数
    vocab_size = len(word_to_id)

    # 反转一个词汇表，以便之后从整数转为单词
    id_to_word = dict(zip(word_to_id.values(), word_to_id.keys()))

    print(word_to_id)
    print("=====================")
    print(vocab_size)
    print("=====================")
    print(train_data[:10])
    print("=====================")
    print(" ".join([id_to_word[x] for x in train_data[:10]]))
    return train_data, valid_data, test_data, vocab_size, id_to_word

# 生成批次样本
def generate_batches(raw_data, batch_size, num_steps):
    # 将数据转为 Tensor 类型
    raw_data = tf.convert_to_tensor(raw_data, name="raw_data", dtype=tf.int32)

    data_len = tf.size(raw_data)
    batch_len = data_len // batch_size

    # 将数据形状转为 [batch_size, batch_len]
    data = tf.reshape(raw_data[0: batch_size * batch_len],
                      [batch_size, batch_len])

    epoch_size = (batch_len - 1) // num_steps

    # range_input_producer 可以用多线程异步的方式从数据集里提取数据
    # 用多线程可以加快训练，因为 feed_dict 的赋值方式效率不高
    # shuffle 为 False 表示不打乱数据而按照队列先进先出的方式提取数据
    i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue()

    # 假设一句话是这样： “我爱我的祖国和人民”
    # 那么，如果 x 是类似这样： “我爱我的祖国”
    x = data[:, i * num_steps:(i + 1) * num_steps]
    x.set_shape([batch_size, num_steps])
    # y 就是类似这样（正好是 x 的时间步长 + 1）： “爱我的祖国和”
    # 因为我们的模型就是要预测一句话中每一个单词的下一个单词
    # 当然这边的例子很简单，实际的数据不止一个维度
    y = data[:, i * num_steps + 1: (i + 1) * num_steps + 1]
    y.set_shape([batch_size, num_steps])

    return x, y

# 输入数据
class Input(object):
    def __init__(self, batch_size, num_steps, data):
        self.batch_size = batch_size
        self.num_steps = num_steps
        self.epoch_size = ((len(data) // batch_size) - 1) // num_steps
        # input_data 是输入，targets 是期望的输出
        self.input_data, self.targets = generate_batches(data, batch_size, num_steps)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

import os, sys

import argparse

import datetime

import collections

import numpy as np

import tensorflow as tf

"""

==== 超参数（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（随机梯度下降），防止被困在局部最小值）

"""

# 数据集目录

data_path = "/Users/alan/Desktop/demo/simple-examples/data"

# 保存训练所得的模型参数文件的目录

save_path = "./save"

# 测试时读取模型参数文件的名称

load_file = "train-checkpoint-69"

parser = argparse.ArgumentParser()

parser.add_argument('--data_path', type=str, default=data_path, help='Path to data for training and testing')

parser.add_argument('--load_file', type=str, default=load_file, help='Path to checkpoint file of model variables during training')

args = parser.parse_args()

# 判断是否 Python3 版本

Py3 = sys.version_info[0] == 3

# 将文件根据语句结束标识符(<eos>)来分割

def read_words(filename):

with tf.gfile.GFile(filename, "r") as f:

if Py3:

return f.read().replace("\n", "<eos>").split()

else:

return f.read().decode("utf-8").replace("\n", "<eos>").split()

# 构造从单词到唯一整数值的映射

def build_vocab(filename):

data = read_words(filename)

# 用counter统计单词出现次数，并进行排序，如the最多对应整数为0，依此类推

counter = collections.Counter(data)

count_pairs = sorted(counter.items(), key= lambda x: (-x[1], x[0]))

words, _ = list(zip(*count_pairs))

# 单词到整数的映射

word_to_id = dict(zip(words, range(len(words))))

return word_to_id

# 将文件里的单词都替换成独一的整数

def file_to_word_ids(filename, word_to_id):

data = read_words(filename)

return [word_to_id[word] for word in data if word in word_to_id]

# 加载所有数据，读取所有单词，把将转成唯一对应的整数值

def load_data(data_path):

# 三个数据集的路径

train_path = os.path.join(data_path, "ptb.train.txt")

valid_path = os.path.join(data_path, "ptb.valid.txt")

test_path = os.path.join(data_path, "ptb.test.txt")

# 建立词汇表，将所有单词转为唯一对应的整数值

word_to_id = build_vocab(train_path)

train_data = file_to_word_ids(train_path, word_to_id)

valid_data = file_to_word_ids(valid_path, word_to_id)

test_data = file_to_word_ids(test_path, word_to_id)

# 所胡独五词汇的个数

vocab_size = len(word_to_id)

# 反转一个词汇表，以便之后从整数转为单词

id_to_word = dict(zip(word_to_id.values(), word_to_id.keys()))

print(word_to_id)

print("=====================")

print(vocab_size)

print("=====================")

print(train_data[:10])

print("=====================")

print(" ".join([id_to_word[x] for x in train_data[:10]]))

return train_data, valid_data, test_data, vocab_size, id_to_word

# 生成批次样本

def generate_batches(raw_data, batch_size, num_steps):

# 将数据转为 Tensor 类型

raw_data = tf.convert_to_tensor(raw_data, name="raw_data", dtype=tf.int32)

data_len = tf.size(raw_data)

batch_len = data_len // batch_size

# 将数据形状转为 [batch_size, batch_len]

data = tf.reshape(raw_data[0: batch_size * batch_len],

[batch_size, batch_len])

epoch_size = (batch_len - 1) // num_steps

# range_input_producer 可以用多线程异步的方式从数据集里提取数据

# 用多线程可以加快训练，因为 feed_dict 的赋值方式效率不高

# shuffle 为 False 表示不打乱数据而按照队列先进先出的方式提取数据

i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue()

# 假设一句话是这样： “我爱我的祖国和人民”

# 那么，如果 x 是类似这样： “我爱我的祖国”

x = data[:, i * num_steps:(i + 1) * num_steps]

x.set_shape([batch_size, num_steps])

# y 就是类似这样（正好是 x 的时间步长 + 1）： “爱我的祖国和”

# 因为我们的模型就是要预测一句话中每一个单词的下一个单词

# 当然这边的例子很简单，实际的数据不止一个维度

y = data[:, i * num_steps + 1: (i + 1) * num_steps + 1]

y.set_shape([batch_size, num_steps])

return x, y

# 输入数据

class Input(object):

def __init__(self, batch_size, num_steps, data):

self.batch_size = batch_size

self.num_steps = num_steps

self.epoch_size = ((len(data) // batch_size) - 1) // num_steps

# input_data 是输入，targets 是期望的输出

self.input_data, self.targets = generate_batches(data, batch_size, num_steps)

network.py

import tensorflow as tf

# 神经网络的模型
class Model(object):
    def __init__(self, input, is_training, hidden_size, vocab_size, num_layers, dropout=0.5, init_scale=0.05):
        self.is_training = is_training
        self.input_obj = input
        self.batch_size = input.batch_size
        self.num_steps = input.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))
            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的权重
        softmax_w = tf.Variable(tf.random_uniform([hidden_size, vocab_size], -init_scale, init_scale))
        # Softmax的偏置
        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})

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

import tensorflow as tf

# 神经网络的模型

class Model(object):

def __init__(self, input, is_training, hidden_size, vocab_size, num_layers, dropout=0.5, init_scale=0.05):

self.is_training = is_training

self.input_obj = input

self.batch_size = input.batch_size

self.num_steps = input.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))

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的权重

softmax_w = tf.Variable(tf.random_uniform([hidden_size, vocab_size], -init_scale, init_scale))

# Softmax的偏置

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})

train.py

"""
训练神经网络模型

大家之后可以加上各种的 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（随机梯度下降），防止被困在局部最小值）
"""

from utils import *
from network import *


def train(train_data, vocab_size, num_layers, num_epochs, batch_size, model_save_name,
          learning_rate=1.0, max_lr_epoch=10, lr_decay=0.93, print_iter=50):
    # 训练的输入
    training_input = Input(batch_size=batch_size, num_steps=35, data=train_data)

    # 创建训练的模型
    m = Model(training_input, is_training=True, hidden_size=650, vocab_size=vocab_size, num_layers=num_layers)

    # 初始化变量的操作
    init_op = tf.global_variables_initializer()

    # 初始的学习率（learning rate）的衰减率
    orig_decay = lr_decay

    with tf.Session() as sess:
        sess.run(init_op)  # 初始化所有变量

        # Coordinator（协调器），用于协调线程的运行
        coord = tf.train.Coordinator()
        # 启动线程
        threads = tf.train.start_queue_runners(coord=coord)

        # 为了用 Saver 来保存模型的变量
        saver = tf.train.Saver() # max_to_keep 默认是 5, 只保存最近的 5 个模型参数文件

        # 开始 Epoch 的训练
        for epoch in range(num_epochs):
            # 只有 Epoch 数大于 max_lr_epoch（设置为 10）后，才会使学习率衰减
            # 也就是说前 10 个 Epoch 的学习率一直是 1, 之后每个 Epoch 学习率都会衰减
            new_lr_decay = orig_decay ** max(epoch + 1 - max_lr_epoch, 0)
            m.assign_lr(sess, learning_rate * new_lr_decay)

            # 当前的状态
            # 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：
            # 一个是 前一时刻 LSTM 的输出 h(t-1)
            # 一个是 前一时刻的单元状态 C(t-1)
            current_state = np.zeros((num_layers, 2, batch_size, m.hidden_size))

            # 获取当前时间，以便打印日志时用
            curr_time = datetime.datetime.now()

            for step in range(training_input.epoch_size):
                # train_op 操作：计算被修剪（clipping）过的梯度，并最小化 cost（误差）
                # state 操作：返回时间维度上展开的最后 LSTM 单元的输出（C(t) 和 h(t)），作为下一个 Batch 的输入状态
                if step % print_iter != 0:
                    cost, _, current_state = sess.run([m.cost, m.train_op, m.state], feed_dict={m.init_state: current_state})
                else:
                    seconds = (float((datetime.datetime.now() - curr_time).seconds) / print_iter)
                    curr_time = datetime.datetime.now()
                    cost, _, current_state, acc = sess.run([m.cost, m.train_op, m.state, m.accuracy], feed_dict={m.init_state: current_state})
                    # 每 print_iter（默认是 50）打印当下的 Cost（误差/损失）和 Accuracy（精度）
                    print("Epoch {}, 第 {} 步, 损失: {:.3f}, 精度: {:.3f}, 每步所用秒数: {:.2f}".format(epoch, step, cost, acc, seconds))

            # 保存一个模型的变量的 checkpoint 文件
            saver.save(sess, save_path + '/' + model_save_name, global_step=epoch)
        # 对模型做一次总的保存
        saver.save(sess, save_path + '/' + model_save_name + '-final')

        # 关闭线程
        coord.request_stop()
        coord.join(threads)


if __name__ == "__main__":
    if args.data_path:
        data_path = args.data_path
    train_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)

    train(train_data, vocab_size, num_layers=2, num_epochs=70, batch_size=20,
          model_save_name='train-checkpoint')

if __name__ == "__main__":
    if args.data_path:
        data_path = args.data_path
    train_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)

    train(train_data, vocab_size, num_layers=2, num_epochs=70, batch_size=20,
          model_save_name='train-checkpoint')

100

101

102

103

104

105

106

107

108

109

110

"""

训练神经网络模型

大家之后可以加上各种的 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（随机梯度下降），防止被困在局部最小值）

"""

from utils import *

from network import *

def train(train_data, vocab_size, num_layers, num_epochs, batch_size, model_save_name,

learning_rate=1.0, max_lr_epoch=10, lr_decay=0.93, print_iter=50):

# 训练的输入

training_input = Input(batch_size=batch_size, num_steps=35, data=train_data)

# 创建训练的模型

m = Model(training_input, is_training=True, hidden_size=650, vocab_size=vocab_size, num_layers=num_layers)

# 初始化变量的操作

init_op = tf.global_variables_initializer()

# 初始的学习率（learning rate）的衰减率

orig_decay = lr_decay

with tf.Session() as sess:

sess.run(init_op) # 初始化所有变量

# Coordinator（协调器），用于协调线程的运行

coord = tf.train.Coordinator()

# 启动线程

threads = tf.train.start_queue_runners(coord=coord)

# 为了用 Saver 来保存模型的变量

saver = tf.train.Saver() # max_to_keep 默认是 5, 只保存最近的 5 个模型参数文件

# 开始 Epoch 的训练

for epoch in range(num_epochs):

# 只有 Epoch 数大于 max_lr_epoch（设置为 10）后，才会使学习率衰减

# 也就是说前 10 个 Epoch 的学习率一直是 1, 之后每个 Epoch 学习率都会衰减

new_lr_decay = orig_decay ** max(epoch + 1 - max_lr_epoch, 0)

m.assign_lr(sess, learning_rate * new_lr_decay)

# 当前的状态

# 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：

# 一个是前一时刻 LSTM 的输出 h(t-1)

# 一个是前一时刻的单元状态 C(t-1)

current_state = np.zeros((num_layers, 2, batch_size, m.hidden_size))

# 获取当前时间，以便打印日志时用

curr_time = datetime.datetime.now()

for step in range(training_input.epoch_size):

# train_op 操作：计算被修剪（clipping）过的梯度，并最小化 cost（误差）

# state 操作：返回时间维度上展开的最后 LSTM 单元的输出（C(t) 和 h(t)），作为下一个 Batch 的输入状态

if step % print_iter != 0:

cost, _, current_state = sess.run([m.cost, m.train_op, m.state], feed_dict={m.init_state: current_state})

else:

seconds = (float((datetime.datetime.now() - curr_time).seconds) / print_iter)

curr_time = datetime.datetime.now()

cost, _, current_state, acc = sess.run([m.cost, m.train_op, m.state, m.accuracy], feed_dict={m.init_state: current_state})

# 每 print_iter（默认是 50）打印当下的 Cost（误差/损失）和 Accuracy（精度）

print("Epoch {}, 第 {} 步, 损失: {:.3f}, 精度: {:.3f}, 每步所用秒数: {:.2f}".format(epoch, step, cost, acc, seconds))

# 保存一个模型的变量的 checkpoint 文件

saver.save(sess, save_path + '/' + model_save_name, global_step=epoch)

# 对模型做一次总的保存

saver.save(sess, save_path + '/' + model_save_name + '-final')

# 关闭线程

coord.request_stop()

coord.join(threads)

if __name__ == "__main__":

if args.data_path:

data_path = args.data_path

train_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)

train(train_data, vocab_size, num_layers=2, num_epochs=70, batch_size=20,

model_save_name='train-checkpoint')

if __name__ == "__main__":

if args.data_path:

data_path = args.data_path

train_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)

train(train_data, vocab_size, num_layers=2, num_epochs=70, batch_size=20,

model_save_name='train-checkpoint')

test.py

from utils import *
from network import *

def test(model_path, test_data, vocab_size, id_to_word):
    # 测试的输入
    test_input = Input(batch_size=20, num_steps=35, data=test_data)
    # 创建测试的模型，基本的超参数需要和训练时用的一致，例如：
    # hidden_size，num_steps，num_layers，vocab_size，batch_size 等等
    # 因为我们要载入训练时保存的参数的文件，如果超参数不匹配 TensorFlow 会报错
    m = Model(test_input, is_training=False, hidden_size=650, vocab_size=vocab_size, num_layers=2)
    # 为了用 Saver 来恢复训练时生成的模型的变量
    saver = tf.train.Saver()

    with tf.Session() as sess:
        # Coordinator（协调器），用于协调线程的运行
        coord = tf.train.Coordinator()
        # 启动线程
        threads = tf.train.start_queue_runners(coord=coord)
        # 当前的状态
        # 第二维是 2 是因为测试时指定只有 2 层 LSTM
        # 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：
        # 一个是 前一时刻 LSTM 的输出 h(t-1)
        # 一个是 前一时刻的单元状态 C(t-1)
        current_state = np.zeros((2, 2, m.batch_size, m.hidden_size))
        # 恢复被训练的模型的变量
        saver.restore(sess, model_path)

        # 测试30个批次
        num_acc_batches = 30
        # 打印预测单词和实际单词的批次数
        check_batch_idx = 25
        # 超过5个批次才开始累加精度
        acc_check_thresh = 5
        # 初始精度的和，用于之后算平均精度
        accuracy = 0

        for batch in range(num_acc_batches):
            if batch == check_batch_idx:
                true, pred, current_state, acc = sess.run([m.input_obj.targets, m.predict, m.state, m.accuracy],
                                                          feed_dict={m.init_state: current_state})
                pred_words = [id_to_word[x] for x in pred[:m.num_steps]]
                true_words = [id_to_word[x] for x in true[0]]
                print("True words (1st line) vs. predicted words (2nd line)")
                print(" ".join(true_words)) # 真实的单词
                print(" ".join(pred_words)) # 预测的单词
            else:
                acc, current_state = sess.run([m.accuracy, m.state],feed_dict={m.init_state: current_state})
            if batch >= accuracy:
                accuracy += acc
        # 打印平均精度
        print("Average accuracy: {:.3f}".format(accuracy / (num_acc_batches - acc_check_thresh)))
        # 关闭线程
        coord.request_stop()
        coord.join(threads)

if __name__ == "__main__":
    if args.data_path:
        data_path = args.data_path
    if args.load_file:
        load_file = args.load_file

    train_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)

    trained_model = save_path + '/' + load_file

    test(trained_model, test_data, vocab_size, id_to_word)

from utils import *

from network import *

def test(model_path, test_data, vocab_size, id_to_word):

# 测试的输入

test_input = Input(batch_size=20, num_steps=35, data=test_data)

# 创建测试的模型，基本的超参数需要和训练时用的一致，例如：

# hidden_size，num_steps，num_layers，vocab_size，batch_size 等等

# 因为我们要载入训练时保存的参数的文件，如果超参数不匹配 TensorFlow 会报错

m = Model(test_input, is_training=False, hidden_size=650, vocab_size=vocab_size, num_layers=2)

# 为了用 Saver 来恢复训练时生成的模型的变量

saver = tf.train.Saver()

with tf.Session() as sess:

# Coordinator（协调器），用于协调线程的运行

coord = tf.train.Coordinator()

# 启动线程

threads = tf.train.start_queue_runners(coord=coord)

# 当前的状态

# 第二维是 2 是因为测试时指定只有 2 层 LSTM

# 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：

# 一个是前一时刻 LSTM 的输出 h(t-1)

# 一个是前一时刻的单元状态 C(t-1)

current_state = np.zeros((2, 2, m.batch_size, m.hidden_size))

# 恢复被训练的模型的变量

saver.restore(sess, model_path)

# 测试30个批次

num_acc_batches = 30

# 打印预测单词和实际单词的批次数

check_batch_idx = 25

# 超过5个批次才开始累加精度

acc_check_thresh = 5

# 初始精度的和，用于之后算平均精度

accuracy = 0

for batch in range(num_acc_batches):

if batch == check_batch_idx:

true, pred, current_state, acc = sess.run([m.input_obj.targets, m.predict, m.state, m.accuracy],

feed_dict={m.init_state: current_state})

pred_words = [id_to_word[x] for x in pred[:m.num_steps]]

true_words = [id_to_word[x] for x in true[0]]

print("True words (1st line) vs. predicted words (2nd line)")

print(" ".join(true_words)) # 真实的单词

print(" ".join(pred_words)) # 预测的单词

else:

acc, current_state = sess.run([m.accuracy, m.state],feed_dict={m.init_state: current_state})

if batch >= accuracy:

accuracy += acc

# 打印平均精度

print("Average accuracy: {:.3f}".format(accuracy / (num_acc_batches - acc_check_thresh)))

# 关闭线程

coord.request_stop()

coord.join(threads)

if __name__ == "__main__":

if args.data_path:

data_path = args.data_path

if args.load_file:

load_file = args.load_file

train_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)

trained_model = save_path + '/' + load_file

test(trained_model, test_data, vocab_size, id_to_word)

在Mac上进行一次训练需耗时30多分钟，写这篇文章时训练仍在进行，以下是第二次训练完成后执行test.py的结果，可以看到精确度还是很低的：

True words (1st line) vs. predicted words (2nd line)

stock market is headed many traders were afraid to trust stock prices quoted on the big board <eos> the futures halt was even <unk> by big board floor traders <eos> it <unk> things up said

is market is n’t by of said <unk> to be <eos> prices <eos> at a dollar board <eos> the dollar index that a a in a board in in said the is a that a

Average accuracy: 0.236