示例#1
0
文件: auteurs.py 项目: jphcoi/MLMTC
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
示例#2
0
文件: auteurs.py 项目: jphcoi/MLMTC
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
示例#3
0
文件: auteurs.py 项目: jphcoi/MLMTC
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
示例#4
0
文件: auteurs.py 项目: jphcoi/MLMTC
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
示例#5
0
文件: auteurs.py 项目: jphcoi/MLMTC
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
示例#6
0
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()
示例#7
0
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
示例#8
0
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'
示例#9
0
文件: tubes.py 项目: jphcoi/MLMTC
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
示例#10
0
文件: tubes.py 项目: jphcoi/MLMTC
			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)	
示例#11
0

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=[]