def __verbos_from_frase(frase: Frase):
logger.debug("Obtendo verbos da frase.")
lista_verbos = []
verbos = [palavra for palavra in frase.termos_relevantes if palavra.is_verbo()]
for verbo in verbos:
lista_verbos.append(remover_acentos(verbo.palavra_canonica).lower())
lista_verbos.append(peso_verbo)
lang_group_sinonimos = verbo.sinonimos
nominalizacoes_verbo = nominalizacao.get(verbo.palavra_canonica)
for nom in nominalizacoes_verbo:
if nom not in lista_verbos:
lista_verbos.append(remover_acentos(nom).lower())
lista_verbos.append(peso_verbo_nomilizado)
for lang, sinonimos in lang_group_sinonimos.items():
for sinonimo in sinonimos:
if len(sinonimo.sinonimo) > 2 and sinonimo.sinonimo not in lista_verbos:
lista_verbos.append(remover_acentos(sinonimo.sinonimo).lower())
lista_verbos.append(peso_substantivo_comum_sinonimo)
# Obter verbos nominalizados dos sinonimos?
logger.debug("Verbos(+sinonimos) da frase: %s", lista_verbos)
return lista_verbos
def vincular_sinonimos_com_tr(frase):
for tr in frase.termos_relevantes:
termo_principal = remover_acentos(tr.palavra_canonica).lower()
if tr.is_substantivo_proprio():
helper.substantivos_proprios_frase.append(termo_principal)
helper.sinonimos[termo_principal] = termo_principal
for key, sinonimos in tr.sinonimos.items():
for sinonimo in sinonimos:
sinonimo = remover_acentos(sinonimo.sinonimo).lower()
helper.sinonimos[sinonimo] = termo_principal
def sub_query_and_update(check_result):
verb = remover_acentos(check_result["verb"].palavra_canonica).lower()
prop = remover_acentos(check_result["prop"].palavra_canonica).lower()
frase = Frase(palavras=[check_result["verb"], check_result["prop"]], frase="subquery of: " + verb + " + " + prop)
params = {}
params["termos"] = {}
params["termos"]["PROP"] = [prop, peso_substantivo_proprio]
params["termos"]["VERB"] = [verb, peso_substantivo_comum]
params["frase"] = frase
params["nao_relacionar"] = True
import json
logger.info("Executando subquery: %s", json.dumps(params))
resultado = answer_generator.execute_integration(params)
logger.debug("resultado subquery: %s", json.dumps(resultado))
props = []
if not resultado:
return None
if not resultado["all_answers"]:
return None
best_result_score = resultado["all_answers"][0]["score"]
for result in resultado["all_answers"]:
if result["score"] == best_result_score:
triple = result["triples"][0]
if triple[1][0] == "*":
if triple[0][0] == "*":
props.append(triple[2])
props.append(peso_substantivo_proprio)
logger.info("Subquery result: %s", triple[2])
continue
if triple[2][0] == "*":
props.append(triple[0])
props.append(peso_substantivo_proprio)
logger.info("Subquery result: %s", triple[0])
continue
logger.info("Subquery não obteve resultados")
break
return {
"resultado": props,
"substantivos_remover": verb,
"substantivos_proprios_remover": prop
}
def __adjetivos_nao_tr(frase: Frase):
logger.debug("Obtendo adjetivos que não são TR")
lista_adjs = []
for palavra in frase.palavras:
if palavra in frase.termos_relevantes:
continue
if palavra.is_adjetivo():
lista_adjs.append(remover_acentos(palavra.palavra_canonica).lower())
lista_adjs.append(peso_adjetivo)
lista_adjs.append(remover_acentos(palavra.palavra_original).lower())
lista_adjs.append(peso_adjetivo)
logger.debug("Verbos(+sinonimos) da frase: %s", lista_adjs)
return lista_adjs
def normalizar_value_step(params, step, steps):
logger.debug("normalizando resultados... ")
helper.init_helper(params["helper"])
triplas = {}
result_normalized = []
result = params["result"]
for field, value in result.items():
for result_tripla in value["hits"]["hits"]:
sujeito = remover_acentos(
result_tripla["_source"]["sujeito"]["conceito"])
predicado = remover_acentos(
result_tripla["_source"]["predicado"]["conceito"])
objeto = remover_acentos(
result_tripla["_source"]["objeto"]["conceito"])
tripla = [sujeito, predicado, objeto]
tripla_ja_existe = triplas.get(
tripla[0] + "-" + tripla[1] + "-" + tripla[2], None)
if not tripla_ja_existe:
triplas[tripla[0] + "-" + tripla[1] + "-" + tripla[2]] = tripla
alterar_para_variaveis(tripla)
result_normalized.append(tripla)
logger.info("done -> size=%s", len(result_normalized))
helper_values = helper.save_helper()
if steps.get(step, None):
if (not helper.substantivos_proprios_frase):
return {"correct_answer": [], "all_answers": []}
values = {}
values["values"] = result_normalized
values["helper"] = helper_values
values["nivel_combination"] = get_nivel(params["frase"], nivel)
values["frase"] = params["frase"].frase_original
values["frase_analisada"] = params["frase"]
save_as_json(values, "resultado_normalizado.json")
return steps[step][0](values, steps[step][1], steps)
else:
return result_normalized
def select_tr_to_bind(previous_result):
trs = [remover_acentos(tr.palavra_canonica.lower()) for tr in helper.frase.termos_relevantes]
if len(helper.frase.termos_relevantes) == 1:
trs_to_inject = termos_tipos_frases.get(helper.frase.tipo.tipo, [])
logger.info("Frase com somente 1 TR: Injetando TRs: %s", str(trs_to_inject))
trs += trs_to_inject
previous_result["trs"] = trs
return previous_result
def __sub_proprio_from_frase(frase: Frase, ignore):
logger.debug("Obtendo substantivos próprios da frase.")
lista_subsantivos_proprios = []
substantivos_proprios = [palavra for palavra in frase.termos_relevantes if palavra.is_substantivo_proprio()]
for substantivo in substantivos_proprios:
palavra = remover_acentos(substantivo.palavra_canonica).lower()
if palavra in ignore:
continue
lista_subsantivos_proprios.append(palavra)
lista_subsantivos_proprios.append(peso_substantivo_proprio)
logger.debug("Substantivos próprios(+sinonimos) da frase: %s", lista_subsantivos_proprios)
return lista_subsantivos_proprios
def __sub_comum_from_frase(frase: Frase, ignore):
logger.debug("Obtendo substantivos comuns da frase.")
lista_subsantivos_comuns = []
substantivos_comuns = [
palavra for palavra in frase.termos_relevantes
if palavra.is_substantivo() # or palavra.is_adjetivo()
]
for substantivo in substantivos_comuns:
palavra = remover_acentos(substantivo.palavra_canonica).lower()
if palavra == ignore:
continue
lista_subsantivos_comuns.append(palavra)
lista_subsantivos_comuns.append(peso_substantivo_comum)
lang_group_sinonimos = substantivo.sinonimos
for lang, sinonimos in lang_group_sinonimos.items():
for sinonimo in sinonimos:
if len(sinonimo.sinonimo) > 2:
lista_subsantivos_comuns.append(remover_acentos(sinonimo.sinonimo).lower())
lista_subsantivos_comuns.append(peso_substantivo_comum_sinonimo)
logger.debug("Substantivos comuns (+sinonimos) da frase: %s", lista_subsantivos_comuns)
return lista_subsantivos_comuns
def obtem_termos_relevantes(params, key):
i = 0
while i < len(params):
termo = remover_acentos(params[i]).lower()
if i + 1 < len(params):
peso = is_int(params[i + 1])
else:
peso = None
if not peso:
peso = 1
i += 1
else:
i += 2
helper.termos_relevantes.append({"termo": termo, "peso": peso, "classe": key})