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 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
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
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
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)
]
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
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]
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:
def sterm(self, text):
st = PortugueseStemmer()
return st.stem(text)
# <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)
def __init__(self):
self.stemmer = PortugueseStemmer()
self.token_pattern = inspect.signature(
TfidfVectorizer).parameters['token_pattern'].default
self.regex = re.compile(self.token_pattern)
# -*- 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]:
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))