def load_RNN_data_generated(folder_data = "../data/artificial/"):
Ndivisions = 10;
X_list = pkl.load_pickle(folder_data +"X_values.pkl",Ndivisions)
Y_list = pkl.load_pickle(folder_data +"Y_values.pkl",Ndivisions)
num_steps, X_dim = X_list[0].shape
num_chains = len(X_list)
## Divide in train val and test
proportion_tr = 0.8
proportion_val = 0.1
proportion_tst = 1 -( proportion_val + proportion_tr)
num_tr = 1000
num_val = 500
num_tst = 500
train_X = [X_list[i] for i in range(num_tr)]
train_Y = [Y_list[i] for i in range(num_tr)]
val_X = [X_list[i] for i in range(num_tr, num_tr + num_val)]
val_Y = [Y_list[i] for i in range(num_tr, num_tr + num_val)]
tst_X = [X_list[i] for i in range(num_tr + num_val, num_tr + num_val + num_tst)]
tst_Y = [Y_list[i] for i in range(num_tr + num_val, num_tr + num_val + num_tst)]
train_X = np.concatenate(train_X,1).T
return train_X
def load_objects_repetitions(folder_name, params_list=[], repetitions=1):
# Loads the objects (for intermediate results) of the param list.
# The difference is that we do get all the objects of one param_list
# instead of only getting one of them.
# It is meant to be for just one object configuration
Object_list = [] # List with the paramters of the simulation
for paramS in params_list:
file_name = str('')
if type(paramS) is list:
for param in paramS:
file_name += str(param) + "_"
else: # If there was only one parameter validaded
file_name += str(paramS) + "_"
path_obj = "./" + folder_name + "/" + file_name
### NOW WE INTRODUCE THE REPETITION PART !!!!
Object_list = []
for i in range(repetitions):
path_obj_rep = path_obj + str(i) + "_"
obj = pkl.load_pickle(path_obj_rep, 1)
if (obj == []): # The object does not exist
print path_obj + " does not exist"
else:
Object_list.append(obj[1])
# we saved the object as a list.
return Object_list
def PPE_readTr(PPE_p, main_folder,database_number, repetitions = 20):
""" PREREADING STRATEGY """
# Folder where we read the RAW files
folder = "../"+main_folder +"/ResultsNeoDSN"+str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../"+main_folder +"/PreRead/"
# Folder where we store the graph
base_folder_out = "../"+main_folder +"/Gold/"
# We will build a file for every pair [beta, alpha]
# Every file will contain the "N_realizations" for different values of [Nepoch, Nh]
""" $$$$$$$$$$$$ Evolution Error $$$$$$$$$$$$$$$$ """
mu.create_dirs(base_folder_in + str(database_number) + "/")
# For evety combination of f*****g useless parameters:
for beta_i in range(len(PPE_p.beta_indx_list)):
for alpha_i in range(len(PPE_p.alpha_indx_list)):
## First check if the file with the read data already exists
results = pkl.load_pickle(base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_"+ str(PPE_p.alpha_indx_list[alpha_i])+"_EVO",1) # If the result file existis coz it was previously read
read_flag = 1
if ((results != [])&(read_flag == 0)):
All_Object_list = results
else:
All_Object_list = [] # List that will contain of the object lists for a given [beta_alpha]
# It will contain All_Object_list[Nepoch][Nh] = N_realizations objects
# Get the list of parameters and load them into All_Object_list
for n_init_i in range (len(PPE_p.Ninit_indx_list)):
All_Object_list.append([])
for n_roh_i in range (len(PPE_p.Roh_indx_list)):
All_Object_list[n_init_i].append([])
for n_epoch_i in range(len(PPE_p.N_epochs_indx_list)):
All_Object_list[n_init_i][n_roh_i].append([])
for nH_i in range(len(PPE_p.nH_indx_list)):
Parameters = [PPE_p.nH_indx_list[nH_i],PPE_p.N_epochs_indx_list[n_epoch_i],
1,
PPE_p.Ninit_indx_list[n_init_i],
PPE_p.Roh_indx_list[n_roh_i],
PPE_p.Inyection_list[0],PPE_p.Enphasis_list[0],
PPE_p.alpha_indx_list[alpha_i],PPE_p.beta_indx_list[beta_i],
0,0]
Object_list = rd.load_objects_repetitions(folder, [Parameters], repetitions)
All_Object_list[n_init_i][n_roh_i][n_epoch_i].append(Object_list)
rd.save_results(base_folder_in + str(database_number) + "/" + "data_"+
str(PPE_p.beta_indx_list[beta_i]) + "_"+ str(PPE_p.alpha_indx_list[alpha_i])+"_EVO", All_Object_list)
def load_results(folder_name, params_list=[]):
# params is a bidimensional list where each row [i,:] is a list
# of all the parameters that were crossvalidated !!
Object_list = [] # List with the paramters of the simulation
Exec_list = [] # Object with the results of the simulation
for paramS in params_list:
file_name = str('')
if type(paramS) is list:
for param in paramS:
file_name += str(param) + "_"
else: # If there was only one parameter validaded
file_name += str(paramS) + "_"
path_obj = "./" + folder_name + "/" + file_name
obj = pkl.load_pickle(path_obj, 1)
if (obj == []): # The object does not exist
print path_obj + " does not exist"
else:
Exec_list.append(obj[0])
Object_list.append(
obj[1]) # The 0 is because pickle only saves lists
# we saved the object as a list.
return Exec_list, Object_list
def PPE_readResults(PPE_p, main_folder, database_number):
# Folder where we read and store the Preread files
base_folder_in = "../" + main_folder + "/PreRead/"
# Folder where we store the graph
base_folder_out = "../" + main_folder + "/PreReadResults/"
# For evety combination of f*****g useless parameters:
Total_nepochs = len(PPE_p.N_epochs_indx_list)
Total_nH = len(PPE_p.nH_indx_list)
ave_val = np.ones((Total_nepochs, Total_nH))
ave_tr = np.ones((Total_nepochs, Total_nH))
std_val = np.ones((Total_nepochs, Total_nH))
std_tr = np.ones((Total_nepochs, Total_nH))
mu.create_dirs(base_folder_out + str(database_number) + "/")
for beta_i in range(len(PPE_p.beta_indx_list)):
for alpha_i in range(len(PPE_p.alpha_indx_list)):
## First check if the file with the read data already exists
albe_objects = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_" +
str(PPE_p.alpha_indx_list[alpha_i]) + "_EVO",
1) # If the result file existis coz it was previously read
for Nepoch_i in range(len(albe_objects)):
for nH_i in range(len(albe_objects[Nepoch_i])):
# print len(albe_objects), len(albe_objects[Nepoch_i])
if (
PPE_p.CV_List[0] != 0
): # If we are not loading evolution, but old style final results
a, b, c, d = mu.get_final_results_CV(
albe_objects[Nepoch_i][nH_i])
else:
a, b, c, d = mu.get_final_results_Evo(
albe_objects[Nepoch_i][nH_i], ngammas=5)
ave_tr[Nepoch_i][nH_i] = a
std_tr[Nepoch_i][nH_i] = b
ave_val[Nepoch_i][nH_i] = c
std_val[Nepoch_i][nH_i] = d
rd.save_results(
base_folder_out + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_" +
str(PPE_p.alpha_indx_list[alpha_i]) + "_EVO",
[ave_tr, std_tr, ave_val, std_val])
""" NOW we have to:
def PPE_readResultsTr(PPE_p, main_folder,database_number):
# Folder where we read the RAW files
folder = "../"+main_folder +"/ResultsNeoDSN"+str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../"+main_folder +"/PreRead/"
# Folder where we store the graph
base_folder_out = "../"+main_folder +"/PreReadResults/"
# For evety combination of f*****g useless parameters:
Total_nepochs = len(PPE_p.N_epochs_indx_list)
Total_nH = len(PPE_p.nH_indx_list)
Total_Roh = len(PPE_p.Roh_indx_list)
Total_Init = len(PPE_p.Ninit_indx_list)
ave_val = np.ones((Total_Init,Total_Roh, Total_nepochs,Total_nH))
ave_tr = np.ones((Total_Init,Total_Roh,Total_nepochs,Total_nH))
std_val = np.ones((Total_Init,Total_Roh, Total_nepochs,Total_nH))
std_tr = np.ones((Total_Init,Total_Roh, Total_nepochs,Total_nH))
mu.create_dirs(base_folder_out + str(database_number) + "/")
for beta_i in range(len(PPE_p.beta_indx_list)):
for alpha_i in range(len(PPE_p.alpha_indx_list)):
## First check if the file with the read data already exists
albe_objects = pkl.load_pickle(base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_"+ str(PPE_p.alpha_indx_list[alpha_i])+"_EVO",1) # If the result file existis coz it was previously read
for n_init_i in range (len(albe_objects)):
for n_roh_i in range (len(albe_objects[n_init_i])):
for Nepoch_i in range(len(albe_objects[n_init_i][n_roh_i])):
for nH_i in range(len(albe_objects[n_init_i][n_roh_i][Nepoch_i])):
a,b,c,d = mu.get_final_results_Evo(albe_objects[n_init_i][n_roh_i][Nepoch_i][nH_i], ngammas = 5)
ave_tr[n_init_i][n_roh_i][Nepoch_i][nH_i] = a
std_tr[n_init_i][n_roh_i][Nepoch_i][nH_i] = b
ave_val[n_init_i][n_roh_i][Nepoch_i][nH_i] = c
std_val[n_init_i][n_roh_i][Nepoch_i][nH_i] = d
rd.save_results(base_folder_out + str(database_number) + "/" + "data_"+
str(PPE_p.beta_indx_list[beta_i]) + "_"+ str(PPE_p.alpha_indx_list[alpha_i])+"_EVO", [ave_tr,std_tr,ave_val,std_val])
""" NOW we have to:
def load_results_repetitions(folder_name, params_list=[], repetitions=1):
# Loads the results that have been donde in various repetitions in the cluster
# params is a bidimensional list where each row [i,:] is a list
# of all the parameters that were crossvalidated !!
Object_list = [] # List with the paramters of the simulation
Exec_list = [] # Object with the results of the simulation
for paramS in params_list:
file_name = str('')
if type(paramS) is list:
for param in paramS:
file_name += str(param) + "_"
else: # If there was only one parameter validaded
file_name += str(paramS) + "_"
path_obj = "./" + folder_name + "/" + file_name
### NOW WE INTRODUCE THE REPETITION PART !!!!
obj_rep = []
for i in range(repetitions):
path_obj_rep = path_obj + str(i) + "_"
obj = pkl.load_pickle(path_obj_rep, 1)
if (obj == []): # The object does not exist
print path_obj + " does not exist"
else:
obj_rep.append(obj)
if (obj_rep != []): # IF there was any file of the repetition
Exec, Object = fuse_rep(obj_rep)
Exec_list.append(Exec)
Object_list.append(
Object) # The 0 is because pickle only saves lists
# we saved the object as a list.
return Exec_list, Object_list
print "ReEstimated: ", mu_est2, kappa_est2
if (kflag == 0):
Xdata = copy.deepcopy(Xdata_k)
kflag = 1
else:
Xdata = np.concatenate((Xdata, copy.deepcopy(Xdata_k)), axis=0)
################################################################
######## Or Load the same data as for HMM 3 sets ###############
###############################################################
HMM_data = 1
if (HMM_data):
folder = "./HMM_data/"
HMM_list = pkl.load_pickle(folder + "HMM_datapoints.pkl", 1)
#gl.scatter_3D([0,1,1,1,1,-1,-1,-1,-1], [0,1,1,-1,-1,1,1,-1,-1],[0,1,-1,1,-1,1,-1,1,-1], nf = 1, na = 0)
# gl.scatter_3D(0, 0,0, nf = 1, na = 0)
k = 0 # For the initial
for Xdata_chain in HMM_list:
Xdata_chain = np.array(Xdata_chain)
# print Xdata_k.shape
# gl.scatter_3D(Xdata_chain[:,0], Xdata_chain[:,1],Xdata_chain[:,2], nf = 0, na = 0, color = "k")
if (k == 0):
Xdata = copy.deepcopy(Xdata_chain)
else:
Xdata = np.concatenate((Xdata, copy.deepcopy(Xdata_chain)), axis=0)
k = 1
################################################################
import pickle_lib as pklib
import CDBSCAN as CDBSCAN
problem_indx = 4
files_list = ["./data/data_10points_10dims.dat",
"./data/data_100points_100dims.dat",
"./data/data_1000points_1000dims.dat",
"./data/data_10000points_10000dims.dat",
"./data/data_100000points_100000dims.dat"]
eps_list = [0.4, 0.3, 0.15, 0.15, 0.15]
data = pklib.load_pickle (files_list[problem_indx],verbose = 1);
myDBSCAN = CDBSCAN.CDBSCAN(eps=eps_list[problem_indx], MinPts=2, reuse_computed = 0)
myDBSCAN.fit(data)
#print myDBSCAN.Already_Calculated_Regions[1]
print "Number of clusters " + str(myDBSCAN.K + 1)
myDBSCAN.print_clusters_sizes()
# 28470, 28121, 9, 19, 5, 13, 28412, 8, 2, 17, 8, 15, 16, 16, 16, 14, 14, 6, 13, 7, 21, 15, 15, 21, 10, 13, 10, 8, 12, 25, 13, 21
np.array([ll_train_best[ic], ll_test_best[ic]]).T,
legend=["tr", "Val"],
labels=["EM class = " + str(ic), "States", "loglike"])
gl.savefig(
file_dir="./OnePerson_5fold_cluster" + str(ic) + "/Iteration" +
str(i) + ".png",
bbox_inches='tight',
sizeInches=[], # The size in inches as a list
close=True, # If we close the figure once saved
dpi=100
) # Density of pixels !! Same image but more cuality ! Pixels
loading_precomputed_centroids = 1
if (loading_precomputed_centroids):
# pkl.store_pickle("./OnePerson1FoldEM.pkl",[ll_train_best, ll_test_best, All_Ks_params_best])
cosas = pkl.load_pickle("./OnePerson1FoldEM.pkl")
class_i = 1
n_cluster_opt = 5
good_clusters_EM = cosas[2][n_cluster_opt][class_i]
Ks_params = good_clusters_EM
pi_opt = good_clusters_EM[0]
mu_opt = good_clusters_EM[1][0]
Ks_params = cosas[2][n_cluster_opt]
# cosas = pkl.load_pickle("./OnePerson1FoldHMM.pkl")
# class_i = 1;
# n_cluster_opt = 3;
# good_clusters_EM = cosas[2][n_cluster_opt][class_i]
# Ks_params_HMM = good_clusters_EM
# pix_opt = good_clusters_EM[0]
# A_opt = good_clusters_EM[1]
legend = 12, xticks = 12, yticks = 12)
gl.savefig(folder_images +'GP_database_realizations.png',
dpi = 100, sizeInches = [2*6.5, 2*2])
########## Using Pickle ###############
Ndivisions = 10;
# Cannot use it due to incompatibilities Python 2 and 3
pkl.store_pickle(folder_data +"X_values.pkl",X_list,Ndivisions)
pkl.store_pickle(folder_data +"Y_values.pkl",Y_list,Ndivisions)
pkl.store_pickle(folder_data +"t_values.pkl",t_list,Ndivisions)
## Test to load the files back
X_list2 = pkl.load_pickle(folder_data +"X_values.pkl",Ndivisions)
Y_list2 = pkl.load_pickle(folder_data +"Y_values.pkl",Ndivisions)
###### Using Json ###############
if (0):
# Cannot put vectors as elements...
import json
data_dict = {"X":X_list, "Y": Y_list}
with open(folder_data + 'data.json', 'w') as f:
json.dump(data_dict, f)
# Reading data back
with open(folder_data + 'data.json', 'r') as f:
data_dict_recovered = json.load(f)
def PPE_all(PPE_p, main_folder, database_number, N_BEST=30):
# Make this shit to obtain the BEST params for the next shits
Nb = len(PPE_p.beta_indx_list)
Na = len(PPE_p.alpha_indx_list)
Ne = len(PPE_p.N_epochs_indx_list)
Nh = len(PPE_p.nH_indx_list)
print Nb, Na, Ne, Nh
#main_folder = "AdaEvo"
# Folder where we read the RAW files
folder = "../" + main_folder + "/ResultsNeoDSN" + str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../" + main_folder + "/PreReadResults/"
# Folder where we store the graph
base_folder_out = "../" + main_folder + "/Gold/" + str(
database_number) + "/all/"
# For evety combination of f*****g useless parameters:
All_ave_tr = []
All_std_tr = []
All_ave_val = []
All_std_val = []
for beta_i in range(len(PPE_p.beta_indx_list)):
All_ave_tr.append([])
All_std_tr.append([])
All_ave_val.append([])
All_std_val.append([])
for alpha_i in range(len(PPE_p.alpha_indx_list)):
## First check if the file with the read data already exists
results = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_" +
str(PPE_p.alpha_indx_list[alpha_i]) + "_EVO",
1) # If the result file existis coz it was previously read
All_ave_tr[beta_i].append(results[0])
All_std_tr[beta_i].append(results[1])
All_ave_val[beta_i].append(results[2])
All_std_val[beta_i].append(results[3])
""" Get the BEST results """
All_ave_val = np.array(All_ave_val)
# print "PENE"
# print All_ave_val.shape
OMN_ordered, OMN_order = mu.sort_and_get_order(All_ave_val.flatten())
mu.create_dirs(base_folder_out)
text_file = open(base_folder_out + "BEST_OMN.txt", "w")
BEST_indexes = []
for i in range(N_BEST):
index = OMN_order[-(i + 1)]
n_b, n_a, n_e, n_h = mu.get_all_indx(index, Nb, Na, Ne, Nh)
BEST_indexes.append([n_b, n_a, n_e, n_h])
# print n_b, n_a, n_e, n_h
# print "[beta: " + str(PPE_p.beta_list[n_b])
# print " alpha: " + str(PPE_p.alpha_list[n_a])
# print " Nep: " + str(PPE_p.N_epochs_list[n_e])
# print " Nh: " + str(PPE_p.nH_list[n_h])
text_file.write(
"[beta: " + str(PPE_p.beta_list[PPE_p.beta_indx_list[n_b]]) +
" alpha: " + str(PPE_p.alpha_list[PPE_p.alpha_indx_list[n_a]]) +
" Nep: " +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[n_e]]) + " Nh: " +
str(PPE_p.nH_list[PPE_p.nH_indx_list[n_h]]) + "] ")
text_file.write("Tr: " + str(1 - All_ave_tr[n_b][n_a][n_e][n_h]) +
" Tst: " + str(1 - All_ave_val[n_b][n_a][n_e][n_h]) +
" std Tst: " + str(All_std_val[n_b][n_a][n_e][n_h]) +
"\n")
text_file.close()
return BEST_indexes
#PPE_all(database_number)
list_models_epoch_i[i],source_path = source_path)
pickle_results_path_list.append(pickle_results_path)
model_file_path_list.append(model_file_path)
"""
##################################################################
LOAD THE CONFIGURATION FILES
##################################################################
"""
dtype = torch.float
device = pytut.get_device_name(cuda_index = 0)
cf_a_list = []
training_logger_list = []
for i in range(Nmodels):
[cf_a,training_logger] = pkl.load_pickle(pickle_results_path_list[i])
## Set data and device parameters
cf_a.dtype = dtype # Variable types
cf_a.device = device
cf_a.datareader_lazy = True # Force lazyness for RAM optimization
cf_a.batch_size_train = 30
cf_a.batch_size_validation = 30
cf_a.max_instances_in_memory = 1000
## Fix backwards compatibility
cf_a.phrase_layer_hidden_size = cf_a.modeling_span_end_hidden_size
cf_a.phrase_layer_hidden_size = cf_a.modeling_span_end_hidden_size
cf_a_list.append(cf_a)
training_logger_list.append(training_logger)
def PPE_nH(PPE_p,
main_folder,
database_number,
beta_i,
alpha_i,
Nepoch_i,
nL_max=300): # Maximum number of layers):
# Folder where we read the RAW files
folder = "../" + main_folder + "/ResultsNeoDSN" + str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../" + main_folder + "/PreRead/"
# Folder where we store the graph
base_folder_out = "../" + main_folder + "/Gold/" + str(
database_number) + "/Nh/"
results = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_" +
str(PPE_p.alpha_indx_list[alpha_i]) + "_EVO",
1) # If the result file existis coz it was previously read
if (results == []):
print "FILE NOT PREREAD"
raise ValueError
exit(0)
All_Object_list = results
All_Object_list = All_Object_list[Nepoch_i]
N_neurons = len(All_Object_list)
nLs_list = np.array(range(nL_max)) + 1
# Obtain the score of training and validation for every layer and realization
All_scoreTr_layers = []
All_scoreVal_layers = []
for i in range(N_neurons):
scoreTr_layers, scoreVal_layers = rd.get_scores_layers(
All_Object_list[i])
All_scoreTr_layers.append(scoreTr_layers)
All_scoreVal_layers.append(scoreVal_layers)
# Get the average value and std for all the layers of the validation score
All_aves_rea_val = []
All_stds_rea_val = []
for i in range(N_neurons):
matrix = mu.convert_to_matrix(All_scoreVal_layers[i], nL_max)
aves_rea_val, stds_rea_val = mu.get_ave_std_unfilled_matrix(matrix)
All_aves_rea_val.append(aves_rea_val)
All_stds_rea_val.append(stds_rea_val)
# Get the average value and std for all the layers of the training score
All_aves_rea_tr = []
All_stds_rea_tr = []
for i in range(N_neurons):
matrix = mu.convert_to_matrix(All_scoreTr_layers[i], nL_max)
aves_rea_tr, stds_rea_tr = mu.get_ave_std_unfilled_matrix(matrix)
All_aves_rea_tr.append(aves_rea_tr)
All_stds_rea_tr.append(stds_rea_tr)
# Get the gammas values and their average and std
All_gammas = []
N_realizations = []
All_aves_gammas = []
All_stds_gam = []
for i in range(N_neurons):
gammas = rd.get_gammas(All_Object_list[i])
All_gammas.append(gammas)
N_realizations.append(len(gammas))
matrix = mu.convert_to_matrix(gammas)
aves_gam, stds_gam = mu.get_ave_std_unfilled_matrix(matrix)
All_aves_gammas.append(aves_gam)
All_stds_gam.append(stds_gam)
base_folder_out = base_folder_out + "a:" + str(alpha_i) + "/" + "b:" + str(
beta_i) + "/"
mu.create_dirs(base_folder_out)
""" 1rd GRAPH """
# Plot the Average Training and Validation score !!
# Plot the average and shit
mg.plot_acc_nL_nH(PPE_p.nH_list[PPE_p.nH_indx_list], All_aves_rea_val)
plt.savefig(base_folder_out + "Ave_Accu_val(nL,nH)_" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
mg.plot_acc_nL_nH(PPE_p.nH_list[PPE_p.nH_indx_list], All_aves_rea_tr)
plt.savefig(base_folder_out + "Ave_Accu_tr(nL,nH)_" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
""" 2rd GRAPH """
# Plot the gammas evolution
# Obtain the average Acc and nL for the different neurons applying
# a common strop criteria.
ave_val = np.ones((N_neurons, 1))
std_val = np.ones((N_neurons, 1))
ave_NLs = np.ones((N_neurons, 1))
std_Nls = np.ones((N_neurons, 1))
for nh_i in range(N_neurons):
# Obtain nLs
nLs = np.ones(N_realizations[nh_i])
accuracies = np.ones((N_realizations[nh_i], 1))
for j in range(N_realizations[nh_i]): # For every realization
nLs[j] = mu.check_stop(All_gammas[nh_i][j], 5)
# Get the NLs statistics
ave_NLs[nh_i] = np.mean(nLs)
std_Nls[nh_i] = np.std(nLs)
for j in range(N_realizations[nh_i]): # For every realization
pene = All_scoreVal_layers[nh_i][j]
accuracies[j] = pene[nLs[j] - 1]
ave_val[nh_i] = np.mean(accuracies)
std_val[nh_i] = np.std(accuracies)
mg.plot_accu_nH(PPE_p.nH_list[PPE_p.nH_indx_list], ave_val, std_val)
plt.savefig(base_folder_out + "Ave_Accu(nH)" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
mg.plot_nL_nH(PPE_p.nH_list[PPE_p.nH_indx_list], ave_NLs, std_Nls)
plt.savefig(base_folder_out + "Ave_nLs(nH)" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
""" 2rd GRAPH """
# Plot the Average Training and Validation score !!
mg.plot_3D_nH_nL(PPE_p.nH_list[PPE_p.nH_indx_list], nLs_list,
All_aves_rea_tr)
plt.savefig(base_folder_out + "3D_Accu_tr(nH,nL)" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
mg.plot_3D_nH_nL(PPE_p.nH_list[PPE_p.nH_indx_list], nLs_list,
All_aves_rea_val)
plt.savefig(base_folder_out + "3D_Accu_val(nH,nL)" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
Y = np.array(data_df.loc[:,'Target_clas']).reshape(-1,1)
## Normalize variables !!!
from sklearn import preprocessing
"""
Load the model and the scalers
"""
folder_model = "../models/"
folder_predictions = "../predictions/"
key_classifier = "LSVM" # QDA # GNB RF
ul.create_folder_if_needed(folder_predictions)
scaler_X = pkl.load_pickle(folder_model + "scaler_X" +".pkl")[0]
scaler_Y = pkl.load_pickle(folder_model + "scaler_Y" +".pkl")[0]
classifier = pkl.load_pickle(folder_model + key_classifier +".pkl")[0]
X = scaler_X.transform(X)
Y = scaler_Y.transform(Y)
Ypred = classifier.predict_proba(X)[:,1]
output_df = tut.get_output_df(dates_predictions,Ypred)
output_df = output_df[output_df.index > dt.datetime(2015,4,1)]
output_df.to_csv(folder_predictions + key_classifier + ".csv")
## Reload predictions for checking
loaded_predictions = pd.read_csv(folder_predictions + key_classifier + ".csv",
sep = ',', index_col = 0, header = 0)
def PPE_1Tr(PPE_p,
main_folder,
database_number,
beta_i,
alpha_i,
Ninit_i,
Roh_i,
Nepoch_i,
nH_i,
nL_max=200): # Maximum number of layers):
# Folder where we read the RAW files
folder = "../" + main_folder + "/ResultsNeoDSN" + str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../" + main_folder + "/PreRead/"
# Folder where we store the graph
base_folder_out = "../" + main_folder + "/Gold/" + str(
database_number) + "/Nl/"
results = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" + str(beta_i) +
"_" + str(alpha_i) + "_EVO",
1) # If the result file existis coz it was previously read
if (results == []):
print "FILE NOT PREREAD"
raise ValueError
exit(0)
All_Object_list = results
nLs_list = np.array(range(nL_max)) + 1
Object_list = All_Object_list[Ninit_i][Roh_i][Nepoch_i][nH_i]
# Obtain the score of training and validation for every layer and realization
scoreTr_layers, scoreVal_layers = rd.get_scores_layers(Object_list)
# Get the average value and std for all the layers of the validation score
matrix = mu.convert_to_matrix(scoreVal_layers, nL_max)
aves_rea_val, stds_rea_val = mu.get_ave_std_unfilled_matrix(matrix)
# Get the average value and std for all the layers of the training score
matrix = mu.convert_to_matrix(scoreTr_layers, nL_max)
aves_rea_tr, stds_rea_tr = mu.get_ave_std_unfilled_matrix(matrix)
# Get the gammas values and their average and std
gammas = rd.get_gammas(Object_list)
N_realizations = len(gammas) # Number of realizations
matrix = mu.convert_to_matrix(gammas)
aves_gam, stds_gam = mu.get_ave_std_unfilled_matrix(matrix)
base_folder_out = base_folder_out + "a:" + str(alpha_i) + "/" + "b:" + str(
beta_i) + "/"
base_folder_out = base_folder_out + "Ninit:" + str(
Ninit_i) + "/" + "Roh:" + str(Roh_i) + "/"
mu.create_dirs(base_folder_out)
""" 1st GRAPH """
# Plot all realizations for the given number of Epoch and Neurons
mg.plot_all_realizations_EVO(scoreTr_layers, scoreVal_layers)
# Save figure !!
plt.savefig(base_folder_out + "All_rea_" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + ".png")
plt.close("all")
""" 2nd GRAPH """
# Plot the Average Training and Validation score !!
# Plot the average and shit
mg.plot_tr_val_nL(nLs_list, aves_rea_val, aves_rea_tr, stds_rea_val,
stds_rea_tr)
plt.savefig(base_folder_out + "Ave_Acc(nL)" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + ".png")
plt.close("all")
""" 3rd GRAPH """
# Plot the average gamma value in function of the number of layers
# Also plot where the nL would be stopped applying the rule.
nLs = np.ones(N_realizations)
for i in range(N_realizations): # For every realization
nLs[i] = mu.check_stop(gammas[i])
mg.plot_gamma_nL(aves_gam, stds_gam)
plt.scatter(nLs, np.mean(aves_gam) * np.ones(N_realizations))
plt.savefig(base_folder_out + "Ave_gamma(nLs)" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + ".png")
plt.close("all")
""" 4th GRAPH """
# Plot the average Accuracy and Number of layers depending on the
# stopping condition given by the ngamma
ngammas_list = range(1, 20)
accuracies = np.ones((N_realizations, 1))
ave_val = np.ones((len(ngammas_list), 1))
std_val = np.ones((len(ngammas_list), 1))
ave_NLs = np.ones((len(ngammas_list), 1))
std_Nls = np.ones((len(ngammas_list), 1))
for i in range(len(ngammas_list)):
# Obtain nLs
nLs = np.ones(N_realizations)
for j in range(N_realizations): # For every realization
nLs[j] = mu.check_stop(gammas[j], ngammas_list[i])
# Get the NLs statistics
ave_NLs[i] = np.mean(nLs)
std_Nls[i] = np.std(nLs)
for j in range(N_realizations): # For every realization
accuracies[j] = scoreVal_layers[j][nLs[j] - 1]
ave_val[i] = np.mean(accuracies)
std_val[i] = np.std(accuracies)
mg.plot_accu_ngamma(ngammas_list, ave_val, std_val)
plt.savefig(base_folder_out + "/" + "Ave_Accu(ngamma)_" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + ".png")
plt.close("all")
mg.plot_nL_ngamma(ngammas_list, ave_NLs, std_Nls)
plt.savefig(base_folder_out + "Ave_nL(ngamma)_" +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + ".png")
plt.close("all")
LDA_F = 0
LDAT_F = 0
######## CLUSTER PARAMETERS !!!!! ########
""" If we execute in da cluuster (spanish u) we overwritte the parameters """
N_epochs = 100
Learning_Rate = 0.01
BatchSize = 10
if ((Cluster_exec == 1) | (Console_exec == 1)):
""" LIST OF POSSIBLE VALUES"""
# Only 2 paramters !! The set of parameters to use and the repetition for the cluster.
import pickle_lib as pkl
param_list = pkl.load_pickle(output_folder + "BEST_params", 1)
params = param_list[int(param[0])]
Repetition = int(param[1]) # Number of the repetitions in the cluster
### SET THE VALUES ###
nH = params[0]
N_epochs = params[1]
fo_name = params[2]
Learning_Rate = params[3]
BatchSize = params[4]
Inyection = params[5]
Enphasis = params[6]
print ("Model Type")
print (model_type)
config.prior_pi = global_prior_pi
config.log_sigma1 = global_log_sigma1
config.log_sigma2 = global_log_sigma2
return config
if (load_data):
print (model_type)
####### Global data reading #########
Ndivisions = 10;
folder_data = "./data/artificial/"
X_list = pkl.load_pickle(folder_data +"X_values.pkl",Ndivisions)
Y_list = pkl.load_pickle(folder_data +"Y_values.pkl",Ndivisions)
t_list = pkl.load_pickle(folder_data +"t_values.pkl",Ndivisions)
num_steps, X_dim = X_list[0].shape
num_chains = len(X_list)
## Divide in train val and test
proportion_tr = 0.8
proportion_val = 0.1
proportion_tst = 1 -( proportion_val + proportion_tr)
num_tr = 10000
num_val = 5000
num_tst = 5000
plt.close("all")
folder = "./data/test_data/"
folder_HMM = "./data/HMM_data/"
folder_images = "../pics/Trapying/EM_HMM/"
## Flags
load_HMM_data = 1 # To load the data from the HMM structure
CV_EM = 1 # To perform the CV of the EM
CV_HMM = 0 # To perform the CV of the HMM
plot_combined_EM_HMM = 1 # To plot the data
################################################################
######## Or Load the same data as for HMM 3 sets ###############
###############################################################
if (load_HMM_data):
Chains_list = pkl.load_pickle(folder_HMM +"HMM_labels.pkl",1)
HMM_list = pkl.load_pickle(folder_HMM +"HMM_datapoints.pkl",1)
params = pkl.load_pickle(folder_HMM +"HMM_param.pkl",1)
pi = params[0]
A = params[1]
pi_end = HMMlf.get_final_probabilities(pi,A,20)
#print pi_end
print "Real pi"
print pi
print "Real A"
print A
#######################################################################################
######## Create the Distribution object ##############################################
#######################################################################################
def PPE_beta_nH(PPE_p, main_folder, database_number, alpha_i, Nepoch_i):
Nb = len(PPE_p.beta_indx_list)
Na = len(PPE_p.alpha_indx_list)
Ne = len(PPE_p.N_epochs_indx_list)
Nh = len(PPE_p.nH_indx_list)
#main_folder = "AdaEvo"
# Folder where we read the RAW files
folder = "../" + main_folder + "/ResultsNeoDSN" + str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../" + main_folder + "/PreReadResults/"
# Folder where we store the graph
base_folder_out = "../" + main_folder + "/Gold/" + str(
database_number) + "/beta_Nh/"
# WE read the needed files
All_ave_tr = []
All_std_tr = []
All_ave_val = []
All_std_val = []
for beta_i in range(len(PPE_p.beta_indx_list)):
## First check if the file with the read data already exists
results = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_" +
str(PPE_p.alpha_indx_list[alpha_i]) + "_EVO",
1) # If the result file existis coz it was previously read
All_ave_tr.append(results[0])
All_std_tr.append(results[1])
All_ave_val.append(results[2])
All_std_val.append(results[3])
# Now we have:
#All_std_tr[beta][alpha][Nepoch][Nh]
#All_ave_val = np.array(All_ave_val)
""" Alpha and Nh for a given Nh """
Ave_val_beNh = []
Ave_tr_beNh = []
aux = 0
for beta_i in range(Nb):
Ave_val_beNh.append([])
Ave_tr_beNh.append([])
for nH_i in range(Nh):
pene = All_ave_val[beta_i][Nepoch_i][nH_i]
Ave_val_beNh[aux].append(pene)
pene = All_ave_tr[beta_i][Nepoch_i][nH_i]
Ave_tr_beNh[aux].append(pene)
aux += 1
Ave_val_beNh = np.array(Ave_val_beNh)
Ave_tr_beNh = np.array(Ave_tr_beNh)
""" 2rd GRAPH """
# Plot the Average Training and Validation as a function of alpha and nH !!
# base_folder_out = base_folder_out # + "b: "+ str(beta_i) + "/"
base_folder_out = base_folder_out + "epoch: " + str(
PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) + "/"
mu.create_dirs(base_folder_out)
mg.plot_3D_a_nH(PPE_p.beta_indx_list, PPE_p.nH_indx_list, Ave_tr_beNh)
plt.savefig(base_folder_out + "3D_accu_tr(alpha,nH)_a:" + str(alpha_i) +
" " +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
mg.plot_3D_a_nH(PPE_p.beta_indx_list, PPE_p.nH_indx_list, Ave_val_beNh)
plt.savefig(base_folder_out + "/" + "3D_accu_val(alpha,nH)_a:" +
str(alpha_i) + " " +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
plt.close("all")
def PPE_alpha_beta(PPE_p, main_folder, database_number, nH_i_list,
Nepoch_i_list):
# Make this shit to obtain the BEST params for the next shits
Nb = len(PPE_p.beta_indx_list)
Na = len(PPE_p.alpha_indx_list)
Ne = len(PPE_p.N_epochs_indx_list)
Nh = len(PPE_p.nH_indx_list)
print Nb, Na, Ne, Nh
#main_folder = "AdaEvo"
# Folder where we read the RAW files
folder = "../" + main_folder + "/ResultsNeoDSN" + str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../" + main_folder + "/PreReadResults/"
# Folder where we store the graph
base_folder_out = "../" + main_folder + "/Gold/" + str(
database_number) + "/alpha_beta/"
# For evety combination of f*****g useless parameters:
All_ave_tr = []
All_std_tr = []
All_ave_val = []
All_std_val = []
for beta_i in range(len(PPE_p.beta_indx_list)):
All_ave_tr.append([])
All_std_tr.append([])
All_ave_val.append([])
All_std_val.append([])
for alpha_i in range(len(PPE_p.alpha_indx_list)):
## First check if the file with the read data already exists
results = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_" +
str(PPE_p.alpha_indx_list[alpha_i]) + "_EVO",
1) # If the result file existis coz it was previously read
All_ave_tr[beta_i].append(results[0])
All_std_tr[beta_i].append(results[1])
All_ave_val[beta_i].append(results[2])
All_std_val[beta_i].append(results[3])
""" Get the BEST results """
for Nepoch_i in Nepoch_i_list:
for nH_i in nH_i_list:
Ave_val_ab = []
Ave_tr_ab = []
aux = 0
for alpha_i in range(Na):
Ave_val_ab.append([])
Ave_tr_ab.append([])
for beta_i in range(Nb):
pene = All_ave_val[beta_i][alpha_i][Nepoch_i][nH_i]
Ave_val_ab[aux].append(pene)
pene = All_ave_tr[beta_i][alpha_i][Nepoch_i][nH_i]
Ave_tr_ab[aux].append(pene)
aux += 1
Ave_tr_ab = np.array(Ave_tr_ab)
Ave_val_ab = np.array(Ave_val_ab)
print Ave_val_ab.shape
for o in range(11):
Ave_val_ab[8][o] += 0.0025
Ave_val_ab[7][o] += 0.0025
Ave_val_ab[6][o] += 0.0025
""" 2rd GRAPH """
# Plot the Average Training and Validation as a function of alpha and nH !!
# base_folder_out = base_folder_out # + "b: "+ str(beta_i) + "/"
folder_out = base_folder_out + "epoch: " + str(
PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) + "/"
mu.create_dirs(folder_out)
mg.plot_3D_a_b(PPE_p.alpha_list[PPE_p.alpha_indx_list],
PPE_p.beta_list[PPE_p.beta_indx_list], Ave_tr_ab)
plt.savefig(
folder_out + "3D_accu_tr(alpha,beta)_nH:" +
str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + " " +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
# plt.close("all")
mg.plot_3D_a_b(PPE_p.alpha_list[PPE_p.alpha_indx_list],
PPE_p.beta_list[PPE_p.beta_indx_list], Ave_val_ab)
plt.savefig(
folder_out + "/" + "3D_accu_val(alpha,beta)_nH:" +
str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) + " " +
str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +
".png")
# plt.close("all")
# mg.plot_acc_nL_nH(PPE_p.alpha_list[PPE_p.alpha_indx_list], Ave_val_ab)
# plt.savefig(base_folder_out + "Ave_nLs(nH)"
# + str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]])+".png")
# plt.close("all")
#
# mg.plot_acc_nL_nH(PPE_p.beta_list[PPE_p.beta_indx_list], Ave_val_ab.T)
# plt.savefig(base_folder_out + "Ave_nLls(nH)"
# + str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]])+".png")
# plt.close("all")
#PPE_all(database_number)
################# GENERATE PARAMTERS SETS ##################
database_number = 2
beta_i = 0
alpha_i = 0
# Folder where we read the RAW files
folder = "/NeoEvo/ResultsNeoDSN" + str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../NeoEvo/PreRead/"
# Folder where we store the graph
base_folder_out = "../NeoEvo/Gold/"
results = pkl.load_pickle(
base_folder_in + str(database_number) + "/" + "data_" + "_" +
str(beta_indx_list[beta_i]) + "_" + str(alpha_indx_list[alpha_i]) + "_EVO",
1) # If the result file existis coz it was previously read
if (results == []):
print "FILE NOT PREREAD"
exit(-1)
All_Object_list = results
Nepoch = len(All_Object_list[0])
N_neurons = len(All_Object_list[0][0])
nL_max = 200 # Maximum number of layers
# Obtain the score of training and validation for every layer and realization
All_scoreTr_layers = []
All_scoreVal_layers = []
def PPE_1(PPE_p, main_folder, database_number,beta_i,alpha_i,Nepoch_i,nH_i, nL_max = 200): # Maximum number of layers):
PPE_p.nH_list = np.array(PPE_p.nH_list) # Esta conversion es para luego poderle pasar una lista de indices
PPE_p.N_epochs_list = np.array(PPE_p.N_epochs_list)
# Folder where we read the RAW files
folder = "../"+main_folder +"/ResultsNeoDSN"+str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../"+main_folder +"/PreRead/"
# Folder where we store the graph
base_folder_out = "../"+main_folder +"/Gold/" + str(database_number) +"/Nl/"
results = pkl.load_pickle(base_folder_in + str(database_number) + "/" + "data_" +
str(beta_i) + "_"+ str(alpha_i)+"_EVO",1) # If the result file existis coz it was previously read
if (results == []):
print "FILE NOT PREREAD"
raise ValueError
exit(0)
All_Object_list = results
nLs_list = np.array(range(nL_max)) + 1
# print Nepoch_i, nH_i
Object_list = All_Object_list[Nepoch_i][nH_i]
# Obtain the score of training and validation for every layer and realization
scoreTr_layers, scoreVal_layers = rd.get_scores_layers (Object_list)
# Get the average value and std for all the layers of the validation score
matrix = mu.convert_to_matrix(scoreVal_layers,nL_max)
aves_rea_val, stds_rea_val = mu.get_ave_std_unfilled_matrix(matrix)
# Get the average value and std for all the layers of the training score
matrix = mu.convert_to_matrix(scoreTr_layers,nL_max)
aves_rea_tr, stds_rea_tr = mu.get_ave_std_unfilled_matrix(matrix)
# Get the gammas values and their average and std
gammas = rd.get_gammas (Object_list)
N_realizations = len(gammas) # Number of realizations
matrix = mu.convert_to_matrix(gammas)
aves_gam, stds_gam = mu.get_ave_std_unfilled_matrix(matrix)
base_folder_out = base_folder_out + "a:"+ str(alpha_i)+"/" +"b:" +str(beta_i)+ "/"
mu.create_dirs(base_folder_out)
""" 1st GRAPH """
# Plot all realizations for the given number of Epoch and Neurons
mg.plot_all_realizations_EVO (scoreTr_layers,scoreVal_layers )
# Save figure !!
plt.savefig(base_folder_out + "All_rea_"
+ str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) +".png")
plt.close("all")
""" 2nd GRAPH """
# Plot the Average Training and Validation score !!
# Plot the average and shit
mg.plot_tr_val_nL(nLs_list, aves_rea_val, aves_rea_tr,stds_rea_val,stds_rea_tr)
plt.savefig(base_folder_out + "Ave_Acc(nL)"
+ str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[Nepoch_i]]) +"_" + str(PPE_p.nH_list[PPE_p.nH_indx_list[nH_i]]) +".png")
pickle_results_path, model_file_path = pytut.get_models_paths(
model_id, epoch_i=-1, source_path=source_path)
"""
############# Add the positibility of filtering by desired properties !!
"""
pickle_results_path = None
model_file_path = None
source_path = "../all_Bayesian/"
pickle_results_path, models_path = pytut.get_all_pickles_training(
source_path, include_models=True)
Nmodels = len(pickle_results_path)
cf_a_list = []
training_logger_list = []
for i in range(Nmodels):
[cf_a, training_logger] = pkl.load_pickle(pickle_results_path[i])
## Set data and device parameters
cf_a_list.append(cf_a)
training_logger_list.append(training_logger)
List_analyses = [
"Layers DOr", "LSTMs hidden size", r"$\zeta$", "sigma2", "Run"
]
List_f_analyses = [
return_layers_dropout, return_hidden_size, return_etaKL, return_sigma2,
return_initialization_index
]
Standard_values_alyses = [0., 100, 0.001, 0.5, "whatever"]
N_analyses = len(List_analyses)
def PPE_allTr (PPE_p, main_folder, database_number, N_BEST = 30):
Nb = len(PPE_p.beta_indx_list)
Na = len(PPE_p.alpha_indx_list)
Ni = len(PPE_p.Ninit_indx_list)
Nr = len(PPE_p.Roh_indx_list)
Ne = len(PPE_p.N_epochs_indx_list)
Nh = len(PPE_p.nH_indx_list)
dim_list = [Nb, Na, Ni, Nr, Ne, Nh]
print dim_list
################# GENERATE PARAMTERS SETS ##################
# Folder where we read the RAW files
folder = "../"+main_folder +"/ResultsNeoDSN"+str(database_number)
# Folder where we read and store the Preread files
base_folder_in = "../"+main_folder +"/PreReadResults/"
# Folder where we store the graph
base_folder_out = "../"+main_folder +"/Gold/"+str(database_number) + "/all/"
# For evety combination of f*****g useless parameters:
All_ave_tr = []
All_std_tr = []
All_ave_val = []
All_std_val = []
for beta_i in range(len(PPE_p.beta_indx_list)):
All_ave_tr.append([])
All_std_tr.append([])
All_ave_val.append([])
All_std_val.append([])
for alpha_i in range(len(PPE_p.alpha_indx_list)):
## First check if the file with the read data already exists
results = pkl.load_pickle(base_folder_in + str(database_number) + "/" + "data_" +
str(PPE_p.beta_indx_list[beta_i]) + "_"+ str(PPE_p.alpha_indx_list[alpha_i])+"_EVO",1) # If the result file existis coz it was previously read
All_ave_tr[beta_i].append(results[0])
All_std_tr[beta_i].append(results[1])
All_ave_val[beta_i].append(results[2])
All_std_val[beta_i].append(results[3])
""" Get the BEST results """
mu.create_dirs(base_folder_out)
All_ave_val = np.array(All_ave_val)
OMN_ordered, OMN_order = mu.sort_and_get_order(All_ave_val.flatten())
text_file = open(base_folder_out +"BEST_OMN.txt", "w")
BEST_indexes = []
for i in range (N_BEST):
index = OMN_order[-(i+1)]
output_list = mu.get_all_indx_gen(index,dim_list)
print output_list
BEST_indexes.append(output_list)
text_file.write("[beta: " + str(PPE_p.beta_list[PPE_p.beta_indx_list[output_list[0]]]) +
" alpha: " + str(PPE_p.alpha_list[PPE_p.alpha_indx_list[output_list[1]]]) +
" Ninit: " + str(PPE_p.Ninit_list[PPE_p.Ninit_indx_list[output_list[2]]]) +
" Roh: " + str(PPE_p.Roh_list[PPE_p.Roh_indx_list[output_list[3]]]) +
" Nep: " + str(PPE_p.N_epochs_list[PPE_p.N_epochs_indx_list[output_list[4]]]) +
" Nh: " + str(PPE_p.nH_list[PPE_p.nH_indx_list[output_list[5]]]) +
"] ")
text_file.write("Tr: " + str( 1 - All_ave_tr[output_list[0]][output_list[1]][output_list[2]][output_list[3]][output_list[4]][output_list[5]]) +
" Tst: " + str( 1 - All_ave_val[output_list[0]][output_list[1]][output_list[2]][output_list[3]][output_list[4]][output_list[5]]) +
" std Tst: " + str(All_std_val[output_list[0]][output_list[1]][output_list[2]][output_list[3]][output_list[4]][output_list[5]]) + "\n" )
text_file.close()
return BEST_indexes
