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
resolution_niveau = 10 seuil_netermes= 0.4 resolution_continuite = 4 proj_thres=0.3 try: CF_weight0 = parameters.CF_weight0 except: CF_weight0=0.5 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) print param_txt try: #recalculer les tubes, alors lancer ligne suivante: #tubes = fonctions.dumpingout(param_txt+'tubessdqklsqkmlsdjslqdkjm') tubes = fonctions.dumpingout(param_txt+'tubes') #res_intertemp_zoom = fonctions.dumpingout(param_txt+'res_intertemp_zoom') #pas utile dyn_net_zoom = fonctions.dumpingout(param_txt+'dyn_net_zoom') print 'bravo' except: tubes,dyn_net_zoom,res_intertemp_zoom=multi_tubes.get_tubes(resolution_niveau,seuil_netermes,resolution_continuite,proj_thres) print "des tubes précédemments calculés ont été importés" #tubes[seuil_intertemp][zoo] = liste de tubes inter_temp_liste = tubes.keys() zoom_niveau_v = tubes[inter_temp_liste[0]] #zoom_continuite = multi_tubes.build_zoom_log(resolution_continuite) zoom_niveau=zoom_niveau_v.keys()
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
else:
name_date = str(years_bins[0][0]) + '_' + str(years_bins[0][-1]) + '_'+ str(years_bins[0][0])+ '_'+str(years_bins[-1][-1])
try:
os.mkdir(path_req +'gexf')
except:
pass
try:# si on a deja calcule le reseau de proximit
if user_interface =='y':
var = raw_input('do you wish to try to rebuild cooccurrence matrix ? (y to rebuild)')
else:
var='n'
try:
if var =='y':
fonctions.dumpingout('klqsdjlmsqjdklqsmd')
#p_cooccurrences = fonctions.dumpingout('p_cooccurrences'+name_date)
print 'dist_mat loading...'
#dist_mat = fonctions.dumpingout('dist_mat'+name_date)
dist_mat = fonctions.dumpingout('dist_mat_10'+name_date)
except:
if var =='y':
print 'on reconstruit'
fonctions.dumpingout('klqsdjlmsqjdklqsmd')
#p_cooccurrences={}
dist_mat={}
dist_mat_10={}
print 'on construit la version pkl de dist_mat'
def load_data(orphan_number):
champs=['id_cluster_1','periode_1','id_cluster_1_univ','id_cluster_2','periode_2','id_cluster_2_univ','strength']
res_maps = fonctions_bdd.select_bdd_table_champ_complet(name_bdd,'maps',','.join(champs))
champs=['id_cluster_1','periode_1','id_cluster_1_univ','id_cluster_2','periode_2','id_cluster_2_univ','strength']
res_phylo = fonctions_bdd.select_bdd_table_champ_complet(name_bdd,'phylo',','.join(champs))
champs=['id_cluster','periode','id_cluster_univ','label_1','label_2','level','concept','nb_fathers','nb_sons','label']
res_cluster = fonctions_bdd.select_bdd_table_champ_complet(name_bdd,'cluster',','.join(champs))
champs=['jours','concepts_id']
occurrences_concepts = fonctions_bdd.select_bdd_table_champ_complet(name_bdd,'billets',','.join(champs))
champs=['concept1','concept2','periode','distance0','distance1']
reseau_termes = fonctions_bdd.select_bdd_table_champ_complet(name_bdd,'sem_weighted',','.join(champs))
dico_termes=fonctions.lexique()#on cree le dictionnaire des termes
#on les restructure pour plus de confort d'utilisation.
clusters={}#on crée un dico de dico.
years_bins_first = []
res_termes={}#on crée un dico de dico dans lequel seront indiqués les distances
for years in years_bins:
years_bins_first.append(years[0])
for lien_terme in reseau_termes:
[concept1,concept2,periode,distance0,distance1] = lien_terme
if distance0>0:
res_termes_inter = res_termes.get(periode,{})
dict_id1 = res_termes_inter.get(concept1,{})
dict_id1[concept2] = distance0
res_termes_inter[concept1]=dict_id1
res_termes[periode] = res_termes_inter
if distance1>0:
res_termes_inter = res_termes.get(periode,{})
dict_id2 = res_termes_inter.get(concept2,{})
dict_id2[concept1] = distance1#attention on rapporte les distances en double
res_termes_inter[concept2]=dict_id2
res_termes[periode] = res_termes_inter
for cluster_terme in res_cluster:
[id_cluster,periode,id_cluster_univ,label_1,label_2,level,concept,nb_fathers,nb_sons,label] = cluster_terme
periode = years_bins_first.index(int(str(periode).split(' ')[0]))
if nb_fathers+nb_sons >= orphan_number:
if id_cluster_univ in clusters:
dict_id = clusters[id_cluster_univ]
temp_concept = dict_id['concepts']
temp_concept.append(concept)
dict_id['concepts'] = temp_concept
clusters[id_cluster_univ] = dict_id
else:
dict_id={}
#dict_id['id_cluster']=id_cluster
dict_id['periode']=periode
dict_id['label']=[label_1,label_2]
dict_id['nb_fathers']=nb_fathers
dict_id['nb_sons']=nb_sons
dict_id['concepts'] = [concept]
dict_id['label'] = label
clusters[id_cluster_univ] = dict_id
#clusters[id_cluster_univ]['id_cluster'/'periode'/'label'/'nb_sons'/'nb_fathers'/'concepts']
add_link(clusters,res_phylo,'dia')
add_link(clusters,res_maps,'syn')
for index in clusters.keys():
if not 'syn' in clusters[index]:
clusters[index]['syn']={}
#on construit la matrice temporelle d'occurrence des termes.
occs = {}
for occ in occurrences_concepts:
year = occ[0]
if len(occ[1])>2:
concept_list = list(map(int,occ[1][1:-1].split(', ')))
else:
concept_list=[]
#print concept_list
for conc in concept_list:
occs_conc=occs.get(conc,{})
occs_conc[year] = 1 + occs_conc.get(year,0)
occs[conc]=occs_conc
#on récupère dist_mat réseau des distances entre termes.
name_date = str(years_bins[0][0]) + '_' + str(years_bins[0][-1]) + '_'+ str(years_bins[1][0])+ '_'+str(years_bins[-1][-1])
#version longue et exacte
#dist_mat = fonctions.dumpingout('dist_mat'+name_date)
#version rapide et approchée:
dist_mat = fonctions.dumpingout('dist_mat_10'+name_date)
return dico_termes,clusters,dist_mat,res_termes
overlap = 0
for tps_i in list(set(timesteps[i])):
if tps_i in list(set(timesteps[j])):
overlap += timesteps[i].count(tps_i) * timesteps[j].count(tps_i)
distance_components[i][j] = dist/float(overlap)
return distance_components,components_belong
def top(dict,n=1):
l=dict.items()
l.sort(key=itemgetter(1),reverse=True)
return l[:n]
orphan_number = 1
try:
liens_totaux_syn_0,liens_totaux_dia_0,clusters,years_bins,label_edges = fonctions.dumpingout('qliens_totaux_syn'+ str(orphan_number)),fonctions.dumpingout('liens_totaux_dia'+ str(orphan_number)),fonctions.dumpingout('clusters'+ str(orphan_number)),fonctions.dumpingout('years_bins'+ str(orphan_number)),fonctions.dumpingout( 'liens_totaux_label'+ str(orphan_number))
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)
name_date = str(years_bins[0][0]) + '_' +str(years_bins[-1][-1])
#construction des voisinages dynamiques:
#on crée la table des voisins
try:
fonctions_bdd.drop_table(name_bdd,'termneighbour')
except:
pass
fonctions_bdd.creer_table_term_neighbor(name_bdd,'termneighbour')
#on importe les données si ce n'est pas déjà fait
try:
dist_2d=fonctions.dumpingout('dist_2d'+name_date)
dist_2d_trans=fonctions.dumpingout('dist_2d_trans'+name_date)
print 'on charge dist_2d_trans deja calculé'
except:
print 'on calcule dist_2d_trans pour les dates indiquées'
try:
contenu[0]==1
except:
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=[]