详情参考:LSTM基础教程
#LSTM预测示例
# -*- coding: utf-8 -*-
import numpy as np
import tensorflow as tf
import sklearn.preprocessing as sk
import sklearn.metrics as sm
import time
import sys
import os
import matplotlib
from matplotlib import rc
import matplotlib.pyplot as pl
import random
import pickle
def getData():
with open('./Data/data.npy', 'rb') as file_:
data = np.load(file_)
return data[::10,:-1]
def scaleData(X):
scaler = sk.StandardScaler()
scaler = scaler.fit(X)
X_scaled = scaler.transform(X)
return X_scaled, scaler
def generateData(X, lookback_time, pred_time):
dataX, dataY = [], []
for i in range(len(X) - lookback_time):
dataX.append(X[i:i+lookback_time,:])
dataY.append(X[i+lookback_time:i+lookback_time+pred_time,:])
return np.array(dataX), np.array(dataY)
def computeLossFunction(Y, prediction, loss_weight, lambda_loss_amount):
#output = sum(t**2)/2
l2 = lambda_loss_amount*sum(tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables())
loss_ = tf.matmul(tf.reduce_mean(tf.squared_difference(prediction, Y), 0), loss_weight)/sum(loss_weight)
loss = loss_[0][0] + l2
return loss
def computeNumberOfModelParameters():
total_parameters = 0
for variable in tf.trainable_variables():
shape = variable.get_shape()
variable_parameters = 1
for dim in shape:
variable_parameters *= dim.value
total_parameters += variable_parameters
return total_parameters
cpu_time1 = time.time()
#Create folders for saving
save_dir = ['./Data/', './Figures/', 'Network']
for path in save_dir:
if os.path.exists(path) is False:
os.makedirs(path)
print('#'*10 + ' Generate data for train and test' + '#'*10)
data = getData()
data_train = data[:200000]
data_val = data[200000:220000]
data_mean = np.mean(data_train, axis=0)
datakc = data_train - np.matlib.repmat(data_mean, data_train.shape[0], 1)
Ek = np.mean(datakc**2, 0)
loss_weights = np.float32(np.reshape(np.sqrt(Ek), (-1, 1)))
input_size = data.shape[1]
output_size = input_size
lookback_time = 40
pred_time = 1
hidden_size = 20
number_of_layers = 5
X_train, Y_train = generateData(data_train, lookback_time, pred_time)
X_train_reshaped = np.reshape(X_train, (X_train.shape[0]*X_train.shape[1], input_size))
Y_train_reshaped = np.reshape(Y_train, (Y_train.shape[0]*Y_train.shape[1], output_size))
X_train_scaled, scaler_input = scaleData(X_train_reshaped)
Y_train_scaled, scaler_output = scaleData(Y_train_reshaped)
X_train = np.reshape(X_train_scaled, (X_train.shape[0], X_train.shape[1], input_size))
Y_train = np.reshape(Y_train_scaled, (Y_train.shape[0], Y_train.shape[1], output_size))
X_val, Y_val = generateData(data_val, lookback_time, pred_time)
X_val_reshaped = np.reshape(X_val, (X_val.shape[0]*X_val.shape[1], input_size))
Y_val_reshaped = np.reshape(Y_val, (Y_val.shape[0]*Y_val.shape[1], output_size))
X_val_scaled = scaler_input.transform(X_val_reshaped)
Y_val_scaled = scaler_output.transform(Y_val_reshaped)
X_val = np.reshape(X_val_scaled, (X_val.shape[0], X_val.shape[1], input_size))
Y_val = np.reshape(Y_val_scaled, (Y_val.shape[0], Y_val.shape[1], output_size))
#Is_training = True
Is_training = False
if Is_training:
batch_size = 100
print('#'*10 + ' Create the graph' + '#'*10)
tf.reset_default_graph()
X = tf.placeholder(tf.float32, [None, lookback_time, input_size], name='input_x')
Y = tf.placeholder(tf.float32, [None, pred_time, output_size], name='input_y')
states = tf.placeholder(tf.float32, [number_of_layers, 2, None, hidden_size], name='lstm_states')
tuple_states = tuple([tf.contrib.rnn.LSTMStateTuple(states[i][0], states[i][1]) for i in range(number_of_layers)])
lam = tf.placeholder(tf.float32, name='lam')
with tf.variable_scope('lstm'):
lstm_cells = []
for _ in range(number_of_layers):
lstm_cells.append(tf.contrib.rnn.BasicLSTMCell(hidden_size, forget_bias=1.0, state_is_tuple=True, activation=tf.nn.softsign))
multi_lstm = tf.contrib.rnn.MultiRNNCell(cells=lstm_cells, state_is_tuple=True)
lstm_outputs, states = tf.nn.dynamic_rnn(multi_lstm, X, dtype=tf.float32, initial_state=tuple_states)
with tf.variable_scope('output_lstm'):
weights = tf.get_variable('weights', shape=[hidden_size*pred_time, input_size], initializer=tf.contrib.layers.xavier_initializer())
biases = tf.get_variable('biases', shape=[pred_time, input_size], initializer=tf.constant_initializer(0.1))
output_lstm = tf.matmul(lstm_outputs[:,-1,:], weights)
output_lstm = tf.reshape(output_lstm, [tf.shape(output_lstm)[0], pred_time, input_size])
prediction = output_lstm + biases
#0.95: 5e-6:2.5==>5e-7:5.6==>5e-8:7.3==>5e-9:7.3==>1e-6:2.5
loss = computeLossFunction(Y, prediction, loss_weights, lam)
loss_val = computeLossFunction(Y, prediction, loss_weights, 0.0)
learning_rate = 0.001
decay_rate = 0.98
global_step = tf.Variable(0, trainable=False)
lr_adam = tf.train.exponential_decay(learning_rate, global_step, 1, decay_rate, staircase=False)
optimizer = tf.train.AdamOptimizer(lr_adam)
train = optimizer.minimize(loss)
optimizer_train = tf.train.GradientDescentOptimizer(lr_adam)
train_train = optimizer_train.minimize(loss)
total_parameters = computeNumberOfModelParameters()
print('# Number of parameters: {:}'.format(total_parameters))
saver = tf.train.Saver(max_to_keep=10000)
tf.add_to_collection('prediction', prediction)
sess = tf.Session()
no_of_batches = int(np.ceil(np.shape(X_train)[0]/batch_size))
#n_train_per_epoch = X_train.shape[0]/4.0
epoches = 250
p = epoches #Patience
Ni = [-9]
for i in Ni:
v = 0
beta_ = 1*pow(10, i)
parameters = '_LB=' + str(lookback_time) + '_HS=' + str(hidden_size) + '_beta_=' + str(beta_)
print('\n# lambda:', beta_)
print('#'*10 + ' Training' + '#'*10)
init = tf.global_variables_initializer()
sess.run(init)
ep = 1
k = 0
v = 1e10
resX, resLB, resLV = [], [], []
while (ep<=epoches and k<=p):
k_train = 1
j_trained_before = 0
ptr = 0
for j in range(no_of_batches-1):
states_batch = np.zeros((number_of_layers, 2, batch_size, hidden_size))
X_train_batch = X_train[ptr:ptr+batch_size,:,:]
Y_train_batch = Y_train[ptr:ptr+batch_size,:,:]
feed_dict = {X:X_train_batch, Y:Y_train_batch, states:states_batch, global_step:ep, lam:beta_}
if (j - j_trained_before == k_train):
j_trained_before = j
k_train = random.randrange(1, 5)
sess.run(train, feed_dict = feed_dict)
ptr += batch_size
loss_batch = sess.run(loss, feed_dict=feed_dict)
# c_state_val, h_state_val = np.zeros((X_val.shape[0], hidden_size)), np.zeros((X_val.shape[0], hidden_size))
# loss_epoch = sess.run(loss_val, feed_dict={X:X_val, Y:Y_val, c_state:c_state_val, h_state:h_state_val})
# sys.stdout.write('\r# Val Epoch={:d} Loss_val={:.7f}'.format(ep, loss_epoch))
# sys.stdout.flush()
# if (loss_epoch <= v):
# v = loss_epoch
# k = 0
# saver.save(sess, './Network/lstm'+parameters)
# print('# Save the graph beta_={:}'.format(beta_))
# else:
# k += 1
# resX.append(beta_)
# resLB.append(loss_batch)
# resLV.append(loss_epoch)
ep += 1
saver.save(sess, './Network/ex42_lstm'+parameters)
print('# Save the graph beta_={:}'.format(beta_))
# resX, resLB, resLV = np.array(resX), np.array(resLB), np.array(resLV)
# LOSS = {'X':resX, 'LB':resLB, 'LV':resLV}
# with open('./Data/lstm' + parameters + '_loss.pickle', 'wb') as file_:
# pickle.dump(LOSS, file_)
else:
beta_ = 1*pow(10, -9)
h = 0.01
parameters = '_LB=' + str(lookback_time) + '_HS=' + str(hidden_size) + '_beta_=' + str(beta_)
stand = np.sqrt(np.mean(pow(np.linalg.norm(data, axis=1), 2)))
tf.reset_default_graph()
sess = tf.Session()
new_saver = tf.train.import_meta_graph('./Network/ex42_lstm'+parameters+'.meta')
new_saver.restore(sess, './Network/ex42_lstm'+parameters)
prediction = tf.get_collection('prediction')[0]
graph = tf.get_default_graph()
input_x = graph.get_operation_by_name('input_x').outputs[0]
lstm_c = graph.get_operation_by_name('lstm_c').outputs[0]
lstm_h = graph.get_operation_by_name('lstm_h').outputs[0]
for k in range(227000, 228000, 1600):
TEST_EXAMPLES = 2000
X_test = data[k:k+lookback_time,:]
X_test_scaled = scaler_input.transform(X_test)
Y_test = data[k+lookback_time:k+lookback_time+TEST_EXAMPLES,:]
batch_size = 1
sys.stdout.write('\r'+'#'*10+' Test '+str(k)+' '+'#'*10)
sys.stdout.flush()
result, real, err, dif = [], [], [], []
x_test_batch = X_test_scaled.reshape((batch_size, lookback_time, input_size))
for i in range(TEST_EXAMPLES):
c_state_test, h_state_test = np.zeros((batch_size, hidden_size)), np.zeros((batch_size, hidden_size))
y_test_batch = sess.run(prediction, feed_dict={input_x:x_test_batch, lstm_c:c_state_test, lstm_h:h_state_test})
y_test_batch_reshaped = np.reshape(y_test_batch, [-1, output_size])
y_test_batch_scaled = scaler_output.inverse_transform(y_test_batch_reshaped)
# x_test_batch_last = np.reshape(x_test_batch[:,-1,:], (batch_size, input_size))
# x_test_batch_last_scaled = scaler_input.inverse_transform(x_test_batch_last)
# x_pred = x_test_batch_last_scaled + y_test_batch_scaled
x_pred = y_test_batch_scaled
result.append(x_pred)
real.append(Y_test[i])
error = np.linalg.norm(x_pred - Y_test[i])/stand
err.append(error)
dif.append(x_pred - Y_test[i])
x_feed_scaled = scaler_input.transform(x_pred)
x_feed_scaled = np.reshape(x_feed_scaled, (1, pred_time, input_size))
x_test_batch = np.concatenate((x_test_batch, x_feed_scaled), axis=1)
x_test_batch = x_test_batch[:, pred_time:lookback_time+pred_time,:]
result = np.reshape(np.array(result), (-1, output_size))
real = np.reshape(np.array(real), (-1, output_size))
err = np.array(err).reshape(-1, 1)
dif = np.reshape(np.array(dif), (-1, output_size))
err_s = [j for j, err_e in enumerate(err) if err_e > 0.1]
if len(err_s) != 0:
tv = err_s[0]*h
else:
tv = len(real)*h
T_pre = np.linspace(0, h*len(real), len(real))
figsize = 10, 10
figure, ax = pl.subplots(figsize=figsize)
pl.rc("text", usetex=True)
font1 = {'family' : 'Times New Roman',
'weight' : 'normal',
'size' : 18, }
font2 = {'family' : 'Times New Roman',
'weight' : 'normal',
'size' : 30,
}
ax1 = pl.subplot(411)
pl.plot(T_pre, result[:,0], '-r', label=r'$Predicted$', linewidth=2)
pl.plot(T_pre, real[:,0], '--b', label=r'$Actual$', linewidth=2)
pl.legend(loc=1, ncol=2, prop=font1)
pl.ylabel(r'$u(t)$', font2)
pl.xticks([])
pl.xlim(0, h*len(real))
pl.tick_params(labelsize=20)
pl.title('$(a)$', fontsize=30, loc='left')
labels = ax1.get_xticklabels() + ax1.get_yticklabels()
[label.set_fontname('Times New Roman') for label in labels]
ax1.set_xticks([])
ax1 = pl.subplot(412)
pl.plot(T_pre, result[:,1], '-r', label=r'$Predicted$', linewidth=2)
pl.plot(T_pre, real[:,1], '--b', label=r'$Actual$', linewidth=2)
pl.ylabel(r'$v(t)$', font2)
pl.xticks([])
pl.xlim(0, h*len(real))
pl.tick_params(labelsize=20)
labels = ax1.get_xticklabels() + ax1.get_yticklabels()
[label.set_fontname('Times New Roman') for label in labels]
ax1.set_xticks([])
ax1 = pl.subplot(413)
pl.plot(T_pre, result[:,2], '-r', label=r'$Predicted$', linewidth=2)
pl.plot(T_pre, real[:,2], '--b', label=r'$Actual$', linewidth=2)
pl.ylabel(r'$\theta(t)$', font2)
pl.xticks([])
pl.xlim(0, h*len(real))
pl.tick_params(labelsize=20)
labels = ax1.get_xticklabels() + ax1.get_yticklabels()
[label.set_fontname('Times New Roman') for label in labels]
ax1.set_xticks([])
ax4 = pl.subplot(414)
pl.plot(T_pre, err, '-r', linewidth=2)
pl.axvline(tv, color='k', linewidth=2)
pl.axhline(0.1, color='k', linewidth=2)
pl.ylabel(r'$E(t)$', font2)
pl.xlabel(r'$t$', font2)
pl.ylim(0, 2)
pl.xlim(0, h*len(real))
pl.tick_params(labelsize=20)
labels = ax4.get_xticklabels() + ax4.get_yticklabels()
[label.set_fontname('Times New Roman') for label in labels]
#ax3.set_xticks([])
pl.savefig('./Figures/ex42_lstm'+parameters+'.png', dpi=600)
pl.savefig('./Figures/ex42_lstm'+parameters+'.pdf', dpi=600)
cpu_time2 = time.time()
print("Time Used :{:.2f}s".format(cpu_time2 - cpu_time1))
注:以上内容仅供参考,转载请注明出处。