Clustering K-Means en Python : exemple étape par étape

L’un des algorithmes de clustering les plus courants dans l’apprentissage automatique est connu sous le nom de clustering k-means .

Le clustering K-means est une technique dans laquelle nous plaçons chaque observation d’un ensemble de données dans l’un des K clusters.

L’objectif final est d’avoir K clusters dans lesquels les observations au sein de chaque cluster sont assez similaires les unes aux autres tandis que les observations dans différents clusters sont assez différentes les unes des autres.

En pratique, nous utilisons les étapes suivantes pour effectuer un clustering K-means :

1. Choisissez une valeur pour K .

• Tout d’abord, nous devons décider combien de clusters nous souhaitons identifier dans les données. Souvent, nous devons simplement tester plusieurs valeurs différentes pour K et analyser les résultats pour voir quel nombre de clusters semble avoir le plus de sens pour un problème donné.

2. Attribuez aléatoirement chaque observation à un cluster initial, de 1 à K.

3. Effectuez la procédure suivante jusqu’à ce que les affectations de cluster cessent de changer.

• Pour chacun des K clusters, calculez le centre de gravité du cluster. Il s’agit simplement du vecteur des p moyennes des caractéristiques pour les observations du k ème cluster.
• Attribuez chaque observation au cluster dont le centre de gravité est le plus proche. Ici, le plus proche est défini en utilisant la distance euclidienne .

L’exemple étape par étape suivant montre comment effectuer un clustering k-means en Python à l’aide de la fonction KMeans du module sklearn .

Étape 1 : Importer les modules nécessaires

Tout d’abord, nous importerons tous les modules dont nous aurons besoin pour effectuer le 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

Étape 2 : Créer le DataFrame

Ensuite, nous allons créer un DataFrame contenant les trois variables suivantes pour 20 joueurs de basket différents :

• points
• aide
• rebondit

Le code suivant montre comment créer ce DataFrame pandas :

#create DataFrame
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

Nous utiliserons le clustering k-means pour regrouper les acteurs similaires sur la base de ces trois métriques.

Étape 3 : Nettoyer et préparer le DataFrame

Ensuite, nous effectuerons les étapes suivantes :

• Utilisez dropna() pour supprimer des lignes avec des valeurs NaN dans n’importe quelle colonne
• Utilisez StandardScaler() pour mettre à l’échelle chaque variable afin d’avoir une moyenne de 0 et un écart type de 1.

Le code suivant montre comment procéder :

#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]]

Remarque : Nous utilisons la mise à l’échelle pour que chaque variable ait la même importance lors de l’ajustement de l’algorithme des k-moyennes. Autrement, les variables ayant les plages les plus larges auraient trop d’influence.

Étape 4 : Trouver le nombre optimal de clusters

Pour effectuer un clustering k-means en Python, nous pouvons utiliser la fonction KMeans du module sklearn .

Cette fonction utilise la syntaxe de base suivante :

KMeans(init=’random’, n_clusters=8, n_init=10, random_state=None)

où:

• init : Contrôle la technique d’initialisation.
• n_clusters : le nombre de clusters dans lesquels placer les observations.
• n_init : Le nombre d’initialisations à effectuer. La valeur par défaut consiste à exécuter l’algorithme k-means 10 fois et à renvoyer celui avec le SSE le plus bas.
• random_state : Une valeur entière que vous pouvez choisir pour rendre les résultats de l’algorithme reproductibles.

L’argument le plus important de cette fonction est n_clusters, qui spécifie dans combien de clusters placer les observations.

Cependant, nous ne savons pas à l’avance combien de clusters est optimal, nous devons donc créer un graphique qui affiche le nombre de clusters ainsi que le SSE (somme des erreurs quadratiques) du modèle.

Généralement, lorsque nous créons ce type de tracé, nous recherchons un « coude » où la somme des carrés commence à « se plier » ou à se stabiliser. Il s’agit généralement du nombre optimal de clusters.

Le code suivant montre comment créer ce type de tracé qui affiche le nombre de clusters sur l’axe des x et le SSE sur l’axe des 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()

Dans ce graphique, il apparaît qu’il y a un coude ou un « coude » à k = 3 clusters .

Ainsi, nous utiliserons 3 clusters lors de l’ajustement de notre modèle de clustering k-means à l’étape suivante.

Remarque : Dans le monde réel, il est recommandé d’utiliser une combinaison de ce tracé et de l’expertise du domaine pour choisir le nombre de clusters à utiliser.

Étape 5 : Effectuer un clustering K-Means avec Optimal K

Le code suivant montre comment effectuer un clustering k-means sur l’ensemble de données en utilisant la valeur optimale pour k sur 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]) 

Le tableau résultant montre les affectations de cluster pour chaque observation dans le DataFrame.

Pour rendre ces résultats plus faciles à interpréter, nous pouvons ajouter une colonne au DataFrame qui montre l’affectation du cluster de chaque joueur :

#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

La colonne de cluster contient un numéro de cluster (0, 1 ou 2) auquel chaque joueur a été attribué.

Les joueurs appartenant au même cluster ont des valeurs à peu près similaires pour les colonnes de points , de passes décisives et de rebonds .

Remarque : Vous pouvez trouver la documentation complète de la fonction KMeans de sklearn ici .

Ressources additionnelles

Les didacticiels suivants expliquent comment effectuer d’autres tâches courantes en Python :

Comment effectuer une régression linéaire en Python
Comment effectuer une régression logistique en Python
Comment effectuer une validation croisée K-Fold en Python