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 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 completa_normalizacao(cadeia, codif='utf-8'):
return Util.completa_normalizacao(cadeia, codif=codif)
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 retornar_valida(self, frase):
return Util.retornar_valida(frase)
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
BaseOx.INSTANCE, lema_caminho, def_caminho, pos)
if sins_defcaminho:
lista_exemplos.append(" ".join(sins_defcaminho))
# Adicionando definicao
lista_exemplos.append(def_caminho)
for ex_iter in lista_exemplos[:maximo_exemplos]:
ex = ex_iter
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:
import traceback
traceback.print_stack()
traceback.print_exc()
exemplos = []
tb_vocab_duplicatas = TextBlob(
" ".join(uniao_palavras_com_duplicatas))
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
def cosine_lesk_inventario_estendido(context_sentence, ambiguous_word, \
pos=None, lemma=True, stem=True, hyperhypo=True, \
stop=True, context_is_lemmatized=False, \
nbest=False, synsets_signatures=None, busca_ampla=False):
"""
In line with vector space models, we can use cosine to calculate overlaps
instead of using raw overlap counts. Essentially, the idea of using
signatures (aka 'sense paraphrases') is lesk-like.
"""
# Ensure that ambiguous word is a lemma.
if lemma:
ambiguous_word = lemmatize(ambiguous_word)
# If ambiguous word not in WordNet return None
#if not wn.synsets(ambiguous_word):
if not criar_inventario_des_wn(ambiguous_word, busca_ampla=busca_ampla):
return None
if context_is_lemmatized:
context_sentence = " ".join(context_sentence.split())
else:
context_sentence = " ".join(lemmatize_sentence(context_sentence))
scores = []
chave_assinatura = "%s.%s.%s.%s.%s.%s" % (ambiguous_word, pos, lemma, stem,
hyperhypo, busca_ampla)
if not chave_assinatura in DesWordnet.cache_assinaturas:
synsets_signatures = simple_signature(ambiguous_word,
pos,
lemma,
stem,
hyperhypo,
busca_ampla=busca_ampla)
DesWordnet.cache_assinaturas[chave_assinatura] = []
for ss, signature in synsets_signatures.items():
# Lowercase and replace "_" with spaces.
signature = " ".join(map(str, signature)).lower().replace("_", " ")
# Removes punctuation.
signature = [i for i in Util.word_tokenize(signature) \
if i not in string.punctuation]
signature = Util.normalizar_ctx(signature,
stop=stop,
lematizar=lemma,
stem=stem)
scores.append((cos_sim(context_sentence, " ".join(signature)), ss))
DesWordnet.cache_assinaturas[chave_assinatura].append(
(ss, signature))
else:
synsets_signatures = DesWordnet.cache_assinaturas[chave_assinatura]
for ss, signature in synsets_signatures:
scores.append((cos_sim(context_sentence, " ".join(signature)), ss))
if not nbest:
return sorted(scores, reverse=True)[0][1]
else:
return [(j, i) for i, j in sorted(scores, reverse=True)]
def extrair_sinonimos(self, ctx, palavra, pos=None, \
usar_exemplos=False, busca_ampla=False, \
repetir=True, coletar_todos=True):
max_sinonimos = 10
print('Executando desambiguador Wordnet...')
resultado = self.adapted_cosine_lesk(ctx,
palavra,
pos,
busca_ampla=busca_ampla)
print('Desambiguador executado...\n')
sinonimos = []
try:
if resultado[0][1] == 0:
resultado = [resultado[0]]
repetir = False
if False:
sinonimos = []
try:
for synset in [s[0] for s in resultado]:
for lema in synset.lemma_names():
if not l in sinonimos:
sinonimos.append(l)
except:
pass
return sinonimos[:max_sinonimos]
else:
resultado = [item for item in resultado if item[1] > 0]
except:
resultado = []
continuar = bool(resultado)
while len(sinonimos) < max_sinonimos and continuar:
len_sinonimos = len(sinonimos)
for item in resultado:
synset, pontuacao = item
if len(sinonimos) < max_sinonimos:
try:
sinonimos_tmp = [
s for s in synset.lemma_names()
if not Util.e_mpalavra(s)
]
sinonimos_tmp = list(
set(sinonimos_tmp) - set(sinonimos))
if coletar_todos: sinonimos += sinonimos_tmp
elif sinonimos_tmp: sinonimos += [sinonimos_tmp[0]]
except:
pass
else:
continuar = False
if repetir == False: continuar = False
elif len_sinonimos == len(sinonimos): continuar = False
return sinonimos[:max_sinonimos]
def construir_objeto_unificado(self, palavra):
palavra_sing = Util.singularize(palavra)
if palavra in BaseOx.objs_unificados:
return BaseOx.objs_unificados[palavra]
dir_bases = self.cfgs['caminho_bases']
dir_cache_oxford = self.cfgs['oxford']['cache']
nome_arq = palavra + '.json'
dir_obj_definicoes = dir_bases + '/' + dir_cache_oxford[
'definicoes'] + '/' + nome_arq
dir_obj_extrator = dir_bases + '/' + dir_cache_oxford[
'extrator_web'] + '/' + nome_arq
dir_obj_sinonimos = dir_bases + '/' + dir_cache_oxford[
'sinonimos'] + '/' + nome_arq
obj_definicoes = Util.abrir_json(dir_obj_definicoes,
criarsenaoexiste=False)
obj_extrator = Util.abrir_json(dir_obj_extrator,
criarsenaoexiste=False)
if obj_definicoes == None or obj_definicoes == {}:
obj_definicoes = CliOxAPI.obter_definicoes(CliOxAPI.CLI, palavra)
Util.salvar_json(dir_obj_definicoes, obj_definicoes)
if not dir_obj_sinonimos in BaseOx.objs_sinonimos_inatingiveis:
obj_sinonimos = Util.abrir_json(dir_obj_sinonimos,
criarsenaoexiste=False)
if obj_sinonimos in [None, {}]:
obj_sinonimos = self.cli_api_ox.obter_sinonimos(palavra)
if obj_sinonimos in [None, {}] and palavra_sing != palavra:
obj_sinonimos = self.cli_api_ox.obter_sinonimos(
palavra_sing)
if obj_sinonimos:
Util.salvar_json(dir_obj_sinonimos, obj_sinonimos)
if palavra_sing != palavra:
dir_obj_sinonimos = dir_bases + '/' + dir_cache_oxford[
'sinonimos'] + '/' + palavra_sing + '.json'
Util.salvar_json(dir_obj_sinonimos, obj_sinonimos)
else:
BaseOx.objs_sinonimos_inatingiveis.add(palavra)
BaseOx.objs_sinonimos_inatingiveis.add(palavra_sing)
if obj_extrator == None:
obj_extrator = self.extrator_web_ox.iniciar_coleta(palavra)
if obj_extrator != None and obj_extrator != {}:
Util.salvar_json(dir_obj_extrator, obj_extrator)
dir_obj_extrator_sing = dir_bases + '/' + dir_cache_oxford[
'extrator_web'] + '/' + palavra_sing + '.json'
if dir_obj_extrator_sing != dir_obj_extrator:
Util.salvar_json(dir_obj_extrator_sing, obj_extrator)
return obj_extrator
else:
obj_extrator = self.extrator_web_ox.iniciar_coleta(
palavra_sing)
if obj_extrator != None and obj_extrator != {}:
Util.salvar_json(dir_obj_extrator, obj_extrator)
dir_obj_extrator_sing = dir_bases + '/' + dir_cache_oxford[
'extrator_web'] + '/' + palavra_sing + '.json'
if dir_obj_extrator_sing != dir_obj_extrator:
Util.salvar_json(dir_obj_extrator_sing, obj_extrator)
return obj_extrator
return {}
# Processando definicoes
obj_join_definicoes = {}
# Processando definicoes extrator
obj_join_extrator = {}
for pos in obj_extrator:
for def_prim in obj_extrator[pos]:
k_reg = pos + self.cfgs['separador'] + def_prim[:-1].lower()
obj_join_extrator[k_reg] = obj_extrator[pos][def_prim][
'exemplos']
for def_sec in obj_extrator[pos][def_prim]['def_secs']:
k_reg = pos + self.cfgs['separador'] + def_sec[:-1].lower()
obj_join_extrator[k_reg] = obj_extrator[pos][def_prim][
'def_secs'][def_sec]['exemplos']
if not obj_definicoes or not obj_sinonimos:
return obj_extrator
for pos in obj_definicoes:
for reg in obj_definicoes[pos]:
if 'thesaurusLinks' in reg:
k_reg = pos + self.cfgs['separador'] + reg[
'thesaurusLinks'][0]['sense_id']
if 'definitions' in reg:
obj_join_definicoes[k_reg] = reg['definitions']
if 'subsenses' in reg:
for reg_sub in reg['subsenses']:
try:
k_reg = pos + self.cfgs[
'separador'] + reg_sub[
'thesaurusLinks'][0]['sense_id']
except:
k_reg = pos + self.cfgs[
'separador'] + reg_sub['id']
try:
obj_join_definicoes[k_reg] = reg_sub[
'definitions']
except:
pass
try:
k_reg = pos + self.cfgs['separador'] + reg[
'thesaurusLinks'][0]['sense_id']
if k_reg in obj_join_definicoes:
obj_join_definicoes[k_reg] += reg_sub[
'definitions']
else:
obj_join_definicoes[k_reg] = reg_sub[
'definitions']
except:
pass
else:
pass
else:
pass
obj_unificado = dict(obj_extrator)
# Processando sinonimos
obj_join_sinonimos = {}
for pos in obj_sinonimos:
for reg in obj_sinonimos[pos]:
k_reg = pos + self.cfgs['separador'] + reg['id']
try:
sins_tmp = [r['text'] for r in reg['synonyms']]
except:
sins_tmp = []
obj_join_sinonimos[k_reg] = sins_tmp
if 'subsenses' in reg:
for reg_sub in reg['subsenses']:
k_reg = pos + self.cfgs['separador'] + reg_sub['id']
try:
sins_tmp = [r['text'] for r in reg_sub['synonyms']]
except:
sins_tmp = []
obj_join_sinonimos[k_reg] = sins_tmp
# Realizando juncao de sinonimos
obj_join_sinonimos_tmp = {}
for k_reg in obj_join_sinonimos:
if k_reg in obj_join_definicoes:
for k_reg_defs in obj_join_definicoes[k_reg]:
if len(obj_join_definicoes[k_reg]) == 1:
obj_join_sinonimos_tmp[
k_reg_defs] = obj_join_sinonimos[k_reg]
for k_reg in obj_join_sinonimos:
if k_reg in obj_join_definicoes:
for k_reg_defs in obj_join_definicoes[k_reg]:
if not k_reg_defs in obj_join_sinonimos_tmp:
obj_join_sinonimos_tmp[
k_reg_defs] = obj_join_sinonimos[k_reg]
for pos in obj_extrator:
for def_prim in obj_extrator[pos]:
if def_prim[:-1].lower() in obj_join_sinonimos_tmp:
chave = def_prim[:-1].lower()
elif def_prim.lower() in obj_join_sinonimos_tmp:
chave = def_prim.lower()
else:
chave = None
if chave:
sins = obj_join_sinonimos_tmp[chave]
obj_unificado[pos][def_prim]['sinonimos'] = sins
for def_sec in obj_extrator[pos][def_prim]['def_secs']:
if def_sec[:-1].lower() in obj_join_sinonimos_tmp:
chave = def_sec[:-1].lower()
elif def_sec.lower() in obj_join_sinonimos_tmp:
chave = def_sec.lower()
else:
chave = None
if chave:
sins = obj_join_sinonimos_tmp[chave]
obj_unificado[pos][def_prim]['def_secs'][def_sec][
'sinonimos'] = sins
obj_join_sinonimos_tmp = None
obj_join_definicoes = None
obj_join_extrator = None
obj_join_sinonimos = None
obj_definicoes = None
obj_sinonimos = None
obj_extrator = None
BaseOx.objs_unificados[palavra] = obj_unificado
for pos_excluir in set(obj_unificado.keys()) - set(
self.cfgs['oxford']['pos']):
if pos_excluir in obj_unificado:
del obj_unificado[pos_excluir]
if obj_unificado == None or obj_unificado == {}:
print("O objeto da palavra %s deu errado!" % palavra)
return obj_unificado
def obter_antonimos(self, palavra):
url = "%s/entries/en/%s/antonyms" % (self.url_base, palavra)
return Util.requisicao_http(url, self.headers)
def persistir_urls_invalidas(self):
Util.salvar_json(self.dir_urls_invalidas_sinonimos,
self.obj_urls_invalidas_sinonimos)
Util.salvar_json(self.dir_urls_invalidas_definicoes,
self.obj_urls_invalidas_definicoes)
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
class DesOx(object):
INSTANCE = None
cache_objs_json = {}
def __init__(self, cfgs, base_ox, rep_vetorial=None):
self.cfgs = cfgs
self.base_ox = base_ox
self.rep_conceitos = None
self.rep_vetorial = rep_vetorial
self.usar_cache = True
self.dir_cache = cfgs['oxford']['cache']['desambiguador']
self.tam_max_ngram = 4
def assinatura_significado_aux(self, lema, pos, definicao, lista_exemplos):
retornar_valida = Util.retornar_valida_pra_indexar
assinatura = retornar_valida(definicao.replace('.', '')).lower()
assinatura = [
p for p in Util.tokenize(assinatura) if not p in [',', ';', '.']
]
if lista_exemplos:
assinatura += list(
itertools.chain(
*[retornar_valida(ex).split() for ex in lista_exemplos]))
assinatura += lema
assinatura = [p for p in assinatura if len(p) > 1]
return assinatura
# "lematizar,True::nbest,True::stop,True::ctx,frase.::pos,r::usar_ontologia,False::
# stem,True::usar_exemplos,True::busca_ampla,False"
def construir_chave_cache(self, vars):
vars = [
",".join((unicode(k), unicode(v))) for k, v in vars.iteritems()
]
return "::".join(vars)
# Metodo Cosseno feito para o dicionario de Oxford
# Retorna dados ordenados de forma decrescente
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
pontuacao = []
for assi in todas_assinaturas:
ass_definicao = Util.normalizar_ctx(assi[3],
stop=stop,
lematizar=lematizar,
stem=stem)
label_def, desc_def, frase_def, ass_def = assi
reg_def = (label_def, desc_def, frase_def)
if med_sim == 'cosine':
func_sim = cos_sim
elif med_sim == 'word_move_distance':
func_sim = self.rep_vetorial.word_move_distance
dist_simi = func_sim(" ".join(ctx), " ".join(ass_definicao))
# Colocando valor infinito
if dist_simi == float('inf'):
dist_simi = float(Util.MAX_WMD)
if dist_simi == 'cosine' and dist_simi == 0.00:
pass
else:
pontuacao.append((dist_simi, reg_def))
# Ordenacao da saida do desambiguador (cosine=decrescente, wmd=crescente)
ordem_crescente = (med_sim == 'cosine')
res_des = [(s, p)
for p, s in sorted(pontuacao, reverse=ordem_crescente)]
if self.usar_cache:
obj_cache[k_vars] = res_des
Util.salvar_json(dir_completo_obj, obj_cache)
return res_des
def extrair_sins_cands_def(self, definicao, pos):
return Util.extrair_sins_cands_def(definicao, pos)
def iniciar_indexacao_signalmedia(dir_lista_arquivos, arquivos_duplicados):
arquivos_duplicados = Util.abrir_json(arquivos_duplicados,
criarsenaoexiste=False)
arquivos_duplicados_set = set()
for reg_str in arquivos_duplicados:
path, _id_ = eval(reg_str)
arquivos_duplicados_set.add(_id_)
Whoosh.DIR_INDEXES = raw_input("Diretorio indexes: ")
if not os.path.exists(Whoosh.DIR_INDEXES):
os.mkdir(Whoosh.DIR_INDEXES)
indexer = create_in(Whoosh.DIR_INDEXES, Whoosh.SCHEMA_CORPORA)
else:
indexer = whoosh.index.open_dir(Whoosh.DIR_INDEXES)
writer = indexer.writer()
arquivo_lista = open(dir_lista_arquivos, 'r')
todos_arquivos = [
e.replace('\n', '') for e in arquivo_lista.readlines()
]
arquivo_lista.close()
indice_arquivo = 1
for _arquivo_ in todos_arquivos:
if writer.is_closed:
writer = None
writer = indexer.writer()
indice_linha = 1
arquivo = "./Bases/Corpora/SignalMedia/" + _arquivo_
print('\tArquivo %d' % (indice_arquivo))
with open(arquivo) as _arq_:
for linha_tmp in _arq_:
try:
obj_json = json.loads(linha_tmp)
if not obj_json["id"] in arquivos_duplicados_set:
titulo_doc_sm = obj_json["title"]
arq = obj_json["content"]
arq.replace(". \n\n", ". ")
arq.replace("? \n\n", "? ")
arq.replace("! \n\n", "! ")
arq.replace(". \n \n", ". ")
arq.replace("? \n \n", "? ")
arq.replace("! \n \n", "! ")
arq = re.split('[.?!]', arq)
arq = [l for l in arq if l.strip() != '']
else:
arq = []
except:
arq = []
for linha_arq in arq:
try:
#conteudo = unicode(str(linha_arq).decode('utf-8'))
#conteudo = re.sub(r'[^\x00-\x7F]+',' ', conteudo)
conteudo = str(linha_arq)
conteudo = "".join(
[i if ord(i) < 128 else " " for i in conteudo])
import random
nome_arquivo = arquivo + '-' + \
str(Util.md5sum_string(conteudo))
title = unicode(nome_arquivo)
path = unicode(nome_arquivo)
content = unicode(conteudo)
try:
if content.strip(" ") != "":
if writer.is_closed:
writer = indexer.writer()
if writer.is_closed == False:
raw_input("Deu certo!")
else:
raw_input("Deu errado!")
writer.add_document(title=title,
path=path,
content=content)
except Exception, e:
print("Content: " +
str((content, title, path)))
import traceback
traceback.print_stack()
raw_input("\nExcecao aqui: %s\n" % str(e))
except Exception, e:
import traceback
traceback.print_stack()
print("\nException: " + str(e) + "\n")
#"""print('\tArquivo %d - Linha %d' % (indice_arquivo, indice_linha))"""
indice_linha += 1
indice_arquivo += 1
print('Realizando commit. Vai gastar um bom tempo!')
try:
if writer.is_closed:
raw_input("\nWriter estava fechado na hora do commit!\n")
writer.commit()
print("@@@ " + _arquivo_)
print('Commit realizado...')
except Exception, e:
import traceback
print("@@@ " + _arquivo_)
print("\nException: " + str(e) + "\n")
print('Commit NAO realizado...')
traceback.print_stack()
print("===============================")
