AI-United » Allgemein » Die Verwendung des k-Means-Algorithmus zur Clusteranalyse

Die Verwendung des k-Means-Algorithmus zur Clusteranalyse

Die Verwendung des k-Means-Algorithmus zur Clusteranalyse

In der Datenwissenschaft gilt unüberwachtes Lernen oft als etwas „unkonventionell“. Dies ist besonders der Fall, wenn empirisch nachweisbare Ergebnisse erwünscht sind. Der K-Means-Algorithmus wird dank seiner Einfachheit immer beliebter. Darüber hinaus funktioniert er als ein leistungsstarkes, wenn auch temperamentvolles Tool zur Datenanalyse.

In diesem Artikel werden einige der Grundlagen des einfachen K-Means-Clusterings betrachtet.


Vergleich des unüberwachten Lernens mit Clustering:


In diesem Artikel gibt es keine „echten“, testbaren Daten zum Vergleich! K-Means-Algorithmus (KM) sowie andere Algorithmen des unüberwachten Lernens werden am häufigsten verwendet, wenn kein Testfall vorliegt – man geht davon aus, dass die testbaren Daten für den Datensatz entweder nicht vorliegen oder ausgeschlossen wurden!


Theoretische Grundlagen des Clusterings mit dem k-Means Algorithmus

Der k-Means-Algorithmus ist eines der am häufigsten verwendeten mathematischen Verfahren zur Clusteranalyse. Aus folgenden Gründen zählt er zu den beliebtesten Clustering-Algorithmen.

Er ist ziemlich einfach, verwendet konzeptionell einfache Metriken und man kann ihn leicht visualisieren. Vor allem versuchen K-Means-Algorithmen, Datenbeobachtungen um Cluster-Schwerpunkte zu gruppieren. Bevor die Schwerpunkte behandelt werden, wird vor dem Clustering ein kurzer Blick auf nachfolgende graphische Darstellung der Beispieldaten geworfen:

Pre-Clustered Daten

Man kann deutlich drei klar getrennte Datencluster sehen, die fast sicher Trends in den Basisdaten wiedergeben, die in dem Moment bekannt sein können oder nicht. In diesem Beispiel werden die Daten mit der nachfolgenden Zelle in einer Python 3-Umgebung erstellt, deshalb kann man sicher sein, dass sie sehr ordentlich sind. Um fortzusetzen, wird dieser Code kopiert und befolgt.

### Building k-means example, step by step!
#### Made sure to import and/or download the following libraries:
from sklearn.datasets import make_blobs   # tool to create our sample data
import matplotlib.pylab as plt            # standard plotting
import pandas as pd, numpy as np          
%matplotlib inline                        # very handy 'magic' command
figsize=(8, 6)
colors = ["r", "b", "g"]
columns = ["x1", "x2", "color"]
# We'll work with a managable sample of 50 observations in 3 distinct clusters.  You can follow these specifications in the arguments below: 
X, color = make_blobs(n_samples=50, random_state=42, centers=3, cluster_std=1.75)
# setting the colors we'll use in a little while
X = map(lambda x: (x[0][0], x[0][1], colors[x[1]]), zip(X, color))
# Starting centroid points.  These can be arbitrary, but it helps to give intelligently-designated starting points:
centroids = pd.DataFrame([(-8, 0, "g"), (-7.5, 8, "r"), (2.5, -2, "b")], columns=columns)
# Training points
gaus_df = pd.DataFrame(list(X), columns=columns)
ax = gaus_df.plot(kind="scatter", x="x1", y="x2", figsize=figsize)
ax.set_title("Begin: Load Data Points", fontsize=15)

Mithilfe des folgenden Codes können Farben auf Daten verwendet werden, um sie ein bisschen klarer zu visualisieren!

Es sollte darauf hingewiesen werden, dass die Daten selbst immer noch monochrom sind und alle erstellten farbigen Schwerpunkte der Cluster, auf die sie sich zu beziehen scheinen, ein bisschen unzentriert sind.


Wie bereits erwähnt wird beim K-Means-Clustering der mittlere quadratische Abstand (mean-squared distance/MSD) zwischen Datenbeobachtungen und ihren Schwerpunkten minimiert. Manchmal kann hier sogar der reine euklidische Abstand als Maß verwendet werden. Dies führt dazu, dass K-Means öfters mit dem K-Nearest-Neighbor-Klassifikationsmodell verwechselt wird. Es ist aber anzumerken, dass die beiden Algorithmen etwas unterschiedliche Funktionsweisen haben.

Eine weitere wichtige Bemerkung besteht darin, dass die ausgewählten Schwerpunkte iterativ von ihrer Startposition aus zu der Position „laufen“, die den mittleren quadratischen Abstand der Daten zum nächsten oder ähnlichsten Schwerpunkt minimiert. Hier wird als Referenz ein Code zur Erstellung der visuellen Überprüfung des euklidischen Abstandes eingefügt:

import numpy as np
import pandas as pd
from sklearn.metrics import euclidean_distances
from sklearn.datasets.samples_generator import make_blobs
import matplotlib.pyplot as plt
%matplotlib inline
X = np.array([[2, -1], [-2, 2]])
plt.figure(figsize=(12, 7))
for i, (x, y) in enumerate(X):
    plt.scatter(y, x)
    plt.text(y + .05, x -.05, "$X_%d$" % (i+1), size=22)
    
plt.plot(X[0], X[1], "g--")
plt.text(.5, .5, "$\sqrt{\sum_{i=1}^N (x_{1i} - x_{2i})^2}$", size=25)
plt.title("Euclidean Distance Between $x_1$ and $x_2$", size=15)

KM läuft die Daten durch, um die Schwerpunkte zu verschieben, und lernt dabei, die unterschiedlichen Cluster festzustellen, die jeder intuitiv im anfänglichen Datenplot sehen kann! Da dies ein sehr einfaches Beispiel ist, ist für K-Means wenig Aufwand erforderlich, um zu schönen, unterschiedlichen Clustern zu konvergieren. Die folgenden Beispielplots veranschaulichen diesen Prozess Schritt für Schritt:

1. Schritt: Initialisieren von Schwerpunkten

Obwohl diese obige Zelle durchgegangen wurde, wird sie noch einmal eingefügt und der logische Ablauf von K-Means durchlaufen.

Die Schwerpunkte werden „willkürlich“ ausgewählt und können auf diese Weise zum Clustering der beobachteten Daten verwendet werden.

Rechts kann man sehen, wie JEDER Datenpunkt von jedem Schwerpunkt berücksichtigt wird. Bei großen Datenmengen kann dieser Algorithmus etwas rechenintensiv sein!

2. Schritt: Berechnung der Schwerpunktabstände (euklidisch)

Bezüglich der Codierung ist dies Neuland. Nachfolgend wird behandelt, wie diese Art von Ergebnissen geliefert werden kann, aber vorerst wird berücksichtigt, wie die ordentliche Unterteilung der Daten durchgeführt wurde.

Es sollte noch darauf hingewiesen werden, dass die Schwerpunkte sich nicht bewegt haben – dies ist bei einfachen Daten der Fall, wenn jedoch komplexeren Daten bearbeitet werden, werden mehr Abläufe benötigt.

3. Schritt: Zuordnung der Datenpunkte zum nächsten Schwerpunkt

Die 2. und 3. Schritte werden bis zur Konvergenz wiederholt! Diese Phase besteht also darin, dass sich die Schwerpunkte allmählich über den Plot bewegen, bis der gesamte MSD von sich selbst zu ihren nächsten Datenpunkten minimiert wurde!

3. Schritt – Weiter: Wiederholung des 2. und 3. Schrittes bis zur Konvergenz

Nachdem die Konvergenz erreicht worden ist, kommen ordentlich getrennte Datencluster heraus! Diese Cluster weisen gemeinsame Merkmale in den Originaldaten auf. Einige davon können im DataFrame selbst nicht erkennbar sein.

Output

Zum Schluss betrachten wir ein praktisches Beispiel von Anfang bis Ende.

Eingesetzter K-Means-Algorithmus:

Als allererstes werden einige Beispieldaten erstellt:

%matplotlib inline
from sklearn.cluster import KMeans, k_means
from sklearn.metrics import silhouette_score
from sklearn.datasets.samples_generator import make_blobs
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')
# # Let's make some more blobs to test K-Means on
X, color = make_blobs(n_samples=100, random_state=29, centers=3, cluster_std=1.5)
df = pd.DataFrame(X, columns=["x1", "x2"])
df['color'] = color
df.head()
Beispiel für erstellte Daten

Die Daten werden mit Matplotlib gezeichnet:

# Plot the scatter -- we need to code the previous cell to get "df"
ax = df.plot(kind="scatter", x="x1", y="x2", figsize=(12,6), s=50)
plt.xlabel("$X_1$", fontsize=18)
plt.ylabel("$X_2$", fontsize=18)
ax.tick_params(axis='both', which='major', labelsize=18)
Ordentliche Cluster von make_blobs

Die Daten werden mit Sklearn-Paketen angepasst. Dies ist ein sehr interessanter Teil:

## Take note that the latest version of Kmeans my behave slightly different.  
kmeans = KMeans(n_clusters=3)
model = kmeans.fit(df[['x1', 'x2']])
# Now, we can get the predicted model labels, or Centroids, in the form of an array:
model.cluster_centers_

Dann werden diese Labels für zukünftige Plots dem DataFrame und die Schwerpunkte auch einem eigenen DataFrame zugewiesen:

# attach predicted cluster to original points
df['predicted'] = model.labels_
# Create a dataframe for cluster_centers (centroids)
centroids = pd.DataFrame(model.cluster_centers_, columns=["x1", "x2"])

Beim diesen Schritt sollte ein grundlegender, aber anschaulicher K-Means-Cluster-Plot erzeugt werden!

from matplotlib import pyplot as plt
plt.figure(figsize=(7,7))
## Plot scatter by cluster / color, and centroids
colors = ["red", "green", "blue"]
df['color'] = df['predicted'].map(lambda p: colors[p])
ax = df.plot(    
    kind="scatter", 
    x="x1", y="x2",
    figsize=(10,8),
    c = df['color']
)
centroids.plot(
    kind="scatter", 
    x="x1", y="x2", 
    marker="*", c=["r", "g", "b"], s=550,
    ax=ax
)
Letzter Plot verschiedener Cluster

Dieser Artikel verschaffte einen kurzen Überblick über das K-Means-Clustering. Es sollte darauf geachtet werden, dass sowie Ausnahmen als auch falsch beschriftete Datenpunkte in weniger idealen, realen Daten vorkommen können, aber dies sollte gemacht werden, um den Einstieg zu vereinfachen. Eine besondere Aufmerksamkeit sollte den „whispy“-Daten gewidmet werden, dies sind die Daten, die sich zu langen, dünnen Clustern entlang der X-, Y- oder beider Achsen zusammenschließen. Dieses einfache Modell ist nicht in der Lage, zwischen diesen Arten von Cluster zu unterscheiden, und findet die NÄCHSTEN Punkte für die Clusterzuordnung, wodurch eine Kreuzkontamination entstehen kann!

Sollten Sie Fragen dazu haben, wie der K-Means-Algorithmus beim Clustering eingesetzt wird, so können Sie sich an das Team von AI-United.de per Mail oder Q&A wenden.

Quelle

AI-United-Redaktion

Kommentar hinzufügen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.