def index_dir(self, root, **args):
"""
NECESARIO PARA TODAS LAS VERSIONES
Recorre recursivamente el directorio "root" y indexa su contenido
los argumentos adicionales "**args" solo son necesarios para las funcionalidades ampliadas
"""
self.multifield = args['multifield']
self.positional = args['positional']
self.stemming = args['stem']
self.permuterm = args['permuterm']
self.approximate = args['approximate']
# Variable secuencial que representa el id de un fichero
for dir, _, files in os.walk(root):
for filename in files:
if filename.endswith('.json'):
fullname = os.path.join(dir, filename)
self.index_file(fullname)
# Si se activa la función de stemming
if self.stemming:
self.make_stemming()
# Si se activa la función de permuterm
if self.permuterm:
self.make_permuterm()
# ALGORITMICA
# Si se activa la función approximate
if self.approximate:
with open('{}_voc'.format(args['index']), 'w') as tmp_file:
for field in self.index.items():
for term in field[1].keys():
tmp_file.write("{}\n".format(term))
self.spellsuggester = SpellSuggester('{}_voc'.format(
args['index']))
def index_dir(self, root, **args):
"""
NECESARIO PARA TODAS LAS VERSIONES
Recorre recursivamente el directorio "root" e indexa su contenido
los argumentos adicionales "**args" solo son necesarios para las funcionalidades ampliadas
"""
self.multifield = args['multifield']
self.positional = args['positional']
self.stemming = args['stem']
self.permuterm = args['permuterm']
self.suggestion = args['suggestion']
if self.multifield:
for field, _ in SAR_Project.fields:
self.index[field] = {}
print("Root : " + root)
if self.suggestion:
self.spellsuggester = SpellSuggester(root)
for dir, subdirs, files in os.walk(root):
for filename in files:
if filename.endswith('.json'):
fullname = os.path.join(dir, filename)
self.index_file(fullname)
if self.stemming:
self.make_stemming()
if self.permuterm:
self.make_permuterm()
class SAR_Project:
"""
Prototipo de la clase para realizar la indexacion y la recuperacion de noticias
Preparada para todas las ampliaciones:
parentesis + multiples indices + posicionales + stemming + permuterm + ranking de resultado
Se deben completar los metodos que se indica.
Se pueden añadir nuevas variables y nuevos metodos
Los metodos que se añadan se deberan documentar en el codigo y explicar en la memoria
"""
# lista de campos, el booleano indica si se debe tokenizar el campo
# NECESARIO PARA LA AMPLIACION MULTIFIELD
fields = [("title", True), ("date", False), ("keywords", True),
("article", True), ("summary", True)]
# numero maximo de documento a mostrar cuando self.show_all es False
SHOW_MAX = 10
def __init__(self):
"""
Constructor de la classe SAR_Indexer.
NECESARIO PARA LA VERSION MINIMA
Incluye todas las variables necesaria para todas las ampliaciones.
Puedes añadir más variables si las necesitas
"""
self.index = {
} # hash para el indice invertido de terminos --> clave: termino, valor: posting list.
# Si se hace la implementacion multifield, se pude hacer un segundo nivel de hashing de tal forma que:
# self.index['title'] seria el indice invertido del campo 'title'.
self.sindex = {
} # hash para el indice invertido de stems --> clave: stem, valor: lista con los terminos que tienen ese stem
self.ptindex = {} # hash para el indice permuterm.
self.docs = {
} # diccionario de terminos --> clave: entero(docid), valor: ruta del fichero.
self.weight = {
} # hash de terminos para el pesado, ranking de resultados. puede no utilizarse
self.news = {
} # hash de noticias --> clave: entero (newid), valor: la info necesaria para diferencia la noticia dentro de su fichero
self.tokenizer = re.compile(
"\W+") # expresion regular para hacer la tokenizacion
self.stemmer = SnowballStemmer('spanish') # stemmer en castellano
self.show_all = False # valor por defecto, se cambia con self.set_showall()
self.show_snippet = False # valor por defecto, se cambia con self.set_snippet()
self.use_stemming = False # valor por defecto, se cambia con self.set_stemming()
self.use_ranking = False # valor por defecto, se cambia con self.set_ranking()
self.doc_id = 0
self.new_id = 0 # También sirve para contar el número de noticias indexadas
###############################
### ###
### CONFIGURACION ###
### ###
###############################
def set_showall(self, v):
"""
Cambia el modo de mostrar los resultados.
input: "v" booleano.
UTIL PARA TODAS LAS VERSIONES
si self.show_all es True se mostraran todos los resultados el lugar de un maximo de self.SHOW_MAX, no aplicable a la opcion -C
"""
self.show_all = v
def set_snippet(self, v):
"""
Cambia el modo de mostrar snippet.
input: "v" booleano.
UTIL PARA TODAS LAS VERSIONES
si self.show_snippet es True se mostrara un snippet de cada noticia, no aplicable a la opcion -C
"""
self.show_snippet = v
def set_stemming(self, v):
"""
Cambia el modo de stemming por defecto.
input: "v" booleano.
UTIL PARA LA VERSION CON STEMMING
si self.use_stemming es True las consultas se resolveran aplicando stemming por defecto.
"""
self.use_stemming = v
def set_ranking(self, v):
"""
Cambia el modo de ranking por defecto.
input: "v" booleano.
UTIL PARA LA VERSION CON RANKING DE NOTICIAS
si self.use_ranking es True las consultas se mostraran ordenadas, no aplicable a la opcion -C
"""
self.use_ranking = v
###############################
### ###
### PARTE 1: INDEXACION ###
### ###
###############################
def index_dir(self, root, **args):
"""
NECESARIO PARA TODAS LAS VERSIONES
Recorre recursivamente el directorio "root" e indexa su contenido
los argumentos adicionales "**args" solo son necesarios para las funcionalidades ampliadas
"""
self.multifield = args['multifield']
self.positional = args['positional']
self.stemming = args['stem']
self.permuterm = args['permuterm']
self.suggestion = args['suggestion']
if self.multifield:
for field, _ in SAR_Project.fields:
self.index[field] = {}
print("Root : " + root)
if self.suggestion:
self.spellsuggester = SpellSuggester(root)
for dir, subdirs, files in os.walk(root):
for filename in files:
if filename.endswith('.json'):
fullname = os.path.join(dir, filename)
self.index_file(fullname)
if self.stemming:
self.make_stemming()
if self.permuterm:
self.make_permuterm()
def index_file(self, filename):
"""
NECESARIO PARA TODAS LAS VERSIONES
Indexa el contenido de un fichero.
Para tokenizar la noticia se debe llamar a "self.tokenize"
Dependiendo del valor de "self.multifield" y "self.positional" se debe ampliar el indexado.
En estos casos, se recomienda crear nuevos metodos para hacer mas sencilla la implementacion
input: "filename" es el nombre de un fichero en formato JSON Arrays (https://www.w3schools.com/js/js_json_arrays.asp).
Una vez parseado con json.load tendremos una lista de diccionarios, cada diccionario se corresponde a una noticia
"""
with open(filename) as fh:
news_list = json.load(fh)
#
# "news_list" es una lista con tantos elementos como noticias hay en el fichero,
# cada noticia es un diccionario con los campos:
# "title", "date", "keywords", "article", "summary"
#
# En la version basica solo se debe indexar el contenido "article"
#
#
#
new_pos = 0
for new in news_list:
self.news[self.new_id] = (self.doc_id, new_pos)
if self.multifield:
for field, tokenize in SAR_Project.fields:
content = new[field]
if tokenize:
content = self.tokenize(content)
term_pos = 0
for term in content:
self.index_term(term, self.new_id, term_pos, field)
term_pos += 1
else:
self.index_term(content, self.new_id, 0, field)
else:
content = self.tokenize(new['article'])
term_pos = 0
for term in content:
self.index_term(term, self.new_id, term_pos)
term_pos += 1
self.new_id += 1
def index_term(self, term, new_id, pos, field='article'):
index = self.index[field] if self.multifield else self.index
news_dic = index.get(term, None)
if news_dic is None:
index[term] = {new_id: [pos]} if self.positional else [new_id]
else:
if self.positional:
if new_id in news_dic.keys():
news_dic[new_id].append(pos)
else:
news_dic[new_id] = [pos]
index[term] = news_dic
else:
index[term].append(new_id)
def tokenize(self, text):
"""
NECESARIO PARA TODAS LAS VERSIONES
Tokeniza la cadena "texto" eliminando simbolos no alfanumericos y dividientola por espacios.
Puedes utilizar la expresion regular 'self.tokenizer'.
params: 'text': texto a tokenizar
return: lista de tokens
"""
return self.tokenizer.sub(' ', text.lower()).split()
def make_stemming(self): # TODO: Check if it works
"""
NECESARIO PARA LA AMPLIACION DE STEMMING.
Crea el indice de stemming (self.sindex) para los terminos de todos los indices.
self.stemmer.stem(token) devuelve el stem del token
"""
if self.multifield:
for field, _ in SAR_Project.fields:
self.sindex[field] = {}
inv_index = self.index[field]
for term in inv_index.keys():
stem = self.stemmer.stem(term)
if stem not in self.sindex[field]:
self.sindex[field][stem] = []
else:
self.sindex[field][stem].append(term)
else:
self.sindex = {}
for term in self.index.keys():
stem = self.stemmer.stem(term)
if stem not in self.sindex:
self.sindex[stem] = []
else:
self.sindex[stem].append(term)
def make_permuterm(self):
"""
NECESARIO PARA LA AMPLIACION DE PERMUTERM
Crea el indice permuterm (self.ptindex) para los terminos de todos los indices.
"""
if self.multifield:
self.ptindex = {}
for field, _ in SAR_Project.fields:
self.ptindex[field] = []
inv_index = self.index[field]
for term in inv_index.keys():
permuterms = self.generate_permuterms(term)
for p in permuterms:
bisect.insort_left(self.ptindex[field], (p, term))
else:
self.ptindex = []
for term in self.index.keys():
permuterms = self.generate_permuterms(term)
for p in permuterms:
bisect.insort_left(self.ptindex, (p, term))
def generate_permuterms(self, term):
term += '$'
return [term[i:] + term[:i] for i in range(len(term))]
def show_stats(self):
"""
NECESARIO PARA TODAS LAS VERSIONES
Muestra estadisticas de los indices
"""
print("===================================================")
print(
f"Number of indexed days: {len(self.index['date'] if self.multifield else '')}"
)
print("---------------------------------------------------")
print(f"Number of indexed news: {self.new_id}")
print("---------------------------------------------------")
print("TOKENS: ")
if self.multifield:
for field, _ in self.fields:
print(
f" # of tokens in '{field}' : {len(self.index[field])} "
)
if self.suggestion:
print(
f" # of words in spellsuggest: {len(self.spellsuggester.vocabulary)} "
)
else:
print(f" # of tokens in 'article' : {len(self.index)}")
if self.permuterm:
print("---------------------------------------------------")
print("PERMUTERMS: ")
if self.multifield:
for field, _ in self.fields:
print(
f" # of permuterms in '{field}' : {len(self.ptindex[field])} "
)
else:
print(
f" # of permuterms in 'article' : {len(self.ptindex)}"
)
if self.stemming:
print("---------------------------------------------------")
print("STEMS: ")
if self.multifield:
for field, _ in self.fields:
print(
f" # of stems in '{field}' : {len(self.sindex[field])} "
)
else:
print(f" # of stems in 'article' : {len(self.sindex)}")
if self.positional:
print("---------------------------------------------------")
print("Positional queries are allowed")
else:
print("---------------------------------------------------")
print("Positional queries are NOT allowed")
print("===================================================")
###################################
### ###
### PARTE 2.1: RECUPERACION ###
### ###
###################################
def solve_query(self, query, prev={}):
"""
NECESARIO PARA TODAS LAS VERSIONES
Resuelve una query.
Debe realizar el parsing de consulta que sera mas o menos complicado en funcion de la ampliacion que se implementen
param: "query": cadena con la query
"prev": incluido por si se quiere hacer una version recursiva. No es necesario utilizarlo.
return: posting list con el resultado de la query
"""
if query is None or query == '' or len(query) == 0:
return []
connectors = ['AND', 'OR', 'NOT']
query_list = query.split()
query_list = list(
map(lambda x: x.split(':')[::-1] if ':' in x else [x],
query_list)) # separamos termino y campo si hay ':'
# One word query
if len(query_list) == 1 and query not in connectors:
posting_list = self.get_posting(*query_list[0])
if self.suggestion and len(posting_list) == 0:
posting_list = self.search_suggestions(*query_list[0])
return posting_list
# esta linea hace lo mismo que el bucle for de abajo
# terms_postings = {i: self.get_posting(*t) for i, t in enumerate(query_list) if t[0] not in connectors}
terms_postings = {}
term_pos = 0
for term in query_list:
if len(term) == 1:
if term[0] not in connectors:
posting_list = self.get_posting(*term)
if self.suggestion and len(posting_list) == 0:
terms_postings[term_pos] = self.search_suggestions(
*term)
terms_postings[term_pos] = posting_list
else:
posting_list = self.get_posting(*term)
if self.suggestion and len(posting_list) == 0:
terms_postings[term_pos] = self.search_suggestions(*term)
terms_postings[term_pos] = posting_list
term_pos = term_pos + 1
query_list = query.split()
x = 0
while x < len(query_list) - 1:
if query_list[x] == 'NOT':
terms_postings[x + 1] = self.reverse_posting(
terms_postings.get(x + 1))
elif query_list[x] == 'AND':
prev_term_posting = terms_postings.get(x - 1)
if query_list[x + 1] == 'NOT':
second_term_posting = self.reverse_posting(
terms_postings.get(x + 2))
terms_postings[x + 2] = self.and_posting(
prev_term_posting, second_term_posting)
x += 1 # Avanzo para no repetir el NOT
else:
terms_postings[x + 1] = self.and_posting(
prev_term_posting, terms_postings.get(x + 1))
elif query_list[x] == 'OR':
prev_term_posting = terms_postings.get(x - 1)
if query_list[x + 1] == 'NOT':
second_term_posting = self.reverse_posting(
terms_postings.get(x + 2))
terms_postings[x + 2] = self.or_posting(
prev_term_posting, second_term_posting)
x += 1 # Avanzo para no repetir el NOT
else:
terms_postings[x + 1] = self.or_posting(
prev_term_posting, terms_postings.get(x + 1))
x += 1
return terms_postings[len(query_list) - 1]
def search_suggestions(self, term):
suggested = self.spellsuggester.suggest(term, "restricted", 2)
query = ''
words = list(suggested.keys())
for i in range(len(words)):
if i < len(words) - 1:
query += str(words[i]) + " OR "
else:
query += str(words[i])
posting_list = self.solve_query(query)
return posting_list
def get_posting(self, term, field='article'):
"""
NECESARIO PARA TODAS LAS VERSIONES
Devuelve la posting list asociada a un termino.
Dependiendo de las ampliaciones implementadas "get_posting" puede llamar a:
- self.get_positionals: para la ampliacion de posicionales
- self.get_permuterm: para la ampliacion de permuterms
- self.get_stemming: para la amplaicion de stemming
param: "term": termino del que se debe recuperar la posting list.
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices
return: posting list
"""
index = self.index[field] if self.multifield else self.index
if '*' in term or '?' in term:
return self.get_permuterm(term)
elif self.use_stemming:
return self.get_stemming(term, field)
if index.get(term) is None:
return []
else:
res_con_repetidos = list(index.get(term))
res = []
for i in res_con_repetidos:
if i not in res:
res.append(i)
return res
def get_positionals(self, terms, field='article'):
"""
NECESARIO PARA LA AMPLIACION DE POSICIONALES
Devuelve la posting list asociada a una secuencia de terminos consecutivos.
param: "terms": lista con los terminos consecutivos para recuperar la posting list.
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices
return: posting list
"""
index = self.index[field] if self.multifield else self.index
pass
########################################################
## COMPLETAR PARA FUNCIONALIDAD EXTRA DE POSICIONALES ##
########################################################
def get_stemming(self, term, field='article'): # TODO: Check if it works
"""
NECESARIO PARA LA AMPLIACION DE STEMMING
Devuelve la posting list asociada al stem de un termino.
param: "term": termino para recuperar la posting list de su stem.
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices
return: posting list
"""
index = self.index[field] if self.multifield else self.index
sindex = self.sindex[field] if self.multifield else self.sindex
stem = self.stemmer.stem(term)
# res = [x for x in [index[t] for t in sindex[stem] if stem in sindex.keys()]] + index[stem] if stem in index.keys() else []
res = []
if stem in index.keys():
res.extend(index[stem])
if stem in list(sindex.keys()):
for t in sindex[stem]:
res.extend(index[t])
return res
def get_permuterm(self, term, field='article'): # TODO: Check if it works
"""
NECESARIO PARA LA AMPLIACION DE PERMUTERM
Devuelve la posting list asociada a un termino utilizando el indice permuterm.
param: "term": termino para recuperar la posting list, "term" incluye un comodin (* o ?).
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices
return: posting list
"""
index = self.index[field] if self.multifield else self.index
if '*' in term:
p1, p2 = term.split('*')
query = p2 + '$' + p1
terms = [t for p, t in self.ptindex[field] if p.startswith(query)]
return [x for x in [index[t] for t in terms]]
else:
p1, p2 = term.split('?')
query = p2 + '$' + p1
q_len = len(query)
terms = [
t for p, t in self.ptindex[field]
if p.startswith(query) and len(t) - q_len <= 1
]
return [x for x in [index[t] for t in terms]]
def reverse_posting(self, p):
"""
NECESARIO PARA TODAS LAS VERSIONES
Devuelve una posting list con todas las noticias excepto las contenidas en p.
Util para resolver las queries con NOT.
param: "p": posting list
return: posting list con todos los newid exceptos los contenidos en p
"""
full_list = list(self.news.keys())
return [x for x in full_list if x not in p]
# res = []
# x = y = 0
#
# while x < len(full_list) and y < len(p):
# if full_list[x] == p[y]:
# x = x + 1
# y = y + 1
#
# else:
# res.append(full_list[x])
# x = x + 1
#
# while x < len(full_list):
# res.append(full_list[x])
# x = x + 1
#
# return res
def and_posting(self, p1, p2):
"""
NECESARIO PARA TODAS LAS VERSIONES
Calcula el AND de dos posting list de forma EFICIENTE
param: "p1", "p2": posting lists sobre las que calcular
return: posting list con los newid incluidos en p1 y p2
"""
if p1 is None or p2 is None or len(p1) == 0 or len(p2) == 0:
return []
# return [x for x in p1 if x in p2]
res = []
x = y = 0
while x < len(p1) and y < len(p2):
if p1[x] == p2[y]:
res.append(p1[x])
x = x + 1
y = y + 1
else:
if p1[x] < p2[y]:
x = x + 1
else:
y = y + 1
return res
def or_posting(self, p1, p2):
"""
NECESARIO PARA TODAS LAS VERSIONES
Calcula el OR de dos posting list de forma EFICIENTE
param: "p1", "p2": posting lists sobre las que calcular
return: posting list con los newid incluidos de p1 o p2
"""
if p1 is None or p2 is None or len(p1) == 0 or len(p2) == 0:
return []
# return p1 + [x for x in p2 if x not in p1]
res = []
x = y = 0
while x < len(p1) and y < len(p2):
if p1[x] == p2[y]:
res.append(p1[x])
x += 1
y += 1
else:
if p1[x] > p2[y]:
res.append(p2[y])
y += 1
else:
res.append(p1[x])
x += 1
while x < len(p1):
res.append(p1[x])
x += 1
while y < len(p2):
res.append(p2[y])
y += 1
return res
# TODO: revisar porque falla cuando lo uso (El and not queria hacerlo con este metodo pero falla)
def minus_posting(self, p1, p2):
"""
OPCIONAL PARA TODAS LAS VERSIONES
Calcula el except de dos posting list de forma EFICIENTE.
Esta funcion se propone por si os es util, no es necesario utilizarla.
param: "p1", "p2": posting lists sobre las que calcular
return: posting list con los newid incluidos de p1 y no en p2
"""
if p1 is None or p2 is None or len(p1) == 0 or len(p2) == 0:
return []
# return [x for x in p1 if x not in p2]
res = []
x = y = 0
while x < len(p1) and y < len(p2):
if p1[x] == p2[y]:
x += 1
y += 1
else:
res.append(p1[x])
x += 1
while x < len(p1):
res.append(p1[x])
x += 1
return res
#####################################
### ###
### PARTE 2.2: MOSTRAR RESULTADOS ###
### ###
#####################################
def solve_and_count(self, query):
"""
NECESARIO PARA TODAS LAS VERSIONES
Resuelve una consulta y la muestra junto al numero de resultados
param: "query": query que se debe resolver.
return: el numero de noticias recuperadas, para la opcion -T
"""
result = self.solve_query(query)
print("%s\t%d" % (query, len(result)))
return len(result) # para verificar los resultados (op: -T)
def solve_and_show(self, query):
"""
NECESARIO PARA TODAS LAS VERSIONES
Resuelve una consulta y la muestra informacion de las noticias recuperadas.
Consideraciones:
- En funcion del valor de "self.show_snippet" se mostrara una informacion u otra.
- Si se implementa la opcion de ranking y en funcion del valor de self.use_ranking debera llamar a self.rank_result
param: "query": query que se debe resolver.
return: el numero de noticias recuperadas, para la opcion -T
"""
result = self.solve_query(query)
if self.use_ranking:
result = self.rank_result(result, query)
print("===================================================")
print(f"Query: {query}")
print(f"Number of results: {len(result)}")
# for news_id in result:
# print(news_id)
print("=================================================")
def rank_result(self, result, query):
"""
NECESARIO PARA LA AMPLIACION DE RANKING
Ordena los resultados de una query.
param: "result": lista de resultados sin ordenar
"query": query, puede ser la query original, la query procesada o una lista de terminos
return: la lista de resultados ordenada
"""
return ['Completar']
# -*- coding: utf-8 -*-
from spellsuggest import SpellSuggester
if __name__ == "__main__":
spellsuggester = SpellSuggester("./corpora/quijote.txt")
for distance in ['levenshtein', 'restricted', 'intermediate']:
destiny = f'result_{distance}_quijote.txt'
with open(destiny, "w", encoding='utf-8') as fw:
for palabra in ("casa", "senor", "jabón", "constitución", "ancho",
"savaedra", "vicios", "quixot", "s3afg4ew"):
for threshold in range(1, 6):
resul = spellsuggester.suggest(palabra,
distance=distance,
threshold=threshold)
numresul = len(resul)
resul = " ".join(
sorted(f'{v}:{k}' for k, v in resul.items()))
fw.write(f'{palabra}\t{threshold}\t{numresul}\t{resul}\n')
from spellsuggest import TrieSpellSuggester
from spellsuggest import SpellSuggester
spellsuggester = TrieSpellSuggester("./corpora/quijote.txt")
res = spellsuggester.suggest("casa", "levenshtein", 1)
print(len(res))
print(res)
res = spellsuggester.suggest("casa", "restricted", 1)
print(len(res))
print(res)
res = spellsuggester.suggest("casa", "intermediate", 1)
print(len(res))
print(res)
spellsuggester = SpellSuggester("./corpora/quijote.txt")
res = spellsuggester.suggest("casa", "levenshtein", 1)
print(len(res))
print(res)
res = spellsuggester.suggest("casa", "restricted", 1)
print(len(res))
print(res)
res = spellsuggester.suggest("casa", "intermediate", 1)
print(len(res))
print(res)
from spellsuggest import SpellSuggester
from spellsuggest import TrieSpellSuggester
import time
if __name__ == "__main__":
vocab_file_path = "./corpora/quijote.txt"
tokenizer = re.compile("\W+")
with open(vocab_file_path, "r", encoding='utf-8') as fr:
c = collections.Counter(tokenizer.split(fr.read().lower()))
if '' in c:
del c['']
reversed_c = [(freq, word) for (word, freq) in c.items()]
sorted_reversed = sorted(reversed_c, reverse=True)
sorted_vocab = [word for (freq, word) in sorted_reversed]
suggester = SpellSuggester(vocab_file_path)
trie_suggester = TrieSpellSuggester(vocab_file_path)
for t in [10, 100, 1000, 10000]:
print("Size " + str(t))
testVoc = sorted([sorted_vocab[i] for i in range(t)
]) # Distintas tallas del dicionario
suggester.changeVocabulary(testVoc)
trie_suggester.changeVocabulary(testVoc)
funcs = ["levenshtein", "restricted", "intermediate"]
for th in [1, 2, 3, 4, 5]: # Distintos thresholds
print(f'Threshold está en : {th}')
for f in range(len(funcs)):
print("\tFunction: " + funcs[f])
totalT = 0.0
class SAR_Project:
"""
Prototipo de la clase para realizar la indexacion y la recuperacion de noticias
Preparada para todas las ampliaciones:
parentesis + multiples indices + posicionales + stemming + permuterm + ranking de resultado
Se deben completar los metodos que se indica.
Se pueden añadir nuevas variables y nuevos metodos
Los metodos que se añadan se deberan documentar en el codigo y explicar en la memoria
"""
# Campos a tokenizar
fields = [("title", True), ("date", True), ("keywords", True),
("article", True), ("summary", True)]
# numero maximo de documento a mostrar cuando self.show_all es False
SHOW_MAX = 10
def __init__(self):
"""
Constructor de la classe SAR_Indexer.
NECESARIO PARA LA VERSION MINIMA
Incluye todas las variables necesaria para todas las ampliaciones.
Puedes añadir más variables si las necesitas
"""
self.index = {
'title': {},
'date': {},
'keywords': {},
'article': {},
'summary': {}
} # hash para el indice invertido de terminos --> clave: termino, valor: posting list / ocurrencias.
self.sindex = {
'title': {},
'date': {},
'keywords': {},
'article': {},
'summary': {}
} # hash para el indice invertido de stems --> clave: stem, valor: lista con los terminos que tienen ese stem.
self.ptindex = {
'title': {},
'date': {},
'keywords': {},
'article': {},
'summary': {}
} # hash para el indice permuterm.
# diccionario de terminos --> clave: entero(docid), valor: ruta del fichero.
self.docs = {}
# hash de noticias --> clave entero (newid), valor: la info necesaria para diferencia la noticia dentro de su fichero
self.news = {}
# expresion regular para hacer la tokenizacion
self.tokenizer = re.compile(r'\W+')
self.stemmer = SnowballStemmer('spanish') # stemmer en castellano
self.show_all = False # valor por defecto, se cambia con self.set_showall()
self.show_snippet = False # valor por defecto, se cambia con self.set_snippet()
self.use_stemming = False # valor por defecto, se cambia con self.set_stemming()
self.use_ranking = False # valor por defecto, se cambia con self.set_ranking()
self.doc_cont = 0
self.new_cont = 0
# ALGORITMICA
self.use_approximate = False # valor por defecto, se cambia con self.set_approximate()
###############################
### ###
### CONFIGURACION ###
### ###
###############################
def set_showall(self, v):
"""
Cambia el modo de mostrar los resultados.
input: "v" booleano.
UTIL PARA TODAS LAS VERSIONES
si self.show_all es True se mostraran todos los resultados el lugar de un maximo de self.SHOW_MAX, no aplicable a la opcion -C
"""
self.show_all = v
def set_snippet(self, v):
"""
Cambia el modo de mostrar snippet.
input: "v" booleano.
UTIL PARA TODAS LAS VERSIONES
si self.show_snippet es True se mostrara un snippet de cada noticia, no aplicable a la opcion -C
"""
self.show_snippet = v
def set_stemming(self, v):
"""
Cambia el modo de stemming por defecto.
input: "v" booleano.
UTIL PARA LA VERSION CON STEMMING
si self.use_stemming es True las consultas se resolveran aplicando stemming por defecto.
"""
self.use_stemming = v
def set_ranking(self, v):
"""
Cambia el modo de ranking por defecto.
input: "v" booleano.
UTIL PARA LA VERSION CON RANKING DE NOTICIAS
si self.use_ranking es True las consultas se mostraran ordenadas, no aplicable a la opcion -C
"""
self.use_ranking = v
# ALGORITMICA
def set_approximate(self, v, dis, thr):
"""
Cambia el modo de approximate por defecto.
input: "v" booleano.
UTIL PARA ALGORITMICA
si self.use_approximate es True, si una palabra no devuelve resultados, se buscará con una sugerencia
"""
self.use_approximate = v
self.app_distance = dis
self.app_thr = thr
###############################
### ###
### PARTE 1: INDEXACION ###
### ###
###############################
def index_dir(self, root, **args):
"""
NECESARIO PARA TODAS LAS VERSIONES
Recorre recursivamente el directorio "root" y indexa su contenido
los argumentos adicionales "**args" solo son necesarios para las funcionalidades ampliadas
"""
self.multifield = args['multifield']
self.positional = args['positional']
self.stemming = args['stem']
self.permuterm = args['permuterm']
self.approximate = args['approximate']
# Variable secuencial que representa el id de un fichero
for dir, _, files in os.walk(root):
for filename in files:
if filename.endswith('.json'):
fullname = os.path.join(dir, filename)
self.index_file(fullname)
# Si se activa la función de stemming
if self.stemming:
self.make_stemming()
# Si se activa la función de permuterm
if self.permuterm:
self.make_permuterm()
# ALGORITMICA
# Si se activa la función approximate
if self.approximate:
with open('{}_voc'.format(args['index']), 'w') as tmp_file:
for field in self.index.items():
for term in field[1].keys():
tmp_file.write("{}\n".format(term))
self.spellsuggester = SpellSuggester('{}_voc'.format(
args['index']))
def index_file(self, filename):
"""
NECESARIO PARA TODAS LAS VERSIONES
Indexa el contenido de un fichero.
Para tokenizar la noticia se debe llamar a "self.tokenize"
Dependiendo del valor de "self.multifield" y "self.positional" se debe ampliar el indexado.
En estos casos, se recomienda crear nuevos metodos para hacer mas sencilla la implementacion
input: "filename" es el nombre de un fichero en formato JSON Arrays (https://www.w3schools.com/js/js_json_arrays.asp).
Una vez parseado con json.load tendremos una lista de diccionarios, cada diccionario se corresponde a una noticia
"""
# Un fichero esta compuesto por noticias, cada noticia por cinco campos y cada campo por unos tokens
with open(filename) as fh:
jlist = json.load(fh)
self.docs[self.doc_cont] = filename
# Contador de la posición de una noticia en un fichero
contador_noticia = 0
for noticia in jlist:
# Se añade al diccionario de noticias la noticia con clave -> self.new_cont, valor -> (filename, contador_noticia)
self.news[self.new_cont] = [self.doc_cont, contador_noticia]
# Si se activa la función de multifield
if self.multifield:
multifield = [
'title', 'date', 'keywords', 'article', 'summary'
]
# Si no, se procesa article y date (nos interesa para una métrica posterior)
else:
multifield = ['article', 'date']
# Se tokeniza el cotenido de cada campo (menos el de date)
for field in multifield:
if field != 'date':
contenido = self.tokenize(noticia[field])
else:
contenido = [noticia[field]]
# Contador de la posición de un token en una noticia
posicion_token = 0
for token in contenido:
# Si el token no esta en el diccionario de tokens, se añade
if token not in self.index[field]:
if not self.positional:
self.index[field][token] = {self.new_cont: 1}
else:
self.index[field][token] = {
self.new_cont: [posicion_token]
}
# Si el token esta ya...
else:
# ...si no existe la noticia en el token, se añade
if self.new_cont not in self.index[field][token]:
if not self.positional:
self.index[field][token][self.new_cont] = 1
else:
self.index[field][token][self.new_cont] = [
posicion_token
]
else:
# Si no, se añade a la entrada del token-noticia la posición donde se ha encontrado
if not self.positional:
self.index[field][token][
self.new_cont] += 1
else:
self.index[field][token][
self.new_cont] += [posicion_token]
posicion_token += 1
self.new_cont += 1
contador_noticia += 1
self.doc_cont += 1
def tokenize(self, text):
"""
NECESARIO PARA TODAS LAS VERSIONES
Tokeniza la cadena "texto" eliminando simbolos no alfanumericos y dividientola por espacios.
Puedes utilizar la expresion regular 'self.tokenizer'.
params: 'text': texto a tokenizar
return: lista de tokens
"""
return self.tokenizer.sub(' ', text.lower()).split()
def make_stemming(self):
"""
NECESARIO PARA LA AMPLIACION DE STEMMING.
Crea el indice de stemming (self.sindex) para los terminos de todos los indices.
self.stemmer.stem(token) devuelve el stem del token
"""
# Si se activa la función multifield
if self.multifield:
multifield = ['title', 'date', 'keywords', 'article', 'summary']
else:
multifield = ['article']
for field in multifield:
# Se aplica stemming a cada token del self.index[field] y se añade al indice de stems
# En este caso solo se guarda la noticia, no la posición
for token in self.index[field].keys():
token_s = self.stemmer.stem(token)
if token_s not in self.sindex[field]:
self.sindex[field][token_s] = [token]
else:
if token not in self.sindex[field][token_s]:
self.sindex[field][token_s] += [token]
def make_permuterm(self):
"""
NECESARIO PARA LA AMPLIACION DE PERMUTERM
Crea el indice permuterm (self.ptindex) para los terminos de todos los indices.
"""
# Si se activa la función multifield
if self.multifield:
multifield = ['title', 'date', 'keywords', 'article', 'summary']
else:
multifield = ['article']
for field in multifield:
# Se crea la lista de permuterms de un token
# En este caso solo se guarda la noticia, no la posición
for token in self.index[field]:
token_p = token + '$'
permuterm = []
for _ in range(len(token_p)):
token_p = token_p[1:] + token_p[0]
permuterm += [token_p]
for permut in permuterm:
if permut not in self.ptindex[field]:
self.ptindex[field][permut] = [token]
else:
if token not in self.ptindex[field][permut]:
self.ptindex[field][permut] += [token]
def show_stats(self):
"""
NECESARIO PARA TODAS LAS VERSIONES
Muestra estadisticas de los indices
"""
# Si se activa la función multifield
if self.multifield:
multifield = ['title', 'date', 'keywords', 'article', 'summary']
else:
multifield = ['article']
print('\n========================================')
print('Number of indexed days: {}'.format(
len(self.index['date'].keys())))
print('----------------------------------------')
print('Number of indexed news: {}'.format(len(self.news.keys())))
print('----------------------------------------')
print('TOKENS:')
for field in multifield:
if field:
print(' # of tokens in \'{}\': {}'.format(
field, len(self.index[field])))
print('----------------------------------------')
if self.permuterm:
for field in multifield:
if field:
print(' # of permuterms in \'{}\': {}'.format(
field, len(self.ptindex[field])))
print('----------------------------------------')
if self.stemming:
for field in multifield:
if field:
print(' # of stems in \'{}\': {}'.format(
field, len(self.sindex[field])))
print('----------------------------------------')
if self.positional:
print('Positional queries are allowed.')
else:
print('Positional queries are NOT allowed.')
print('========================================')
###################################
### ###
### PARTE 2.1: RECUPERACION ###
### ###
###################################
def solve_query(self, query):
"""
NECESARIO PARA TODAS LAS VERSIONES
Resuelve una query.
Debe realizar el parsing de consulta que sera mas o menos complicado en funcion de la ampliacion que se implementen
param: "query": cadena con la query
"prev": incluido por si se quiere hacer una version recursiva. No es necesario utilizarlo.
return: posting list con el resultado de la query
"""
# Una 'primera' implementación más enreversada, pero más detallada
'''
# Preprocesamiento de la consulta
query = query.replace('(', ' ( ')
query = query.replace(')', ' ) ')
query = query.replace(':', ' : ')
query = query.replace('"', ' " ')
query = query.split()
# Resolver consulta (por prioridades)
# 1º: Resolver parentesis (de manera recursiva, si procede)
# Solo resuelve parentesis simples
if '(' in query:
number_of_subqueries = query.count('(')
while query.count('(') > 0:
aux_number_of_subqueries = 0
start_position_of_subquery = query.index('(')
end_position_of_subquery = start_position_of_subquery + 1
subquery_solved = False
while not subquery_solved:
if query[end_position_of_subquery] == '(':
aux_number_of_subqueries += 1
elif query[end_position_of_subquery] == ')' and aux_number_of_subqueries > 0:
aux_number_of_subqueries -= 1
elif query[end_position_of_subquery] == ')' and aux_number_of_subqueries == 0:
subquery = ' '.join(
query[start_position_of_subquery + 1:end_position_of_subquery])
answer = self.solve_query(subquery)
# if len(answer[0]) > 0 and isinstance(answer[0][0], list):
# answer = answer[0]
query = query[:start_position_of_subquery] + answer + query[end_position_of_subquery + 1:]
subquery_solved = True
# Si la consulta son varios parentesis seguidos
if len(query) == 0 or not isinstance(query[0], str):
return query
end_position_of_subquery += 1
number_of_subqueries -= 1
# 2º: Resolver consultas posicionales
if '"' in query:
number_of_positionals = query.count('"') / 2
while number_of_positionals > 0:
start_position_of_positional = query.index('(')
end_position_of_positional = start_position_of_positional + 2
positional_solved = False
while not positional_solved:
if query[end_position_of_positional] == '"':
query[start_position_of_positional] = self.get_posting(
' '.join(query[start_position_of_positional: end_position_of_positional + 1]))
query = query[:start_position_of_positional +
1] + query[end_position_of_positional + 1:]
positional_solved = True
end_position_of_positional += 1
number_of_positionals -= 1
# 3º: Resolver consultas multifield
if ':' in query:
number_of_multifields = query.count(':')
while number_of_multifields > 0:
position_of_multifield = query.index(':')
query[position_of_multifield] = self.get_posting(
query[position_of_multifield + 1].lower(), query[position_of_multifield - 1])
query.pop(position_of_multifield + 1)
query.pop(position_of_multifield - 1)
number_of_multifields -= 1
# 4º: Resolver consultas NOT
if 'NOT' in query:
number_of_nots = query.count('NOT')
while number_of_nots > 0:
position_of_not = query.index('NOT')
if isinstance(query[position_of_not + 1], str):
query[position_of_not] = self.reverse_posting(
self.get_posting(query.pop(position_of_not + 1).lower()))
else:
query[position_of_not] = self.reverse_posting(query.pop(position_of_not + 1))
number_of_nots -= 1
# 5º: Terminar de resolver la consulta (una palabra, AND's y OR's)
while len(query) > 1:
postinglist_a = query[0]
postinglist_b = query[2]
if isinstance(postinglist_a, str):
postinglist_a = self.get_posting(postinglist_a)
if isinstance(postinglist_b, str):
postinglist_b = self.get_posting(postinglist_b)
if query[1] == 'AND':
query[0] = self.and_posting(postinglist_a, postinglist_b)
query.pop(2)
query.pop(1)
elif query[1] == 'OR':
query[0] = self.or_posting(postinglist_a, postinglist_b)
query.pop(2)
query.pop(1)
if isinstance(query[0], str):
query[0] = self.get_posting(query[0])
return query[0]
'''
# La implementación final más concisa y eficiente
if query is None or len(query) == 0:
return []
res = []
# Preprocesamiento de la consulta
query = query.replace('"', '')
query = query.replace('(', ' ( ')
query = query.replace(')', ' ) ')
q = query.split()
# Bucle que realiza, primeramente, las funcionalidades extra
i = 0
while i < len(q):
term = q[i]
# 1º Subconcultas y subconsultas anidadas (de forma iterativa)
if term == '(':
i += 1
q2 = ''
aux = 0
while aux >= 0:
if q[i] == '(':
aux += 1
if q[i] == ')':
aux -= 1
q2 += q[i] + ' '
i += 1
q2 = q2.strip()
q2 = q2[0:len(q2) - 1]
res.append(self.solve_query(q2))
else:
# 2º Consultas multifield
if ':' in term:
field = term[0:term.find(':')]
term = term[term.find(':') + 1:]
else:
field = 'article'
# Se codifica los conectores básicos para un posterior tratado
if term == 'AND':
res += [1]
i += 1
elif term == 'OR':
res += [0]
i += 1
elif term == 'NOT':
res += [-1]
i += 1
else:
# 3º Consultas permuterm (wildcard query)
term = term.lower()
if '*' in term:
res.append(self.get_permuterm(term, field))
i += 1
elif '?' in term:
res.append(self.get_permuterm(term, field))
i += 1
else:
# 4º Consultas posicionales
aux = 0
terms = []
while (i + aux) < len(q) and q[i + aux] != 'AND' and q[
i + aux] != 'OR' and q[i + aux] != 'NOT':
terms.append(q[i + aux])
aux += 1
if len(terms) == 1:
if self.use_stemming:
res.append(self.get_stemming(term, field))
else:
res.append(self.get_posting(term, field))
i += 1
else:
res.append(self.get_positionals(terms, field))
i += aux
# Bucle que realiza, en segundo lugar, las funcionalidades básicas
ret = []
i = 0
while i < len(res):
# Según la codificación anterior realiza NOT o AND o OR, respectivamente
r = res[i]
if r == 1:
if res[i + 1] == -1:
seg = self.reverse_posting(res[i + 2])
i += 3
else:
seg = res[i + 1]
i += 2
ret = self.and_posting(ret, seg)
elif r == 0:
if res[i + 1] == -1:
seg = self.reverse_posting(res[i + 2])
i += 3
else:
seg = res[i + 1]
i += 2
ret = self.or_posting(ret, seg)
elif r == -1:
ret = self.reverse_posting(res[i + 1])
i += 2
else:
ret = r
i += 1
return ret
def get_posting(self, term, field='article', wildcard='False'):
"""
NECESARIO PARA TODAS LAS VERSIONES
Devuelve la posting list asociada a un termino.
Dependiendo de las ampliaciones implementadas "get_posting" puede llamar a:
- self.get_permuterm: para la ampliacion de permuterms
- self.get_stemming: para la amplaicion de stemming
param: "term": termino del que se debe recuperar la posting list.
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices.
"wildcard": indica si es una consulta widlcard (no hay que realizar stemming si esta activada la opción)
return: posting list.
"""
res = []
# Posting list de una wildcard query
if '*' in term or '?' in term:
res = self.get_permuterm(term, field)
# Posting list de un stem
elif self.use_stemming and not wildcard:
res = self.get_stemming(term, field)
# Posting list de un termino
else:
if term in self.index[field]:
res = list(self.index[field][term].keys())
# ALGORITMICA
if self.use_approximate and res == []:
suggestion = self.spellsuggester.suggest(term, self.app_distance,
self.app_thr)
for sugg_term in suggestion.keys():
res = self.or_posting(
res, self.get_posting(sugg_term, field, wildcard))
return res
def get_positionals(self, terms, field='article'):
"""
NECESARIO PARA LA AMPLIACION DE POSICIONALES
Devuelve la posting list asociada a una secuencia de terminos consecutivos.
param: "terms": lista con los terminos consecutivos para recuperar la posting list.
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices
return: posting list
"""
res = []
# NO FUNCIONA BIEN
# Se comprueba que se ha indexado el primer termino
if terms[0] in self.index[field]:
# Se recorre la posting list del primer termino (quitando el número de documentos)
for post in self.index[field][terms[0]].items():
seguido = True
# Obtenemos la noticia y la posición
new, list_pos = post
# Se comprueba que, para los siguientes terminos, eixste una entrada con ese noticia y una posición más
for position in list_pos:
for term in (term for term in terms[1:] if seguido):
if term in self.index[field]:
if new in self.index[field][term]:
if position + 1 in self.index[field][term][
new]:
position += 1
else:
seguido = False
else:
seguido = False
else:
seguido = False
if seguido:
res += [new]
return res
def get_stemming(self, term, field='article'):
"""
NECESARIO PARA LA AMPLIACION DE STEMMING
Devuelve la posting list asociada al stem de un termino.
param: "term": termino para recuperar la posting list de su stem.
"field": campo sobre el que se debe recuperar la posting list, solo necesario si se hace la ampliacion de multiples indices
return: posting list
"""
# Se obtiene el stem de un término
stem = self.stemmer.stem(term)
res = []
# Se hace la unión de las posting list de cada termino que contenga la entrada en el indice de stems
if stem in self.sindex[field]:
for token in self.sindex[field][stem]:
# Se utiliza el OR propio por eficiencia
res = self.or_posting(res,
list(self.index[field][token].keys()))
return res
def get_permuterm(self, term, field='article'):
"""
NECESARIO PARA LA AMPLIACION DE PERMUTERM
Devuelve la posting list asociada a un termino utilizando el indice permuterm.
param: "term": termino para recuperar la posting list, "term" incluye un comodin (* o ?).
"field": campo sobre el que se debe recuperar la posting list, solo necesario se se hace la ampliacion de multiples indices
return: posting list
"""
res = []
# Se construye la wildcard query del termino comodín
term += '$'
while term[-1] != '*' and term[-1] != '?':
term = term[1:] + term[0]
simbolo = term[-1]
term = term[:-1]
# Se hace la unión de las diferentes posting list de cada termino al que apunta un indice permuterm
# Si el comodin es '*', se busca todos los permuterms que comiencen por la wildcard query
# Si el comidin es '?', lo mismo pero que ademas la longitud sea igual a la del término original
for permuterm in (x for x in list(self.ptindex[field].keys())
if x.startswith(term) and (
simbolo == '*' or len(x) == len(term) + 1)):
for token in self.ptindex[field][permuterm]:
# Se utiliza el OR propio por eficiencia
# Se activa el campor wildcard=True para evitar que haga el stem de cada término
res = self.or_posting(
res, self.get_posting(token, field, wildcard=True))
return res
def reverse_posting(self, p):
"""
NECESARIO PARA TODAS LAS VERSIONES
Devuelve una posting list con todas las noticias excepto las contenidas en p.
Util para resolver las queries con NOT.
param: "p": posting list
return: posting list con todos los newid exceptos los contenidos en p
"""
# Obtenemos lista de todas las noticias
res = list(self.news.keys())
# Recorremos la posting list
for post in p:
# Eliminamos la noticia de la lista de todas las noticias
res.remove(post)
return res
def and_posting(self, p1, p2):
"""
NECESARIO PARA TODAS LAS VERSIONES
Calcula el AND de dos posting list de forma EFICIENTE
param: "p1", "p2": posting lists sobre las que calcular
return: posting list con los newid incluidos en p1 y p2
"""
res = []
i = 0
j = 0
# El pseudocodigo de teoria pasado a Python
while i < len(p1) and j < len(p2):
if p1[i] == p2[j]:
res.append(p1[i])
i += 1
j += 1
elif p1[i] <= p2[j]:
i += 1
elif p1[i] >= p2[j]:
j += 1
return res
def or_posting(self, p1, p2):
"""
NECESARIO PARA TODAS LAS VERSIONES
Calcula el OR de dos posting list de forma EFICIENTE
param: "p1", "p2": posting lists sobre las que calcular
return: posting list con los newid incluidos de p1 o p2
"""
res = []
i = 0
j = 0
# El pseudocodigo de teoria pasado a Python
while i < len(p1) and j < len(p2):
if p1[i] == p2[j]:
res.append(p1[i])
i += 1
j += 1
elif p1[i] <= p2[j]:
res.append(p1[i])
i += 1
elif p1[i] >= p2[j]:
res.append(p2[j])
j += 1
for pos in range(i, len(p1)):
res.append(p1[pos])
for pos in range(j, len(p2)):
res.append(p2[pos])
return res
#####################################
### ###
### PARTE 2.2: MOSTRAR RESULTADOS ###
### ###
#####################################
def solve_and_count(self, query):
"""
NECESARIO PARA TODAS LAS VERSIONES
Resuelve una consulta y la muestra junto al numero de resultados
param: "query": query que se debe resolver.
return: el numero de noticias recuperadas, para la opcion -T
"""
result = self.solve_query(query)
print("%s\t%d" % (query, len(result)))
return len(result) # para verificar los resultados (op: -T)
def solve_and_show(self, query):
"""
NECESARIO PARA TODAS LAS VERSIONES
Resuelve una consulta y la muestra informacion de las noticias recuperadas.
Consideraciones:
- En funcion del valor de "self.show_snippet" se mostrara una informacion u otra.
- Si se implementa la opcion de ranking y en funcion del valor de self.use_ranking debera llamar a self.rank_result
param: "query": query que se debe resolver.
return: el numero de noticias recuperadas, para la opcion -T
"""
result = self.solve_query(query)
if self.use_ranking:
result = self.rank_result(result, query)
print('========================================')
print('Query: \'{}\''.format(query))
print('Number of results: {}'.format(len(result)))
i = 1
for new in result:
aux = self.news[new]
with open(self.docs[self.news[new][0]]) as fh:
jlist = json.load(fh)
aux = jlist[self.news[new][1]]
if self.use_ranking:
puntuacion = self.jaccard(query, aux)
else:
puntuacion = 0
# Si esta activada la función de snippets
if not self.show_snippet:
print('#{:<4} ({}) ({}) ({}) {} ({})'.format(
i, puntuacion, new, aux['date'], aux['title'],
aux['keywords']))
else:
print('#{}'.format(i))
print('Score: {}'.format(puntuacion))
print(new)
print('Date: {}'.format(aux['date']))
print('Title: {}'.format(aux['title']))
print('Keywords: {}'.format(aux['keywords']))
print('{}\n'.format(self.snippet(aux, query)))
i += 1
if not self.show_all and i > self.SHOW_MAX:
break
def rank_result(self, result, query):
"""
NECESARIO PARA LA AMPLIACION DE RANKING
Ordena los resultados de una query.
param: "result": lista de resultados sin ordenar
"query": query, puede ser la query original, la query procesada o una lista de terminos
return: la lista de resultados ordenada
"""
# Preprocesamos la consulta de términos que no queremos puntuar
query = query.replace('AND', '')
query = query.replace('OR', '')
query = query.replace('NOT ', 'NOT')
query = query.replace(':', ' ')
res = []
# Para cada noticia se obtiene su puntuación de Jaccard
# Se realiza, por cada noticia, una insercción tupla (noticia, puntuación)
for new in result:
with open(self.docs[self.news[new][0]]) as fh:
jlist = json.load(fh)
aux = jlist[self.news[new][1]]
res.append([new, self.jaccard(query, aux)])
# Se ordena la lista de noticias según la puntuación
res.sort(key=lambda tup: tup[1], reverse=True)
# Se devuelven solo las noticias
return [i[0] for i in res]
def jaccard(self, query, documento):
'''
Obtiene la métrica de Jaccard para una consulta y un documento (revisa todos los campos).
Si la función de multifield está activada, realiza la combinación de la métrica de Jaccard para todos los campos.
Se define la métrica de Jaccard como Jaccard(A, B) = A inter B / A union B.
La métrica oscilara entre [1, 0] o [5, 0] si es multifield.
param: "query": query procesada
"documento": la noticia, con todos sus campos
return: la métrica de un par consulta - documento
'''
query = query.replace('NOT ', 'NOT')
query = query.replace('AND', '')
query = query.replace('OR', '')
query = set(self.tokenize(query))
metrica_total = 0
# Si la función de multifield está activada
if self.multifield:
for field in ['title', 'article', 'date', 'keywords', 'summary']:
# Se trabajan con sets porqué contienen metodos útiles para esta implementación
if field != 'date':
documento_aux = set(self.tokenize(documento[field]))
else:
documento_aux = set([documento[field]])
metrica_total += len(query.intersection(documento_aux)) / len(
query.union(documento_aux))
else:
documento = set(self.tokenize(documento['article']))
metrica_total = len(query.intersection(documento)) / len(
query.union(documento))
# Como las consultas son cortas y los documentos, en comparación, largos
# se toman 6 decimales para porder comparar bien
return round(metrica_total, 6)
def snippet(self, new, query):
'''
Obtiene el snippet de una noticia.
param: "new": la noticia, con todos sus campos
"query": query sin procesar
return: la métrica de un par consulta - documento
'''
words = self.tokenize(new['article'])
# Se preprocesa la consulta
query = query.replace('"', '')
query = query.replace('*', '')
query = query.replace('(', '')
query = query.replace(')', '')
query = query.replace('?', '')
query = query.replace('NOT ', 'NOT')
# Palabra rara para tener en cuenta campo multifield
query = query.replace(':', 'HZMPOSICIONAL')
query = self.tokenize(query)
# A diferencia del ejemplo, se ha optado por enmarcar el snippet en " "
snippet = '"'
l_cont = 0
# Intentamos obtener un fragmento para cada término relevante de la query
# No siempre es posible por la naturaleza de los conectores y las ampliaciones (los permuterms es díficil que consiga algo)
for word in query:
local = words
# Si un término es consulta multifield, la generación del
# snippet para ese término se hará en ese campo
if 'HZMPOSICIONAL' in word:
field, word = word.split('HZMPOSICIONAL')
# No hay que tokenizar la fecha
if field != 'date':
local = self.tokenize(new[field])
# Por defecto se busca en 'article' pero por si es multifield
# se realiza la copia local
if word in local:
# Se obtiene la primera ocurrencia del término (si esta)
# y se obtiene un fragmento anterior y posterior.
# Se tiene en cuenta si está al principio o al final
pos = local.index(word)
min_p = pos - 4
if min_p < 0:
min_p = 0
max_p = pos + 5
if max_p > len(local) - 1:
max_p = len(local) - 1
# Si el fragmento no está al principio
snippet_aux = ''
if min_p > 0:
snippet_aux += '...'
snippet_aux += " ".join(local[min_p:max_p + 1])
# Si el fragmento no está al final
if max_p < len(local) - 1:
snippet_aux += '...'
l_cont += 1
if l_cont != len(query) - 1 and len(query) > 1 and len(
snippet_aux.lstrip()) > 0:
snippet_aux += '\n'
snippet += snippet_aux
return snippet + '"'
import re
#Comparar algoritmos mediante:
# 1. Variando la talla del diccionario
# 2. Variando el threshold
dicts = ["quijote_0_100.txt", "quijote_0_500.txt", "quijote_0_1000.txt", "quijote_0_20000.txt", "quijote_0_40000.txt"]
thresholds = [0, 1, 2, 3, 5]
print("Levenshtein \t\t Levenshtein Restringida \t\t Levenshtein Intermedia \t\t Levenshtein Con Trie \t\t Levenshtein Restringida Con Trie \t\t Levenshtein Intermedia Con Trie")
for dict in dicts:
spellsuggester = SpellSuggester("./corpora/"+dict)
trie_spellsuggester = TrieSpellSuggester("./corpora/"+dict)
for threshold in thresholds:
#Levenshtein
t_ini_lev = time.process_time()
res = spellsuggester.suggest("casa", "levenshtein", threshold)
t_end_lev = time.process_time()
#print("[Distancia Levenshtein] -> Tiempo usando "+dict+" y threshold: " + str(threshold)+":\t"+str(t_end-t_ini))
#Restringida
t_ini_lev_res = time.process_time()
res = spellsuggester.suggest("casa", "restricted", threshold)
t_end_lev_res = time.process_time()
#print("[Distancia Levenshtein Restringida] -> Tiempo usando "+dict+" y threshold: " + str(threshold)+":\t"+str(t_end-t_ini))