K-Means Clustering é um algoritmo de aprendizado não supervisionado usado para resolver problemas de cluster em aprendizado de máquina ou ciência de dados. Neste tópico, aprenderemos o que é o algoritmo de clustering K-means, como o algoritmo funciona, junto com a implementação Python do clustering k-means.

O que é o algoritmo K-Means?

O agrupamento K-Means é um Algoritmo de aprendizagem não supervisionada , que agrupa o conjunto de dados não rotulado em clusters diferentes. Aqui K define o número de clusters pré-definidos que precisam ser criados no processo, como se K=2, haverá dois clusters, e para K=3, haverá três clusters, e assim por diante.

É um algoritmo iterativo que divide o conjunto de dados não rotulado em k clusters diferentes, de tal forma que cada conjunto de dados pertence a apenas um grupo que possui propriedades semelhantes.

Ele nos permite agrupar os dados em diferentes grupos e é uma maneira conveniente de descobrir as categorias de grupos no conjunto de dados não rotulado por conta própria, sem a necessidade de qualquer treinamento.

É um algoritmo baseado em centróide, onde cada cluster está associado a um centróide. O principal objetivo deste algoritmo é minimizar a soma das distâncias entre o ponto de dados e seus clusters correspondentes.

O algoritmo pega o conjunto de dados não rotulado como entrada, divide o conjunto de dados em um número k de clusters e repete o processo até não encontrar os melhores clusters. O valor de k deve ser predeterminado neste algoritmo.

O k-meios agrupamento algoritmo executa principalmente duas tarefas:

• Determina o melhor valor para K pontos centrais ou centróides por um processo iterativo.
• Atribui cada ponto de dados ao seu centro k mais próximo. Os pontos de dados que estão próximos ao centro k específico criam um cluster.

Conseqüentemente, cada cluster possui pontos de dados com alguns pontos em comum e está distante de outros clusters.

O diagrama abaixo explica o funcionamento do algoritmo de clustering K-means:

Como funciona o algoritmo K-Means?

O funcionamento do algoritmo K-Means é explicado nas etapas abaixo:

Passo 1: Selecione o número K para decidir o número de clusters.

Passo 2: Selecione K pontos ou centróides aleatórios. (Pode ser outro do conjunto de dados de entrada).

Etapa 3: Atribua cada ponto de dados ao seu centróide mais próximo, que formará os K clusters predefinidos.

Passo 4: Calcule a variância e coloque um novo centróide de cada cluster.

Etapa 5: Repita as terceiras etapas, o que significa reatribuir cada ponto de dados ao novo centróide mais próximo de cada cluster.

Etapa 6: Se ocorrer alguma reatribuição, vá para a etapa 4, caso contrário, vá para FINISH.

Etapa 7 : O modelo está pronto.

Vamos entender as etapas acima considerando os gráficos visuais:

Suponha que temos duas variáveis ​​M1 e M2. O gráfico de dispersão do eixo xy dessas duas variáveis ​​é fornecido abaixo:

• Vamos pegar o número k de clusters, ou seja, K=2, para identificar o conjunto de dados e colocá-los em clusters diferentes. Isso significa que aqui tentaremos agrupar esses conjuntos de dados em dois clusters diferentes.
• Precisamos escolher alguns k pontos ou centróides aleatórios para formar o cluster. Esses pontos podem ser os pontos do conjunto de dados ou qualquer outro ponto. Então, aqui estamos selecionando os dois pontos abaixo como k pontos, que não fazem parte do nosso conjunto de dados. Considere a imagem abaixo:
  
• Agora atribuiremos cada ponto de dados do gráfico de dispersão ao seu ponto K ou centróide mais próximo. Iremos calculá-lo aplicando alguma matemática que estudamos para calcular a distância entre dois pontos. Então, traçaremos uma mediana entre os dois centróides. Considere a imagem abaixo:
  

Na imagem acima, fica claro que os pontos do lado esquerdo da linha estão próximos do K1 ou centróide azul, e os pontos à direita da linha estão próximos do centróide amarelo. Vamos colori-los em azul e amarelo para uma visualização clara.

• Como precisamos encontrar o cluster mais próximo, repetiremos o processo escolhendo um novo centróide . Para escolher os novos centróides, calcularemos o centro de gravidade desses centróides e encontraremos os novos centróides conforme abaixo:
  
• A seguir, reatribuiremos cada ponto de dados ao novo centróide. Para isso, repetiremos o mesmo processo de localização de uma linha mediana. A mediana será como a imagem abaixo:
  

Na imagem acima, podemos ver que um ponto amarelo está no lado esquerdo da linha e dois pontos azuis estão à direita da linha. Assim, esses três pontos serão atribuídos aos novos centróides.

Como a reatribuição ocorreu, iremos novamente para a etapa 4, que é encontrar novos centróides ou pontos K.

java comparar strings

• Repetiremos o processo encontrando o centro de gravidade dos centróides, então os novos centróides ficarão como mostrado na imagem abaixo:
  
• À medida que obtivemos os novos centróides, desenharemos novamente a linha mediana e reatribuiremos os pontos de dados. Então, a imagem será:
  
• Podemos ver na imagem acima; não há pontos de dados diferentes em nenhum dos lados da linha, o que significa que nosso modelo está formado. Considere a imagem abaixo:
  

Como nosso modelo está pronto, podemos agora remover os centróides assumidos, e os dois clusters finais serão como mostrado na imagem abaixo:

Como escolher o valor de 'K número de clusters' no K-means Clustering?

O desempenho do algoritmo de agrupamento K-means depende dos clusters altamente eficientes que ele forma. Mas escolher o número ideal de clusters é uma tarefa difícil. Existem algumas maneiras diferentes de encontrar o número ideal de clusters, mas aqui estamos discutindo o método mais apropriado para encontrar o número de clusters ou o valor de K. O método é fornecido abaixo:

Método do cotovelo

O método Elbow é uma das formas mais populares de encontrar o número ideal de clusters. Este método usa o conceito de valor WCSS. WCSS apoia Dentro da soma dos quadrados do cluster , que define as variações totais dentro de um cluster. A fórmula para calcular o valor do WCSS (para 3 clusters) é apresentada abaixo:

Na fórmula acima do WCSS,

∑_{Peu no Cluster1}distância (P_euC₁)²: É a soma do quadrado das distâncias entre cada ponto de dados e seu centróide dentro de um cluster1 e o mesmo para os outros dois termos.

Para medir a distância entre os pontos de dados e o centróide, podemos usar qualquer método, como distância euclidiana ou distância de Manhattan.

Para encontrar o valor ideal dos clusters, o método do cotovelo segue as etapas abaixo:

• Ele executa o agrupamento K-means em um determinado conjunto de dados para diferentes valores K (intervalos de 1 a 10).
• Para cada valor de K, calcula o valor WCSS.
• Traça uma curva entre os valores WCSS calculados e o número de clusters K.
• O ponto agudo da curva ou um ponto do gráfico se parece com um braço, então esse ponto é considerado o melhor valor de K.

Como o gráfico mostra a curva acentuada, que se parece com um cotovelo, é conhecido como método do cotovelo. O gráfico para o método do cotovelo se parece com a imagem abaixo:

Nota: Podemos escolher o número de clusters igual aos pontos de dados fornecidos. Se escolhermos o número de clusters igual aos pontos de dados, então o valor de WCSS torna-se zero, e esse será o ponto final do gráfico.

Implementação Python do algoritmo de clustering K-means

Na seção acima, discutimos o algoritmo K-means, agora vamos ver como ele pode ser implementado usando Pitão .

Antes da implementação, vamos entender que tipo de problema iremos resolver aqui. Então, temos um conjunto de dados de Shopping_Clientes , que são os dados dos clientes que visitam o shopping e passam por lá.

No conjunto de dados fornecido, temos Customer_Id, sexo, idade, renda anual ($) e pontuação de gastos (que é o valor calculado de quanto um cliente gastou no shopping, quanto mais valor, mais ele gastou). A partir deste conjunto de dados, precisamos calcular alguns padrões, pois é um método não supervisionado, portanto não sabemos exatamente o que calcular.

Os passos a serem seguidos para a implementação são apresentados a seguir:

Pré-processamento de dados Encontrando o número ideal de clusters usando o método do cotovelo Treinando o algoritmo K-means no conjunto de dados de treinamento Visualizando os clusters

Etapa 1: Etapa de pré-processamento de dados

O primeiro passo será o pré-processamento dos dados, como fizemos nos tópicos anteriores de Regressão e Classificação. Mas para o problema de agrupamento, será diferente de outros modelos. Vamos discutir isso:

Importando Bibliotecas
Assim como fizemos nos tópicos anteriores, primeiramente iremos importar as bibliotecas para o nosso modelo, que faz parte do pré-processamento dos dados. O código é fornecido abaixo:

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd 

No código acima, o entorpecido importamos para a realização de cálculos matemáticos, matplotlib é para traçar o gráfico, e pandas são para gerenciar o conjunto de dados.

Importando o conjunto de dados:
A seguir, importaremos o conjunto de dados que precisamos usar. Então, aqui estamos usando o conjunto de dados Mall_Customer_data.csv. Ele pode ser importado usando o código abaixo:

 # Importing the dataset dataset = pd.read_csv('Mall_Customers_data.csv') 

Ao executar as linhas de código acima, obteremos nosso conjunto de dados no Spyder IDE. O conjunto de dados se parece com a imagem abaixo:

No conjunto de dados acima, precisamos encontrar alguns padrões nele.

Extraindo variáveis ​​independentes

Aqui não precisamos de nenhuma variável dependente para a etapa de pré-processamento de dados, pois é um problema de agrupamento e não temos ideia do que determinar. Portanto, adicionaremos apenas uma linha de código para a matriz de recursos.

 x = dataset.iloc[:, [3, 4]].values 

Como podemos ver, estamos extraindo apenas 3^terceiroe 4^ºrecurso. É porque precisamos de um gráfico 2D para visualizar o modelo, e alguns recursos não são necessários, como customer_id.

Etapa 2: Encontrar o número ideal de clusters usando o método do cotovelo

Na segunda etapa, tentaremos encontrar o número ideal de clusters para nosso problema de clustering. Então, conforme discutido acima, aqui usaremos o método do cotovelo para essa finalidade.

Como sabemos, o método do cotovelo usa o conceito WCSS para desenhar o gráfico traçando os valores WCSS no eixo Y e o número de clusters no eixo X. Então, vamos calcular o valor do WCSS para diferentes valores de k variando de 1 a 10. Abaixo está o código para isso:

 #finding optimal number of clusters using the elbow method from sklearn.cluster import KMeans wcss_list= [] #Initializing the list for the values of WCSS #Using for loop for iterations from 1 to 10. for i in range(1, 11): kmeans = KMeans(n_clusters=i, init='k-means++', random_state= 42) kmeans.fit(x) wcss_list.append(kmeans.inertia_) mtp.plot(range(1, 11), wcss_list) mtp.title('The Elobw Method Graph') mtp.xlabel('Number of clusters(k)') mtp.ylabel('wcss_list') mtp.show() 

Como podemos ver no código acima, usamos o KMeans classe de sklearn. biblioteca de cluster para formar os clusters.

A seguir, criamos o lista_wcss variável para inicializar uma lista vazia, que é usada para conter o valor de wcss calculado para diferentes valores de k variando de 1 a 10.

Depois disso, inicializamos o loop for para a iteração em um valor diferente de k variando de 1 a 10; já que o loop for em Python exclui o limite de saída, então é considerado 11 para incluir 10^ºvalor.

O restante do código é semelhante ao que fizemos nos tópicos anteriores, pois ajustamos o modelo em uma matriz de recursos e, em seguida, traçamos o gráfico entre o número de clusters e o WCSS.

Saída: Após executar o código acima, obteremos a saída abaixo:

No gráfico acima, podemos ver que o ponto do cotovelo está em 5. Portanto, o número de clusters aqui será 5.

Etapa 3: Treinar o algoritmo K-means no conjunto de dados de treinamento

Como obtivemos o número de clusters, agora podemos treinar o modelo no conjunto de dados.

Para treinar o modelo, usaremos as mesmas duas linhas de código que usamos na seção acima, mas aqui em vez de usar i, usaremos 5, pois sabemos que existem 5 clusters que precisam ser formados. O código é fornecido abaixo:

 #training the K-means model on a dataset kmeans = KMeans(n_clusters=5, init='k-means++', random_state= 42) y_predict= kmeans.fit_predict(x) 

A primeira linha é igual à anterior para criar o objeto da classe KMeans.

Na segunda linha do código, criamos a variável dependente y_prever para treinar o modelo.

Ao executar as linhas de código acima, obteremos a variável y_predict. Podemos verificar abaixo o explorador de variáveis opção no Spyder IDE. Agora podemos comparar os valores de y_predict com nosso conjunto de dados original. Considere a imagem abaixo:

intenção intenção

Pela imagem acima, podemos agora relacionar que o CustomerID 1 pertence a um cluster

3 (como o índice começa em 0, portanto 2 será considerado como 3), e 2 pertence ao cluster 4 e assim por diante.

Etapa 4: Visualizando os Clusters

A última etapa é visualizar os clusters. Como temos 5 clusters para nosso modelo, visualizaremos cada cluster um por um.

Para visualizar os clusters usaremos o gráfico de dispersão usando a função mtp.scatter() do matplotlib.

 #visulaizing the clusters mtp.scatter(x[y_predict == 0, 0], x[y_predict == 0, 1], s = 100, c = 'blue', label = 'Cluster 1') #for first cluster mtp.scatter(x[y_predict == 1, 0], x[y_predict == 1, 1], s = 100, c = 'green', label = 'Cluster 2') #for second cluster mtp.scatter(x[y_predict== 2, 0], x[y_predict == 2, 1], s = 100, c = 'red', label = 'Cluster 3') #for third cluster mtp.scatter(x[y_predict == 3, 0], x[y_predict == 3, 1], s = 100, c = 'cyan', label = 'Cluster 4') #for fourth cluster mtp.scatter(x[y_predict == 4, 0], x[y_predict == 4, 1], s = 100, c = 'magenta', label = 'Cluster 5') #for fifth cluster mtp.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s = 300, c = 'yellow', label = 'Centroid') mtp.title('Clusters of customers') mtp.xlabel('Annual Income (k$)') mtp.ylabel('Spending Score (1-100)') mtp.legend() mtp.show() 

Nas linhas de código acima, escrevemos código para cada cluster, variando de 1 a 5. A primeira coordenada do mtp.scatter, ou seja, x[y_predict == 0, 0] contendo o valor x para mostrar a matriz de apresenta valores e y_predict varia de 0 a 1.

Saída:

A imagem de saída mostra claramente os cinco clusters diferentes com cores diferentes. Os clusters são formados entre dois parâmetros do conjunto de dados; Renda anual de clientes e gastos. Podemos alterar as cores e etiquetas conforme a necessidade ou escolha. Também podemos observar alguns pontos dos padrões acima, que são apresentados a seguir:

Cluster1mostra os clientes com salário médio e gastos médios para que possamos categorizar esses clientes como
• O Cluster2 mostra que o cliente tem uma renda alta, mas gastos baixos, então podemos categorizá-los como cuidadoso .
• O Cluster3 mostra a baixa renda e também os baixos gastos, para que possam ser categorizados como sensatos.
• O Cluster4 mostra os clientes de baixa renda com gastos muito elevados para que possam ser categorizados como descuidado .
• O Cluster5 mostra os clientes com alta renda e altos gastos para que possam ser categorizados como alvo, e esses clientes podem ser os clientes mais lucrativos para o dono do shopping.