Endgültiger Leitfaden für K-Means-Clustering mit Scikit-Learn

Einleitung

K-Means Clustering ist einer der am weitesten verbreiteten Algorithmen für unbeaufsichtigtes maschinelles Lernen, der Datencluster basierend auf der Ähnlichkeit zwischen Dateninstanzen bildet.

In diesem Leitfaden sehen wir uns zunächst ein einfaches Beispiel an, um zu verstehen, wie der K-Means-Algorithmus funktioniert, bevor wir ihn mit Scikit-Learn implementieren. Dann besprechen wir, wie die Anzahl der Cluster (Ks) in K-Means bestimmt wird, und behandeln auch Distanzmetriken, Varianz und Vor- und Nachteile von K-Means.

Motivation

Stellen Sie sich folgende Situation vor. Eines Tages, als Sie durch die Nachbarschaft gingen, bemerkten Sie, dass es 10 Convenience-Stores gab, und begannen sich zu fragen, welche Geschäfte ähnlich waren – näher beieinander in der Nähe. Bei der Suche nach Möglichkeiten zur Beantwortung dieser Frage sind Sie auf einen interessanten Ansatz gestoßen, bei dem die Geschäfte anhand ihrer Koordinaten auf einer Karte in Gruppen eingeteilt werden.

Wenn sich beispielsweise ein Geschäft 5 km westlich und 3 km nördlich befindet, würden Sie es zuweisen (5, 3) Koordinaten dazu, und stellen Sie es in einem Diagramm dar. Lassen Sie uns diesen ersten Punkt darstellen, um zu visualisieren, was passiert:

import matplotlib.pyplot as plt

plt.title("Store With Coordinates (5, 3)")
plt.scatter(x=5, y=3)

Dies ist nur der erste Punkt, damit wir uns ein Bild davon machen können, wie wir einen Laden darstellen können. Angenommen, wir haben bereits 10 Koordinaten zu den 10 gesammelten Geschäften. Nachdem Sie sie in a organisiert haben numpy array, wir können auch ihre Standorte plotten:

import numpy as np

points = np.array([[5, 3], [10, 15], [15, 12], [24, 10], [30, 45], [85, 70], [71, 80], [60, 78], [55, 52],[80, 91]])

xs = points[:,0] 
ys = points[:,1]  

plt.title("10 Stores Coordinates")
plt.scatter(x=xs, y=ys)

So implementieren Sie den K-Means-Algorithmus manuell

Jetzt können wir uns die 10 Geschäfte in einem Diagramm ansehen, und das Hauptproblem besteht darin, herauszufinden, ob es eine Möglichkeit gibt, sie basierend auf der Nähe in verschiedene Gruppen einzuteilen. Schon ein kurzer Blick auf die Grafik wird uns wahrscheinlich auffallen zwei Ladengruppen – Einer sind die unteren Punkte unten links und der andere sind die oberen rechten Punkte. Vielleicht können wir diese beiden Punkte in der Mitte sogar als separate Gruppe unterscheiden – also schaffen drei verschiedene Gruppen.

In diesem Abschnitt gehen wir auf den Prozess der manuellen Gruppierung von Punkten ein – deren Unterteilung in die angegebene Anzahl von Gruppen. Auf diese Weise werden wir im Wesentlichen alle Schritte des sorgfältig durchgehen K-Means-Clustering-Algorithmus. Am Ende dieses Abschnitts erlangen Sie sowohl ein intuitives als auch praktisches Verständnis aller Schritte, die während des K-Means-Clustering durchgeführt werden. Danach delegieren wir es an Scikit-Learn.

Wie lässt sich am besten feststellen, ob es zwei oder drei Gruppen von Punkten gibt? Eine einfache Möglichkeit wäre, einfach eine Anzahl von Gruppen auszuwählen – zum Beispiel zwei – und dann zu versuchen, Punkte basierend auf dieser Auswahl zu gruppieren.

Nehmen wir an, wir haben entschieden, dass es welche gibt zwei Gruppen unserer Filialen (Punkte). Jetzt müssen wir einen Weg finden, um zu verstehen, welche Punkte zu welcher Gruppe gehören. Dies könnte durch Auswahl eines darzustellenden Punktes erfolgen Gruppe 1 und eine zu vertreten Gruppe 2. Diese Punkte werden als Referenz verwendet, wenn der Abstand von allen anderen Punkten zu jeder Gruppe gemessen wird.

Sagen Sie auf diese Weise Punkt (5, 3) endet die Zugehörigkeit zu Gruppe 1, und Punkt (79, 60) zu Gruppe 2. Beim Versuch, einen neuen Punkt zuzuweisen (6, 3) zu Gruppen, müssen wir den Abstand zu diesen beiden Punkten messen. Im Fall des Punktes (6, 3) is näher zu den (5, 3), gehört also zu der durch diesen Punkt repräsentierten Gruppe – Gruppe 1. Auf diese Weise können wir alle Punkte einfach in entsprechende Gruppen gruppieren.

In diesem Beispiel wird neben der Bestimmung der Anzahl der Gruppen (Clustern) – wir wählen auch einige Punkte aus, um a zu sein Referenz der Entfernung für neue Punkte jeder Gruppe.

Das ist die allgemeine Idee, um Ähnlichkeiten zwischen unseren Geschäften zu verstehen. Lassen Sie es uns in die Praxis umsetzen – wir können zunächst die beiden Bezugspunkte bei wählen zufällig. Der Bezugspunkt von Gruppe 1 wird sein (5, 3) und Bezugspunkt von Gruppe 2 wird sein (10, 15). Wir können unsere beiden Punkte auswählen numpy Array von [0] und [1] Indizes und speichern Sie sie in g1 (Gruppe 1) und g2 (Gruppe 2) Variablen:

g1 = points[0]
g2 = points[1]

Danach müssen wir die Entfernung von allen anderen Punkten zu diesen Referenzpunkten berechnen. Dies wirft eine wichtige Frage auf – wie man diese Entfernung misst. Wir können im Wesentlichen jedes Entfernungsmaß verwenden, aber für die Zwecke dieser Anleitung verwenden wir die euklidische Entfernung_.

Es kann nützlich sein zu wissen, dass das euklidische Distanzmaß auf dem Satz von Pythagoras basiert:

$$
c^2 = a^2 + b^2
$$

Bei Anpassung an Punkte in einer Ebene – (a1, b1) und (a2, b2), wird die vorherige Formel zu:

$$
c^2 = (a2-a1)^2 + (b2-b1)^2
$$

Der Abstand wird die Quadratwurzel von sein c, also können wir die Formel auch schreiben als:

$$
euklidisch_{dist} = sqrt[2][(a2 – a1)^2 + (b2 – b1) ^2)]
$$

Bisher haben wir die Punkte ausgewählt, um Gruppen darzustellen, und wir wissen, wie man Entfernungen berechnet. Lassen Sie uns nun die Entfernungen und Gruppen zusammenstellen, indem wir jeden unserer gesammelten Speicherpunkte einer Gruppe zuweisen.

Um das besser zu veranschaulichen, werden wir drei Listen deklarieren. Der erste, der Punkte der ersten Gruppe speichert – points_in_g1. Der zweite zum Speichern von Punkten aus der Gruppe 2 – points_in_g2, und der Letzte - group leben, Etikette die Punkte als entweder 1 (gehört zur Gruppe 1) bzw 2 (gehört zu Gruppe 2):

points_in_g1 = []
points_in_g2 = []
group = []

Wir können nun durch unsere Punkte iterieren und den euklidischen Abstand zwischen ihnen und jeder unserer Gruppenreferenzen berechnen. Jeder Punkt wird sein näher zu einer von zwei Gruppen – je nachdem, welche Gruppe am nächsten ist, ordnen wir jeden Punkt der entsprechenden Liste zu und fügen gleichzeitig hinzu 1 or 2 zu den group Liste:

for p in points:
    x1, y1 = p[0], p[1]
    euclidean_distance_g1 = np.sqrt((g1[0] - x1)**2 + (g1[1] - y1)**2)
    euclidean_distance_g2 = np.sqrt((g2[0] - x1)**2 + (g2[1] - y1)**2)
    if euclidean_distance_g1 < euclidean_distance_g2:
        points_in_g1.append(p)
        group.append('1')
    else:
        points_in_g2.append(p)
        group.append('2')

Schauen wir uns die Ergebnisse dieser Iteration an, um zu sehen, was passiert ist:

print(f'points_in_g1:{points_in_g1}n 
npoints_in_g2:{points_in_g2}n 
ngroup:{group}')

Was in ... endet:

points_in_g1:[array([5, 3])]
 
points_in_g2:[array([10, 15]), array([15, 12]), 
              array([24, 10]), array([30, 45]), 
              array([85, 70]), array([71, 80]),
              array([60, 78]), array([55, 52]), 
              array([80, 91])]
 
group:[1, 2, 2, 2, 2, 2, 2, 2, 2, 2] 

Wir können das Clustering-Ergebnis auch mit unterschiedlichen Farben basierend auf den zugewiesenen Gruppen mit Seaborns darstellen scatterplot() an. Nach der Installation können Sie HEIC-Dateien mit der group als ein hue Argument:

import seaborn as sns

sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

Es ist deutlich zu erkennen, dass nur unser erster Punkt der Gruppe 1 zugeordnet wurde und alle anderen Punkte der Gruppe 2 zugeordnet wurden. Dieses Ergebnis weicht von dem ab, was wir uns zu Beginn vorgestellt hatten. Angesichts des Unterschieds zwischen unseren Ergebnissen und unseren anfänglichen Erwartungen – gibt es eine Möglichkeit, das zu ändern? Es scheint, es gibt!

Ein Ansatz besteht darin, den Vorgang zu wiederholen und verschiedene Punkte als Referenzpunkte für die Gruppen auszuwählen. Dies wird unsere Ergebnisse hoffentlich mehr in Übereinstimmung mit dem bringen, was wir uns am Anfang vorgestellt haben. Dieses zweite Mal konnten wir sie nicht wie zuvor zufällig auswählen, sondern indem wir a erhielten bedeuten aller unserer bereits gruppierten Punkte. Auf diese Weise könnten diese neuen Punkte in der Mitte entsprechender Gruppen positioniert werden.

Zum Beispiel, wenn die zweite Gruppe nur Punkte hätte (10, 15), (30, 45). Die neue Hauptgeschäftsstelle Punkt wäre (10 + 30)/2 und (15+45)/2 – was gleich ist (20, 30).

Da wir unsere Ergebnisse in Listen abgelegt haben, können wir diese zunächst umrechnen numpy Arrays, wählen Sie ihre xs, ys und erhalten Sie dann die bedeuten:

g1_center = [np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()]
g2_center = [np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()]
g1_center, g2_center

Um den Vorgang mit unseren neuen Mittelpunkten zu wiederholen, wandeln wir unseren vorherigen Code in eine Funktion um, führen sie aus und sehen, ob es Änderungen bei der Gruppierung der Punkte gab:

def assigns_points_to_two_groups(g1_center, g2_center):
    points_in_g1 = []
    points_in_g2 = []
    group = []

    for p in points:
        x1, y1 = p[0], p[1]
        euclidean_distance_g1 = np.sqrt((g1_center[0] - x1)**2 + (g1_center[1] - y1)**2)
        euclidean_distance_g2 = np.sqrt((g2_center[0] - x1)**2 + (g2_center[1] - y1)**2)
        if euclidean_distance_g1 < euclidean_distance_g2:
            points_in_g1.append(p)
            group.append(1)
        else:
            points_in_g2.append(p)
            group.append(2)
    return points_in_g1, points_in_g2, group

Rufen wir die Funktion auf und speichern ihre Ergebnisse in points_in_g1, points_in_g2 und group Variablen:

points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
points_in_g1, points_in_g2, group

Zeichnen Sie auch das Streudiagramm mit den farbigen Punkten, um die Gruppenaufteilung zu visualisieren:

sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

Es scheint die Clusterbildung unserer Punkte zu sein besser werden. Dennoch gibt es zwei Punkte in der Mitte des Diagramms, die jeder Gruppe zugeordnet werden könnten, wenn man ihre Nähe zu beiden Gruppen berücksichtigt. Der von uns bisher entwickelte Algorithmus ordnet diese beiden Punkte der zweiten Gruppe zu.

Das bedeutet, dass wir den Vorgang wahrscheinlich noch einmal wiederholen können, indem wir die Mittel der Xs und Ys nehmen und zwei neue zentrale Punkte erstellen (Schwerpunkte) zu unseren Gruppen und ordnen sie basierend auf der Entfernung neu zu.

Lassen Sie uns auch eine Funktion erstellen, um die Schwerpunkte zu aktualisieren. Der gesamte Prozess kann nun auf mehrere Aufrufe dieser Funktion reduziert werden:

def updates_centroids(points_in_g1, points_in_g2):
    g1_center = np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()
    g2_center = np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()
    return g1_center, g2_center

g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

Beachten Sie, dass nach dieser dritten Iteration jeder der Punkte nun zu unterschiedlichen Clustern gehört. Es scheint, dass die Ergebnisse besser werden – machen wir es noch einmal. Jetzt geht es an die vierte Iteration unserer Methode:

g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

Dieses vierte Mal bekamen wir das gleiche ergebnis wie der vorherige. Es scheint also, dass unsere Punkte die Gruppen nicht mehr wechseln werden, unser Ergebnis hat eine gewisse Stabilität erreicht – es hat einen unveränderlichen Zustand erreicht, oder konvergierte. Abgesehen davon haben wir genau das gleiche Ergebnis, das wir uns für die 2 Gruppen vorgestellt hatten. Wir können auch sehen, ob diese erreichte Aufteilung sinnvoll ist.

Fassen wir kurz zusammen, was wir bisher getan haben. Wir haben unsere 10 Filialen geografisch in zwei Bereiche unterteilt – einen im unteren Südwesten und einen im Nordosten. Es kann interessant sein, neben dem, was wir bereits haben, weitere Daten zu sammeln – Umsatz, die tägliche Anzahl von Kunden und vieles mehr. Auf diese Weise können wir eine reichhaltigere Analyse durchführen und möglicherweise interessantere Ergebnisse erzielen.

Clustering-Studien wie diese können durchgeführt werden, wenn eine bereits etablierte Marke einen Bereich auswählen möchte, um ein neues Geschäft zu eröffnen. In diesem Fall werden neben dem Standort noch viele weitere Variablen berücksichtigt.

Was hat das alles mit dem K-Means-Algorithmus zu tun?

Während Sie diesen Schritten gefolgt sind, haben Sie sich vielleicht gefragt, was sie mit dem K-Means-Algorithmus zu tun haben. Der Prozess, den wir bisher durchgeführt haben, ist der K-Means-Algorithmus. Kurz gesagt, wir haben die Anzahl der Gruppen/Cluster bestimmt, nach dem Zufallsprinzip Anfangspunkte ausgewählt und die Zentroide in jeder Iteration aktualisiert, bis die Cluster konvergierten. Wir haben im Grunde den gesamten Algorithmus von Hand durchgeführt – jeden Schritt sorgfältig durchgeführt.

Das K in K-Means kommt von der Anzahl der Cluster die vor Beginn des Iterationsprozesses festgelegt werden müssen. In unserem Fall K = 2. Diese Eigenschaft wird manchmal als angesehen Negativ wenn man bedenkt, dass es andere Clustering-Methoden gibt, wie z. B. hierarchisches Clustering, die keine feste Anzahl von Clustern im Voraus haben müssen.

Aufgrund seiner Verwendung von Mitteln wird auch K-Means empfindlich gegenüber Ausreißern und Extremwerten – sie erhöhen die Variabilität und erschweren es unseren Schwerpunkten, ihre Rolle zu spielen. Seien Sie sich also der Notwendigkeit bewusst, Leistung zu erbringen Extremwerte und Ausreißeranalyse bevor Sie ein Clustering mit dem K-Means-Algorithmus durchführen.

Beachten Sie auch, dass unsere Punkte in gerade Teile segmentiert wurden, es gibt keine Kurven beim Erstellen der Cluster. Das kann auch ein Nachteil des K-Means-Algorithmus sein.

K-Means hat auch viele Vorteilen ! Es funktioniert gut auf große Datensätze Dies kann schwierig zu handhaben sein, wenn Sie einige Arten von hierarchischen Clustering-Algorithmen verwenden. Es auch Konvergenz garantiert, und kann leicht verallgemeinern und automatisch. Abgesehen davon ist es wahrscheinlich der am häufigsten verwendete Clustering-Algorithmus.

Nachdem wir nun alle im K-Means-Algorithmus ausgeführten Schritte durchgegangen sind und alle Vor- und Nachteile verstanden haben, können wir K-Means endlich mit der Scikit-Learn-Bibliothek implementieren.

So implementieren Sie den K-Means-Algorithmus mit Scikit-Lernen

Um unser Ergebnis noch einmal zu überprüfen, führen wir diesen Vorgang noch einmal durch, aber verwenden Sie jetzt 3 Codezeilen mit sklearn:

from sklearn.cluster import KMeans


kmeans = KMeans(n_clusters=2, random_state=42) 
kmeans.fit(points)
kmeans.labels_

Hier sind die Bezeichnungen die gleichen wie bei unseren vorherigen Gruppen. Lassen Sie uns das Ergebnis schnell darstellen:

sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)

Das resultierende Diagramm ist das gleiche wie das aus dem vorherigen Abschnitt.

Mit Scikit-Learn können Sie K-Means auch für eine schnellere Konvergenz initialisieren, indem Sie die init='k-means++' Streit. Im weiteren Sinne, K-bedeutet ++ wählt immer noch die k anfängliche Clusterzentren zufällig nach einer gleichmäßigen Verteilung. Dann wird jedes nachfolgende Clusterzentrum aus den verbleibenden Datenpunkten nicht nur durch Berechnung eines Abstandsmaßes, sondern durch Verwendung von Wahrscheinlichkeiten ausgewählt. Die Verwendung der Wahrscheinlichkeit beschleunigt den Algorithmus und ist hilfreich beim Umgang mit sehr großen Datensätzen.

Die Elbow-Methode – Auswahl der besten Gruppenanzahl

So weit, ist es gut! Wir haben 10 Geschäfte basierend auf dem euklidischen Abstand zwischen Punkten und Schwerpunkten gruppiert. Aber was ist mit den beiden Punkten in der Mitte des Diagramms, die etwas schwieriger zu gruppieren sind? Könnten sie nicht auch eine eigene Gruppe bilden? Haben wir bei der Auswahl tatsächlich einen Fehler gemacht? K = 2 Gruppen? Vielleicht hatten wir das tatsächlich K = 3 Gruppen? Wir könnten sogar mehr als drei Gruppen haben und uns dessen nicht bewusst sein.

Die hier gestellte Frage ist wie man die Anzahl der Gruppen (K) in K-Means bestimmt. Um diese Frage zu beantworten, müssen wir verstehen, ob es einen „besseren“ Cluster für einen anderen Wert von K geben würde.

Der naive Weg, dies herauszufinden, besteht darin, Punkte mit unterschiedlichen Werten von zu gruppieren K, so für K=2, K=3, K=4 und so weiter:

for number_of_clusters in range(1, 11): 
    kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
    kmeans.fit(points) 

Aber Clustering-Punkte für verschiedene Ks allein wird nicht genug sein um zu verstehen, ob wir den idealen Wert für gewählt haben K. Wir brauchen eine Möglichkeit, die Clustering-Qualität für jeden zu bewerten K wir haben gewählt.

Manuelle Berechnung der Innerhalb der Clustersumme der Quadrate (WCSS)

Hier ist der ideale Ort, um ein Maß dafür einzuführen, wie nahe unsere gruppierten Punkte beieinander liegen. Es beschreibt im Wesentlichen, wie viel Unterschied Wir haben innerhalb eines einzelnen Clusters. Diese Maßnahme heißt Innerhalb des Clusters Summe der Quadrate, oder WCSS kurz. Je kleiner das WCSS ist, desto näher sind unsere Punkte, daher haben wir einen wohlgeformteren Cluster. Die WCSS-Formel kann für beliebig viele Cluster verwendet werden:

$$
WCSS = sum(Pi_1 – Centroid_1)^2 + cdots + sum(Pi_n – Centroid_n)^2
$$

Jetzt können wir davon ausgehen, dass wir uns für zwei Cluster entschieden haben und versuchen, das WCSS zu implementieren, um besser zu verstehen, was das WCSS ist und wie es verwendet wird. Wie die Formel besagt, müssen wir die quadrierten Differenzen zwischen allen Clusterpunkten und Zentroiden zusammenfassen. Also, wenn unser erster Punkt aus der ersten Gruppe ist (5, 3) und unser letzter Schwerpunkt (nach Konvergenz) der ersten Gruppe ist (16.8, 17.0), das WCSS wird sein:

$$
WCSS = Summe((5,3) – (16.8, 17.0))^2
$$

$$
WCSS = Summe((5-16.8) + (3-17.0))^2
$$

$$
WCSS = Summe((-11.8) + (-14.0))^2
$$

$$
WCSS = Summe((-25.8))^2
$$

$$
WCSS = 335.24
$$

Dieses Beispiel veranschaulicht, wie wir den WCSS für den einen Punkt aus dem Cluster berechnen. Aber der Cluster enthält normalerweise mehr als einen Punkt, und wir müssen alle bei der Berechnung des WCSS berücksichtigen. Dazu definieren wir eine Funktion, die eine Gruppe von Punkten und Schwerpunkten empfängt und die Summe der Quadrate zurückgibt:

def sum_of_squares(cluster, centroid):
    squares = []
    for p in cluster:
        squares.append((p - centroid)**2)
        ss = np.array(squares).sum()
    return ss

Jetzt können wir die Summe der Quadrate für jeden Cluster erhalten:

g1 = sum_of_squares(points_in_g1, g1_center)
g2 = sum_of_squares(points_in_g2, g2_center)

Und summieren Sie die Ergebnisse, um die Gesamtsumme zu erhalten WCSS:

g1 + g2

Das führt zu:

2964.3999999999996

Also in unserem Fall wann K gleich 2 ist, ist die gesamte WCSS 2964.39. Jetzt können wir Ks tauschen und den WCSS für alle berechnen. So bekommen wir einen Einblick in was K Wir sollten uns dafür entscheiden, unser Clustering optimal auszuführen.

Berechnung WCSS Die richtigen Scikit-Lernen

Glücklicherweise müssen wir den WCSS nicht für jeden manuell berechnen K. Nachdem wir das K-Means-Clustering für die angegebene Anzahl von Clustern durchgeführt haben, können wir sein WCSS mithilfe von abrufen inertia_ Attribut. Jetzt können wir zu unseren K-Means zurückkehren for Schleife, verwenden Sie sie, um die Anzahl der Cluster zu wechseln, und listen Sie die entsprechenden WCSS-Werte auf:

wcss = [] 
for number_of_clusters in range(1, 11): 
    kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
    kmeans.fit(points) 
    wcss.append(kmeans.inertia_)
wcss

Beachten Sie, dass der zweite Wert in der Liste genau derselbe ist, für den wir zuvor berechnet haben K = 2:

[18272.9, # For k=1 
 2964.3999999999996, # For k=2
 1198.75, # For k=3
 861.75,
 570.5,
 337.5,
 175.83333333333334,
 79.5,
 17.0,
 0.0]

Um diese Ergebnisse zu visualisieren, zeichnen wir unsere Ks zusammen mit den WCSS-Werten:

ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss)

Es gibt eine Unterbrechung auf einem Grundstück, wenn x = 2, ein Tiefpunkt in der Linie, und ein noch niedrigerer, wenn x = 3. Beachten Sie, dass es uns an die erinnert Form eines Ellbogens. Indem wir die Ks zusammen mit dem WCSS darstellen, verwenden wir die Ellenbogen-Methode um die Anzahl der Ks zu wählen. Und die Das gewählte K ist genau der unterste Punkt des Bogens, so wäre es 3 statt 2, in unserem Fall:

ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss);
plt.axvline(3, linestyle='--', color='r')

Wir können den K-Means-Cluster-Algorithmus erneut ausführen, um zu sehen, wie unsere Daten damit aussehen würden drei Cluster:

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(points)
sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)

Wir waren bereits mit zwei Clustern zufrieden, aber nach der Ellbogenmethode würden drei Cluster besser zu unseren Daten passen. In diesem Fall hätten wir drei Arten von Geschäften statt zwei. Bevor wir die Ellbogenmethode verwendeten, dachten wir an südwestliche und nordöstliche Cluster von Geschäften, jetzt haben wir auch Geschäfte in der Mitte. Vielleicht könnte das ein guter Standort sein, um ein weiteres Geschäft zu eröffnen, da es in der Nähe weniger Konkurrenz hätte.

Alternative Clusterqualitätsmaße

Es gibt auch andere Maßnahmen, die bei der Bewertung der Clusterqualität verwendet werden können:

• Silhouette-Punktzahl – analysiert nicht nur den Abstand zwischen Intra-Cluster-Punkten, sondern auch zwischen Clustern selbst
• Zwischen Clustern Quadratsumme (BCSS) – Metrik ergänzend zum WCSS
• Quadratsummenfehler (ESS)
• Maximaler Radius – misst den größten Abstand von einem Punkt zu seinem Schwerpunkt
• Durchschnittlicher Radius – die Summe der größten Entfernung von einem Punkt zu seinem Schwerpunkt dividiert durch die Anzahl der Cluster.

Es wird empfohlen, zu experimentieren und sich mit jedem von ihnen vertraut zu machen, da einige der Alternativen je nach Problem anwendbarer sein können als die am weitesten verbreiteten Metriken (WCSS- und Silhouette-Score).

Am Ende wollen wir, wie bei vielen Data-Science-Algorithmen, die Varianz innerhalb jedes Clusters reduzieren und die Varianz zwischen verschiedenen Clustern maximieren. Wir haben also definiertere und trennbarere Cluster.

Anwenden von K-Means auf einen anderen Datensatz

Lassen Sie uns das, was wir gelernt haben, auf einen anderen Datensatz anwenden. Dieses Mal werden wir versuchen, Gruppen ähnlicher Weine zu finden.

Wir beginnen mit dem Import pandas Lesen der wine-clustering CSV (Komma-getrennte Werte) Datei in a Dataframe Struktur:

import pandas as pd

df = pd.read_csv('wine-clustering.csv')

Werfen wir nach dem Laden einen Blick auf die ersten fünf Datensätze mit der head() Verfahren:

df.head()

Das führt zu:

	Alcohol 	Malic_Acid 	Ash 	Ash_Alcanity 	Magnesium 	Total_Phenols 	Flavanoids 	Nonflavanoid_Phenols 	Proanthocyanins 	Color_Intensity 	Hue 	OD280 	Proline
0 	14.23 		1.71 		2.43 	15.6 			127 		2.80 			3.06 		0.28 					2.29 				5.64 				1.04 	3.92 	1065
1 	13.20 		1.78 		2.14 	11.2 			100 		2.65 			2.76 		0.26 					1.28 				4.38 				1.05 	3.40 	1050
2 	13.16 		2.36 		2.67 	18.6 			101 		2.80 			3.24 		0.30 					2.81 				5.68 				1.03 	3.17 	1185
3 	14.37 		1.95 		2.50 	16.8 			113 		3.85 			3.49 		0.24 					2.18 				7.80 				0.86 	3.45 	1480
4 	13.24 		2.59 		2.87 	21.0 			118 		2.80 			2.69 		0.39 					1.82 				4.32 				1.04 	2.93 	735

Wir haben viele Messungen von Substanzen, die in Weinen vorhanden sind. Hier müssen wir auch keine kategorialen Spalten transformieren, da sie alle numerisch sind. Schauen wir uns nun die deskriptiven Statistiken mit an describe() Verfahren:

df.describe().T 

Die Beschreibungstabelle:

 						count 	mean 		std 		min 	25% 	50% 	75% 		max
Alcohol 				178.0 	13.000618 	0.811827 	11.03 	12.3625 13.050 	13.6775 	14.83
Malic_Acid 				178.0 	2.336348 	1.117146 	0.74 	1.6025 	1.865 	3.0825 		5.80
Ash 					178.0 	2.366517 	0.274344 	1.36 	2.2100 	2.360 	2.5575 		3.23
Ash_Alcanity 			178.0 	19.494944 	3.339564 	10.60 	17.2000 19.500 	21.5000 	30.00
Magnesium 				178.0 	99.741573 	14.282484 	70.00 	88.0000 98.000 	107.0000 	162.00
Total_Phenols 			178.0 	2.295112 	0.625851 	0.98 	1.7425 	2.355 	2.8000 		3.88
Flavanoids 				178.0 	2.029270 	0.998859 	0.34 	1.2050 	2.135 	2.8750 		5.08
Nonflavanoid_Phenols 	178.0 	0.361854 	0.124453 	0.13 	0.2700 	0.340 	0.4375 		0.66
Proanthocyanins 		178.0 	1.590899 	0.572359 	0.41 	1.2500 	1.555 	1.9500 		3.58
Color_Intensity 		178.0 	5.058090 	2.318286 	1.28 	3.2200 	4.690 	6.2000 		13.00
Hue 					178.0 	0.957449 	0.228572 	0.48 	0.7825 	0.965 	1.1200 		1.71
OD280 					178.0 	2.611685 	0.709990 	1.27 	1.9375 	2.780 	3.1700 		4.00
Proline 				178.0 	746.893258 	314.907474 	278.00 	500.500 673.500 985.0000 	1680.00

Wenn man sich die Tabelle ansieht, ist klar, dass es welche gibt Variabilität in den Daten – für einige Spalten wie z Alchool es gibt mehr, und für andere, wie z Malic_Acid, weniger. Jetzt können wir prüfen, ob es welche gibt null, oder NaN Werte in unserem Datensatz:

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 178 entries, 0 to 177
Data columns (total 13 columns):
 #   Column                Non-Null Count  Dtype  
---  ------                --------------  -----  
 0   Alcohol               178 non-null    float64
 1   Malic_Acid            178 non-null    float64
 2   Ash                   178 non-null    float64
 3   Ash_Alcanity          178 non-null    float64
 4   Magnesium             178 non-null    int64  
 5   Total_Phenols         178 non-null    float64
 6   Flavanoids            178 non-null    float64
 7   Nonflavanoid_Phenols  178 non-null    float64
 8   Proanthocyanins       178 non-null    float64
 9   Color_Intensity       178 non-null    float64
 10  Hue                   178 non-null    float64
 11  OD280                 178 non-null    float64
 12  Proline               178 non-null    int64  
dtypes: float64(11), int64(2)
memory usage: 18.2 KB

Es ist nicht erforderlich, Daten zu löschen oder einzugeben, da das Dataset keine leeren Werte enthält. Wir können eine Seaborn benutzen pairplot() um die Datenverteilung zu sehen und um zu prüfen, ob der Datensatz Spaltenpaare bildet, die für das Clustering interessant sein können:

sns.pairplot(df)

Wenn man sich das Pairplot ansieht, scheinen zwei Spalten für Clustering-Zwecke vielversprechend zu sein – Alcohol und OD280 (das ist eine Methode zur Bestimmung der Proteinkonzentration in Weinen). Es scheint, dass es 3 verschiedene Cluster auf Parzellen gibt, die zwei von ihnen kombinieren.

Es gibt andere Spalten, die ebenfalls in Korrelation zu stehen scheinen. Vor allem Alcohol und Total_Phenols und Alcohol und Flavanoids. Sie haben große lineare Beziehungen, die im Pairplot beobachtet werden können.

Da unser Fokus auf dem Clustering mit K-Means liegt, wählen wir beispielsweise ein Spaltenpaar aus Alcohol und OD280, und testen Sie die Ellenbogenmethode für dieses Dataset.

Lassen Sie uns das Streudiagramm zeichnen, wobei diese beiden Spalten als Achse festgelegt sind, um die Punkte, die wir in Gruppen unterteilen möchten, genauer zu betrachten:

sns.scatterplot(data=df, x='OD280', y='Alcohol')

Jetzt können wir unsere Spalten definieren und die Ellenbogenmethode verwenden, um die Anzahl der Cluster zu bestimmen. Wir werden auch den Algorithmus mit initiieren kmeans++ Nur um sicherzustellen, dass es schneller konvergiert:

values = df[['OD280', 'Alcohol']]

wcss_wine = [] 
for i in range(1, 11): 
    kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
    kmeans.fit(values) 
    wcss_wine.append(kmeans.inertia_)

Wir haben den WCSS berechnet, damit wir die Ergebnisse grafisch darstellen können:

clusters_wine = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
plt.plot(clusters_wine, wcss_wine)
plt.axvline(3, linestyle='--', color='r')

Nach der Ellbogenmethode sollten wir hier 3 Cluster haben. Lassen Sie uns für den letzten Schritt unsere Punkte in 3 Cluster gruppieren und die durch Farben gekennzeichneten Cluster plotten:

kmeans_wine = KMeans(n_clusters=3, random_state=42)
kmeans_wine.fit(values)
sns.scatterplot(x = values['OD280'], y = values['Alcohol'], hue=kmeans_wine.labels_)

Wir können Cluster sehen 0, 1 und 2 in der Grafik. Basierend auf unserer Analyse, Gruppe 0 hat Weine mit höherem Proteingehalt und weniger Alkohol, Gruppe 1 hat Weine mit höherem Alkoholgehalt und niedrigem Proteingehalt, und Gruppe 2 hat sowohl einen hohen Protein- als auch einen hohen Alkoholgehalt in seinen Weinen.

Dies ist ein sehr interessanter Datensatz, und ich ermutige Sie, weiter in die Analyse einzusteigen, indem Sie die Daten nach Normalisierung und PCA gruppieren – auch indem Sie die Ergebnisse interpretieren und neue Verbindungen finden.

Zusammenfassung

K-Mittel Clustering ist ein einfacher, aber sehr effektiver Algorithmus für unbeaufsichtigtes maschinelles Lernen für Daten-Clustering. Es gruppiert Daten basierend auf dem euklidischen Abstand zwischen Datenpunkten. Der K-Means-Clustering-Algorithmus hat viele Verwendungsmöglichkeiten zum Gruppieren von Textdokumenten, Bildern, Videos und vielem mehr.