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;
