Clustering k-means em python: exemplo passo a passo

Um dos algoritmos de clustering mais comuns em aprendizado de máquina é conhecido como clustering k-means .

O agrupamento K-means é uma técnica na qual colocamos cada observação de um conjunto de dados em um dos K clusters.

O objetivo final é ter K clusters nos quais as observações dentro de cada cluster sejam bastante semelhantes entre si, enquanto as observações em diferentes clusters sejam bastante diferentes umas das outras.

Na prática, usamos as seguintes etapas para realizar o agrupamento K-means:

1. Escolha um valor para K.

• Primeiro, precisamos decidir quantos clusters queremos identificar nos dados. Freqüentemente, precisamos apenas testar vários valores diferentes para K e analisar os resultados para ver qual número de clusters parece fazer mais sentido para um determinado problema.

2. Atribua aleatoriamente cada observação a um cluster inicial, de 1 a K.

3. Execute o procedimento a seguir até que as atribuições do cluster parem de mudar.

• Para cada um dos K clusters, calcule o centro de gravidade do cluster. Este é simplesmente o vetor de características p- médias para as observações do k-ésimo cluster.
• Atribua cada observação ao cluster com o centróide mais próximo. Aqui, o mais próximo é definido usando a distância euclidiana .

O exemplo passo a passo a seguir mostra como realizar clustering k-means em Python usando a função KMeans do módulo sklearn .

Passo 1: Importe os módulos necessários

Primeiro, importaremos todos os módulos necessários para realizar o clustering k-means:

 import pandas as pd
import numpy as np
import matplotlib. pyplot as plt
from sklearn. cluster import KMeans
from sklearn. preprocessing import StandardScaler

Etapa 2: Crie o DataFrame

A seguir, criaremos um DataFrame contendo as três variáveis a seguir para 20 jogadores de basquete diferentes:

• pontos
• ajuda
• salta

O código a seguir mostra como criar este DataFrame do pandas:

 #createDataFrame
df = pd. DataFrame ({' points ': [18, np.nan, 19, 14, 14, 11, 20, 28, 30, 31,
                              35, 33, 29, 25, 25, 27, 29, 30, 19, 23],
                   ' assists ': [3, 3, 4, 5, 4, 7, 8, 7, 6, 9, 12, 14,
                               np.nan, 9, 4, 3, 4, 12, 15, 11],
                   ' rebounds ': [15, 14, 14, 10, 8, 14, 13, 9, 5, 4,
                                11, 6, 5, 5, 3, 8, 12, 7, 6, 5]})

#view first five rows of DataFrame
print ( df.head ())

   points assists rebounds
0 18.0 3.0 15
1 NaN 3.0 14
2 19.0 4.0 14
3 14.0 5.0 10
4 14.0 4.0 8

Usaremos agrupamento k-means para agrupar atores semelhantes com base nessas três métricas.

Etapa 3: limpe e prepare o DataFrame

Em seguida realizaremos os seguintes passos:

• Use dropna() para eliminar linhas com valores NaN em qualquer coluna
• Use StandardScaler() para dimensionar cada variável para ter uma média de 0 e um desvio padrão de 1.

O código a seguir mostra como fazer isso:

 #drop rows with NA values in any columns
df = df. dropna ()

#create scaled DataFrame where each variable has mean of 0 and standard dev of 1
scaled_df = StandardScaler(). fit_transform (df)

#view first five rows of scaled DataFrame
print (scaled_df[:5])

[[-0.86660275 -1.22683918 1.72722524]
 [-0.72081911 -0.96077767 1.45687694]
 [-1.44973731 -0.69471616 0.37548375]
 [-1.44973731 -0.96077767 -0.16521285]
 [-1.88708823 -0.16259314 1.45687694]]

Nota : Usamos escalonamento para que cada variável tenha a mesma importância ao ajustar o algoritmo k-means. Caso contrário, as variáveis com os intervalos mais amplos teriam muita influência.

Etapa 4: Encontre o número ideal de clusters

Para realizar clustering k-means em Python, podemos usar a função KMeans do módulo sklearn .

Esta função usa a seguinte sintaxe básica:

KMeans(init=’aleatório’, n_clusters=8, n_init=10, random_state=Nenhum)

Ouro:

• init : Controla a técnica de inicialização.
• n_clusters : o número de clusters nos quais colocar as observações.
• n_init : O número de inicializações a serem executadas. O padrão é executar o algoritmo k-means 10 vezes e retornar aquele com o SSE mais baixo.
• random_state : um valor inteiro que você pode escolher para tornar os resultados do algoritmo reproduzíveis.

O argumento mais importante para esta função é n_clusters, que especifica em quantos clusters colocar as observações.

No entanto, não sabemos antecipadamente quantos clusters são ideais, então precisamos criar um gráfico que exiba o número de clusters, bem como o SSE (soma dos erros quadrados) do modelo.

Normalmente, quando criamos esse tipo de gráfico, procuramos um “joelho” onde a soma dos quadrados começa a “dobrar” ou se nivelar. Geralmente, esse é o número ideal de clusters.

O código a seguir mostra como criar esse tipo de gráfico que exibe o número de clusters no eixo x e o SSE no eixo y:

 #initialize kmeans parameters
kmeans_kwargs = {
" init ": " random ",
" n_init ": 10,
" random_state ": 1,
}

#create list to hold SSE values for each k
sse = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, ** kmeans_kwargs)
    kmeans. fit (scaled_df)
    sse. append (kmeans.inertia_)

#visualize results
plt. plot (range(1, 11), sse)
plt. xticks (range(1, 11))
plt. xlabel (" Number of Clusters ")
plt. ylabel (“ SSE ”)
plt. show () 

Neste gráfico, parece que há uma torção ou “joelho” em k = 3 clusters .

Portanto, usaremos 3 clusters ao ajustar nosso modelo de cluster k-means na próxima etapa.

Nota : No mundo real, é recomendado usar uma combinação deste gráfico e experiência de domínio para escolher o número de clusters a serem usados.

Etapa 5: realizar clustering K-Means com K ideal

O código a seguir mostra como realizar clustering k-means no conjunto de dados usando o valor ideal para k de 3:

 #instantiate the k-means class, using optimal number of clusters
kmeans = KMeans(init=" random ", n_clusters= 3 , n_init= 10 , random_state= 1 )

#fit k-means algorithm to data
kmeans. fit (scaled_df)

#view cluster assignments for each observation
kmeans. labels_

array([1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0]) 

A tabela resultante mostra as atribuições de cluster para cada observação no DataFrame.

Para facilitar a interpretação desses resultados, podemos adicionar uma coluna ao DataFrame que mostra a atribuição de cluster de cada jogador:

 #append cluster assingments to original DataFrame
df[' cluster '] = kmeans. labels_

#view updated DataFrame
print (df)

points assists rebounds cluster
0 18.0 3.0 15 1
2 19.0 4.0 14 1
3 14.0 5.0 10 1
4 14.0 4.0 8 1
5 11.0 7.0 14 1
6 20.0 8.0 13 1
7 28.0 7.0 9 2
8 30.0 6.0 5 2
9 31.0 9.0 4 0
10 35.0 12.0 11 0
11 33.0 14.0 6 0
13 25.0 9.0 5 0
14 25.0 4.0 3 2
15 27.0 3.0 8 2
16 29.0 4.0 12 2
17 30.0 12.0 7 0
18 19.0 15.0 6 0
19 23.0 11.0 5 0

A coluna do cluster contém um número de cluster (0, 1 ou 2) ao qual cada jogador foi atribuído.

Jogadores pertencentes ao mesmo cluster possuem valores aproximadamente semelhantes para as colunas de pontos , assistências e rebotes .

Nota : Você pode encontrar a documentação completa da função KMeans do sklearn aqui .

Recursos adicionais

Os tutoriais a seguir explicam como realizar outras tarefas comuns em Python:

Como realizar regressão linear em Python
Como realizar regressão logística em Python
Como realizar a validação cruzada K-Fold em Python