def test(self):
p = PreProcessing([], [], [])
cts = machado.fileids()[:5]
tokens = []
for c in cts:
text = machado.raw(c)
tokens += p.clean_and_stem(text)
bow, bow_features_names = p.build_bow(tokens)
dist = np.sum(bow.toarray(), axis=0)
tbow = {}
for term, count in zip(bow_features_names, dist):
tbow[term] = count
import operator
print sorted(tbow.items(), key=operator.itemgetter(1), reverse=True)
texts = {}
for c in cts:
text = machado.raw(c)
texts[c] = text
terms = p.compute_tfidf(texts.values(), top_n=10, eliminate_zeros=True)
print terms
def read_machado():
'''
Esse método carrega um corpus com obras de Machado de Assis
com as respectivas categorias
'''
labels = machado.categories()
data = list()
for l in labels:
# Capturando todos os textos da categoria l
text_ids = machado.fileids(categories=l)
data.extend([(machado.raw(fileids=tid), l) for tid in text_ids])
return data
def create_indexes():
stopwords_pt = stopwords.raw('portuguese').decode('utf-8').split('\n')[:-1]
snowball_stemmer = PortugueseStemmer()
rslp_stemmer = RSLPStemmer()
indexes = {'no-stemmer-with-stopwords': Index(stemmer=None, stopwords=[]),
'no-stemmer-without-stopwords': Index(stemmer=None, stopwords=stopwords_pt),
'snowball-with-stopwords': Index(stemmer=snowball_stemmer, stopwords=[]),
'snowball-without-stopwords': Index(stemmer=snowball_stemmer, stopwords=stopwords_pt),
'rslp-with-stopwords': Index(stemmer=rslp_stemmer, stopwords=[]),
'rslp-without-stopwords': Index(stemmer=rslp_stemmer, stopwords=stopwords_pt),}
for index_name, index in indexes.iteritems():
index.name = index_name
filenames = machado.fileids()
index_count = len(indexes)
total_iterations = len(filenames) * index_count
counter = 1
for filename in filenames:
contents = machado.raw(filename)
for index_name, index in indexes.iteritems():
info = '[{:05d}/{:05d}] Adding document "{}" to index "{}" ... '\
.format(counter, total_iterations, filename, index_name)
sys.stdout.write(info)
start = time()
index.add_document(filename, contents)
end = time()
sys.stdout.write('OK ({:09.5f}s)\n'.format(end - start))
counter += 1
if not os.path.exists('data'):
os.mkdir('data')
counter = 1
for index_name, index in indexes.iteritems():
info = '[{:02d}/{:02d}] Dumping index "{}" ... '.format(counter,
index_count, index_name)
sys.stdout.write(info)
start = time()
index.dump('data/{}.pickle'.format(index_name))
end = time()
sys.stdout.write('OK ({:09.5f}s)\n'.format(end - start))
counter += 1
def __init__(self):
classes = "contos critica cronica miscelanea poesia romance teatro".split()
self.token = self.punct = self.clauses = self.patterns = ''
self.punctuation = list(",.:;!?") + ["CC", "--"]
self.punctuate = list(",.:;!?-")
# _text = self.text_setup(text5)
# self.split_clauses(_text)
# self.plot_clause('a')
self.classes = util.Mont().mont_symbol_pt()
self.classes.update({pt: "\033[1;33m{}\033[1;0m".format(pt) for pt in self.punctuate})
self.marker()
self.gens = {gen: [machado.words(txid) for txid in machado.fileids() if gen in txid] for gen in classes}
self.texts = []
self.legends = []
self._patt_data = []
self._patt_labels = []
for gen in classes:
self.legends.extend([gen]*GEN_CNT)
self.texts.extend([tx for tx in self.gens[gen]][:GEN_CNT])
# self.texts = [machado.words(conto) for conto in machado.fileids() if "contos" in conto][:20]
for txt in self.texts:
print(txt[1000:1004])
from nltk.corpus import machado, stopwords
import nltk
# nltk.download('machado')
print(machado.readme())
#2.a Categorias presentes no corpus
print(machado.categories())
#2.b
print(machado.fileids())
#2.c
arq = 'romance/marm05.txt'
palavras = machado.words([arq])
print(palavras)
#2.d
fdist = nltk.FreqDist(palavras)
for p in ['olhos', 'estado']:
print(f'Arquivo {arq} e frequência da palavra {p} {fdist[p]}')
#2.e
print(len(palavras))
#2.f
print(len(fdist.keys()))
#2.g
print(fdist.keys())
#2.h
# <markdowncell>
# Vamos também baixar o banco de *stopwords* do NLTK. Stop words são um conjunto de palavras que normalmente carregam baixo conteúdo semântico e portanto não são alvo de buscas.
# <codecell>
nltk.download('stopwords')
# <markdowncell>
# Lendo o texto *puro* dos livros de Machado:
# <codecell>
textos = [machado.raw(id) for id in machado.fileids()]
len(textos)
# <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.
texto = texto.lower()
# Tokeniza o texto
tokenize.word_tokenize(texto, language='portuguese')
"""### **A coleção de corpora do NLTK**
O NLTK contém diversos corpora disponíveis, inclusive para língua portuguesa.
> **DEFINIÇÃO**: Um corpus é uma coleção de documentos.
"""
# Importa o corpus dos livros de Machado de Assis
from nltk.corpus import machado
nltk.download('machado')
# Cada arquivo corresponde a um livro
machado.fileids()
#machado.readme()
# Obtém o texto de "Memórias Póstumas de Brás Cubas"
texto = machado.raw('romance/marm05.txt')
texto
# Você pode selecionar uma parte específica do texto
texto[9:40]
"""### **Part-of-speech Tagging (POS-Tagging)**
Esta também pode ser considerada uma das operações básicas de PLN, e tem por objetivo definir o valor morfológico de cada palavra no texto (e.g., substantivo, adjetivo, verbo, artigo, advérbio).
O objetivo da morfologia é estudar a estrutura interna e a variabilidade das palavras em uma língua, como conjugações verbais, plurais, nominalização, etc.
Ao contrário dos processos mostrados até agora, este depende do treinamento de um algoritmo supervisionado de *Machine Learning*, treinado a partir de **corpus anotado com as informações morfológicas de cada palavra**.
import sys
from nltk.corpus import machado
from tqdm import tqdm
def word_break(vocab, word):
if len(word) == 0:
yield []
else:
length = len(word)
for i in range(1, length+1):
# Have prefix on vocab
sub_string = word[:i]
if sub_string not in vocab:
continue
for each in word_break(vocab, word[i:]):
yield [sub_string] + each
if __name__ == "__main__":
word = sys.argv[1]
idx = machado.fileids()
vocab = []
for i, each in tqdm(enumerate(idx)):
vocab.extend(machado.words(each))
vocab = set(vocab)
vocab = list(vocab)
for result in word_break(vocab, word):
print(result)
import string
from nltk import ngrams
from nltk import tokenize
from nltk.corpus import machado
from nltk.corpus import stopwords
# Execute print(machado.readme()) para conhecer melhor o corpus
print(machado.readme())
# Utilizando o corpus machado, elabore um programa que atenda aos requisitos:
# a. Quais são as categorias presentes no corpus?
print('Categorias: {}'.format(machado.categories()))
# b. Quais são os documentos dentro desse corpus?
print('Documentos: {}'.format(machado.fileids()))
# c. Imprima o conteúdo do arquivo do documento que contem a obra
# Memórias Postumas de Braz Cubas
book_fileid = 'romance/marm05.txt'
print(machado.raw(book_fileid))
# d. Analise a frequência das palavras [‘olhos’,’estado’] em
# Memórias Postumas de Bras Cubas
book_text = machado.raw(book_fileid)
book_tokens = tokenize.word_tokenize(book_text)
book_freq = nltk.FreqDist(book_tokens)
for w in ['olhos', 'estado']:
print('Frequência da palavra {:>8s} : {:03}'.format(w, book_freq[w]))
#!/usr/bin/env python
# coding: utf-8
# Tip: run this script with `python -i example.py`
# (or `ipython -i example.py`), so you can interactively do searches by
# executing: `my_index.search('...search terms...')`
from nltk.corpus import machado
from index import Index
print 'Creating index...'
my_index = Index()
filenames = machado.fileids()[50:]
for filename in filenames:
my_index.add_document(filename, machado.raw(filename))
print 'Searching...'
print my_index.find('brasil azul')
from nltk.probability import FreqDist
from nltk.util import bigrams
from nltk.misc import babelize_shell
from portuguese.models import Word
import datetime
print("Type: 'texts()' to list the materials.")
ptext1 = Text(machado.words('romance/marm05.txt'),
name="Memórias Póstumas de Brás Cubas (1881)")
ptext2 = Text(machado.words('romance/marm08.txt'), name="Dom Casmurro (1899)")
ptext3 = Text(genesis.words('portuguese.txt'), name="Gênesis")
ptext4 = Text(mac_morpho.words('mu94se01.txt'),
name="Folha de Sao Paulo (1994)")
machado_fileids = machado.fileids()
machado_words = machado.words(
['romance/marm05.txt', 'cronica/macr04.txt', 'critica/mact15.txt'])
#machado_words = machado.words(machado_fileids) + mac_morpho.words('mu94se01.txt') + genesis.words('portuguese.txt')
machado_text = Text(machado_words)
machado_ci = ConcordanceIndex(machado_text)
def texts():
print("ptext1:", ptext1.name)
print("ptext2:", ptext2.name)
print("ptext3:", ptext3.name)
print("ptext4:", ptext4.name)
def common_vocab(text, n=50):