def make_plots(context, predictions_timesteps, true_values, look_ahead, title,
path, save_figure, Xserver):
step = 1
if look_ahead > 1:
step = look_ahead - 1
for idx, i in enumerate(np.arange(0, look_ahead, step)):
fig = plt.figure()
#plt.title(title+" Timestep: %d "%i)
plt.xlabel("Time step")
plt.ylabel("Power Consumption")
plt.plot(true_values,
label="True value",
linewidth=1,
color=sns.xkcd_rgb["denim blue"])
plt.plot(predictions_timesteps[:, i],
label="Predicted value",
linewidth=1,
linestyle="--",
color=sns.xkcd_rgb["medium green"])
error = abs(true_values - predictions_timesteps[:, i])
plt.plot(error,
label='Error',
color=sns.xkcd_rgb["pale red"],
linewidth=0.5)
plt.legend(bbox_to_anchor=(1, .99))
plt.tight_layout()
if save_figure:
util.save_figure(path, "%s_timestep_%d" % (context, i), fig)
if Xserver:
plt.show()
def make_plots(context,predictions_timesteps,true_values,look_ahead,title,path,save_figure):
step = 1
if look_ahead > 1:
step = look_ahead - 1
for idx, i in enumerate(np.arange(0, look_ahead, step)):
fig = plt.figure()
plt.title(" Timestep: %d "%i)
plt.xlabel("Time Step")
plt.ylabel("Power Consumption")
plt.plot(true_values, label="actual", linewidth=1)
plt.plot(predictions_timesteps[:, i], label="prediction", linewidth=1, linestyle="--")
error = abs(true_values - predictions_timesteps[:, i])
plt.plot(error, label="error", linewidth=0.5)
plt.legend()
plt.tight_layout()
if save_figure:
util.save_figure(path,"%s_timestep_%d"%(context,i), fig)
plt.show()
def make_plots(context,predictions_timesteps,true_values,look_ahead,title,path,save_figure,Xserver):
step = 1
if look_ahead > 1:
step = look_ahead - 1
for idx, i in enumerate(np.arange(0, look_ahead, step)):
fig = plt.figure()
#plt.title(title+" Timestep: %d "%i)
plt.xlabel("Time Step")
plt.ylabel("Power Consumption")
plt.plot(true_values, label="actual", linewidth=1)
plt.plot(predictions_timesteps[:, i], label="prediction", linewidth=1, linestyle="--")
error = abs(true_values - predictions_timesteps[:, i])
plt.plot(error, label="error", linewidth=0.5)
plt.legend()
plt.tight_layout()
if save_figure:
util.save_figure(path,"%s_timestep_%d"%(context,i), fig)
if Xserver:
plt.show()
def make_plots(context,predictions_timesteps,true_values,look_ahead,title,path,save_figure,Xserver):
step = 1
if look_ahead > 1:
step = look_ahead - 1
for idx, i in enumerate(np.arange(0, look_ahead, step)):
fig = plt.figure()
#plt.title(title+" Timestep: %d "%i)
plt.xlabel("Time step")
plt.ylabel("Power Consumption")
plt.plot(true_values, label="True value", linewidth=1,color=sns.xkcd_rgb["denim blue"])
plt.plot(predictions_timesteps[:, i], label="Predicted value", linewidth=1, linestyle="--",color=sns.xkcd_rgb["medium green"])
error = abs(true_values - predictions_timesteps[:, i])
plt.plot(error, label='Error',color=sns.xkcd_rgb["pale red"], linewidth=0.5)
plt.legend(bbox_to_anchor=(1, .99))
plt.tight_layout()
if save_figure:
util.save_figure(path,"%s_timestep_%d"%(context,i), fig)
if Xserver:
plt.show()
def run():
print "************* RUNING LSTM PREDICTOR *************"
# load config settings
experiment_id = cfg.run_config['experiment_id']
data_folder = cfg.run_config['data_folder']
look_back = cfg.multi_step_lstm_config['look_back']
# look_back = lookback
look_ahead = cfg.multi_step_lstm_config['look_ahead']
# look_ahead = lookahead
batch_size = cfg.multi_step_lstm_config['batch_size']
epochs = cfg.multi_step_lstm_config['n_epochs']
# epochs = epoch
dropout = cfg.multi_step_lstm_config['dropout']
layers = cfg.multi_step_lstm_config['layers']
loss = cfg.multi_step_lstm_config['loss']
# optimizer = cfg.multi_step_lstm_config['optimizer']
shuffle = cfg.multi_step_lstm_config['shuffle']
patience = cfg.multi_step_lstm_config['patience']
validation = cfg.multi_step_lstm_config['validation']
learning_rate = cfg.multi_step_lstm_config['learning_rate']
logging.info(
"--------------------------Start Running--------------------------")
logging.info('Run id %s' % (experiment_id))
logging.info(" HYPERPRAMRAMS : %s" % (str(locals())))
train_scaler, X_train, y_train, X_validation1, y_validation1, X_validation2, y_validation2, validation2_labels, \
X_test, y_test, test_labels = util.load_data(
data_folder, look_back, look_ahead)
multistep_lstm = lstm.MultiStepLSTM(look_back=look_back, look_ahead=look_ahead,
layers=layers,
dropout=dropout, loss=loss, learning_rate=learning_rate)
model = multistep_lstm.build_model()
# if cfg.run_config['save_figure']:
# plot_model(model, to_file="imgs/%s_lstm.png" %
# (experiment_id), show_shapes=True, show_layer_names=True)
# train model on training set. validation1 set is used for early stopping
fig = plt.figure()
history = lstm.train_model(model, X_train, y_train, batch_size, epochs,
shuffle, validation, (X_validation1, y_validation1), patience)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
# TODO: Show Plot!
# plt.show()
if cfg.run_config['save_figure']:
util.save_figure("%s/%s/" %
("imgs", experiment_id), "train_errors", fig)
validation2_loss = model.evaluate(
X_validation2, y_validation2, batch_size=batch_size, verbose=2)
print "Validation2 Loss %s" % (validation2_loss)
logging.info("Validation2 Loss %s" % (validation2_loss))
test_loss = model.evaluate(
X_test, y_test, batch_size=batch_size, verbose=2)
print "Test Loss %s" % (test_loss)
logging.info("Test Loss %s" % (test_loss))
print "----------- Training finished, start making predictions -----------"
logging.info(
"----------- Training finished, start making predictions -----------")
predictions_train, y_true_train = get_predictions("Train", model, X_train, y_train, train_scaler,
batch_size, look_ahead, look_back, epochs, experiment_id,
)
np.save(data_folder + "train_predictions", predictions_train)
np.save(data_folder + "train_true", y_true_train)
predictions_validation1, y_true_validation1 = get_predictions("Validation1", model, X_validation1, y_validation1,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation1_scaled = train_scaler.transform(
predictions_validation1)
print "Calculated validation1 loss %f" % (mean_squared_error(
np.reshape(y_validation1, [len(y_validation1), look_ahead]),
np.reshape(predictions_validation1_scaled, [len(predictions_validation1_scaled), look_ahead])))
np.save(data_folder + "validation1_predictions", predictions_validation1)
np.save(data_folder + "validation1_true", y_true_validation1)
np.save(data_folder + "validation1_labels", validation2_labels)
predictions_validation2, y_true_validation2 = get_predictions("Validation2", model, X_validation2, y_validation2,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation2_scaled = train_scaler.transform(
predictions_validation2)
print "Calculated validation2 loss %f" % (mean_squared_error(
np.reshape(y_validation2, [len(y_validation2), look_ahead]),
np.reshape(predictions_validation2_scaled, [len(predictions_validation2_scaled), look_ahead])))
np.save(data_folder + "validation2_predictions", predictions_validation2)
np.save(data_folder + "validation2_true", y_true_validation2)
np.save(data_folder + "validation2_labels", validation2_labels)
predictions_test, y_true_test = get_predictions("Test", model, X_test, y_test, train_scaler, batch_size, look_ahead,
look_back, epochs, experiment_id,
)
predictions_test_scaled = train_scaler.transform(predictions_test)
print "Calculated test loss %f" % (mean_squared_error(np.reshape(y_test, [len(y_test), look_ahead]),
np.reshape(predictions_test_scaled, [len(predictions_test_scaled), look_ahead])))
np.save(data_folder + "test_predictions", predictions_test)
np.save(data_folder + "test_true", y_true_test)
np.save(data_folder + "test_labels", test_labels)
logging.info(
"---------------------------------------------------------------------")
logging.info("Validation2 Loss %s" % (validation2_loss))
logging.info("Test Loss %s" % (test_loss))
logging.info(
"------------------------------ run complete ------------------------------")
logging.info("")
def run():
#load config settings
experiment_id = cfg.run_config['experiment_id']
data_folder = cfg.run_config['data_folder']
look_back = cfg.multi_step_lstm_config['look_back']
look_ahead = cfg.multi_step_lstm_config['look_ahead']
batch_size = cfg.multi_step_lstm_config['batch_size'] -(look_back+look_ahead) +1
epochs = cfg.multi_step_lstm_config['n_epochs']
dropout = cfg.multi_step_lstm_config['dropout']
layers = cfg.multi_step_lstm_config['layers']
loss = cfg.multi_step_lstm_config['loss']
# optimizer = cfg.multi_step_lstm_config['optimizer']
shuffle = cfg.multi_step_lstm_config['shuffle']
patience = cfg.multi_step_lstm_config['patience']
validation = cfg.multi_step_lstm_config['validation']
learning_rate = cfg.multi_step_lstm_config['learning_rate']
logging.info("----------------------------------------------------")
logging.info('Run id %s' % (experiment_id))
logging.info(" HYPERPRAMRAMS : %s" % (str(locals())))
train_scaler, X_train, y_train, X_validation1, y_validation1, X_validation2, y_validation2, validation2_labels, \
X_test, y_test, test_labels = util.load_data(data_folder, look_back, look_ahead)
#For stateful lstm the batch_size needs to be fixed before hand.
#We also need to ernsure that all batches shud have the same number of samples. So we drop the last batch as it has less elements than batch size
if batch_size > 1:
n_train_batches = len(X_train)/batch_size
len_train = n_train_batches * batch_size
if len_train < len(X_train):
X_train = X_train[:len_train]
y_train = y_train[:len_train]
n_validation1_batches = len(X_validation1)/batch_size
len_validation1 = n_validation1_batches * batch_size
if n_validation1_batches * batch_size < len(X_validation1):
X_validation1 = X_validation1[:len_validation1]
y_validation1 = y_validation1[:len_validation1]
n_validation2_batches = len(X_validation2) / batch_size
len_validation2 = n_validation2_batches * batch_size
if n_validation2_batches * batch_size < len(X_validation2):
X_validation2 = X_validation2[:len_validation2]
y_validation2 = y_validation2[:len_validation2]
n_test_batches = len(X_test)/batch_size
len_test = n_test_batches * batch_size
if n_test_batches * batch_size < len(X_test):
X_test = X_test[:len_test]
y_test = y_test[:len_test]
stateful_lstm = lstm.StatefulMultiStepLSTM(batch_size=batch_size, look_back=look_back, look_ahead=look_ahead,
layers=layers,
dropout=dropout, loss=loss, learning_rate=learning_rate)
model = stateful_lstm.build_model()
if cfg.run_config['save_figure']:
plot_model(model, to_file="imgs/%s_stateful_lstm.png"%(experiment_id), show_shapes=True, show_layer_names=True)
# train model on training set. validation1 set is used for early stopping
history = lstm.train_stateful_model(model, X_train, y_train, batch_size, epochs, shuffle, validation, (X_validation1, y_validation1),
patience)
fig = plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
if cfg.run_config['save_figure']:
util.save_figure("%s/%s/"%("imgs",experiment_id), "train_errors" , fig)
validation2_loss = model.evaluate(X_validation2, y_validation2, batch_size=batch_size, verbose=2)
print("Validation2 Loss %s" % (validation2_loss))
logging.info("Validation2 Loss %s" % (validation2_loss))
test_loss = model.evaluate(X_test, y_test, batch_size=batch_size, verbose=2)
print("Test Loss %s" % (test_loss))
logging.info("Test Loss %s" % (test_loss))
predictions_train, y_true_train = get_predictions("Train", model, X_train, y_train, train_scaler,
batch_size, look_ahead, look_back, epochs, experiment_id,
)
np.save(data_folder + "train_predictions", predictions_train)
np.save(data_folder + "train_true",y_true_train)
predictions_validation1, y_true_validation1 = get_predictions("Validation1", model, X_validation1, y_validation1,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation1_scaled = train_scaler.transform(predictions_validation1)
print("Calculated validation1 loss %f" % (mean_squared_error(
np.reshape(y_validation1, [len(y_validation1), look_ahead]),
np.reshape(predictions_validation1_scaled, [len(predictions_validation1_scaled), look_ahead]))))
np.save(data_folder + "validation1_predictions", predictions_validation1)
np.save(data_folder + "validation1_true", y_true_validation1)
predictions_validation2, y_true_validation2 = get_predictions("Validation2", model, X_validation2, y_validation2,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation2_scaled = train_scaler.transform(predictions_validation2)
print("Calculated validation2 loss %f"%(mean_squared_error(
np.reshape(y_validation2, [len(y_validation2), look_ahead]),
np.reshape(predictions_validation2_scaled, [len(predictions_validation2_scaled), look_ahead]))))
np.save(data_folder + "validation2_predictions", predictions_validation2)
np.save(data_folder + "validation2_true", y_true_validation2)
np.save(data_folder + "validation2_labels", validation2_labels)
predictions_test, y_true_test = get_predictions("Test", model, X_test, y_test, train_scaler, batch_size, look_ahead,
look_back, epochs, experiment_id,
)
predictions_test_scaled = train_scaler.transform(predictions_test)
print("Calculated test loss %f" % (mean_squared_error( np.reshape(y_test, [len(y_test),look_ahead]),
np.reshape(predictions_test_scaled, [len(predictions_test_scaled),look_ahead]))))
np.save(data_folder + "test_predictions", predictions_test)
np.save(data_folder + "test_true", y_true_test)
np.save(data_folder + "test_labels", test_labels)
logging.info("-------------------------run complete----------------------------------------------")
def run():
#load config settings
experiment_id = cfg.run_config['experiment_id']
data_folder = cfg.run_config['data_folder']
look_back = cfg.multi_step_lstm_config['look_back']
look_ahead = cfg.multi_step_lstm_config['look_ahead']
batch_size = cfg.multi_step_lstm_config['batch_size'] -(look_back+look_ahead) +1
epochs = cfg.multi_step_lstm_config['n_epochs']
dropout = cfg.multi_step_lstm_config['dropout']
layers = cfg.multi_step_lstm_config['layers']
loss = cfg.multi_step_lstm_config['loss']
# optimizer = cfg.multi_step_lstm_config['optimizer']
shuffle = cfg.multi_step_lstm_config['shuffle']
patience = cfg.multi_step_lstm_config['patience']
validation = cfg.multi_step_lstm_config['validation']
learning_rate = cfg.multi_step_lstm_config['learning_rate']
logging.info("----------------------------------------------------")
logging.info('Run id %s' % (experiment_id))
logging.info(" HYPERPRAMRAMS : %s" % (str(locals())))
train_scaler, X_train, y_train, X_validation1, y_validation1, X_validation2, y_validation2, validation2_labels, \
X_test, y_test, test_labels = util.load_data(data_folder, look_back, look_ahead)
#For stateful lstm the batch_size needs to be fixed before hand.
#We also need to ernsure that all batches shud have the same number of samples. So we drop the last batch as it has less elements than batch size
if batch_size > 1:
n_train_batches = len(X_train)/batch_size
len_train = n_train_batches * batch_size
if len_train < len(X_train):
X_train = X_train[:len_train]
y_train = y_train[:len_train]
n_validation1_batches = len(X_validation1)/batch_size
len_validation1 = n_validation1_batches * batch_size
if n_validation1_batches * batch_size < len(X_validation1):
X_validation1 = X_validation1[:len_validation1]
y_validation1 = y_validation1[:len_validation1]
n_validation2_batches = len(X_validation2) / batch_size
len_validation2 = n_validation2_batches * batch_size
if n_validation2_batches * batch_size < len(X_validation2):
X_validation2 = X_validation2[:len_validation2]
y_validation2 = y_validation2[:len_validation2]
n_test_batches = len(X_test)/batch_size
len_test = n_test_batches * batch_size
if n_test_batches * batch_size < len(X_test):
X_test = X_test[:len_test]
y_test = y_test[:len_test]
stateful_lstm = lstm.StatefulMultiStepLSTM(batch_size=batch_size, look_back=look_back, look_ahead=look_ahead,
layers=layers,
dropout=dropout, loss=loss, learning_rate=learning_rate)
model = stateful_lstm.build_model()
if cfg.run_config['save_figure']:
plot_model(model, to_file="imgs/%s_stateful_lstm.png"%(experiment_id), show_shapes=True, show_layer_names=True)
# train model on training set. validation1 set is used for early stopping
history = lstm.train_stateful_model(model, X_train, y_train, batch_size, epochs, shuffle, validation, (X_validation1, y_validation1),
patience)
fig = plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
if cfg.run_config['save_figure']:
util.save_figure("%s/%s/"%("imgs",experiment_id), "train_errors" , fig)
validation2_loss = model.evaluate(X_validation2, y_validation2, batch_size=batch_size, verbose=2)
print "Validation2 Loss %s" % (validation2_loss)
logging.info("Validation2 Loss %s" % (validation2_loss))
test_loss = model.evaluate(X_test, y_test, batch_size=batch_size, verbose=2)
print "Test Loss %s" % (test_loss)
logging.info("Test Loss %s" % (test_loss))
predictions_train, y_true_train = get_predictions("Train", model, X_train, y_train, train_scaler,
batch_size, look_ahead, look_back, epochs, experiment_id,
)
np.save(data_folder + "train_predictions", predictions_train)
np.save(data_folder + "train_true",y_true_train)
predictions_validation1, y_true_validation1 = get_predictions("Validation1", model, X_validation1, y_validation1,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation1_scaled = train_scaler.transform(predictions_validation1)
print "Calculated validation1 loss %f" % (mean_squared_error(
np.reshape(y_validation1, [len(y_validation1), look_ahead]),
np.reshape(predictions_validation1_scaled, [len(predictions_validation1_scaled), look_ahead])))
np.save(data_folder + "validation1_predictions", predictions_validation1)
np.save(data_folder + "validation1_true", y_true_validation1)
predictions_validation2, y_true_validation2 = get_predictions("Validation2", model, X_validation2, y_validation2,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation2_scaled = train_scaler.transform(predictions_validation2)
print "Calculated validation2 loss %f"%(mean_squared_error(
np.reshape(y_validation2, [len(y_validation2), look_ahead]),
np.reshape(predictions_validation2_scaled, [len(predictions_validation2_scaled), look_ahead])))
np.save(data_folder + "validation2_predictions", predictions_validation2)
np.save(data_folder + "validation2_true", y_true_validation2)
np.save(data_folder + "validation2_labels", validation2_labels)
predictions_test, y_true_test = get_predictions("Test", model, X_test, y_test, train_scaler, batch_size, look_ahead,
look_back, epochs, experiment_id,
)
predictions_test_scaled = train_scaler.transform(predictions_test)
print "Calculated test loss %f" % (mean_squared_error( np.reshape(y_test, [len(y_test),look_ahead]),
np.reshape(predictions_test_scaled, [len(predictions_test_scaled),look_ahead])))
np.save(data_folder + "test_predictions", predictions_test)
np.save(data_folder + "test_true", y_true_test)
np.save(data_folder + "test_labels", test_labels)
logging.info("-------------------------run complete----------------------------------------------")
def run():
#load config settings
experiment_id = cfg.run_config['experiment_id']
data_folder = cfg.run_config['data_folder']
look_back = cfg.multi_step_lstm_config['look_back']
look_ahead = cfg.multi_step_lstm_config['look_ahead']
batch_size = cfg.multi_step_lstm_config['batch_size'] -(look_back+look_ahead) +1
epochs = cfg.multi_step_lstm_config['n_epochs']
dropout = cfg.multi_step_lstm_config['dropout']
layers = cfg.multi_step_lstm_config['layers']
loss = cfg.multi_step_lstm_config['loss']
shuffle = cfg.multi_step_lstm_config['shuffle']
patience = cfg.multi_step_lstm_config['patience']
validation = cfg.multi_step_lstm_config['validation']
learning_rate = cfg.multi_step_lstm_config['learning_rate']
train_scaler, X_train, y_train, X_validation1, y_validation1, X_validation2, y_validation2, validation2_labels, \
X_test, y_test, test_labels = util.load_data(data_folder, look_back, look_ahead)
#For stateful lstm the batch_size needs to be fixed before hand.
#We also need to ernsure that all batches shud have the same number of samples. So we drop the last batch as it has less elements than batch size
if batch_size > 1:
n_train_batches = int(len(X_train)/batch_size)
len_train = n_train_batches * batch_size
if len_train < len(X_train):
X_train = X_train[:len_train]
y_train = y_train[:len_train]
n_validation1_batches = int(len(X_validation1)/batch_size)
len_validation1 = n_validation1_batches * batch_size
if n_validation1_batches * batch_size < len(X_validation1):
X_validation1 = X_validation1[:len_validation1]
y_validation1 = y_validation1[:len_validation1]
n_validation2_batches = int(len(X_validation2) / batch_size)
len_validation2 = n_validation2_batches * batch_size
if n_validation2_batches * batch_size < len(X_validation2):
X_validation2 = X_validation2[:len_validation2]
y_validation2 = y_validation2[:len_validation2]
n_test_batches = int(len(X_test)/batch_size)
len_test = n_test_batches * batch_size
if n_test_batches * batch_size < len(X_test):
X_test = X_test[:len_test]
y_test = y_test[:len_test]
stateful_lstm = lstm.StatefulMultiStepLSTM(batch_size=batch_size, look_back=look_back, look_ahead=look_ahead,
layers=layers,
dropout=dropout, loss=loss, learning_rate=learning_rate)
model = stateful_lstm.build_model()
history = lstm.train_stateful_model(model, X_train, y_train, batch_size, epochs, shuffle, validation, (X_validation1, y_validation1),
patience)
fig = plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
if cfg.run_config['save_figure']:
util.save_figure("%s/%s/"%("imgs",experiment_id), "train_errors" , fig)
validation2_loss = model.evaluate(X_validation2, y_validation2, batch_size=batch_size, verbose=2)
test_loss = model.evaluate(X_test, y_test, batch_size=batch_size, verbose=2)
predictions_train, y_true_train = get_predictions("Train", model, X_train, y_train, train_scaler,
batch_size, look_ahead, look_back, epochs, experiment_id,
)
np.save(data_folder + "train_predictions", predictions_train)
np.save(data_folder + "train_true",y_true_train)
predictions_validation1, y_true_validation1 = get_predictions("Validation1", model, X_validation1, y_validation1,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
np.save(data_folder + "validation1_predictions", predictions_validation1)
np.save(data_folder + "validation1_true", y_true_validation1)
predictions_validation2, y_true_validation2 = get_predictions("Validation2", model, X_validation2, y_validation2,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
np.save(data_folder + "validation2_predictions", predictions_validation2)
np.save(data_folder + "validation2_true", y_true_validation2)
np.save(data_folder + "validation2_labels", validation2_labels)
predictions_test, y_true_test = get_predictions("Test", model, X_test, y_test, train_scaler, batch_size, look_ahead,
look_back, epochs, experiment_id,
)
np.save(data_folder + "test_predictions", predictions_test)
np.save(data_folder + "test_true", y_true_test)
np.save(data_folder + "test_labels", test_labels)
def run():
#load config settings
experiment_id = cfg.run_config['experiment_id']
data_folder = cfg.run_config['data_folder']
look_back = cfg.multi_step_lstm_config['look_back']
look_ahead = cfg.multi_step_lstm_config['look_ahead']
batch_size = cfg.multi_step_lstm_config['batch_size']
epochs = cfg.multi_step_lstm_config['n_epochs']
dropout = cfg.multi_step_lstm_config['dropout']
layers = cfg.multi_step_lstm_config['layers']
loss = cfg.multi_step_lstm_config['loss']
# optimizer = cfg.multi_step_lstm_config['optimizer']
shuffle = cfg.multi_step_lstm_config['shuffle']
patience = cfg.multi_step_lstm_config['patience']
validation = cfg.multi_step_lstm_config['validation']
learning_rate = cfg.multi_step_lstm_config['learning_rate']
logging.info("----------------------------------------------------")
logging.info('Run id %s' % (experiment_id))
logging.info(" HYPERPRAMRAMS : %s" % (str(locals())))
train_scaler, X_train, y_train, X_validation1, y_validation1, X_validation2, y_validation2, validation2_labels, \
X_test, y_test, test_labels = util.load_data(data_folder, look_back, look_ahead)
multistep_lstm = lstm.MultiStepLSTM( look_back=look_back, look_ahead=look_ahead,
layers=layers,
dropout=dropout, loss=loss, learning_rate=learning_rate)
model = multistep_lstm.build_model()
if cfg.run_config['save_figure']:
plot_model(model, to_file="imgs/%s_lstm.png"%(experiment_id), show_shapes=True, show_layer_names=True)
# train model on training set. validation1 set is used for early stopping
fig = plt.figure()
history = lstm.train_model(model, X_train, y_train, batch_size, epochs, shuffle, validation, (X_validation1, y_validation1), patience)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
if cfg.run_config['save_figure']:
util.save_figure("%s/%s/" % ("imgs", experiment_id), "train_errors", fig)
validation2_loss = model.evaluate(X_validation2, y_validation2, batch_size=batch_size, verbose=2)
print "Validation2 Loss %s" % (validation2_loss)
logging.info("Validation2 Loss %s" % (validation2_loss))
test_loss = model.evaluate(X_test, y_test, batch_size=batch_size, verbose=2)
print "Test Loss %s" % (test_loss)
logging.info("Test Loss %s" % (test_loss))
predictions_train, y_true_train = get_predictions("Train", model, X_train, y_train, train_scaler,
batch_size, look_ahead, look_back, epochs, experiment_id,
)
np.save(data_folder + "train_predictions", predictions_train)
np.save(data_folder + "train_true",y_true_train)
predictions_validation1, y_true_validation1 = get_predictions("Validation1", model, X_validation1, y_validation1,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation1_scaled = train_scaler.transform(predictions_validation1)
print "Calculated validation1 loss %f" % (mean_squared_error(
np.reshape(y_validation1, [len(y_validation1), look_ahead]),
np.reshape(predictions_validation1_scaled, [len(predictions_validation1_scaled), look_ahead])))
np.save(data_folder + "validation1_predictions", predictions_validation1)
np.save(data_folder + "validation1_true", y_true_validation1)
np.save(data_folder + "validation1_labels", validation2_labels)
predictions_validation2, y_true_validation2 = get_predictions("Validation2", model, X_validation2, y_validation2,
train_scaler, batch_size, look_ahead, look_back,
epochs, experiment_id,
)
predictions_validation2_scaled = train_scaler.transform(predictions_validation2)
print "Calculated validation2 loss %f"%(mean_squared_error(
np.reshape(y_validation2, [len(y_validation2), look_ahead]),
np.reshape(predictions_validation2_scaled, [len(predictions_validation2_scaled), look_ahead])))
np.save(data_folder + "validation2_predictions", predictions_validation2)
np.save(data_folder + "validation2_true", y_true_validation2)
np.save(data_folder + "validation2_labels", validation2_labels)
predictions_test, y_true_test = get_predictions("Test", model, X_test, y_test, train_scaler, batch_size, look_ahead,
look_back, epochs, experiment_id,
)
predictions_test_scaled = train_scaler.transform(predictions_test)
print "Calculated test loss %f" % (mean_squared_error( np.reshape(y_test, [len(y_test),look_ahead]),
np.reshape(predictions_test_scaled, [len(predictions_test_scaled),look_ahead])))
np.save(data_folder + "test_predictions", predictions_test)
np.save(data_folder + "test_true", y_true_test)
np.save(data_folder + "test_labels", test_labels)
logging.info("-------------------------run complete----------------------------------------------")