Clusterização: lidando com dados sem rótulo

Entendendo o problema dos dados não rotulados - Apresentação

Olá! Me chamo Mirla Costa, sou instrutora da Alura.

Audiodescrição: Mirla é uma mulher de pele clara, com cabelos pretos e cacheados de comprimento médio. Ela usa óculos de grau com armação redonda. Ao fundo, uma parede iluminada em tons de verde e azul, adornada por duas prateleiras flutuantes que exibem algumas decorações.

Você já teve experiência com dados rotulados em tarefas de classificação ou regressão? Agora, você está interessado em desenvolver um modelo de machine learning para trabalhar com dados não rotulados? Vamos aprofundar na técnica de clusterização.

O que vamos aprender?

Neste curso, iremos desenvolver um projeto em uma empresa do setor de consultoria e marketing, com o objetivo de criar um modelo capaz de agrupar consumidores com base em seus interesses. Essa abordagem permitirá a elaboração de campanhas de marketing mais eficazes e direcionadas.

Pré-requisitos

Para a realização deste projeto, utilizaremos a linguagem de programação Python e bibliotecas essenciais como Pandas e Scikit-Learn. Estas ferramentas serão fundamentais para a manipulação de dados e a implementação do nosso modelo de clusterização.

Para maximizar sua aprendizagem, é recomendável que você já possua um conhecimento sólido em Python, além de familiaridade com as bibliotecas Pandas, Matplotlib e Scikit-Learn.

Vamos começar?

Entendendo o problema dos dados não rotulados - Coletando dados sem rótulo

Estamos atuando em uma empresa de consultoria de marketing e enfrentamos um desafio significativo: segmentar nossas bases de clientes de acordo com seus interesses. Essa segmentação é crucial para que possamos desenvolver campanhas de marketing eficazes.

Sem uma segmentação clara, frequentemente enfrentamos altos custos na criação, elaboração e divulgação de campanhas, sem conseguir o retorno esperado sobre esse investimento. Embora os dados que coletamos sejam ricos em informações, identificar os interesses e padrões de consumo dos nossos clientes e categorizá-los de forma eficiente é uma tarefa que se revela extremamente desafiadora, se não impossível, apenas com análise manual.

Nossa missão será desenvolver um modelo de machine learning capaz de identificar padrões em nossos dados e segmentar nossos consumidores de acordo com suas áreas de interesse. Além disso, precisamos analisar e determinar as características específicas dessas áreas de interesse.

Por último, iremos disponibilizar tanto o modelo quanto os resultados obtidos para a equipe de marketing, permitindo que eles elaborem campanhas mais direcionadas e eficazes.

Para encontrar uma solução eficaz, o primeiro passo é coletar os dados e avaliar qual modelo ou técnica de machine learning podemos aplicar. Para iniciar este projeto, utilizaremos um notebook, que servirá como nossa ferramenta principal ao longo de todo o curso.

O notebook está disponível para download nas atividades desta aula.

Importando as bibliotecas

Ao longo do curso, iremos trabalhar juntos na construção do código. Neste momento, já acessamos o Colab, que está aberto e conectado, prontos para iniciar nossas atividades.

A primeira etapa que devemos realizar é importar as bibliotecas mais utilizadas em projetos de data science, que incluem NumPy, Pandas, Matplotlib e Seaborn. Procederemos executando os seguintes comandos:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

Teclamos "Shift + Enter" para executar a célula.

Essas bibliotecas já estão integradas ao ambiente do Colab, portanto, não é necessário realizar nenhuma instalação adicional.

Agora, temos um link que nos proporcionará acesso aos dados que utilizaremos para treinar o modelo de machine learning.

url = 'https://raw.githubusercontent.com/Mirlaa/Clusterizacao-dados-sem-rotulo/main/Dados/dados_mkt.csv'

Executaremos a célula para salvar esse link de acesso.

Coletando e ajustando dados

Importaremos os dados em um dataframe, que denominaremos de df, utilizando a função pd.read_csv(), onde pd refere-se à biblioteca Pandas. O método .read_csv() é apropriado, pois, ao analisarmos o link, constatamos que os dados estão no formato CSV. Assim, passaremos a url dentro dos parênteses para realizar a importação. Por fim, inserimos df para exibir o dataframe.

df = pd.read_csv('url')
df

Teclamos "Shift + Enter".

Tabela parcialmente transcrita:

O conjunto de dados que iremos utilizar refere-se às pessoas consumidoras, contendo características e informações relevantes sobre eles, além dos temas de interesse para a equipe de marketing.

Para cada amostra que representa uma pessoa consumidora, analisaremos a frequência com que esses temas de interesse foram mencionados ou compartilhados em suas redes sociais. Por exemplo, se os dados indicarem que "futebol" foi mencionado 10 vezes e "futebol americano" 50, isso refletirá o número de vezes que cada tema foi divulgado.

Outra observação sobre nosso conjunto de dados é que temos informações sobre as características de cada amostra, mas não contamos com colunas que apresentem rótulos, ou seja, valores esperados para cada amostra. Isso indica que estamos lidando com dados não rotulados, sem valores esperados.

Clusterização

Nesse contexto, uma técnica de machine learning que podemos utilizar é o clustering, que agrupa e segmenta o conjunto de dados com base em suas características e semelhanças.

Verificando a estrutura do dataframe

Precisamos verificar como está estruturado do dataframe e se há ajustes a serem feitos antes de criar e enviar os dados ao modelo de clustering. Utilizaremos o comando df.info() para observar possíveis irregularidades:

df.info()

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 12992 entries, 0 to 12991

Data columns (total 27 columns):

dtypes: int64(26), object(1)

memory usage: 2.7+ MB

Observamos que não temos nenhuma coluna nula, o que é ótimo, mas temos uma coluna, a coluna sexo, que está como object. Isso indica que temos valores do tipo string. Normalmente, modelos de clustering não aceitam dados textuais, então precisamos ajustar essa coluna para um formato numérico.

Verificando os dados da coluna

Verificaremos os tipos de dados dentro dessa coluna:

df['sexo'].unique()

array(['F', 'M', 'NE'], dtype=object)

Percebemos que há apenas três valores únicos, o que indica que essa coluna é categórica. Para colunas categóricas, podemos aplicar técnicas que transformam essas informações em dados numéricos.

Aplicando encoder

Uma dessas técnicas é o OneHotEncoder, que converte cada categoria em colunas numéricas. Iremos aplicar o OneHotEncoder utilizando a biblioteca Scikit-learn:

from sklearn.preprocessing import OneHotEncoder

Neste comando, estamos importando a classe OneHotEncoder da biblioteca Scikit-learn, que é uma ferramenta muito útil para transformar dados categóricos em um formato que pode ser utilizado por modelos de machine learning.

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder(categories=[['NE', 'F', 'M']], sparse_output=False)

No encoder, estamos criando uma instância do OneHotEncoder.

• categories=[['NE', 'F', 'M']]: Esta parte especifica quais são as categorias que queremos codificar. Neste caso, temos três categorias: "NE" (que pode representar "Não Especificado"), "F" (feminino) e "M" (masculino). Ao listar essas categorias, estamos informando ao encoder quais valores ele deve considerar.

• sparse_output=False: Este parâmetro determina o formato da saída do encoder. Quando definido como False, o resultado será um array denso, ou seja, uma matriz onde todos os valores são armazenados de forma compacta. Se estivesse definido como True, o resultado seria uma matriz esparsa, que é mais eficiente em termos de memória, especialmente se tivermos muitas categorias e muitos zeros.

Teclamos "Shift + Enter".

Identificamos que o tipo de modelo que utilizaremos é o modelo de clustering. Antes de criar e treinar esse modelo, é necessário concluir a transformação das colunas categóricas em numéricas.

Próximo passo

Daremos continuidade a esse processo no próximo vídeo!

Entendendo o problema dos dados não rotulados - Convertendo dados e construindo o modelo

A partir dos dados disponíveis no nosso contexto, identificamos a possibilidade de construir um modelo de machine learning com foco na técnica de clusterização, que permitirá agrupar os dados em grupos de interesse.

Entretanto, ainda temos dados categóricos no nosso conjunto, e é necessário concluir a aplicação da técnica de OneHotEncoder. Para isso, transformaremos a coluna categórica em numérica e a adicionaremos aos nossos dados. Em seguida, retornaremos ao nosso Colab para realizar essa tarefa.

Convertendo dados e construindo o modelo

Começando exatamente de onde paramos, já temos o objeto encoder configurado com o OneHotEncoder. Agora, é o momento de transformar nossa coluna categórica.

Criaremos uma variável chamada encoded_sexo, que armazenará o resultado do encoding da nossa coluna. Utilizaremos encoder.fit_transform(), passando entre parênteses a coluna categórica que desejamos transformar.

Para acessar a coluna "sexo" do nosso DataFrame df, abriremos colchetes e colocaremos aspas simples com o nome da coluna. Em seguida, adicionaremos mais um par de colchetes para selecionar essa coluna corretamente. Após isso, daremos um enter e inseriremos encoded_sexo, pressionando "Shift + Enter" para visualizar o resultado.

encoded_sexo = encoder.fit_transform(df[['sexo']])
encoded_sexo

array([[0., 1., 0.],

  [0., 1., 0.],
  
  [0., 1., 0.],
  
  ...,
  
  [0., 1., 0.],
  
  [0., 1., 0.],
  
  [0., 1., 0.]])

Retornou um array do NumPy com valores que, antes categóricos, agora estão completamente numéricos, variando entre 0 e 1, correspondendo a suas respectivas categorias.

Organizando os dados no dataframe

Iremos agora organizar esses dados em um novo DataFrame para integrá-los ao DataFrame original que já possuímos. Criaremos um DataFrame chamado encoded_df =, utilizando pd.DataFrame() para gerar um DataFrame com esses valores.

Entre parênteses, inseriremos os dados que coletamos, que correspondem ao encoded_sexo, e também especificaremos os nomes das colunas. Para isso, utilizaremos columns igual a encoder.get_feature_names_out(), que nos permite obter os nomes das colunas correspondentes a cada uma dessas features.

Dentro dos parênteses, indicaremos a coluna relacionada a esses nomes. Assim, abriremos colchetes, colocaremos aspas e inseriremos 'sexo', que é o nome da coluna.

encoded_df = pd.DataFrame(encoded_sexo, columns=encoder.get_feature_names_out(['sexo']))

Executamos a célula teclando "Shift + Enter".

Aplicando o concat() para integrar os dataframes

Na próxima etapa realizaremos o concat(), que integrará o DataFrame recém-criado com o nosso DataFrame original. O DataFrame final, que conterá todos esses valores, será denominado de dados.

Atribuímos a dados o resultado de pd.concat(). Dentro dos parênteses, o primeiro argumento será um par de colchetes contendo df, o DataFrame original, e encoded_df, que é o DataFrame com os novos dados a serem integrados. Após esses colchetes, adicionaremos uma vírgula e especificaremos axis=1, uma vez que essa integração ocorrerá por colunas.

Fora do concat(), adicionaremos a função drop() para excluir a coluna "sexo", que possui o tipo object. Utilizaremos um ponto seguido de drop(), abrindo parênteses para especificar a coluna a ser descartada. Em seguida, inseriremos aspas e digitaremos 'sexo', que é a coluna que será removida.

Também precisaremos adicionar uma vírgula e especificar axis=1, pois estamos lidando com uma coluna. Após concluir toda essa construção, é importante visualizar nossos dados na linha seguinte da mesma célula.

dados = pd.concat([df, encoded_df], axis=1).drop('sexo', axis=1)
dados

Ao pressionar "Shift + Enter" para executar essa célula.

As colunas da tabela abaixo foram parcialmente transcritas:

Temos todas as variáveis numéricas com as quais já estamos familiarizados, a coluna "sexo" foi removida e, no final, aparecem três novas colunas: "sexo_F", "sexo_M" e "sexo_NE", com os respectivos valores que indicam a presença ou ausência dessas características. Com isso, alcançamos sucesso na aplicação do encoder.

Para disponibilizarmos os dados ao final, salvaremos o objeto encoder que utilizamos para realizar essa transformação. Para isso, transformaremos esse objeto em um arquivo pkl, que é um formato padrão para salvar objetos em Python.

Transformando o objeto em um pkl

Importamos uma biblioteca chamada joblib. Começamos com import JobLib, pressionamos dois enters e, para criar o novo arquivo, utilizamos joblib.dump(). Dentro dos parênteses, especificamos nosso objeto, que é o encoder, seguido de uma vírgula e o nome do arquivo. Colocamos aspas simples e escrevemos "'encoder.pkl'", que é a extensão do arquivo pkl.

import joblib

joblib.dump(encoder, 'encoder.pkl')

Pressionamos "Shift + Enter" para executar a célula.

['encoder.pkl']

O sistema nos retornará a confirmação, e, ao observarmos os arquivos na barra lateral esquerda do Colab, veremos que o arquivo encoder.pkl foi criado e está pronto para ser baixado e utilizado posteriormente.

Desenvolvendo o modelo

Agora que já criamos e ajustamos os dados, é hora de desenvolver nosso modelo de K-Means. Utilizaremos o modelo K-Means, que faz parte das técnicas de clustering. Esse modelo será extremamente útil para o projeto, pois agrupa os dados com base em características semelhantes, formando agrupamentos, ou "bolhas".

Essas bolhas representarão os interesses das pessoas consumidoras. Por exemplo, aqueles que são fãs de futebol ficarão dentro de uma bolha relacionada a esportes, enquanto pessoas interessadas em compras formarão outra bolha específica para esse tema.

Assim, cada grupo de pessoas consumidoras com interesses distintos estará em sua própria bolha. Por isso, o KMeans é uma excelente escolha para resolver a questão que estamos abordando.

Deixaremos uma atividade para que vocês possam estudar e entender melhor como o KMeans funciona, os conceitos relacionados e como ele realiza o aprendizado. É importante que analisem a atividade e se aprofundem nesse assunto.

Construiremos o modelo. Para utilizá-lo, utilizaremos a biblioteca sklearn. Portanto, digitaremos no nosso código from sklearn.cluster import KMeans.

from sklearn.cluster import KMeans

Após realizar o import do modelo, criamos um objeto para armazená-lo. Nomeamos esse objeto como mod_kmeans, e o igualamos ao KMeans(). Dentro dos parênteses, especificamos a quantidade de agrupamentos, que representa as bolhas de interesse que estaremos criando. Esses agrupamentos são conhecidos como clusters no contexto do KMeans, e é fundamental que essa informação seja inicializada dentro do modelo.

Para inicializar, utilizamos um parâmetro chamado n_clusters, começando com o valor 2. Além desse parâmetro, definimos também uma inicialização de estado aleatório, utilizando random_state=45. Isso nos permite ter um ambiente controlado e garantir resultados consistentes.

from sklearn.cluster import KMeans

mod_kmeans = KMeans(n_clusters=2, random_state=45)

Após isso, pressionamos "Shift + enter" para criar o modelo. Em seguida, procederemos para treiná-lo com nossos dados.

Treinando o modelo

Para realizar o treinamento do modelo, inserimos na outra célula modelo = mod_kmeans.fit(), especificando os dados entre parênteses.

modelo = mod_kmeans.fit(dados)

Após isso, pressionamos "Shift + Enter" para executar o treinamento.

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of n_init will change from 10 to 'auto' in 1.4. Set the value of n_init explicitly to suppress the warning super()._check_params_vs_input(X, default_n_init=10)

É possível que apareça um aviso de future warning, mas isso se deve a uma alteração no valor de um parâmetro n_init, que não nos impactará neste momento. Não precisamos nos preocupar com essa informação, pois já completamos o treinamento do nosso modelo.

Próximo passo

Agora temos nosso modelo treinado, pronto para fazer a separação de interesses. No entanto, não podemos enviar esse modelo na forma como está, pois ainda não avaliamos a qualidade das separações. Faremos essa avaliação na próxima aula!

Sobre o curso Clusterização: lidando com dados sem rótulo

O curso Clusterização: lidando com dados sem rótulo possui 127 minutos de vídeos, em um total de 48 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:

• Entendendo o problema dos dados não rotulados
• Avaliando o K-means
• Otimizando o resultado
• Verificando os clusters criados
• Criando a aplicação do projeto