Artigo escrito com a colaboração de Valéria Nicéria da Silva
O processamento de linguagem natural (PLN) é uma área dentro da Inteligência Artificial que busca fazer com que os computadores entendam e simulem uma linguagem humana. É usado no Google Translate, em sistemas de reconhecimentos e sintetização de falas, respostas automáticas e análises de sentimento. Mas como será que o PLN funciona na prática?
No artigo de hoje vamos falar um pouco mais sobre esse processamento e explicar como fazer uma análise de sentimentos usando o R para estudar uma pequena amostra de tweets.
Mineração de texto
Todo o processamento de linguagem natural só é possível por causa da mineração e extração de significado dos conteúdos postados na internet, o chamado big data. Quando falamos de conteúdo queremos dizer de artigos – em blogs como este –, notícias, comentários nas redes sociais e tudo o que é colocado na internet em forma de texto.
Esses conteúdos são considerados dados não estruturados. A mineração de texto é importante para transformá-los em dados estruturados: organizados em tabelas e devidamente identificados para que possam ser analisados. Só assim é possível extrair informações relevantes deles. Esses dados podem ser usados, por exemplo, para realizar diferentes análises de mercado, produzir matérias jornalísticas ou pesquisas científicas.
Resumindo, a mineração de texto tem como objetivo encontrar termos relevantes e estabelecer relacionamento entre eles de acordo com a sua frequência para extrair informações de grandes volumes de textos.
Workflow
Para realizar essa tarefa precisamos estabelecer um fluxo que deve ser seguido para orientar o nosso trabalho e evitar a coleta de dados que não são úteis ou análises que não são compatíveis com os dados disponíveis. O processo de obtenção dessas informações segue a seguinte lógica:
Começar com uma pergunta: primeiro devemos ter um problema que queremos resolver, ou uma pergunta que desejamos responder, como “o que as pessoas estão falando sobre data science?”
Obter os dados: com essa pergunta em mente, precisamos usar os dados para respondê-la. Para isso, utilizaremos como fonte de dados o que as pessoas estão postando no Twitter.
Limpar: depois de coletar os dados, passamos para a limpeza deles, removendo caracteres especiais – como acentos e pontuações – e transformando todas as letras em minúsculo. Depois disso retiramos também todas as stopwords, que são palavras irrelevantes para a pergunta que queremos responder.
Analisar: com tudo isso pronto, iremos realizar uma das partes mais divertidas que é analisar os dados. Aqui podemos aplicar diversas técnicas e verificar se conseguimos responder a pergunta que nos motivou a analisar esses dados.
Visualizar: nessa etapa, queremos ver o resultado da nossa análise e assim gerar diversas opções de gráficos como nuvem de palavras, gráfico de barras, dendogramas, entre outros.
Extrair conhecimento: a última parte do processo, e o objetivo do trabalho, é gerar conhecimento a partir das análises realizadas, agregando ainda mais ao nosso entendimento prévio sobre o assunto.
Código de exemplo
Para entender mais sobre o assunto criaremos um projeto básico de text mining. Para isso, utilizaremos a linguagem de programação R e os seguintes pacotes:
- ‘rtweet’ permite que você, caso tenha uma conta, se conecte ao Twitter e realize buscas de até 18 mil tweets.
- ‘tm’ o pacote tm, de “Text Mining”, é utilizado para trabalhar com textos.
- ‘wordcloud2’ permite visualizar as palavras mais usadas em tamanhos diferentes de acordo com a frequência em que cada uma delas aparece.
- ‘tydeverse’ possui uma coleção de pacotes inclusos que ajudam na manipulação dos dados.
Primeiro, vamos instalar os pacotes que serão necessários durante o projeto:
# Instalando os pacotes
install.packages("rtweet")
install.packages("tm")
install.packages("wordcloud")
install.packages("tidyverse")
E, com os pacotes instalados, devemos carregá-los para utilizar suas funções.
# Carregando os pacotes library(tm) library(rtweet) library(wordcloud) library(tidyverse)
Precisaremos de dados e vamos coletar esses dados utilizando a API do Twitter e a função de busca ‘search_tweets()’. Informamos a # que iremos buscar, o número de tweets (que não pode ultrapassar 18 mil), diremos também que não queremos os retweets e que o idioma dos tweets deverá ser o inglês.
# Buscando os tweets com a #datascience datascience_tweet <- search_tweets( "#datascience", n = 18000, include_rts = FALSE, lang = "en" )
Visualizando a frequência de tweets que utilizam a #datascience no intervalo de 1 hora:
# Gerando um gráfico com a frequencia dos tweets no intervalo de 1 hora
datascience_tweet %>%
ts_plot("1 hours") +
ggplot2::theme_minimal() +
ggplot2::theme(plot.title = ggplot2::element_text(face = "bold")) +
ggplot2::labs(
x = NULL, y = NULL,
title = "Frequência de #datascience no Twitter",
subtitle = "Tweets no intervalo de 1 hora",
caption = "\nSource: Dados coletados do Twitter's REST API via rtweet"
)
Para começar a mineração de texto vamos atribuir uma variável para a coluna text.
# Atribuindo os textos a uma variável datascience_texto <- datascience_tweet$text
Em seguida limpamos o corpus que é o total de textos colhidos. Para isso utilizamos a função tm_map, onde removeremos os caracteres especiais, transformaremos todas as letras para minúsculas, removeremos as pontuações e as stopwords em inglês.
# Transformando os textos em um corpus
datascience_corpus <- VCorpus(VectorSource(datascience_texto))
# Realizando a limpeza do corpus
datascience_corpus <-
tm_map(
datascience_corpus,
content_transformer(
function(x) iconv(x, from = 'UTF-8', to = 'ASCII//TRANSLIT')
)
) %>%
tm_map(content_transformer(tolower)) %>%
tm_map(removePunctuation) %>%
tm_map(removeWords, stopwords("english"))
Após realizar a limpeza dos textos, podemos visualizar o resultado da pesquisa em uma nuvem de palavras. Usamos a função brewer.pal para gerar as cores em hexadecimal e assim colorirmos a nuvem.
# Lista de cores em hexadecimal paleta <- brewer.pal(8, "Dark2") # Criando uma nuvem de palavras, com no máximo 100 palavras # onde tenha se repetido ao menos 2 vezes. wordcloud( datascience_corpus, min.freq = 2, max.words = 100, colors = paleta )
Em seguida criamos uma matriz de documentos-termos (DocumentTermMatrix). Removemos os termos menos frequentes da matriz e somamos os termos restantes para assim verificar quais aparecem mais vezes.
# Criando uma matriz de termos datascience_document <- DocumentTermMatrix(datascience_corpus) # Removendo os termos menos frequentes datascience_doc <- removeSparseTerms(datascience_document, 0.98) # Gerando uma matrix ordenada, com o termos mais frequentes datascience_freq <- datascience_doc %>% as.matrix() %>% colSums() %>% sort(decreasing = T)
Geramos um dataframe com os termos mais frequentes e visualizamos em um gráfico.
# Criando um dataframe com as palavras mais frequentes
df_datascience <- data.frame(
word = names(datascience_freq),
freq = datascience_freq
)
# Gerando um gráfico da frequência
df_datascience %>%
filter(!word %in% c("datascience", "via")) %>%
subset(freq > 450) %>%
ggplot(aes(x = reorder(word, freq),
y = freq)) +
geom_bar(stat = "identity", fill='#0c6cad', color="#075284") +
theme(axis.text.x = element_text(angle = 45, hjus = 1)) +
ggtitle("Termos relacionados a Data Science mais frequentes no Twitter") +
labs(y = "Frequência", x = "Termos") +
coord_flip()
Podemos também visualizar o resultado em uma nuvem de palavras utilizando o pacote wordcloud2 para gerar a nuvem.
# Carregando o pacote 'devtools'
library(devtools)
# Instalando o pacote 'wordcloud2'
devtools::install_github("lchiffon/wordcloud2")
Passamos o dataframe com os termos mais frequentes para a função wordcloud2 e teremos como resultado o seguinte gráfico.
# Carregando o pacote 'wordcloud2' library(wordcloud2) wordcloud2(data = df_datascience)
Podemos visualizar como os nossos termos estão agrupados. Para isso produziremos um dendrograma de agrupamento hierárquico, ou diagrama de árvore.
# Removendo os termos menos frequentes datascience_doc1 <- removeSparseTerms(datascience_document, 0.95) # Clustering 1 = Dendograma distancia <- dist(t(datascience_doc1), method = "euclidian") dendograma <- hclust(d = distancia, method = "complete") plot(dendograma, habg = -1, main = "Dendograma Tweets Data Science", xlab = "Distância", ylab = "Altura")
Esse é um exemplo de como podemos utilizar a mineração de texto para extrair informações relevantes de uma grande quantidade de conteúdo disponível na internet. Essa é a primeira parte de como fazer um processamento de linguagem natural.
Agora vamos pegar outro exemplo de como isso pode ser feito e quais os resultados que podem ser extraídos de uma análise se sentimos.
Para esse exemplo tentaremos responder a seguinte pergunta “qual é o sentimento das pessoas em relação à economia?”. Depois de definir a pergunta, precisamos de uma fonte de dados e para isso utilizaremos os comentários do Twitter. O projeto de exemplificação será construído utilizando a linguagem R e será necessário ter os seguintes pacotes instalados em seu computador:
- ‘tydeverse’ É um pacote, que possui uma coleção de pacotes inclusos, para ajudar na manipulação dos dados;
- ‘rtweet’ É um pacote, que permitirá que você se conecte ao Twitter, caso você tenha uma conta, onde você poderá realizar buscas, com no máximo 18 mil tweets;
- ‘tm’ O pacote tm de “Text Mining” é um pacote utilizado para trabalharmos com textos;
- ‘wordcloud’ É um pacote que nos permite visualizar de forma rápida, as palavras, utilizando como critério de tamanho, a frequência;
- ‘syuzhet’ É um pacote, que utilizaremos para classificar os sentimentos.
# Instalando os pacotes
install.packages("tydeverse")
install.packages("rtweet")
install.packages("tm")
install.packages("wordcloud")
install.packages("syuzhet")
Vamos carregar os pacotes.
# Carregando os pacotes library(tydeverse) library(rtweet) library(tm) library(wordcloud) library(syuzhet)
Agora vamos buscar os textos utilizando a função search_tweets do pacote rtweet. Utilizaremos como amostra 2 mil tweets e esses tweets estarão em inglês.
# Buscando tweets relacionados a economia economia_tweets <- search_tweets( "#economy", n = 2000, include_rts = FALSE, lang = "en" )
Para fazer o pré-processamento do texto e para simplificar nosso trabalho, vamos separar a coluna ‘text’ em uma variável.
# Separando o texto economia_text <- economia_tweets$text
Para fazer a limpeza dos textos podemos utilizar as funções do pacote tm, ou podemos criar as nossas próprias funções, como no exemplo abaixo:
# Função para limpeza dos textos
limpar_texto <- function(texto) {
# Convertendo o texto para minúsculo
texto <- tolower(texto)
# Removendo o usuário adicionado no comentário
texto <- gsub("@\\w+", "", texto)
# Removendo as pontuações
texto <- gsub("[[:punct:]]", "", texto)
# Removendo links
texto <- gsub("http\\w+", "", texto)
# Removendo tabs
texto <- gsub("[ |\t]{2,}", "", texto)
# Removendo espaços no início do texto
texto <- gsub("^ ", "", texto)
# Removendo espaços no final do texto
texto <- gsub(" $", "", texto)
return(texto)
}
Utilizando a função criada para limpar o texto temos:
# Limpando os textos economia_text <- limpar_texto(economia_text)
Transformamos o texto limpo em um corpus e depois usamos o pacote tm para remover as stopwords.
# Convertendo os textos em corpus
economia_corpus <- VCorpus(VectorSource(economia_text))
# Removendo stopwords
economia_corpus % tm_map(removeWords, stopwords("english"))
Após a limpeza, podemos visualizar os textos em uma nuvem de palavras, para descobrir os termos mais frequentes no conjunto de dados.
# Lista de cores em hexadecimal paleta <- brewer.pal(8, "Dark2") wordcloud( economia_corpus, min.freq = 15, max.words = 250, random.order = F, colors = paleta )
Agora transformaremos o nosso corpus em uma matriz de documentos-termos para criarmos um gráfico de barras com os termos e sua frequência.
# Lista de cores em hexadecimal
# Transformando o corpus em matriz de documentos-termos
economia_doc <- DocumentTermMatrix(economia_corpus)
# Removendo os termos menos frequentes
economia_doc1 <- removeSparseTerms(economia_doc, 0.97)
# Gerando uma matrix ordenada, com o termos mais frequentes
economia_freq <-
economia_doc1 %>%
as.matrix() %>%
colSums() %>%
sort(decreasing = T)
# Criando um dataframe com as palavras mais frequentes
df_economia_freq <- data.frame(
word = names(economia_freq),
freq = economia_freq
)
# Gerando um gráfico da frequência
df_economia_freq %>%
filter(!word %in% c("economy")) %>%
subset(freq > 50) %>%
ggplot(aes(x = reorder(word, freq),
y = freq)) +
geom_bar(stat = "identity", fill='#0c6cad', color="#075284") +
theme(axis.text.x = element_text(angle = 45, hjus = 1)) +
ggtitle("Termos relacionados a Economia mais frequentes no Twitter") +
labs(y = "Frequência", x = "Termos") +
coord_flip()
Criando um dendrograma (diagrama de árvore) onde será possível visualizar o agrupamento dos nossos termos.
# Dendrograma -> Visualizando os grupos
distancia <- dist(t(economia_doc1), method = "euclidian")
dendrograma <- hclust(d = distancia, method = "complete")
plot(dendrograma, habg = -1, main = "Dendrograma Tweets Economia",
xlab = "Distância",
ylab = "Altura")
E por último realizaremos a análise de sentimentos dos tweets. Para isso utilizaremos a função get_nrc_sentiment do pacote syuzhet e passaremos como parâmetro os termos da matriz de documentos-termos. Após obtermos as emoções dos termos, faremos o cálculo da frequência dos sentimentos que utilizaram a #economy.
# Obtendo os emoções economia_sentimento <- get_nrc_sentiment( economia_doc$dimnames$Terms, language = "english" ) # Calculando a frequência dos sentimentos economia_sentimento_freq % colSums() %>% sort(decreasing = T)
Com a frequência calculada, vamos traduzir os sentimentos do inglês para o português e transformar o resultado em um dataframe para depois gerar o gráfico e visualizar os resultados.
# Criando um dataframe com os sentimentos traduzidos, que será utilizado como de-para.
sentimetos_traducao <-
data.frame(
sentiment = c(
"positive",
"negative",
"trust",
"anticipation",
"fear",
"joy",
"sadness",
"surprise",
"anger",
"disgust"
),
sentimentos = c(
"Positivo",
"Negativo",
"Confiança",
"Antecipação",
"Medo",
"Alegria",
"Tristeza",
"Surpresa",
"Raiva",
"Nojo"
)
)
# Tranformando os resultados da frequência em um dataframe
# e juntando ao dataframe de tradução
df_sentimento <-
data.frame(
sentiment = names(economia_sentimento_freq),
freq = economia_sentimento_freq
) %>%
left_join(sentimetos_traducao, by = "sentiment") %>%
dplyr::select(-sentiment) %>%
arrange(desc(freq))
# Visualizando a frequência dos sentimentos em relação a #economy
ggplot(data = df_sentimento,
aes(x = reorder(sentimentos, -freq), y = freq)) +
geom_bar(aes(fill=sentimentos), stat = "identity") +
theme(legend.position = "none",
axis.text.x = element_text(angle = 45, hjus = 1)) +
xlab("Sentimentos") +
ylab("Frequência") +
ggtitle(titulo)
1 comentário em “Um exemplo prático de PLN (processamento de linguagem natural)”
Thanks for sharing. I read many of your blog posts, cool, your blog is very good.