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 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 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")
sys.path.append(os.path.abspath('')) import clusterizing as clus ## Param contains the str parameters param = clus.clusterize() import manutils as mu database_num = int(os.path.basename(__file__).split(".")[-2][-1]) print database_num print param # Configure cluster folders for data input and output output_folder = "../Results/" + str(database_num) + "G/" dataset_folder = "../data/" mu.create_dirs(output_folder) ################################################# ############ HEADING FOR WORKING ################ ################################################# import matplotlib.pyplot as plt from sklearn import preprocessing import scipy.io import GDSNBoost import DSNBoost # for the DSN_visual class import GSLFN import paramClasses as paC plt.close('all')
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)
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")
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)
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")
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")
def PPE_read(PPE_p, main_folder, database_number, repetitions=20): # Folder where we read the RAW files folder = "../" + main_folder + "/" + str(database_number) # Folder where we read and store the Preread files base_folder_in = "../" + main_folder + "/PreRead/" # 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) + "/") if (PPE_p.alpha_indx_list[0] == 10): All_Object_list = [ ] # List that will contain of the object lists for a given [beta_alpha] All_Exec_list = [] alpha_i = 0 beta_i = 0 print "WE are delaing with the one an only 10" for n_epoch_i in range(len(PPE_p.N_epochs_indx_list)): All_Object_list.append([]) All_Exec_list.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], PPE_p.fo_list[0], 1, PPE_p.BatchSize_list[0], PPE_p.Inyection_list[0], PPE_p.Enphasis_list[0], PPE_p.alpha_indx_list[alpha_i], PPE_p.beta_indx_list[beta_i], PPE_p.CV_List[0], PPE_p.Nruns_List[0] ] if ( PPE_p.CV_List[0] != 0 ): # If we are not loading evolution, but old style final results Exec_list = rd.load_Exec_repetitions( folder, [Parameters], repetitions) # print Exec_list All_Exec_list[n_epoch_i].append(Exec_list) else: Object_list = rd.load_objects_repetitions( folder, [Parameters], repetitions) All_Object_list[n_epoch_i].append(Object_list) # We write them all b = 0,1,2,.... copying the original alpha = 10, beta = 0 for beta_i in range(len(PPE_p.beta_indx_list)): if ( PPE_p.CV_List[0] != 0 ): # If we are not loading evolution, but old style final results 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_Exec_list) else: 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) return 5 # For evety combination of f*****g useless parameters: for alpha_i in range(len(PPE_p.alpha_indx_list)): for beta_i in range(len(PPE_p.beta_indx_list)): # # If the alpha == 1, then beta does not mind and it is 10 # if (PPE_p.alpha_list[PPE_p.alpha_indx_list[alpha_i]] == 1): # beta_i = 5 ## 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 results = [] 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 All_Exec_list = [ ] # Se usa solo para los que no tienen evolucion # Get the list of parameters and load them into All_Object_list for n_epoch_i in range(len(PPE_p.N_epochs_indx_list)): All_Object_list.append([]) All_Exec_list.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], PPE_p.fo_list[0], 1, PPE_p.BatchSize_list[0], PPE_p.Inyection_list[0], PPE_p.Enphasis_list[0], PPE_p.alpha_indx_list[alpha_i], PPE_p.beta_indx_list[beta_i], PPE_p.CV_List[0], PPE_p.Nruns_List[0] ] if ( PPE_p.CV_List[0] != 0 ): # If we are not loading evolution, but old style final results Exec_list = rd.load_Exec_repetitions( folder, [Parameters], repetitions) # print Exec_list All_Exec_list[n_epoch_i].append(Exec_list) else: Object_list = rd.load_objects_repetitions( folder, [Parameters], repetitions) All_Object_list[n_epoch_i].append(Object_list) if ( PPE_p.CV_List[0] != 0 ): # If we are not loading evolution, but old style final results 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_Exec_list) else: 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 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