Esempio n. 1
0
    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
Esempio n. 2
0
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
Esempio n. 4
0
 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])
Esempio n. 5
0
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
Esempio n. 6
0
# <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.
Esempio n. 7
0
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**.
Esempio n. 8
0
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)
Esempio n. 9
0
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]))
Esempio n. 10
0
#!/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')
Esempio n. 11
0
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):