def train(train_params):
debug = True
data_params = train_params['data_params']
model_params = train_params['model_params']
model_save_path = train_params['model_save_path']
logs_dir_path = train_params['logs_dir_path']
batch_size = model_params['batch_size']
num_epochs = model_params[
'num_epochs'] # add early stopping, save best model
input_num_features = model_params['input_num_features'] # 1
output_num_features = model_params['output_num_features']
look_back = model_params['look_back']
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
val_batch_size = batch_size
visualize = train_params['visualize']
raw_values, X_train, y_train, X_validation, y_validation, scaler = preprocess_data(
data_params)
print(raw_values.shape, X_train.shape, y_train.shape, X_validation.shape,
y_validation.shape)
# print(X_train[0])
# print(X_train[0].shape)
# print(X_train[0:2].shape)
# gen = batch_generator(X_train, y_train, batch_size)
# print(next(gen)[0].shape)
# print(next(gen)[1].shape)
train_loader = batch_generator(X_train, y_train, batch_size)
val_loader = batch_generator(X_validation, y_validation, val_batch_size)
train_writer = tf.summary.FileWriter(os.path.join(
logs_dir_path, 'train')) #, accuracy.graph)
val_writer = tf.summary.FileWriter(
os.path.join(logs_dir_path, 'validation')) #, accuracy.graph)
num_training_batches = X_train.shape[0] // batch_size
num_validation_batches = X_validation.shape[0] // batch_size
print("num_training_batches: {}, num_validation_batches: {}".format(
num_training_batches, num_validation_batches))
x = tf.placeholder(
tf.float32, [None, look_back, input_num_features]) # 1 feature (price)
y = tf.placeholder(tf.float32, [None, output_num_features])
init_state_0_c = tf.placeholder(tf.float32, [None, n_hidden])
init_state_0_h = tf.placeholder(tf.float32, [None, n_hidden])
# **** model ****
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
num_layers = model_params['num_layers']
prediction_num_features = model_params['output_num_features']
batch_size = model_params['batch_size']
weights = {
'out':
tf.Variable(tf.random_normal([n_hidden, prediction_num_features]))
}
biases = {'out': tf.Variable(tf.random_normal([prediction_num_features]))}
rnn_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, state_is_tuple=True)
rnn_tuple_state = tf.nn.rnn_cell.LSTMStateTuple(init_state_0_c,
init_state_0_h)
outputs, current_state = tf.nn.dynamic_rnn(rnn_cell,
x,
initial_state=rnn_tuple_state)
# cur_state_0_c = current_state.c
# cur_state_0_h = current_state.h
tf.summary.histogram('rnn_outputs', outputs)
prediction = tf.matmul(outputs[:, -1, :], weights['out']) + biases['out']
with tf.name_scope('Metrices'):
# y = tf.reshape(y, [-1]) # necesary?
# regular version VS v2 VS sparse
# what about the shape of prediction VS shape of y??
# loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=prediction, labels=y))
loss = tf.losses.mean_squared_error(
labels=y, predictions=prediction
) # is the loss calculated correctly? are these the params I need to pass?
tf.summary.scalar('loss', loss)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(loss)
# in order to calculate rmse we need to transform data back to a price
## prediction_inverse = inverse_transforms(prediction, scaler)
## y_inverse = inverse_transforms(y, scaler)
## prediction_inverse = prediction_inverse.squeeze()[1:]
## y_test_inverse = y_test_inverse.squeeze()
## rmse = sqrt(mean_squared_error(prediction_inverse, y_inverse))
## tf.summary.scalar('rmse', rmse)
merged_summary = tf.summary.merge_all()
saver = tf.train.Saver()
_cur_state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32)
_cur_state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32)
_current_state = tuple((_cur_state_0_c, _cur_state_0_h))
## print(_cur_state_0_c.shape)
print(
"Run 'tensorboard --logdir=./{}' to checkout tensorboard logs.".format(
logs_dir_path))
print("==> training")
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# training
for epoch in tqdm.tqdm(range(num_epochs)):
train_rmse = 0.0
for i, data in tqdm.tqdm(enumerate(train_loader, 0),
total=num_training_batches):
# print(i)
if i == num_training_batches:
print("*" * 50)
break
_x, _y = data
_x = _x.reshape((-1, look_back, input_num_features))
_y = _y.reshape((-1, output_num_features))
_pred, _loss, _, _summary, _current_state = sess.run(
[
prediction, loss, optimizer, merged_summary,
current_state
],
feed_dict={
x: _x,
y: _y,
init_state_0_c: _current_state[0],
init_state_0_h: _current_state[1]
})
train_writer.add_summary(_summary,
i + num_training_batches * epoch)
train_writer.close()
saver.save(sess, model_save_path)
validation_set_size = data_params['validation_set_size']
train_set_size = data_params['training_set_size']
predictions = list()
ground_truths = list()
print("==> validating")
# print(num_validation_batches)
for epoch in tqdm.tqdm(range(1)):
total_rmse = 0.0
for i, data in tqdm.tqdm(enumerate(val_loader, 0),
total=num_validation_batches):
if i == 0:
history = []
if i == num_validation_batches:
break
_x, _y = data
_x = _x.reshape((-1, look_back, input_num_features))
_y = _y.reshape((-1, output_num_features))
_pred, _summary, _current_state = sess.run(
[prediction, merged_summary, current_state],
feed_dict={
x: _x,
y: _y,
init_state_0_c: _current_state[0],
init_state_0_h: _current_state[1]
})
# print(_pred.shape)
# print(type(_pred))
# print(_pred)
# _pred = np.squeeze(_pred, axis=0)
# print(_pred, _pred.shape)
# prediction_inverse = inverse_transforms(_pred, scaler)
prediction_inverse = invert_scale(scaler, _x, _pred)
# prediction_inverse = prediction_inverse.squeeze(axis=0)
prediction_inverse = inverse_difference(raw_values, prediction_inverse, \
validation_set_size + 1 - i)
predictions.append(prediction_inverse)
ground_truths.append(raw_values[train_set_size + i +
1]) # why +1 ?
# rmse = sqrt(mean_squared_error(prediction_inverse, _y))
print("predicted = {}, groud truth = {}".format(prediction_inverse, \
raw_values[train_set_size + i + 1]))
# print("rmse: {}".format(rmse))
# print("\n")
# total_rmse += rmse
val_writer.close()
# total_rmse /= num_validation_batches
# rmse_2 = sqrt(mean_squared_error(ground_truths, predictions))
predictions = np.array(predictions)
print("predictions.shape = {}, y_validation.shape = {}".format(
predictions.shape, y_validation.shape))
rmse_2 = sqrt(mean_squared_error(y_validation, predictions))
# print("validation rmse: {}".format(total_rmse))
print("validation rmse 2: {}".format(rmse_2))
if visualize:
plt.plot(ground_truths, 'r')
plt.plot(predictions, 'b')
plt.show()
def train(train_params):
debug = True
data_params = train_params['data_params']
model_params = train_params['model_params']
model_save_path = train_params['model_save_path']
logs_dir_path = train_params['logs_dir_path']
batch_size = model_params['batch_size']
num_epochs = model_params[
'num_epochs'] # add early stopping, save best model
input_num_features = model_params['input_num_features'] # 1
output_num_features = model_params['output_num_features']
look_back = model_params['look_back']
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
val_batch_size = batch_size
visualize = train_params['visualize']
validate_only = train_params['validate_only']
trained_model_path = train_params['trained_model_path']
raw_values, X_train, y_train, X_validation, y_validation, scaler = preprocess_data(
data_params)
print(raw_values.shape, X_train.shape, y_train.shape, X_validation.shape,
y_validation.shape)
# print(X_train[0])
# print(X_train[0].shape)
# print(X_train[0:2].shape)
# gen = batch_generator(X_train, y_train, batch_size)
# print(next(gen)[0].shape)
# print(next(gen)[1].shape)
train_loader = batch_generator(X_train, y_train, batch_size)
val_loader = batch_generator(X_validation, y_validation, val_batch_size)
train_writer = tf.summary.FileWriter(os.path.join(
logs_dir_path, 'train')) #, accuracy.graph)
val_writer = tf.summary.FileWriter(
os.path.join(logs_dir_path, 'validation')) #, accuracy.graph)
num_training_batches = X_train.shape[0] // batch_size
num_validation_batches = X_validation.shape[0] // batch_size
print("num_training_batches: {}, num_validation_batches: {}".format(
num_training_batches, num_validation_batches))
x = tf.placeholder(
tf.float32, [None, look_back, input_num_features]) # 1 feature (price)
y = tf.placeholder(tf.float32, [None, output_num_features])
init_state_0_c = tf.placeholder(tf.float32, [None, n_hidden])
init_state_0_h = tf.placeholder(tf.float32, [None, n_hidden])
# **** model ****
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
num_layers = model_params['num_layers']
prediction_num_features = model_params['output_num_features']
batch_size = model_params['batch_size']
weights = {
'out':
tf.Variable(tf.random_normal([n_hidden, prediction_num_features]))
}
biases = {'out': tf.Variable(tf.random_normal([prediction_num_features]))}
rnn_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, state_is_tuple=True)
rnn_tuple_state = tf.nn.rnn_cell.LSTMStateTuple(init_state_0_c,
init_state_0_h)
outputs, current_state = tf.nn.dynamic_rnn(rnn_cell,
x,
initial_state=rnn_tuple_state)
# cur_state_0_c = current_state.c
# cur_state_0_h = current_state.h
tf.summary.histogram('rnn_outputs', outputs)
prediction = tf.matmul(outputs[:, -1, :], weights['out']) + biases['out']
with tf.name_scope('Metrices'):
# y = tf.reshape(y, [-1]) # necesary?
# regular version VS v2 VS sparse
# what about the shape of prediction VS shape of y??
# loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=prediction, labels=y))
loss = tf.losses.mean_squared_error(
labels=y, predictions=prediction
) # is the loss calculated correctly? are these the params I need to pass?
tf.summary.scalar('loss', loss)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(loss)
# in order to calculate rmse we need to transform data back to a price
## prediction_inverse = inverse_transforms(prediction, scaler)
## y_inverse = inverse_transforms(y, scaler)
## prediction_inverse = prediction_inverse.squeeze()[1:]
## y_test_inverse = y_test_inverse.squeeze()
## rmse = sqrt(mean_squared_error(prediction_inverse, y_inverse))
## tf.summary.scalar('rmse', rmse)
merged_summary = tf.summary.merge_all()
saver = tf.train.Saver()
_cur_state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32)
_cur_state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32)
_current_state = tuple((_cur_state_0_c, _cur_state_0_h))
validation_set_size = data_params['validation_set_size']
train_set_size = data_params['training_set_size']
prev_current_state = None
best_model_rmse = float("inf")
_val_current_state = None
## print(_cur_state_0_c.shape)
print(
"Run 'tensorboard --logdir=./{}' to checkout tensorboard logs.".format(
logs_dir_path))
print("==> training")
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# training
for epoch in tqdm.tqdm(range(num_epochs)):
# print("_current_state before training:")
# print(_current_state)
# print("before == previous after? {}".format(cmp_tuples(_current_state, prev_current_state)))
if not validate_only:
for i, data in tqdm.tqdm(enumerate(train_loader, 0),
total=num_training_batches):
# print(i)
if i == num_training_batches:
print("*" * 50)
break
_x, _y = data
_x = _x.reshape((-1, look_back, input_num_features))
_y = _y.reshape((-1, output_num_features))
_pred, _loss, _, _summary, _current_state = sess.run(
[
prediction, loss, optimizer, merged_summary,
current_state
],
feed_dict={
x: _x,
y: _y,
init_state_0_c: _current_state[0],
init_state_0_h: _current_state[1]
})
train_writer.add_summary(_summary,
i + num_training_batches * epoch)
_val_current_state = tuple(
(_current_state[0].copy(), _current_state[1].copy()))
validation_params = dict()
validation_params['sess'] = sess
validation_params[
'_current_state'] = _current_state # just for saving it
validation_params['_val_current_state'] = _val_current_state
validation_params['raw_values'] = raw_values
validation_params['y_validation'] = y_validation
validation_params['validation_set_size'] = validation_set_size
validation_params['val_loader'] = val_loader
validation_params['val_writer'] = val_writer
validation_params['scaler'] = scaler
validation_params[
'num_validation_batches'] = num_validation_batches
validation_params['look_back'] = look_back
validation_params['epoch'] = epoch
validation_params['input_num_features'] = input_num_features
validation_params['output_num_features'] = output_num_features
validation_params['placeholders'] = {
'x': x,
'y': y,
'init_state_0_c': init_state_0_c,
'init_state_0_h': init_state_0_h
}
sess_params = dict()
sess_params['prediction'] = prediction
sess_params['merged_summary'] = merged_summary
sess_params['current_state'] = current_state
validation_params['sess_params'] = sess_params
validation_params['saver'] = saver
validation_params['model_save_path'] = model_save_path
validation_params['visualize'] = visualize
validation_params['best_model_rmse'] = best_model_rmse
validation_params['trained_model_path'] = trained_model_path
validate(validation_params)
best_model_rmse = validation_params['best_model_rmse']
if validate_only:
break
val_writer.close()
train_writer.close()
def train(train_params):
debug = True
data_params = train_params['data_params']
model_params = train_params['model_params']
model_save_path = train_params['model_save_path']
logs_dir_path = train_params['logs_dir_path']
batch_size = model_params['batch_size']
num_epochs = model_params[
'num_epochs'] # add early stopping, save best model
input_num_features = model_params['input_num_features'] # 1
output_num_features = model_params['output_num_features']
look_back = model_params['look_back']
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
num_layers = model_params['num_layers']
keep_prob = model_params['keep_prob']
val_batch_size = batch_size
visualize = train_params['visualize']
validate_only = train_params['validate_only']
trained_model_path = train_params['trained_model_path']
raw_values, X_train, y_train, X_validation, y_validation, scaler = preprocess_data(
data_params)
print(raw_values.shape, X_train.shape, y_train.shape, X_validation.shape,
y_validation.shape)
train_loader = batch_generator(X_train, y_train, batch_size)
val_loader = batch_generator(X_validation, y_validation, val_batch_size)
train_writer = tf.summary.FileWriter(os.path.join(
logs_dir_path, 'train')) #, accuracy.graph)
val_writer = tf.summary.FileWriter(
os.path.join(logs_dir_path, 'validation')) #, accuracy.graph)
num_training_batches = X_train.shape[0] // batch_size
num_validation_batches = X_validation.shape[0] // batch_size
print("num_training_batches: {}, num_validation_batches: {}".format(
num_training_batches, num_validation_batches))
# placeholders
# 1 feature (price)
x = tf.placeholder(tf.float32, [None, look_back, input_num_features])
y = tf.placeholder(tf.float32, [None, output_num_features])
init_state = tf.placeholder(tf.float32, [2, None, n_hidden])
# **** model ****
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
num_layers = model_params['num_layers']
prediction_num_features = model_params['output_num_features']
batch_size = model_params['batch_size']
weights = {
'out':
tf.Variable(tf.random_normal([n_hidden, prediction_num_features]))
}
biases = {'out': tf.Variable(tf.random_normal([prediction_num_features]))}
rnn_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, state_is_tuple=True)
rnn_tuple_state = tf.nn.rnn_cell.LSTMStateTuple(init_state[0],
init_state[1])
outputs, current_state = tf.nn.dynamic_rnn(rnn_cell,
x,
initial_state=rnn_tuple_state)
tf.summary.histogram('rnn_outputs', outputs)
prediction = tf.matmul(outputs[:, -1, :], weights['out']) + biases['out']
with tf.name_scope('Metrices'):
loss = tf.losses.mean_squared_error(labels=y, predictions=prediction)
tf.summary.scalar('loss', loss)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(loss)
merged_summary = tf.summary.merge_all()
saver = tf.train.Saver()
_current_state = np.zeros((2, batch_size, n_hidden))
validation_set_size = data_params['validation_set_size']
train_set_size = data_params['training_set_size']
prev_current_state = None
best_model_rmse = float("inf")
_val_current_state = None
print(
"Run 'tensorboard --logdir=./{}' to checkout tensorboard logs.".format(
logs_dir_path))
print("==> training")
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# training
for epoch in tqdm.tqdm(range(num_epochs)):
if not validate_only:
for i, data in tqdm.tqdm(enumerate(train_loader, 0),
total=num_training_batches):
# print(i)
if i == num_training_batches:
print("*" * 50)
break
_x, _y = data
_x = _x.reshape((-1, look_back, input_num_features))
_y = _y.reshape((-1, output_num_features))
_pred, _loss, _, _summary, _current_state = sess.run(
[
prediction, loss, optimizer, merged_summary,
current_state
],
feed_dict={
x: _x,
y: _y,
init_state: _current_state
})
train_writer.add_summary(_summary,
i + num_training_batches * epoch)
_val_current_state = pickle.loads(
pickle.dumps(_current_state, -1))
validation_params = dict()
validation_params['sess'] = sess
validation_params[
'_current_state'] = _current_state # just for saving it
validation_params['_val_current_state'] = _val_current_state
validation_params['raw_values'] = raw_values
validation_params['y_validation'] = y_validation
validation_params['validation_set_size'] = validation_set_size
validation_params['val_loader'] = val_loader
validation_params['val_writer'] = val_writer
validation_params['scaler'] = scaler
validation_params[
'num_validation_batches'] = num_validation_batches
validation_params['look_back'] = look_back
validation_params['epoch'] = epoch
validation_params['input_num_features'] = input_num_features
validation_params['output_num_features'] = output_num_features
validation_params['placeholders'] = {
'x': x,
'y': y,
'init_state': init_state
}
sess_params = dict()
sess_params['prediction'] = prediction
sess_params['merged_summary'] = merged_summary
sess_params['current_state'] = current_state
validation_params['sess_params'] = sess_params
validation_params['saver'] = saver
validation_params['model_save_path'] = model_save_path
validation_params['visualize'] = visualize
validation_params['best_model_rmse'] = best_model_rmse
validation_params['trained_model_path'] = trained_model_path
validate(validation_params)
best_model_rmse = validation_params['best_model_rmse']
if validate_only:
break
val_writer.close()
train_writer.close()
def train(train_params):
# ************** params **************
debug = True
data_params = train_params['data_params']
model_params = train_params['model_params']
model_save_path = train_params['model_save_path']
logs_dir_path = train_params['logs_dir_path']
batch_size = model_params['batch_size']
num_epcohs = model_params['num_epochs'] # add early stopping, save best model
input_num_features = model_params['input_num_features'] # 1
output_num_features = model_params['output_num_features']
look_back = model_params['look_back']
n_hidden = model_params['n_hidden']
learning_rate = model_params['learning_rate']
val_batch_size = batch_size
X_train, y_train, X_validation, y_validation, scaler = preprocess_data(data_params)
# print(X_train[0])
# print(X_train[0].shape)
# print(X_train[0:2].shape)
# gen = batch_generator(X_train, y_train, batch_size)
# print(next(gen)[0].shape)
# print(next(gen)[1].shape)
train_loader = batch_generator(X_train, y_train, batch_size)
val_loader = batch_generator(X_validation, y_validation, val_batch_size)
train_writer = tf.summary.FileWriter(os.path.join(logs_dir_path, 'train')) #, accuracy.graph)
val_writer = tf.summary.FileWriter(os.path.join(logs_dir_path, 'validation')) #, accuracy.graph)
num_training_batches = X_train.shape[0] // batch_size
num_validation_batches = X_validation.shape[0] // batch_size
# let's say prices are: [1,2,3,4,5,6,7,8,9,10,11,12]
# and we use the prices from the past 3 minutes/days (look back = 3)
# in order to predict the next
# let batch_size = 3 and let num_batches = 3
# input: [[[1, 2, 3], [2, 3, 4], [3, 4, 5]],
# [[4,5,6], [5,6,7], [6,7,8]]
# [7,8,9], [8,9,10], [9,10,11]]]
# labels: [[[4], [5], [6]]
# [[7], [8], [9]]
# [[10], [11], [12]]]
#
# Visualizations help!
x = tf.placeholder(tf.float32, [None, look_back, input_num_features]) # 1 feature (price)
y = tf.placeholder(tf.float32, [None, output_num_features])
# WHAT IS THE SHAPE OF init_state ?
## current_state = tf.placeholder(tf.float32, [model_params['num_layers'], 2, batch_size, n_hidden])
## current_state = tf.placeholder(tf.float32, [2, batch_size, n_hidden])
state_0_h = tf.placeholder(tf.float32, [None, n_hidden])
state_0_c = tf.placeholder(tf.float32, [None, n_hidden])
# current_state = []
# reset_state = tf.placeholder(tf.int32, shape=[])
### prediction, current_state = model(x, model_params, current_state, reset_state)
# prediction, current_state= model(x, model_params, [], reset_state)
# if debug:
prediction, current_state = model(x, model_params, (state_0_c, state_0_h)) # debug
state_0_c = current_state.c
state_0_h = current_state.h
# else:
# prediction, current_state = model(x, model_params, current_state) # debug
# _current_state = np.zeros((model_params['num_layers'], 2, batch_size, n_hidden))
# _current_state = tuple([tuple((el[0], el[1])) for el in _current_state])
# works for LSTMCell
## _current_state = np.zeros((2, batch_size, n_hidden), dtype=np.float32)
## _current_state = tuple((_current_state[0], _current_state[1]))
# *** debugging ***
if debug:
_state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32)
_state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32)
print(_state_0_c.shape)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# training
print("==> debugging")
for epoch in tqdm.tqdm(range(num_epcohs)):
# _current_state = np.zeros((model_params['num_layers'], 2, batch_size, n_hidden))
# _current_state = tuple([tuple((el[0], el[1])) for el in _current_state])
# print(len(_current_state))
i = 0
train_rmse = 0.0
for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches):
if i == num_training_batches:
break
_x,_y = data
_x = _x.reshape((-1, look_back, input_num_features))
_y = _y.reshape((-1, output_num_features))
_state_0_c, _state_0_h, _pred = sess.run([state_0_c, state_0_h, prediction],
feed_dict = {
x: _x,
y: _y,
state_0_h: _state_0_h,
state_0_c: _state_0_c
}
)
# current_state: _current_state})
# print(_current_state)
# print(np.shape(_current_state[0]))
# print(np.shape(_outputs[0]))
print(np.shape(_pred[0]))
# print(tf.shape(_init_state_debug))
# raise NotImplementedError()
# print(_prediction, tf.shape(_prediction[0]))
# print(len(_prediction), type(_prediction))
raise NotImplementedError()
# *** debugging ***
with tf.name_scope('Metrices'):
y = tf.reshape(y, [-1]) # necesary?
# regular version VS v2 VS sparse
# what about the shape of prediction VS shape of y??
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=prediction, labels=y))
tf.summary.scalar('loss', loss)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
# in order to calculate rmse we need to transform data back to a price
prediction_inverse = inverse_transforms(prediction, scaler)
y_inverse = inverse_transforms(y, scaler)
prediction_inverse = prediction_inverse.squeeze()[1:]
y_test_inverse = y_test_inverse.squeeze()
rmse = sqrt(mean_squared_error(prediction_inverse, y_inverse))
tf.summary.scalar('rmse', rmse)
merged_summary = tf.summary.merge_all()
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# training
print("==> training")
for epoch in tqdm.tqdm(range(num_epcohs)):
# initialize every epoch?
# _current_state = np.zeros((model_params['num_layers'], 2, batch_size, n_hidden))
# _current_state = tuple([tuple((el[0], el[1])) for el in _current_state])
_state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32)
_state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32)
i = 0
train_rmse = 0.0
for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches):
if i == num_training_batches:
break
_state_0_c, _state_0_h = sess.run([state_0_c, state_0_h],
feed_dict = {x: _x, y: _y, state_0_h: _state_0_h.astype(np.float32), state_0_c: _state_0_c.astype(np.float32)})
_x, _y = data
_x = _x.reshape((-1, look_back, input_num_features)) # necesary ?
_y = _y.reshape((-1, output_num_features)) # necesary ?
_loss, _rmse, _, _summary, _current_state = sess.run([loss, rmse, optimizer,
merged_summary, state_0_c, state_0_h],
# _init_state = sess.run([init_state_debug],
feed_dict = {
x: _x,
y: _y,
state_0_c: _current_state[0],
state_0_h: _current_state[1]
##current_state: _current_state,
## reset_state: 1 if i == 0 else 0
## reset_state: 1
})
### print("state shape = {}".format(tf.shape(_current_state)))
print("state shape = {}".format(tf.shape(_current_state[0])))
raise NotImplementedError()
train_rmse += _rmse
train_writer.add_summary(_summary, i + num_training_batches * epoch)
# validation
print("==> validation")
for epoch in tqdm.tqdm(range(num_epcohs)):
for i, data in tqdm.tqdm(enumerate(val_loader, 0), total=num_training_batches):
_x, _y = data
_rmse, _summary, _current_state = sess.run([rmse, merged_summary, current_state],
feed_dict = {
x: _x,
y: _y,
current_state: _current_state
})
val_writer.add_summary(_summary, i + num_validation_batches * epoch)
train_writer.close()
val_writer.close()
saver.save(sess, model_save_path)
