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 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 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={} dictionnaire_frequence_exact={} N = fonctions_bdd.count_rows_where(name_bdd,'billets'," where jours IN ('" + "','".join(list(map(str,year))) + "') ") for terme in liste_concepts: dictionnaire_frequence_exact[terme[0]]=0 dictionnaire_frequence_exact_auteur[terme[0]]=0 for clique in ngramme_billets_fit: clique_index=[] for terme in set(clique): clique_index.append(liste_concepts_dico[terme]) dictionnaire_frequence_exact[terme]=dictionnaire_frequence_exact[terme]+1 ngrammes_fit_index.append(clique_index) print " + liste des index des concepts creee" for aut,clique in ngrammes_auteurs_fit.iteritems(): for terme in set(clique): dictionnaire_frequence_exact_auteur[terme]=dictionnaire_frequence_exact_auteur[terme]+1 print " + liste des index des concepts creee" file_freq_exact = path_req +'years/'+ requete +str(year) + '_' + 'frequences_exactes.csv' fichier_out =file(file_freq_exact,'w') def format(value): return "%.9f" % value for x in dictionnaire_frequence_exact: # print str(x) + '\t' + str(correspondance_lemme_forme[x]) +'\t' + (str(format(float(dictionnaire_frequence_exact[x])/N))).replace('.',',') +'\t' + (str(format(float(dictionnaire_frequence_exact_auteur[x])/float(Nb_auteurs)))).replace('.',',')+ '\n' fichier_out.write(str(x) + '\t' + str(correspondance_lemme_forme[x]) +'\t' + (str(format(float(dictionnaire_frequence_exact[x])/N))).replace('.',',') +'\t' + (str(format(float(dictionnaire_frequence_exact_auteur[x])/float(Nb_auteurs)))).replace('.',',')+ '\n') print " + frequences exactes calculees "+ file_freq_exact
################################### #fonction d'affichage, champ par champ #champs_name = ["title","date","permalink","site","categorie1","categorie2","categorie3","content_html","content","href","requete","identifiant_unique"] #for cha in champs_name[6:8]: # fonctions_bdd.afficher_bdd_table(name_bdd,name_table,cha,requete) ################################### #######2.Analyse contenu########### ################################### lemmatisation=1#on active/desactive la phase de lemmatisation des billets brutes #!!!!!!!!utiliser lemmadictionary=1 si dictionnaire des lemmes deja calculé pour eviter de refaire une passe inutile lemmadictionary=0 Nb_rows = fonctions_bdd.count_rows(name_bdd,'billets') name_export_pkl=requete + '_dico_'+str(sample)+'_'+str(Nb_rows) + '_year' name_export_lemme_pkl = requete + '_lemme_'+str(sample)+'_'+str(Nb_rows) #on recupere d'abord toutes les années en base years=parameters.years_bins_no_overlap def do_calculation(year): print str(year) + ' being processed ' where = " jours IN ('" + "','".join(list(map(str,year))) + "') "
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')
if user_interface =='y': var = raw_input('reduire la liste avant de lancer l\'indexation ? (y pour arreter, tout autre touche pour continuer)') else: var = 'n' if var=='y': exit() ################################### #####indexation des billets######## ################################### def extension(x,y): x.extend(y) return list(set(x)) #il faut découper ici car ça prend trop de RAM 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={} #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)
#il faut découper ici car ça prend trop de RAM #decoupage annuel: #on recupere d'abord toutes les années en base years=parameters.years_bins_no_overlap #puis on itere sur chaque tranche: ngrammes_auteurs_fit_year={} ngramme_billets_fit_year={} formes={} for y,year in enumerate(years): 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={} #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 = '100000000'