1. rnn.BasicLSTMCell(num_hidden) # 构造单层的lstm网络结构
参数说明：num_hidden表示隐藏层的个数
2.tf.nn.dynamic_rnn(cell, self.x, tf.float32) # 执行lstm网络，获得state和outputs
参数说明：cell表示实例化的rnn网络，self.x表示输入层，tf.float32表示类型
3. tf.expand_dim(self.w, axis=0) 对数据增加一个维度
参数说明：self.w表示需要增加的数据维度，axis表示哪个维度进行增加
4. tf.tile(tf_expand, [num_example, 1, 1]) # 延某个方向进行平铺操作
参数说明：tf_expand表示输入的数据， [num_example, 1, 1] 表示延第一个维度进行num_example倍的平铺迭代
sess = tf.Session()
x = tf.constant([[1,2,1],[1,2,1]])
y = tf.tile(x, [2,1])
print(sess.run(y))
# 代码结果
[[1 2 1]
[1 2 1]
[1 2 1]
[1 2 1]]
5.tf.squeeze(out) # 将维度上为1的维度都进行去除， 代码中将[?, 4, 1] 变成了[?, 4]
参数说明：out为输入数据
代码说明：代码使用了类的构造方式，在初始化阶段，进行参数和输入数据的初始化，同时使用self.model() 构造输出结果y_pred即?, 4, 返回的结果，在初始化过程中，使用tf.reduce_mean(tf.square(y - self.model))计算损失值，使用梯度下降进行优化，使用self.train和self.test输入实际值， 进行模型的训练和预测
数据说明：自己构造[?, 4, 1] 的数据集，数据集的规律是前两个相加等于预测结果，预测样本的维度为[?, 4] 压缩了最后一个维度
模型说明：使用的是单层的cell = rnn.LTSMCell(hidden_num),使用tf.nn.dynamic_rnn(cell, self.x, shape=tf.float32) , 获得输出值维度为[?, 4, 10]
代码主要分为三个部分：
第一部分：主要是构造初始参数，以及self.model() 进行模型的结果输出即y_pred, 对返回值使用均分误差，并使用自适应梯度下降降低损失值，同时构造self.Saver()
第二部分：构造输入函数self.train(self, train_x, train_y) 进行模型的训练，使用self.Saver.save(sess, './model') 进行模型的参数的保存
第三部分：构造输入函数self.test(self.test_x) 进行模型的预测， 使用self.Saver.restore(sess, './model') 进行模型参数的加载
第一部分：
第一步：构造类SeriesPredictor， 使用self.input_size = input_size 将输入转换为内部使用的数
第二步：使用tf.placeholder构造x的维度为[None, seq_size, input_size], 构造y的维度为[None, seq_size], 使用tf.Variable()构造W的维度为[hidden_num, 1], 构造b的维度为[1]
第三步：构造self.model() 用于获得预测值y_pred
第一步：使用rnn.BasicLSTMCell(self.hidden_num) 构造单层的LSTM网络
第二步： 使用tf.nn.dynamic_rnn(cell, self.x, shape=tf.float32)获得outputs和states的输出值，outputs的维度为[?, 4, 10]
第三步：使用tf.shape(self.x)[0] 获得self.x的样品数目
第四步：使用tf.expand_dim增加self.w_out的维度， 再使用tf.tile(tf_expand, [num_examples, 1, 1]) 将第一个维度的大小变得和样本数目self.x的大小相等
第五步：使用tf.matmul(self.x, tf_tile) + self.b_out 获得输出值
第六步：使用tf.squeeze(out) 将out的维度从[?, 4, 1]压缩为[?, 4]
第四步：将self.model() 返回的输出值与self.y 做均分误差用于计算损失值
第五步：tf.train.Adaoptimzer().minimize(cost) # 用于进行损失值的梯度下降
第六步：使用tf.Saver() 构建每个类的存储函数
import tensorflow as tf
import numpy as np
from tensorflow.contrib import rnn class SeriesPredictor: def __init__(self, input_size, seq_size, hidden_num): self.input_size = input_size
self.seq_size = seq_size
self.hidden_num = hidden_num # 使用tf.placeholder设置x和y， 并且设置W, b
self.W_out = tf.Variable(tf.random_normal([hidden_num, 1]), name='W_out')
self.b_out = tf.Variable(tf.constant(0.1, shape=[1]), name='b_out')
self.x = tf.placeholder(tf.float32, [None, seq_size, input_size])
self.y = tf.placeholder(tf.float32, [None, seq_size]) self.cost = tf.reduce_mean(tf.square(self.model() - self.y))
self.train_op = tf.train.AdamOptimizer().minimize(self.cost) self.saver = tf.train.Saver() def model(self): cell = rnn.BasicLSTMCell(self.hidden_num)
outputs, states = tf.nn.dynamic_rnn(cell, self.x, dtype=tf.float32)
num_example = tf.shape(self.x)[0] tf_expand = tf.expand_dims(self.W_out, axis=0)
tf_tile = tf.tile(tf_expand, [num_example, 1, 1])
out = tf.matmul(outputs, tf_tile) + self.b_out
out = tf.squeeze(out) return out
第二部分：在类中构建train函数，输入train_x, train_y 进行模型的训练
第一步：构建sess, tf.get_variable_scope().reuse_variable() 进行模型的参数的复用， 模型的初始化
第二步：sess.run([train_op, cost], feed_dict=) 执行降低损失值和计算cost的操作
第三步：每循环200次，打印损失值和迭代次数i
第四步：self.saver.save(sess, './model') # 将模型参数的sess进行保存
def train(self, train_x, train_y):
# 第一步：构建sess，
with tf.Session() as sess:
# 模型参数的复用
tf.get_variable_scope().reuse_variables()
# 模型初始化
sess.run(tf.global_variables_initializer())
for i in range(1000):
# 第二步：执行降低损失值和计算cost
_, mse = sess.run([self.train_op, self.cost], feed_dict={self.x:train_x, self.y:train_y})
# 第三步：每循环200次，打印结果
if i % 200 == 0:
print(i, mse)
# 第四步：保存sess的参数
save_path = self.saver.save(sess, './model')
print('Model saved to {}'.format(save_path))
第三部分：构建test函数，输入为test_x, 加载sess参数，进行模型的预测
第一步：构建sess函数，使用tf.get_variable_scope().reuse_variable() 进行参数的复用
第二步：使用self.saver.restore(sess, './model') # 进行参数的加载
第三步：使用sess.run(self.model(), feed_dict={self.x:test_x}) 获得实际的预测值y_pred，返回预测的结果
def test(self, test_x):
# 第一步：构建sess，并进行模型参数的复用
with tf.Session() as sess:
tf.get_variable_scope().reuse_variables()
# 第二步：加载sess模型的参数
self.saver.restore(sess, './model')
# 第三步：输出模型的预测结果self.model, 返回结果
out = sess.run(self.model(), feed_dict={self.x:test_x})
return out
代码的主要调用函数
if __name__ == '__main__':
# 实例化模型，input_size表示每一次输入，seq_size表示一共有几个单元，hidden_num表示隐藏层的个数
predictor = SeriesPredictor(input_size=1, seq_size=4, hidden_num=10)
# 训练集的X
train_x = [[[1], [2], [5], [6]],
[[5], [7], [7], [8]],
[[3], [4], [5], [7]]]
# 训练集的y
train_y = [[1, 3, 7, 11],
[5, 12, 14, 15],
[3, 7, 9, 12]]
# 调用实例化函数的train进行模型训练
predictor.train(train_x, train_y)
# 测试集的x
test_x = [[[1], [2], [3], [4]], # 1, 3, 5, 7
[[4], [5], [6], [7]]]
# 测试集的y
actual_y = [[[1], [3], [5], [7]],
[[4], [9], [11], [13]]]
# 调用实例化的y进行模型的预测
pred_y = predictor.test(test_x)
# 打印输出的结果
for i, x in enumerate(test_x):
print('the input is {}'.format(x))
print('the actual y is {}'.format(actual_y[i]))
print('the pred y is {}'.format(pred_y[i]))
