Exemplo n.º 1
0
    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
Exemplo n.º 2
0
                        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))