def ngramme_fit(year):
Nb_rows = fonctions_bdd.count_rows_where(name_bdd,'billets'," where jours IN ('" + "','".join(list(map(str,year))) + "') ")
#Nb_rows = fonctions_bdd.count_rows(name_bdd,'billets')
Nb_auteurs = fonctions_bdd.count_rows(name_bdd,'auteurs')
size_seq = 1000
nb_sequences = Nb_rows/size_seq
billets_id=[]
ngramme_billets_fit=[]
ngrammes_auteurs_fit={}
formes_fit={}
#for x in range(nb_sequences+1):
for x in range(nb_sequences+1):
lim_d = str(size_seq*x)
if x<nb_sequences:
duration = str(size_seq)
else:
duration = str(size_seq)
where = " jours IN ('" + "','".join(list(map(str,year))) + "') "
sample = '1000000000'
contenu = fonctions_bdd.select_bdd_table_where_limite(name_bdd,'billets','id,content_lemmatise,content,auteur_id',sample,requete,where,lim_d+','+duration,Nb_rows)
#on indexe chaque billet et on recupere un triplet qui donne: la liste des ngrammes pour chaque billet, la liste des index des ngrammes pour chaque billet, et l'id des billets - ce script permet egalement de calculer les formes des n-lemmes.
include=1 #le parametre include permet d'activer ou non l'overlap de lemmes dans le comptage: si 1, les nicolas sarkozy ne forment pas de sarkozy
ngramme_billets_fit_x,billets_id_x,formes_x,ngrammes_auteurs_fit_x = text_processing.indexer_billet(contenu,ngrammes,maxTermLength,include)
billets_id = billets_id + billets_id_x
ngramme_billets_fit = ngramme_billets_fit + ngramme_billets_fit_x
formes_fit=fonctions_lib.merge(formes_fit, formes_x, lambda x,y: fonctions_lib.merge(x,y,lambda x,y:x+y))
ngrammes_auteurs_fit=fonctions_lib.merge(ngrammes_auteurs_fit,ngrammes_auteurs_fit_x,lambda x,y : extension(x,y))
print " + billets numéros "+ str(int(lim_d)+1)+ " à "+ str(int(lim_d)+int(duration)) +" indexés (sur "+ str(Nb_rows) +")"
return ngrammes_auteurs_fit, ngramme_billets_fit,formes_fit
def build_res_intertemp(zoom,seuil_intertemp,dyn_net_zoom,type_dist_inter,dist_mat,seuil_netermes):
res_intertemp_zoo={}
for zoo in zoom:
res_intertemp_zoo[zoo]={}
dyn_net=dyn_net_zoom[zoo]
for retni in range(len(years_bins))[:-1]:
inter = len(years_bins) - retni - 1
net_now = dyn_net[inter]
net_old = dyn_net[inter-1]
res_intertemp_retni = build_intertemp_links(net_now,net_old,dist_mat,seuil_netermes,seuil_intertemp,type_dist_inter)
res_intertemp_zoo[zoo]= fonctions_lib.merge(res_intertemp_zoo[zoo],res_intertemp_retni, lambda x,y:x+y)
return res_intertemp_zoo
def create_js_bar(liste_points,label_tubes,niv,fichier):
rge_y = range(years_bins[0][0], years_bins[-1][-1]+1)
dict_0 = dict_init(rge_y,0)
out =''
for label,points in zip(label_tubes,liste_points):
out = out + '\n"' + str(niv) + '*' + label[1:] + '"' + ': {'
points_complets = fonctions_lib.merge(to_dict(points),dict_0,lambda x,y:x+y)
points_ranges=[]
for x in rge_y:
points_ranges.append((points_complets[x]))
out = out + '\n' + str(niv) + ':'
out = out + str(points_ranges)# + ',' + '\n'
out = out + '},'
fichier.write(out)
def find_fathers(ch_now,champs_liste_old,dist_mat,seuil_netermes,seuil_intertemp,type_dist_inter):
periode_now = ch_now.periode
periode_old = periode_now - 1
score_overlap={}
if type_dist_inter == 'prox':
inter = ch_now.periode
liste_chp_old_termes={}
ch_now_termes_index = map(Terme.get_index,ch_now.termes.liste_termes)
for i,ch_old in enumerate(champs_liste_old):
ch_old_termes_index = map(Terme.get_index,ch_old.termes.liste_termes)
liste_chp_old_termes[i] = ch_old_termes_index
score_overlap[i]=(fonctions.calcul_distance(ch_now_termes_index,ch_old_termes_index,dist_mat,inter,'moy')+fonctions.calcul_distance(ch_old_termes_index,ch_now_termes_index,dist_mat,inter,'moy'))/2.
if type_dist_inter == 'jaccard':
# on construit le reseau de termes du champ courant now.
res_termes_now=under_net_termes(ch_now.termes.liste_termes,periode_now,seuil_netermes,dist_mat)
# res_termes_now est de type liste de liens.
liste_res_termes_old=[]
for ch_old in champs_liste_old:
liste_res_termes_old.append(under_net_termes(ch_old.termes.liste_termes,periode_old,seuil_netermes,dist_mat))
i=-1
for res_termes_old in liste_res_termes_old:
i=i+1
score_overlap[i] = overlap_pondere(res_termes_now,res_termes_old)
#score_overlap decrit ici l'overlap en nombre de liens entre clusters passes et futurs.
keymax = (max(score_overlap, key=score_overlap.get))
keymax=[keymax]
valmax = score_overlap[keymax[0]]
#puis on fait une deuxième passe pour chercher des couples de clusters éventuels.
ix = -1
for ante1 in score_overlap.keys()[:-1]:
ix = ix+1
if score_overlap[ante1]>0:
for ante2 in score_overlap.keys()[ix+1:]:
if score_overlap[ante2]>0:
if type_dist_inter == 'prox':
ch_olds_termes_index = unique(liste_chp_old_termes[ante1] + liste_chp_old_termes[ante2])
score = fonctions.calcul_distance(ch_now_termes_index,ch_olds_termes_index,dist_mat,inter,'moy')
score = score+fonctions.calcul_distance(ch_olds_termes_index,ch_now_termes_index,dist_mat,inter,'moy')
score = score / 2.
if type_dist_inter == 'jaccard':
res_termes_old_union = fonctions_lib.merge(liste_res_termes_old[ante1], liste_res_termes_old[ante2], lambda x,y:max(x,y))# a priori si 2 fois la même clé alors la valeur est identifique, puisque c'est la même période ...
score = overlap_pondere(res_termes_now,res_termes_old_union)
if score>valmax:
valmax = score
keymax = [ante1,ante2]
if valmax >seuil_intertemp:
return keymax,valmax
else:
return [],0
def find_tube_epaisseur(liste_champs): inters = unique(map(Champ.get_periode,liste_champs)) annees = range(years_bins[min(inters)][0],years_bins[max(inters)][-1]+1) tube_epaisseur= dict_init(annees) for champ in liste_champs: notices = champ.poids annees=years_bins[Champ.get_periode(champ)] epais = dict_init(annees) for notice in notices: annee =notice[1] notice_annee = notice[0] epais[annee]=epais[annee]+[notice_annee] #version dans laquelle on ne compte qu'une fois les notice multiples #tube_epaisseur=fonctions_lib.merge(tube_epaisseur,epais,lambda x,y:unique(x+y)) #version dans laquelle on compte n fois les notice multiples tube_epaisseur=fonctions_lib.merge(tube_epaisseur,epais,lambda x,y:(x+y)) return tube_epaisseur
def fast_ngram_counter(name_bdd,concept_list=''):
Nb_rows = fonctions_bdd.count_rows(name_bdd,'billets')
size_seq = 5000
nb_sequences = Nb_rows/size_seq
dictionnaire_gramme = {}#initialisation du dictionnaire de lemmes
billetprocessed_after_requete=0 #counts the number of processed posts
import multiprocessing
pool_size = min(nb_sequences+1,multiprocessing.cpu_count()*4)
pool = multiprocessing.Pool(processes=pool_size)
inputs=[]
for x in range(nb_sequences+1):
inputs.append((x,size_seq,Nb_rows,sample,nb_sequences,concept_list,name_bdd))
pool_outputs = pool.map(fast_ngram_counter_x, inputs)
dictionnaire_gramme={}
for dictionnaire_gramme_x in pool_outputs:
dictionnaire_gramme=fonctions_lib.merge(dictionnaire_gramme, dictionnaire_gramme_x, lambda x,y:x+y)
if concept_list=='':
dictionnaire_gramme = misc.freq_tri(dictionnaire_gramme,freqmin,int(math.floor(top*1.1)),language,ng_filter)#on effectue le tri de notre dictionnaire
return dictionnaire_gramme
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
print " + billets numéros "+ str(int(lim_d)+1)+ " à "+ str(int(lim_d)+int(duration)) +" indexés (sur "+ str(Nb_rows) +")"
return ngrammes_auteurs_fit, ngramme_billets_fit,formes_fit
pool_size = int(multiprocessing.cpu_count() / 2 * 3)
pool = multiprocessing.Pool(processes=pool_size)
pool_outputs = pool.map(ngramme_fit, years)
for y,x in enumerate(pool_outputs):
ngrammes_auteurs_fit_year[y]=x[0]
ngramme_billets_fit_year[y]=x[1]
formes_fit_year[y]=x[2]
formes={}
for formes_x in formes_fit_year.values():
formes=fonctions_lib.merge(formes, formes_x, lambda x,y: fonctions_lib.merge(x,y,lambda x,y:x+y))
dictionnaire_treetagged__formes_name = path_req + "Treetagger_n-lemmes_formes.txt"
dictionnaire_treetagged__formemajoritaire_name = path_req + "Treetagger_n-lemmes_formemajoritaire.txt"
text_processing.extraire_forme_majoritaire(0,formes,dictionnaire_treetagged__formes_name,dictionnaire_treetagged__formemajoritaire_name)
#N = float(len(ngramme_billets_fit))
#print " +" + str(N) + " billets indexés"
## on alimente la table concepts avec la liste des concepts trie et leur forme principale
file_concepts=codecs.open(dictionnaire_treetagged__formemajoritaire_name,'r','utf-8')
liste_concepts=[]
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')))
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))
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 == len(contenu) :
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)
fonctions_lib.dumpingin(dictionnaire_gramme,name_export_pkl,requete)
#on trie par fréquence et on exporte le lexique final avec les occurrences
print '\n'
dico_final = misc.freq_tri(dictionnaire_gramme,freqmin,int(math.floor(top*1.1)),language,ng_filter)#on effectue le tri de notre dictionnaire
#print dico_final
# redondance=0#pas otimise le machin, attention!!! revoir avant d'activer la fonctionnalite
# #redondance = 0, on n'utilise pas l'algo qui calcule avec la redondance !
# if redondance == 1:
# print "\n--- beginning processing redundant nlemmes "
# dico_final = misc.redondance_cleaner(dico_final)
#for x in range(nb_sequences+1): for x in range(nb_sequences+1): lim_d = str(size_seq*x) if x<nb_sequences: duration = str(size_seq) else: duration = str(size_seq) #duration = str(Nb_rows - size_seq*x) #on extrait les champs contenus lemmatises et id de la table contenu = fonctions_bdd.select_bdd_table_limite(name_bdd,'billets','id,content_lemmatise,content,auteur_id',requete,lim_d+','+duration) #on indexe chaque billet et on recupere un triplet qui donne: la liste des ngrammes pour chaque billet, la liste des index des ngrammes pour chaque billet, et l'id des billets - ce script permet egalement de calculer les formes des n-lemmes. include=1 #le parametre include permet d'activer ou non l'overlap de lemmes dans le comptage: si 1, les nicolas sarkozy ne forment pas de sarkozy ngramme_billets_fit_x,billets_id_x,formes_x,ngrammes_auteurs_fit_x = text_processing.indexer_billet(contenu,ngrammes,maxTermLength,include) billets_id = billets_id + billets_id_x ngramme_billets_fit = ngramme_billets_fit + ngramme_billets_fit_x formes=fonctions_lib.merge(formes, formes_x, lambda x,y: fonctions_lib.merge(x,y,lambda x,y:x+y)) ngrammes_auteurs_fit=fonctions_lib.merge(ngrammes_auteurs_fit,ngrammes_auteurs_fit_x,lambda x,y : extension(x,y)) print " + billets numéros "+ str(int(lim_d)+1)+ " à "+ str(int(lim_d)+int(duration)) +" indexés (sur "+ str(Nb_rows) +")" dictionnaire_treetagged__formes_name = path_req + "Treetagger_n-lemmes_formes.txt" dictionnaire_treetagged__formemajoritaire_name = path_req + "Treetagger_n-lemmes_formemajoritaire.txt" text_processing.extraire_forme_majoritaire(0,formes,dictionnaire_treetagged__formes_name,dictionnaire_treetagged__formemajoritaire_name) N = float(len(ngramme_billets_fit)) print " +" + str(N) + " billets indexés" ## on alimente la table concepts avec la liste des concepts trie et leur forme principale file_concepts=codecs.open(dictionnaire_treetagged__formemajoritaire_name,'r','utf-8') liste_concepts=[]
