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 __init__(self, configs):
self.configs = configs
# self.configs['dir_base_casada_manualmente']
self.diretorio_base_casada_manualmente = self.configs[
'dir_base_casada_manualmente']
self.base_casada_manualmente = Util.abrir_json(
self.diretorio_base_casada_manualmente)
self.base_ox = BaseOx(self.configs)
if self.base_casada_manualmente == None:
self.base_casada_manualmente = {}
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 iniciar_casamento(self, termo, pos, corrigir=False):
if corrigir:
del self.base_casada_manualmente[termo]
if not termo in self.base_casada_manualmente:
self.base_casada_manualmente[termo] = {}
if not wn.synsets(
unicode(termo),
pos)[0].name() in self.base_casada_manualmente[termo]:
obj_oxford = BaseOx.construir_objeto_unificado(termo)
pos_oxford = Util.cvrsr_pos_wn_oxford(pos)
try:
obj_oxford = obj_oxford[pos_oxford]
except TypeError:
print('A POS %s para o termo %s nao foi encontrada!' %
(pos_oxford, termo))
return
for synset in wn.synsets(unicode(termo), pos):
self.base_casada_manualmente[termo][synset.name()] = []
print('\n\n')
print('\t' + str((str(termo), str(pos))))
print('\t' + synset.definition().upper() + '\n')
indice = 1
definicoes_indexadas = []
for definicao in obj_oxford:
definicoes_indexadas.append(definicao)
print('\n\t\t' + str(indice) + ' - ' + repr(definicao) +
'\n')
indice += 1
for def_sec_iter in obj_oxford[definicao]['def_secs']:
def_sec = def_sec_iter.encode('utf8')
definicoes_indexadas.append(def_sec)
print('\t\t' + str(indice) + ' - ' + repr(def_sec))
indice += 1
valores = self.ler_inteiros('\n\tINDICES: ')
print('\tAnotacao > ' + str(valores))
print('\n\n')
for v in valores:
try:
self.base_casada_manualmente[termo][
synset.name()].append(definicoes_indexadas[v - 1])
except IndexError:
pass
dir_saida = self.diretorio_base_casada_manualmente
Util.salvar_json(dir_saida, self.base_casada_manualmente)
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 recuperar_exemplos(self, nome_synset=""):
termo = wn.synset(nome_synset).lemma_names()[0]
pos_oxford = wn.synset(nome_synset).pos()
pos_oxford = Util.cvrsr_pos_wn_oxford(pos_oxford)
try:
obj_unificado = BaseOx.construir_objeto_unificado(
termo)[pos_oxford]
except:
print('Excecao: ' + str((termo, pos_oxford)))
obj_unificado = None
try:
definicoes_oxford = self.base_casada_manualmente[termo][
nome_synset]
except:
print(
'Excecao! Nao foram encontradas definicoes para o (%s, %s) na base casada manualmente!'
% (termo, nome_synset))
definicoes_oxford = None
if definicoes_oxford:
lista_definicoes = []
for def_principal in obj_unificado:
reg = ("", def_principal,
obj_unificado[def_principal]['exemplos'])
lista_definicoes.append(reg)
for def_sec in obj_unificado[def_principal]['def_secs']:
reg = ("", def_sec, obj_unificado[def_principal]
['def_secs'][def_sec]['exemplos'])
lista_definicoes.append(reg)
for nome_def, definicao, exemplos in lista_definicoes:
if definicao in definicoes_oxford:
return exemplos
return []
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 assinatura_significado(self, lema, lematizar=True,\
stem=False, stop=True,\
extrair_relacao_semantica=False,\
usar_exemplos=False):
resultado = BaseOx.construir_objeto_unificado(self.base_ox, lema)
if not resultado:
resultado = {}
lema = lemmatize(lema)
assinaturas_significados = [] # (nome, definicao, exemplos)
for pos in resultado.keys():
todos_significados = resultado[pos].keys()
indice = 1
for sig in todos_significados:
nome_sig = "%s.%s.%d" % (lema, pos, indice)
indice += 1
if usar_exemplos:
exemplos = resultado[pos][sig]['exemplos']
else:
exemplos = []
# nome, definicao, exemplos, assinatura
definicao_corrente = [nome_sig, sig, exemplos, []]
assinaturas_significados.append(definicao_corrente)
# Colocando exemplos na assinatura
definicao_corrente[len(definicao_corrente) -
1] += self.assinatura_significado_aux(
lema, pos, sig, exemplos)
sig_secundarios = resultado[pos][sig]['def_secs']
for ss in sig_secundarios:
nome_sig_sec = "%s.%s.%d" % (lema, pos, indice)
if usar_exemplos:
exemplos_secundarios = resultado[pos][sig]['def_secs'][
ss]['exemplos']
else:
exemplos_secundarios = []
definicao_corrente_sec = [
nome_sig_sec, ss, exemplos_secundarios, []
]
assinaturas_significados.append(definicao_corrente_sec)
definicao_corrente_sec[
len(definicao_corrente) -
1] += self.assinatura_significado_aux(
lema, pos, ss, exemplos_secundarios)
indice += 1
for sig in assinaturas_significados:
sig[3] = Util.normalizar_ctx(sig[3],
stop=True,
lematizar=True,
stem=True)
return [tuple(a) for a in assinaturas_significados]
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
def des_exemplos(self, ctx,\
ambigua, pos, nbest=True,\
lematizar=True, stem=True, stop=True,\
normalizar_pont=True):
cfgs = self.cfgs
dir_bases = self.cfgs['caminho_bases']
base_ox = self.base_ox
rep_vet = self.rep_vetorial
alvaro = Alvaro.Alvaro.INSTANCE
dir_cache_rel_sinonimia = cfgs['caminho_bases'] + '/' + cfgs['oxford'][
'cache']['sinonimia']
chave_cache_relacao_sin = "%s-%s.json" % (ambigua, pos)
dir_obj = dir_cache_rel_sinonimia + '/' + chave_cache_relacao_sin
if not chave_cache_relacao_sin in Util.list_arqs(
dir_cache_rel_sinonimia):
rel_definicoes = alvaro.construir_relacao_definicoes(
ambigua, pos, fontes='oxford')
Util.salvar_json(dir_obj, rel_definicoes)
else:
rel_definicoes = Util.abrir_json(dir_obj, criarsenaoexiste=False)
res_des_tmp = []
pontuacao_somada = 0.00
for def_ambigua in rel_definicoes:
uniao_palavras_sem_duplicatas = set()
uniao_palavras_com_duplicatas = list()
exemplos_blob = []
palavras_tf = {}
try:
maximo_exemplos = self.cfgs['params_exps']['qtde_exemplos'][0]
lista_exemplos = BaseOx.obter_atributo(ambigua, pos,
def_ambigua, 'exemplos')
# Adicionando lemas
lista_exemplos.append(" ".join(
BaseOx.obter_sins(ambigua, def_ambigua, pos)))
# Adicionando definicao
lista_exemplos.append(def_ambigua)
for ex in lista_exemplos[:maximo_exemplos]:
ex_blob = TextBlob(ex)
exemplos_blob.append(ex_blob)
for token in ex_blob.words:
if Util.is_stop_word(token.lower()) == False:
token_lematizado = lemmatize(token)
uniao_palavras_sem_duplicatas.add(token_lematizado)
uniao_palavras_com_duplicatas.append(
token_lematizado)
except Exception, caminho:
exemplos = []
textblob_vocab = TextBlob(" ".join(uniao_palavras_com_duplicatas))
palavras_latentes = []
for p in textblob_vocab.word_counts:
if textblob_vocab.word_counts[p] > 1:
palavras_latentes.append(p)
palavras_derivadas = []
for p in uniao_palavras_sem_duplicatas:
tf = alvaro.tf(p, textblob_vocab)
palavras_tf[p] = tf
pontuacao = 0.00
for t in Util.tokenize(Util.resolver_en(ctx).lower()):
try:
pontuacao += palavras_tf[t]
except:
pontuacao += 0.00
pontuacao_somada += pontuacao
try:
if normalizar_pont:
reg_pont = pontuacao / sum(palavras_tf.values())
else:
reg_pont = pontuacao
except ZeroDivisionError, zde:
reg_pont = 0.00
exemplos_blob = []
palavras_tf = {}
try:
maximo_exemplos = self.cfgs['params_exps']['qtde_exemplos'][0]
lista_exemplos = []
definicoes_caminho = [
tuple(r.split(":::")) for r in reg_caminhos.split("/")
]
# Percorrendo todos caminhos nas arvores de sinonimos
for lema_caminho, def_caminho in definicoes_caminho:
try: # Adicionando caminho
novos_ex = BaseOx.obter_atributo(BaseOx.INSTANCE,\
lema_caminho, pos, def_caminho, 'exemplos')
novos_ex = list(novos_ex)
lista_exemplos += novos_ex
except:
lista_exemplos = []
# Adicionando lemas
sins_defcaminho = BaseOx.obter_sins(
BaseOx.INSTANCE, lema_caminho, def_caminho, pos)
if sins_defcaminho:
lista_exemplos.append(" ".join(sins_defcaminho))
# Adicionando definicao
lista_exemplos.append(def_caminho)
