def get_ae_2():
global exog_lag
global endo_lag
ae_obj_1 = get_ae_1()
X_train, _, Y_train, _, _ = data_feeder.get_data(True)
xformed_exog_train = ae_obj_1.model.predict(X_train)
_x1 = get_windowed_data(data=xformed_exog_train, window_size=exog_lag)
_y1 = get_windowed_data(data=Y_train, window_size=endo_lag)
num_samples = min(_x1.shape[0], _y1.shape[0])
_x1 = _x1[-num_samples:]
_y1 = _y1[-num_samples:]
ae2_train_data = np.concatenate([_x1, _y1], axis=-1)
ae_2_inp_dim = ae2_train_data.shape[-1]
name = str(2) + '_' + str(exog_lag) + '_' + str(endo_lag)
ae_obj_2 = ae_class(name)
ae_obj_2.set_hyperparams(layer_units=ae_2_units,
inp_dim=ae_2_inp_dim,
batch_size=128,
epochs=ae_2_epoch)
ae_obj_2.set_data(ae2_train_data)
ae_2_losses = ae_obj_2.load_model()
return ae_obj_1, ae_obj_2
def build_train_model():
global endo_lag
global exog_lag
global lstm_units
global lstm_batch_size
X_train, _, Y_train, _, _ = data_feeder.get_data(True)
ae_1_obj, ae_2_obj = get_ae_2()
xformed_exog_train = ae_1_obj.model.predict(X_train)
_x1 = get_windowed_data(data=xformed_exog_train, window_size=exog_lag)
_x2 = get_windowed_data(data=Y_train, window_size=endo_lag + 1)
_x2 = _x2[:, 0:endo_lag]
_y = _x2[:, -1:]
num_samples = min(_x1.shape[0], _x2.shape[0])
_x1 = _x1[-num_samples:]
_x2 = _x2[-num_samples:]
_y = _y[-num_samples:, :]
ae2_inp = np.concatenate([_x1, _x2], axis=-1)
x = ae_2_obj.model.predict(ae2_inp)
name = str(exog_lag) + '_' + str(endo_lag)
lstm_model_obj = lstm_model(name)
lstm_model_obj.set_hyperparams(lstm_units=lstm_units,
time_step=lstm_time_steps,
epochs=lstm_epochs,
batch_size=lstm_batch_size)
lstm_model_obj.set_train_data(x, _y)
train_mse = lstm_model_obj.load_model()
return ae_1_obj, ae_2_obj, lstm_model_obj, train_mse
def train_model(self):
exog_train, _, end_train, _, _ = data_feeder.get_data(True)
x1, x2, y = self.format_data_xy(exog_train, end_train)
hist = self.model.fit([x1,x2],y,epochs=self.epochs)
print hist.history['loss']
# self.model.save(self.model_file)
return
def ctdnn_get_data(window_size, type='trian'):
exog_train, exog_test, end_train, end_test, scaler_array = data_feeder.get_data(True)
if type == 'train':
train_x_exog, train_x_end, train_y = ctdnn_get_data_aux(exog_train, end_train, window_size)
return train_x_exog, train_x_end, train_y
else:
test_x_exog, test_x_end, test_y = ctdnn_get_data_aux(exog_test, end_test, window_size)
return test_x_exog, test_x_end, test_y
def FTDNN():
global target_window
batch_size = 256
X_train, X_test, Y_train, Y_test, scaler_array = data_feeder.get_data(True)
# print X_train.shape
# print Y_train.shape
train_windowed_data = get_windowed_data_ex(Y_train, target_window + 1)
test_windowed_data = get_windowed_data_ex(Y_test, target_window + 1)
print train_windowed_data.shape
# Set up training input and output
x_train = []
y_train = []
for i in range(train_windowed_data.shape[0]):
x_train.append(train_windowed_data[i, 0:target_window])
y_train.append(train_windowed_data[i, -1:])
x_train = np.asarray(x_train)
y_train = np.asarray(y_train)
x_train = np.asarray(x_train)
x_train = np.reshape(x_train, [x_train.shape[0], x_train.shape[1]])
y_train = np.asarray(y_train)
y_train = np.reshape(y_train, [y_train.shape[0], y_train.shape[1]])
print x_train.shape
print y_train.shape
x_test = []
y_test = []
for i in range(test_windowed_data.shape[0]):
x_test.append(test_windowed_data[i, 0:target_window])
y_test.append(test_windowed_data[i, -1:])
x_test = np.asarray(x_test)
y_test = np.asarray(y_test)
x_test = np.asarray(x_test)
x_test = np.reshape(x_test, [x_test.shape[0], x_test.shape[1]])
y_test = np.asarray(y_test)
y_test = np.reshape(y_test, [y_test.shape[0], y_test.shape[1]])
print x_train.shape
print y_test.shape
model = FTDNN_model(target_window)
history = model.fit(x_test, y_train, epochs=2, batch_size=batch_size)
train_loss = history.history['loss']
print train_loss
# Plot Training Loss
# _plot(range(len(train_loss)), train_loss,
# ' Training Loss in Focused TDNN with target series input only. Batch size of 128')
score = model.evaluate(x_test, y_test, batch_size=128)
print score
def get_stacked_ae():
global ae_epochs
global batch_size
if os.path.exists('ae_model.h5'):
return
nb_epoch = ae_epochs
batch_size = batch_size
X_train, _, _, _, _ = data_feeder.get_data(True)
num_layers = 3
shape = [64, 32, 16]
inp_dim = X_train.shape[-1]
model = keras.models.Sequential()
# input_layer = keras.layers.Dense(units=inp_dim,
# input_dim=inp_dim,
# activation=None,
# use_bias=False,
# activity_regularizer=None)
# model.add(input_layer)
for i in range(num_layers):
if i == 0:
layer = Dense(shape[i], input_dim=inp_dim, activation='sigmoid')
else:
layer = Dense(shape[i], activation='tanh')
model.add(layer)
layer = Dense(units=inp_dim, activation='tanh')
model.add(layer)
model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.MSE,
metrics=['accuracy'])
model.fit(X_train,
X_train,
epochs=nb_epoch,
batch_size=batch_size,
shuffle=False)
for layer in model.layers:
layer.trainable = False
model.pop()
model.save('ae_model.h5')
return model
def get_ae_1():
X_train, _, Y_train, _, _ = data_feeder.get_data(True)
# set up autoencoder for exogenous values
ae_obj_1 = ae_class(1)
ae_obj_1.set_hyperparams(layer_units=ae_1_units,
inp_dim=X_train.shape[-1],
batch_size=128,
epochs=ae_1_epoch)
ae_obj_1.set_data(X_train)
ae_1_losses = ae_obj_1.load_model()
return ae_obj_1
def get_data(time_window, type ):
# window of training data = time_window
X_train, X_test, Y_train, Y_test, _ = data_feeder.get_data(std=True)
if type == 'test':
y = Y_test
else :
y = Y_train
y = np.asanyarray(y)
y = np.reshape(y, [-1, 1])
res = utils.get_windowed_data(y, time_window + 1)
x = res[:, 0:time_window]
y = res[:, -1:]
x = np.reshape(x, [x.shape[0], time_window, 1])
y = np.reshape(y, [y.shape[0], 1])
return x, y
def get_train_data():
global ae_obj
global window_size
X_train, _, Y_train, _, _ = data_feeder.get_data(True)
# set up train data
ae_obj, X_train_ae = pretrain_ae(X_train)
train_y_inp, train_y_op = get_windowed_y(Y_train, window_size=window_size)
train_exog_inp = X_train_ae[window_size:, :]
print ' train_exog_inp ', train_exog_inp.shape
# concatenate train_exog_inp and train_y_op
train_data_x = np.concatenate([train_y_inp, train_exog_inp], axis=1)
print 'train_data_x', train_data_x.shape
print 'Train Data'
print 'Train_data_x ', train_data_x.shape
print 'train_data_x', train_y_op.shape
return train_data_x, train_y_op
def test_model():
ae_model = load_model('ae_model.h5')
model = load_model('model_1.h5')
_, X_test, _, Y_test, scaler_array = data_feeder.get_data(True)
window_size = 8
# create windows
inp, op = get_windowed_inp(Y_test, window_size)
num_samples = inp.shape[0]
X_test = X_test[-num_samples:, :]
ae_op = ae_model.predict(X_test)
inp = np.concatenate([inp, ae_op], axis=1)
# Reshape the data
lstm_batch_size = 128
pad_len = lstm_batch_size - (inp.shape[0] % lstm_batch_size)
# add padding
_inp_pad = np.zeros(shape=[pad_len, inp.shape[-1]])
_op_pad = np.zeros(shape=[pad_len, op.shape[-1]])
inp = np.concatenate([_inp_pad, inp], axis=0)
op = np.concatenate([_op_pad, op], axis=0)
inp_dim = inp.shape[-1]
op_dim = op.shape[-1]
# print 'Shape input dimension ', inp_dim
# print 'Shape output dimension ', op_dim
inp = np.reshape(inp, [-1, lstm_batch_size, inp_dim])
op = np.reshape(op, [-1, lstm_batch_size, op_dim])
print 'Shape input dimension ', inp.shape
print 'Shape output dimension ', op.shape
test_x = inp
test_y = op
score = model.evaluate(x=test_x, y=test_y, batch_size=1)
print score
return
def get_training_data(time_window, endog_only=True):
# window of training data = time_window
_, _, z, _, _ = data_feeder.get_data(std=True)
if endog_only == True:
z = np.asanyarray(z)
print '>>', z.shape
z = np.reshape(z, [-1, 1])
print z.shape
res = utils.get_windowed_data(z, time_window)
print ' >>> ', res.shape
_x = res[:, -1:]
_y = res[:, 0:time_window]
print ' >>> ', _x.shape, _y.shape
_x = np.reshape(_x, [_x.shape[0], 1, 1])
_y = np.reshape(_y, [_y.shape[0], time_window, 1])
return _y, _x
else:
pass
return
def get_training_data(time_window):
# window of training data = time_window
# X : exogenous series
# Y : target series
exog_train, exog_test, end_train, end_test, _ = data_feeder.get_data(
std=True)
exog_dim = exog_train.shape[-1]
res = utils.get_windowed_data(exog_train, time_window)
res = np.reshape(res, [-1, time_window, 1, exog_dim])
# time_window, 1, exog_dim
exog_train_x = res
res = utils.get_windowed_data(end_train, time_window)
res = np.reshape(res, [-1, time_window, 1])
end_train_x = res
n_samples = res.shape[0]
res = utils.get_windowed_data(end_train, 1)
res = res[-n_samples:, :]
res = np.reshape(res, [-1, 1, 1])
end_train_y = res
return exog_train_x, end_train_x, end_train_y
def create_complete_model():
model = load_model('ae_model.h5')
X_train, X_test, Y_train, Y_test, scaler_array = data_feeder.get_data(True)
window_size = 8
# create windows
inp, op = get_windowed_inp(Y_train, window_size)
num_samples = inp.shape[0]
print ' num samples', num_samples
X_train = X_train[-num_samples:, :]
# concatenate X_train and input passed through ae
ae_op = model.predict(X_train)
print 'Shape of op from Auto encoder', ae_op.shape
inp = np.concatenate([inp, ae_op], axis=1)
# Reshape the data
lstm_batch_size = 128
pad_len = lstm_batch_size - (inp.shape[0] % lstm_batch_size)
# add padding
_inp_pad = np.zeros(shape=[pad_len, inp.shape[-1]])
_op_pad = np.zeros(shape=[pad_len, op.shape[-1]])
inp = np.concatenate([_inp_pad, inp], axis=0)
op = np.concatenate([_op_pad, op], axis=0)
inp_dim = inp.shape[-1]
op_dim = op.shape[-1]
inp = np.reshape(inp, [-1, lstm_batch_size, inp_dim])
op = np.reshape(op, [-1, lstm_batch_size, op_dim])
model = keras.models.Sequential()
epochs = 100
batch_input_shape = [1, inp.shape[1], inp.shape[-1]]
lstm1 = keras.layers.LSTM(
128,
use_bias=True,
batch_input_shape=batch_input_shape,
dropout=0.25,
stateful=True,
return_sequences=True,
)
model.add(lstm1)
lstm2 = keras.layers.LSTM(
64,
use_bias=True,
dropout=0.25,
stateful=True,
return_sequences=True,
)
model.add(lstm2)
d1 = Dense(units=64, activation='tanh')
model.add(d1)
d2 = Dense(units=1, activation='tanh')
model.add(d2)
model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.MSE,
metrics=['mse'])
history = model.fit(inp, op, epochs=epochs, batch_size=1, shuffle=False)
print model.summary()
t_loss = history.history['loss']
plt.figure()
plt.title('Training Loss', fontsize=20)
plt.ylabel('Mean Square Error', fontsize=20)
plt.plot(range(len(t_loss)), t_loss, 'r-')
plt.xlabel('Epochs', fontsize=20)
plt.yticks(np.arange(0, 2.2, 0.2))
plt.show()
model.save('model_1.h5')
return
def test_model(self):
_, exog_test, _, end_test, _ = data_feeder.get_data(True)
x1, x2, y = self.format_data_xy(exog_test, end_test)
print self.model.evaluate([x1,x2],y)
def val_test_model(val=False):
# -------- #
global lstm_time_step
global batch_size
global epochs
global window_size
# --------- #
ae_model = load_model('ae_model.h5')
lstm_model = load_model('model_1.h5')
if val == True:
_, _, X_test, _, _, Y_test, _ = data_feeder.get_data_val(True)
else:
_, X_test, _, Y_test, _ = data_feeder.get_data(True)
# create windows
inp, op = get_windowed_inp(Y_test, window_size)
num_samples = inp.shape[0]
print 'num_samples', num_samples
X_test = X_test[-num_samples:, :]
print 'X_test', X_test.shape
# concatenate X_train and input passed through ae
ae_op = ae_model.predict(X_test)
# print 'ae_op', ae_op.shape
inp = np.concatenate([inp, ae_op], axis=-1)
print 'inp shape', inp.shape
# Reshape the data
pad_len = lstm_time_step - (inp.shape[0] % lstm_time_step)
# add padding
_inp_pad = np.zeros(shape=[pad_len, inp.shape[-1]])
_op_pad = np.zeros(shape=[pad_len, op.shape[-1]])
inp = np.concatenate([_inp_pad, inp], axis=0)
op = np.concatenate([_op_pad, op], axis=0)
inp_dim = inp.shape[-1]
op_dim = op.shape[-1]
inp = np.reshape(inp, [-1, lstm_time_step, inp_dim])
op = np.reshape(op, [-1, lstm_time_step, op_dim])
num_samples = (inp.shape[0] // batch_size) * batch_size
inp = inp[-num_samples:, :, :]
op = op[-num_samples:, :, :]
# -------- #
print 'Shape input dimension ', inp.shape
print 'Shape output dimension ', op.shape
test_x = inp
test_y = op
score = lstm_model.evaluate(x=test_x, y=test_y, batch_size=batch_size)
print 'Mean Square Error', score[0]
return score[0]
def pretrain_ae(X_train):
data_x = X_train
ae_obj = ae()
ae_obj.set_data(data_x)
ae_obj.layerwise_train()
ae_op = ae_obj.reduce(X_train)
print ae_op.shape
return ae_obj, ae_op
# --------------------------------------------------------------------------------------- #
X_train, X_test, Y_train, Y_test, scaler_array = data_feeder.get_data(True)
# ----------------- #
# Create sliding window of target value #
# ----------------- #
def get_windowed_y(data, window_size):
y = list(np.reshape(data, [data.shape[0]]))
print len(y)
# local function
def window(iterable, size):
iters = tee(iterable, size)
for i in xrange(1, size):
for each in iters[i:]:
def create_complete_model():
# ------------ #
global lstm_time_step
global batch_size
global lstm_epochs
global window_size
# ------------ #
if os.path.exists('model_1.h5'):
return
ae_model = load_model('ae_model.h5')
X_train, _, Y_train, _, _ = data_feeder.get_data(True)
# create windows
inp, op = get_windowed_inp(Y_train, window_size)
num_samples = inp.shape[0]
# print 'num_samples', num_samples
X_train = X_train[-num_samples:, :]
# print 'X_train', X_train.shape
# concatenate X_train and input passed through ae
ae_op = ae_model.predict(X_train)
# print 'ae_op', ae_op.shape
inp = np.concatenate([inp, ae_op], axis=-1)
# print 'inp shape', inp.shape
# Reshape the data
pad_len = lstm_time_step - (inp.shape[0] % lstm_time_step)
# add padding
_inp_pad = np.zeros(shape=[pad_len, inp.shape[-1]])
_op_pad = np.zeros(shape=[pad_len, op.shape[-1]])
inp = np.concatenate([_inp_pad, inp], axis=0)
op = np.concatenate([_op_pad, op], axis=0)
inp_dim = inp.shape[-1]
op_dim = op.shape[-1]
inp = np.reshape(inp, [-1, lstm_time_step, inp_dim])
op = np.reshape(op, [-1, lstm_time_step, op_dim])
# Ensure number of samples are divisible by batch size
num_samples = (inp.shape[0] // batch_size) * batch_size
inp = inp[-num_samples:, :, :]
op = op[-num_samples:, :, :]
model = keras.models.Sequential()
batch_input_shape = [batch_size, inp.shape[1], inp.shape[-1]]
lstm1 = keras.layers.LSTM(
16,
use_bias=True,
batch_input_shape=batch_input_shape,
dropout=0.25,
stateful=True,
return_sequences=True,
)
model.add(lstm1)
lstm2 = keras.layers.LSTM(
16,
use_bias=True,
dropout=0.25,
stateful=True,
return_sequences=True,
)
model.add(lstm2)
d1 = keras.layers.TimeDistributed(Dense(units=8, activation='tanh'))
model.add(d1)
d2 = keras.layers.TimeDistributed(Dense(units=1, activation='tanh'))
model.add(d2)
model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.MSE,
metrics=['mse'])
# Ensure number of samples divisible by batch size
history = model.fit(inp,
op,
epochs=lstm_epochs,
batch_size=batch_size,
shuffle=False,
verbose=False)
t_loss = history.history['loss']
# plt.figure()
# plt.title('Training Loss', fontsize=20)
# plt.ylabel('Mean Square Error', fontsize=20)
# plt.plot(range(len(t_loss)), t_loss, 'r-')
# plt.xlabel('Epochs', fontsize=20)
# plt.yticks(np.arange(0, 2.2, 0.2))
# # plt.show()
model.save('model_1.h5')
return np.mean(t_loss)
next(each, None)
return izip(*iters)
op = []
for w in window(data, window_size):
w = np.reshape(w, [-1])
op.append(w)
op = np.asarray(op)
return op
# ------ #
# Get Data
# ------ #
X_train, _, Y_train, _, _ = data_feeder.get_data(True)
# set up autoencoder for exogenous values
ae_obj_1 = ae_class(1)
ae_obj_1.set_hyperparams(layer_units=[64, 32, 16],
inp_dim=X_train.shape[-1],
batch_size=512,
epochs=ae_1_epoch)
print 'Shape of training data for 1st auto encoder', X_train.shape
ae_obj_1.set_data(X_train)
ae_1_losses, ae_1_acc = ae_obj_1.load_model()
print 'Auto Encoder 1'
# ae_obj_1.model.summary()
# ------ #
