Clustering K-Means est un Apprentissage automatique non supervisé algorithme, qui regroupe l'ensemble de données non étiqueté en différents clusters. L'article vise à explorer les principes fondamentaux et le fonctionnement du clustering k-mean ainsi que sa mise en œuvre.
Table des matières
- Qu’est-ce que le clustering K-means ?
- Quel est l’objectif du clustering k-means ?
- Comment fonctionne le clustering k-means ?
- Implémentation du clustering K-Means en Python
Qu’est-ce que le clustering K-means ?
Apprentissage automatique non supervisé est le processus consistant à apprendre à un ordinateur à utiliser des données non étiquetées et non classifiées et à permettre à l'algorithme de fonctionner sur ces données sans supervision. Sans aucune formation préalable sur les données, le travail de la machine dans ce cas consiste à organiser les données non triées selon des parallèles, des modèles et des variations.
K signifie clustering, attribue des points de données à l'un des K clusters en fonction de leur distance par rapport au centre des clusters. Cela commence par attribuer aléatoirement le centre de gravité des clusters dans l'espace. Ensuite, chaque point de données est attribué à l'un des clusters en fonction de sa distance par rapport au centroïde du cluster. Après avoir attribué chaque point à l'un des clusters, de nouveaux centroïdes de cluster sont attribués. Ce processus s'exécute de manière itérative jusqu'à ce qu'il trouve un bon cluster. Dans l'analyse, nous supposons que le nombre de clusters est donné à l'avance et que nous devons mettre des points dans l'un des groupes.
Dans certains cas, K n'est pas clairement défini et nous devons réfléchir au nombre optimal de K. K signifie que le clustering fonctionne le mieux, les données sont bien séparées. Lorsque les points de données se chevauchent, ce regroupement n'est pas adapté. K Means est plus rapide que les autres techniques de clustering. Il fournit un couplage fort entre les points de données. K Means cluster ne fournit pas d’informations claires sur la qualité des clusters. Une affectation initiale différente du centroïde du cluster peut conduire à des clusters différents. De plus, l’algorithme K Means est sensible au bruit. Il est peut-être resté coincé dans les minima locaux.
Quel est l’objectif du clustering k-means ?
L'objectif de regroupement est de diviser la population ou ensemble de points de données en un certain nombre de groupes afin que les points de données au sein de chaque groupe soient plus comparable les uns aux autres et différents des points de données au sein des autres groupes. Il s’agit essentiellement d’un regroupement de choses en fonction de leur similitude et de leur différence.
Comment fonctionne le clustering k-means ?
Nous recevons un ensemble de données d'éléments, avec certaines caractéristiques et des valeurs pour ces caractéristiques (comme un vecteur). La tâche consiste à classer ces éléments en groupes. Pour y parvenir, nous utiliserons l’algorithme K-means, un algorithme d’apprentissage non supervisé. « K » au nom de l'algorithme représente le nombre de groupes/clusters dans lesquels nous souhaitons classer nos éléments.
(Cela vous aidera si vous considérez les éléments comme des points dans un espace à n dimensions). L'algorithme classera les éléments en k groupes ou clusters de similarité. Pour calculer cette similarité, nous utiliserons la distance euclidienne comme mesure.
L'algorithme fonctionne comme suit:
- Tout d’abord, nous initialisons k points de manière aléatoire, appelés moyennes ou centroïdes de cluster.
- Nous catégorisons chaque élément selon sa moyenne la plus proche et nous mettons à jour les coordonnées de la moyenne, qui sont les moyennes des éléments catégorisés jusqu'à présent dans ce cluster.
- Nous répétons le processus pour un nombre donné d'itérations et à la fin, nous avons nos clusters.
Les points mentionnés ci-dessus sont appelés moyennes car ce sont les valeurs moyennes des éléments qui y sont classés. Pour initialiser ces moyens, nous disposons de nombreuses options. Une méthode intuitive consiste à initialiser les moyennes sur des éléments aléatoires de l'ensemble de données. Une autre méthode consiste à initialiser les moyennes à des valeurs aléatoires entre les limites de l'ensemble de données (si pour une caractéristique X, les items ont des valeurs dans [0,3], on initialisera les moyennes avec des valeurs pour X à [0,3]).
L'algorithme ci-dessus en pseudocode est le suivant :
Initialize k means with random values -->Pour un nombre d'itérations donné : --> Parcourir les éléments : --> Trouver la moyenne la plus proche de l'élément en calculant la distance euclidienne de l'élément avec chacune des moyennes --> Attribuer l'élément à la moyenne --> Mettre à jour la moyenne par en le déplaçant vers la moyenne des éléments de ce cluster>
Implémentation du clustering K-Means en Python
Exemple 1
Importez les bibliothèques nécessaires
Nous importons Numpy pour les calculs statistiques, Matplotlib tracer le graphique, et make_blobs de sklearn.datasets.
Python3
sinon si bash
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Créez l'ensemble de données personnalisé avec make_blobs et tracez-le
Python3
X,y>=> make_blobs(n_samples>=> 500>,n_features>=> 2>,centers>=> 3>,random_state>=> 23>)> fig>=> plt.figure(>0>)> plt.grid(>True>)> plt.scatter(X[:,>0>],X[:,>1>])> plt.show()> |
>
>
Sortir :
Ensemble de données de clustering
Initialiser les centroïdes aléatoires
Le code initialise trois clusters pour le clustering K-means. Il définit une graine aléatoire et génère des centres de cluster aléatoires dans une plage spécifiée, et crée un espace vide. liste de points pour chaque cluster.
Python3
k>=> 3> clusters>=> {}> np.random.seed(>23>)> for> idx>in> range>(k):> >center>=> 2>*>(>2>*>np.random.random((X.shape[>1>],))>->1>)> >points>=> []> >cluster>=> {> >'center'> : center,> >'points'> : []> >}> > >clusters[idx]>=> cluster> > clusters> |
>
>
Sortir:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Tracez le centre d'initialisation aléatoire avec des points de données
Python3
chaîne de longueur
plt.scatter(X[:,>0>],X[:,>1>])> plt.grid(>True>)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '*'>,c>=> 'red'>)> plt.show()> |
>
>
Sortir :
Points de données avec centre aléatoire
Le tracé affiche un nuage de points de points de données (X[:,0], X[:,1]) avec des lignes de grille. Il marque également les centres de cluster initiaux (étoiles rouges) générés pour le clustering K-means.
Définir la distance euclidienne
Python3
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Créez la fonction pour attribuer et mettre à jour le centre de cluster
L'étape E attribue des points de données au centre de cluster le plus proche et l'étape M met à jour les centres de cluster en fonction de la moyenne des points attribués dans le clustering K-means.
Python3
#Implementing E step> def> assign_clusters(X, clusters):> >for> idx>in> range>(X.shape[>0>]):> >dist>=> []> > >curr_x>=> X[idx]> > >for> i>in> range>(k):> >dis>=> distance(curr_x,clusters[i][>'center'>])> >dist.append(dis)> >curr_cluster>=> np.argmin(dist)> >clusters[curr_cluster][>'points'>].append(curr_x)> >return> clusters> > #Implementing the M-Step> def> update_clusters(X, clusters):> >for> i>in> range>(k):> >points>=> np.array(clusters[i][>'points'>])> >if> points.shape[>0>]>>0>:> >new_center>=> points.mean(axis>=>0>)> >clusters[i][>'center'>]>=> new_center> > >clusters[i][>'points'>]>=> []> >return> clusters> |
>
>
Étape 7 : Créez la fonction pour prédire le cluster pour les points de données
Python3
def> pred_cluster(X, clusters):> >pred>=> []> >for> i>in> range>(X.shape[>0>]):> >dist>=> []> >for> j>in> range>(k):> >dist.append(distance(X[i],clusters[j][>'center'>]))> >pred.append(np.argmin(dist))> >return> pred> |
>
>
Attribuer, mettre à jour et prédire le centre du cluster
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
>
Tracez les points de données avec leur centre de cluster prévu
Python3
plt.scatter(X[:,>0>],X[:,>1>],c>=> pred)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.show()> |
>
liste chaînée
>
Sortir :
Clustering K-means
Le graphique montre les points de données colorés par leurs clusters prédits. Les marqueurs rouges représentent les centres de cluster mis à jour après les étapes E-M dans l'algorithme de clustering K-means.
Exemple 2
Importez les bibliothèques nécessaires
Python3
import> pandas as pd> import> numpy as np> import> seaborn as sns> import> matplotlib.pyplot as plt> import> matplotlib.cm as cm> from> sklearn.datasets>import> load_iris> from> sklearn.cluster>import> KMeans> |
>
>
Charger l'ensemble de données
Python3
X, y>=> load_iris(return_X_y>=>True>)> |
télécharger le lecteur multimédia YouTube VLC
>
>
Méthode du coude
Trouver le nombre idéal de groupes dans lesquels diviser les données est une étape fondamentale de tout algorithme non supervisé. L’une des techniques les plus courantes pour déterminer cette valeur idéale de k est l’approche du coude.
Python3
#Find optimum number of cluster> sse>=> []>#SUM OF SQUARED ERROR> for> k>in> range>(>1>,>11>):> >km>=> KMeans(n_clusters>=>k, random_state>=>2>)> >km.fit(X)> >sse.append(km.inertia_)> |
>
>
Tracez le graphique Elbow pour trouver le nombre optimal de clusters
Python3
sns.set_style(>'whitegrid'>)> g>=>sns.lineplot(x>=>range>(>1>,>11>), y>=>sse)> g.>set>(xlabel>=>'Number of cluster (k)'>,> >ylabel>=> 'Sum Squared Error'>,> >title>=>'Elbow Method'>)> plt.show()> |
>
>
Sortir:
Méthode du coude
À partir du graphique ci-dessus, nous pouvons observer qu’à k=2 et k=3, une situation semblable à celle d’un coude. On considère donc K=3
Construire le modèle de clustering Kmeans
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Sortir:
KMeans KMeans(n_clusters=3, random_state=2)>
Trouver le centre du cluster
Python3
jointures et types de jointures
kmeans.cluster_centers_> |
>
>
Sortir:
array([[5.006 , 3.428 , 1.462 , 0.246 ], [5.9016129 , 2.7483871 , 4.39354839, 1.43387097], [6.85 , 3.07368421, 5.74210526, 2.07105263]])>
Prédisez le groupe de cluster :
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Sortir:
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1], dtype=int32)>
Tracer le centre du cluster avec des points de données
Python3
plt.figure(figsize>=>(>12>,>5>))> plt.subplot(>1>,>2>,>1>)> plt.scatter(X[:,>0>],X[:,>1>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[:>2>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'petal length (cm)'>)> plt.ylabel(>'petal width (cm)'>)> > plt.subplot(>1>,>2>,>2>)> plt.scatter(X[:,>2>],X[:,>3>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[>2>:>4>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'sepal length (cm)'>)> plt.ylabel(>'sepal width (cm)'>)> plt.show()> |
>
>
Sortir:
K-means clustering
Le sous-tracé de gauche affiche la longueur des pétales par rapport à la largeur des pétales avec des points de données colorés par grappes, et les marqueurs rouges indiquent les centres de grappes K-means. La sous-intrigue de droite montre de la même manière la longueur des sépales par rapport à la largeur des sépales.
Conclusion
En conclusion, le clustering K-means est un puissant algorithme d’apprentissage automatique non supervisé permettant de regrouper des ensembles de données non étiquetés. Son objectif est de diviser les données en clusters, en faisant en sorte que les points de données similaires fassent partie du même groupe. L'algorithme initialise les centroïdes de cluster et attribue de manière itérative des points de données au centroïde le plus proche, mettant à jour les centroïdes en fonction de la moyenne des points de chaque cluster.
Foire aux questions (FAQ)
1. Qu'est-ce que le clustering k-means pour l'analyse des données ?
K-means est une méthode de partitionnement qui divise un ensemble de données en « k » sous-ensembles (clusters) distincts et ne se chevauchant pas, en fonction de la similarité, dans le but de minimiser la variance au sein de chaque cluster.
2.Quel est un exemple de k-moyennes dans la vraie vie ?
Segmentation des clients en marketing, où k-means regroupe les clients en fonction de leur comportement d'achat, permettant aux entreprises d'adapter leurs stratégies marketing à différents segments.
3. De quel type de données correspond le modèle de clustering k-means ?
K-means fonctionne bien avec les données numériques, où le concept de distance entre les points de données est significatif. Il est couramment appliqué aux variables continues.
4.Les K-means sont-ils utilisés pour la prédiction ?
K-means est principalement utilisé pour regrouper et regrouper des points de données similaires. Il ne prédit pas les étiquettes des nouvelles données ; il les attribue aux clusters existants en fonction de la similarité.
5.Quel est l’objectif du clustering k-means ?
L’objectif est de diviser les données en clusters « k », en minimisant la variance intra-cluster. Il cherche à former des groupes dans lesquels les points de données de chaque cluster sont plus similaires les uns aux autres qu'à ceux des autres clusters.