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'
