def train(hidden_size, learning_rate, l2_regularization):
# train_set = np.load('../../Trajectory_generate/dataset_file/HF_train_.npy').reshape(-1, 6, 30)
# test_set = np.load('../../Trajectory_generate/dataset_file/HF_validate_.npy').reshape(-1, 6, 30)
# test_set = np.load('../../Trajectory_generate/dataset_file/HF_test_.npy').reshape(-1, 6, 30)
# train_set = np.load("../../Trajectory_generate/dataset_file/train_x_.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/test_x.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/validate_x_.npy").reshape(-1, 6, 60)
# train_set = np.load("../../Trajectory_generate/dataset_file/mimic_train_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_test_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_validate_.npy").reshape(-1, 6, 37)
# sepsis mimic dataset
train_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_train.npy').reshape(-1, 13, 40)
test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_test.npy').reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_validate.npy').reshape(-1, 13, 40)
previous_visit = 3
predicted_visit = 10
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
batch_size = 64
epochs = 50
# hidden_size = 2 ** (int(hidden_size))
# learning_rate = 10 ** learning_rate
# l2_regularization = 10 ** l2_regularization
print('previous_visit---{}---predicted_visit----{}-'.format(previous_visit, predicted_visit))
print('hidden_size{}-----learning_rate{}----l2_regularization{}----'.format(hidden_size, learning_rate, l2_regularization))
encode_share = Encoder(hidden_size=hidden_size)
decoder_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
logged = set()
max_loss = 0.01
max_pace = 0.0001
mse_loss = 0
count = 0
optimizer = tf.keras.optimizers.RMSprop(learning_rate=learning_rate)
while train_set.epoch_completed < epochs:
input_train = train_set.next_batch(batch_size)
input_x_train = input_train[:, :, 1:]
input_t_train = input_train[:, :, 0]
batch = input_x_train.shape[0]
with tf.GradientTape() as tape:
predicted_trajectory = np.zeros(shape=(batch, 0, feature_dims))
for predicted_visit_ in range(predicted_visit):
sequence_time_last_time = input_x_train[:, previous_visit+predicted_visit_-1, :] # y_j
for previous_visit_ in range(previous_visit+predicted_visit_):
sequence_time = input_x_train[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
encode_h = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
encode_c, encode_h = encode_share([sequence_time, encode_c, encode_h])
context_state = encode_h # h_j from 1 to j
input_decode = tf.concat((sequence_time_last_time, context_state), axis=1) # y_j and h_j
if predicted_visit_ == 0:
decode_c = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
decode_h = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
input_t = tf.reshape(input_t_train[:, previous_visit+predicted_visit_], [-1, 1])
predicted_next_sequence, decode_c, decode_h = decoder_share([input_decode, input_t, decode_c, decode_h])
predicted_next_sequence = tf.reshape(predicted_next_sequence, [batch, -1, feature_dims])
predicted_trajectory = tf.concat((predicted_trajectory, predicted_next_sequence), axis=1)
mse_loss = tf.reduce_mean(tf.keras.losses.mse(input_x_train[:, previous_visit: previous_visit+predicted_visit, :], predicted_trajectory))
variables = [var for var in encode_share.trainable_variables]
for weight in encode_share.trainable_variables:
mse_loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in decoder_share.trainable_variables:
mse_loss += tf.keras. regularizers.l2(l2_regularization)(weight)
variables.append(weight)
gradient = tape.gradient(mse_loss, variables)
optimizer.apply_gradients(zip(gradient, variables))
if train_set.epoch_completed % 1 == 0 and train_set.epoch_completed not in logged:
logged.add(train_set.epoch_completed)
loss_pre = mse_loss
mse_loss = tf.reduce_mean(tf.keras.losses.mse(input_x_train[:, previous_visit: previous_visit + predicted_visit, :], predicted_trajectory))
loss_diff = loss_pre - mse_loss
if mse_loss > max_loss:
count = 0
else:
if loss_diff > max_pace:
count = 0
else:
count += 1
if count > 9:
break
input_x_test = test_set[:, :, 1:]
input_t_test = test_set[:, :, 0]
batch_test = input_x_test.shape[0]
predicted_trajectory_test = np.zeros(shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
if predicted_visit_ == 0:
sequence_time_last_time_test = input_x_test[:, predicted_visit_+previous_visit-1, :]
for previous_visit_ in range(previous_visit):
sequence_time_test = input_x_test[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
encode_h_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
encode_c_test, encode_h_test = encode_share([sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
sequence_input_t = predicted_trajectory_test[:, i, :]
encode_c_test, encode_h_test = encode_share([sequence_input_t, encode_c_test, encode_h_test])
context_state = encode_h_test
if predicted_visit_ == 0:
decode_c_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
decode_h_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
input_decode_test = tf.concat((sequence_time_last_time_test, context_state), axis=1)
input_t = tf.reshape(input_t_test[:, previous_visit+predicted_visit_], [-1, 1])
predicted_next_sequence_test, decode_c_test, decode_h_test = decoder_share([input_decode_test, input_t, decode_c_test, decode_h_test])
sequence_time_last_time_test = predicted_next_sequence_test # feed the generated sequence into next state
predicted_next_sequence_test = tf.reshape(predicted_next_sequence_test, [batch_test, -1, feature_dims])
predicted_trajectory_test = tf.concat((predicted_trajectory_test, predicted_next_sequence_test),
axis=1)
mse_loss_predicted = tf.reduce_mean(tf.keras.losses.mse(input_x_test[:, previous_visit:previous_visit+predicted_visit, :], predicted_trajectory_test))
mae_predicted = tf.reduce_mean(tf.keras.losses.mae(input_x_test[:, previous_visit:previous_visit+predicted_visit, :], predicted_trajectory_test))
r_value_all = []
for patient in range(batch_test):
r_value = 0.0
for feature in range(feature_dims):
x_ = input_x_test[patient, previous_visit:, feature].reshape(predicted_visit, 1)
y_ = predicted_trajectory_test[patient, :, feature].numpy().reshape(predicted_visit, 1)
r_value += DynamicTimeWarping(x_, y_)
r_value_all.append(r_value / 29.0)
print('------epoch{}------mse_loss{}----predicted_mse-----{}---predicted_r_value---{}--'
'-count {}'.format(train_set.epoch_completed,
mse_loss, mse_loss_predicted,
np.mean(r_value_all),
count))
# r_value_all = []
# p_value_all = []
# r_value_spearman = []
# r_value_kendalltau = []
# for visit in range(predicted_visit):
# for feature in range(feature_dims):
# x_ = input_x_test[:, previous_visit+visit, feature]
# y_ = predicted_trajectory_test[:, visit, feature]
# r_value_ = stats.pearsonr(x_, y_)
# r_value_spearman_ = stats.spearmanr(x_, y_)
# r_value_kendalltau_ = stats.kendalltau(x_, y_)
# if not np.isnan(r_value_[0]):
# r_value_all.append(np.abs(r_value_[0]))
# p_value_all.append(np.abs(r_value_[1]))
# if not np.isnan(r_value_spearman_[0]):
# r_value_spearman.append(np.abs(r_value_spearman_[0]))
# if not np.isnan(r_value_kendalltau_[0]):
# r_value_kendalltau.append(np.abs(r_value_kendalltau_[0]))
# print('------epoch{}------mse_loss{}----predicted_mse-----{}---predicted_r_value---{}--'
# 'r_value_spearman---{}---r_value_kendalltau---{}--count {}'.format(train_set.epoch_completed,
# mse_loss, mse_loss_predicted,
# np.mean(r_value_all),
# np.mean(r_value_spearman),
# np.mean(r_value_kendalltau),
# count))
tf.compat.v1.reset_default_graph()
return mse_loss_predicted, mae_predicted, np.mean(r_value_all), np.mean(p_value_all)
def train(hidden_size, z_dims, l2_regularization, learning_rate, kl_imbalance,
reconstruction_imbalance, generated_mse_imbalance):
# train_set = np.load("../../Trajectory_generate/dataset_file/HF_train_.npy").reshape(-1, 6, 30)
# test_set = np.load("../../Trajectory_generate/dataset_file/HF_test_.npy").reshape(-1, 6, 30)
# test_set = np.load("../../Trajectory_generate/dataset_file/HF_validate_.npy").reshape(-1, 6, 30)
# train_set = np.load("../../Trajectory_generate/dataset_file/train_x_.npy").reshape(-1, 6, 60)[:, :, 1:]
# test_set = np.load("../../Trajectory_generate/dataset_file/test_x.npy").reshape(-1, 6, 60)[:, :, 1:]
# test_set = np.load("../../Trajectory_generate/dataset_file/validate_x_.npy").reshape(-1, 6, 60)[:, :, 1:]
# train_set = np.load("../../Trajectory_generate/dataset_file/mimic_train_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_test_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_validate_.npy").reshape(-1, 6, 37)
train_set = np.load(
'../../Trajectory_generate/dataset_file/sepsis_mimic_train.npy'
).reshape(-1, 13, 40)
test_set = np.load(
'../../Trajectory_generate/dataset_file/sepsis_mimic_test.npy'
).reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_validate.npy').reshape(-1, 13, 40)
previous_visit = 3
predicted_visit = 10
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
batch_size = 64
epochs = 50
#
# hidden_size = 2 ** (int(hidden_size))
# z_dims = 2 ** (int(z_dims))
# learning_rate = 10 ** learning_rate
# l2_regularization = 10 ** l2_regularization
# kl_imbalance = 10 ** kl_imbalance
# reconstruction_imbalance = 10 ** reconstruction_imbalance
# generated_mse_imbalance = 10 ** generated_mse_imbalance
print('previous_visit---{}---predicted_visit----{}-'.format(
previous_visit, predicted_visit))
print(
'hidden_size{}----z_dims{}------learning_rate{}----l2_regularization{}---'
'kl_imbalance{}----reconstruction_imbalance '
' {}----generated_mse_imbalance{}----'.format(
hidden_size, z_dims, learning_rate, l2_regularization,
kl_imbalance, reconstruction_imbalance, generated_mse_imbalance))
encode_share = Encoder(hidden_size=hidden_size)
decode_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
prior_net = Prior(z_dims=z_dims)
post_net = Post(z_dims=z_dims)
logged = set()
max_loss = 0.01
max_pace = 0.0001
loss = 0
count = 0
optimizer = tf.keras.optimizers.RMSprop(learning_rate=learning_rate)
while train_set.epoch_completed < epochs:
input_train = train_set.next_batch(batch_size=batch_size)
input_x_train = tf.cast(input_train[:, :, 1:], dtype=tf.float32)
input_t_train = tf.cast(input_train[:, :, 0], tf.float32)
batch = input_x_train.shape[0]
with tf.GradientTape() as tape:
generated_trajectory = np.zeros(shape=[batch, 0, feature_dims])
construct_trajectory = np.zeros(shape=[batch, 0, feature_dims])
z_log_var_post_all = np.zeros(shape=[batch, 0, z_dims])
z_mean_post_all = np.zeros(shape=[batch, 0, z_dims])
z_log_var_prior_all = np.zeros(shape=[batch, 0, z_dims])
z_mean_prior_all = np.zeros(shape=[batch, 0, z_dims])
for predicted_visit_ in range(predicted_visit):
sequence_last_time = input_x_train[:, predicted_visit_ +
previous_visit - 1, :]
sequence_time_current_time = input_x_train[:,
predicted_visit_ +
previous_visit, :]
for previous_visit_ in range(previous_visit +
predicted_visit_):
sequence_time = input_x_train[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_h = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_c, encode_h = encode_share(
[sequence_time, encode_c, encode_h])
context_state = encode_h
z_prior, z_mean_prior, z_log_var_prior = prior_net(
context_state) # h_i--> z_(i+1)
encode_c, encode_h = encode_share(
[sequence_time_current_time, encode_c,
encode_h]) # h_(i+1)
z_post, z_mean_post, z_log_var_post = post_net(
[context_state, encode_h]) # h_i, h_(i+1) --> z_(i+1)
if predicted_visit_ == 0:
decode_c_generate = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h_generate = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_c_reconstruct = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h_reconstruct = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
input_t = tf.reshape(
input_t_train[:, previous_visit + predicted_visit_],
[-1, 1])
construct_next_visit, decode_c_reconstruct, decode_h_reconstruct = decode_share(
[
z_post, context_state, sequence_last_time,
decode_c_reconstruct, decode_h_reconstruct, input_t
])
construct_next_visit = tf.reshape(construct_next_visit,
[batch, -1, feature_dims])
construct_trajectory = tf.concat(
(construct_trajectory, construct_next_visit), axis=1)
generated_next_visit, decode_c_generate, decode_h_generate = decode_share(
[
z_prior, context_state, sequence_last_time,
decode_c_generate, decode_h_generate, input_t
])
generated_next_visit = tf.reshape(generated_next_visit,
(batch, -1, feature_dims))
generated_trajectory = tf.concat(
(generated_trajectory, generated_next_visit), axis=1)
z_mean_prior_all = tf.concat(
(z_mean_prior_all,
tf.reshape(z_mean_prior, [batch, -1, z_dims])),
axis=1)
z_mean_post_all = tf.concat(
(z_mean_post_all,
tf.reshape(z_mean_post, [batch, -1, z_dims])),
axis=1)
z_log_var_prior_all = tf.concat(
(z_log_var_prior_all,
tf.reshape(z_log_var_prior, [batch, -1, z_dims])),
axis=1)
z_log_var_post_all = tf.concat(
(z_log_var_post_all,
tf.reshape(z_log_var_post, [batch, -1, z_dims])),
axis=1)
mse_reconstruction = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :], construct_trajectory))
mse_generate = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :], generated_trajectory))
std_post = tf.math.sqrt(tf.exp(z_log_var_post_all))
std_prior = tf.math.sqrt(tf.exp(z_mean_prior_all))
kl_loss_element = 0.5 * (
2 * tf.math.log(tf.maximum(std_prior, 1e-9)) -
2 * tf.math.log(tf.maximum(std_post, 1e-9)) +
(tf.math.pow(std_post, 2) + tf.math.pow(
(z_mean_post_all - z_mean_prior_all), 2)) /
tf.maximum(tf.math.pow(std_prior, 2), 1e-9) - 1)
kl_loss_all = tf.reduce_mean(kl_loss_element)
loss += mse_reconstruction * reconstruction_imbalance + kl_loss_all * kl_imbalance + mse_generate * generated_mse_imbalance
variables = [var for var in encode_share.trainable_variables]
for weight in encode_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in decode_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for weight in post_net.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for weight in prior_net.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
tape.watch(variables)
gradient = tape.gradient(loss, variables)
optimizer.apply_gradients(zip(gradient, variables))
if train_set.epoch_completed % 1 == 0 and train_set.epoch_completed not in logged:
logged.add(train_set.epoch_completed)
loss_pre = mse_generate
mse_reconstruction = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :],
construct_trajectory))
mse_generate = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory))
kl_loss_all = tf.reduce_mean(
kl_loss(z_mean_post=z_mean_post_all,
z_mean_prior=z_mean_prior_all,
log_var_post=z_log_var_post_all,
log_var_prior=z_log_var_prior_all))
loss = mse_reconstruction + mse_generate + kl_loss_all
loss_diff = loss_pre - mse_generate
if mse_generate > max_loss:
count = 0 # max_loss = 0.01
else:
if loss_diff > max_pace: # max_pace = 0.0001
count = 0
else:
count += 1
if count > 9:
break
input_test = test_set
input_x_test = tf.cast(input_test[:, :, 1:], dtype=tf.float32)
input_t_test = tf.cast(input_test[:, :, 0], tf.float32)
batch_test = input_x_test.shape[0]
generated_trajectory_test = np.zeros(
shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
for previous_visit_ in range(previous_visit):
sequence_time_test = input_x_test[:,
previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(
tf.zeros(shape=(batch_test, hidden_size)))
encode_h_test = tf.Variable(
tf.zeros(shape=(batch_test, hidden_size)))
encode_c_test, encode_h_test = encode_share(
[sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
sequence_input_t = generated_trajectory_test[:,
i, :]
encode_c_test, encode_h_test = encode_share([
sequence_input_t, encode_c_test, encode_h_test
])
context_state_test = encode_h_test
z_prior_test, z_mean_prior_test, z_log_var_prior_test = prior_net(
context_state_test)
if predicted_visit_ == 0:
decode_c_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
decode_h_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
sequence_last_time_test = input_x_test[:,
predicted_visit_
+
previous_visit -
1, :]
input_t = tf.reshape(
input_t_test[:, previous_visit + predicted_visit_],
[-1, 1])
sequence_last_time_test, decode_c_generate_test, decode_h_generate_test = decode_share(
[
z_prior_test, context_state_test,
sequence_last_time_test, decode_c_generate_test,
decode_h_generate_test, input_t
])
generated_next_visit_test = sequence_last_time_test
generated_next_visit_test = tf.reshape(
generated_next_visit_test,
[batch_test, -1, feature_dims])
generated_trajectory_test = tf.concat(
(generated_trajectory_test, generated_next_visit_test),
axis=1)
mse_generate_test = tf.reduce_mean(
tf.keras.losses.mse(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
mae_generate_test = tf.reduce_mean(
tf.keras.losses.mae(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
# r_value_all = []
# p_value_all = []
# r_value_spearman_all = []
# r_value_kendalltau_all = []
# for visit in range(predicted_visit):
# for feature in range(feature_dims):
# x_ = input_x_test[:, previous_visit+visit, feature]
# y_ = generated_trajectory_test[:, visit, feature]
# r_value_pearson = stats.pearsonr(x_, y_)
# r_value_spearman = stats.spearmanr(x_, y_)
# r_value_kendalltau = stats.kendalltau(x_, y_)
# if not np.isnan(r_value_pearson[0]):
# r_value_all.append(np.abs(r_value_pearson[0]))
# p_value_all.append(np.abs(r_value_pearson[1]))
#
# if not np.isnan(r_value_spearman[0]):
# r_value_spearman_all.append(np.abs(r_value_spearman[0]))
#
# if not np.isnan(r_value_kendalltau[0]):
# r_value_kendalltau_all.append(np.abs(r_value_kendalltau[0]))
r_value_all = []
for patient in range(batch_test):
r_value = 0.0
for feature in range(feature_dims):
x_ = input_x_test[patient, previous_visit:,
feature].numpy().reshape(
predicted_visit, 1)
y_ = generated_trajectory_test[
patient, :,
feature].numpy().reshape(predicted_visit, 1)
r_value += DynamicTimeWarping(x_, y_)
r_value_all.append(r_value / 29.0)
print(
"epoch {}---train_mse_generate {}--train_reconstruct {}--train_kl "
"{}--test_mse {}--test_mae {}----r_value {}--"
"---count {}---".format(train_set.epoch_completed,
mse_generate, mse_reconstruction,
kl_loss_all, mse_generate_test,
mae_generate_test,
np.mean(r_value_all), count))
# print("epoch {}---train_mse_generate {}--train_reconstruct {}--train_kl "
# "{}--test_mse {}--test_mae {}----r_value {}--r_value_spearman---{}---"
# "r_value_kendalltau---{}------count {}-".format(train_set.epoch_completed,
# mse_generate,
# mse_reconstruction,
# kl_loss_all,
# mse_generate_test,
# mae_generate_test,
# np.mean(r_value_all),
# np.mean(r_value_spearman_all),
# np.mean(r_value_kendalltau_all),
# count))
tf.compat.v1.reset_default_graph()
return mse_generate_test, mae_generate_test, np.mean(r_value_all)
def test():
train_set = np.load(
"../../Trajectory_generate/dataset_file/train_x_.npy").reshape(
-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/test_x.npy").reshape(-1, 6, 60)
test_set = np.load(
"../../Trajectory_generate/dataset_file/validate_x_.npy").reshape(
-1, 6, 60)
previous_visit = 3
predicted_visit = 3
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
hidden_size = 64
z_dims = 64
encode_share = Encoder(hidden_size=hidden_size)
decoder_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
prior_net = Prior(z_dims=z_dims)
post_net = Post(z_dims=z_dims)
hawkes_process = HawkesProcess()
checkpoint_encode_share = tf.train.Checkpoint(encode_share=encode_share)
checkpoint_encode_share.restore(
tf.train.latest_checkpoint('./model/encoder_share/46.ckpt'))
checkpoint_decode_share = tf.train.Checkpoint(decoder_share=decoder_share)
checkpoint_decode_share.restore(
tf.train.latest_checkpoint('./model/decoder_share/46.ckpt'))
checkpoint_post = tf.train.Checkpoint(post_net=post_net)
checkpoint_post.restore(
tf.train.latest_checkpoint('./model/checkpoint_post/46.ckpt'))
checkpoint_prior = tf.train.Checkpoint(prior_net=prior_net)
checkpoint_prior.restore(
tf.train.latest_checkpoint('./model/checkpoint_prior/46.ckpt'))
checkpoint_hawkes = tf.train.Checkpoint(hawkes_process=hawkes_process)
checkpoint_hawkes.restore(
tf.train.latest_checkpoint('./model/checkpoint_hawkes/46.ckpt'))
input_x_test = tf.cast(test_set[:, :, 1:], tf.float32)
input_t_test = tf.cast(test_set[:, :, 0], tf.float32)
batch_test = input_x_test.shape[0]
generated_trajectory_test = tf.zeros(shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
for previous_visit_ in range(previous_visit + predicted_visit_):
sequence_time_test = input_x_test[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_h_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_c_test, encode_h_test = encode_share(
[sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
sequence_input_t = generated_trajectory_test[:, i, :]
encode_c_test, encode_h_test = encode_share(
[sequence_input_t, encode_c_test, encode_h_test])
context_state_test = encode_h_test
z_prior_test, z_mean_prior_test, z_log_var_prior = prior_net(
context_state_test)
if predicted_visit_ == 0:
decode_c_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
decode_h_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
sequence_last_time_test = input_x_test[:, predicted_visit_ +
previous_visit, :]
current_time_index_shape_test = tf.ones(
shape=[previous_visit + predicted_visit_])
condition_intensity_test, likelihood_test = hawkes_process(
[input_t_test, current_time_index_shape_test])
sequence_next_visit_test, decode_c_generate_test, decode_h_generate_test = decoder_share(
[
z_prior_test, context_state_test, sequence_last_time_test,
decode_c_generate_test,
decode_h_generate_test * condition_intensity_test
])
sequence_last_time_test = sequence_next_visit_test
sequence_next_visit_test = tf.reshape(sequence_last_time_test,
[batch_test, -1, feature_dims])
generated_trajectory_test = tf.concat(
(generated_trajectory_test, sequence_next_visit_test), axis=1)
mse_generated_test = tf.reduce_mean(
tf.keras.losses.mse(
input_x_test[:,
previous_visit:previous_visit + predicted_visit, :],
generated_trajectory_test))
mae_generated_test = tf.reduce_mean(
tf.keras.losses.mae(
input_x_test[:,
previous_visit:previous_visit + predicted_visit, :],
generated_trajectory_test))
r_value_all = []
p_value_all = []
for r in range(predicted_visit):
x_ = tf.reshape(input_x_test[:, previous_visit + r, :], (-1, ))
y_ = tf.reshape(generated_trajectory_test[:, r, :], (-1, ))
r_value_ = stats.pearsonr(x_, y_)
r_value_all.append(r_value_[0])
p_value_all.append(r_value_[1])
return mse_generated_test, mae_generated_test, np.mean(r_value_all)
def train(hidden_size, z_dims, l2_regularization, learning_rate, kl_imbalance,
reconstruction_imbalance, generated_mse_imbalance,
likelihood_imbalance):
# train_set = np.load("../../Trajectory_generate/dataset_file/train_x_.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/test_x.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/validate_x_.npy").reshape(-1, 6, 60)
train_set = np.load(
'../../Trajectory_generate/dataset_file/HF_train_.npy').reshape(
-1, 6, 30)
# test_set = np.load('../../Trajectory_generate/dataset_file/HF_validate_.npy').reshape(-1, 6, 30)
test_set = np.load(
'../../Trajectory_generate/dataset_file/HF_test_.npy').reshape(
-1, 6, 30)
# train_set = np.load("../../Trajectory_generate/dataset_file/mimic_train_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_test_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_validate_.npy").reshape(-1, 6, 37)
previous_visit = 1
predicted_visit = 5
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
batch_size = 64
epochs = 50
#
# hidden_size = 2 ** (int(hidden_size))
# z_dims = 2 ** (int(z_dims))
# learning_rate = 10 ** learning_rate
# l2_regularization = 10 ** l2_regularization
# kl_imbalance = 10 ** kl_imbalance
# reconstruction_imbalance = 10 ** reconstruction_imbalance
# generated_mse_imbalance = 10 ** generated_mse_imbalance
# likelihood_imbalance = 10 ** likelihood_imbalance
print('previous_visit---{}---predicted_visit----{}-'.format(
previous_visit, predicted_visit))
print(
'hidden_size{}----z_dims{}------learning_rate{}----l2_regularization{}---'
'kl_imbalance{}----reconstruction_imbalance '
' {}----generated_mse_imbalance{}----'.format(
hidden_size, z_dims, learning_rate, l2_regularization,
kl_imbalance, reconstruction_imbalance, generated_mse_imbalance))
encode_share = Encoder(hidden_size=hidden_size)
decoder_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
prior_net = Prior(z_dims=z_dims)
post_net = Post(z_dims=z_dims)
hawkes_process = HawkesProcess()
logged = set()
max_loss = 0.001
max_pace = 0.0001
loss = 0
count = 0
optimizer = tf.keras.optimizers.RMSprop(learning_rate=learning_rate)
while train_set.epoch_completed < epochs:
input_train = train_set.next_batch(batch_size=batch_size)
input_x_train = tf.cast(input_train[:, :, 1:], tf.float32)
input_t_train = tf.cast(input_train[:, :, 0], tf.float32)
batch = input_x_train.shape[0]
with tf.GradientTape() as tape:
generated_trajectory = tf.zeros(shape=[batch, 0, feature_dims])
reconstruction_trajectory = tf.zeros(
shape=[batch, 0, feature_dims])
z_log_var_post_all = tf.zeros(shape=[batch, 0, z_dims])
z_mean_post_all = tf.zeros(shape=[batch, 0, z_dims])
z_mean_prior_all = tf.zeros(shape=[batch, 0, z_dims])
z_log_var_prior_all = tf.zeros(shape=[batch, 0, z_dims])
probability_likelihood = tf.zeros(shape=[batch, 0, 1])
for predicted_visit_ in range(predicted_visit):
sequence_time_current_time = input_x_train[:,
predicted_visit_ +
previous_visit, :]
sequence_time_last_time = input_x_train[:, predicted_visit_ +
previous_visit - 1, :]
for previous_visit_ in range(previous_visit +
predicted_visit_):
sequence_time = input_x_train[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_h = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_c, encode_h = encode_share(
[sequence_time, encode_c, encode_h])
context_state = encode_h
if predicted_visit_ == 0:
decode_c_generate = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h_generate = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_c_reconstruct = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h_reconstruct = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
z_prior, z_mean_prior, z_log_var_prior = prior_net(
context_state)
encode_c, encode_h = encode_share(
[sequence_time_current_time, encode_c, encode_h])
z_post, z_mean_post, z_log_var_post = post_net(
[context_state, encode_h])
current_time_index_shape = tf.ones(
shape=[predicted_visit_ + previous_visit])
condition_intensity, likelihood = hawkes_process(
[input_t_train, current_time_index_shape])
generated_next_visit, decode_c_generate, decode_h_generate = decoder_share(
[
z_prior, context_state, sequence_time_last_time,
decode_c_generate,
decode_h_generate * condition_intensity
])
likelihood = tf.reshape(likelihood, [batch, -1, 1])
probability_likelihood = tf.concat(
(probability_likelihood, likelihood), axis=1)
generated_next_visit = tf.reshape(generated_next_visit,
[batch, -1, feature_dims])
generated_trajectory = tf.concat(
(generated_trajectory, generated_next_visit), axis=1)
construct_next_visit, decode_c_reconstruct, decode_h_reconstruct = decoder_share(
[
z_post, context_state, sequence_time_last_time,
decode_c_reconstruct,
decode_h_reconstruct * condition_intensity
])
construct_next_visit = tf.reshape(construct_next_visit,
[batch, -1, feature_dims])
reconstruction_trajectory = tf.concat(
(reconstruction_trajectory, construct_next_visit), axis=1)
z_mean_prior_all = tf.concat(
(z_mean_prior_all,
tf.reshape(z_mean_prior, [batch, -1, z_dims])),
axis=1)
z_log_var_prior_all = tf.concat(
(z_log_var_prior_all,
tf.reshape(z_log_var_prior, [batch, -1, z_dims])),
axis=1)
z_mean_post_all = tf.concat(
(z_mean_post_all,
tf.reshape(z_mean_post, [batch, -1, z_dims])),
axis=1)
z_log_var_post_all = tf.concat(
(z_log_var_post_all,
tf.reshape(z_log_var_post, [batch, -1, z_dims])),
axis=1)
mse_reconstruction = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :],
reconstruction_trajectory))
mse_generated = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :],
reconstruction_trajectory))
std_post = tf.math.sqrt(tf.exp(z_log_var_post_all))
std_prior = tf.math.sqrt(tf.exp(z_log_var_prior_all))
kl_loss_element = 0.5 * (
2 * tf.math.log(tf.maximum(std_prior, 1e-9)) -
2 * tf.math.log(tf.maximum(std_post, 1e-9)) +
(tf.math.pow(std_post, 2) + tf.math.pow(
(z_mean_post_all - z_mean_prior_all), 2)) /
tf.maximum(tf.math.pow(std_prior, 2), 1e-9) - 1)
kl_loss_all = tf.reduce_mean(kl_loss_element)
# print('kl_loss---{}'.format(kl_loss_all))
likelihood_loss = tf.reduce_mean(probability_likelihood)
loss += mse_reconstruction * reconstruction_imbalance + mse_generated * generated_mse_imbalance + kl_loss_all * kl_imbalance + likelihood_loss * likelihood_imbalance
variables = [var for var in encode_share.trainable_variables]
for weight in encode_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in decoder_share.trainable_variables:
variables.append(weight)
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in prior_net.trainable_variables:
variables.append(weight)
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in post_net.trainable_variables:
variables.append(weight)
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in hawkes_process.trainable_variables:
variables.append(weight)
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
tape.watch(variables)
gradient = tape.gradient(loss, variables)
optimizer.apply_gradients(zip(gradient, variables))
if train_set.epoch_completed % 1 == 0 and train_set.epoch_completed not in logged:
logged.add(train_set.epoch_completed)
loss_pre = mse_generated
mse_generated = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :],
reconstruction_trajectory))
loss_diff = loss_pre - mse_generated
if mse_generated > max_loss:
count = 0
else:
if loss_diff > max_pace:
count = 0
else:
count += 1
if count > 9:
break
input_x_test = tf.cast(test_set[:, :, 1:], tf.float32)
input_t_test = tf.cast(test_set[:, :, 0], tf.float32)
batch_test = input_x_test.shape[0]
generated_trajectory_test = tf.zeros(
shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
for previous_visit_ in range(previous_visit):
sequence_time_test = input_x_test[:,
previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_h_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_c_test, encode_h_test = encode_share(
[sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
sequence_input_t = generated_trajectory_test[:,
i, :]
encode_c_test, encode_h_test = encode_share([
sequence_input_t, encode_c_test, encode_h_test
])
context_state_test = encode_h_test
z_prior_test, z_mean_prior_test, z_log_var_prior = prior_net(
context_state_test)
if predicted_visit_ == 0:
decode_c_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
decode_h_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
sequence_last_time_test = input_x_test[:,
predicted_visit_
+
previous_visit, :]
current_time_index_shape_test = tf.ones(
shape=[previous_visit + predicted_visit_])
condition_intensity_test, likelihood_test = hawkes_process(
[input_t_test, current_time_index_shape_test])
sequence_next_visit_test, decode_c_generate_test, decode_h_generate_test = decoder_share(
[
z_prior_test, context_state_test,
sequence_last_time_test, decode_c_generate_test,
decode_h_generate_test * condition_intensity_test
])
sequence_last_time_test = sequence_next_visit_test
sequence_next_visit_test = tf.reshape(
sequence_last_time_test,
[batch_test, -1, feature_dims])
generated_trajectory_test = tf.concat(
(generated_trajectory_test, sequence_next_visit_test),
axis=1)
mse_generated_test = tf.reduce_mean(
tf.keras.losses.mse(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
mae_generated_test = tf.reduce_mean(
tf.keras.losses.mae(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
r_value_all = []
p_value_all = []
for r in range(predicted_visit):
x_ = tf.reshape(input_x_test[:, previous_visit + r, :],
(-1, ))
y_ = tf.reshape(generated_trajectory_test[:, r, :], (-1, ))
r_value_ = stats.pearsonr(x_, y_)
r_value_all.append(r_value_[0])
p_value_all.append(r_value_[1])
print(
"epoch {}---train_mse_generate {}--train_reconstruct {}--train_kl "
"{}--test_mse {}--test_mae {}----r_value {}---count {}".
format(train_set.epoch_completed, mse_generated,
mse_reconstruction, kl_loss_all, mse_generated_test,
mae_generated_test, np.mean(r_value_all), count))
tf.compat.v1.reset_default_graph()
# return mse_generated_test, mae_generated_test, np.mean(r_value_all)
return -1 * mse_generated_test
def train(hidden_size, z_dims, l2_regularization, learning_rate, n_disc,
generated_mse_imbalance, generated_loss_imbalance, kl_imbalance,
reconstruction_mse_imbalance, likelihood_imbalance):
# train_set = np.load("../../Trajectory_generate/dataset_file/train_x_.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/test_x.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/validate_x_.npy").reshape(-1, 6, 60)
# train_set = np.load('../../Trajectory_generate/dataset_file/HF_train_.npy').reshape(-1, 6, 30)[:, :, :]
# test_set = np.load('../../Trajectory_generate/dataset_file/HF_validate_.npy').reshape(-1, 6, 30)[:, :, :]
# test_set = np.load('../../Trajectory_generate/dataset_file/HF_test_.npy').reshape(-1, 6, 30)[:, :, :]
# train_set = np.load("../../Trajectory_generate/dataset_file/mimic_train_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_test_x_.npy").reshape(-1, 6, 37)
# # test_set = np.load("../../Trajectory_generate/dataset_file/mimic_validate_.npy").reshape(-1, 6, 37)
# sepsis mimic dataset
train_set = np.load(
'../../Trajectory_generate/dataset_file/sepsis_mimic_train.npy'
).reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate_dataset_file/sepsis_mimic_test.npy').reshape(-1, 13, 40)[:1072,:, : ]
test_set = np.load(
'../../Trajectory_generate/dataset_file/sepsis_mimic_validate.npy'
).reshape(-1, 13, 40)
previous_visit = 3
predicted_visit = 10
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
batch_size = 64
epochs = 50
hidden_size = 2**(int(hidden_size))
z_dims = 2**(int(z_dims))
l2_regularization = 10**l2_regularization
learning_rate = 10**learning_rate
n_disc = int(n_disc)
generated_mse_imbalance = 10**generated_mse_imbalance
generated_loss_imbalance = 10**generated_loss_imbalance
kl_imbalance = 10**kl_imbalance
reconstruction_mse_imbalance = 10**reconstruction_mse_imbalance
likelihood_imbalance = 10**likelihood_imbalance
print('feature_dims---{}'.format(feature_dims))
print('previous_visit---{}---predicted_visit----{}-'.format(
previous_visit, predicted_visit))
print(
'hidden_size---{}---z_dims---{}---l2_regularization---{}---learning_rate---{}--n_disc---{}-'
'generated_mse_imbalance---{}---generated_loss_imbalance---{}---'
'kl_imbalance---{}---reconstruction_mse_imbalance---{}---'
'likelihood_imbalance---{}'.format(
hidden_size, z_dims, l2_regularization, learning_rate, n_disc,
generated_mse_imbalance, generated_loss_imbalance, kl_imbalance,
reconstruction_mse_imbalance, likelihood_imbalance))
encode_share = Encoder(hidden_size=hidden_size)
decoder_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
discriminator = Discriminator(predicted_visit=predicted_visit,
hidden_size=hidden_size,
previous_visit=previous_visit)
post_net = Post(z_dims=z_dims)
prior_net = Prior(z_dims=z_dims)
hawkes_process = HawkesProcess()
loss = 0
count = 0
optimizer_generation = tf.keras.optimizers.RMSprop(
learning_rate=learning_rate)
optimizer_discriminator = tf.keras.optimizers.RMSprop(
learning_rate=learning_rate)
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
logged = set()
max_loss = 0.001
max_pace = 0.0001
while train_set.epoch_completed < epochs:
input_train = train_set.next_batch(batch_size=batch_size)
input_x_train = tf.cast(input_train[:, :, 1:], tf.float32)
input_t_train = tf.cast(input_train[:, :, 0], tf.float32)
batch = input_train.shape[0]
with tf.GradientTape() as gen_tape, tf.GradientTape(
persistent=True) as disc_tape:
generated_trajectory = tf.zeros(shape=[batch, 0, feature_dims])
probability_likelihood = tf.zeros(shape=[batch, 0, 1])
reconstructed_trajectory = tf.zeros(shape=[batch, 0, feature_dims])
z_mean_post_all = tf.zeros(shape=[batch, 0, z_dims])
z_log_var_post_all = tf.zeros(shape=[batch, 0, z_dims])
z_mean_prior_all = tf.zeros(shape=[batch, 0, z_dims])
z_log_var_prior_all = tf.zeros(shape=[batch, 0, z_dims])
for predicted_visit_ in range(predicted_visit):
sequence_last_time = input_x_train[:, previous_visit +
predicted_visit_ - 1, :]
sequence_current_time = input_x_train[:, previous_visit +
predicted_visit_, :]
for previous_visit_ in range(previous_visit +
predicted_visit_):
sequence_time = input_x_train[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_h = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_c, encode_h = encode_share(
[sequence_time, encode_c, encode_h])
context_state = encode_h # h_i
encode_c, encode_h = encode_share(
[sequence_current_time, encode_c, encode_h]) # h_(i+1)
if predicted_visit_ == 0:
decode_c_generate = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h_generate = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_c_reconstruction = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h_reconstruction = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
z_post, z_mean_post, z_log_var_post = post_net(
[context_state, encode_h])
z_prior, z_mean_prior, z_log_var_prior = prior_net(
context_state)
current_time_index_shape = tf.ones(
shape=[previous_visit + predicted_visit_])
condition_value, likelihood = hawkes_process(
[input_t_train, current_time_index_shape])
probability_likelihood = tf.concat(
(probability_likelihood,
tf.reshape(likelihood, [batch, -1, 1])),
axis=1)
probability_likelihood = tf.keras.activations.softmax(
probability_likelihood)
# generation
generated_next_visit, decode_c_generate, decode_h_generate = decoder_share(
[
z_prior, context_state, sequence_last_time,
decode_c_generate, decode_h_generate * condition_value
])
# reconstruction
reconstructed_next_visit, decode_c_reconstruction, decode_h_reconstruction = decoder_share(
[
z_post, context_state, sequence_last_time,
decode_c_reconstruction,
decode_h_reconstruction * condition_value
])
reconstructed_trajectory = tf.concat(
(reconstructed_trajectory,
tf.reshape(reconstructed_next_visit,
[batch, -1, feature_dims])),
axis=1)
generated_trajectory = tf.concat(
(generated_trajectory,
tf.reshape(generated_next_visit,
[batch, -1, feature_dims])),
axis=1)
z_mean_post_all = tf.concat(
(z_mean_post_all,
tf.reshape(z_mean_post, [batch, -1, z_dims])),
axis=1)
z_mean_prior_all = tf.concat(
(z_mean_prior_all,
tf.reshape(z_mean_prior, [batch, -1, z_dims])),
axis=1)
z_log_var_post_all = tf.concat(
(z_log_var_post_all,
tf.reshape(z_log_var_post, [batch, -1, z_dims])),
axis=1)
z_log_var_prior_all = tf.concat(
(z_log_var_prior_all,
tf.reshape(z_log_var_prior, [batch, -1, z_dims])),
axis=1)
d_real_pre_, d_fake_pre_ = discriminator(input_x_train,
generated_trajectory)
d_real_pre_loss = cross_entropy(tf.ones_like(d_real_pre_),
d_real_pre_)
d_fake_pre_loss = cross_entropy(tf.zeros_like(d_fake_pre_),
d_fake_pre_)
d_loss = d_real_pre_loss + d_fake_pre_loss
gen_loss = cross_entropy(tf.ones_like(d_fake_pre_), d_fake_pre_)
generated_mse_loss = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :], generated_trajectory))
reconstructed_mse_loss = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :],
reconstructed_trajectory))
std_post = tf.math.sqrt(tf.exp(z_log_var_post_all))
std_prior = tf.math.sqrt(tf.exp(z_log_var_prior_all))
kl_loss_element = 0.5 * (
2 * tf.math.log(tf.maximum(std_prior, 1e-9)) -
2 * tf.math.log(tf.maximum(std_post, 1e-9)) +
(tf.square(std_post) +
(tf.square(z_mean_post_all - z_mean_prior_all)) /
(tf.maximum(tf.square(std_prior), 1e-9))) - 1)
kl_loss = tf.reduce_mean(kl_loss_element)
likelihood_loss = tf.reduce_mean(probability_likelihood)
loss += generated_mse_loss * generated_mse_imbalance +\
reconstructed_mse_loss * reconstruction_mse_imbalance + \
kl_loss * kl_imbalance + likelihood_loss * likelihood_imbalance \
+ gen_loss * generated_loss_imbalance
for weight in discriminator.trainable_variables:
d_loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables = [var for var in encode_share.trainable_variables]
for weight in encode_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in decoder_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for weight in post_net.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for weight in prior_net.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for weight in hawkes_process.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for disc in range(n_disc):
gradient_disc = disc_tape.gradient(
d_loss, discriminator.trainable_variables)
optimizer_discriminator.apply_gradients(
zip(gradient_disc, discriminator.trainable_variables))
gradient_gen = gen_tape.gradient(loss, variables)
optimizer_generation.apply_gradients(zip(gradient_gen, variables))
if train_set.epoch_completed % 1 == 0 and train_set.epoch_completed not in logged:
logged.add(train_set.epoch_completed)
loss_pre = generated_mse_loss
mse_generated = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :], generated_trajectory))
loss_diff = loss_pre - mse_generated
if mse_generated > max_loss:
count = 0
else:
if loss_diff > max_pace:
count = 0
else:
count += 1
if count > 9:
break
input_x_test = tf.cast(test_set[:, :, 1:], tf.float32)
input_t_test = tf.cast(test_set[:, :, 0], tf.float32)
batch_test = test_set.shape[0]
generated_trajectory_test = tf.zeros(
shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
for previous_visit_ in range(previous_visit):
sequence_time_test = input_x_test[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_h_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_c_test, encode_h_test = encode_share(
[sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
encode_c_test, encode_h_test = encode_share([
generated_trajectory_test[:, i, :], encode_c_test,
encode_h_test
])
context_state_test = encode_h_test
if predicted_visit_ == 0:
decode_c_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
decode_h_generate_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
sequence_last_time_test = input_x_test[:, previous_visit +
predicted_visit_ -
1, :]
z_prior_test, z_mean_prior_test, z_log_var_prior_test = prior_net(
context_state_test)
current_time_index_shape_test = tf.ones(
[previous_visit + predicted_visit_])
intensity_value_test, likelihood_test = hawkes_process(
[input_t_test, current_time_index_shape_test])
generated_next_visit_test, decode_c_generate_test, decode_h_generate_test = decoder_share(
[
z_prior_test, context_state_test,
sequence_last_time_test, decode_c_generate_test,
decode_h_generate_test * intensity_value_test
])
generated_trajectory_test = tf.concat(
(generated_trajectory_test,
tf.reshape(generated_next_visit_test,
[batch_test, -1, feature_dims])),
axis=1)
sequence_last_time_test = generated_next_visit_test
mse_generated_test = tf.reduce_mean(
tf.keras.losses.mse(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
mae_generated_test = tf.reduce_mean(
tf.keras.losses.mae(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
r_value_all = []
for patient in range(batch_test):
r_value = 0.0
for feature in range(feature_dims):
x_ = input_x_test[patient, previous_visit:previous_visit +
predicted_visit,
feature].numpy().reshape(
predicted_visit, 1)
y_ = generated_trajectory_test[patient, :,
feature].numpy().reshape(
predicted_visit, 1)
r_value += DynamicTimeWarping(x_, y_)
r_value_all.append(r_value / 29.0)
print(
'epoch ---{}---train_mse_generated---{}---likelihood_loss{}---'
'train_mse_reconstruct---{}---train_kl---{}---'
'test_mse---{}---test_mae---{}---'
'r_value_test---{}---count---{}'.format(
train_set.epoch_completed, generated_mse_loss,
likelihood_loss, reconstructed_mse_loss,
kl_loss, mse_generated_test, mae_generated_test,
np.mean(r_value_all), count))
tf.compat.v1.reset_default_graph()
# return mse_generated_test, mae_generated_test, np.mean(r_value_all)
return -1 * mse_generated_test
def train(hidden_size, learning_rate, l2_regularization, n_disc,
generated_mse_imbalance, generated_loss_imbalance,
likelihood_imbalance):
# train_set = np.load("../../Trajectory_generate/dataset_file/train_x_.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/test_x.npy").reshape(-1, 6, 60)
# test_set = np.load("../../Trajectory_generate/dataset_file/validate_x_.npy").reshape(-1, 6, 60)
train_set = np.load(
'../../Trajectory_generate/dataset_file/HF_train_.npy').reshape(
-1, 6, 30)
# test_set = np.load('../../Trajectory_generate/dataset_file/HF_validate_.npy').reshape(-1, 6, 30)
test_set = np.load(
'../../Trajectory_generate/dataset_file/HF_test_.npy').reshape(
-1, 6, 30)
# train_set = np.load("../../Trajectory_generate/dataset_file/mimic_train_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_test_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_validate_.npy").reshape(-1, 6, 37)
# sepsis mimic dataset
# train_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_train.npy').reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_test.npy').reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_validate.npy').reshape(-1, 13, 40)
previous_visit = 3
predicted_visit = 3
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
batch_size = 64
epochs = 50
# hidden_size = 2 ** (int(hidden_size))
# learning_rate = 10 ** learning_rate
# l2_regularization = 10 ** l2_regularization
# n_disc = int(n_disc)
# generated_mse_imbalance = 10 ** generated_mse_imbalance
# generated_loss_imbalance = 10 ** generated_loss_imbalance
# likelihood_imbalance = 10 ** likelihood_imbalance
print('previous_visit---{}---predicted_visit----{}-'.format(
previous_visit, predicted_visit))
print(
'hidden_size---{}---learning_rate---{}---l2_regularization---{}---n_disc---{}'
'generated_mse_imbalance---{}---generated_loss_imbalance---{}---'
'likelihood_imbalance---{}'.format(hidden_size, learning_rate,
l2_regularization, n_disc,
generated_mse_imbalance,
generated_loss_imbalance,
likelihood_imbalance))
encode_share = Encoder(hidden_size=hidden_size)
decoder_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
hawkes_process = HawkesProcess()
discriminator = Discriminator(previous_visit=previous_visit,
predicted_visit=predicted_visit,
hidden_size=hidden_size)
logged = set()
max_loss = 0.001
max_pace = 0.0001
count = 0
loss = 0
optimizer_generation = tf.keras.optimizers.RMSprop(
learning_rate=learning_rate)
optimizer_discriminator = tf.keras.optimizers.RMSprop(
learning_rate=learning_rate)
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
while train_set.epoch_completed < epochs:
input_train = train_set.next_batch(batch_size=batch_size)
input_x_train = tf.cast(input_train[:, :, 1:], tf.float32)
input_t_train = tf.cast(input_train[:, :, 0], tf.float32)
batch = input_train.shape[0]
with tf.GradientTape() as gen_tape, tf.GradientTape(
persistent=True) as disc_tape:
generated_trajectory = tf.zeros(shape=[batch, 0, feature_dims])
probability_likelihood = tf.zeros(shape=[batch, 0, 1])
for predicted_visit_ in range(predicted_visit):
sequence_last_time = input_x_train[:, previous_visit +
predicted_visit_ - 1, :]
for previous_visit_ in range(previous_visit +
predicted_visit_):
sequence_time = input_x_train[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_h = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
encode_c, encode_h = encode_share(
[sequence_time, encode_c, encode_h])
context_state = encode_h
if predicted_visit_ == 0:
decode_c = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
decode_h = tf.Variable(
tf.zeros(shape=[batch, hidden_size]))
current_time_index_shape = tf.ones(
shape=[previous_visit + predicted_visit_])
intensity_value, likelihood = hawkes_process(
[input_t_train, current_time_index_shape])
probability_likelihood = tf.concat(
(probability_likelihood,
tf.reshape(likelihood, [batch, -1, 1])),
axis=1)
generated_next_visit, decode_c, decode_h = decoder_share([
sequence_last_time, context_state, decode_c,
decode_h * intensity_value
])
generated_trajectory = tf.concat(
(generated_trajectory,
tf.reshape(generated_next_visit,
[batch, -1, feature_dims])),
axis=1)
d_real_pre_, d_fake_pre_ = discriminator(input_x_train,
generated_trajectory)
d_real_pre_loss = cross_entropy(tf.ones_like(d_real_pre_),
d_real_pre_)
d_fake_pre_loss = cross_entropy(tf.zeros_like(d_fake_pre_),
d_fake_pre_)
d_loss = d_real_pre_loss + d_fake_pre_loss
gen_loss = cross_entropy(tf.ones_like(d_fake_pre_), d_fake_pre_)
generated_mse_loss = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :], generated_trajectory))
likelihood_loss = tf.reduce_mean(probability_likelihood)
loss += generated_mse_loss * generated_mse_imbalance + likelihood_loss * likelihood_imbalance + \
gen_loss * generated_loss_imbalance
for weight in discriminator.trainable_variables:
d_loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables = [var for var in encode_share.trainable_variables]
for weight in encode_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in decoder_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for weight in hawkes_process.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
variables.append(weight)
for disc in range(n_disc):
gradient_disc = disc_tape.gradient(
d_loss, discriminator.trainable_variables)
optimizer_discriminator.apply_gradients(
zip(gradient_disc, discriminator.trainable_variables))
gradient_gen = gen_tape.gradient(loss, variables)
optimizer_generation.apply_gradients(zip(gradient_gen, variables))
if train_set.epoch_completed % 1 == 0 and train_set.epoch_completed not in logged:
logged.add(train_set.epoch_completed)
loss_pre = generated_mse_loss
mse_generated = tf.reduce_mean(
tf.keras.losses.mse(
input_x_train[:, previous_visit:previous_visit +
predicted_visit, :], generated_trajectory))
loss_diff = loss_pre - mse_generated
if mse_generated > max_loss:
count = 0
else:
if loss_diff > max_pace:
count = 0
else:
count += 1
if count > 9:
break
input_x_test = tf.cast(test_set[:, :, 1:], tf.float32)
input_t_test = tf.cast(test_set[:, :, 0], tf.float32)
batch_test = test_set.shape[0]
generated_trajectory_test = tf.zeros(
shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
for previous_visit_ in range(previous_visit):
sequence_time_test = input_x_test[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_h_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
encode_c_test, encode_h_test = encode_share(
[sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
encode_c_test, encode_h_test = encode_share([
generated_trajectory_test[:, i, :], encode_c_test,
encode_h_test
])
context_state_test = encode_h_test
if predicted_visit_ == 0:
decode_c_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
decode_h_test = tf.Variable(
tf.zeros(shape=[batch_test, hidden_size]))
sequence_last_time_test = input_x_test[:, previous_visit +
predicted_visit_ -
1, :]
current_time_index_shape = tf.ones(
[previous_visit + predicted_visit_])
intensity_value, likelihood = hawkes_process(
[input_t_test, current_time_index_shape])
generated_next_visit, decode_c_test, decode_h_test = decoder_share(
[
sequence_last_time_test, context_state_test,
decode_c_test, decode_h_test * intensity_value
])
generated_trajectory_test = tf.concat(
(generated_trajectory_test,
tf.reshape(generated_next_visit,
[batch_test, -1, feature_dims])),
axis=1)
sequence_last_time_test = generated_next_visit
mse_generated_test = tf.reduce_mean(
tf.keras.losses.mse(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
mae_generated_test = tf.reduce_mean(
tf.keras.losses.mae(
input_x_test[:, previous_visit:previous_visit +
predicted_visit, :],
generated_trajectory_test))
r_value_all = []
for patient in range(batch_test):
r_value = 0.0
for feature in range(feature_dims):
x_ = input_x_test[patient, previous_visit:,
feature].numpy().reshape(
predicted_visit, 1)
y_ = generated_trajectory_test[patient, :,
feature].numpy().reshape(
predicted_visit, 1)
r_value += DynamicTimeWarping(x_, y_)
r_value_all.append(r_value / 29.0)
print(
'------epoch{}------mse_loss{}----mae_loss{}------predicted_r_value---{}--'
'-count {}'.format(train_set.epoch_completed,
mse_generated_test, mae_generated_test,
np.mean(r_value_all), count))
# r_value_all = []
# p_value_all = []
# r_value_spearman = []
# r_value_kendalltau = []
# for visit in range(predicted_visit):
# for feature in range(feature_dims):
# x_ = input_x_test[:, previous_visit+visit, feature]
# y_ = generated_trajectory_test[:, visit, feature]
# r_value_ = stats.pearsonr(x_, y_)
# r_value_spearman_ = stats.spearmanr(x_, y_)
# r_value_kendalltau_ = stats.kendalltau(x_, y_)
# if not np.isnan(r_value_[0]):
# r_value_all.append(np.abs(r_value_[0]))
# p_value_all.append(np.abs(r_value_[1]))
# if not np.isnan(r_value_spearman_[0]):
# r_value_spearman.append(np.abs(r_value_spearman_[0]))
# if not np.isnan(r_value_kendalltau_[0]):
# r_value_kendalltau.append(np.abs(r_value_kendalltau_[0]))
# print('------epoch{}------mse_loss{}----mae_loss{}------predicted_r_value---{}--'
# 'r_value_spearman---{}---r_value_kendalltau---{}--count {}'.format(train_set.epoch_completed,
# mse_generated_test,
# mae_generated_test,
# np.mean(r_value_all),
# np.mean(r_value_spearman),
# np.mean(r_value_kendalltau),
# count))
tf.compat.v1.reset_default_graph()
return mse_generated_test, mae_generated_test, np.mean(r_value_all)
def train(hidden_size, l2_regularization, learning_rate, generated_imbalance, likelihood_imbalance):
train_set = np.load("../../Trajectory_generate/dataset_file/HF_train_.npy").reshape(-1, 6, 30)
test_set = np.load("../../Trajectory_generate/dataset_file/HF_test_.npy").reshape(-1, 6, 30)
# test_set = np.load("../../Trajectory_generate/dataset_file/HF_validate_.npy").reshape(-1, 6, 30)
# train_set = np.load("../../Trajectory_generate/dataset_file/mimic_train_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_test_x_.npy").reshape(-1, 6, 37)
# test_set = np.load("../../Trajectory_generate/dataset_file/mimic_validate_.npy").reshape(-1, 6, 37)
# sepsis mimic dataset
# train_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_train.npy').reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_test.npy').reshape(-1, 13, 40)
# test_set = np.load('../../Trajectory_generate/dataset_file/sepsis_mimic_validate.npy').reshape(-1, 13, 40)
previous_visit = 3
predicted_visit = 3
feature_dims = train_set.shape[2] - 1
train_set = DataSet(train_set)
train_set.epoch_completed = 0
batch_size = 64
epochs = 50
# hidden_size = 2 ** (int(hidden_size))
# learning_rate = 10 ** learning_rate
# l2_regularization = 10 ** l2_regularization
# generated_imbalance = 10 ** generated_imbalance
# likelihood_imbalance = 10 ** likelihood_imbalance
print('previous_visit---{}---predicted_visit----{}-'.format(previous_visit, predicted_visit))
print('hidden_size----{}---'
'l2_regularization---{}---'
'learning_rate---{}---'
'generated_imbalance---{}---'
'likelihood_imbalance---{}'.
format(hidden_size, l2_regularization, learning_rate,
generated_imbalance, likelihood_imbalance))
decoder_share = Decoder(hidden_size=hidden_size, feature_dims=feature_dims)
encode_share = Encoder(hidden_size=hidden_size)
hawkes_process = HawkesProcess()
logged = set()
max_loss = 0.01
max_pace = 0.001
loss = 0
count = 0
optimizer = tf.keras.optimizers.RMSprop(learning_rate=learning_rate)
while train_set.epoch_completed < epochs:
input_train = train_set.next_batch(batch_size=batch_size)
batch = input_train.shape[0]
input_x_train = tf.cast(input_train[:, :, 1:], tf.float32)
input_t_train = tf.cast(input_train[:, :, 0], tf.float32)
with tf.GradientTape() as tape:
predicted_trajectory = tf.zeros(shape=[batch, 0, feature_dims])
likelihood_all = tf.zeros(shape=[batch, 0, 1])
for predicted_visit_ in range(predicted_visit):
sequence_time_last_time = input_x_train[:, previous_visit+predicted_visit_-1, :]
for previous_visit_ in range(previous_visit+predicted_visit_):
sequence_time = input_x_train[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
encode_h = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
encode_c, encode_h = encode_share([sequence_time, encode_c, encode_h])
context_state = encode_h
if predicted_visit_ == 0:
decode_c = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
decode_h = tf.Variable(tf.zeros(shape=[batch, hidden_size]))
current_time_index_shape = tf.ones(shape=[predicted_visit_+previous_visit])
condition_intensity, likelihood = hawkes_process([input_t_train, current_time_index_shape])
likelihood_all = tf.concat((likelihood_all, tf.reshape(likelihood, [batch, -1, 1])), axis=1)
generated_next_visit, decode_c, decode_h = decoder_share([sequence_time_last_time, context_state, decode_c, decode_h*condition_intensity])
predicted_trajectory = tf.concat((predicted_trajectory, tf.reshape(generated_next_visit, [batch, -1, feature_dims])), axis=1)
mse_generated_loss = tf.reduce_mean(tf.keras.losses.mse(input_x_train[:, previous_visit:previous_visit+predicted_visit, :], predicted_trajectory))
mae_generated_loss = tf.reduce_mean(tf.keras.losses.mae(input_x_train[:, previous_visit:previous_visit+predicted_visit, :], predicted_trajectory))
likelihood_loss = tf.reduce_mean(likelihood_all)
loss += mse_generated_loss * generated_imbalance + likelihood_loss * likelihood_imbalance
variables = [var for var in encode_share.trainable_variables]
for weight in encode_share.trainable_variables:
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in decoder_share.trainable_variables:
variables.append(weight)
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
for weight in hawkes_process.trainable_variables:
variables.append(weight)
loss += tf.keras.regularizers.l2(l2_regularization)(weight)
gradient = tape.gradient(loss, variables)
optimizer.apply_gradients(zip(gradient, variables))
if train_set.epoch_completed % 1 == 0 and train_set.epoch_completed not in logged:
logged.add(train_set.epoch_completed)
loss_pre = mse_generated_loss
mse_generated_loss = tf.reduce_mean(
tf.keras.losses.mse(input_x_train[:, previous_visit:previous_visit + predicted_visit, :],
predicted_trajectory))
loss_diff = loss_pre - mse_generated_loss
if max_loss < mse_generated_loss:
count = 0
else:
if max_pace < loss_diff:
count = 0
else:
count += 1
if count > 9:
break
input_x_test = tf.cast(test_set[:, :, 1:], tf.float32)
input_t_test = tf.cast(test_set[:, :, 0], tf.float32)
batch_test = input_x_test.shape[0]
predicted_trajectory_test = tf.zeros(shape=[batch_test, 0, feature_dims])
for predicted_visit_ in range(predicted_visit):
for previous_visit_ in range(previous_visit):
sequence_time_test = input_x_test[:, previous_visit_, :]
if previous_visit_ == 0:
encode_c_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
encode_h_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
encode_c_test, encode_h_test = encode_share([sequence_time_test, encode_c_test, encode_h_test])
if predicted_visit_ != 0:
for i in range(predicted_visit_):
encode_c, encode_h_test = encode_share([predicted_trajectory_test[:, i, :], encode_c_test, encode_h_test])
context_state_test = encode_h_test
if predicted_visit_ == 0:
decode_c_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
decode_h_test = tf.Variable(tf.zeros(shape=[batch_test, hidden_size]))
sequence_time_last_time_test = input_x_test[:, predicted_visit_+previous_visit-1, :]
current_time_index_shape_test = tf.ones(shape=[previous_visit+predicted_visit_])
condition_intensity_test, likelihood_test = hawkes_process([input_t_test, current_time_index_shape_test])
sequence_next_visit_test, decode_c_test, decode_h_test = decoder_share([sequence_time_last_time_test, context_state_test, decode_c_test, decode_h_test*condition_intensity_test])
predicted_trajectory_test = tf.concat((predicted_trajectory_test, tf.reshape(sequence_next_visit_test, [batch_test, -1, feature_dims])), axis=1)
sequence_time_last_time_test = sequence_next_visit_test
mse_generated_loss_test = tf.reduce_mean(tf.keras.losses.mse(input_x_test[:, previous_visit:previous_visit+predicted_visit, :], predicted_trajectory_test))
mae_generated_loss_test = tf.reduce_mean(tf.keras.losses.mae(input_x_test[:, previous_visit:previous_visit+predicted_visit, :], predicted_trajectory_test))
r_value_all = []
for patient in range(batch_test):
r_value = 0.0
for feature in range(feature_dims):
x_ = input_x_test[patient, previous_visit:, feature].numpy().reshape(predicted_visit, 1)
y_ = predicted_trajectory_test[patient, :, feature].numpy().reshape(predicted_visit, 1)
r_value += DynamicTimeWarping(x_, y_)
r_value_all.append(r_value / 29.0)
print("epoch {}---train_mse_generate {}- - "
"mae_generated_loss--{}--test_mse {}--test_mae "
"{}--r_value {}-count {}".format(train_set.epoch_completed,
mse_generated_loss,
mae_generated_loss,
mse_generated_loss_test,
mae_generated_loss_test,
np.mean(r_value_all),
count))
# r_value_all = []
# p_value_all = []
# r_value_spearman_all = []
# r_value_kendall_all = []
# for visit in range(predicted_visit):
# for feature in range(feature_dims):
# x_ = input_x_test[:, previous_visit+visit, feature]
# y_ = predicted_trajectory_test[:, visit, feature]
# r_value_ = stats.pearsonr(x_, y_)
# r_value_spearman = stats.spearmanr(x_, y_)
# r_value_kendall = stats.kendalltau(x_, y_)
# if not np.isnan(r_value_[0]):
# r_value_all.append(np.abs(r_value_[0]))
# p_value_all.append(np.abs(r_value_[1]))
# if not np.isnan(r_value_spearman[0]):
# r_value_spearman_all.append(np.abs(r_value_spearman[0]))
# if not np.isnan(r_value_kendall[0]):
# r_value_kendall_all.append(np.abs(r_value_kendall[0]))
# print("epoch {}---train_mse_generate {}- - "
# "mae_generated_loss--{}--test_mse {}--test_mae "
# "{}----r_value {}--r_spearman---{}-"
# "r_kendall---{} -count {}".format(train_set.epoch_completed,
# mse_generated_loss,
# mae_generated_loss,
# mse_generated_loss_test,
# mae_generated_loss_test,
# np.mean(r_value_all),
# np.mean(r_value_spearman_all),
# np.mean(r_value_kendall_all),
# count))
tf.compat.v1.reset_default_graph()
return mse_generated_loss_test, mae_generated_loss_test, np.mean(r_value_all)
