AI-United » Allgemein » Das Verständnis von K-Means Clustering in Machine Learning

Das Verständnis von K-Means Clustering in Machine Learning

K-Means Clustering

K-Means Clustering ist einer der einfachsten und beliebtesten unüberwachten Algorithmen für Machine Learning.

Normalerweise ziehen unüberwachte Algorithmen aus Datensätzen nur aus Eingabevektoren, ohne auf bekannte oder markierte Ergebnisse Bezug zu nehmen.

AndreyBu, der mehr als 5 Jahre Erfahrung im Bereich des Machine Learning hat, sagt: „Das Ziel von K-Means ist einfach: Gruppieren Sie ähnliche Datenpunkte und entdecken Sie die zugrunde liegenden Muster. Um dieses Ziel zu erreichen, sucht K-Means nach einer festen Anzahl (k) von Clustern in einem Datensatz.“

Ein Cluster bezieht sich auf eine Sammlung von Datenpunkten, die aufgrund bestimmter Ähnlichkeiten zusammengefasst sind.

Sie definieren eine Zielnummer k, die sich auf die Anzahl der Zentroide bezieht, die Sie in der Datenmenge benötigen.

Ein Zentroid ist der imaginäre oder reale Ort, der das Zentrum des Clusters darstellt.

Jeder Datenpunkt wird jedem Cluster zugewiesen, indem die Quadratsumme innerhalb des Clusters reduziert wird.

Mit anderen Worten, der K-Means Algorithmus identifiziert k Anzahl der Zentroide und ordnet dann jeden Datenpunkt dem nächsten Cluster zu, während die Zentroide so klein wie möglich bleiben. ‘Means’ in K-Means bezieht sich auf die Mittelwertbildung der Daten, d. h., den Zentroid zu finden.

Wie der K-Means Algorithmus funktioniert

Um die Lerndaten zu verarbeiten, beginnt der K-Means Algorithmus im Data Mining mit einer ersten Gruppe von zufällig ausgewählten Zentroiden, die als Ausgangspunkt für jeden Cluster verwendet werden, und führt dann iterative (sich wiederholende) Berechnungen durch, um die Positionen der Zentroiden zu optimieren.

Der K-Means Algorithmus hält die Schaffung und Optimierung von Clustern an, wenn entweder:

  • Die Zentroide sich stabilisiert haben – ihre Werte ändern sich nicht, da das Clustering erfolgreich war.
  • Die definierte Anzahl von Iterationen erreicht wurde.

K-Means Algorithmus bei der Lösung des Beispielproblems

Schauen wir uns die Schritte an, wie der K-Means Algorithmus für Machine Learning mit der Programmiersprache Python funktioniert.

Wir verwenden Scikit-learn Bibliothek und einige zufällige Daten, um eine einfache Erklärung für das K-Means Clustering zu veranschaulichen.

Schritt 1: die Bibliotheken importieren
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
%matplotlib inline

Wie Sie dem obigen Code entnehmen können, importieren wir die folgenden Bibliotheken in unser Projekt:

  • Pandas – zum Lesen und Schreiben von Tabellenkalkulationen.
  • Numpy – für die Durchführung effizienter Berechnungen.
  • Matplotlib – zur Visualisierung von Daten.
Schritt 2: Zufallsdaten generieren

Hier ist der Code für die Generierung einiger Zufallsdaten in einem zweidimensionalen Raum:

X= -2 * np.random.rand(100,2)
X1 = 1 + 2 * np.random.rand(50,2)
X[50:100, :] = X1
plt.scatter(X[ : , 0], X[ :, 1], s = 50, c = ‘b’)
plt.show()

Es wurden insgesamt 100 Datenpunkte generiert und in zwei Gruppen mit jeweils 50 Punkten unterteilt.

So werden die Daten in einem zweidimensionalen Raum angezeigt:

Schritt 3: Scikit-Learn verwenden

Wir verwenden einige der verfügbaren Funktionen in der Scikit-Learn Bibliothek, um die zufällig generierten Daten zu verarbeiten.

Hier ist der Code:

from sklearn.cluster import KMeans
Kmean = KMeans(n_clusters=2)
Kmean.fit(X)

In diesem Fall haben wir willkürlich k (n_Clustern) einen beliebigen Wert von zwei gegeben.

Hier ist die Ausgabe der K-Means Parameter, die wir erhalten, wenn wir den Code ausführen:

KMeans(algorithm=’auto’, copy_x=True, init=’k-means++’, max_iter=300
 n_clusters=2, n_init=10, n_jobs=1, precompute_distances=’auto’,
 random_state=None, tol=0.0001, verbose=0)
Schritt 5: den Zentroid finden

Hier ist der Code, um das Zentrum des Cluster zu finden:

Kmean.cluster_centers_

Hier ist das Ergebnis des Wertes der Zentroiden:

array([[-0.94665068, -0.97138368],
 [ 2.01559419, 2.02597093]])

Lassen Sie uns die Cluster-Zentroide anzeigen (mit grüner und roter Farbe).

plt.scatter(X[ : , 0], X[ : , 1], s =50, c=’b’)
plt.scatter(-0.94665068, -0.97138368, s=200, c=’g’, marker=’s’)
plt.scatter(2.01559419, 2.02597093, s=200, c=’r’, marker=’s’)
plt.show()

Hier ist die Ausgabe:

Schritt 5: den Algorithmus prüfen

Hier ist der Code, um die Etiketten Eigenschaft des K-Means Clustering-Beispieldatensatzes zu bekommen; d. h., wie die Datenpunkte in die zwei Cluster eingeteilt werden.

Kmean.labels_

Hier ist das Ergebnis der Funktion des obigen K-Means Algorithmus-Codes:

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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])

Wie Sie oben sehen können, gehören 50 Datenpunkte zum 0-Cluster, der Rest zum 1-Cluster.

Lassen Sie uns zum Beispiel den unteren Code verwenden, um den Cluster eines Datenpunktes vorherzusagen:

sample_test=np.array([-3.0,-3.0])
second_test=sample_test.reshape(1, -1)
Kmean.predict(second_test)

Hier ist das Ergebnis:

array([0])

Es zeigt, dass der Testdatenpunkt zum 0-Cluster (grüner Zentroid) gehört.

Einbettung

Hier ist der gesamte K-Means Clustering-Algorithmus-Code in Python:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
%matplotlib inline
X= -2 * np.random.rand(100,2)
X1 = 1 + 2 * np.random.rand(50,2)
X[50:100, :] = X1
plt.scatter(X[ : , 0], X[ :, 1], s = 50, c = ‘b’)
plt.show()
from sklearn.cluster import KMeans
Kmean = KMeans(n_clusters=2)
Kmean.fit(X)
Kmean.cluster_centers_
plt.scatter(X[ : , 0], X[ : , 1], s =50, c=’b’)
plt.scatter(-0.94665068, -0.97138368, s=200, c=’g’, marker=’s’)
plt.scatter(2.01559419, 2.02597093, s=200, c=’r’, marker=’s’)
plt.show()
Kmean.labels_
sample_test=np.array([-3.0,-3.0])
second_test=sample_test.reshape(1, -1)
Kmean.predict(second_test)

K-Means Clustering ist eine weit verbreitete Technik für die Datenclusteranalyse.

Es ist leicht zu verstehen, insbesondere wenn Sie Ihr Lernen mit einem K-Means clustering tutorial beschleunigen. Allerdings ist die Leistung in der Regel nicht so wettbewerbsfähig wie bei den anderen ausgeklügelten Clustering-Techniken, da geringfügige Abweichungen in den Daten zu hohen Abweichungen führen können.

Außerdem wird davon ausgegangen, dass Cluster sphärisch und gleichmäßig groß sind, etwas, was die Genauigkeit der K-Means Clustering-Python-Ergebnisse verringern kann.

Welche Erfahrungen haben Sie mit K-Means Clustering in Machine Learning?

Bitte hinterlassen Sie Ihre Kommentare unten.

Gern beantwortet Ihnen das Team von Al United Ihre Fragen per E-Mail oder in den Q & Bereich.

Quelle: https://towardsdatascience.com/understanding-k-means-clustering-in-machine-learning-6a6e67336aa1

AI-United-Redaktion

Kommentar hinzufügen

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