def construire_DAG(arguments, matE_calcule, ens_C, test_booleen): """ A partir des cliques triees par ordre croissant, orienter le graphe """ cliques = list() dico_dual_arc_sommet = dict() matE = pd.DataFrame() matA = pd.DataFrame() # generer matE if (test_booleen == True): matE, matA, dico_dual_arc_sommet = simu50.matriceE( arguments["dimMatA"], arguments["nbre_lien"],\ arguments["chemin_matrices"], arguments["chemin_dataset"], \ arguments["nbre_ts"], arguments["epsilon"], \ arguments["effet_joule"], arguments["test"] ) cliques, aretes, dico_cliq, som_cout_min = \ decouvClique.decouverte_cliques( matE, dico_dual_arc_sommet, arguments["seuil_U"], arguments["epsilon"], \ arguments["chemin_dataset"], arguments["chemin_matrices"], \ arguments["ascendant_1"]) else: cliques = ens_C.copy() matE = matE_calcule # construction et orientation sorted_cliques = fct_aux.quicksort(cliques) dico = VerifCorrel.caracterisation_arc(matE.columns.tolist()) matA_predit = VerifCorrel.construire_matA_intelligent(dico, sorted_cliques) dico = VerifCorrel.orientation_arete(cliques, arguments["chemin_dataset"], matE, arguments["epsilon"]) matA_predit.to_csv(arguments["chemin_matrices"] + "matA_predit.csv") list_adjacency_matA_predit = from_adjacency_to_list_matrix( matA_predit, arguments["chemin_matrices"]) # representation matA et matA_predit if (test_booleen == True): aretes_matA = fct_aux.liste_arcs(matA) aretes_matA_predit = fct_aux.liste_arcs(matA_predit) G_matA = nx.Graph() G_matA.add_edges_from(aretes_matA) G_matA_predit = nx.Graph() G_matA_predit.add_edges_from(aretes_matA_predit) plt.figure(1) plt.subplot(211) nx.draw(G_matA, with_labels=True) plt.subplot(212) nx.draw(G_matA_predit, with_labels=True) plt.savefig(arguments["chemin_matrices"] + "matA_predit.png", format="PNG") return cliques, dico, dico_dual_arc_sommet pass
def G_k(matE_G0, k_deep, p_correl, correl_seuil): """ generer le graphe iourte G_k de k = k_deep profondeur ajoute des aretes entre les noeuds de degre = 2 ===> k = 0, puis sur ces aretes crees on ajoute 3 noeuds (les noeuds sont adjacents entre eux) A VERIFIER je ne crois pas trop """ liste_aretes_G_k = fct_aux.liste_arcs(matE_G0) cpt_noeuds = len(matE_G0.columns.tolist()) for k in range(0,k_deep+1): dico_gamma_noeud = gamma_noeud(liste_aretes_G_k) # bizarre set_noeuds_degre_2 = degre_noeuds_k(dico_gamma_noeud, 2) # bizarre aretes = list(it.combinations(set_noeuds_degre_2, 2)) # bizarre if k == k_deep: liste_aretes_G_k.extend(aretes) else: for arete in aretes : noeud = str(cpt_noeuds+1) liste_aretes_G_k.extend([(arete[0],noeud),(noeud,arete[1])]) cpt_noeuds += 1; ## construire la matrice d'adjacence de G_k noeuds = list(set([arete for tup in liste_aretes_G_k for arete in tup])) matE_G_k = pd.DataFrame( index = noeuds, columns = noeuds); for arc in liste_aretes_G_k: matE_G_k.loc[ arc[0] ][arc[1]] = 1; matE_G_k.loc[ arc[1] ][arc[0]] = 1; matE_G_k.fillna(0, inplace=True); matE_corr_G_k, dico_probas = matrice_correl_G_k(matE_G_k, p_correl, correl_seuil); return matE_G_k, liste_aretes_G_k, dico_probas;
def algo_Welsh_Powel(matA): """ but: coloration des sommets du graphe tel que * 2 arcs adjacents ont des couleurs differentes particularite de existe_node_adj_in_liste_Node_NonAdj: recupere les noeuds n'etant pas adjacents a un "noeud defini" dans une liste "ma_liste" ensuite cherche les noeuds dans "ma_liste" etant adjacent entre eux et les inserer dans "ma_liste_bis" si il existe des noeuds dans "ma_liste_bis" alors un de ces noeuds a la meme couleur que le "noeud defini" et les autres autres noeuds auront des numero de couleurs differentes """ liste_noeuds = matA.columns.tolist() liste_arcs_ = fct_aux.liste_arcs(matA) # 1 liste des noeuds par ordre decroissant # degre de chaque noeud dico_degre_noeud = dict() for noeud in liste_noeuds: dico_degre_noeud[noeud] = fct_aux.degre_noeud(liste_arcs_, noeud) # classer liste_noeuds par ordre decroissant sorted_tuple_ordre_decroissant = sorted(dico_degre_noeud.items(), key=lambda x: x[1], reverse=True) liste_noeuds_decroissant = list() for tuple_ in sorted_tuple_ordre_decroissant: liste_noeuds_decroissant.append(tuple_[0]) # 2 attribution de couleurs aux noeuds color = 0 dico_color_noeud = dict() liste_noeuds_decroissant_copy = liste_noeuds_decroissant.copy() for noeud in liste_noeuds_decroissant_copy: # initialisation node color s dico_color_noeud[noeud] = None while liste_noeuds_decroissant_copy: noeud = liste_noeuds_decroissant_copy.pop() if dico_color_noeud[noeud] == None: dico_color_noeud[noeud] = color liste_node_nonAdj = liste_node_NonAdj_NonColorie( noeud, matA, dico_color_noeud) liste_nodes_u_v = existe_node_adj_in_liste_Node_NonAdj( list(liste_node_nonAdj), liste_arcs_) if len(liste_nodes_u_v) != 0: nodeAdjANoeud = liste_node_nonAdj.intersection(liste_nodes_u_v) for node_u in nodeAdjANoeud: dico_color_noeud[node_u] = color for u in liste_nodes_u_v: dico_color_noeud[u] = color color += 1 else: for noeud_nonAdj in liste_node_nonAdj: dico_color_noeud[noeud_nonAdj] = color color += 1 return liste_noeuds_decroissant, dico_color_noeud
def generer_matrice_with_mean_degre(dim_mat, degre_moy): """ but: """ mat_ = np.random.randint(0, 1, (dim_mat, dim_mat)) proba = degre_moy / mat_.shape[0] ind_diagonale = 0 cpt_row = 0 index_row = 0 for row in mat_: degre_row_max = math.floor(proba * mat_.shape[0]) - sum(x == 1 for x in row) index_row = None #print("*** row: ",row, " ind_diagonale: ",ind_diagonale) for nbre_case1 in range(0, degre_row_max): ind_items0 = [i[0] for i in enumerate(row) if i[1] == 0] #print("cpt_row: ", cpt_row," degre_row_max: ",degre_row_max,\ # " nbre_case1: ",nbre_case1," ind_items0: ",ind_items0,\ # " index_row: ",index_row," ind_diagonale: ",ind_diagonale) if len(ind_items0) != 0: index_row = random.choice(ind_items0) row[index_row] = 1 mat_[:, cpt_row][index_row] = 1 ind_diagonale += 1 cpt_row += 1 #print("***(apres) row: ",row) np.fill_diagonal(mat_, 0) noeuds = [str(i) for i in range(mat_.shape[0])] mat = pd.DataFrame(mat_, index=noeuds, columns=noeuds) aretes = fct_aux.liste_arcs(mat) # graphes connexes mat = graphe_connexe(mat, aretes) matA = orienter_graphe(mat, noeuds, aretes) G_ = nx.Graph(fct_aux.liste_arcs(matA)) matA.index.rename("nodes", inplace=True) matA.loc["nodes"] = [str(i) for i in matA.index] # print("matA is_directed = ", nx.is_directed_acyclic_graph(G_)) return matA
def comparaison_aretes_G_k_LG_Debug_old(): # A EFFACER aretes_G_k = fct_aux.liste_arcs(matriceE_particuliere()); matE_G_2,aretes_G_k,dico = G_k(matriceE_particuliere(), 2, 0.5, 0.8) aretes_LG = []; line_cover = [{'H','E','I'},{'L','J','I'},{'K','L'},{'F','J'},{'F','E','A','D'},\ {'C','A','B'},{'C','G'},{'D','H','G'}]; for cliq in line_cover: aretes_LG.extend(list(it.combinations(cliq,2))); print("LG={}".format(aretes_LG)); print("G_k={} , LG = {}".format(len(aretes_G_k), len(aretes_LG))) print("aretes_diff G_k et LG = {}".format(comparaison_aretes_G_k_LG(aretes_G_k, aretes_LG)));
def mise_a_jour_voisinage_sommets(dico_gamma_noeud, cliques, matE_k_alpha, aretes_matE_k_alpha): """ supprimer les aretes de C1 et C2 en changeant le voisinage des sommets. """ aretes_supp = [] for C in cliques: if C is not None: aretes = set(it.combinations(C, 2)) aretes_supp.extend(aretes) for arete in aretes: matE_k_alpha.loc[arete[0], arete[1]] = 0 matE_k_alpha.loc[arete[1], arete[0]] = 0 aretes_matE_k_alpha = fct_aux.liste_arcs(matE_k_alpha) dico_gamma_noeud = fct_aux.gamma_noeud(matE_k_alpha, aretes_matE_k_alpha) return dico_gamma_noeud, list(aretes_matE_k_alpha)
def graphe_connexe(mat_, aretes): # aretes = fct_aux.liste_arcs(mat_); G = nx.Graph(aretes) # print("mat_ is_DAG = ", nx.is_directed(G), " is_connected = ",nx.is_connected(G)) if nx.is_connected(G): return mat_ else: components = list(nx.connected_components(G)) for ind_i in range(len(components) - 1): for ind_j in range(ind_i, len(components)): node_1 = random.choice(list(components[ind_i])) node_2 = random.choice(list(components[ind_j])) mat_.loc[node_1][node_2] = 1 mat_.loc[node_2][node_1] = 1 G_ = nx.Graph(fct_aux.liste_arcs(mat_)) # print("mat_ is_connected = ", nx.is_connected(G_)) return mat_ pass
def G0_k(matE, k_max): """ ajoute des aretes entre les noeuds de degre = 2 ===> k = 0, puis sur ces aretes crees on ajoute 3 noeuds (les noeuds sont adjacents entre eux) """ liste_aretes = fct_aux.liste_arcs(matE) cpt_noeuds = len(matE.columns.tolist()) for k in range(0, k_max + 1): dico_gamma_noeud = gamma_noeud(liste_aretes) set_noeuds_degre_2 = degre_noeuds_k(dico_gamma_noeud, 2) aretes = list(it.combinations(set_noeuds_degre_2, 2)) if k == k_max: liste_aretes.extend(aretes) else: for arete in aretes: noeud = str(cpt_noeuds + 1) liste_aretes.extend([(arete[0], noeud), (noeud, arete[1])]) cpt_noeuds += 1 pass return liste_aretes pass
def comparaison_matEReel_matEPredit(matEReel, metriques, path_root, file_matE_reel): """ but: comparer les aretes differents entre matE reelles et matE predit. en un mot, compter le nombre d'aretes differentes. path_root = arg_chemins["chemin_equipements"] """ dico_metrique = dict() for metrique in metriques: if matEReel.empty: matEReel = pd.read_csv(path_root + file_matE_reel + ".csv", index_col="Unnamed: 0") edges_reel = fct_aux.liste_arcs(matEReel) dico = json.load( open(path_root + "seuil_aretes_LG_" + metrique + ".json", "r")) dico_result = dict() for seuil, aretes_LG_predit in dico.items(): dico = dict() nbre_edges_diff = np.nan edges_diff = [] aretes_LG_predit = [(arete[0], arete[1]) for arete in aretes_LG_predit] nbre_edges_diff, edges_diff = simu50_PARALL.distance_hamming( edges_reel, aretes_LG_predit) dico["aretes_communes"] = len( set(edges_reel).intersection(set(aretes_LG_predit))) dico["aretes_predites"] = len(aretes_LG_predit) dico["aretes_reel"] = len(edges_reel) dico["aretes_differentes"] = nbre_edges_diff dico_result[seuil] = dico bool_seuil, dico_adj = adjacency(aretes_LG_predit, seuil) print("dico_result = ", dico_result) dico_metrique[metrique] = dico_result return dico_metrique pass
def simulation_seuil(args, seuil): """ """ # print("****seuil = {}, chemin_distrib={}".format(seuil, args["chemin_distrib"])); # fichier de tracking or debug headers_df = ["G_cpt","seuil","num_graphe","nbre_aretes_matE_s","nbre_aretes_LG",\ "nbre_aretes_diff_matE_s_LG","dist_line","liste_aretes_diff_matE_s_LG","nbre_aretes_diff_matE_LG","hamming",\ "liste_aretes_diff_matE_LG","C","som_cout_min","noeuds_corriges", "min_hamming",\ "mean_hamming","max_hamming","ecart_type","max_cout","max_permutation",\ "dico_som_min_permutations", "dico_arc_sommet", "ordre_noeuds_traites","C_old",\ "faux_pos_seuil","faux_pos_apres_correction", "faux_neg_seuil",\ "faux_neg_apres_correction" ] df_debug_s = pd.DataFrame( columns = headers_df); G_s = "G_"+str(seuil)+"_"+str(args["num_graphe"]); # initialisation variables moy_distline = 0; moy_hamming = 0; sum_distline = 0; sum_hamming = 0; correl_dl_dh = 0; faux_pos_correct, faux_neg_correct, faux_pos_seuil, faux_neg_seuil = list(),list(),list(),list(); # application du seuil # print("(**) M_C={}, matE={}".format(args["M_C"].columns.tolist(), args["matE"].columns.tolist())) matE_s, faux_pos_seuil, faux_neg_seuil = matrice_binaire_seuil(args["M_C"].copy(), \ args["matE"].copy(), seuil); # print("MC = \n{}, matE_s={}\n".format(args["M_C"], matE_s)); aretes_matE_s = len(fct_aux.liste_arcs(matE_s)); try: dico_permutation_cliq = dict(); #algo corrigeant tous les noeuds a -1 # print("1"); args["correl_seuil"] = seuil; dico_permutation_cliq = \ decouvClique.decouverte_cliques(matE_s, args["dico_arc_sommet"], \ args["seuil_U"], args["epsilon"], \ args["chemin_datasets"], args["chemin_matrices"],\ args["ascendant_1"], args["simulation"],\ args["dico_proba_cases"],\ args); # print("2"); # Debut selection de la permutation de noeuds dont la distance hamming est la plus petite dico_sol = dict() dico_sol = simu50.best_permutation(dico_permutation_cliq, args["matE"], matE_s); # FIN selection de la permutation de noeuds dont la distance hamming est la plus petite dico_som_min_permutations = dict(); for l_noeuds_1, values in dico_permutation_cliq.items(): if values[6] not in dico_som_min_permutations.keys(): dico_som_min_permutations[values[6]] = [l_noeuds_1] else: dico_som_min_permutations[values[6]].append(l_noeuds_1); faux_pos_correct, faux_neg_correct = calculer_faux_pos_neg_correction(\ dico_sol["aretes_LG"],args["matE"]); #--- ajouter le debug par seuil ---> DEBUT cpt_s = args["occurence_seuil"]; df_debug_s.loc[int(cpt_s)] = [G_s, seuil, args["num_graphe"],\ dico_sol["nbre_aretes_matE"], \ dico_sol["nbre_aretes_LG"], dico_sol["liste_aretes_diff_matE_k_alpha_LG"],\ dico_sol["dist_line"], dico_sol["liste_aretes_diff_matE_k_alpha_LG"], \ dico_sol["nbre_aretes_diff_matE_LG"], dico_sol["hamming"],\ dico_sol["liste_aretes_diff_matE_LG"],\ dico_sol["C"], dico_sol["som_cout_min"], \ dico_sol["noeuds_corriges"], \ dico_sol["min_hamming"],dico_sol["mean_hamming"], \ dico_sol["max_hamming"],dico_sol["ecart_type"],\ dico_sol["max_cout"], dico_sol["max_permutation"],\ dico_som_min_permutations, args["dico_arc_sommet"],\ dico_sol["ordre_noeuds_traites"], dico_sol["C_old"],\ faux_pos_seuil,faux_pos_correct, faux_neg_seuil,faux_neg_correct] #--- ajouter le debug par seuil ---> FIN sum_distline += dico_sol["dist_line"] # dico_sol["dist_line"]/dico_sol["nbre_aretes_matE_k_alpha"] sum_hamming += dico_sol["hamming"] # dico_sol["hamming"]/dico_sol["nbre_aretes_matE"] print("{},s={},num_graphe={}, noeuds_1={},fct_cout={} --> TERMINE".\ format(G_s, seuil, args["num_graphe"], args["mode_select_noeuds_1"], args["coef_fct_cout"][2])) except Exception as e: print("####### EmptyDataError fct_cout={} noeuds_1={}, s={}, num_graphe={}, {} : e = {} #######".format( args["coef_fct_cout"][2],arg_params["mode_select_noeuds_1"], \ seuil, args["num_graphe"], G_s, e)); # a ajouter le debug seuil cpt_s = args["occurence_seuil"] df_debug_s[cpt_s] = [G_s, seuil, args["num_graphe"],\ "error", "error","error","error", "error",\ "error", "error","error","error", "error", \ "error", "error","error","error", "error",\ "error", "error","error", args["dico_arc_sommet"],"error", \ "error"] moy_distline = sum_distline; moy_hamming = sum_hamming; if moy_hamming == 0 and moy_distline == 0: correl_dl_dh = 1 else: correl_dl_dh = abs(moy_hamming - moy_distline)/max(moy_hamming, moy_distline) # ecrire dans un fichier pouvant etre lu pendant qu'il continue d'etre ecrit f = open(args["chemin_distrib"]+"distribution_moyDistLine_moyHamming_s_"+str(seuil)+".txt","a") f.write(G_s+";"+str(seuil)+";"+str(moy_distline)+";"+str(moy_hamming)+";"+str(aretes_matE_s)+\ ";"+str(correl_dl_dh)+";"+str(len(faux_pos_seuil))+";"+str(len(faux_neg_seuil))+";"+\ str(len(faux_pos_correct))+";"+str(len(faux_neg_correct))+"\n") f.close(); save_df(df_debug_s, args["chemin_distrib"], seuil, headers_df)
def simulation_G0_k(matE_G0_k, k, alpha_min, identifiant, arg_params): """ but: tester la modification de correlation sur le graphe particulier G0_k selon les methodes suivantes * le degre min avec permutation * le cout min avec permutation * aleatoire N = 100 matE_G0_k : k etant la profondeur du graphe G0, matE_G0_k est une MATRICE D'ADJACENCE de G0_k arg_params = {"number_permutations_nodes_1": 10(30, 100), "biais": True, "algoGreedy":False, \ "mode_select_noeuds_1":"coutMin" or "degreMin" or "aleatoire", "number_items_pi1_pi2" = 1,\ "methode_deleted_add_edges": 0, "SEUIL_PROBA": 0.8, \ "proba_seuil": proba_seuil, \ "coef_fct_cout":(exposant, facteur_multiplicatif)} """ # fichier de tracking or debug headers_df = ["G_cpt", "k", "alpha", "nbre_aretes_matE", "nbre_aretes_matE_k_alpha", "deleted_edges",\ "nbre_aretes_L_G", "nbre_aretes_diff_matE_k_alpha_LG",\ "dist_line", "aretes_diff_matE_k_alpha_LG",\ "nbre_aretes_diff_matE_LG", "hamming", "aretes_diff_matE_LG",\ "C","som_cout_min","noeuds_corriges",\ "min_hamming","mean_hamming","max_hamming","ecart_type",\ "max_cout","max_permutation",\ "dico_som_min_permutations","dico_dual_arc_sommet","ordre_noeuds_traites","C_old"] # creation du repertoire de calcul selon methode path_distr_chemin = str(arg_params["mode_select_noeuds_1"])+"_particulier/"+"data_p_"+\ str(arg_params["proba_seuil"])+"/distribution/" path_distr = Path(path_distr_chemin) path_distr.mkdir(parents=True, exist_ok=True) df_debug = pd.DataFrame(columns=headers_df) cpt_df_debug = 0 G_cpt = "G_" + str(k) + "_" + str(alpha_min) # creation repertoire contenant dataset et matrices # exple rep = methode_correction_nodes_1/data_p_XX/G_10 avec 10 = cpt_graphe_genere path = Path(str(arg_params["mode_select_noeuds_1"])+"_particulier/"+\ "data_p_"+str(arg_params["proba_seuil"])+"/"+G_cpt+'/datasets/') path.mkdir(parents=True, exist_ok=True) path = Path(str(arg_params["mode_select_noeuds_1"])+"_particulier/"+\ "data_p_"+str(arg_params["proba_seuil"])+"/"+G_cpt+'/matrices/') path.mkdir(parents=True, exist_ok=True) # initialisation variables aretes_matE = len(fct_aux.liste_arcs(matE_G0_k)) moy_distline = 0 moy_hamming = 0 sum_distline = 0 sum_hamming = 0 correl_dl_dh = 0 # chemin_datasets = str(arg_params["mode_select_noeuds_1"])+"/"+\ # "data_p_"+str(arg_params["proba_seuil"])+"/"+G_cpt+"/datasets/"; # chemin_matrices = str(arg_params["mode_select_noeuds_1"])+"/"+\ # "data_p_"+str(arg_params["proba_seuil"])+"/"+G_cpt+"/matrices/"; #### A EFFACER SI CA MARCHE try: # modification k correlations # TODO modifier modif_k_cases tel que deleted_edge ne se repete pas ==> UN PEU COMPLIQUE car process independant matE_k_alpha, dico_deleted_add_edges = simu.modif_k_cases(matE_G0_k.copy(), k, \ arg_params["methode_delete_add_edges"], arg_params["proba_seuil"]) deleted_edges = list(dico_deleted_add_edges.values()) dico_proba_cases = simu.ajouter_proba_matE(matE_k_alpha, dico_deleted_add_edges, arg_params["SEUIL_PROBA"]) # cliques decoulant de l'algo de couverture liste_cliques = list() dico_cliq = dict() ordre_noeuds_traites = [] # car liste_cliques = [] for noeud in matE_k_alpha.columns.tolist(): dico_cliq[noeud] = -1 aretes_matE_alpha = fct_aux.liste_arcs(matE_k_alpha) dico_gamma_noeud = fct_aux.gamma_noeud(matE_k_alpha, aretes_matE_alpha) # algo de couverture selon methodes (arg_params["mode_select_noeuds_1"]) dico_permutations = dict() dico_permutations = decouvClique.solution_methode_nodes_1(dico_gamma_noeud,\ liste_cliques, aretes_matE_alpha, ordre_noeuds_traites, \ dico_cliq, dico_proba_cases, arg_params) # Debut selection de la permutation de noeuds dont la distance hamming est la plus petite dico_sol = dict() dico_sol = simu.best_permutation(dico_permutations, matE_G0_k, matE_k_alpha) # FIN selection de la permutation de noeuds dont la distance hamming est la plus petite # moyenner dist_line et hamming pour k aretes supprimes moy_distline = dico_sol["dist_line"] moy_hamming = dico_sol["hamming"] if moy_hamming == 0 and moy_distline == 0: correl_dl_dh = 1 else: correl_dl_dh = abs(moy_hamming - moy_distline) / max( moy_hamming, moy_distline) #print("ici") # ecrire dans un fichier pouvant etre lu pendant qu'il continue d'etre ecrit f = open( path_distr_chemin + "distribution_moyDistLine_moyHamming_k_" + str(k) + ".txt", "a") f.write(G_cpt+";"+str(k)+";"+str(moy_distline)+";"+str(moy_hamming)+";"+str(aretes_matE)+\ ";"+str(correl_dl_dh)+"\n") f.close() # pour debug, log, ..... dico_som_min_permutations = dict() for l_noeuds_1, values in dico_permutations.items(): if values[6] not in dico_som_min_permutations.keys(): dico_som_min_permutations[values[6]] = [l_noeuds_1] else: dico_som_min_permutations[values[6]].append(l_noeuds_1) dico_dual_arc_sommet = mesures.nommage_arcs(matE_G0_k) df_debug.loc[len(df_debug.index)] = [G_cpt, k, alpha_min, \ dico_sol["nbre_aretes_matE"], dico_sol["nbre_aretes_matE_k_alpha"], \ deleted_edges,\ dico_sol["nbre_aretes_LG"], dico_sol["nbre_aretes_diff_matE_k_alpha_LG"],\ dico_sol["dist_line"], dico_sol["liste_aretes_diff_matE_k_alpha_LG"], \ dico_sol["nbre_aretes_diff_matE_LG"], dico_sol["hamming"],\ dico_sol["liste_aretes_diff_matE_LG"],\ dico_sol["C"], dico_sol["som_cout_min"], \ dico_sol["noeuds_corriges"], \ dico_sol["min_hamming"],dico_sol["mean_hamming"], \ dico_sol["max_hamming"],dico_sol["ecart_type"],\ dico_sol["max_cout"], dico_sol["max_permutation"],\ dico_som_min_permutations, dico_dual_arc_sommet,\ dico_sol["ordre_noeuds_traites"], dico_sol["C_old"]] if cpt_df_debug % 100 == 0: simu.save_df(df_debug, path_distr_chemin, identifiant, headers_df) df_debug = pd.DataFrame(columns=headers_df) print("save %s fois" % cpt_df_debug) except Exception as e: print("####### EmptyDataError ", G_cpt, ": e = ", e, " ####### ") df_debug.loc[len(df_debug.index)] = [G_cpt, k, alpha_min, \ "error", "error", \ "error",\ "error","error" ,\ "error","error" , \ "error","error" ,\ "error",\ "error", "error", \ "error", \ "error","error", "error",\ "error",\ "error","error" ,\ "error","error","error", "error"] pass
def algo_decomposition_en_cliques(matE_k_alpha, dico_sommet_arete, seuil_U=10, epsilon=0.75, chemin_datasets="", chemin_matrices="", ascendant_1=True, simulation=True, dico_proba_cases=dict(), dico_parametres_new=dict()): """ obtenir la decomposition en cliques des sommets du graphe matE_k_alpha un sommet doit appartenir au plus a 2 cliques. une arete doit appartenir a 1 clique. chaque sommet a 5 etats {0,1,2,3,-1} """ #initialisation cliq et ver et C etats_sommets = dict() dico_ver = dict() for sommet in matE_k_alpha.columns: # nbre de noeuds dans le graphe etats_sommets[sommet] = 0 dico_ver[sommet] = 0 # fusion des datasets liste_grandeurs = [] #fct_aux.liste_grandeurs(chemin_datasets) arguments_MAJ = { "dico_sommet_arete": dico_sommet_arete, "df_fusion": dict(), "seuil_U": seuil_U, "epsilon": epsilon, "chemin_dataset": chemin_datasets, "simulation": simulation, "grandeurs": liste_grandeurs } # copy E0 <- Ec aretes_matE_k_alpha = fct_aux.liste_arcs(matE_k_alpha) dico_gamma_noeud = fct_aux.gamma_noeud( matE_k_alpha, aretes_matE_k_alpha) # {"2":[3,{"1","3","4"}],....} if is_isomorphe_graphe_double(aretes_matE_k_alpha): """ QU'EST CE un GRAPHE DOUBLE : graphe avec 2 couvertures. """ #print("le traiter avec Verif_correl ou ORACLE") return { "C": list(), "etats_sommets": etats_sommets, "aretes_restantes": aretes_matE_k_alpha, "ordre_noeuds_traites": list(), "sommets_par_cliqs": dict() } else: dico_couverture = couverture_en_cliques(etats_sommets, dico_gamma_noeud, aretes_matE_k_alpha, matE_k_alpha.copy(), dico_ver, arguments_MAJ) return dico_couverture
def simulation_p_correl_k(matE_LG, matA_GR, dico_sommet_arete, chemin_matrices, chemin_datasets, mode, p_correl, k_erreur, num_graph, rep_base, dico_parametres_new): """ executer les algos de couverture et de correction sur des graphes dans lesquels on a supprime (p_correl = 1) k aretes alpha (<alpha_max) fois. """ path_distr = rep_base+"/../"+"distribution/"; path = Path(path_distr); path.mkdir(parents=True, exist_ok=True) print("path_distr = {}".format(path_distr)) aretes_matE = fct_aux.liste_arcs(matE_LG); list_returns = list(); for alpha in range(dico_parametres_new["alpha_max"]): num_graph_alpha = num_graph +"_"+str(alpha) print("num_graph={}, k = {}, alpha = {} ==> debut".format( num_graph, k_erreur, alpha)) start = time.time(); try: matE_k_alpha = None; dico_proba_cases = dict(); matE_k_alpha, \ dico_deleted_add_edges = \ fct_aux.modif_k_cases( matE_LG.copy(), k_erreur, dico_parametres_new["methode_delete_add_edges"], p_correl) dico_proba_cases = fct_aux.ajouter_proba_matE( matE_k_alpha, dico_deleted_add_edges, dico_parametres_new["loi_stats"], p_correl, dico_parametres_new["correl_seuil"]) matE_k_alpha.to_csv(chemin_matrices\ +"matE_"+str(k_erreur)+"_"+str(alpha)+".csv") # algorithme de couverture # ajouter les aretes restantes trop nombreuses ==> OK # Verifier algo de couverture ==> OK print("1") dico_couverture = algo_couv.algo_decomposition_en_cliques( matE_k_alpha, dico_sommet_arete, seuil_U=10, epsilon=0.75, chemin_datasets=chemin_datasets, chemin_matrices=chemin_matrices, ascendant_1=True, simulation=True, dico_proba_cases=dico_proba_cases, dico_parametres_new=dico_parametres_new ) dico_couverture["k_erreur"] = k_erreur; dico_couverture["C_old"] = dico_couverture["C"].copy(); dico_couverture["sommets_a_corriger"] = \ [k for k, v in dico_couverture["etats_sommets"].items() if v == -1]; dico_couverture["nbre_sommets_a_corriger"] = \ len(dico_couverture["sommets_a_corriger"]); # algorithme correction pour k = 1 print("2") dico_correction = dico_couverture; dico_sommets_corriges = dict(); if -1 in dico_couverture['etats_sommets'].values(): aretes_matE_k_alpha = fct_aux.liste_arcs(matE_k_alpha); dico_correction["C"] = dico_correction["C"] \ + dico_correction['aretes_restantes']; dico_correction["C"] = list(map(set, dico_correction["C"])); dico_correction["sommets_par_cliqs_avec_aretes"] = \ fct_aux.couverture_par_sommets( sommets_matE = list(dico_correction["etats_sommets"].keys()), C = dico_correction["C"]); dico_correction["aretes_matE"] = aretes_matE; dico_correction["aretes_Ec"] = aretes_matE_k_alpha; dico_correction["dico_gamma_sommets"] = fct_aux.gamma_noeud( matE_k_alpha, aretes_matE_k_alpha); dico_correction, dico_sommets_corriges = \ algo_corr.correction_cliques( dico_correction, dico_parametres_new); elif -1 not in dico_couverture['etats_sommets'].values() and \ len(dico_correction['aretes_restantes']) > 0: dico_correction["C"] = \ dico_correction["C"] \ + dico_correction['aretes_restantes']; dico_correction["sommets_par_cliqs_avec_aretes"] = \ fct_aux.couverture_par_sommets( sommets_matE = list(dico_correction["etats_sommets"].keys()), C = dico_correction["C"]); elif -1 not in dico_couverture['etats_sommets'].values() and \ len(dico_correction['aretes_restantes']) == 0: dico_correction["sommets_par_cliqs_avec_aretes"] = \ fct_aux.couverture_par_sommets( sommets_matE = list(dico_correction["etats_sommets"].keys()), C = dico_correction["C"]); # calcul DH et DC print("3") aretes_cliques = fct_aux.determiner_aretes_cliques(dico_correction["C"]); aretes_matE_k_alpha = fct_aux.liste_arcs(matE_k_alpha); aretes_matE_LG = fct_aux.liste_arcs(matE_LG); print("4") dc, set_dc = calculer_distance_hamming( aretes_cliques, aretes_matE_k_alpha); dh, set_dh = calculer_distance_hamming( aretes_cliques, aretes_matE_LG); X1 = abs(dc - k_erreur); correl_dc_dh = abs(dh - X1)/(k_erreur + dc) if k_erreur+dc != 0 else -1; print("k={}, ".format(k_erreur)\ +"moy_dc={}, ".format(dc) \ +"moy_dh={}, ".format(dh) \ +"moy_dc-k={}, ".format(X1) \ +"moy_dc+k={}, ".format( k_erreur+dc ) \ +"corr={} ".format( round(correl_dc_dh,2) ) ) # sauvegarde dans un fichier distribution sauvegarder_execution_k_alpha(path_distr, num_graph, k_erreur, alpha, dc, dh, len(aretes_matE_LG), correl_dc_dh, start) print("5") # voisins des sommets des aretes supprimees/ajoutees et leurs etats dico_voisins_etats_supp,\ dico_voisins_etats_ajout = \ determiner_voisins_etats_aretes_modifiees( matE_k_alpha, dico_deleted_add_edges, dico_couverture["etats_sommets"] ) print("6") # sommets a -1 etant les voisins des sommets de l arete modifies sommets_1_vois, \ sommets_1_non_vois = determiner_sommets_1_avec_conditions( dico_correction["etats_sommets"], matE_k_alpha, dico_correction["sommets_par_cliqs_avec_aretes"], dico_deleted_add_edges ); print("7") # sauvegarde les parametres de l'execution num_graph_alpha = num_graph +"_"+str(alpha) list_returns.append(sauvegarder_parametres_execution( num_graph_alpha, k_erreur, alpha, dc, dh, time.time() - start, len(aretes_matE_LG), dico_deleted_add_edges, dico_correction, dico_voisins_etats_supp, dico_voisins_etats_ajout, sommets_1_vois, sommets_1_non_vois)) print("8") except Exception as e : print("####### EmptyDataError {}".format(dico_parametres_new["coef_fct_cout"][2]) \ +" {},".format(dico_parametres_new["mode_select_noeuds_1"]) \ +" seuil={}".format(dico_parametres_new["correl_seuil"]) \ +" p={}".format(p_correl) \ +" k={}".format(k_erreur) \ +" num_graph={}".format(num_graph) \ +" alpha={}".format(alpha) \ +" e={}".format(e) ) return list_returns; pass ############################################################################### # simulation graphe avec des k=1 aretes supprimees ---> fin ###############################################################################
print("erreur_verif_clique_sommet = {}".format(cpt_error_verif_clique_sommet)); ### test partition sur graphe double couverture if bool_error_partition : graphes_iter = disc_gr_sim.graphe_double_couverture( chemin_dataset, chemin_matrice, nbre_ts, effet_joule); for nom_graphe in ["triangle", "etoile", "marteau", "losange", "carre"]: try : matE_LG, mat_GR, dico_arcs_sommets = next(graphes_iter) nb_aretes_GR = fct_aux.liste_arcs(mat_GR); aretes = fct_aux.liste_aretes(matE_LG); gamma_noeuds = fct_aux.gamma(matE_LG); etat_noeuds = fct_aux.etat(matE_LG); noeud = selection_noeud(etat_noeuds, critere1=0, critere2=3); gamma_noeud = set(gamma_noeuds[noeud]); bool_clique, bool_coherent, C1, C2 = \ partitionner(noeud, gamma_noeud, dico_arcs_sommets, aretes, matE_LG, # gamma_noeuds,
def genererMatriceA_nbreAreteMinMax(dimMat, nb_lien=(2, 5)): """ dimMat: nombre de sommets dans le graphe nb_lien: le nbre d'aretes min et max TODO verifier sil est un graphe connexe """ liste_noeuds = [str(i) for i in range(dimMat)] matA = pd.DataFrame(columns=liste_noeuds, index=liste_noeuds) # generation graphe avec nbre de voisins min et max mat_ = np.random.randint(0, 2, (dimMat, dimMat)) mat_ = np.tril(mat_, k=-1) for i in range(dimMat): if i <= int(dimMat / 2): l = list(mat_[i + 1:, i]) while l.count(1) > nb_lien[-1]: indices = [i for i, x in enumerate(l) if x == 1] rand_index = indices[rd.randint(0, len(indices) - 1)] l[rand_index] = 0 while l.count(1) < nb_lien[0]: indices = [i for i, x in enumerate(l) if x == 0] rand_index = indices[rd.randint(0, len(indices) - 1)] l[rand_index] = 1 mat_[i + 1:, i] = np.asarray(l) else: l = list(mat_[i, :i]) while l.count(1) > nb_lien[-1]: indices = [i for i, x in enumerate(l) if x == 1] rand_index = indices[rd.randint(0, len(indices) - 1)] l[rand_index] = 0 while l.count(1) < nb_lien[0]: indices = [i for i, x in enumerate(l) if x == 0] rand_index = indices[rd.randint(0, len(indices) - 1)] l[rand_index] = 1 mat_[i, :i] = np.asarray(l) for i in range(1, dimMat): for j in range(0, i): mat_[j, i] = mat_[i, j] mat = pd.DataFrame(mat_) mat.columns = liste_noeuds mat.index = liste_noeuds # orientation des aretes dico = dict() for noeud in liste_noeuds: dico[noeud] = 0 liste_arcs_ = fct_aux.liste_arcs(mat) liste_noeuds_decroissant, dico_color_noeud = algo_Welsh_Powel(mat) liste_noeuds_decroissant.reverse() for noeud in liste_noeuds_decroissant: liste_w = fct_aux.voisins(liste_arcs_, noeud) for w in liste_w: if dico_color_noeud[noeud] < dico_color_noeud[w]: matA.loc[noeud][w] = 1 matA.fillna(0, inplace=True) matA.index.rename("nodes", inplace=True) matA.loc["nodes"] = [str(i) for i in matA.index] return matA
def genererMesures_descendant(matA, dico_dual_arc_sommet, grandeur, taille=3, effet_joule=0.2): ''' tester bon propagation du flux de la source aux puits taille : la dimension de chaque serie de mesures = 3000 effet_joule: pourcentage de perte due a la resistance des cables. ici correspond a la difference entre l'entre et la sortie du noeud dico_pred : dictionnaire des predecesseurs avec cle : le noeud et valeurs: ses predecesseurs dico_succ : dictionnaire des successeurs avec cle : le noeud et valeurs: ses successeurs liste_grandeurs_sommables : liste des grandeurs dont les valeurs instantanees peuvent etre sommees (sum_entrant = sum_sortant => conservation de flux) intervalle_grandeur : dictionnaire contenant les valeurs inf et sup de chaque grandeur dico_grandeur : dictionnaire contenant les series de mesures pour chaque noeud( cle) liste_feuille : liste des noeuds n'ayant aucuns successeurs list_succ : la liste des successeurs a un noeud liste_pourcentage = np.random.dirichlet(np.ones(nbre_pred),size=1)[0] : generation de nombre dont la somme est = a 1 et on recupere le 1er tableau ( [0] ) ''' dico_pred = liste_predecesseurs(matA) dico_succ = liste_successeurs(matA) liste_grandeurs_sommables = ["I12", "I23", "I31", "P", "S"] intervalle_grandeur = {"I12": (150, 200), "I23": (150, 200), "I31": (150, 200), "P": (33000, 62500),\ "U12": (220, 250), "U23": (220, 250), "U31": (220, 250), "S": (33000, 62500)} dico_grandeur = dict() dico_arc = dict() dico_grandeur_nom = dict() dico_arc_nom = dict() liste_cols = matA.columns.tolist() for noeud in liste_cols: if grandeur in liste_grandeurs_sommables: dico_grandeur[noeud] = np.zeros(taille) else: dico_grandeur[noeud] = np.ones(taille) # liste_arcs_ = liste_arcs(matA); liste_arcs_ = fct_aux.liste_arcs(mat=matA, oriented=True, val=1) for arc in liste_arcs_: if grandeur in liste_grandeurs_sommables: dico_arc[arc] = np.zeros(taille) else: dico_arc[arc] = np.ones(taille) #recherche des sources de ce graphe liste_source = list() for cle, val in dico_pred.items(): if len(val) == 0: liste_source.append(cle) ##print ("liste_source = ", liste_source) # generation de valeurs aux noeuds sources if len(liste_source) != 0: inf = intervalle_grandeur[grandeur][0] sup = intervalle_grandeur[grandeur][1] for source in liste_source: if grandeur in liste_grandeurs_sommables: dico_grandeur[ source] = dico_grandeur[source] + np.random.uniform( inf, sup, taille) else: dico_grandeur[ source] = dico_grandeur[source] * np.random.uniform( inf, sup, taille) # #print ("dico_grandeur = ", dico_grandeur) bool = True while bool: noeud_source = liste_source.pop( ) # retirer les elts de liste_feuilles comme une file list_succ = dico_succ[noeud_source] # #print(" noeud_source ",noeud_source, "list_succ = ", list_succ) if len(list_succ) == 0: ##print("noeud source ", noeud_source) ##print (" ON PASSE AU NOEUD FEUILLE SUIVANT ") pass else: nbre_succ = len(list_succ) cpt = 0 while len(list_succ) != 0: succ = list_succ.pop() if grandeur in liste_grandeurs_sommables: dico_grandeur[succ] += dico_grandeur[noeud_source] \ * (1/nbre_succ)*(1 - effet_joule) arc_ = (noeud_source, succ) \ if (noeud_source, succ) in dico_arc.keys() \ else (succ, noeud_source) dico_arc[arc_] += dico_grandeur[noeud_source] \ * (1/nbre_succ)*(1 - effet_joule) else: dico_grandeur[succ] = dico_grandeur[noeud_source] \ *( 1 - effet_joule/nbre_succ ) arc_ = (noeud_source, succ) \ if (noeud_source, succ) in dico_arc.keys() \ else (succ, noeud_source) dico_arc[arc_] = dico_grandeur[noeud_source] \ *( 1 - effet_joule/nbre_succ ) # #print ("dico_grandeur[", succ ,"] = ", dico_grandeur[succ]) liste_source.insert( 0, succ) # ajout de noeud successeur dans la queue de la file cpt += 1 if len(liste_source) == 0: bool = False for cle, serie in dico_grandeur.items(): nom_cle = cle + "_" + grandeur dico_grandeur_nom[nom_cle] = serie for arc, tuple_ in dico_dual_arc_sommet.items(): tuple_inv = (tuple_[1], tuple_[0]) if tuple_ in dico_arc.keys(): nom_cle = arc + "_" + grandeur dico_arc_nom[nom_cle] = dico_arc[tuple_] if tuple_inv in dico_arc.keys(): nom_cle = arc + "_" + grandeur dico_arc_nom[nom_cle] = dico_arc[tuple_inv] return dico_arc_nom
maxi = 0 maxi_key = None for k, v in dico.items(): if v > maxi: maxi = v maxi_key = k #print ("maxi_key = ", maxi_key) return dico if __name__ == "__main__": start = time.time() chemin_datasets = "data/datasets/" nbre_ts = 10 effet_joule = 0.1 matA = pd.read_csv("df_matA_generer.csv", index_col="nodes") # matA.set_index("nodes", inplace = True) # matA.index = [str(i) for i in matA.index] dico = fct_aux.nommage_arcs(matA) create_datasets(matA, dico, chemin_datasets, nbre_ts, effet_joule) #print("dico\n", dico) listeArcs = fct_aux.liste_arcs(matA, oriented=True) #print("listeArcs\n", listeArcs) matE = creation_matE(dico, listeArcs) #print(" matE = \n", matE) #print (time.time() - start)
def simulation_iourte(matE_G_k, dico_proba_cases, args): """ corriger le graphe G_k selon les paramatres args """ # fichier de tracking or debug headers_df = ["G_cpt", "nbre_aretes_G_k", "nbre_aretes_LG", \ "dist_line", "nbre_aretes_diff_G_k_LG", \ "aretes_diff_G_k_LG", "C", "len(C)", "som_cout_min",\ "noeuds_corriges", "ordre_noeuds_traites",\ "min_DL", "mean_DL", "max_DL", "ecart_type",\ "max_cout", "max_permutation",\ "dico_som_min_permutations"]; df_debug = pd.DataFrame( columns = headers_df); G_cpt = "G_"+str(args["k"]); # creation repertoire contenant distribution path_distr = Path(args["path_save"]+args["mode_select_noeuds_1"]+"_iourte/"); path_distr.mkdir(parents=True, exist_ok=True); path_save = args["path_save"]+args["mode_select_noeuds_1"]+"_iourte/"; # initialisation variables aretes_matE_G_k = fct_aux.liste_arcs(matE_G_k); try: ordre_noeuds_traites = [] # car liste_cliques = [] cliques = []; # car graphe iourte; dico_cliq = dict(); for noeud in matE_G_k.columns: dico_cliq[noeud] = -1 dico_gamma_noeud = fct_aux.gamma_noeud(matE_G_k, aretes_matE_G_k) # algo de correction selon methodes (arg_params["mode_select_noeuds_1"]) dico_permutations = dict(); dico_permutations = decouvClique.solution_methode_nodes_1(dico_gamma_noeud,\ cliques, aretes_matE_G_k, ordre_noeuds_traites, \ dico_cliq, dico_proba_cases, args); # Debut selection de la permutation de noeuds dont la distance hamming est la plus petite dico_sol = dict() dico_sol = best_permutation_iourte(dico_permutations, matE_G_k) # FIN selection de la permutation de noeuds dont la distance hamming est la plus petite # comparaison entre aretes_matE_G_k et aretes_LG cpt_aretes_G_k_notIn_LG = 0; #(en pourcentage) cpt_aretes_G_k_notIn_LG = comparaison_aretes_G_k_LG(aretes_matE_G_k, dico_sol["aretes_LG"]); # ecrire dans un fichier pouvant etre lu pendant qu'il continue d'etre ecrit f = open(path_save+"distribution_moyDistLine_G_k.txt","a") f.write(G_cpt+";"+str(args["k"])+";"+str(dico_sol["dist_line"])+";"\ +str(len(aretes_matE_G_k))+";"+str(cpt_aretes_G_k_notIn_LG)+"\n") f.close(); # pour debug, log, ..... dico_som_min_permutations = dict(); for l_noeuds_1, values in dico_permutations.items(): if values[6] not in dico_som_min_permutations.keys(): dico_som_min_permutations[values[6]] = [l_noeuds_1] else: dico_som_min_permutations[values[6]].append(l_noeuds_1) df_debug.loc[len(df_debug.index)] = [\ G_cpt, len(aretes_matE_G_k),\ dico_sol["nbre_aretes_LG"], dico_sol["dist_line"],\ dico_sol["nbre_aretes_diff_matE_G_k_LG"],\ dico_sol["aretes_diff_matE_G_k_LG"],\ dico_sol["C"], len(dico_sol["C"]), dico_sol["som_cout_min"],\ dico_sol["noeuds_corriges"], dico_sol["ordre_noeuds_traites"],\ dico_sol["min_line"], dico_sol["mean_line"],\ dico_sol["max_line"], dico_sol["ecart_type"],\ dico_sol["max_cout"], dico_sol["max_permutation"],\ dico_som_min_permutations] # CPT_DF_DEBUG += 1; if args["k"] % 100 == 0: simu50.save_df(df_debug, path_save, args["k_deep"], headers_df) df_debug = pd.DataFrame( columns = headers_df) print("save {} fois".format( args["k"] )) except Exception as e: print("####### EmptyDataError ", G_cpt, ": e = ", e," ####### "); df_debug.loc[len(df_debug.index)] = [G_cpt, len(aretes_matE_G_k), \ "error", "error", "error", "error", "error" ,\ "error", "error", "error", "error", "error",\ "error", "error", "error", "error","error", \ "error"]; simu50.save_df(df_debug, path_save, args["k_deep"], headers_df) pass
maxi = 0 maxi_key = None for k, v in dico.items(): if v > maxi: maxi = v maxi_key = k #print ("maxi_key = ", maxi_key) return dico if __name__ == "__main__" : start= time.time() chemin_datasets = "data/datasets/" nbre_ts = 10 effet_joule = 0.1 matA = pd.read_csv("df_matA_generer.csv", index_col="nodes") # matA.set_index("nodes", inplace = True) # matA.index = [str(i) for i in matA.index] dico = nommage_arcs( matA ) create_datasets(matA, dico, chemin_datasets, nbre_ts, effet_joule ) #print("dico\n", dico) listeArcs = fct_aux.liste_arcs(matA) #print("listeArcs\n", listeArcs) matE = creation_matE(dico, listeArcs) #print(" matE = \n", matE) #print (time.time() - start)
def best_permutation_iourte(dico_permutation_cliq, matE_G_k): """ selection de la permutation dont le cout et la distance de Hamming sont minimum dico_permutation = [ cle : une permutation (A,B,C,D): [C, Ec, dico_cliq, som_cout_min, noeuds_corriges] ] return dico_sol dico_sol = {"nbre_aretes_LG":,"aretes_LG":,"nbre_aretes_diff_matE_G_k_LG": ,\ "dist_line":,"aretes_diff_matE_G_k_LG":,"C":,"som_cout_min":,\ "noeuds_corriges":,"ordre_noeuds_traites":} """ dico_sol = dict(); som_dist_line = 0 aretes_matE_G_k = fct_aux.liste_arcs(matE_G_k); for tup_node_1, solutions in dico_permutation_cliq.items(): aretes_LG = None; aretes_LG = simu50.aretes_C(solutions[0]); dist_line = None; aretes_diff_matE_G_k_LG = None; dist_line, aretes_diff_matE_G_k_LG = \ simu50.distance_hamming( aretes_matE_G_k, aretes_LG ) som_cout = solutions[6]; som_dist_line += dist_line; # print(" hamming=", hamming," ordre:", tup_node_1," cout:",som_cout," LG:",len(liste_aretes_LG)," MAtE:",len(liste_aretes_matE)) if (dist_line, som_cout) not in dico_sol.keys(): dico_sol[(dist_line, som_cout)] = [{"nbre_aretes_LG": len(aretes_LG ), \ "aretes_LG": aretes_LG,\ "nbre_aretes_diff_matE_G_k_LG": len(aretes_diff_matE_G_k_LG),\ "dist_line": dist_line, \ "aretes_diff_matE_G_k_LG": aretes_diff_matE_G_k_LG, \ "C": solutions[0], \ "som_cout_min":solutions[6], \ "noeuds_corriges": tup_node_1 ,\ "ordre_noeuds_traites": solutions[5] }] else: dico_sol[(dist_line, som_cout)].append({"nbre_aretes_LG": len(aretes_LG ), \ "aretes_LG": aretes_LG,\ "nbre_aretes_diff_matE_G_k_LG": len(aretes_diff_matE_G_k_LG),\ "dist_line": dist_line, \ "aretes_diff_matE_G_k_alpha_LG": aretes_diff_matE_G_k_LG, \ "C": solutions[0], \ "som_cout_min":solutions[6], \ "noeuds_corriges": tup_node_1,\ "ordre_noeuds_traites": solutions[5] }) # selection du min et ajout mean, max # print("dico_sol.keys = ", dico_sol.keys()) print("len(dico_permutation_cliq) = ",len(dico_permutation_cliq)) min_keys_line_cout = min(dico_sol.keys()) max_keys_line_cout = max(dico_sol.keys()) mean_line = som_dist_line/len(dico_permutation_cliq) ## ecart type --> debut ecart_type = 0; som = 0; for tup_key, list_dico in dico_sol.items(): som += len(list_dico) * pow((tup_key[0] - mean_line),2) ecart_type = pow( som/len(dico_permutation_cliq), 1/2) ## ecart type --> fin print("----> min_line = ",min_keys_line_cout, " som_line = ", som_dist_line,\ " mean_line= ", mean_line," len_tupl = ", len(dico_permutation_cliq) ) dico_sol_min = dict(); dico_sol_min = { \ "nbre_aretes_LG": dico_sol[min_keys_line_cout][0]["nbre_aretes_LG"],\ "aretes_LG": dico_sol[min_keys_line_cout][0]["aretes_LG"],\ "nbre_aretes_diff_matE_G_k_LG": dico_sol[min_keys_line_cout][0]["nbre_aretes_diff_matE_G_k_LG"],\ "dist_line": dico_sol[min_keys_line_cout][0]["dist_line"],\ "aretes_diff_matE_G_k_LG": dico_sol[min_keys_line_cout][0]["aretes_diff_matE_G_k_LG"],\ "C": dico_sol[min_keys_line_cout][0]["C"], \ "som_cout_min": min_keys_line_cout[1],\ "noeuds_corriges": dico_sol[min_keys_line_cout][0]["noeuds_corriges"],\ "ordre_noeuds_traites": dico_sol[min_keys_line_cout][0]["ordre_noeuds_traites"],\ "min_line": dico_sol[min_keys_line_cout][0]["dist_line"],\ "mean_line": mean_line,\ "max_line": max_keys_line_cout[0],\ "max_cout": max_keys_line_cout[1],\ "max_permutation": dico_sol[max_keys_line_cout][0]["noeuds_corriges"], \ "ecart_type": ecart_type \ } return dico_sol_min;