8 Clustering-Algorithmen beim maschinellen Lernen, die alle Datenwissenschaftler kennen sollten

Abhängig von Ihren Daten gibt es drei verschiedene Ansätze für maschinelles Lernen. Sie können mit überwachtem Lernen, halbüberwachtem Lernen oder unbeaufsichtigtem Lernen beginnen.

Beim überwachten Lernen haben Sie Daten beschriftet, sodass Sie Ausgaben haben, von denen Sie sicher wissen, dass sie die richtigen Werte für Ihre Eingaben sind. Das ist so, als würde man die Autopreise anhand von Merkmalen wie Marke, Modell, Stil, Antriebsstrang und anderen Attributen kennen.

Beim halbüberwachten Lernen verfügen Sie über einen großen Datensatz, in dem einige Daten beschriftet sind, die meisten jedoch nicht.

Dies deckt eine große Menge realer Daten ab, da es teuer sein kann, einen Experten zu beauftragen, jeden Datenpunkt zu kennzeichnen. Sie können dies umgehen, indem Sie eine Kombination aus überwachtem und unbeaufsichtigtem Lernen verwenden.

Unbeaufsichtigtes Lernen bedeutet, dass Sie einen Datensatz haben, der vollständig unbeschriftet ist. Sie wissen nicht, ob in den Daten Muster verborgen sind, und überlassen es dem Algorithmus, alles zu finden, was er kann.

Hier kommen Clustering-Algorithmen ins Spiel. Dies ist eine der Methoden, die Sie bei einem unbeaufsichtigten Lernproblem anwenden können.

Was sind Clustering-Algorithmen?

Clustering ist eine unbeaufsichtigte maschinelle Lernaufgabe. Aufgrund der Funktionsweise dieser Methode wird dies möglicherweise auch als Clusteranalyse bezeichnet.

Wenn Sie einen Clustering-Algorithmus verwenden, geben Sie dem Algorithmus viele Eingabedaten ohne Beschriftung und lassen ihn Gruppierungen in den Daten finden, die er kann.

Diese Gruppierungen werden als Cluster bezeichnet . Ein Cluster ist eine Gruppe von Datenpunkten, die sich aufgrund ihrer Beziehung zu umgebenden Datenpunkten ähneln. Clustering wird beispielsweise für Feature-Engineering oder Mustererkennung verwendet.

Wenn Sie mit Daten beginnen, von denen Sie nichts wissen, ist Clustering möglicherweise ein guter Ort, um einen Einblick zu erhalten.

Arten von Clustering-Algorithmen

Es gibt verschiedene Arten von Clustering-Algorithmen, die alle Arten von eindeutigen Daten verarbeiten.

Dichtebasiert

Beim dichtebasierten Clustering werden Daten nach Bereichen mit hohen Konzentrationen von Datenpunkten gruppiert, die von Bereichen mit niedrigen Konzentrationen von Datenpunkten umgeben sind. Grundsätzlich findet der Algorithmus die Orte, die mit Datenpunkten dicht sind, und ruft diese Cluster auf.

Das Tolle daran ist, dass die Cluster jede Form haben können. Sie sind nicht an die erwarteten Bedingungen gebunden.

Die Clustering-Algorithmen dieses Typs versuchen nicht, Clustern Ausreißer zuzuweisen, sodass sie ignoriert werden.

Distributionsbasiert

Bei einem verteilungsbasierten Clustering-Ansatz werden alle Datenpunkte basierend auf der Wahrscheinlichkeit, dass sie zu einem bestimmten Cluster gehören, als Teile eines Clusters betrachtet.

Das funktioniert so: Es gibt einen Mittelpunkt, und wenn der Abstand eines Datenpunkts vom Mittelpunkt zunimmt, nimmt die Wahrscheinlichkeit ab, dass er Teil dieses Clusters ist.

Wenn Sie sich nicht sicher sind, wie die Verteilung in Ihren Daten aussehen könnte, sollten Sie einen anderen Algorithmus in Betracht ziehen.

Schwerpunkt basiert

Centroid-basiertes Clustering ist das, von dem Sie wahrscheinlich am meisten hören. Es ist ein wenig empfindlich gegenüber den Anfangsparametern, die Sie ihm geben, aber es ist schnell und effizient.

Diese Arten von Algorithmen trennen Datenpunkte basierend auf mehreren Schwerpunkten in den Daten. Jeder Datenpunkt wird basierend auf seiner quadratischen Entfernung vom Schwerpunkt einem Cluster zugewiesen. Dies ist die am häufigsten verwendete Art der Clusterbildung.

Hierarchisch basiert

Hierarchisches Clustering wird normalerweise für hierarchische Daten verwendet, wie Sie sie aus einer Unternehmensdatenbank oder aus Taxonomien erhalten würden. Es wird ein Clusterbaum erstellt, sodass alles von oben nach unten organisiert ist.

Dies ist restriktiver als die anderen Clustertypen, eignet sich jedoch perfekt für bestimmte Arten von Datensätzen.

Wann wird Clustering verwendet?

Wenn Sie über eine Reihe unbeschrifteter Daten verfügen, verwenden Sie höchstwahrscheinlich einen unbeaufsichtigten Lernalgorithmus.

Es gibt viele verschiedene unbeaufsichtigte Lerntechniken, wie neuronale Netze, verstärkendes Lernen und Clustering. Welche Art von Algorithmus Sie verwenden möchten, hängt davon ab, wie Ihre Daten aussehen.

Möglicherweise möchten Sie Clustering verwenden, wenn Sie versuchen, Anomalien zu erkennen, um Ausreißer in Ihren Daten zu finden. Es hilft, indem Sie diese Gruppen von Clustern finden und die Grenzen anzeigen, die bestimmen würden, ob ein Datenpunkt ein Ausreißer ist oder nicht.

Wenn Sie sich nicht sicher sind, welche Funktionen für Ihr Modell für maschinelles Lernen verwendet werden sollen, werden beim Clustering Muster ermittelt, mit denen Sie herausfinden können, was in den Daten auffällt.

Clustering ist besonders nützlich, um Daten zu untersuchen, von denen Sie nichts wissen. Es kann einige Zeit dauern, um herauszufinden, welche Art von Clustering-Algorithmus am besten funktioniert. Wenn Sie dies jedoch tun, erhalten Sie wertvolle Einblicke in Ihre Daten. Möglicherweise finden Sie Verbindungen, an die Sie nie gedacht hätten.

Einige reale Clustering-Anwendungen umfassen die Betrugserkennung in Versicherungen, die Kategorisierung von Büchern in einer Bibliothek und die Kundensegmentierung im Marketing. Es kann auch bei größeren Problemen wie Erdbebenanalyse oder Stadtplanung eingesetzt werden.

Die Top 8 Clustering-Algorithmen

Nachdem Sie einige Hintergrundinformationen zur Funktionsweise von Clustering-Algorithmen und zu den verschiedenen verfügbaren Typen haben, können wir über die tatsächlichen Algorithmen sprechen, die Sie in der Praxis häufig sehen.

Wir werden diese Algorithmen in einem Beispieldatensatz aus der sklearn-Bibliothek in Python implementieren.

Wir werden den Datensatz make_classification aus der sklearn-Bibliothek verwenden, um zu demonstrieren, dass verschiedene Clustering-Algorithmen nicht für alle Clustering-Probleme geeignet sind.

Den Code für alle folgenden Beispiele finden Sie hier.

K-bedeutet Clustering-Algorithmus

K-Means-Clustering ist der am häufigsten verwendete Clustering-Algorithmus. Es ist ein Schwerpunkt-basierter Algorithmus und der einfachste unbeaufsichtigte Lernalgorithmus.

Dieser Algorithmus versucht, die Varianz von Datenpunkten innerhalb eines Clusters zu minimieren. Auf diese Weise werden die meisten Menschen in das unbeaufsichtigte maschinelle Lernen eingeführt.

K-means wird am besten für kleinere Datensätze verwendet, da es über alle Datenpunkte iteriert . Das bedeutet, dass die Klassifizierung von Datenpunkten länger dauert, wenn sich eine große Menge davon im Datensatz befindet.

Da k-means auf diese Weise Datenpunkte gruppiert, lässt es sich nicht gut skalieren.

Implementierung:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import KMeans # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model kmeans_model = KMeans(n_clusters=2) # assign each data point to a cluster dbscan_result = dbscan_model.fit_predict(training_data) # get all of the unique clusters dbscan_clusters = unique(dbscan_result) # plot the DBSCAN clusters for dbscan_cluster in dbscan_clusters:     # get data points that fall in this cluster     index = where(dbscan_result == dbscan_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the DBSCAN plot pyplot.show()

DBSCAN-Clustering-Algorithmus

DBSCAN steht für dichtebasierte räumliche Clusterbildung von Anwendungen mit Rauschen. Im Gegensatz zu k-means handelt es sich um einen dichtebasierten Clustering-Algorithmus.

Dies ist ein guter Algorithmus zum Auffinden von Outlinern in einem Datensatz. Es werden beliebig geformte Cluster basierend auf der Dichte von Datenpunkten in verschiedenen Regionen gefunden. Es trennt Regionen durch Bereiche mit geringer Dichte, so dass Ausreißer zwischen den Clustern mit hoher Dichte erkannt werden können.

Dieser Algorithmus ist besser als k-means, wenn es darum geht, mit ungewöhnlich geformten Daten zu arbeiten.

DBSCAN verwendet zwei Parameter, um zu bestimmen, wie Cluster definiert werden: minPts (die minimale Anzahl von Datenpunkten, die zusammen geclustert werden müssen, damit ein Bereich als hochdicht eingestuft wird) und eps (die Entfernung, die verwendet wird, um zu bestimmen, ob sich ein Datenpunkt in der befindet gleicher Bereich wie andere Datenpunkte).

Die Auswahl der richtigen Anfangsparameter ist entscheidend, damit dieser Algorithmus funktioniert.

Implementierung:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import DBSCAN # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model dbscan_model = DBSCAN(eps=0.25, min_samples=9) # train the model dbscan_model.fit(training_data) # assign each data point to a cluster dbscan_result = dbscan_model.predict(training_data) # get all of the unique clusters dbscan_cluster = unique(dbscan_result) # plot the DBSCAN clusters for dbscan_cluster in dbscan_clusters:     # get data points that fall in this cluster     index = where(dbscan_result == dbscan_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the DBSCAN plot pyplot.show()

Gaußscher Mischungsmodellalgorithmus

Eines der Probleme mit k-means ist, dass die Daten einem kreisförmigen Format folgen müssen. Die Art und Weise, wie k-means den Abstand zwischen Datenpunkten berechnet, hat mit einer Kreisbahn zu tun, sodass nicht kreisförmige Daten nicht korrekt geclustert werden.

Dies ist ein Problem, das durch Gaußsche Mischungsmodelle behoben wird. Sie benötigen keine kreisförmigen Daten, damit sie gut funktionieren.

Das Gaußsche Mischungsmodell verwendet mehrere Gaußsche Verteilungen, um beliebig geformte Daten anzupassen.

Es gibt mehrere einzelne Gaußsche Modelle, die in diesem Hybridmodell als verborgene Schichten fungieren. Das Modell berechnet also die Wahrscheinlichkeit, dass ein Datenpunkt zu einer bestimmten Gaußschen Verteilung gehört, und das ist der Cluster, unter den er fällt.

Implementierung:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.mixture import GaussianMixture # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model gaussian_model = GaussianMixture(n_components=2) # train the model gaussian_model.fit(training_data) # assign each data point to a cluster gaussian_result = gaussian_model.predict(training_data) # get all of the unique clusters gaussian_clusters = unique(gaussian_result) # plot Gaussian Mixture the clusters for gaussian_cluster in gaussian_clusters:     # get data points that fall in this cluster     index = where(gaussian_result == gaussian_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Gaussian Mixture plot pyplot.show()

BIRCH-Algorithmus

Der BIRCH-Algorithmus (Balance Iterative Reducing and Clustering using Hierarchies) funktioniert bei großen Datenmengen besser als der k-means-Algorithmus.

Die Daten werden in kleine Zusammenfassungen unterteilt, die anstelle der ursprünglichen Datenpunkte gruppiert werden. Die Zusammenfassungen enthalten so viele Verteilungsinformationen wie möglich über die Datenpunkte.

Dieser Algorithmus wird üblicherweise mit anderen Clustering-Algorithmen verwendet, da die anderen Clustering-Techniken für die von BIRCH generierten Zusammenfassungen verwendet werden können.

The main downside of the BIRCH algorithm is that it only works on numeric data values. You can't use this for categorical values unless you do some data transformations.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import Birch # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model birch_model = Birch(threshold=0.03, n_clusters=2) # train the model birch_model.fit(training_data) # assign each data point to a cluster birch_result = birch_model.predict(training_data) # get all of the unique clusters birch_clusters = unique(birch_result) # plot the BIRCH clusters for birch_cluster in birch_clusters:     # get data points that fall in this cluster     index = where(birch_result == birch_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the BIRCH plot pyplot.show() 

Affinity Propagation clustering algorithm

This clustering algorithm is completely different from the others in the way that it clusters data.

Each data point communicates with all of the other data points to let each other know how similar they are and that starts to reveal the clusters in the data. You don't have to tell this algorithm how many clusters to expect in the initialization parameters.

As messages are sent between data points, sets of data called exemplars are found and they represent the clusters.

An exemplar is found after the data points have passed messages to each other and form a consensus on what data point best represents a cluster.

When you aren't sure how many clusters to expect, like in a computer vision problem, this is a great algorithm to start with.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import AffinityPropagation # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model model = AffinityPropagation(damping=0.7) # train the model model.fit(training_data) # assign each data point to a cluster result = model.predict(training_data) # get all of the unique clusters clusters = unique(result) # plot the clusters for cluster in clusters:     # get data points that fall in this cluster     index = where(result == cluster)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the plot pyplot.show()

Mean-Shift clustering algorithm

This is another algorithm that is particularly useful for handling images and computer vision processing.

Mean-shift is similar to the BIRCH algorithm because it also finds clusters without an initial number of clusters being set.

This is a hierarchical clustering algorithm, but the downside is that it doesn't scale well when working with large data sets.

It works by iterating over all of the data points and shifts them towards the mode. The mode in this context is the high density area of data points in a region.

That's why you might hear this algorithm referred to as the mode-seeking algorithm. It will go through this iterative process with each data point and move them closer to where other data points are until all data points have been assigned to a cluster.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import MeanShift # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model mean_model = MeanShift() # assign each data point to a cluster mean_result = mean_model.fit_predict(training_data) # get all of the unique clusters mean_clusters = unique(mean_result) # plot Mean-Shift the clusters for mean_cluster in mean_clusters:     # get data points that fall in this cluster     index = where(mean_result == mean_cluster)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Mean-Shift plot pyplot.show()

OPTICS algorithm

OPTICS stands for Ordering Points to Identify the Clustering Structure. It's a density-based algorithm similar to DBSCAN, but it's better because it can find meaningful clusters in data that varies in density. It does this by ordering the data points so that the closest points are neighbors in the ordering.

This makes it easier to detect different density clusters. The OPTICS algorithm only processes each data point once, similar to DBSCAN (although it runs slower than DBSCAN). There's also a special distance stored for each data point that indicates a point belongs to a specific cluster.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import OPTICS # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model optics_model = OPTICS(eps=0.75, min_samples=10) # assign each data point to a cluster optics_result = optics_model.fit_predict(training_data) # get all of the unique clusters optics_clusters = unique(optics_clusters) # plot OPTICS the clusters for optics_cluster in optics_clusters:     # get data points that fall in this cluster     index = where(optics_result == optics_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the OPTICS plot pyplot.show()

Agglomerative Hierarchy clustering algorithm

This is the most common type of hierarchical clustering algorithm. It's used to group objects in clusters based on how similar they are to each other.

This is a form of bottom-up clustering, where each data point is assigned to its own cluster. Then those clusters get joined together.

At each iteration, similar clusters are merged until all of the data points are part of one big root cluster.

Agglomerative clustering is best at finding small clusters. The end result looks like a dendrogram so that you can easily visualize the clusters when the algorithm finishes.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import AgglomerativeClustering # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model agglomerative_model = AgglomerativeClustering(n_clusters=2) # assign each data point to a cluster agglomerative_result = agglomerative_model.fit_predict(training_data) # get all of the unique clusters agglomerative_clusters = unique(agglomerative_result) # plot the clusters for agglomerative_cluster in agglomerative_clusters:     # get data points that fall in this cluster     index = where(agglomerative_result == agglomerative_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Agglomerative Hierarchy plot pyplot.show()

Other types of clustering algorithms

We've covered eight of the top clustering algorithms, but there are plenty more than that available. There are some very specifically tuned clustering algorithms that quickly and precisely handle your data. Here are a few of the others that might be of interest to you.

There's another hierarchical algorithm that's the opposite of the agglomerative approach. It starts with a top-down clustering strategy. So it will start with one large root cluster and break out the individual clusters from there.

This is known as the Divisive Hierarchical clustering algorithm. There's research that shows this is creates more accurate hierarchies than agglomerative clustering, but it's way more complex.

Mini-Batch K-means is similar to K-means, except that it uses small random chunks of data of a fixed size so they can be stored in memory. This helps it run faster than K-means so it converges to a solution in less time.

The drawback to this algorithm is that the speed boost will cost you some cluster quality.

The last algorithm we'll briefly cover is Spectral Clustering. This algorithm is completely different from the others we've looked at.

It works by taking advantage of graph theory. This algorithm doesn't make any initial guesses about the clusters that are in the data set. It treats data points like nodes in a graph and clusters are found based on communities of nodes that have connecting edges.

Other thoughts

Watch out for scaling issues with the clustering algorithms. Your data set could have millions of data points, and since clustering algorithms work by calculating the similarities between all pairs of data points, you might end up with an algorithm that doesn’t scale well.

Conclusion

Clustering algorithms are a great way to learn new things from old data. Sometimes you'll be surprised by the resulting clusters you get and it might help you make sense of a problem.

One of the coolest things about using clustering for unsupervised learning is that you can use the results in a supervised learning problem.

The clusters could be your new features that you use on a completely different data set! You can use clustering on just about any unsupervised machine learning problem, but make sure that you know how to analyze the results for accuracy.