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