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 execAll(title):
texto = machado.raw(title)
texto = structureText(texto)
dicSinonimos = execSimplica(texto)
texto = alteraTextos(texto, dicSinonimos)
print("\nSimplificações Gramaticais")
for i in range(0, len(texto)):
mesoclise = processa_mesoclise(texto[i], tagger)
for meso in mesoclise:
texto[i] = re.sub(meso[0],
"{\'" + meso[0] + "\':[\'" + meso[1] + "\']}",
texto[i])
mesoclise = processa_contracao(texto[i], tagger, unitex)
for meso in mesoclise:
meso = list(meso)
meso[0] = " ".join(meso[0].split())
texto[i] = re.sub(meso[0],
"{\'" + meso[0] + "\':[\'" + meso[1] + "\']}",
texto[i])
mesoclise = inverter_negacao(texto[i])
for meso in mesoclise:
texto[i] = re.sub(meso[0],
"{\'" + meso[0] + "\':[\'" + meso[1] + "\']}",
texto[i])
mesoclise = enclises_raras(texto[i])
for meso in mesoclise:
texto[i] = re.sub(meso[0],
"{\'" + meso[0] + "\':[\'" + meso[1] + "\']}",
texto[i])
texto = ''.join(texto)
return texto
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 search(query):
from tokenizer import tokenize
for index in indexes:
results = index.find(query)
print '{} ({}):'.format(index.name, len(results))
for result in results:
print ' {}'.format(result)
text = machado.raw(result)
for token in tokenize(query):
new_token = index.stem(token.lower())
counter = text.lower().count(new_token)
initial_index = 0
for i in range(counter):
idx = text.lower().find(new_token, initial_index)
initial_index = idx + 1
print ' ', text[idx - 50:idx + 50].replace('\n',
'\n ')
print
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
# <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.
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**.
> **DEFINIÇÃO**: Um corpus anotado, é uma coleção de documentos etiquetada por humanos para identificar determinado valor morfológico, sintático ou semântico do texto.
No caso a seguir, estaremos trabalhando com um corpus anotado com informações morfológicas de palavras.
#### Principais dificuldades
# 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]))
# e. Quantas palavras há no texto? Use len(texto)
print('Total de palavras: {}'.format(len(book_text)))
# f. Quantas palavras distintas há na obra?
print('Total de palavras distintas: {}'.format(len(book_freq)))
this may required the downloads of some nltk data to run.
"""
import sys
import codecs
import report
from time import time
# if 'PyPy' in sys.version:
# import numpypy #important to make numpy import in NLTK work
import nltk
from nltk import *
from nltk.corpus import machado
from nltk import grammar, parse
from nltk.parse.featurechart import InstantiateVarsChart
sent_tokenizer=nltk.data.load('tokenizers/punkt/portuguese.pickle')
raw_text1 = machado.raw('romance/marm05.txt')
raw_text2 = machado.raw('romance/marm04.txt')
raw_text3 = machado.raw('romance/marm03.txt')
ptext1 = nltk.Text(machado.words('romance/marm01.txt'))
ptext2 = nltk.Text(machado.words('romance/marm02.txt'))
ptext3 = nltk.Text(machado.words('romance/marm03.txt'))
ptext4 = nltk.Text(machado.words('romance/marm04.txt'))
cp = parse.load_parser('grammars/book_grammars/feat0.fcfg', trace=1)
stemmer = nltk.stem.RSLPStemmer()
## Checking version of the benchmarking
if 'PyPy' in sys.version:
version = 'PyPy {}'.format(sys.version)
else:
#!/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')