def predicao_usual(frase, palavra, pos, fonte='oxford'):
conjunto = []
if fonte == 'oxford':
inst = BaseOx.INSTANCE
for d in BaseOx.obter_definicoes(inst, palavra, pos):
for s in BaseOx.obter_sins(inst, palavra, d, pos):
if s != palavra:
conjunto.append(s)
elif fonte == 'wordnet':
for s in wn.synsets(palavra, pos):
for l in s.lemma_names():
if palavra != l:
if Util.e_mpalavra(l):
conjunto.append(l)
return [p for p in conjunto if Util.e_mpalavra(p) == False]
def indexar_definicoes_palavra_ox(palavra):
from OxAPI import BaseOx
documentos = []
numero = 1
for d, pos in BaseOx.obter_definicoes(BaseOx.INSTANCE,
palavra,
retornar_pos=True):
exemplos = BaseOx.obter_atributo(BaseOx.INSTANCE, palavra, None, d,
'exemplos')
exemplos = ":::".join(exemplos)
path = '%s-%s.json-%d' % (palavra, pos[0].lower(), numero)
reg = (palavra + ":::" + d, path, exemplos)
documentos.append(reg)
numero += 1
Whoosh.iniciar_indexacao_exemplos(documentos)
return documentos
def bow_embbedings_definicao(palavra, pos):
from OxAPI import BaseOx
from Alvaro import Alvaro
descricao_definicoes = {}
uniao_definicoes = set()
for d in BaseOx.obter_definicoes(BaseOx.INSTANCE, palavra, pos=pos):
d_sins = BaseOx.obter_sins(BaseOx.INSTANCE, palavra, d, pos=pos)
correlatas = []
for s in d_sins:
similares_tmp = [
reg[0] for reg in Alvaro.palavras_similares(s, pos)
]
uniao_definicoes.update(similares_tmp)
correlatas.append(similares_tmp)
# Interseccao entre palavras da mesma definicao
interseccao = set(correlatas[0])
for c in correlatas[:1]:
interseccao = set(interseccao) & set(c)
descricao_definicoes[d] = interseccao
#for d in descricao_definicoes:
# descricao_definicoes[d] = list(set(descricao_definicoes[d]) - set(uniao_definicoes))
descricao_definicoes_tmp = {}
for d in descricao_definicoes:
uniao_outros = set()
for outro in descricao_definicoes:
if outro != d: uniao_outros.update(descricao_definicoes[outro])
descricao_definicoes_tmp[d] = set(
descricao_definicoes[d]) - uniao_outros
descricao_definicoes_tmp[d] = list(descricao_definicoes_tmp[d])
uniao_outros = None
return descricao_definicoes_tmp
def obter_frases_exemplo(palavra):
ext = ExtratorWikipedia(None)
url = Util.CONFIGS['wikipedia'][
'url_desambiguacao'] % palavra.capitalize()
duplicatas = set()
frases_desambiguadads = {}
todas_definicoes = {}
instance = BaseOx.INSTANCE
links_relevantes_tmp = ext.obter_links_relevantes_desambiguacao(
url, palavra)
pagina_desambiguacao = not links_relevantes_tmp in [None, [], {}]
if pagina_desambiguacao == False:
url = Util.CONFIGS['wikipedia'][
'url_base_verbete'] + '/' + palavra.lower()
links_relevantes_tmp = [url]
links_relevantes_tmp = [
l for l in links_relevantes_tmp if not "dictiona" in l
]
links_relevantes = []
todos_sins = []
lemas = {}
url_lema = {}
for def_iter in BaseOx.obter_definicoes(instance, palavra, pos=None):
conj_sins = BaseOx.obter_sins(instance,
palavra,
def_iter,
pos=None)
todos_sins += conj_sins
todos_sins = [palavra] + list(set(todos_sins))
for l in links_relevantes_tmp:
for s in todos_sins:
if s.lower() in l.lower() and not l in links_relevantes:
links_relevantes.append(l)
if not s.lower() in lemas: lemas[s.lower()] = []
lemas[s.lower()].append(l)
url_lema[l] = s.lower()
links_relevantes_tmp = None
registros = []
for url in links_relevantes:
if "wikipedia" in url:
texto_wikipedia, todas_urls_referencias = ext.obter_texto(
url, obter_referencias=True)
plain_text = Util.completa_normalizacao(texto_wikipedia)
if set(nltk.word_tokenize(plain_text)).intersection(
set(todos_sins)):
todas_sentencas = re.split('[.?!]', plain_text)
descricao = todas_sentencas[0].replace('\n',
' ').strip(' ')
todas_sentencas = todas_sentencas[1:]
todas_sentencas = [
re.sub('[\s\n\t]', ' ', s) for s in todas_sentencas
]
todas_sentencas = [
s for s in todas_sentencas if s.count(' ') > 1
]
for frase in todas_sentencas:
if len(set(frase).intersection(
set("<>{ }"))) > 0 or not '":"' in frase:
if ExtratorWikipedia.filtrar_frase_bruta(
frase, url_lema[url]) != None:
nova_frase = frase.replace('\n',
' ').strip(' ')
if not nova_frase in duplicatas:
reg = palavra, descricao, url, nova_frase
registros.append(reg)
duplicatas.add(nova_frase)
# Iterando referencias recuperadas
for url_ref in todas_urls_referencias:
for frase in ext.extrair_frases_pagina_comum(
todas_urls_referencias, palavra):
nova_frase = frase.replace('\n', ' ').strip(' ')
if not nova_frase in duplicatas:
reg = palavra, descricao, url + '@@@@' + url_ref, nova_frase
registros.append(reg)
duplicatas.add(nova_frase)
return registros
def adapted_lesk(self,
ctx,
ambigua,
pos,
nbest=True,
lematizar=True,
stem=True,
stop=True,
usr_ex=False,
janela=2):
if len(pos) == 1:
pos = Util.cvrsr_pos_wn_oxford(pos)
limiar_polissemia = 10
# Casamentos cartesianos das diferentes definicoes
solucoes_candidatas = []
# Todas definicoes da palavra ambigua
definicoes = [
def_ox for def_ox in BaseOx.obter_definicoes(ambigua, pos)
]
ctx_blob = TextBlob(ctx)
tags_validas = self.cfgs['pos_tags_treebank']
tokens_validos = [(token, tag) for (token, tag) in ctx_blob.tags
if tag in tags_validas]
tokens_validos_tmp = []
# [('The', 'DT'), ('titular', 'JJ'), ('threat', 'NN'), ('of', 'IN'), ...]
for token, tag in tokens_validos:
pos_ox = Util.cvrsr_pos_wn_oxford(tag[0].lower())
defs_token = BaseOx.obter_definicoes(token, pos_ox)
if not defs_token in [[], None]:
tokens_validos_tmp.append((token, tag))
solucoes_candidatas.append(defs_token)
tokens_validos = tokens_validos_tmp
tokens_validos_tmp = None
indices_tokens_validos = []
if len(tokens_validos) != len(solucoes_candidatas):
raise Exception("\nTAMANHOS DIFERENTES!\n")
i = 0
for tk, tag in list(tokens_validos):
if tk == ambigua:
cont = 0
for e in sorted(range(0, i), reverse=True):
if len(solucoes_candidatas[e]) < limiar_polissemia:
indices_tokens_validos.append(e)
cont += 1
if cont == janela:
break
indices_tokens_validos.append(i)
cont = 0
for d in range(i + 1, len(tokens_validos)):
if len(solucoes_candidatas[d]) < limiar_polissemia:
indices_tokens_validos.append(d)
cont += 1
if cont == janela:
break
i += 1
tokens_validos = [tokens_validos[i] for i in indices_tokens_validos]
print("\n")
print("AMBIGUA: '%s'" % ambigua)
print("CONTEXTO: '%s'\n" % ctx)
print("TOKENS VALIDOS: " + str([(token, tag)
for (token, tag) in tokens_validos]))
prod = 1
print("\n\n")
print([len(solucoes_candidatas[i]) for i in indices_tokens_validos])
for e in [solucoes_candidatas[i] for i in indices_tokens_validos]:
prod *= len(e)
print("Produtorio: " + str(prod))
raw_input("\n")
for dtmp in definicoes:
d = str(dtmp).lower()
todos_tamanhos_ngram = sorted(range(1, self.tam_max_ngram + 1),
reverse=True)
for n in todos_tamanhos_ngram:
ctx_blob = TextBlob(ctx.lower())
todos_ngrams = ctx_blob.ngrams(n=n)
for ngram in todos_ngrams:
ngram_str = " ".join(ngram)
freq = d.count(ngram_str)
pontuacao = freq * (n**2)
if freq:
d = d.replace(ngram_str, '')
return 0.00
