Beispiel #1
0
#	fonctions.ecrire_reseau(p_cooccurrences,years_bins,'',0,'cooc',dedoubler(dico_termes,years_bins))		 	

#INUTILE D'ECRIRE RESEAU CF de cooccurrences
#fonctions.ecrire_reseau_CF(p_cooccurrences,years_bins,'',0,'cooc')

#INUTILE DE CALCULER TOUTES LES DISTANCES A LA FOIS
#dist_mat = distance(dist_type,p_cooccurrences)

	print "matrice de distance construite"
#	fonctions.ecrire_reseau(dist_mat,years_bins,dist_type,seuil,1,dedoubler(dico_termes,years_bins))		 
	fonctions.ecrire_reseau_CF_inter(dist_mat,inter,dist_type,seuil,1)




dico_termes=fonctions.build_dico(termsandblogs)
#print dico_termes	




print years_bins
if len(years_bins)>1:
	name_date = str(years_bins[0][0]) + '_' + str(years_bins[0][-1]) + '_'+ str(years_bins[1][0])+ '_'+str(years_bins[-1][-1])
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
					
Beispiel #2
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
Beispiel #3
0
		for x,y in dico_termes.iteritems():
			dico_termes_temp[(inter,x)]=y
	return dico_termes_temp

def compare_dictionnaire(dist_mat_temp_old,dist_mat_temp):
		commun = 0
		total_old = len(dist_mat_temp_old)
		total_new = len(dist_mat_temp)
		for x in dist_mat_temp_old:
			if x in dist_mat_temp:
				commun += 1
		return commun, total_old, total_new
		

		
dico_termes=fonctions.build_dico()
#print dico_termes	
print years_bins
name_date = str(years_bins[0][0]) + '_' + str(years_bins[0][-1]) + '_'+ str(years_bins[1][0])+ '_'+str(years_bins[-1][-1])

def add_zeros(dyn,years_bins):
	dyna = []
	for y in range(len(years_bins)):
		dyna.append("%.3f" %dyn.get(y,0.))
	return dyna


name_date = str(years_bins[0][0]) + '_' +str(years_bins[-1][-1])

#construction des voisinages dynamiques: