Homec4science
Diffusion Machine Learning ECMO (master) Browse

ML_ECMO/test_real.py
c4c453efe50dmaster

Last Change
Raw File

test_real.py
View Options

import tensorflow as tf
import numpy as np
import param_str as ps
import RNN as frw
from matplotlib import pyplot as plt
from operator import itemgetter
tf.compat.v1.enable_eager_execution()
path = "data_CHUV"
nb_epochs, batch_size, nb_samples = 20, 100, 10
learning_rate = 0.001
input_train_arrays, target_train_arrays = [], []
input_test_arrays, target_test_arrays = [], []
train_loss_tab = []
data_array = []
max_params = np.load(path + '/data/max_param_' + str(nb_samples) + '.npy', allow_pickle=True)
idx_inputs = [np.where(max_params == param_input)[0][0] + 1 for param_input in max_params if param_input in ps.inputs]
idx_targets = [np.where(max_params == param_target)[0][0] + 1 for param_target in max_params if param_target not in ps.inputs]
dim_input, dim_recurrent, dim_output = len(idx_inputs), 32, len(idx_targets)
#print(idx_inputs)
#print(idx_targets)
times = []
inputs, targets = [], []
inputs_dataset, targets_dataset = [], []
max_inputs, min_inputs = [], []
max_targets, min_targets = [], []
NAN_inputs, NAN_targets = [], []
for i in range(nb_samples):
data_array = np.genfromtxt(path + '/data/Signals' + str(i) + '.csv', delimiter=';')
#print(data_array)
times.append(data_array[:, 0])
inputs.append(tf.reshape(tf.transpose(tf.stack(
[tf.convert_to_tensor(data_array[:, idx]) for idx in idx_inputs], axis=0), perm=[1, 0]),
[1, len(times[i]), dim_input]))
targets.append(tf.reshape(tf.transpose(tf.stack(
[tf.convert_to_tensor(data_array[:, idx]) for idx in idx_targets], axis=0), perm=[1, 0]),
[1, len(times[i]), dim_output]))
#inputs[i] = tf.select(tf.is_nan(inputs[i]), tf.ones_like(inputs[i]) * (-1), inputs[i]);
#targets[i] = tf.select(tf.is_nan(targets[i]), tf.ones_like(targets[i]) * (-1), targets[i]);
#inputs.append([np.array(data_array[:, idx]) for idx in idx_inputs])
#targets.append([np.array(data_array[:, idx]) for idx in idx_targets])
NAN_inputs.append(tf.is_nan(inputs[i]))
NAN_targets.append(tf.is_nan(targets[i]))
print("input ", i, " : ", inputs[i])
max_inputs.append(tf.reduce_max(inputs[i], reduction_indices=[1]))
min_inputs.append(tf.reduce_min(inputs[i], reduction_indices=[1]))
max_targets.append(tf.reduce_max(targets[i], reduction_indices=[1]))
min_targets.append(tf.reduce_min(targets[i], reduction_indices=[1]))
max_inputs[i] = tf.where(tf.is_inf(max_inputs[i]), tf.constant(np.nan, shape=max_inputs[i].shape, dtype=tf.float64),
max_inputs[i])
min_inputs[i] = tf.where(tf.is_inf(min_inputs[i]), tf.constant(np.nan, shape=min_inputs[i].shape, dtype=tf.float64),
min_inputs[i])
max_targets[i] = tf.where(tf.is_inf(max_targets[i]), tf.constant(np.nan, shape=max_targets[i].shape, dtype=tf.float64),
max_targets[i])
min_targets[i] = tf.where(tf.is_inf(min_targets[i]), tf.constant(np.nan, shape=min_targets[i].shape, dtype=tf.float64),
min_targets[i])
#print("max_input ", i, " : ", max_inputs[i])
max_inputs = tf.stack(max_inputs)
min_inputs = tf.stack(min_inputs)
max_targets = tf.stack(max_targets)
min_targets = tf.stack(min_targets)
max_inputs = tf.reduce_max(max_inputs, reduction_indices=[0])
min_inputs = tf.reduce_min(min_inputs, reduction_indices=[0])
max_targets = tf.reduce_max(max_targets, reduction_indices=[0])
min_targets = tf.reduce_min(min_targets, reduction_indices=[0])
for i in range(nb_samples):
inputs[i] = tf.divide(inputs[i] - min_inputs, max_inputs - min_inputs)
targets[i] = tf.divide(targets[i] - min_targets, max_targets - min_targets)
inputs[i] = tf.where(tf.is_nan(inputs[i]), tf.constant(-1., shape=inputs[i].shape, dtype=tf.float64), inputs[i])
targets[i] = tf.where(tf.is_nan(targets[i]), tf.constant(-1., shape=targets[i].shape, dtype=tf.float64), targets[i])
#inputs.append(list(itemgetter(*idx_inputs)(data_array)))
#targets.append(list(itemgetter(*idx_targets)(data_array)))
#inputs.append(data_array[i][:, idx_inputs])
#targets.append(data_array[i][:, idx_targets])
count = 0
j = 0
for i in range(nb_samples):
if (len(times[i-j]) < 800):
del inputs[i-j]
del targets[i-j]
del times[i-j]
del NAN_inputs[i-j]
del NAN_targets[i-j]
#del max_inputs[i-j]
#del max_targets[i-j]
#del min_inputs[i-j]
#del min_targets[i-j]
count = count + 1
j = j + 1
print("After : ", inputs[i-j])
print("After : ", targets[i-j])
################################################################################################
# TRAINING WITH ZEROS INITIAL STATE
model = frw.RNNReal(dim_input, dim_recurrent, dim_output)
frw.train_model_real(model, inputs, targets, NAN_targets, dim_recurrent, learning_rate, num_epochs=nb_epochs,
loss_tab=train_loss_tab)
################################################################################################
# TEST
predictions = []
for i in range(nb_samples - count):
predictions_tmp = [targets[i][:, 0]]
state = tf.zeros(shape=[1, dim_recurrent], dtype=tf.float64)
for t in range(len(times[i])-1):
prediction, state = model(inputs[i][:, t+1], state)
predictions_tmp.append(prediction)
predictions_tmp = tf.stack(predictions_tmp, axis=1)
predictions.append(predictions_tmp)
predictions[i] = tf.multiply(predictions[i], max_targets - min_targets) + min_targets
targets[i] = tf.multiply(targets[i], max_targets - min_targets) + min_targets
inputs[i] = tf.multiply(inputs[i], max_inputs - min_inputs) + min_inputs
plt.plot(times[3], targets[3][0, :, 2], color='green', label='target')
plt.plot(times[3], predictions[3][0, :, 2], color='red', label='prediction')
plt.plot(times[3], inputs[3][0, :, 2], color='blue', label='input')
plt.legend()
plt.show()
axis = [i for i in range(len(train_loss_tab))]
plt.semilogy(axis, train_loss_tab, color='black')
plt.show()
c4science · Help