Esempio n. 1
0
 def __init__(self, folder_path, language):
     self.folder_path = folder_path
     self.output_path = os.getcwd() + "\\Outputs"
     os.makedirs("Output",exist_ok=True)
     self.list_of_files = glob.glob(self.folder_path)
     # set the language for the stopwords
     self.stop_words = set(stopwords.words(language))
     # set the punctuactions
     symbols = {"º", "ª", "“", "”", "–", "¾", ',', '„', '⅞', '°', '\'', '£', '…', '’', '½'}
     self.punctuations = set(string.punctuation).union(symbols)
     # get the lemmas
     self.lemmas = PortugueseStemmer()
     # load and clean the texts
     self.texts = []
     for fil in self.list_of_files:
         with open(fil, "r", encoding='utf-8') as f:
             txt = f.read()
             #self.texts.append(txt)
             self.texts.append(self._clean_text(txt))
     # create tokens
     self.tokens = [[w.lower() for w in word_tokenize(text)] for text in self.texts]
     # create dictionary
     self.dictionary = gensim.corpora.Dictionary(self.tokens)
     # create bag-of-words
     self.bag_of_words = [self.dictionary.doc2bow(token) for token in self.tokens]
     # create tf-idf
     self.tf_idf = gensim.models.TfidfModel(self.bag_of_words)
Esempio n. 2
0
def get_stem(data):
    """
    Cria radicais para as palavras

    Parâmetros

    Data: string com texto de entrada ou lista de strings

    Retorno

    String com texto com radicais ou lista com radicais
    """

    stemmer = PortugueseStemmer()

    if(type(data)==str):
        words = data.split()
        stemWords = [stemmer.stem(word) for word in words]
        stemWords = " ".join(stemWords)
    elif(type(data)==list):
        stemWords = []
        for sentence in data:
            words = sentence.split()
            stemmed = [stemmer.stem(word) for word in words]
            stemmed = " ".join(stemmed)
            stemWords.append(stemmed)
    else:
        print("Forbidden data type %s"%(type(data)))
        return ""

    return stemWords
Esempio n. 3
0
    def execute(self, documento):
        stemmer = PortugueseStemmer()
        palavras_processadas = [
        ]  # Lista com as raizes de todas as palavras do documento
        stoplist = ArquivoUtil().get_stoplist()

        for palavra in documento.texto.split():

            # print " +++ palavra = %s" % palavra

            resultado = self.remover_pontuacao_palavra(palavra)
            palavra_sem_pontuacao = resultado[0]
            pontuacoes_antecedentes = resultado[1]
            pontuacoes_posteriores = resultado[2]

            palavras_processadas.append(pontuacoes_antecedentes)

            # Se todas as letras da palavras estão em caixa alta,
            # ou se a palavra é uma stopword.
            if palavra_sem_pontuacao.isupper() or palavra_sem_pontuacao.lower(
            ) in stoplist:
                palavras_processadas.append(
                    palavra_sem_pontuacao)  # A palavra não passa pelo stemmer
                palavras_processadas.append(pontuacoes_posteriores)
                continue

            is_notacao = False  # Indica se a palavra contém alguma das notações adotadas nos textos
            # Se a palavra contém alguma das notações adotadas no texto.
            for notacao in self.NOTACOES:
                if notacao in palavra_sem_pontuacao:
                    palavras_processadas.append(
                        palavra_sem_pontuacao
                    )  # A palavra permanece inalterada
                    palavras_processadas.append(pontuacoes_posteriores)
                    is_notacao = True
                    break

            if is_notacao is True:
                continue  # Próxima iteração

            # A palavra passa pelo stemmer
            palavras_processadas.append(stemmer.stem(palavra_sem_pontuacao))
            palavras_processadas.append(pontuacoes_posteriores)

        # Une todos os stems em uma única string, separando-os por um espaço em branco
        documento_processado = Documento(" ".join(palavras_processadas),
                                         documento.categoria,
                                         documento.corpus_pertencente,
                                         documento.nome)

        return documento_processado
Esempio n. 4
0
    def tokenize(self, text):
        #text = self.join_words(text)
        text = self.remove_accents(text)
        # Split Sentenças e em seguida palavras
        tokens = [
            unidecode(word) for sent in nltk.sent_tokenize(text)
            for word in nltk.word_tokenize(self.clear_unecessary(sent))
        ]

        stemmer = PortugueseStemmer()

        filtered_tokens = self.clear_text(tokens)
        stems = [stemmer.stem(t) for t in filtered_tokens]
        return stems
Esempio n. 5
0
class Preprocessor:
    def __init__(self):
        self.stemmer = PortugueseStemmer()

        self.token_pattern = inspect.signature(
            TfidfVectorizer).parameters['token_pattern'].default
        self.regex = re.compile(self.token_pattern)

    def stem(self, token):
        return self.stemmer.stem(token)

    def tokenize(self, document):
        return self.regex.findall(document)

    def strip_accents(self, entry):
        return strip_accents_ascii(entry)

    def lowercase(self, entry):
        return entry.lower()

    def build_tokenizer(self, stem=True, strip_accents=True, lowercase=True):
        null_call = lambda x: x

        stem_call = self.stem if stem else null_call
        strip_accents_call = self.strip_accents if strip_accents else null_call
        lowercase_call = self.lowercase if lowercase else null_call

        tokenize_call = lambda document: self.tokenize(
            strip_accents_call(lowercase_call(document)))

        return lambda document: [
            stem_call(token) for token in tokenize_call(document)
        ]
Esempio n. 6
0
    def execute(self, documento):
        stemmer = PortugueseStemmer()
        palavras_processadas = []  # Lista com as raizes de todas as palavras do documento
        stoplist = ArquivoUtil().get_stoplist()

        for palavra in documento.texto.split():

            # print " +++ palavra = %s" % palavra

            resultado = self.remover_pontuacao_palavra(palavra)
            palavra_sem_pontuacao = resultado[0]
            pontuacoes_antecedentes = resultado[1]
            pontuacoes_posteriores = resultado[2]

            palavras_processadas.append(pontuacoes_antecedentes)

            # Se todas as letras da palavras estão em caixa alta,
            # ou se a palavra é uma stopword.
            if palavra_sem_pontuacao.isupper() or palavra_sem_pontuacao.lower() in stoplist:
                palavras_processadas.append(palavra_sem_pontuacao)  # A palavra não passa pelo stemmer
                palavras_processadas.append(pontuacoes_posteriores)
                continue

            is_notacao = False  # Indica se a palavra contém alguma das notações adotadas nos textos
            # Se a palavra contém alguma das notações adotadas no texto.
            for notacao in self.NOTACOES:
                if notacao in palavra_sem_pontuacao:
                    palavras_processadas.append(palavra_sem_pontuacao)  # A palavra permanece inalterada
                    palavras_processadas.append(pontuacoes_posteriores)
                    is_notacao = True
                    break

            if is_notacao is True:
                continue  # Próxima iteração

            # A palavra passa pelo stemmer
            palavras_processadas.append(stemmer.stem(palavra_sem_pontuacao))
            palavras_processadas.append(pontuacoes_posteriores)

        # Une todos os stems em uma única string, separando-os por um espaço em branco
        documento_processado = Documento(" ".join(palavras_processadas), documento.categoria,
                                         documento.corpus_pertencente, documento.nome)
        
        return documento_processado
Esempio n. 7
0
import pickle
import re
import math
from collections import defaultdict
from nltk.stem.snowball import PortugueseStemmer
stemmer = PortugueseStemmer()
registries = pickle.load(open("registries.pkl")) # (partido, document, term)

stem_counter = defaultdict(lambda: defaultdict(int))

relevancia = defaultdict(dict)
dict_partido_by_term = defaultdict(lambda: defaultdict(set))
partidos = set()
qtd_doc_by_partido = defaultdict(int)
for partido, doc, term in registries:
    partidos.add(partido)
    stem = stemmer.stem(term)
    stem_counter[stem][term] += 1
    dict_partido_by_term[stem][partido].add(doc)
    qtd_doc_by_partido[partido] += 1

stem_to_term = {}
for stem, counter_dict in stem_counter.items():
    counter_list = counter_dict.items()
    counter_list.sort(key=lambda a: -a[1])
    term = counter_list[0][0]
    stem_to_term[stem] = term

qtd_partidos = len(partidos)
for stem, dict_doc_by_partido in dict_partido_by_term.items():
    term = stem_to_term[stem]
Esempio n. 8
0
from nltk.stem.snowball import PortugueseStemmer
from unidecode import unidecode

import nltk
import numpy as np
import os
import re

STEMMER = PortugueseStemmer()
STOPWORDS = {
    unidecode(word)
    for word in nltk.corpus.stopwords.words('portuguese')
}


def clean_text(text):
    # remove accents
    text = unidecode(text)
    # remove non-letters from text
    text = re.sub('[^a-z]', ' ', text.lower())
    return text


def tokenize(text):
    tokens = nltk.word_tokenize(text)
    # stemming tokens, if not a stopword
    return [STEMMER.stem(token) for token in tokens if token not in STOPWORDS]


def get_histograms(texts):
    for text in texts:
Esempio n. 9
0
 def sterm(self, text):
     st = PortugueseStemmer()
     return st.stem(text)
Esempio n. 10
0
# <markdowncell>

# Carregando a  lista de stopwords em lingua portuguesa para limpeza dos textos. Note que é preciso trazer as palavras para *UTF-8* antes de usá-las.

# <codecell>

sw = stopwords.words('portuguese') + list (string.punctuation)
swu = [word.decode('utf8') for word in sw]

# <markdowncell>

# Um outro ingrediente essencial é um stemmer para a nossa língua. O Stemmer reduz as palavras a uma abreviação que se aproxima da "raiz" da palavra.

# <codecell>

stemmer = PortugueseStemmer()

# <markdowncell>

# Preparando o Texto
# ------------------
# 
# Na célula abaixo, vamos normalizar os nossos textos trazendo todas as palavras para caixa baixa e abreviando-as de forma a deixar apenas as suas raízes. Neste passo, removeremos também as *stopwords*. Tenha paciência, esta análise vai levar algum tempo...

# <codecell>

textos_limpos = []
for texto in textos:
    tlimpo = [stemmer.stem(token.lower()) for token in WordPunctTokenizer().tokenize(texto) if token not in swu]
    textos_limpos.append(tlimpo)
Esempio n. 11
0
    def __init__(self):
        self.stemmer = PortugueseStemmer()

        self.token_pattern = inspect.signature(
            TfidfVectorizer).parameters['token_pattern'].default
        self.regex = re.compile(self.token_pattern)
Esempio n. 12
0
# -*- coding: utf-8 -*-

import nltk
from nltk.tokenize import WordPunctTokenizer
import string
from collections import defaultdict
from nltk.stem.snowball import PortugueseStemmer

stemmer = PortugueseStemmer()
import operator
import tools
import rdflib

# todo 1: Separador de texto (se os textos vierem como um único arquivo com tudo junto); ou de alguma forma tratar um input de vários textos
# todo 2: Fazer as instanciações a cada texto colocando como propriedade a que texto pertence
# todo 3: Ativar o reasoner
# todo 4 Contar quantos objetos com as características desejadas nós temos, fazendo assim as "coordenadas" de cada texto
# todo 5: Calcular a distância entre cada texto.
# todo 6: Fazer a k-clusterização para separar os textos em categorias.

# Vou começar usando o banco de dados que tenho, no qual os textos são exportados como arquivos únicos


def use_and_prepare_text(arquivo, splitter=','):
    #abre o arquivo, retornando uma lista de textos.
    file1 = open(arquivo, 'r+')
    texto = file1.read()
    texto = texto.decode('utf-8')
    texto = texto.split(splitter)
    return texto
# In[20]:

# Exibindo principais palavras relacionadas à classe positiva
hero.visualization.wordcloud(df[df['class'] == 'positiva']['clean'],
                             background_color='white')

# In[21]:

# Exibindo principais palavras relacionadas à classe negativa
hero.visualization.wordcloud(df[df['class'] == 'negativa']['clean'],
                             background_color='lightblue')

# In[22]:

# Diferença de stemização entre palavras com e sem acento
stemmer = PortugueseStemmer()
print(stemmer.stem('informacao'))
print(stemmer.stem('informação'))

# ### Pré-processamento dos dados

# In[23]:

stop_words = nltk.corpus.stopwords.words('portuguese')
# removing stop_words
stop_words = set(stop_words)
stop_words.update(['dia', 'q', 'pra', 'pro', 'vc', 'vcs'])
stop_words

# In[24]:
Esempio n. 14
0
class CorpusHandler:

    def __init__(self, folder_path, language):
        self.folder_path = folder_path
        self.output_path = os.getcwd() + "\\Outputs"
        os.makedirs("Output",exist_ok=True)
        self.list_of_files = glob.glob(self.folder_path)
        # set the language for the stopwords
        self.stop_words = set(stopwords.words(language))
        # set the punctuactions
        symbols = {"º", "ª", "“", "”", "–", "¾", ',', '„', '⅞', '°', '\'', '£', '…', '’', '½'}
        self.punctuations = set(string.punctuation).union(symbols)
        # get the lemmas
        self.lemmas = PortugueseStemmer()
        # load and clean the texts
        self.texts = []
        for fil in self.list_of_files:
            with open(fil, "r", encoding='utf-8') as f:
                txt = f.read()
                #self.texts.append(txt)
                self.texts.append(self._clean_text(txt))
        # create tokens
        self.tokens = [[w.lower() for w in word_tokenize(text)] for text in self.texts]
        # create dictionary
        self.dictionary = gensim.corpora.Dictionary(self.tokens)
        # create bag-of-words
        self.bag_of_words = [self.dictionary.doc2bow(token) for token in self.tokens]
        # create tf-idf
        self.tf_idf = gensim.models.TfidfModel(self.bag_of_words)

    def _clean_text(self, text):
        stop_free = " ".join([i for i in text.lower().split() if i not in self.stop_words])
        punc_free = ''.join(ch for ch in stop_free if ch not in self.punctuations)
        normalized = " ".join(self.lemmas.stem(word) for word in punc_free.split())
        return normalized

    def get_LDA_modelling(self):
        LDA = gensim.models.ldamodel.LdaModel
        return LDA(self.bag_of_words, num_topics=3, id2word = self.dictionary, passes=50)
    
    def get_corpus_frequent_terms(self, num_words):
        all_texts = ""
        for text in self.texts:
            all_texts += text
        fdist = FreqDist(all_texts.split())
        return fdist.most_common(num_words)

    def get_bigrams(self, doc_num):
        return nltk.bigrams(self.texts[doc_num].split())

    def get_trigrams(self, doc_num):
        return nltk.trigrams(self.texts[doc_num].split())

    def word_embedding(self):
        return FastText(self.tokens, size=100, min_count=5, workers=multiprocessing.cpu_count(), sg=1)
    
    def plot_word_embedding(self, word, model, nviz=15):
        g = nx.Graph()
        g.add_node(word, attr={'color':'blue'})
        viz1 = model.most_similar(word, topn=nviz)
        g.add_weighted_edges_from([(word, v, w) for v,w in viz1 if w> 0.5] )
        for v in viz1:
            g.add_weighted_edges_from([(v[0], v2, w2) for v2,w2 in model.most_similar(v[0])])
        cols = ['r']*len(g.nodes()); cols[list(g.nodes()).index(word)]='b'
        pos = nx.spring_layout(g, iterations=100)
        plt.figure(3,figsize=(12,12))
        nx.draw_networkx(g,pos=pos, node_color=cols, node_size=500, alpha=0.5, font_size=8)
        plt.savefig("Graph.png", format="PNG")
def stem(term):
    snowball_stemmer = PortugueseStemmer()
    rslp_stemmer = RSLPStemmer()
    print u'[{}] Snowball: {}, RSLP: {}'.format(term,
            snowball_stemmer.stem(term), rslp_stemmer.stem(term))