def desambiguar(self, ctx, ambigua, pos, nbest=True,\
lematizar=True, stem=True, stop=True,\
usar_ontologia=False, usr_ex=False,\
busca_ampla=False, med_sim='cosine', cands=[ ]):
# Para gerar chave do CACHE
vars_locais = dict(locals())
dir_cache_tmp = None
dir_bases = self.cfgs['caminho_bases']
self.usar_cache = False
if self.usar_cache:
obj_dir_cache_des = dir_bases + '/' + self.cfgs['oxford']['cache'][
'desambiguador']
del vars_locais['self']
del vars_locais['ambigua']
k_vars = self.construir_chave_cache(vars_locais)
dir_completo_obj = "%s/%s.json" % (obj_dir_cache_des, ambigua)
Util.abrir_json(dir_completo_obj, criarsenaoexiste=True)
if k_vars in obj_cache:
return obj_cache[k_vars]
if len(pos) == 1:
pos = Util.cvrsr_pos_wn_oxford(pos)
lem, st = (med_sim == 'cosine'), (med_sim == 'cosine')
todas_assinaturas = []
try:
todas_assinaturas = self.assinatura_significado(
ambigua, usar_exemplos=usr_ex, lematizar=lem, stem=st)
for candidato_iter in cands:
todas_assinaturas += self.assinatura_significado(
candidato_iter,
usar_exemplos=usr_ex,
lematizar=lem,
stem=st)
todas_assinaturas = [
assi for assi in todas_assinaturas
if pos == assi[0].split('.')[1]
]
# Tirando palavras de tamanho 1
ctx = [p for p in Util.tokenize(ctx.lower()) if len(p) > 1]
ctx = Util.normalizar_ctx(ctx, stop=stop, lematizar=lem, stem=st)
except KeyboardInterrupt, ke:
pass
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 obter_atributo(self, palavra, pos, definicao, atributo):
obj_unificado = self.construir_objeto_unificado(palavra)
if pos != None:
if len(pos) == 1:
todas_pos = [Util.cvrsr_pos_wn_oxford(pos)]
else: todas_pos = [pos]
else: todas_pos = obj_unificado.keys()
try:
for pos in todas_pos:
for def_primaria in obj_unificado[pos]:
obj_filtrado = obj_unificado[pos][def_primaria]
if definicao == def_primaria:
return obj_filtrado[atributo]
for def_sec in obj_filtrado['def_secs']:
if definicao == def_sec:
return obj_filtrado['def_secs'][def_sec][atributo]
except Exception, e: pass
return None
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_sins(self, palavra, definicao, pos=None, remover_sinonimos_replicados=False):
obj_unificado = self.construir_objeto_unificado(palavra)
if pos == None:
lista_pos = [pos for pos in obj_unificado.keys()]
elif len(pos) == 1:
lista_pos = [Util.cvrsr_pos_wn_oxford(pos)]
sinonimos_retorno = [ ]
try:
for pos in lista_pos:
for def_primaria in obj_unificado[pos]:
obj_filtrado = obj_unificado[pos][def_primaria]
if definicao in def_primaria or def_primaria in definicao:
sinonimos_retorno = obj_filtrado['sinonimos']
for def_sec in obj_unificado[pos][def_primaria]['def_secs']:
if definicao in def_sec or def_sec in definicao:
sinonimos_retorno = obj_filtrado['def_secs'][def_sec]['sinonimos']
# Se sinonimos de definicao mais aninhada é
# igual às definicoes mais externas, entao, retorne nada!
if sinonimos_retorno == obj_filtrado['sinonimos']:
if remover_sinonimos_replicados == True:
return [ ]
# Se sinonimos estao no objeto
if sinonimos_retorno != [ ]:
return sinonimos_retorno
sinonimos_extraidos_definicao = [ ]
if sinonimos_retorno != [ ]:
if pos in ['Noun', 'n', 'Verb', 'v']:
sinonimos_extraidos_definicao = self.obter_sins_nv(palavra, definicao, pos=pos[0].lower())
else:
sinonimos_extraidos_definicao = self.extrair_sins_cands_def(palavra, definicao, pos=pos[0].lower())
sinonimos_extraidos_definicao = set(sinonimos_extraidos_definicao)-set(sinonimos_retorno)
if sinonimos_retorno + list(sinonimos_extraidos_definicao) != [ ]:
return sinonimos_retorno + list(sinonimos_extraidos_definicao)
else:
raise Exception("Erro na obtencao de sinonimos!")
except Exception, e:
sins_def = self.extrair_sins_cands_def(definicao, pos)
sins_nouns = [ ]
if pos in ['Adverb', 'Adjective', 'a', 'r']:
if not palavra in sins_def: return [palavra] + sins_def
else: return sins_def
if pos in ['Noun', 'n', 'Verb', 'v']:
retorno = self.obter_sins_nv(palavra, definicao, sins_def, pos=pos[0].lower())
if retorno == [ ] and sins_def != [ ]:
for noun in sins_def:
for s in wn.synsets(palavra, 'n'):
for sh in s.hypernyms() + s.hyponyms() + s.similar_tos():
if noun in sh.lemma_names():
if not noun in retorno:
retorno.append(noun)
if retorno:
if not palavra in retorno: return [palavra] + retorno
else: return retorno
else:
if not palavra in sins_def: return [palavra] + sins_def
else: return sins_def
else :
if not palavra in sins_def: return [palavra] + sins_def
else: return sins_def
if obj_unificado == None:
pos_verb = "Verb"
if pos == pos_verb:
palavra = BaseOx.lematizador.lemmatize(palavra, pos=pos[0].lower())
try:
if retornar_pos == True:
return self.obter_definicoes(palavra, pos_verb)
else:
return [(d, pos_verb) for d in self.obter_definicoes(palavra, pos_verb)]
except Exception, e:
return None
try:
# Se POS = None, pegue todas as POS
if pos != None:
pos = Util.cvrsr_pos_wn_oxford(pos)
if pos in obj_unificado:
obj_unificado = { pos: obj_unificado[pos] }
else:
obj_unificado = dict()
else:
pass
todas_definicoes = [ ]
except (TypeError, AttributeError), e:
return [ ]
try:
for pos in obj_unificado:
for def_primaria in obj_unificado[pos]:
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