Homec4science
Diffusion Machine Learning ECMO (master) Browse

ML_ECMO/code/synthetic_data_processing/test_Net_missing_data.py
b71ab0e3472emaster

Last Change
Raw File

test_Net_missing_data.py
View Options

import numpy as np
import tensorflow as tf
from tensorflow import keras
import RNN_synthetic as frw
from matplotlib import pyplot as plt
from tensorflow.keras.layers import Dense, Flatten, Conv1D, MaxPooling1D, GlobalAveragePooling1D, Dropout, TimeDistributed, LSTM
nb_epochs, batch_size, nb_samples = 65, 25, 1000
dim_input, dim_recurrent, dim_output = 30, 64, 30
learning_rate = 1e-3
time_steps = 71
offset = 5
path = '../../synthetic_data/'
t_init, t_fin = 0, 5
Nt = 21
################################################################################################
################################################################################################
# READING FILES
INPUT_TRAIN_FILE_NAMES = [path + 'files_missingdata_' + str(dim_input) + '/train/input/file_' + str(i) + '.txt' for i in range(nb_samples)]
TARGET_TRAIN_FILE_NAMES = [path + 'files_missingdata_' + str(dim_input) + '/train/target/file_' + str(i) + '.txt' for i in range(nb_samples)]
INPUT_TEST_FILE_NAMES = [path + 'files_missingdata_' + str(dim_input) + '/test/input/file_' + str(i) + '.txt' for i in range(nb_samples)]
TARGET_TEST_FILE_NAMES = [path + 'files_missingdata_' + str(dim_input) + '/test/target/file_' + str(i) + '.txt' for i in range(nb_samples)]
TRUE_TARGET_TEST_FILE_NAMES = [path + 'files_' + str(dim_input) + '/test/target/file_' + str(i) + '.txt' for i in range(nb_samples)]
input_train_arrays, target_train_arrays = [], []
input_test_arrays, target_test_arrays = [], []
true_target_test_arrays = []
train_loss_tab = []
for i in range(nb_samples):
input_train_arrays.append(np.loadtxt(INPUT_TRAIN_FILE_NAMES[i], dtype=np.float32))
target_train_arrays.append(np.loadtxt(TARGET_TRAIN_FILE_NAMES[i], dtype=np.float32))
input_test_arrays.append(np.loadtxt(INPUT_TEST_FILE_NAMES[i], dtype=np.float32))
target_test_arrays.append(np.loadtxt(TARGET_TEST_FILE_NAMES[i], dtype=np.float32))
true_target_test_arrays.append(np.loadtxt(TRUE_TARGET_TEST_FILE_NAMES[i], dtype=np.float32))
# Stack the different samples
train_input = tf.stack([input_train_arrays[i] for i in range(nb_samples)])
train_target = tf.stack([target_train_arrays[i] for i in range(nb_samples)])
test_input = tf.stack([input_test_arrays[i] for i in range(nb_samples)])
test_target = tf.stack([target_test_arrays[i] for i in range(nb_samples)])
true_test_target = tf.stack([true_target_test_arrays[i] for i in range(nb_samples)])
# Transpose the second and the third dimension in order to have (samples, time, parameters)
train_input = tf.transpose(train_input, perm=[0, 2, 1])
train_target = tf.transpose(train_target, perm=[0, 2, 1])
test_input = tf.transpose(test_input, perm=[0, 2, 1])
test_target = tf.transpose(test_target, perm=[0, 2, 1])
true_test_target = tf.transpose(true_test_target, perm=[0, 2, 1])
# Get the positions of the NaN values
train_NAN_input = tf.is_nan(train_input)
train_NAN_target = tf.is_nan(train_target)
test_NAN_input = tf.is_nan(test_input)
test_NAN_target = tf.is_nan(test_target)
################################################################################################
# NORMALIZATION
# Get the min and the max along the first dimension (samples)
max_input = tf.reduce_max(train_input, reduction_indices=[0])
min_input = tf.reduce_min(train_input, reduction_indices=[0])
max_target = tf.reduce_max(train_target, reduction_indices=[0])
min_target = tf.reduce_min(train_target, reduction_indices=[0])
max_input = tf.where(tf.is_inf(max_input), tf.constant(np.nan, shape=max_input.shape, dtype=tf.float32),
max_input)
min_input = tf.where(tf.is_inf(min_input), tf.constant(np.nan, shape=min_input.shape, dtype=tf.float32),
min_input)
max_target = tf.where(tf.is_inf(max_target), tf.constant(np.nan, shape=max_target.shape, dtype=tf.float32),
max_target)
min_target = tf.where(tf.is_inf(min_target), tf.constant(np.nan, shape=min_target.shape, dtype=tf.float32),
min_target)
# And along the time dimension
max_input = tf.reduce_max(max_input, reduction_indices=[0])
min_input = tf.reduce_min(min_input, reduction_indices=[0])
max_target = tf.reduce_max(max_target, reduction_indices=[0])
min_target = tf.reduce_min(min_target, reduction_indices=[0])
# Apply the normalization
train_input = tf.divide(train_input - min_input, max_input - min_input)
test_input = tf.divide(test_input - min_input, max_input - min_input)
train_target = tf.divide(train_target - min_target, max_target - min_target)
test_target = tf.divide(test_target - min_target, max_target - min_target)
# Replace NaN values by -1
train_input = tf.where(tf.is_nan(train_input), tf.constant(-1., shape=train_input.shape, dtype=tf.float32), train_input)
train_target = tf.where(tf.is_nan(train_target), tf.constant(-1., shape=train_target.shape, dtype=tf.float32), train_target)
test_input = tf.where(tf.is_nan(test_input), tf.constant(-1., shape=test_input.shape, dtype=tf.float32), test_input)
test_target = tf.where(tf.is_nan(test_target), tf.constant(-1., shape=test_target.shape, dtype=tf.float32), test_target)
################################################################################################
################################################################################################
# CHOICE OF THE MODEL
model_type = 'RNN'
if model_type == 'RNN':
model = RNN(dim_input, dim_recurrent, dim_output)
train_model_mv(model, train_input, train_target, train_NAN_target, states, learning_rate, num_epochs=nb_epochs,
mini_batch_size=batch_size, loss_tab=train_loss_tab)
elif model_type == 'GRU':
model = GRU(dim_input, dim_recurrent, dim_output)
train_model_mv(model, train_input, train_target, train_NAN_target, states, learning_rate, num_epochs=nb_epochs,
mini_batch_size=batch_size, loss_tab=train_loss_tab)
elif model_type == 'GatedRNNComplex':
model = GatedRNNComplexBN(dim_input, dim_recurrent, dim_output)
train_model_mv(model, train_input, train_target, train_NAN_target, states, learning_rate, num_epochs=nb_epochs,
mini_batch_size=batch_size, loss_tab=train_loss_tab)
################################################################################################
################################################################################################
# TEST
if model_type == 'GRU_multisteps' or 'GRU_multisteps2':
predictions = model.predict(test_input, test_target, time_steps)
else:
predictions = model.predict(test_input, time_steps, dim_recurrent)
################################################################################################
################################################################################################
# PLOT
# Apply inverse normalization
predictions = tf.multiply(predictions, max_target - min_target) + min_target
test_target = tf.multiply(test_target, max_target - min_target) + min_target
test_input = tf.multiply(test_input, max_input - min_input) + min_input
# Get time interval
t = [((t_fin-t_init)/(time_steps-1))*i for i in range(time_steps)]
# Define number of plots
nb_test = 5
# Plot the training loss and samples of inputs/outputs
plot(test_target, test_input, train_input, predictions, train_loss_tab, t, nb_epochs, dim_recurrent,
batch_size, nb_test, Nt)
c4science · Help