def load_projection(niv):
try:
projection_aut2chp = fonctions.dumpingout('projection_aut2chp_'+str(niv))
projection_chp2aut = fonctions.dumpingout('projection_chp2aut_'+str(niv))
except:
dist_mat = load_distance_mat()
champs=fonctions.dumpingout('champs_'+str(niv))
#champs[inter] = liste des champs de la période
#dist_champ=fonctions.dumpingout('distance_champ_'+str(niv))
projection_aut2chp ={}
projection_chp2aut ={}
for x,bagage in soc_sem.iteritems():
auteur = x[0]
inter = x[1]
champs_inter=champs[inter]
print x
for champ in champs_inter:
dist = fonctions.calcul_distance_max(bagage,champ,dist_mat,inter)
projection_aut2chp[(auteur,champs_inter.index(champ),inter)]=dist
dist = fonctions.calcul_distance_max(champ,bagage,dist_mat,inter)
projection_chp2aut[(champs_inter.index(champ),auteur,inter)]=dist
fonctions.dumpingin(projection_aut2chp,'projection_aut2chp_'+str(niv))
fonctions.dumpingin(projection_chp2aut,'projection_chp2aut_'+str(niv))
return projection_aut2chp,projection_chp2aut
def load_distance_mat():
try:
dist_mat = fonctions.dumpingout('dist_mat')
except:
import context_process
dist_mat = context_process.dist_mat#on recupere la matrice de distance entre termes
fonctions.dumpingin(dist_mat,'dist_mat')
print 'matrice de distance importée'
return dist_mat
def load_soc_sem():
try:
soc_sem = fonctions.dumpingout('soc_sem')
except:
auteurs_billets,contenu_socsem=load_contenu_socsem()
auteurs_pert = select_auteurs_pertinent(auteurs_billets,6)
print len(auteurs_pert)
soc_sem = bagage_sem(contenu_socsem,auteurs_pert)
fonctions.dumpingin(soc_sem,'soc_sem')
return soc_sem
def load_dico():
try:
dico_auteurs = fonctions.dumpingout('dico_auteurs')
except:
lesauteurs = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','auteurs')
lesidsauteurs = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','id')
dico_auteurs ={}
for x,y in zip(lesidsauteurs,lesauteurs):
dico_auteurs[x[0]]=y[0]
fonctions.dumpingin(dico_auteurs,'dico_auteurs')
return dico_auteurs
def load_contenu_socsem():
try:
auteurs_billets = fonctions.dumpingout('auteurs_billets')
contenu_socsem =fonctions.dumpingout('contenu_socsem')
except:
contenu_socsem = fonctions_bdd.select_bdd_table(name_bdd,'socsem','auteur,concept,jours,id_b',requete)
auteurs_billets={}
#auteurs_billets associe à chaque auteur les billets auxquels il a contribué
for cont in contenu_socsem:
auteur = cont[0]
id_b = cont[3]
if auteurs_billets.has_key(auteur):
temp=auteurs_billets[auteur]
if not id_b in temp:
temp.append(id_b)
auteurs_billets[auteur] = temp
else:
arr = []
arr.append(id_b)
auteurs_billets[auteur] = arr
fonctions.dumpingin(contenu_socsem,'contenu_socsem')
fonctions.dumpingin(auteurs_billets,'auteurs_billets')
return auteurs_billets,contenu_socsem
distance_champ=fonctions.map_champs(champs,dist_mat,'moy')
#print distance_champ
distance_champ_edges_list=edges_list(distance_champ)
#version des distances sans la limitation degmax.
fonctions.ecrire_reseau_CF(distance_champ,years_bins,dist_type,seuil_net_champ,niveau+1)
#print '\n'
#print distance_champ_edges_list
distance_champ_edges_list_seuil=fonctions.seuiller(distance_champ_edges_list,degmax)
#print '\n'
#print distance_champ_edges_list_seuil
distance_champ = edges_list_reverse(distance_champ_edges_list_seuil)
#print '\n'
#print distance_champ
legende_noeuds,legende_noeuds_id=gexf_champ(years_bins,scores,champs,nb_label,dico_termes,sep_label,dist_type,distance_champ,niveau,seuil_net_champ)
fonctions.dumpingin(champs,'champs_'+str(niveau))
fonctions.dumpingin(distance_champ,'distance_champ_'+str(niveau))
fonctions.ecrire_legende(champs,legende_noeuds,legende_noeuds_id,niveau+1,years_bins)
fonctions.ecrire_reseau(distance_champ,years_bins,dist_type,seuil_net_champ,niveau+1,legende_noeuds)
print "niveau vide!"
maps_union.union_map(2,seuil_net_champ)
#print lenchampsfinal.keys()
logfile = open(Cfinderexport_name(0,0,degmax),'a')
for x,y in info.iteritems():
text= text + '\n'
text = text+ 'niveau: '+str(x) + '\n'
inter=-1
for ligne in y:
if '*** periode: ' in ligne:
ligne_v = ligne.split('*** periode: ')
def get_tubes(resolution_niveau = 4,seuil_netermes= 0.5,resolution_continuite = 2 ,proj_thres=0.3):
#param_txt = name_data_real+'_res_niv_' + str(resolution_niveau) + '_seuil_netermes_' + str(seuil_netermes) +'_res_cont_'+str(resolution_continuite) +'_proj_thres_'+str(proj_thres)
name_date = str(years_bins[0][0]) + '_' + str(years_bins[0][-1]) + '_'+ str(years_bins[1][0])+ '_'+str(years_bins[-1][-1])
param_txt = name_data_real+'_res_niv_' + str(resolution_niveau) + '_seuil_netermes_' + str(seuil_netermes) +'_res_cont_'+str(resolution_continuite) +'_proj_thres_'+str(proj_thres) + name_date + str(CF_weight0)
try:
#inutile puisque le try est déjà calculé
#=>on rajoute un dumpingout inexistant
dist_mat = fonctions.dumpingout(param_txt+'ksmqljkljqmljdist_mat')
print 'on essaye de recupérer un multi_level_dyn_net déjà calculé'
multi_level_dyn_net = fonctions.dumpingout(param_txt+'multi_level_dyn_net')
print 'on a recupéré un multi_level_dyn_net déjà calculé'
dist_mat = fonctions.dumpingout(param_txt+'dist_mat')
dico = fonctions.dumpingout(param_txt+'dico')
tubes = fonctions.dumpingout(param_txt+'tubes')
#chelou
dyn_net_zoom = fonctions.dumpingin(dyn_net_zoom,param_txt+'dyn_net_zoom')
except:
#pour accélerer, on remplace ce qui est commenté par ce qui suit
#import context_process
#dico=context_process.dico_termes
#dist_mat = context_process.dist_mat
dico=fonctions.build_dico()
name_date = str(years_bins[0][0]) + '_' + str(years_bins[0][-1]) + '_'+ str(years_bins[1][0])+ '_'+str(years_bins[-1][-1])
dist_mat = fonctions.dumpingout('dist_mat'+name_date)
################################################################################################################################################
#on renseigne maintenant les champs pour leur donner leur "importance" respective.
#on définit la taille d'un champ en fonction du nombre d'articles dont la projection est "maximale" sur l'ensemble des champs reconstruits.
#il faut donc dans un premier temps récupérer la composition en termes des champs
################################################################################################################################################
notices_str = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','concepts_id,jours')
notices = map(str_list,notices_str)
#print notices
################################################################################################################################################
#on importe maintenant les champs au premier niveau.
################################################################################################################################################
nets = import_cfpipe(notices,proj_thres,dist_mat,dico)
################################################################################################################################################
#on construit le réseau multi-échelle à l'aide de l'algorithme de clustering.
################################################################################################################################################
multi_level_dyn_net = hierarchical_clustering(nets,dico,dist_mat)
#multi_level_dyn_net[(inter,fusion_level)] = Network(champs_liste[:],champs_dist)
################################################################################################################################################
#il ne reste plus qu'a construire nos tubes, en veillant à bien labelliser ceux-ci!!!
################################################################################################################################################
fonctions.dumpingin(multi_level_dyn_net,param_txt+'multi_level_dyn_net')
fonctions.dumpingin(dist_mat,param_txt+'dist_mat')
fonctions.dumpingin(dico,param_txt+'dico')
tubes,dyn_net_zoom,res_intertemp_zoom = build_tubes(multi_level_dyn_net,resolution_niveau,resolution_continuite,seuil_netermes,dist_mat,dico)
fonctions.dumpingin(tubes,param_txt+'tubes')
fonctions.dumpingin(dyn_net_zoom,param_txt+'dyn_net_zoom')
fonctions.dumpingin(res_intertemp_zoom,param_txt+'res_intertemp_zoom')
#print tubes
return tubes,dyn_net_zoom,res_intertemp_zoom
dist_mat_temp_res_10 = fonctions.seuiller(dist_mat_temp_res,10)
print 'on construit maintenant dist_mat pour chaque periode ' + str(inter)
for x,y in dist_mat_temp.iteritems():
dist_mat[(int(x[0]),int(x[1]),int(inter))]=y
for x,y in dist_mat_temp_res_10.iteritems():
for u in y:
dist_mat_10[(int(x),int(u[0]),int(inter))]=u[1]
level={}
for x in dico_termes:
level[x]=1
gexf.gexf_builder(dico_termes,dist_mat_temp,fichier_gexf,level)
fonctions.ecrire_dico(dico_termes,dico_termes,dico_termes,1)
print 'dicos ecrits'
#fonctions.dumpingin(p_cooccurrences,'p_cooccurrences'+name_date)
fonctions.dumpingin(dist_mat_10,'dist_mat_10'+name_date)
print 'on a dumpé distmat_10: top 10 de chaque terme'
fonctions.dumpingin(dist_mat,'dist_mat'+name_date)
print 'on a dumpé distmat'
try:
fonctions_bdd.detruire_table(name_bdd,'sem_weighted')
except: pass
#fonctions_bdd.creer_table_sem(name_bdd,'sem')
fonctions_bdd.creer_table_sem_periode_valuee(name_bdd,'sem_weighted')
lienssem_weighted=[]
deja=[]
for x,dist0 in dist_mat_10.iteritems():
if not x in deja:
deja.append((x[1],x[0],x[2]))
deja.append(x)
print 'data loaded'
except:
print 'tubes coordinates being computed'
try:
dico_termes =fonctions.dumpingout('dico_termes' + str(orphan_number))
clusters=fonctions.dumpingout('clusters'+ str(orphan_number))
dist_mat=fonctions.dumpingout('dist_mat'+ str(orphan_number))
res_termes=fonctions.dumpingout('res_termes'+ str(orphan_number))
biparti_champsnotices=fonctions.dumpingout('biparti_champsnotices'+ str(orphan_number))
biparti_noticeschamps=fonctions.dumpingout('biparti_noticeschamps'+ str(orphan_number))
epaisseur=fonctions.dumpingout('epaisseur'+ str(orphan_number))
print 'dumped data loaded'
except:
dico_termes,clusters,dist_mat,res_termes = load_data(orphan_number)
epaisseur,biparti_noticeschamps,biparti_champsnotices=width(clusters)
fonctions.dumpingin(dico_termes,'dico_termes' + str(orphan_number))
fonctions.dumpingin(clusters,'clusters'+ str(orphan_number))
fonctions.dumpingin(dist_mat,'dist_mat'+ str(orphan_number))
fonctions.dumpingin(res_termes,'res_termes'+ str(orphan_number))
fonctions.dumpingin(biparti_champsnotices,'biparti_champsnotices'+ str(orphan_number))
fonctions.dumpingin(biparti_noticeschamps,'biparti_noticeschamps'+ str(orphan_number))
fonctions.dumpingin(epaisseur,'epaisseur'+ str(orphan_number))
for x,y in epaisseur.iteritems():
clusters[x]['epaisseur']=math.sqrt(1+y)
print 'on regarde la tête d epaisseur'
array = scipy.array(epaisseur.values())
# pylab.figure()
# pylab.hist(array, 1000)
contenu = fonctions_bdd.select_bdd_table(name_bdd,'billets','concepts_id,jours,id',requete)
print "contenu importé"
print "on construit la variable avec tous les jours"
#on va plutôt calculer les distances par période, c'est moins long!!!
#sinon ci dessous version au jour le jour
# years_bins_jour = range(years_bins[0][0],years_bins[-1][-1]+1)
# years_bins=[]
# for x in years_bins_jour:
# years_bins.append([x])
# print years_bins
p_cooccurrences = build_cooc_matrix(contenu,years_bins)
print "matrice de cooccurrence sur tous les jours construite"
dist_mat = distance(dist_type,p_cooccurrences)
print "matrice de distance construite"
dist_2d,dist_2d_trans = convert_dist_mat3d_dist2d(dist_mat)
fonctions.dumpingin(dist_2d,'dist_2d'+name_date)
fonctions.dumpingin(dist_2d_trans,'dist_2d_trans'+name_date)
def turn1d_moy(dict_couple):
dict_mono_dict={}
for couple,valeurs in dict_couple.iteritems():
x=couple[0]
y=couple[1]
if x in dict_mono_dict:
temp = dict_mono_dict[x]
else:
temp = {}
temp[y]=moy = float(sum(valeurs.values())/n)
dict_mono_dict[x]=temp
return dict_mono_dict
