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 build_dico():
lesidstermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id')
leslemmestermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','concepts')
lestermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','forme_principale')
dico_termes ={}
dico_lemmes ={}
for x,y,z in zip(lesidstermes,lestermes,leslemmestermes):
dico_termes[x[0]]=y[0]
dico_lemmes[x[0]]=z[0]
print 'dictionnaire des termes écrit, taille: '+str(len(dico_termes))
return dico_termes,dico_lemmes
def extraire_reseaux_pondere(contenu,file_social_net_name,name_bdd):
#filtre sur la sélection...
billets_index = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'socsem','id_b')
billet_occ={}
for bill_et in billets_index:
bille=bill_et[0]
if bille in billet_occ:
billet_occ[bille]=billet_occ[bille]+1
else:
billet_occ[bille]=1
# print billet_occ
file_social_net = open(file_social_net_name,'w')
net={}
for lien in contenu:
if 1:
normalisation = billet_occ[lien[3]]
auteur1 = lien[0]
auteur2 = lien[1]
jour = lien[2]
lien_soc = (auteur1,auteur2,jour)
if not lien_soc in net:
net[lien_soc] = float(1) / float(normalisation)
else:
net[lien_soc] = float(1) / float(normalisation)+net[lien_soc]
#else:
# print 'billet '+str(lien[3]) + ' occ ' + str(billet_occ[lien[3]]) + ' rejete'
for link_date in net:
file_social_net.write(str(link_date[0]) + '\t'+str(link_date[1]) + '\t' +str(link_date[2]) + '\t'+ str(net[link_date])+ '\n')
def extract_champs_db(filename):
articles=[]
print " - fichier d'articles: \""+filename+"\"..."
#file=codecs.open(filename,"r","utf8")
#lines = file.readlines()
i=0
categ1,categ2,categ3,permalink,contentanchor = '','','','',''
#clause_titre=0
#clause_content=0
import fonctions_bdd
contenu = fonctions_bdd.select_bdd_table_champ_simple(filename,'maladiesrares',"id,topics,sujet,vues,reponses,auteur,profil,date,heure,contenu,citation,page,hrefs")
for cont in contenu:
#('id','topics','sujet','vues','reponses','auteur','profil','date','heure','contenu','citation','page','hrefs')
title = cont[2]
date = cont[7]
permalink = cont[1]
website = cont[5]
categ1 = cont[3]
categ2 = cont[3]
categ3 = cont[6]
contentclean = str.strip(cont[9])
contentanchor = str.strip(cont[12])
articles.append([title,date,permalink,website,categ1,categ2,categ3,contentclean,contentanchor])#sans le html brut
print "---",len(articles),"posts processed."
return articles
def width(clusters):
notices_str = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','id,concepts_id,jours')
notices = map(str_list,notices_str)
biparti_noticeschamps={}
biparti_champsnotices={}
for notice in notices:
numero = int(notice[0])
champ1 = notice[1]
jour = notice[2]
for inter,years in enumerate(years_bins):
if jour in years:
for id_univ,clu in clusters.iteritems():
if clu['periode'] == inter:
if len(set(champ1) & set(clu['concepts']))>0:
dist = fonctions.calcul_distance(champ1,clu['concepts'],dist_mat,inter,type_distance='moy')
dico = biparti_noticeschamps.get(numero,{})
dicoinv = biparti_champsnotices.get(id_univ,{})
if dist > 0.1:
dico[id_univ] = dist
dicoinv[numero] = dist
biparti_noticeschamps[numero] = dico
biparti_champsnotices[id_univ] = dicoinv
epaisseur={}
for id_univ,clu in clusters.iteritems():
try:
epaisseur[id_univ]=sum(biparti_champsnotices[id_univ].values())
except:
print 'taille nulle'
return epaisseur,biparti_noticeschamps,biparti_champsnotices
def build_dico(termsandblogs='n'):
lesidstermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id')
lestermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','forme_principale')
dico_termes ={}
for x,y in zip(lesidstermes,lestermes):
dico_termes[x[0]]=y[0]
if termsandblogs=='y':
N = len(dico_termes.keys())
print 'authors and concepts are merged'
lesidstermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','id')
lestermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','auteurs')
for x,y in zip(lesidstermes,lestermes):
dico_termes[x[0] + N]= y[0]
print 'dictionnaire des termes écrit, taille: '+str(len(dico_termes))
return dico_termes
def build_dico():
concepts_triplets = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,concepts,forme_principale')
dico_termes,dico_lemmes ={},{}
for triplets in concepts_triplets:
dico_termes[triplets[0]] = triplets[2]
dico_lemmes[triplets[0]] = triplets[1]
print 'dictionnaire des termes écrit, taille: '+str(len(dico_termes))
print_extrait_dico(dico_termes,dico_lemmes)
return dico_termes,dico_lemmes
def xhi2_comp(year):
print "periode " + str(year)
where = " jours IN ('" + "','".join(list(map(str,year))) + "') "
contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','concepts_id,jours,id',where)
print "content imported: " + str(len(contenu)) + " notices \n"
cooccurrences,nb_cooc,cooccurrences_somme,occurrences = build_cooc(contenu)
print str(nb_cooc) + ' total cooccurrences computed'
print str(sum(occurrences.values())) + ' total occurrences computed'
xhi2val = build_mutual_information(cooccurrences,cooccurrences_somme,nb_cooc,occurrences)
export_concepts_xhi2(xhi2val,cooccurrences,cooccurrences_somme,dico_termes,dico_lemmes,year,occurrences)
def lexique(termsandblogs='n'):
lesidstermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id')
lestermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','forme_principale')
dico_termes ={}
for x,y in zip(lesidstermes,lestermes):
dico_termes[x[0]]=y[0]
if termsandblogs=='y':
N = len(dico_termes.keys())
print 'authors and concepts are merged'
print N
lesidstermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','id')
lestermes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','auteurs')
for x,y in zip(lesidstermes,lestermes):
print x[0],y[0]
dico_termes[x[0] + N]= y[0]
return dico_termes
def xhi2_comp(year):
print year
# contenu = fonctions_bdd.select_bdd_table(name_bdd,'billets','concepts_id,jours,id',requete)
where = " jours IN ('" + "','".join(list(map(str,year))) + "') "
print where
contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','concepts_id,jours,id',where)
print "contenu importé"
print '\n'
from time import time
timeavt = time()
p_cooccurrences,nb_billets,p_cooccurrences_lignes,p_cooccurrences_ordre1,occurrences,top_concepts_dict = build_cooc_matrix(contenu,year)
somme=0.
for x in p_cooccurrences_ordre1.values():
somme += x
print 'somme'
print somme
#print occurrences
print 'coocc fabriquées'
#timeapres = timeavt
#timeavt = time()
#print 'duree de la derniere etape : ' + str( timeavt-timeapres) + '\n'
#distribution_distance = distribution_distance_build(p_cooccurrences,dico_termes,p_cooccurrences_lignes)
#print '\nrapprochements suggérés:\n'
#timeapres = timeavt
#timeavt = time()
#print 'duree de la derniere etape : ' + str(timeavt-timeapres) + '\n'
#
# l = distribution_distance.items()
# l.sort(key=itemgetter(1),reverse=True)
# dico_final_top={}
#
# synonymes_potentiels = open(path_req + 'synonymes.txt','w')
#
# for x in l[:10000]:
# couple=x[0]
# #if p_cooccurrences[(couple[0],couple[0],0)]*NN>freqmin and p_cooccurrences[(couple[1],couple[1],0)]*NN>freqmin:
# #print dico_termes[couple[0]] + '\t'+dico_termes[couple[1]] + '\t' + str(float(distribution_distance[couple]))
# synonymes_potentiels.write(dico_termes[couple[0]] + '\t'+dico_termes[couple[1]] + '\t' + str(float(distribution_distance[couple])) + '\n')
#
# timeapres = timeavt
# timeavt = time()
# print 'duree de la derniere etape : ' + str(timeavt-timeapres) + '\n'
# print "matrice de cooccurrence construite"
muti = build_mutual_information(p_cooccurrences,p_cooccurrences_ordre1,nb_billets,occurrences,top_concepts_dict)
xhi2val = xhi2(muti)
export_concepts_xhi2(xhi2val,p_cooccurrences,p_cooccurrences_ordre1,dico_termes,dico_lemmes,year,occurrences)
def extract_champs_vdn(filename):
articles=[]
print " - fichier d'articles: \""+filename+"\"..."
i=0
categ1,categ2,categ3,permalink,contentanchor = '','','','',''
import fonctions_bdd
contenu = fonctions_bdd.select_bdd_table_champ_simple(filename,'commentaires',"id,cp,comm_meta,comm_texte")
for cont in contenu:
title = cont[1]
website,date = detacher_meta(cont[2])
website=website.replace("'",' ')
permalink = cont[2]
categ1 = date
date=''
categ2 = ''
categ3 = ''
contentclean = str.strip(cont[3])
contentanchor = ''
articles.append([title,date,permalink,website,categ1,categ2,categ3,contentclean,contentanchor])#sans le html brut
print "---",len(articles),"posts processed."
return articles
def remplir_colonne_distance_sem_weighted(dist_mat):
print 'in remplir_colonne_distance_sem_weighted'
contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'sem_weighted','id,concept1,concept2,periode',' where 1 limit 10000')
sem_weighted_triplet_id={}
j=0
N=len(contenu)
print N
for cont in contenu:
j+=1
if not j%1000:
print j , N
sem_weighted_triplet_id[(cont[1],cont[2],cont[3])]=cont[0]
champs_liste=[]
champs_name=[]
j=0
N = len(dist_mat.keys())
for x,y in dist_mat.iteritems():
j+=1
if not j%1000:
print j , N
#if x in sem_weighted_triplet_id:
id_triplet = sem_weighted_triplet_id[x]
champs_liste.append((id_triplet,y))
champs_name.append('distance0')
id_triplet = sem_weighted_triplet_id[(x[1],x[0],x[2])]
champs_liste.append((id_triplet,y))
champs_name.append('distance1')
#else:
# #c'est une distance entrante!
# try:
# x=(x[1],x[0],x[2])
# id_triplet = sem_weighted_triplet_id[x]
# champs_liste.append((id_triplet,y))
# champs_name.append('distance1')
# except:
# #some distances may be under the threshold.
# pass
fonctions_bdd.update_multi_table(name_bdd,'sem_weighted',champs_name,champs_liste)
print "remplit la colonne champ_name d'indice id - entree liste de doublon (id, valeur)"
def do_calculation(year):
print str(year) + ' being processed '
where = " jours IN ('" + "','".join(list(map(str,year))) + "') "
contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','jours',where)
Nb_rows=len(contenu)
#il faut découper ici car ça prend trop de RAM
if sample<Nb_rows:
size_seq = sample
nb_sequences=0
else:
size_seq = 10000
nb_sequences = Nb_rows/size_seq
dictionnaire_gramme = {}#initialisation du dictionnaire de lemmes
billetprocessed_after_requete=0 #counts the number of processed posts
for x in range(nb_sequences+1):
dictionnaire_gramme_x={}
# billetprocessed_after_requete=1+billetprocessed_after_requete
lim_d = str(size_seq*x)
if x<nb_sequences:
duration = str(size_seq)
else:
duration = str(min(Nb_rows - size_seq*x,sample))
where = " jours IN ('" + "','".join(list(map(str,year))) + "') "
where=''
for ii,ystr in enumerate(list(map(str,year))):
if ii>0:
where = where + ' or '
where = where + ' jours = ' +"'"+ ystr+"'"
#print where
contenu = fonctions_bdd.select_bdd_table_where_limite(name_bdd,'billets','content_lemmatise',sample,requete,where,lim_d+','+duration,Nb_rows)
for billetlemm in contenu:
billetprocessed_after_requete=1+billetprocessed_after_requete
if not billetprocessed_after_requete%500 or billetprocessed_after_requete == Nb_rows :
print '---------'+str(billetprocessed_after_requete)+ ' traités (export ngrammes sur '+str(Nb_rows)+ ' billets)'
billet_lemmatise = billetlemm[0]
dictionnaire_gramme_x = text_processing.ngramme_build(billet_lemmatise.split(),maxTermLength,dictionnaire_gramme_x,language,'absolu')
dictionnaire_gramme=fonctions_lib.merge(dictionnaire_gramme, dictionnaire_gramme_x, lambda x,y:x+y)
return dictionnaire_gramme
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
def select_query(query=[]):
#on définit une nouvelle table et une table billets temporaires
#specific_nlemmes est la requête de base issue de query.csv.
if len(query)==0:
specific_nlemme = misc.lire_dico_classes(path_req + 'query.csv',language)
specific_nlemmes=[]
for x in specific_nlemme:
specific_nlemmes=specific_nlemmes+x.split('***')
else:
specific_nlemmes = query
print specific_nlemmes
print '\n' + str(len(specific_nlemmes)) +' terms in the query '
#on récupère les ids des concepts présents dans la requête dans query_ids
query_ids =[]
try:
concepts = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,concepts')
for con in concepts:
if con[1] in specific_nlemmes:
query_ids.append(con[0])
except:
#il se peut que la base n'est jamais été indexée
pass
try:
#tous les termes de la query ont déjà été indexés
sous_corpus_idb_vect = fonctions_bdd.select_bdd_table_champ_simple(jesaispas,name_bdd,'concept2billets','id_b', ' where concept in '+ str(query_ids).replace('[','(').replace(']',')'))
sous_corpus_idb=[]
for x in sous_corpus_idb_vect:
if not x[0] in sous_corpus_idb:
sous_corpus_idb.append(x[0])
except:
#tous les termes de la query n'ont pas encore été indexés, on passe à une méthode like.
where_like = " where content_lemmatise like '%"
where_like = where_like + " %' or content_lemmatise like '% ".join(specific_nlemmes) + " %'"
print where_like
sous_corpus_idb = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','id',where_like )
print str(len(sous_corpus_idb)) +' documents retrieved \n'
sql_where = " id in " + str(sous_corpus_idb).replace('[','(').replace(']',')')
#print sql_where
print 'creation de la nouvelle base de données ' + name_bdd_new
shutil.copy(name_bdd, name_bdd_temp)
try:
fonctions_bdd.detruire_table(name_bdd,'billets2')
except:
pass
try:
fonctions_bdd.add_column(name_bdd,'billets','concepts_id','text')#et lui adjoindre le champ concepts_id
except:
pass
try:
fonctions_bdd.creer_table_billets(name_bdd,'billets2')#creer une table billet2
fonctions_bdd.add_column(name_bdd,'billets2','concepts_id','text')#et lui adjoindre le champ concepts_id
except:
pass
fonctions_bdd.insert_select(name_bdd,'billets','billets2',sql_where)
fonctions_bdd.detruire_table(name_bdd,'billets')
fonctions_bdd.renommer_table(name_bdd,'billets2','billets')
shutil.copy(name_bdd, name_bdd_new)
shutil.copy(name_bdd_temp, name_bdd)
os.remove(name_bdd_temp)
return specific_nlemmes,fonctions_bdd.count_rows(name_bdd,'billets')
def query_exander(query,N):
encore=1
while encore==1:
dico_new=0
dico=0
#construit la base name_bdd_new en fonction de la query
id_new_list = fonctions_bdd.select_bdd_table_champ_simple(name_bdd_new,'billets','id')
N_new = len(id_new_list)
id_new=[]
for x in id_new_list:
id_new.append(x[0])
dico_new = fast_ngram_counter(name_bdd_new,'')
print len(dico_new.keys())
dico= fast_ngram_counter(name_bdd,dico_new.keys())
print len(dico.keys())
ratio= out_doc(dico_new,dico)
ratio_l = trier_dictionnaire(ratio)
steps=100000
nb_question=0
champs_name = "(id,title,date,permalink,site,categorie1,categorie2,categorie3,content,content_lemmatise,href,requete,identifiant_unique)"#on n'enregistre pas le html brut
mode_dynamique=0
if mode_dynamique==1:
for x in ratio_l:
if nb_question<steps:
val = x[1]
if dico_new[x[0]]!=dico[x[0]]:
info ='\n'
#affichage des exemples:
exemple=0
if exemple >0:
nouveaux_billets = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets',champs_name[1:-1],"where content_lemmatise like '% " + x[0] +" %'")
for billets in nouveaux_billets[:9]:
if not billets[0] in id_new:
info=info + '*** '+ billets[1] + '(' + billets[4] + ')' + '\n'
print info
print str(dico_new[x[0]]) +' doc. in ( '+str(float(dico_new[x[0]])/float(N_new)*100.) +'% )' + ' vs ' + str(dico[x[0]])+' doc. out ( '+str(float(dico[x[0]])/float(N)*100.) +'% )' + ' => ratio: ' + str(float(dico_new[x[0]])/float(N_new)/(float(dico[x[0]])/float(N)))
var = raw_input('Do you wish to add "' + x[0] + '" to the query ?')
if var=='y':
query = add_query(query,x[0])
fonctions_bdd.remplir_table(name_bdd_new,'billets',nouveaux_billets,champs_name)
nb_question=nb_question+1
if var=='s':
steps=0
else:
query = add_query(query,x[0])
else:
pass
else:
fileout=open(path_req + 'query_extension.csv','w')
print path_req + 'query_extension.csv'
fileout.write('nlemme' + '\t' + ' nb doc. in ' + '\t' + "pourcentage doc in" +'\t' + ' nb doc out ' + '\t'+'poucentage doc out' +'\t' +' ratio: ' +'\n')
for x in ratio_l:
fileout.write(str(x[0]) +'\t' + str(dico_new[x[0]]) +'\t'+str(float(dico_new[x[0]])/float(N_new)*100.) + '\t' + str(dico[x[0]])+' \t'+str(float(dico[x[0]])/float(N)*100.) +'\t ' + str(float(dico_new[x[0]])/float(N_new)/(float(dico[x[0]])/float(N))) + '\n')
print str(x[0]) +'\t' + str(dico_new[x[0]]) +'\t'+str(float(dico_new[x[0]])/float(N_new)*100.) + '\t' + str(dico[x[0]])+' \t'+str(float(dico[x[0]])/float(N)*100.) +'\t ' + str(float(dico_new[x[0]])/float(N_new)/(float(dico[x[0]])/float(N))) + '\n'
print 'query finale'
print query
var = raw_input('Do you wish to perform a new indexation of the database based on the new query ?')
if var == 'n':
encore=0
return query
correspondance_lemme_forme={}
for ligne in file_concepts.readlines():
lignev = ligne.split('\t')
liste_concepts.append((lignev[0].encode('utf-8','replace'),lignev[1].encode('utf-8','replace')))
correspondance_lemme_forme[lignev[0].encode('utf-8','replace')]=lignev[1].encode('utf-8','replace')
print "&&&",len(liste_concepts),"concepts now."
##si necessaire on recree la table concepts
#on remplit la table concept
#print liste_concepts
fonctions_bdd.remplir_table(name_bdd,'concepts',liste_concepts,"(concepts,forme_principale)")
contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,concepts')
liste_concepts_dico={}
for con in contenu:
liste_concepts_dico[con[1]]=con[0]
def freq_comp(year):
y=years.index(year)
#for y,year in enumerate(years):
#on construit la liste des index des concepts dans l'ordre
ngrammes_fit_index=[]
Nb_auteurs = fonctions_bdd.count_rows(name_bdd,'auteurs')
ngramme_billets_fit =ngramme_billets_fit_year[y]
ngrammes_auteurs_fit=ngrammes_auteurs_fit_year[y]
#on calcule nos stats à l'échelle des auteurs aussi, freq = nombre de blogs parlant d'un terme
dictionnaire_frequence_exact_auteur={}
def build_social_net(requete,name_bdd,sep,name_data):
lienssoc=[]
auteurs = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','id,auteurs')
dic_auteurs ={}
for aut in auteurs:
dic_auteurs[aut[1]] = aut[0]
#auteur = fonctions_bdd.select_bdd_table_champ(name_bdd,'billets','site','id',b_id)
#auteur = text_processing.nettoyer_url((auteur))
#jours = fonctions_bdd.select_bdd_table_champ(name_bdd,'billets','jours','id',b_id)
# print auteur
#names =auteur.split(" *%* ")
#auteur_ids=[]
#for nom in names:
# auteur_ids.append(fonctions_bdd.select_bdd_table_champ(name_bdd,'auteurs','id','auteurs',nom))
if name_data[-4:] in ['.isi','.med'] :
contenu = fonctions_bdd.select_bdd_table(name_bdd,'billets','id,auteur_id,jours',requete)
for cont in contenu:
b_id=cont[0]
clique_auteurs = cont[1]
participants=[]
jours = cont[2]
for participant in clique_auteurs.split(', '):
participant=participant.replace('[','')
participant=participant.replace(']','')
participants.append(participant)
for aut_1 in participants:
for aut_2 in participants:
if aut_1 != aut_2:
lienssoc.append([aut_1,aut_2,jours,b_id,requete,str(b_id)+'_' + str(aut_1) + '_' + str(aut_2)])
else:
contenu = fonctions_bdd.select_bdd_table(name_bdd,'billets','id,href,jours,site',requete)
for cont in contenu:
b_id=cont[0]
aut_id = cont[1]
href_list = cont[1]
jours = cont[2]
site = cont[3]
auteurs = text_processing.nettoyer_url(site)
names =auteurs.split(sep)
auteur_ids=[]
for nom in names:
auteur_ids.append(fonctions_bdd.select_bdd_table_champ(name_bdd,'auteurs','id','auteurs',nom))
url_ids=[]
if len(href_list)>0:
hrefs = href_list.split("***")
hrefs_propre=[]
for hre in hrefs:
if len(hre)>1:
hrefs_propre.append(hre)
hrefs = hrefs_propre
hrefs = map(text_processing.nospace,hrefs)
for url in hrefs:
if not str(url)=='None':
urlok = url.decode('utf-8','replace')
url = urlok.replace("popostrophe","'")
for aut in dic_auteurs.keys():
if aut in url:
id_lien = dic_auteurs[aut]
if not id_lien in url_ids:
url_ids.append(id_lien)
for aut_id in auteur_ids:
if not id_lien ==aut_id:
lienssoc.append([aut_id,id_lien,jours,b_id,requete,str(b_id)+'_' + str(aut_id) + '_' + str(id_lien)])
return(lienssoc)
user_interface=parameters.user_interface
print "--- initialisations terminees...\n"
print "+++ processing raw database \""+name_data+"\" into SQL database file \""+name_bdd+"\""
sep = ' *** '
##############################################################
#######1.importation des billets d'une base extérieure########
##############################################################
#a modifier en fonction de l'endroit où on se trouve:
name_bdd_new = '.'.join(name_bdd.split('.')[:-2]) + '_new.' + '.'.join(name_bdd.split('.')[-2:])
print name_bdd
print name_bdd_new
champs_name = "(title,date,permalink,site,categorie1,categorie2,categorie3,content_lemmatise,content,href,jours,concepts,identifiant_unique,requete,concepts_id)"#on n'enregistre pas le html brut
billet_new = fonctions_bdd.select_bdd_table_champ_simple(name_bdd_new,'billets',champs_name[1:-1])
champs=billet_new
fonctions_bdd.remplir_table(name_bdd,'billets',champs,champs_name)
###################################
#######2.calcul des infos annexes##
###################################
#creation de la table auteurs
try:
fonctions_bdd.detruire_table(name_bdd,'auteurs')
except:
pass
print " + creation de la table auteurs..."
print " - remplissage de la table auteurs..."
sortie = fonctions_bdd.select_bdd_table(name_bdd,'billets','site',requete)
sites = set()
for sor in sortie:
names =sor[0].split(" *%* ")
for nom in names:
site_name=text_processing.nettoyer_url(nom)
if site_name not in sites_interdits:
sites.add(site_name)
sites=list(sites)
fonctions_bdd.remplir_table(name_bdd,'auteurs',sites,"(auteurs)")
print " - recuperation des ids des auteurs dans la table \"auteurs\" (index SQL) pour reinjecter dans la table \"billets\"..."
auteurs = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','id,auteurs')
dic_auteurs ={}
for aut in auteurs:
dic_auteurs[aut[1]] = aut[0]
site_billets = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','id,site')
auteur_index=[]
for sit in site_billets:
id_b= sit[0]
names =sit[1].split(" *%* ")
for nom in names:
sit_name = text_processing.nettoyer_url(nom)
if sit_name in dic_auteurs:
id_aut = dic_auteurs[sit_name]
auteur_index.append([id_b,id_aut])
else:
file_net_name = path_req + "exportWE/sem_net" + '.txt' misc.extraire_reseaux(contenu,file_net_name) print "=> reseau semantique exporte fichier: " + file_net_name file_net_name = path_req + "exportWE/sem_net" + "_pondere.txt" misc.extraire_reseaux_pondere(contenu,file_net_name,name_bdd) print "=> reseau semantique pondere exporte fichier: " + file_net_name #reseau socio-semantique contenu = fonctions_bdd.select_bdd_table(name_bdd,'socsem','auteur,concept,jours',requete) file_net_name = path_req + "exportWE/soc-sem_net.txt" misc.extraire_reseaux(contenu,file_net_name) print "=> reseau socio-semantique exporte fichier: " + file_net_name #liste des concepts contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,concepts') contenu2 = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,forme_principale') file_concepts_name = path_req + "exportWE/liste_concepts.txt" file_concepts=open(file_concepts_name,'w') file_concepts_name2 = path_req + "exportWE/concepts_forme_principale.txt" file_concepts2=open(file_concepts_name2,'w') for con in contenu: file_concepts.write(str(con[0]) + '\t' + str(con[1]) + '\n') print "=> liste des concepts ecrite dans le fichier " +file_concepts_name for con in contenu2: file_concepts2.write(str(con[0]) + '\t' + str(con[1]) + '\n') print "=> liste des formes principales ecrite dans le fichier " +file_concepts_name #liste des auteurs contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'auteurs','id,auteurs') file_auteurs_name = path_req + "exportWE/auteurs.txt"
def get_distance(inter):
print 'nouvelle iteration ',inter
years=years_bins[inter]
print years
where=' where jours in ('+ str(years)[1:-1] + ')'
#lignes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','id,concepts_id',where)
print 'ici1'
print name_bdd
print where
lignes = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'billets','id,concepts_id',where)
print 'ici2'
contenu_occurrences={}
for ligne in lignes:
contenu_occurrences[ligne[0]]=ligne[1]
print 'ici3'
cooccurrences,nb_cooc,cooccurrences_somme,occurrences=build_cooc_ok(contenu_occurrences)#contenu_occurrences = dictionnaire: id,concepts_ids
# coocs = fonctions_bdd.select_bdd_table(name_bdd,'sem_weighted','concept1,concept2,periode,cooccurrences')
# contenu = fonctions_bdd.select_bdd_table(name_bdd,'billets','id,jours',requete)
# nb_billets = build_nbbillet(contenu,years_bins)
print inter
print 'somme'
dist_mat = distance(dist_type,cooccurrences,nb_cooc,cooccurrences_somme)
# print sum(cooccurrences.values())
# lienssem_weighted=[]
# for x,y in cooccurrences.iteritems():
# if y>=parameters.seuil_cooccurrences:
# lienssem_weighted.append((x[0],x[1],inter,y))
# for x,y in cooccurrences_somme.iteritems():
# if y>=parameters.seuil_cooccurrences:
# lienssem_weighted.append((x,x,inter,y))
#
# fonctions_bdd.remplir_table(name_bdd,'sem_weighted',lienssem_weighted,"(concept1,concept2,periode,cooccurrences)")
#INUTILE DE CALCULER p_cooc
# for couple,cooc in cooccurrences.iteritems():
# if int(cooc)>=parameters.seuil_cooccurrences:
# terme1 = int(couple[0])
# terme2 = int(couple[1])
# p = float(cooc)/float(nb_cooc)
# p_cooccurrences[(terme1,terme2,inter)] = p
# for terme,cooc in cooccurrences_somme.iteritems():
# if int(cooc)>=parameters.seuil_cooccurrences:
# p = float(cooc)/float(nb_cooc)
# p_cooccurrences[(int(terme),int(terme),inter)] = p
#print "matrice de cooccurrence construite"
# 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)
print "+++ processing raw database \""+name_data+"\" into sql_where database file \""+name_bdd+"\""
sep = ' *** '
#on définit une nouvelle table et une table billets temporaires
name_bdd_new = '.'.join(name_bdd.split('.')[:-2]) + '_new.' + '.'.join(name_bdd.split('.')[-2:])
name_bdd_temp = '.'.join(name_bdd.split('.')[:-2]) + '_temp.' +'.'.join(name_bdd.split('.')[-2:])
#on définit une série de nlemme qui forment la requête
#specific_nlemmes=['NO_an AD_lors','NO_scène','NO_expert']
specific_nlemmes = misc.lire_dico_classes(path_req + 'query.csv',language)
print specific_nlemmes
#on récupère les ids des concepts présents dans la requête dans query_ids
concepts = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,concepts')
query_ids =[]
for con in concepts:
if con[1] in specific_nlemmes:
query_ids.append(con[0])
print '\n' + str(len(query_ids)) + ' terms in the query.'
sous_corpus_idb_vect = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concept2billets','id_b', ' where concept in '+ str(query_ids).replace('[','(').replace(']',')'))
sous_corpus_idb=[]
for x in sous_corpus_idb_vect:
if not x[0] in sous_corpus_idb:
sous_corpus_idb.append(x[0])
print str(len(sous_corpus_idb)) +' documents \n'
correspondance_lemme_forme={}
for ligne in file_concepts.readlines():
lignev = ligne.split('\t')
liste_concepts.append((lignev[0].encode('utf-8','replace'),lignev[1].encode('utf-8','replace')))
correspondance_lemme_forme[lignev[0].encode('utf-8','replace')]=lignev[1].encode('utf-8','replace')
print "&&&",len(liste_concepts),"concepts now."
##si necessaire on recree la table concepts
#print liste_concepts
print 'on remplit la table concept'
fonctions_bdd.remplir_table_propre(name_bdd,'concepts',liste_concepts,['concepts','forme_principale'])
contenu = fonctions_bdd.select_bdd_table_champ_simple(name_bdd,'concepts','id,concepts')
liste_concepts_dico={}
for con in contenu:
liste_concepts_dico[con[1]]=con[0]
#on construit la liste des index des concepts dans l'ordre
ngrammes_fit_index=[]
#on calcule nos stats à l'échelle des auteurs aussi, freq = nombre de blogs parlant d'un terme
dictionnaire_frequence_exact_auteur={}
dictionnaire_frequence_exact={}
for terme in liste_concepts:
dictionnaire_frequence_exact[terme[0]]=0
dictionnaire_frequence_exact_auteur[terme[0]]=0
