def main():
para = params_setup()
logging_config_setup(para)
logging.info('Creating graph')
graph, model, data_generator = create_graph(para)
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
logging.info('Loading weights')
load_weights(para, sess, model)
print_num_of_trainable_parameters()
try:
if para.mode == 'train':
logging.info('Started training')
train(para, sess, model, data_generator)
if para.save_final_model_path != '':
save_weights(sess, model, para.save_final_model_path)
elif para.mode == 'validation':
logging.info('Started validation')
test(para, sess, model, data_generator)
elif para.mode == 'test':
logging.info('Started testing')
test(para, sess, model, data_generator)
elif para.mode == 'predict':
logging.info('Predicting')
predict(para, sess, model, data_generator,
'./data/solar-energy3/solar_predict.txt', para.samples)
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Stop')
def train(para, sess, model, train_data_generator):
valid_para, valid_graph, valid_model, valid_data_generator = \
create_valid_graph(para)
with tf.Session(config=config_setup(), graph=valid_graph) as valid_sess:
valid_sess.run(tf.global_variables_initializer())
# validation
load_weights(valid_para, valid_sess, valid_model)
valid_sess.run(valid_data_generator.iterator.initializer)
valid_loss = 0.0
valid_rse = 0.0
valid_rae = 0.0
count = 0
n_samples = 0
all_outputs, all_labels, all_inputs = [], [], []
while True:
try:
[loss, outputs, labels, inputs] = valid_sess.run(fetches=[
valid_model.loss,
valid_model.all_rnn_outputs,
valid_model.labels,
valid_model.rnn_inputs
])
if para.mts:
valid_rse += np.sum(
((outputs - labels) * valid_data_generator.scale)
**2)
valid_rae += np.sum(
(abs(outputs - labels) * valid_data_generator.scale))
all_outputs.append(outputs)
all_labels.append(labels)
all_inputs.append(inputs)
n_samples += np.prod(outputs.shape)
valid_loss += loss
count += 1
except tf.errors.OutOfRangeError:
break
if para.mts:
all_outputs = np.concatenate(all_outputs)
all_labels = np.concatenate(all_labels)
all_inputs = np.concatenate(all_inputs)
return all_inputs, all_labels, all_outputs
def main():
para = params_setup()
logging_config_setup(para)
print("Creating graph...")
graph, model, data_generator = create_graph(para)
print("Done creating graph.")
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
print("Loading weights...")
load_weights(para, sess, model)
print_num_of_trainable_parameters()
# PRINT NAMES OF TENSORS THAT ARE ALPHAS
# example name: "model/rnn/cond/rnn/multi_rnn_cell/cell_0/cell_0/temporal_pattern_attention_cell_wrapper/attention/Sigmoid:0"
# for item in [n.name for n in tf.get_default_graph().as_graph_def().node
# if (n.name.find("temporal_pattern_attention_cell_wrapper/attention")!=-1 and
# n.name.find("Sigmoid")!=-1)]:
# print(item)
# Print names of ops
# for op in tf.get_default_graph().get_operations():
# if(op.name.find("ben_multiply")!=-1):
# print(str(op.name))
# PRINT REG KERNEL AND BIAS
# reg_weights = [v for v in tf.global_variables() if v.name == "model/dense_2/kernel:0"][0]
# reg_bias = [v for v in tf.global_variables() if v.name == "model/dense_2/bias:0"][0]
# print("Reg Weights:", sess.run(reg_weights))
# print("Reg Bias:", sess.run(reg_bias) * data_generator.scale[0])
try:
if para.mode == 'train':
train(para, sess, model, data_generator)
elif para.mode == 'test':
print("Evaluating model...")
test(para, sess, model, data_generator)
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Stop')
def main():
para = params_setup()
logging_config_setup(para)
graph, model, data_generator = create_graph(para)
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
load_weights(para, sess, model)
print_num_of_trainable_parameters()
try:
if para.mode == 'train':
train(para, sess, model, data_generator)
elif para.mode == 'test':
test(para, sess, model, data_generator)
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Stop')
def main():
para = sess_params_setup()
logging_config_setup(para)
graph, model, data_generator = create_graph(para)
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
load_weights(para, sess, model)
print_num_of_trainable_parameters()
try:
all_inputs, all_labels, all_outputs = train(
para, sess, model, data_generator)
return all_inputs, all_labels, all_outputs, model
# all_inputs = all_inputs.permute(0,2,1)
#
# modelSize = 500
# sampleSize = 500
#
# model_input = [tf.convert_to_tensor(x, dtype=tf.float32) for x in all_inputs[:modelSize]]
# model_output = tf.convert_to_tensor(all_outputs[:modelSize], dtype=tf.float32)
#
# data = [x for x in all_inputs[:sampleSize]]
# X = [x for x in all_inputs[:modelSize]]
#
# model2 = (model_input, model_output)
# explainer = shap.DeepExplainer(model2, data, sess)
# shap_values = explainer.shap_values(X)
#
# return shap_values
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Stop')
def main():
para = params_setup()
logging_config_setup(para)
graph, model, data_generator = create_graph(para)
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
load_weights(para, sess, model)
print_num_of_trainable_parameters()
try:
# EXTRACT WEIGHTS HERE
for variable in tf.global_variables(): # tf.trainable_variables():
print(variable)
# VIEW FETCHABLE OPS
graph = tf.get_default_graph()
print([op for op in parent_ops if graph.is_fetchable(op)])
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Weights extracted. Stop.')
def main():
para = params_setup()
logging_config_setup(para)
graph, model, data_generator = create_graph(para)
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
load_weights(para, sess, model)
print_num_of_trainable_parameters()
try:
if para.mode == 'train':
train(para, sess, model, data_generator)
elif para.mode == 'test':
obs, predicted = test(para, sess, model, data_generator)
obs = obs * data_generator.scale + data_generator.min_value
predicted = predicted * data_generator.scale + data_generator.min_value
print("MSE: ", mean_squared_error(obs[:, 0], predicted[:, 0]))
idx = pd.DatetimeIndex(start='2016-10-16',
end='2018-11-04',
freq='W')
obs_df = pd.DataFrame(data=obs[:, 0],
columns=['Observed'],
index=idx)
pred_df = pd.DataFrame(data=predicted[:, 0],
columns=['Predicted'],
index=idx)
df = pd.concat([obs_df, pred_df], axis=1)
df.plot()
plt.show()
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Stop')
def train(para, sess, model, train_data_generator):
valid_para, valid_graph, valid_model, valid_data_generator = \
create_valid_graph(para)
with tf.Session(config=config_setup(), graph=valid_graph) as valid_sess:
valid_sess.run(tf.global_variables_initializer())
for epoch in range(1, para.num_epochs + 1):
logging.info("Epoch: %d" % epoch)
sess.run(train_data_generator.iterator.initializer)
start_time = time.time()
train_loss = 0.0
count = 0
while True:
try:
[loss, global_step, _] = sess.run(
fetches=[model.loss, model.global_step, model.update])
train_loss += loss
count += 1
except tf.errors.OutOfRangeError:
logging.info(
"global step: %d, loss: %.5f, epoch time: %.3f",
global_step, train_loss / count,
time.time() - start_time)
save_model(para, sess, model)
break
# validation
load_weights(valid_para, valid_sess, valid_model)
valid_sess.run(valid_data_generator.iterator.initializer)
valid_loss = 0.0
valid_rse = 0.0
count = 0
n_samples = 0
all_outputs, all_labels = [], []
while True:
try:
[loss, outputs, labels] = valid_sess.run(fetches=[
valid_model.loss,
valid_model.all_rnn_outputs,
valid_model.labels,
])
if para.mts:
valid_rse += np.sum(
((outputs - labels) * valid_data_generator.scale)
**2)
all_outputs.append(outputs)
all_labels.append(labels)
n_samples += np.prod(outputs.shape)
valid_loss += loss
count += 1
except tf.errors.OutOfRangeError:
break
if para.mts:
all_outputs = np.concatenate(all_outputs)
all_labels = np.concatenate(all_labels)
sigma_outputs = all_outputs.std(axis=0)
sigma_labels = all_labels.std(axis=0)
mean_outputs = all_outputs.mean(axis=0)
mean_labels = all_labels.mean(axis=0)
idx = sigma_labels != 0
valid_corr = ((all_outputs - mean_outputs) *
(all_labels - mean_labels)).mean(
axis=0) / (sigma_outputs * sigma_labels)
valid_corr = valid_corr[idx].mean()
valid_rse = (
np.sqrt(valid_rse / n_samples) / train_data_generator.rse)
valid_loss /= count
logging.info(
"validation loss: %.5f, validation rse: %.5f, validation corr: %.5f",
valid_loss, valid_rse, valid_corr)
else:
logging.info("validation loss: %.5f", valid_loss / count)
def train(para, sess, model, train_data_generator):
valid_para, valid_graph, valid_model, valid_data_generator = \
create_valid_graph(para)
with tf.Session(config=config_setup(), graph=valid_graph) as valid_sess:
valid_sess.run(tf.global_variables_initializer())
for epoch in range(1, para.num_epochs + 1):
logging.info("\n\nEpoch: %d" % epoch)
sess.run(train_data_generator.iterator.initializer)
start_time = time.time()
train_loss = 0.0
count = 0
while True:
try:
[loss, global_step, _] = sess.run(
fetches=[model.loss, model.global_step, model.update])
train_loss += loss
count += 1
if count % 25 == 0:
# print(count, end=' ')
logging.debug(count)
except tf.compat.v1.errors.OutOfRangeError:
logging.info(
"global step: %d, loss: %.5f, epoch time: %.3fs",
global_step, train_loss / count,
time.time() - start_time)
#if para.save_models:
save_model(para, sess, model)
break
# validation
# if para.save_models:
load_weights(valid_para, valid_sess, valid_model)
# else:
# valid_model = model
valid_sess.run(valid_data_generator.iterator.initializer)
valid_loss = 0.0
valid_rse = 0.0
tp, fp, tn, fn = 0, 0, 0, 0
count = 0
n_samples = 0
all_outputs, all_labels = [], []
while True:
try:
[loss, outputs, labels] = valid_sess.run(fetches=[
valid_model.loss,
valid_model.all_rnn_outputs,
valid_model.labels,
])
if para.mts:
valid_rse += np.sum(((outputs - labels) *
valid_data_generator.scale)**2)
all_outputs.append(outputs)
all_labels.append(labels)
n_samples += np.prod(outputs.shape)
elif para.data_set == 'muse' or para.data_set == 'lpd5':
# print(np.shape(outputs))
# print(np.shape(labels))
# print(para.batch_size)
for b in range(
np.shape(outputs)[0]
): ##era para.batchsize, da' ultimul batch avea mai putine el
for p in range(128):
if outputs[b][p] >= 0.5 and labels[b][p] >= 0.5:
tp += 1
elif outputs[b][p] >= 0.5 and labels[b][
p] < 0.5:
fp += 1
elif outputs[b][p] < 0.5 and labels[b][p] < 0.5:
tn += 1
elif outputs[b][p] < 0.5 and labels[b][
p] >= 0.5:
fn += 1
# print([tp, fp, tn, fn])
valid_loss += loss
count += 1
except tf.errors.OutOfRangeError:
break
if para.mts:
all_outputs = np.concatenate(all_outputs)
all_labels = np.concatenate(all_labels)
sigma_outputs = all_outputs.std(axis=0)
sigma_labels = all_labels.std(axis=0)
mean_outputs = all_outputs.mean(axis=0)
mean_labels = all_labels.mean(axis=0)
idx = sigma_labels != 0
valid_corr = ((all_outputs - mean_outputs) *
(all_labels - mean_labels)).mean(
axis=0) / (sigma_outputs * sigma_labels)
valid_corr = valid_corr[idx].mean()
valid_rse = (np.sqrt(valid_rse / n_samples) /
train_data_generator.rse)
valid_loss /= count
logging.info(
"validation loss: %.5f, validation rse: %.5f, validation corr: %.5f",
valid_loss, valid_rse, valid_corr)
elif para.data_set == 'muse' or para.data_set == 'lpd5':
if (tp != 0 or fp != 0):
precision = tp / (tp + fp)
else:
precision = 0
recall = tp / (tp + fn)
if precision + recall >= 1e-6:
F1 = 2 * precision * recall / (precision + recall)
else:
F1 = 0.0
logging.info('validation loss: %.5f', valid_loss / count)
logging.info('precision: %.5f', precision)
logging.info('recall: %.5f', recall)
logging.info('F1 score: %.5f', F1)
#%%
create_dir(para.model_dir)
create_dir(para.output_dir)
json_path = para.model_dir + '/parameters.json'
json.dump(vars(para), open(json_path, 'w'), indent=4)
# %%
graph = tf.Graph()
# %%
graph, model, data_generator = create_graph(para)
# %%
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
load_weights(para, sess, model)
print_num_of_trainable_parameters()
train(para, sess, model, data_generator)
# %%
para.mode = 'test'
graph, model, data_generator = create_graph(para)
with tf.Session(config=config_setup(), graph=graph) as sess:
sess.run(tf.global_variables_initializer())
load_weights(para, sess, model)
print_num_of_trainable_parameters()
test(para, sess, model, data_generator)
# %%
pred_df = pd.read_parquet(
os.path.join(para.output_dir, para.data_set + '_predict_output.parquet'))
pred_df.head(10)
from lib.rl import policy_gradient
from lib.test import test
if __name__ == "__main__":
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
PARA = params_setup()
create_model_dir(PARA)
logging_config_setup(PARA)
print_parameters(PARA)
GRAPH, MODEL = create_graph(PARA)
with tf.Session(config=config_setup(), graph=GRAPH) as sess:
sess.run(tf.global_variables_initializer())
load_weights(PARA, sess, MODEL)
COORD = tf.train.Coordinator()
THREADS = tf.train.start_queue_runners(sess=sess, coord=COORD)
try:
if PARA.mode == 'pretrain':
pretrain(PARA, sess, MODEL)
elif PARA.mode == 'rl':
policy_gradient(PARA, sess, MODEL)
elif PARA.mode == 'test':
test(PARA, sess, MODEL)
except KeyboardInterrupt:
print('KeyboardInterrupt')
finally:
print('Stop')
COORD.request_stop()
def load_original_weights(original_para, original_sess, original_model):
"Load weights of the pretrained model"
original_sess.run(tf.global_variables_initializer())
logging.info('Loading original model')
load_weights(original_para, original_sess, original_model)
