K-Means Clustering est un algorithme d'apprentissage non supervisé utilisé pour résoudre les problèmes de clustering en apprentissage automatique ou en science des données. Dans cette rubrique, nous apprendrons ce qu'est l'algorithme de clustering K-means, comment l'algorithme fonctionne, ainsi que l'implémentation Python du clustering k-means.

Qu’est-ce que l’algorithme K-Means ?

Le clustering K-Means est un Algorithme d'apprentissage non supervisé , qui regroupe l'ensemble de données non étiqueté en différents clusters. Ici, K définit le nombre de clusters prédéfinis qui doivent être créés dans le processus, comme si K=2, il y aura deux clusters, et pour K=3, il y aura trois clusters, et ainsi de suite.

Il s'agit d'un algorithme itératif qui divise l'ensemble de données non étiqueté en k groupes différents de telle sorte que chaque ensemble de données n'appartienne qu'à un seul groupe ayant des propriétés similaires.

Cela nous permet de regrouper les données en différents groupes et constitue un moyen pratique de découvrir seul les catégories de groupes dans l'ensemble de données non étiqueté sans avoir besoin d'aucune formation.

Il s'agit d'un algorithme basé sur le centroïde, dans lequel chaque cluster est associé à un centroïde. L'objectif principal de cet algorithme est de minimiser la somme des distances entre le point de données et leurs clusters correspondants.

c'est en python

L'algorithme prend l'ensemble de données non étiqueté en entrée, divise l'ensemble de données en un nombre k de clusters et répète le processus jusqu'à ce qu'il ne trouve pas les meilleurs clusters. La valeur de k doit être prédéterminée dans cet algorithme.

Les k-signifies regroupement L'algorithme effectue principalement deux tâches :

• Détermine la meilleure valeur pour K points centraux ou centroïdes par un processus itératif.
• Attribue chaque point de données à son centre K le plus proche. Les points de données qui sont proches du centre k particulier créent un cluster.

Par conséquent, chaque cluster possède des points de données présentant certains points communs et est éloigné des autres clusters.

Le diagramme ci-dessous explique le fonctionnement de l'algorithme de clustering K-means :

Comment fonctionne l’algorithme K-Means ?

Le fonctionnement de l'algorithme K-Means est expliqué dans les étapes ci-dessous :

Étape 1: Sélectionnez le nombre K pour décider du nombre de clusters.

Étape 2: Sélectionnez des points K ou des centroïdes aléatoires. (Cela peut être différent de l'ensemble de données d'entrée).

Étape 3: Attribuez chaque point de données à son centroïde le plus proche, qui formera les K clusters prédéfinis.

Étape 4: Calculez la variance et placez un nouveau centre de gravité de chaque cluster.

Étape 5 : Répétez les troisièmes étapes, ce qui signifie réaffecter chaque point de données au nouveau centroïde le plus proche de chaque cluster.

Étape 6 : Si une réaffectation se produit, passez à l'étape 4, sinon passez à TERMINER.

Étape 7 : Le modèle est prêt.

Comprenons les étapes ci-dessus en considérant les tracés visuels :

Supposons que nous ayons deux variables M1 et M2. Le nuage de points sur l'axe x-y de ces deux variables est donné ci-dessous :

• Prenons le nombre k de clusters, c'est-à-dire K=2, pour identifier l'ensemble de données et les placer dans différents clusters. Cela signifie qu'ici nous allons essayer de regrouper ces ensembles de données en deux clusters différents.
• Nous devons choisir des k points ou centroïdes aléatoires pour former le cluster. Ces points peuvent être soit les points de l'ensemble de données, soit tout autre point. Nous sélectionnons donc ici les deux points ci-dessous comme k points, qui ne font pas partie de notre ensemble de données. Considérez l'image ci-dessous :
  
• Nous allons maintenant attribuer chaque point de données du nuage de points à son point K ou centroïde le plus proche. Nous allons le calculer en appliquant certaines mathématiques que nous avons étudiées pour calculer la distance entre deux points. Nous allons donc tracer une médiane entre les deux centroïdes. Considérez l'image ci-dessous :
  

D'après l'image ci-dessus, il est clair que les points du côté gauche de la ligne sont proches du centre de gravité K1 ou bleu, et que les points à droite de la ligne sont proches du centre de gravité jaune. Colorons-les en bleu et en jaune pour une visualisation claire.

• Comme nous devons trouver le cluster le plus proche, nous répéterons le processus en choisissant un nouveau centre de gravité . Pour choisir les nouveaux centroïdes, nous calculerons le centre de gravité de ces centroïdes, et trouverons de nouveaux centroïdes comme ci-dessous :
  
• Ensuite, nous réattribuerons chaque point de données au nouveau centroïde. Pour cela, nous répéterons le même processus de recherche d’une ligne médiane. La médiane sera comme l'image ci-dessous :
  

Sur l’image ci-dessus, nous pouvons voir qu’un point jaune se trouve sur le côté gauche de la ligne et deux points bleus se trouvent juste à côté de la ligne. Ainsi, ces trois points seront attribués à de nouveaux centroïdes.

Une fois la réaffectation effectuée, nous passerons à nouveau à l'étape 4, qui consiste à trouver de nouveaux centroïdes ou points K.

• Nous allons répéter le processus en trouvant le centre de gravité des centroïdes, de sorte que les nouveaux centroïdes seront comme indiqué dans l'image ci-dessous :
  
• Au fur et à mesure que nous avons obtenu les nouveaux centroïdes, nous tracerons à nouveau la ligne médiane et réattribuerons les points de données. L'image sera donc :
  
• Nous pouvons voir dans l’image ci-dessus ; il n'y a pas de points de données différents de chaque côté de la ligne, ce qui signifie que notre modèle est formé. Considérez l'image ci-dessous :
  

Comme notre modèle est prêt, nous pouvons maintenant supprimer les centroïdes supposés, et les deux clusters finaux seront comme indiqué dans l'image ci-dessous :

Comment choisir la valeur du « nombre K de clusters » dans le clustering K-means ?

Les performances de l'algorithme de clustering K-means dépendent des clusters hautement efficaces qu'il forme. Mais choisir le nombre optimal de clusters est une tâche ardue. Il existe différentes manières de trouver le nombre optimal de clusters, mais nous discutons ici de la méthode la plus appropriée pour trouver le nombre de clusters ou la valeur de K. La méthode est donnée ci-dessous :

Méthode du coude

La méthode Elbow est l’un des moyens les plus populaires pour trouver le nombre optimal de clusters. Cette méthode utilise le concept de valeur WCSS. WCSS représente Dans la somme des carrés du cluster , qui définit les variations totales au sein d'un cluster. La formule pour calculer la valeur de WCSS (pour 3 clusters) est donnée ci-dessous :

Dans la formule ci-dessus de WCSS,

différence entre un tigre et un lion

∑_{P.je suis dans le Cluster1}distance(P_jeC₁)²: C'est la somme du carré des distances entre chaque point de données et son centroïde au sein d'un cluster1 et pareil pour les deux autres termes.

Pour mesurer la distance entre les points de données et le centroïde, nous pouvons utiliser n'importe quelle méthode telle que la distance euclidienne ou la distance de Manhattan.

Pour trouver la valeur optimale des clusters, la méthode du coude suit les étapes ci-dessous :

• Il exécute le clustering K-means sur un ensemble de données donné pour différentes valeurs K (plages de 1 à 10).
• Pour chaque valeur de K, calcule la valeur WCSS.
• Trace une courbe entre les valeurs WCSS calculées et le nombre de clusters K.
• Le point de courbure aigu ou un point du tracé ressemble à un bras, alors ce point est considéré comme la meilleure valeur de K.

Puisque le graphique montre le coude prononcé, qui ressemble à un coude, on l'appelle donc la méthode du coude. Le graphique de la méthode du coude ressemble à l'image ci-dessous :

Remarque : Nous pouvons choisir le nombre de clusters égal aux points de données donnés. Si nous choisissons le nombre de clusters égal aux points de données, alors la valeur de WCSS devient nulle, et ce sera le point final du tracé.

Implémentation Python de l'algorithme de clustering K-means

Dans la section ci-dessus, nous avons discuté de l'algorithme K-means, voyons maintenant comment il peut être implémenté en utilisant Python .

Avant la mise en œuvre, comprenons quel type de problème nous allons résoudre ici. Nous disposons donc d'un ensemble de données de Mall_Clients , qui correspondent aux données des clients qui visitent le centre commercial et y dépensent.

Dans l'ensemble de données donné, nous avons Customer_Id, sexe, âge, revenu annuel ($) et score de dépenses (qui est la valeur calculée de combien un client a dépensé dans le centre commercial, plus la valeur est élevée, plus il a dépensé). À partir de cet ensemble de données, nous devons calculer certains modèles, car il s'agit d'une méthode non supervisée, nous ne savons donc pas quoi calculer exactement.

Les étapes à suivre pour la mise en œuvre sont indiquées ci-dessous :

Prétraitement des données Trouver le nombre optimal de clusters à l'aide de la méthode du coude Entraînement de l'algorithme K-means sur l'ensemble de données d'entraînement Visualiser les clusters

Étape 1 : Étape de prétraitement des données

La première étape sera le prétraitement des données, comme nous l'avons fait dans nos précédents sujets sur la régression et la classification. Mais pour le problème du clustering, ce sera différent des autres modèles. Discutons-en :

Importation de bibliothèques
Comme nous l'avons fait dans les sujets précédents, nous allons dans un premier temps importer les bibliothèques de notre modèle, qui fait partie du prétraitement des données. Le code est donné ci-dessous :

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

Dans le code ci-dessus, le numpy nous avons importé pour le calcul mathématique performant, matplotlib sert à tracer le graphique, et pandas servent à gérer l’ensemble de données.

Importation de l'ensemble de données :
Ensuite, nous importerons l’ensemble de données que nous devons utiliser. Nous utilisons donc ici l'ensemble de données Mall_Customer_data.csv. Il peut être importé en utilisant le code ci-dessous :

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

En exécutant les lignes de code ci-dessus, nous obtiendrons notre ensemble de données dans l'IDE Spyder. L'ensemble de données ressemble à l'image ci-dessous :

À partir de l’ensemble de données ci-dessus, nous devons y trouver des modèles.

Extraction de variables indépendantes

Ici, nous n'avons besoin d'aucune variable dépendante pour l'étape de prétraitement des données car il s'agit d'un problème de clustering et nous n'avons aucune idée de ce qu'il faut déterminer. Nous allons donc simplement ajouter une ligne de code pour la matrice de fonctionnalités.

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

Comme nous pouvons le voir, nous extrayons seulement 3^rdet 4^èmefonctionnalité. C'est parce que nous avons besoin d'un tracé 2D pour visualiser le modèle et que certaines fonctionnalités ne sont pas requises, comme customer_id.

Étape 2 : Trouver le nombre optimal de clusters à l'aide de la méthode du coude

Dans un deuxième temps, nous tenterons de trouver le nombre optimal de clusters pour notre problème de clustering. Ainsi, comme indiqué ci-dessus, nous allons utiliser ici la méthode du coude à cette fin.

Comme nous le savons, la méthode du coude utilise le concept WCSS pour tracer le tracé en traçant les valeurs WCSS sur l'axe Y et le nombre de clusters sur l'axe X. Nous allons donc calculer la valeur de WCSS pour différentes valeurs k allant de 1 à 10. Vous trouverez ci-dessous le code correspondant :

monflixer

 #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() 

Comme nous pouvons le voir dans le code ci-dessus, nous avons utilisé les KMeans classe de sklearn. bibliothèque de clusters pour former les clusters.

Ensuite, nous avons créé le liste_wcss variable pour initialiser une liste vide, qui sert à contenir la valeur de wcss calculée pour différentes valeurs de k allant de 1 à 10.

Après cela, nous avons initialisé la boucle for pour l'itération sur une valeur différente de k allant de 1 à 10 ; puisque la boucle for en Python exclut la limite sortante, elle est donc prise comme 11 pour inclure 10^èmevaleur.

Le reste du code est similaire à celui des sujets précédents, car nous avons ajusté le modèle sur une matrice de fonctionnalités, puis tracé le graphique entre le nombre de clusters et WCSS.

Sortir: Après avoir exécuté le code ci-dessus, nous obtiendrons le résultat ci-dessous :

À partir du graphique ci-dessus, nous pouvons voir que le point du coude est à 5. Le nombre de clusters ici sera donc de 5.

Étape 3 : Entraîner l'algorithme K-means sur l'ensemble de données d'entraînement

Comme nous avons le nombre de clusters, nous pouvons maintenant entraîner le modèle sur l'ensemble de données.

Pour entraîner le modèle, nous utiliserons les deux mêmes lignes de code que celles utilisées dans la section ci-dessus, mais ici au lieu d'utiliser i, nous en utiliserons 5, car nous savons qu'il y a 5 clusters à former. Le code est donné ci-dessous :

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

La première ligne est la même que ci-dessus pour créer l’objet de la classe KMeans.

Dans la deuxième ligne de code, nous avons créé la variable dépendante y_predict pour entraîner le modèle.

En exécutant les lignes de code ci-dessus, nous obtiendrons la variable y_predict. Nous pouvons le vérifier ci-dessous l'explorateur de variables dans l'IDE Spyder. Nous pouvons maintenant comparer les valeurs de y_predict avec notre ensemble de données d'origine. Considérez l'image ci-dessous :

À partir de l'image ci-dessus, nous pouvons maintenant comprendre que le CustomerID 1 appartient à un cluster

3 (comme l'index commence à 0, donc 2 sera considéré comme 3), et 2 appartient au cluster 4, et ainsi de suite.

Étape 4 : Visualiser les clusters

La dernière étape consiste à visualiser les clusters. Comme nous avons 5 clusters pour notre modèle, nous allons donc visualiser chaque cluster un par un.

Pour visualiser les clusters, nous utiliserons un nuage de points en utilisant la fonction mtp.scatter() de 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() 

Dans les lignes de code ci-dessus, nous avons écrit du code pour chaque cluster, allant de 1 à 5. La première coordonnée du mtp.scatter, c'est-à-dire x[y_predict == 0, 0] contenant la valeur x pour afficher la matrice de présente des valeurs et y_predict est compris entre 0 et 1.

Sortir:

L'image de sortie montre clairement les cinq clusters différents avec des couleurs différentes. Les clusters sont formés entre deux paramètres de l'ensemble de données ; Revenu annuel du client et dépenses. Nous pouvons modifier les couleurs et les étiquettes selon les exigences ou le choix. Nous pouvons également observer certains points des modèles ci-dessus, qui sont donnés ci-dessous :

Cluster1montre les clients avec un salaire moyen et des dépenses moyennes afin que nous puissions catégoriser ces clients comme
• Cluster2 montre que le client a un revenu élevé mais de faibles dépenses, nous pouvons donc le classer comme suit : prudent .
• Le cluster 3 montre les faibles revenus ainsi que les faibles dépenses afin qu'ils puissent être classés comme raisonnables.
• Cluster4 montre les clients à faible revenu avec des dépenses très élevées afin qu'ils puissent être classés comme suit : imprudent .
• Cluster5 montre les clients ayant des revenus et des dépenses élevés afin qu'ils puissent être classés comme cibles, et ces clients peuvent être les clients les plus rentables pour le propriétaire du centre commercial.