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