def choix_sim_stockee(choix):
with open("graphe_complet_pondere_sim.pickle",
'rb') as fichier_graphe_complet:
mon_depickler_complet = pickle.Unpickler(fichier_graphe_complet)
graphe_complet = mon_depickler_complet.load()
for u, v in graphe_complet.edges():
elt1 = graphe_complet.nodes[u]["nom"]
elt2 = graphe_complet.nodes[v]["nom"]
if "4V9F_0_25_4" not in elt1 and "4V9F_0_25_4" not in elt2:
print(elt1)
print(elt2)
with open("graphes_extension/fichier_" + elt1 + ".pickle",
'rb') as fichier_graphe1:
mon_depickler_graphe1 = pickle.Unpickler(fichier_graphe1)
graphe1 = mon_depickler_graphe1.load()
with open("graphes_extension/fichier_" + elt2 + ".pickle",
'rb') as fichier_graphe2:
mon_depickler_graphe2 = pickle.Unpickler(
fichier_graphe2)
graphe2 = mon_depickler_graphe2.load()
with open("dico_graphe_epure_en_tout_test.pickle",
'rb') as fichier_commun:
mon_depickler_commun = pickle.Unpickler(
fichier_commun)
dico_graphe = mon_depickler_commun.load()
if choix == "non_cov_sans_motif":
if ("fichier_" + elt1, "fichier_" +
elt2) in dico_graphe.keys():
sim = calcul_sim_non_cov_sans_motif(
graphe1, graphe2,
dico_graphe[("fichier_" + elt1,
"fichier_" + elt2)])
else:
sim = calcul_sim_non_cov_sans_motif(
graphe2, graphe1,
dico_graphe[("fichier_" + elt2,
"fichier_" + elt1)])
else:
if ("fichier_" + elt1, "fichier_" +
elt2) in dico_graphe.keys():
sim = calcul_sim_avec_poids(
graphe1, graphe2,
dico_graphe[("fichier_" + elt1,
"fichier_" + elt2)])
else:
sim = calcul_sim_avec_poids(
graphe2, graphe1,
dico_graphe[("fichier_" + elt2,
"fichier_" + elt1)])
graphe_complet.edges[u, v]["poids"] = sim
with open("graphe_complet_pondere_sim.pickle",
'wb') as fichier_graphe_complet_refait:
mon_pickler_complet = pickle.Pickler(fichier_graphe_complet_refait)
mon_pickler_complet.dump(graphe_complet)
def construction_graphe_complet_pondere():
graphe_complet = nx.Graph()
i = 0
for fic in os.listdir("graphes_extension"):
if "pickle" in fic:
#print(fic)
graphe_complet.add_node(i, nom=fic[8:len(fic) - 7])
i = i + 1
print(graphe_complet.nodes.data())
with open("dico_graphe_epure_en_tout.pickle", 'rb') as fichier_graphe:
mon_depickler = pickle.Unpickler(fichier_graphe)
dico_graphe = mon_depickler.load()
for cle in dico_graphe.keys():
element1 = cle[0]
element2 = cle[1]
#print(element1)
#print(element2)
enlever = False
for elt in liste:
if elt in element1 or elt in element2:
enlever = True
#print(enlever)
if enlever == False:
with open("graphes_extension/" + element1 + ".pickle",
'rb') as fichier_graphe_1:
mon_depickler_1 = pickle.Unpickler(fichier_graphe_1)
graphe1 = mon_depickler_1.load()
with open("graphes_extension/" + element2 + ".pickle",
'rb') as fichier_graphe_2:
mon_depickler_2 = pickle.Unpickler(fichier_graphe_2)
graphe2 = mon_depickler_2.load()
sim = calcul_sim_non_cov_sans_motif(
graphe1, graphe2, dico_graphe[cle])
num_1 = -1
num_2 = -1
for noeud, attr in graphe_complet.nodes(data="nom"):
#print(attr)
if attr == element1[8:]:
num_1 = noeud
elif attr == element2[8:]:
num_2 = noeud
graphe_complet.add_edge(num_1,
num_2,
poids=float(sim[0]))
with open("graphe_complet_pondere_sim.pickle",
'wb') as fichier_graphe_complet:
mon_pickler_complet = pickle.Pickler(fichier_graphe_complet)
mon_pickler_complet.dump(graphe_complet)
return graphe_complet
voisin_1, voisin_2
) not in dico_graphe[cle][(
i, i)]:
if data1[
"label"] == 'CWW':
typ = "CAN"
else:
typ = "NON_CAN"
#dico_graphe[cle].add_edge((voisin_1,voisin_2), (i,i), type=typ)
dico_graphe[
cle].add_edge(
(i, i),
(voisin_1,
voisin_2),
type=typ)
sim = calcul_sim_non_cov_sans_motif(
graphe1, graphe2, dico_graphe[cle])
if ('fichier_5FDU_1A_197_3',
'fichier_5J7L_DA_197_4') == cle:
print(sim)
dico_sim.update({cle: sim[0]})
with open("dico_graphe_epure_en_tout_test.pickle",
'wb') as fichier_ecriture:
mon_pickler = pickle.Pickler(fichier_ecriture)
mon_pickler.dump(dico_graphe)
print(len(dico_graphe))
with open("dico_graphe_epure_en_tout_test_sim.pickle",
'wb') as fichier_ecriture_sim:
mon_pickler_sim = pickle.Pickler(fichier_ecriture_sim)
mon_pickler_sim.dump(dico_sim)
rows = 1
nom = ""
GC = dico_graphe[comp].copy()
print(comp[0])
print(comp[1])
compteur_arc_arete_1, compteur_arc_arete_2 = nombre_aretes_arcs(
dico_graphes[comp[0]], dico_graphes[comp[1]])
recalcul_sim = (
((GC.number_of_nodes() + GC.number_of_edges()) *
(GC.number_of_nodes() + GC.number_of_edges())) /
((dico_graphes[comp[0]].number_of_nodes() +
compteur_arc_arete_1) *
(dico_graphes[comp[1]].number_of_nodes() +
compteur_arc_arete_2)))
sim_non_cov_sans_motif = calcul_sim_non_cov_sans_motif(
dico_graphes[comp[0]], dico_graphes[comp[1]], GC)
fig.suptitle('sim = ' +
str(round(sim_non_cov_sans_motif[0], 2)),
fontsize=16)
for element in comp:
#fig.suptitle('sim = '+str(round(dico_sim[elt],2)), fontsize=16)
fig.add_subplot(rows, columns, compteur % 2 + 1)
#fig.axis('off')
#axs[compteur%2].xaxis.set_visible(False)
axs[compteur % 2].axis("off")
axs[compteur % 2].set_title(element)
print(element)
def calcul_sim_morceau(typ, depart, type_comp):
if depart == "extensions":
with open("graphe_complet_pondere_sim.pickle",
'rb') as fichier_graphe_complet:
mon_depickler_complet = pickle.Unpickler(fichier_graphe_complet)
graphe_complet = mon_depickler_complet.load()
dico_sim_par_chaine = {}
i = 0.1
#i = 0.4
while i <= 1.0:
with open(
"composantes_connexes_" + type_comp + "_" + +str(i) +
".pickle", 'rb') as fichier_comp:
mon_depickler_comp = pickle.Unpickler(fichier_comp)
composantes_connexes = mon_depickler_comp.load()
for composante in composantes_connexes:
if len(composante) < 10 and len(composante) > 2:
graphe_comp = graphe_complet.subgraph(composante)
for u, v in graphe_comp.edges():
chaines_1, chaines_2, chaines_commun = recherche_chaines_par_morceau(
u, v, graphe_comp, depart)
with open(
"graphes_extension/fichier_" +
graphe_comp.nodes[u]["nom"] +
".pickle", 'rb') as fichier_graphe1:
mon_depickler_graphe1 = pickle.Unpickler(
fichier_graphe1)
graphe1 = mon_depickler_graphe1.load()
with open(
"graphes_extension/fichier_" +
graphe_comp.nodes[v]["nom"] +
".pickle",
'rb') as fichier_graphe2:
mon_depickler_graphe2 = pickle.Unpickler(
fichier_graphe2)
graphe2 = mon_depickler_graphe2.load()
with open(
"dico_graphe_epure_en_tout_test.pickle",
'rb') as fichier_commun:
mon_depickler_commun = pickle.Unpickler(
fichier_commun)
dico_graphe = mon_depickler_commun.load(
)
tab_sim = []
if ("fichier_" +
graphe_comp.nodes[u]["nom"],
"fichier_" +
graphe_comp.nodes[v]["nom"]
) in dico_graphe.keys():
cle = ("fichier_" +
graphe_comp.nodes[u]["nom"],
"fichier_" +
graphe_comp.nodes[v]["nom"])
graphe_commun = dico_graphe[cle]
for j in range(4):
if typ == "longue_distance":
sim = calcul_sim_non_cov_sans_motif(
graphe1, graphe2,
graphe_commun,
chaines_1, chaines_2,
chaines_commun, j)
if typ == "non_cov":
sim = calcul_sim_avec_poids_par_chaine(
graphe1, graphe2,
graphe_commun,
chaines_1, chaines_2,
chaines_commun, j)
#print(sim)
tab_sim.append(sim)
dico_sim_par_chaine.update({
(graphe_comp.nodes[u]["nom"], graphe_comp.nodes[v]["nom"]):
tab_sim
})
else:
cle = ("fichier_" +
graphe_comp.nodes[v]["nom"],
"fichier_" +
graphe_comp.nodes[u]["nom"])
graphe_commun = dico_graphe[cle]
for j in range(4):
if typ == "longue_distance":
sim = calcul_sim_non_cov_sans_motif(
graphe2, graphe1,
graphe_commun,
chaines_2, chaines_1,
chaines_commun, j)
if typ == "non_cov":
sim = calcul_sim_avec_poids_par_chaine(
graphe2, graphe1,
graphe_commun,
chaines_2, chaines_1,
chaines_commun, j)
#print(sim)
tab_sim.append(sim)
dico_sim_par_chaine.update({
(graphe_comp.nodes[v]["nom"], graphe_comp.nodes[u]["nom"]):
tab_sim
})
i = i + 0.1
else:
with open("graphe_complet_pondere_sim.pickle",
'rb') as fichier_graphe_complet:
mon_depickler_complet = pickle.Unpickler(fichier_graphe_complet)
graphe_complet = mon_depickler_complet.load()
dico_sim_par_chaine = {}
i = 0.1
#i = 0.4
while i <= 1.0:
with open(
"composantes_connexes_" + type_comp + "_" + str(i) +
".pickle", 'rb') as fichier_comp:
mon_depickler_comp = pickle.Unpickler(fichier_comp)
composantes_connexes = mon_depickler_comp.load()
for composante in composantes_connexes:
if len(composante) < 10 and len(composante) > 2:
graphe_comp = graphe_complet.subgraph(composante)
for u, v in graphe_comp.edges():
# if (graphe_comp.nodes[u]["nom"] == '4V9F_0_48_26' and graphe_comp.nodes[v]["nom"] == '5J7L_DA_48_30') or (graphe_comp.nodes[v]["nom"] == '4V9F_0_48_26' and graphe_comp.nodes[u]["nom"] == '5J7L_DA_48_30') :
#
chaines_1, chaines_2, chaines_commun = recherche_chaines_par_morceau(
u, v, graphe_comp, depart)
print(u)
print(v)
print(chaines_commun)
with open("grands_graphes.pickle",
'rb') as fichier_graphes:
mon_depickler_graphes = pickle.Unpickler(
fichier_graphes)
graphes = mon_depickler_graphes.load()
with open(
"fichier_comp_grands_graphes_V2.pickle",
'rb') as fichier_commun:
mon_depickler_commun = pickle.Unpickler(
fichier_commun)
dico_graphe = mon_depickler_commun.load(
)
elt1 = (graphe_comp.nodes[u]
["nom"].split("_")[0],
graphe_comp.nodes[u]
["nom"].split("_")[1],
int(graphe_comp.nodes[u]
["nom"].split("_")[2]),
int(graphe_comp.nodes[u]
["nom"].split("_")[3]))
elt2 = (graphe_comp.nodes[v]
["nom"].split("_")[0],
graphe_comp.nodes[v]
["nom"].split("_")[1],
int(graphe_comp.nodes[v]
["nom"].split("_")[2]),
int(graphe_comp.nodes[v]
["nom"].split("_")[3]))
if (elt1, elt2) in dico_graphe.keys():
cle = (elt1, elt2)
cle_sim = (
graphe_comp.nodes[u]["nom"],
graphe_comp.nodes[v]["nom"])
else:
cle = (elt2, elt1)
cle_sim = (
graphe_comp.nodes[v]["nom"],
graphe_comp.nodes[u]["nom"])
if cle_sim not in dico_sim_par_chaine.keys(
):
graphe_commun = dico_graphe[cle]
tab_sim = []
for j in range(4):
if typ == "non_cov":
sim = calcul_sim_non_cov_sans_motif_par_chaine(
graphes[cle[0]],
graphes[cle[1]],
graphe_commun,
chaines_1, chaines_2,
chaines_commun, j)
if (elt1 == ('4V9F', '0',
48, 26)
and elt2 ==
('5J7L', 'DA', 48, 30)
) or (elt2 ==
('4V9F', '0', 48,
26) and elt1
== ('5J7L', 'DA',
48, 30)):
print(cle[0])
print(cle[1])
print(j)
print(sim)
#print(sim)
tab_sim.append(sim)
dico_sim_par_chaine.update(
{cle_sim: tab_sim})
i = i + 0.1
with open("sim_" + depart + "_" + typ + "par_chaine.pickle",
'wb') as fichier_graphe_complet_plus:
mon_pickler_complet = pickle.Pickler(fichier_graphe_complet_plus)
mon_pickler_complet.dump(dico_sim_par_chaine)
def calcul_sim_chaines_2_4():
with open("graphe_complet_pondere_sim.pickle",
'rb') as fichier_graphe_complet:
mon_depickler_complet = pickle.Unpickler(fichier_graphe_complet)
graphe_complet = mon_depickler_complet.load()
print(graphe_complet.edges.data())
nx.set_node_attributes(graphe_complet, [], "chaines")
for u in graphe_complet.nodes():
graphe_complet.nodes[u]["chaines"] = recherche_chaines(
graphe_complet, u)
print(graphe_complet.nodes.data())
nx.set_edge_attributes(graphe_complet, -1.0, "sim_chaines_2_4")
for u, v, data in graphe_complet.edges(data=True):
chaine_1 = list(
set(graphe_complet.nodes[u]["chaines"][1] +
graphe_complet.nodes[u]["chaines"][3] + [1, 2, 3, 4, 5]))
chaine_2 = list(
set(graphe_complet.nodes[v]["chaines"][1] +
graphe_complet.nodes[v]["chaines"][3] + [1, 2, 3, 4, 5]))
with open(
"graphes_extension/fichier_" +
graphe_complet.nodes[u]["nom"] + ".pickle",
'rb') as fichier_graphe1:
mon_depickler_graphe1 = pickle.Unpickler(fichier_graphe1)
graphe1 = mon_depickler_graphe1.load()
with open(
"graphes_extension/fichier_" +
graphe_complet.nodes[v]["nom"] + ".pickle",
'rb') as fichier_graphe2:
mon_depickler_graphe2 = pickle.Unpickler(fichier_graphe2)
graphe2 = mon_depickler_graphe2.load()
with open("dico_graphe_epure_en_tout.pickle",
'rb') as fichier_commun:
mon_depickler_commun = pickle.Unpickler(fichier_commun)
dico_graphe = mon_depickler_commun.load()
if ("fichier_" + graphe_complet.nodes[u]["nom"],
"fichier_" + graphe_complet.nodes[v]["nom"]
) in dico_graphe.keys():
graphe_commun = dico_graphe[(
"fichier_" + graphe_complet.nodes[u]["nom"],
"fichier_" + graphe_complet.nodes[v]["nom"])]
chaine_commun = []
for noeud in graphe_commun.nodes():
if noeud[0] in chaine_1 and noeud[1] in chaine_2:
chaine_commun.append(noeud)
chaine_commun = list(
set(chaine_commun +
[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]))
else:
graphe_commun = dico_graphe[(
"fichier_" + graphe_complet.nodes[v]["nom"],
"fichier_" + graphe_complet.nodes[u]["nom"])]
chaine_commun = []
for noeud in graphe_commun.nodes():
if noeud[1] in chaine_1 and noeud[0] in chaine_2:
chaine_commun.append(noeud)
chaine_commun = list(
set(chaine_commun +
[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]))
sim_2_4 = calcul_sim_non_cov_sans_motif(
graphe1.subgraph(chaine_1), graphe2.subgraph(chaine_2),
graphe_commun.subgraph(chaine_commun))
print(sim_2_4)
graphe_complet.edges[u, v]["sim_chaines_2_4"] = sim_2_4
with open("graphe_complet_pondere_sim.pickle",
'wb') as fichier_graphe_complet_2:
mon_pickler_complet = pickle.Pickler(fichier_graphe_complet_2)
mon_pickler_complet.dump(graphe_complet)