K-Means-Clustering ist ein Unüberwachtes maschinelles Lernen Algorithmus, der den unbeschrifteten Datensatz in verschiedene Cluster gruppiert. Ziel des Artikels ist es, die Grundlagen und Funktionsweise von k-Mean-Clustering sowie die Implementierung zu untersuchen.
Inhaltsverzeichnis
- Was ist K-Means-Clustering?
- Was ist das Ziel des K-Means-Clusterings?
- Wie funktioniert K-Means-Clustering?
- Implementierung von K-Means-Clustering in Python
Was ist K-Means-Clustering?
Unüberwachtes maschinelles Lernen ist der Prozess, einem Computer beizubringen, unbeschriftete, nicht klassifizierte Daten zu verwenden und es dem Algorithmus zu ermöglichen, diese Daten ohne Aufsicht zu bearbeiten. Ohne vorheriges Datentraining besteht die Aufgabe der Maschine in diesem Fall darin, unsortierte Daten nach Parallelen, Mustern und Variationen zu organisieren.
K bedeutet Clustering und ordnet Datenpunkte abhängig von ihrer Entfernung vom Zentrum der Cluster einem der K Cluster zu. Es beginnt mit der zufälligen Zuweisung des Cluster-Schwerpunkts im Raum. Dann wird jeder Datenpunkt basierend auf seiner Entfernung vom Schwerpunkt des Clusters einem der Cluster zugeordnet. Nachdem jeder Punkt einem der Cluster zugewiesen wurde, werden neue Clusterschwerpunkte zugewiesen. Dieser Prozess wird iterativ ausgeführt, bis ein guter Cluster gefunden wird. Bei der Analyse gehen wir davon aus, dass die Anzahl der Cluster im Voraus angegeben wird und wir Punkte in einer der Gruppen vergeben müssen.
In einigen Fällen ist K nicht klar definiert, und wir müssen über die optimale Anzahl von K nachdenken. K bedeutet, dass Clustering die beste Leistung erbringt und die Daten gut getrennt sind. Wenn sich Datenpunkte überlappen, ist diese Clusterbildung nicht geeignet. K Means ist im Vergleich zu anderen Clustering-Techniken schneller. Es sorgt für eine starke Kopplung zwischen den Datenpunkten. K bedeutet, dass Cluster keine eindeutigen Informationen über die Qualität von Clustern liefern. Eine unterschiedliche anfängliche Zuordnung des Clusterschwerpunkts kann zu unterschiedlichen Clustern führen. Außerdem ist der K-Means-Algorithmus empfindlich gegenüber Rauschen. Es könnte in lokalen Minima stecken geblieben sein.
Was ist das Ziel des K-Means-Clusterings?
Das Ziel von Clusterbildung ist die Bevölkerung zu spalten oder Satz von Datenpunkten in mehrere Gruppen, sodass die Datenpunkte innerhalb jeder Gruppe größer sind vergleichbar zueinander und unterscheiden sich von den Datenpunkten innerhalb der anderen Gruppen. Es handelt sich im Wesentlichen um eine Gruppierung von Dingen basierend darauf, wie ähnlich und unterschiedlich sie zueinander sind.
Wie funktioniert K-Means-Clustering?
Wir erhalten einen Datensatz mit Elementen mit bestimmten Merkmalen und Werten für diese Merkmale (wie ein Vektor). Die Aufgabe besteht darin, diese Elemente in Gruppen zu kategorisieren. Um dies zu erreichen, verwenden wir den K-Means-Algorithmus, einen unbeaufsichtigten Lernalgorithmus. „K“ im Namen des Algorithmus stellt die Anzahl der Gruppen/Cluster dar, in die wir unsere Artikel klassifizieren möchten.
(Es ist hilfreich, wenn Sie sich Elemente als Punkte in einem n-dimensionalen Raum vorstellen.) Der Algorithmus kategorisiert die Elemente in k Gruppen oder Ähnlichkeitscluster. Um diese Ähnlichkeit zu berechnen, verwenden wir den euklidischen Abstand als Maß.
Der Algorithmus funktioniert wie folgt:
- Zuerst initialisieren wir zufällig k Punkte, sogenannte Mittelwerte oder Clusterschwerpunkte.
- Wir kategorisieren jedes Element anhand seines nächsten Mittelwerts und aktualisieren die Koordinaten des Mittelwerts, bei denen es sich um die Durchschnittswerte der bisher in diesem Cluster kategorisierten Elemente handelt.
- Wir wiederholen den Vorgang für eine bestimmte Anzahl von Iterationen und am Ende haben wir unsere Cluster.
Die oben genannten Punkte werden als Mittelwerte bezeichnet, da sie die Mittelwerte der darin kategorisierten Elemente darstellen. Um diese Mittel zu initialisieren, haben wir viele Möglichkeiten. Eine intuitive Methode besteht darin, die Mittelwerte für zufällige Elemente im Datensatz zu initialisieren. Eine andere Methode besteht darin, die Mittelwerte mit zufälligen Werten zwischen den Grenzen des Datensatzes zu initialisieren (sofern es sich um ein Feature handelt). X, Die Elemente haben Werte in [0,3], wir werden die Mittelwerte mit Werten für initialisieren X bei [0,3]).
Der obige Algorithmus im Pseudocode lautet wie folgt:
Initialize k means with random values -->Für eine gegebene Anzahl von Iterationen: --> Durch Elemente iterieren: --> Finden Sie den Mittelwert, der dem Element am nächsten kommt, indem Sie den euklidischen Abstand des Elements mit jedem der Mittelwerte berechnen --> Element dem Mittelwert zuweisen --> Mittelwert aktualisieren um Verschieben Sie es auf den Durchschnitt der Elemente in diesem Cluster>
Implementierung von K-Means-Clustering in Python
Beispiel 1
Importieren Sie die erforderlichen Bibliotheken
Wir importieren Numpy für statistische Berechnungen, Matplotlib das plotten Graph, und make_blobs aus sklearn.datasets.
Python3
Java-Sammlungsframework
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Erstellen Sie den benutzerdefinierten Datensatz mit make_blobs und zeichnen Sie ihn
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()> |
>
>
Ausgabe :
Clustering-Datensatz
Initialisieren Sie die zufälligen Schwerpunkte
Der Code initialisiert drei Cluster für K-Means-Clustering. Es legt einen zufälligen Startwert fest, generiert zufällige Clusterzentren innerhalb eines angegebenen Bereichs und erstellt einen leeren Cluster Liste von Punkten für jeden 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> |
>
>
Ausgabe:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Zeichnen Sie das zufällige Initialisierungszentrum mit Datenpunkten auf
Python3
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()> |
>
>
Ausgabe :
Datenpunkte mit zufälligem Mittelpunkt
Das Diagramm zeigt ein Streudiagramm von Datenpunkten (X[:,0], X[:,1]) mit Gitterlinien. Es markiert auch die anfänglichen Clusterzentren (rote Sterne), die für die K-Means-Clusterbildung generiert wurden.
Definieren Sie den euklidischen Abstand
Python3
for-Schleife in Java
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Erstellen Sie die Funktion zum Zuweisen und Aktualisieren des Clusterzentrums
Der E-Schritt weist Datenpunkte dem nächstgelegenen Clusterzentrum zu und der M-Schritt aktualisiert Clusterzentren basierend auf dem Mittelwert der zugewiesenen Punkte beim K-Mittel-Clustering.
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> |
>
>
Schritt 7: Erstellen Sie die Funktion zur Vorhersage des Clusters für die Datenpunkte
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> |
>
>
Zuweisen, Aktualisieren und Vorhersagen des Clusterzentrums
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
>
Stellen Sie die Datenpunkte mit ihrem vorhergesagten Clusterzentrum grafisch dar
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()> |
>
>
Ausgabe :
K-bedeutet Clustering
Das Diagramm zeigt Datenpunkte, die nach ihren vorhergesagten Clustern gefärbt sind. Die roten Markierungen stellen die aktualisierten Clusterzentren nach den E-M-Schritten im K-Means-Clustering-Algorithmus dar.
Beispiel 2
Importieren Sie die erforderlichen Bibliotheken
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> |
>
>
Laden Sie den Datensatz
Python3
Vorrang des Java-Operators
X, y>=> load_iris(return_X_y>=>True>)> |
Java-String in Array
>
>
Ellenbogenmethode
Das Finden der idealen Anzahl von Gruppen zur Aufteilung der Daten ist ein grundlegender Schritt in jedem unbeaufsichtigten Algorithmus. Eine der gebräuchlichsten Techniken zur Ermittlung dieses Idealwerts von k ist der Ellbogenansatz.
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_)> |
>
>
Zeichnen Sie das Ellbogendiagramm, um die optimale Clusteranzahl zu ermitteln
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()> |
>
>
Ausgabe:
Ellenbogenmethode
Aus der obigen Grafik können wir erkennen, dass es bei k=2 und k=3 zu einer ellenbogenähnlichen Situation kommt. Wir betrachten also K=3
Erstellen Sie das Kmeans-Clustering-Modell
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Ausgabe:
KMeans KMeans(n_clusters=3, random_state=2)>
Finden Sie das Clusterzentrum
Python3
Arten von Joins in RDBMS
kmeans.cluster_centers_> |
>
>
Ausgabe:
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]])>
Sagen Sie die Clustergruppe voraus:
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Ausgabe:
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)>
Zeichnen Sie das Clusterzentrum mit Datenpunkten grafisch auf
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()> |
>
>
Ausgabe:
K-bedeutet Clustering
Das Nebendiagramm auf der linken Seite zeigt die Blütenblattlänge im Vergleich zur Blütenblattbreite mit nach Clustern gefärbten Datenpunkten, und rote Markierungen zeigen K-Mittel-Clusterzentren an. Die Nebendarstellung auf der rechten Seite zeigt die Kelchblattlänge im Vergleich zur Kelchblattbreite in ähnlicher Weise.
Abschluss
Zusammenfassend lässt sich sagen, dass K-Means-Clustering ein leistungsstarker unbeaufsichtigter Algorithmus für maschinelles Lernen zum Gruppieren unbeschrifteter Datensätze ist. Sein Ziel besteht darin, Daten in Cluster zu unterteilen und so ähnliche Datenpunkte zu derselben Gruppe zu machen. Der Algorithmus initialisiert Clusterschwerpunkte und weist Datenpunkte iterativ dem nächstgelegenen Schwerpunkt zu, wobei er die Schwerpunkte basierend auf dem Mittelwert der Punkte in jedem Cluster aktualisiert.
Häufig gestellte Fragen (FAQs)
1. Was ist K-Means-Clustering für die Datenanalyse?
K-Means ist eine Partitionierungsmethode, die einen Datensatz basierend auf der Ähnlichkeit in „k“ verschiedene, sich nicht überlappende Teilmengen (Cluster) unterteilt, mit dem Ziel, die Varianz innerhalb jedes Clusters zu minimieren.
2.Was ist ein Beispiel für k-means im wirklichen Leben?
Kundensegmentierung im Marketing, wobei k-means Kunden basierend auf dem Kaufverhalten gruppiert und es Unternehmen ermöglicht, Marketingstrategien für verschiedene Segmente anzupassen.
3. Welche Art von Daten ist das K-Means-Clustering-Modell?
K-means funktioniert gut mit numerischen Daten, bei denen das Konzept des Abstands zwischen Datenpunkten sinnvoll ist. Es wird üblicherweise auf kontinuierliche Variablen angewendet.
4. Werden K-Mittel zur Vorhersage verwendet?
K-Means wird hauptsächlich zum Clustern und Gruppieren ähnlicher Datenpunkte verwendet. Es werden keine Bezeichnungen für neue Daten vorhergesagt. Es ordnet sie basierend auf der Ähnlichkeit vorhandenen Clustern zu.
5.Was ist das Ziel des K-Means-Clusterings?
Das Ziel besteht darin, Daten in „k“-Cluster zu unterteilen und so die Varianz innerhalb des Clusters zu minimieren. Ziel ist es, Gruppen zu bilden, in denen die Datenpunkte innerhalb jedes Clusters einander ähnlicher sind als denen in anderen Clustern.