Alura > Cursos de Data Science > Cursos de Machine Learning > Conteúdos de Machine Learning > Primeiras aulas do curso NLP: aplicando processamento de linguagem natural para análise de sentimentos

NLP: aplicando processamento de linguagem natural para análise de sentimentos

Explorando e vetorizando dados textuais - Apresentação

Olá! Meu nome é Valquíria Alencar e sou instrutora na escola de Dados.

Audiodescrição: Valquíria é uma mulher de pele clara, com olhos castanhos e cabelos ondulados, castanhos, que caem abaixo dos ombros. Ela usa um piercing no septo e veste uma blusa azul. Ao fundo, à sua direita, há uma estante decorativa, que exibe diversos itens, e a cena é iluminada por uma suave luz verde e azul.

Contextualizando

Diariamente, estamos expostos a uma variedade de informações textuais. Ao abrir nosso celular e verificar as redes sociais, nos deparamos com mensagens enviadas por outras pessoas e comentários diversos. Ao realizar uma compra em uma página, também encontramos avaliações de produtos que nos orientam nas nossas escolhas. Além disso, recebemos informações em formato de texto por meio de e-mails e outras plataformas.

À primeira vista, essas informações podem parecer caóticas, mas, ao utilizarmos ferramentas adequadas, conseguimos extrair insights valiosos a partir dos textos que encontramos.

Por exemplo, consideremos um e-commerce que recebe milhares de avaliações diariamente. As pessoas consumidoras compram produtos e compartilham suas opiniões, o que nos permite extrair insights sobre suas preferências e descontentamentos.

A partir dessas avaliações, conseguimos identificar o que agrada, o que desagrada e o sentimento geral em relação à experiência com a marca ou o produto, seja ele positivo ou negativo. Com as técnicas que aprenderemos ao longo deste curso, seremos capazes de identificar padrões e sentimentos presentes nos dados textuais.

O que aprenderemos?

Neste curso, desenvolveremos um projeto voltado para a classificação de sentimentos de clientes. Analisaremos um e-commerce que recebe diversas avaliações de consumidores. Iremos criar abordagens e utilizar estratégias eficazes para trabalhar com esses textos.

Iniciaremos compreendendo como converter informações textuais em dados numéricos, permitindo que o algoritmo as interprete e possibilitando a classificação de sentimentos. Exploraremos a frequência das palavras e aprenderemos a construir visualizações que ilustrem o que é mais recorrente, tanto em sentimentos positivos quanto negativos.

Em seguida, trabalharemos no tratamento do texto, onde aprenderemos a remover elementos irrelevantes e a processar e normalizar as informações. Aprofundaremos nosso conhecimento em técnicas mais avançadas, como Stemming, TF-IDF e N-grams, que serão fundamentais para aprimorar o modelo e aumentar a precisão na determinação se um sentimento é positivo ou negativo.

Aplicação prática do modelo

Ao final do curso, seremos capazes de aplicar esse modelo a novos dados. Faremos o modelo funcionar e completaremos um projeto que nos permitirá ver sua aplicação prática.

Pré-requisitos

Para melhor aproveitamento do conteúdo, é recomendável ter conhecimentos prévios em Python e em Machine Learning, especialmente na área de classificação.

Vamos começar?

Explorando e vetorizando dados textuais - Conhecendo os dados

Iniciaremos nosso projeto assumindo o papel cientistas de dados em um e-commerce que oferece uma ampla gama de produtos, incluindo eletrônicos, itens para o lar, produtos de beleza, vestuário, entre outros.

Entendendo a demanda

Quando uma pessoa cliente realiza uma compra e recebe o produto, ela tem a oportunidade de deixar uma avaliação.

Nesse processo, atribui uma nota ao item e redige um comentário detalhando sua experiência, que pode ser positiva ou negativa, mencionando aspectos que lhe agradaram ou desapontaram. O e-commerce recebe centenas de avaliações mensalmente.

Desafios

Um dos desafios que enfrentamos é a ausência de um método automático para identificar se a experiência da pessoa cliente foi positiva ou negativa. Isso revela a necessidade de um sistema capaz de classificar as avaliações de forma automática. Ao receber cada avaliação, o sistema poderá categorizar o sentimento como positivo ou negativo.

Essa classificação permitirá que a empresa utilize essas informações para aprimorar produtos com feedback negativo e otimizar estratégias de marketing para aqueles que foram bem avaliados.

Solução

Para resolver essa questão, criaremos um modelo de machine learning que realizará a classificação das avaliações. Teremos o texto da avaliação e transformaremos isso em uma categoria: o sentimento é positivo ou negativo? Essa abordagem auxiliará o e-commerce nas tomadas de decisão.

Carregando os dados

A primeira etapa consistirá em carregar os dados disponíveis. No GitHub, acessamos o repositório de análise de sentimento, onde encontramos uma pasta contendo os Dados, especificamente o arquivo dataset_avaliacoes.csv. Portanto, o caminho é: Dados/dataset_avaliacoes.csv.

Esse arquivo está no formato CSV, separado por vírgulas. Para visualizar os dados, clicamos na opção "View Raw" ("Ver Bruto") na parte superior central para acessar os dados brutos.

Os dados abaixo foram parcialmente transcritos para fins didáticos:

ID_avaliacao,avaliacao,nota,sentimento
81841,"Esse smartphone superou minhas expectativas, recomendo",5,positivo
28031,o cheiro e muito desagradavel!! pra quem se incomoda  nao recomendoo..,2,negativo
91332,"Eu fiz a compra a loja não entregou o produto, a compra foi feita no cartão de crédito e até o momento a loja também nao me devolveu o valor da compra.",1,negativo
110045,"Atendeu minhas expectativas, só achei a luz ruim, mas nada que dificulte seu funcionamento.",4,positivo
36929,"Gostei muito, só achei que ficou a desejar a qualidade das fotos. Achei que fosse bem melhor .",5,positivo
13086,Comprei o produto e ñ tinha para entrega isso não foi legal!!!!!!,1,negativo
117549,"o produto pode até ser bom ,mais só posso avaliá-lo depois que for feito a troca para eu usá-lo, pois estou esperando a troca ser feita o que recebi veio quebrado",1,negativo
56436,"já enviei duas reclamações, mas não obtive resposta. recebi o produto quebrado e quero que seja enviado outro. estou no aguardo para saber o que fazer. att. Cármen",1,negativo
127040,"não recebi o produto, pois vocês não cumpriram o compromisso firmado de entregar até hoje 23/05/18. PÉSSIMA LOGÍSTICA. Já solicitei o cancelamento da compra.",1,negativo

…

Em seguida, copiamos o link na parte superior usando "Ctrl + C" e vamos para o Google Colab para dar início ao nosso trabalho com esses dados.

Importando a biblioteca Pandas

O ambiente já está conectado. A primeira ação é carregar o arquivo CSV utilizando a biblioteca Pandas. Importamos a biblioteca com o seguinte comando:

import pandas as pd

Executamos a célula e criamos uma variável para armazenar o conjunto de dados carregado, que chamaremos de df (data frame) chamando a biblioteca Pandas para ler o arquivo com pd.read_csv("") passando o endereço do arquivo que copiamos:

df = pd.read_csv("endereço_do_arquivo")

Executamos a célula e visualizamos as cinco primeiras linhas para ter uma ideia do que temos no data frame:

df.head()
ID_avaliacaoavaliacaonotasentimento
81841Esse smartphone superou minhas expectativas, r...5positivo
28031o cheiro é muito desagradável!! pra quem se in...2negativo
91332Eu fiz a compra e a loja não entregou o produto,...1negativo
110045Atendeu minhas expectativas, só achei a luz ru...4positivo
36929Gostei muito, só achei que ficou a desejar a q...5positivo

Carregamos o data frame com sucesso.

Temos uma coluna com o ID_avaliacao, que serve como um código para identificar a avaliação feita pela pessoa. Com essa informação, o e-commerce consegue saber qual produto foi comprado e quem fez a avaliação. Também temos uma coluna contendo o texto da avaliacao, que descreve a experiência de compra, e uma nota atribuída, como 5, 2, 1 ou 4. Além disso, existe uma coluna que classifica o sentimento como positivo ou negativo.

Agora, vamos verificar quantas linhas e avaliações temos no total, utilizando o atributo shape:

df.shape

(15501, 4)

O resultado apresenta 15.501 avaliações organizadas em quatro colunas.

Explorando as avaliações

Agora, exploraremos a quantidade de avaliações positivas e negativas, aplicando o método value_counts() passando a coluna sentimento.

df['sentimento'].value_counts('sentimento')

Executamos a célula e obtemos:

sentimentocount
positivo7890
negativo7611

dtype: int64

Identificamos um total de 7.890 avaliações positivas e 7.611 negativas. Neste cenário, estamos lidando com uma classificação binária, uma vez que temos apenas duas categorias: positiva e negativa. Embora pudéssemos incluir um terceiro grupo com avaliações neutras, neste caso, focamos exclusivamente nas duas classes.

Para ilustrar as percepções das pessoas usuárias, selecionaremos uma avaliação positiva e uma negativa. Começaremos analisando a avaliação positiva:

print('positiva \n')

df.avaliacao[0]

O comando acima exibe no console a string "positiva:", seguida de uma quebra de linha (\n), e em seguida imprime o conteúdo da primeira entrada da coluna 'avaliacao' do DataFrame df acessando o primeiro elemento, [0], do dataframe.

Executamos a célula.

A primeira avaliação positiva afirma:

"Esse smartphone superou nossas expectativas, recomendo."

A experiência de quem adquiriu o celular foi tão satisfatória que as expectativas foram superadas, levando à recomendação do produto.

Agora, analisemos uma avaliação negativa:

print('negativa \n')

df.avaliacao[2]

A avaliação negativa diz:

"Eu fiz a compra, a loja não entregou o produto, a compra foi feita no cartão de crédito e até o momento a loja também não me devolveu o valor da compra."

A insatisfação é evidente, uma vez que o produto não foi entregue e o valor não foi estornado.

Com isso, conseguimos carregar o DataFrame, identificar quantas avaliações existem para cada sentimento e explorar uma avaliação representativa de cada categoria. Surge, então, a questão:

É possível construir um modelo de classificação com os dados no formato atual?

A resposta é não, pois os dados não estão estruturados.

Para avançarmos, precisamos transformar essas informações textuais em uma representação numérica que os algoritmos de machine learning consigam compreender.

Próximos passos

O desafio que enfrentamos agora é converter esses textos em números, dando início ao nosso trabalho com machine learning. Nos encontraremos no próximo vídeo para iniciar esse processo!

Explorando e vetorizando dados textuais - Transformando textos em dados numéricos

Já carregamos os dados e analisamos o que temos à nossa disposição. Agora, enfrentamos o desafio de converter essas informações, que se encontram em formato de texto não estruturado, em dados numéricos. Essa transformação é essencial para que nosso modelo possa compreender e classificar os sentimentos como positivos ou negativos.

Bag of Words

A transformação de um texto, repleto de palavras, em uma representação numérica pode ser realizada por meio de diversas estratégias e técnicas. Uma abordagem inicial é a Bag of Words ("sacola de palavras"). Essa técnica envolve a extração de todas as palavras presentes no texto e o cálculo da frequência de cada uma delas em cada avaliação. Assim, obtemos um vetor que reflete a frequência das palavras de forma numérica.

Para implementar essa técnica, utilizaremos uma classe específica da biblioteca Scikit-learn, que é projetada para realizar esse processo de maneira eficiente. O primeiro passo consiste em importar a classe CountVectorizer:

from sklearn.feature_extraction.text import CountVectorizer

Não executamos a célula ainda. Utilizaremos um exemplo com duas frases para compreender como esse processo funciona. Para isso, criaremos uma variável chamada texto e criar uma lista usando colchetes para inserir as frases que usaremos como exemplo. A primeira frase será 'Comprei um produto ótimo' e a outra 'Comprei um produto ruim'.

from sklearn.feature_extraction.text import CountVectorizer

texto = ['Comprei um produto ótimo', 'Comprei um produto ruim']

Temos duas frases em nossa lista, constituindo o corpus textual que será vetorizado e transformado em números. Para isso, criaremos uma variável chamada vetorizar e instanciamos a classe CountVectorizer():

from sklearn.feature_extraction.text import CountVectorizer

texto = ['Comprei um produto ótimo', 'Comprei um produto ruim']

vetorizar = CountVectorizer()

Transformando o texto em números

Agora, criaremos a variável bag_of_words para transformar os textos em números utilizando o método fit_transform(). Para isso, atribuiremos a bag_of_words o resultado da chamada à variável vetorizar, seguida do método fit_transform(texto), que realizará a conversão dos textos em números.

from sklearn.feature_extraction.text import CountVectorizer

texto = ['Comprei um produto ótimo', 'Comprei um produto ruim']

vetorizar = CountVectorizer()
bag_of_words = vetorizar.fit_transform(texto)

Executamos a célula com "Shift + Enter". Não obtivemos nenhum retorno com esse comando, precisamos chamar a variável que acabamos de gerar com o seguinte comando:

bag_of_words

Executamos a célula.

<2x5 sparse matrix of type '<class 'numpy.int64'>' with 8 stored elements in Compressed Sparse Row format>

Obtemos uma matriz com dimensões 2 por 5, ou seja, duas linhas e cinco colunas. Essa matriz é do tipo esparsa, contendo muitos zeros, uma vez que várias palavras não estão presentes em todas as avaliações. Isso porque há diversas palavras que não estarão presentes em várias avaliações.

Para facilitar a visualização dessa matriz, podemos convertê-la em um dataframe utilizando a biblioteca Pandas. Faremos isso para entendermos como a frequência foi calculada e o que mais foi realizado.

Criamos uma variável chamada matriz_esparsa e utilizamos a biblioteca pandas com pd.DataFrame. Em seguida, aplicamos o método sparse.from_spmatrix() para converter a matriz esparsa para o formato de dataframe.

No parênteses, passamos a variável bag_of_words e como segundo parâmetro nomeamos as colunas. Isso ocorre porque teremos uma matriz com diversas colunas, uma para cada palavra. Utilizamos columns=vetorizar.get_feature_names_out() para capturar o nome das palavras. O método get_feature_names_out() serve para obter os nomes das palavras presentes na matriz.

import pandas as pd

matriz_esparsa = pd.DataFrame.sparse.from_spmatrix(
    bag_of_words,
    columns=vetorizar.get_feature_names_out()
)

Executamos a célula e, na próxima célula, chamamos a matriz_esparsa:

matriz_esparsa

Obtemos o seguinte retorno:

compreiprodutoruimumótimo
011101
111110

Ao executar esta célula, encontramos duas linhas: uma para cada frase do nosso texto. A primeira linha corresponde a "Comprei um produto ótimo" e a segunda a "Comprei um produto ruim". Temos uma coluna para cada palavra.

Na primeira frase, "comprei" atribui o valor 1, pois a palavra está presente. "Produto" também recebe 1, enquanto "ruim" recebe 0, pois não está presente. Para "ótimo", o valor é 1. Na segunda frase, "comprei", "produto" e "ruim" recebem 1, enquanto "ótimo" recebe 0.

Quando uma palavra se repete, atribuímos a ela um valor de 2 ou mais, de acordo com sua frequência. A seguir, aplicaremos essa técnica aos dados em si. Para isso, criaremos novamente uma variável chamada vetorizar e chamamos o CountVectorizer().

É importante notar que, ao utilizarmos o CountVectorizer() anteriormente, todas as palavras foram convertidas para letras minúsculas. Por exemplo, a palavra "Comprei", que aparece com inicial maiúscula na frase, foi transformada em minúscula na matriz resultante.

No caso de nossos dados, não desejamos aplicar nenhuma transformação e pretendemos trabalhar com as informações em seu estado bruto. Para garantir que as palavras não sejam convertidas para minúsculas, utilizamos o parâmetro lowercase=False.

vetorizar = CountVectorizer(lowercase=False)

Ainda não executamos a célula e deixamos uma linha em branco. Agora, procederemos com a criação da variável bag_of_words, chamando o método vetorizar.fit_transform() e passando como argumento df['avaliacao'], que corresponde à coluna de avaliação do nosso dataframe.

vetorizar = CountVectorizer(lowercase=False)
bag_of_words = vetorizar.fit_transform(df.avaliacao)

Consultamos a dimensão dessa matriz com print(bag_of_words.shape):

vetorizar = CountVectorizer(lowercase=False)
bag_of_words = vetorizar.fit_transform(df.avaliacao)
print(bag_of_words.shape)

Executamos a célula e obtemos:

(15501, 23352)

O resultado indica que ainda temos 15.501 linhas de avaliações, mas o número de colunas aumentou para 23.352, refletindo a quantidade de palavras.

Esse alto número de colunas não é ideal do ponto de vista computacional, pois requer muito processamento e recursos.

Para resolver isso, podemos limitar a dimensão do conjunto de dados definindo um número máximo de features. Podemos copiar o código da célula anterior e realizar alguns ajustes.

Na primeira linha, onde definimos o vetorizar, inserimos max_features=50 como segundo parâmetro do CountVectorizer(). Com essa configuração, a matriz resultante incluirá as 50 palavras que aparecem com mais frequência na sacola de palavras, limitando assim a dimensão do conjunto de dados.

vetorizar = CountVectorizer(lowercase=False, max_features=50)
bag_of_words = vetorizar.fit_transform(df.avaliacao)
print(bag_of_words.shape)

Ao executar, obtemos:

(15501, 50)

Agora, a matriz tem apenas 50 colunas.

Podemos visualizar essa matriz esparsa criando uma variável chamada matriz_esparsa_avaliacoes, à qual atribuímos o resultado de pd.DataFrame.sparse.from_spmatrix(), passando como argumentos bag_of_words e columns=vetorizar.get_feature_names_out(). Este último parâmetro nos permite definir os nomes das colunas. Em seguida, chamaremos matriz_esparsa_avaliacoes para visualizar o resultado.

matriz_esparsa_avaliacoes = pd.DataFrame.sparse.from_spmatrix(
    bag_of_words,
    columns=vetorizar.get_feature_names_out()
)

Executamos a célula e obtemos:

NãoProdutoaindaantesasatébembomchegoucom...qualidadequerecebirecomendosesemtemumumaveio
00000000000...0001000000
10000000000...0000100000
20000000000...0000000000
30000000000...0000000000
40000000100...1200000000
..................................................................
154960000000000...0001000000
154970000000000...0000001000
154980000000000...0000000100
154990010101010...0100000001
155000000000000...0000000000

Ao executar, notamos que há diversos zeros dado que existem palavras que não estão em nenhuma avaliação.

Observamos que temos uma matriz composta por 50 palavras, onde cada linha corresponde a uma avaliação. Quando uma palavra não está presente, o valor é 0; quando está presente, o valor é 1. Se a palavra aparecer mais de uma vez, o valor será maior, como na linha 4.

Assim, conseguimos transformar palavras em números.

Próximo passo

No próximo vídeo, criaremos nosso modelo!

Sobre o curso NLP: aplicando processamento de linguagem natural para análise de sentimentos

O curso NLP: aplicando processamento de linguagem natural para análise de sentimentos possui 178 minutos de vídeos, em um total de 49 atividades. Gostou? Conheça nossos outros cursos de Machine Learning em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Aprenda Machine Learning acessando integralmente esse e outros cursos, comece hoje!

Conheça os Planos para Empresas