Uma IA para ajudar você a escrever

Image for post
Image for post
Photo by Matan Segev from Pexels

E se criássemos uma inteligência artificial para revisar e criticar nossos textos? Melhor que ensinar as máquinas a jogar Xadrez, não? Ao menos para quem escreve.

Image for post
Image for post
Photo by Caleb Woods on Unsplash

Como engenheiro e cientista de dados, sempre quis destrinchar meus textos com as mesmas ferramentas que uso para analisar dados. Porém, nunca dediquei tempo para fazer isso.

Gosto do meu editor de texto (o Scrivener). Ele guarda algumas estatísticas do projeto e até faz categorizações gramaticais com a ferramenta de foco linguístico. Porém, sinto falta de algumas de análises mais sofisticadas do texto. Por isso, decidi fazer meu próprio ajudante de escrita, um sidekick para o meu editor de texto predileto. Como ele ainda é um embrião, sua primeira e única funcionalidade é:

Realce de palavras muito usadas na cena.

Aqui eu vou ensinar a:

Colorir seu texto baseado na frequência das palavras.

Image for post
Image for post
Resultado do contador de palavras para a página de Wikipedia sobre Inteligência Artificial.

Se você não quer pôr as mãos na massa e programar, pode só conferir a ferramenta no link aqui:

https://werbos.herokuapp.com/conta_palavras

Image for post
Image for post
Photo by SwapnIl Dwivedi on Unsplash

Vamos sujar as mãos com um pouco de programação?

Por que programar? Lembre-se que no futuro todos deverão saber programar. Além de tudo, programar é expandir a mente. Então… por que não?

Se você não for familiar com programação em Python, sugiro procurar um tutorial antes de continuar com a leitura, pois não vou explicar conceitos de linguagens de programação nem vou explicar como instalar o seu ambiente de programação.

Eu uso a distribuição Python da Anaconda, mas você pode usar outro interpretador. Se for reproduzir o código desse artigo, sugiro também trabalhar em um ambiente virtual (virtual env ou conda env). Depois de criar e entrar na pasta do projeto, fiz assim:

$ python -m venv venv/
$ source venv/bin/activate
$ pip install nltk
$ pip install matplotlib

As quatro linhas de comando aí em cima devem:

  1. Criar um ambiente virtual python dentro da pasta do seu projeto
  2. Ativar o ambiente virtual de desenvolvimento
  3. Instalar o biblioteca NLTK para o processamento de linguagem natural
  4. Instalar a biblioteca matplotlib para visualização de dados

Por que precisamos da NLTK?

Para quem não conhece, a NLTK é a biblioteca de processamento de linguagem natural mais popular no mundo Python. No nosso exemplo, ela vai nos ajudar a eliminar as palavras vazias (stopwords) e também com separação apropriada das sentenças em um conjunto de palavras (o processo conhecido como tokenização). Realmente não precisaríamos da NLTK nesse exemplo (é possível fazer tudo com python puro). Porém, como pretendo usar a NLTK para outras coisas em breve, achei melhor já utilizá-la.

E a Matplotlib?

Aqui a matplotlib só irá nos ajudar a colorir o texto. Ela tem um conjunto predefinido de mapeamento de cores (os colormaps) que é muito útil.

Passo 1: Separação dos Parágrafos

A ferramenta foi pensada para analisar uma cena completa. Portanto, vamos primeiro separar o texto em parágrafos, utilizando a separação de linha como delimitador:

text = "Type your beautiful scene here"
paragraphs = text.split("\n")

A segunda linha do código acima, separa o conteúdo da variável text a cada vez que encontra o caractere (invisível) de quebra de linha

Passo 2: Tokenização

Pode parecer simples como fazer um novo split utilizando o caractere do espaço como separador. Porém, queremos também nos livrar aqui da pontuação e separadores como o hífen e o travessão. Por isso, vamos utilizar um separador específico da NLTK.

import nltknltk.download('punkt') # do it onceparagraph_tokens = [nltk.word_tokenize(i) for i in paragraphs]

A variável paragraph_tokens guarda, para cada parágrafo, seu conjunto de tokens. O método word_tokenize da NLTK faz todo o trabalho para nós e retorna a lista de tokens do parágrafo.

Passo 3: Limpeza com remoção de Stopwords

Para cada token de cada parágrafo, vamos uniformizá-los (em letras minúsculas), remover símbolos indesejados (pontuações e caracteres espaciais) e ainda nos livrarmos das palavras vazias (stopwords).

import renltk.download('stopwords') # do it once# get portuguese stopwords from NLTK
stopwords = nltk.corpus.stopwords.words('portuguese')
# create regex pattern to keep only alpha numerical characters
pattern = re.compile('.*[A-Za-z].*')
# resulting list of words (empty for now)
words = []
for tokens in self.paragraph_tokens:
# only keep words that match the regex pattern
# and are not stopwords
w = [t.lower() for t in tokens
if pattern.match(t) and t not in stopwords]
# add words to the resulting list
words += w

Ao final desse laço, temos uma única lista de palavras relevantes do texto, todas em letras minúsculas, sem caracteres indesejados.

Passo 4: Contar a frequência de palavras

Essa é a parte fácil porque o Python tem uma estrutura de dados pronta para fazer isso. Então bastam estas linhas aqui embaixo:

from collections import Countercounter = Counter(words)

Aqui, você já pode verificar as dez palavras mais comuns do texto, chamando o seguinte método:

counter.most_common(10)

Passo 5: Hora de colorir!

Para exibir o texto colorido, dependemos do meio onde o texto será visualizado. Eu optei por uma visualização HTML pois eu já planejava construir uma ferramenta Web. Sendo assim, o código a seguir reconstrói o texto original acrescentando marcadores em HTML que ajustam a cor de cada palavra para ser visualizado em um navegador.

import matplotlib.pyplot as plt
from matplotlib.colors import rgb2hex
# most frequent word count
max_counter = max(counter.values())
# counter with relative frequencies
rel_counter = {k: v/max_counter for k, v in self.counter.items()}
# only words that appear more than once will be colored
frequency_threshold = 1/max_counter
# get a matplotlib colormap
cmap = plt.get_cmap('autumn_r')
# resulting tokens colored using HTML tags
html_tokens = []
for paragraph in self.paragraph_tokens:
# for each paragraph, start a HTML <p> tag
html_tokens.append('<p>')
for t in paragraph:
# for each token, set a color if it appears more than once
if t.lower() in rel_counter \
and rel_counter[t.lower()] > frequency_threshold:
# get color based on frequency
color = rgb2hex(cmap(rel_counter[t.lower()]))
html_tokens.append(f'<font size=4 color={color}>{t}</font>')
else:
html_tokens.append(t)
# end paragraph tag
html_tokens.append('</p>')
html_string = ' '.join(html_tokens)

Se você visualizar a string HTML acima em um navegador, verá seu texto colorido baseado na frequência das palavras. Você pode visualizar também em um Jupyter Notebook, utilizando o seguinte código:

from IPython.core.display import display, HTML
display(HTML(html_string))

Deixo aqui embaixo o código completo do exemplo acima, de uma forma mais fácil de copiar e colar.

Código do exemplo do artigo na forma de uma classe Python.

Pronto! O que achou? Deixe seu comentário, sugestão, opinião, bata palmas, ou reclame no Twitter @escrevejonas.

Se você chegou até aqui, obrigado pela paciência e disposição :-)

Se estiver interessado em contribuir para o projeto, pode ir lá no github também: https://github.com/jonasfd/werbos

Até mais!

Written by

Head of data science @ Evergen and aspiring writer, living in Australia. Passionate about innovation and creativity.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store