DBSCAN mit Scikit-Learn in Python

Einleitung

Sie arbeiten in einem Beratungsunternehmen als Data Scientis. Das Projekt, dem Sie derzeit zugeordnet sind, enthält Daten von Studenten, die kürzlich Kurse zum Thema Finanzen abgeschlossen haben. Das Finanzunternehmen, das die Kurse durchführt, möchte verstehen, ob es gemeinsame Faktoren gibt, die die Studenten beeinflussen, dieselben Kurse oder unterschiedliche Kurse zu kaufen. Durch das Verständnis dieser Faktoren kann das Unternehmen ein Studentenprofil erstellen, jeden Studenten nach Profil klassifizieren und eine Liste von Kursen empfehlen.

Wenn Sie Daten von verschiedenen Schülergruppen untersuchen, sind Sie auf drei Punkteverteilungen gestoßen, wie in 1, 2 und 3 unten:

Beachten Sie, dass in Diagramm 1 violette Punkte in einem Halbkreis angeordnet sind, mit einer Masse rosafarbener Punkte innerhalb dieses Kreises, einer kleinen Konzentration orangefarbener Punkte außerhalb dieses Halbkreises und fünf grauen Punkten, die weit von allen anderen entfernt sind.

In Diagramm 2 gibt es eine runde Masse aus violetten Punkten, eine weitere aus orangefarbenen Punkten und auch vier graue Punkte, die weit von allen anderen entfernt sind.

Und in Diagramm 3 können wir vier Konzentrationen von Punkten sehen, violette, blaue, orange, rosa und drei weiter entfernte graue Punkte.

Wenn Sie nun ein Modell auswählen würden, das neue Schülerdaten verstehen und ähnliche Gruppen bestimmen könnte, gibt es dann einen Clustering-Algorithmus, der für diese Art von Daten interessante Ergebnisse liefern könnte?

Bei der Beschreibung der Plots haben wir Begriffe wie erwähnt Masse an Punkten und Konzentration von Punkten, was darauf hinweist, dass es in allen Graphen Bereiche mit größerer Dichte gibt. Wir haben auch darauf verwiesen Rundschreiben und halbkreisförmig Formen, die schwer zu identifizieren sind, indem man eine gerade Linie zeichnet oder nur die nächstgelegenen Punkte untersucht. Darüber hinaus gibt es einige entfernte Punkte, die wahrscheinlich von der Hauptdatenverteilung abweichen und weitere Herausforderungen mit sich bringen oder Lärm bei der Bestimmung der Gruppen.

Ein dichtebasierter Algorithmus, der Rauschen herausfiltern kann, wie z DBSCAN (Ddichte-Based Steilweise CGlanz von AAnwendungen mit Noise) ist eine gute Wahl für Situationen mit dichteren Bereichen, abgerundeten Formen und Rauschen.

Über DBSCAN

DBSCAN ist einer der am häufigsten zitierten Algorithmen in der Forschung, seine erste Veröffentlichung erscheint 1996, dies ist der Original DBSCAN-Papier. In dem Papier demonstrieren die Forscher, wie der Algorithmus nichtlineare räumliche Cluster identifizieren und Daten mit höheren Dimensionen effizient verarbeiten kann.

Die Hauptidee hinter DBSCAN ist, dass es eine Mindestanzahl von Punkten gibt, die sich innerhalb einer bestimmten Entfernung oder befinden radius vom „zentralsten“ Clusterpunkt, genannt Kernpunkt. Die Punkte innerhalb dieses Radius sind die Nachbarschaftspunkte, und die Punkte am Rand dieser Nachbarschaft sind die Grenzpunkte or Grenzpunkte. Der Radius oder Nachbarschaftsabstand wird genannt Epsilon-Viertel, ε-Nachbarschaft oder einfach nur ε (das Symbol für den griechischen Buchstaben Epsilon).

Wenn es Punkte gibt, die keine Kernpunkte oder Grenzpunkte sind, weil sie den Radius für die Zugehörigkeit zu einem bestimmten Cluster überschreiten und auch nicht die Mindestanzahl von Punkten haben, um ein Kernpunkt zu sein, werden sie berücksichtigt Geräuschpunkte.

Das bedeutet, dass wir drei verschiedene Arten von Punkten haben, nämlich Core, Grenze und Lärm. Darüber hinaus ist es wichtig zu beachten, dass die Hauptidee grundsätzlich auf einem Radius oder einer Entfernung basiert, wodurch DBSCAN – wie die meisten Clustering-Modelle – von dieser Entfernungsmetrik abhängig ist. Diese Metrik könnte euklidisch, Manhattan, Mahalanobis und viele mehr sein. Daher ist es entscheidend, eine geeignete Entfernungsmetrik zu wählen, die den Kontext der Daten berücksichtigt. Wenn Sie beispielsweise Fahrstreckendaten von einem GPS verwenden, kann es interessant sein, eine Metrik zu verwenden, die die Straßenlayouts berücksichtigt, z. B. Manhattan-Entfernung.

Um den Kernpunkt zu finden, wählt DBSCAN zunächst einen zufälligen Punkt aus, bildet alle Punkte innerhalb seiner ε-Nachbarschaft ab und vergleicht die Anzahl der Nachbarn des ausgewählten Punkts mit der minimalen Anzahl von Punkten. Wenn der ausgewählte Punkt die gleiche Anzahl oder mehr Nachbarn als die Mindestanzahl von Punkten hat, wird er als Kernpunkt markiert. Dieser Kernpunkt und seine Nachbarschaftspunkte bilden den ersten Cluster.

Der Algorithmus untersucht dann jeden Punkt des ersten Clusters und sieht, ob er eine gleiche Anzahl oder mehr Nachbarpunkte als die Mindestanzahl von Punkten innerhalb von ε hat. Wenn dies der Fall ist, werden diese Nachbarpunkte auch dem ersten Cluster hinzugefügt. Dieser Prozess wird fortgesetzt, bis die Punkte des ersten Clusters weniger Nachbarn haben als die minimale Anzahl von Punkten innerhalb von ε. In diesem Fall beendet der Algorithmus das Hinzufügen von Punkten zu diesem Cluster, identifiziert einen anderen Kernpunkt außerhalb dieses Clusters und erstellt einen neuen Cluster für diesen neuen Kernpunkt.

DBSCAN wiederholt dann den ersten Cluster-Prozess zum Finden aller Punkte, die mit einem neuen Kernpunkt des zweiten Clusters verbunden sind, bis es keine weiteren Punkte mehr gibt, die zu diesem Cluster hinzugefügt werden müssen. Es wird dann auf einen anderen Kernpunkt stoßen und einen dritten Cluster erstellen, oder es wird alle Punkte durchlaufen, die es zuvor nicht betrachtet hat. Wenn diese Punkte im Abstand ε von einem Cluster liegen, werden sie diesem Cluster hinzugefügt und werden zu Grenzpunkten. Wenn dies nicht der Fall ist, werden sie als Rauschpunkte betrachtet.

Es ist interessant zu wissen, wie der DBSCAN-Algorithmus funktioniert, obwohl es glücklicherweise nicht nötig ist, den Algorithmus zu codieren, da Pythons Scikit-Learn-Bibliothek bereits eine Implementierung hat.

Mal sehen, wie es in der Praxis funktioniert!

Importieren von Daten für Clustering

Um zu sehen, wie DBSCAN in der Praxis funktioniert, werden wir Projekte ein wenig ändern und einen kleinen Kundendatensatz verwenden, der das Genre, das Alter, das Jahreseinkommen und die Ausgabenbewertung von 200 Kunden enthält.

Der Spending Score reicht von 0 bis 100 und stellt auf einer Skala von 1 bis 100 dar, wie oft eine Person Geld in einem Einkaufszentrum ausgibt. Mit anderen Worten, wenn ein Kunde einen Score von 0 hat, gibt er nie Geld aus, und wenn der Score ist 100, sie sind die höchsten Ausgaben.

Nach dem Herunterladen des Datensatzes sehen Sie, dass es sich um eine CSV-Datei (Comma-Separated Values) handelt Einkaufsdaten.csv, laden wir es mit Pandas in einen DataFrame und speichern es in der customer_data Variable:

import pandas as pd path_to_file = '../../datasets/dbscan/dbscan-with-python-and-scikit-learn-shopping-data.csv'
customer_data = pd.read_csv(path_to_file)

Um einen Blick auf die ersten fünf Zeilen unserer Daten zu werfen, können Sie ausführen customer_data.head():

Das führt zu:

 CustomerID Genre Age Annual Income (k$) Spending Score (1-100)
0 1 Male 19 15 39
1 2 Male 21 15 81
2 3 Female 20 16 6
3 4 Female 23 16 77
4 5 Female 31 17 40

Durch die Untersuchung der Daten können wir Kunden-ID-Nummern, Genre, Alter, Einkommen in k$ und Ausgabenwerte sehen. Beachten Sie, dass einige oder alle dieser Variablen im Modell verwendet werden. Zum Beispiel, wenn wir verwenden würden Age und Spending Score (1-100) Als Variablen für DBSCAN, das eine Entfernungsmetrik verwendet, ist es wichtig, sie auf eine gemeinsame Skala zu bringen, um seitdem Verzerrungen zu vermeiden Age wird in Jahren und gemessen Spending Score (1-100) hat einen begrenzten Bereich von 0 bis 100. Das bedeutet, dass wir eine Art Datenskalierung durchführen.

Wir können auch prüfen, ob die Daten neben der Skalierung noch weiter vorverarbeitet werden müssen, indem wir prüfen, ob der Datentyp konsistent ist, und überprüfen, ob es fehlende Werte gibt, die behandelt werden müssen, indem wir Pandas ausführen info() Verfahren:

customer_data.info()

Dies zeigt:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 5 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 CustomerID 200 non-null int64 1 Genre 200 non-null object 2 Age 200 non-null int64 3 Annual Income (k$) 200 non-null int64 4 Spending Score (1-100) 200 non-null int64 dtypes: int64(4), object(1)
memory usage: 7.9+ KB

Wir können beobachten, dass es keine fehlenden Werte gibt, weil es 200 Nicht-Null-Einträge für jedes Kundenmerkmal gibt. Wir können auch sehen, dass nur die Genre-Spalte Textinhalt hat, da es sich um eine kategoriale Variable handelt, die als angezeigt wird object, und alle anderen Merkmale sind numerisch vom Typ int64. Somit sind unsere Daten in Bezug auf die Datentypkonsistenz und das Fehlen von Nullwerten bereit für die weitere Analyse.

Wir können mit der Visualisierung der Daten fortfahren und bestimmen, welche Funktionen für die Verwendung in DBSCAN interessant wären. Nachdem wir diese Features ausgewählt haben, können wir sie skalieren.

Dieser Kundendatensatz ist der gleiche wie der, der in unserem endgültigen Leitfaden zum hierarchischen Clustering verwendet wird. Um mehr über diese Daten zu erfahren, wie man sie untersucht, und über Entfernungsmetriken, können Sie einen Blick auf werfen Endgültiger Leitfaden für hierarchisches Clustering mit Python und Scikit-Learn!

Daten visualisieren

Durch die Verwendung von Seaborn pairplot(), können wir für jede Merkmalskombination ein Streudiagramm zeichnen. Seit CustomerID nur eine Kennzeichnung und kein Feature ist, werden wir es mit entfernen drop() vor dem plotten:

import seaborn as sns customer_data = customer_data.drop('CustomerID', axis=1) sns.pairplot(customer_data);

Dies gibt aus:

Wenn man sich die Kombination von Merkmalen ansieht, die von erzeugt werden pairplot, der Graph von Annual Income (k$) mit Spending Score (1-100) scheint ungefähr 5 Gruppen von Punkten anzuzeigen. Dies scheint die vielversprechendste Kombination von Funktionen zu sein. Wir können eine Liste mit ihren Namen erstellen, sie aus der auswählen customer_data DataFrame, und speichern Sie die Auswahl in der customer_data wieder variabel zur Verwendung in unserem zukünftigen Modell.

selected_cols = ['Annual Income (k$)', 'Spending Score (1-100)']
customer_data = customer_data[selected_cols]

Nach Auswahl der Spalten können wir die im vorherigen Abschnitt besprochene Skalierung durchführen. Um die Features auf den gleichen Maßstab zu bringen bzw standardisieren ihnen können wir Scikit-Learns importieren StandardScaler, erstellen Sie es, passen Sie unsere Daten an, um den Mittelwert und die Standardabweichung zu berechnen, und transformieren Sie die Daten, indem Sie den Mittelwert subtrahieren und durch die Standardabweichung dividieren. Dies kann in einem Schritt mit dem erfolgen fit_transform() Verfahren:

from sklearn.preprocessing import StandardScaler ss = StandardScaler() scaled_data = ss.fit_transform(customer_data)

Die Variablen sind jetzt skaliert, und wir können sie untersuchen, indem wir einfach den Inhalt von ausgeben scaled_data Variable. Alternativ können wir sie auch zu einer neuen hinzufügen scaled_customer_data DataFrame zusammen mit Spaltennamen und verwenden Sie die head() Methode nochmal:

scaled_customer_data = pd.DataFrame(columns=selected_cols, data=scaled_data)
scaled_customer_data.head()

Dies gibt aus:

 Annual Income (k$) Spending Score (1-100)
0 -1.738999 -0.434801
1 -1.738999 1.195704
2 -1.700830 -1.715913
3 -1.700830 1.040418
4 -1.662660 -0.395980 

Diese Daten sind bereit für das Clustering! Bei der Einführung von DBSCAN haben wir die Mindestpunktzahl und das Epsilon erwähnt. Diese beiden Werte müssen vor dem Erstellen des Modells ausgewählt werden. Mal sehen, wie es gemacht wird.

Auswahl min. Proben und Epsilon

Um die Mindestpunktzahl für das DBSCAN-Clustering auszuwählen, gibt es eine Faustregel, die besagt, dass sie gleich oder höher als die Anzahl der Dimensionen in den Daten plus eins sein muss, wie in:

$$
Text {mind. Punkte} >= Text{Datendimensionen} + 1
$$

Die Dimensionen sind die Anzahl der Spalten im Datenrahmen, wir verwenden 2 Spalten, also die min. Punkte sollten entweder 2+1, also 3, oder höher sein. Lassen Sie uns für dieses Beispiel verwenden 5 Minuten. Punkte.

$$
Text{5 (min. Punkte)} >= Text{2 (Datendimensionen)} + 1
$$

Nun, um den Wert für ε zu wählen, gibt es ein Verfahren, bei dem a Nächste Nachbarn Algorithmus wird verwendet, um die Entfernungen einer vordefinierten Anzahl von nächstgelegenen Punkten für jeden Punkt zu finden. Diese vordefinierte Anzahl von Nachbarn ist die min. Punkte, die wir gerade ausgewählt haben, minus 1. In unserem Fall findet der Algorithmus also die 5-1 oder 4 nächsten Punkte für jeden Punkt unserer Daten. das sind die k-Nachbarn und unseren k entspricht 4.

$$
Text{k-Nachbarn} = Text{min. Punkte} – 1
$$

Nachdem wir die Nachbarn gefunden haben, ordnen wir ihre Abstände vom größten zum kleinsten und zeichnen die Abstände auf der y-Achse und die Punkte auf der x-Achse auf. Wenn wir uns das Diagramm ansehen, werden wir feststellen, wo es der Beugung eines Ellbogens ähnelt, und der Punkt auf der y-Achse, der diese Beugung des Ellbogens beschreibt, ist der vorgeschlagene ε-Wert.

Um diese Schritte auszuführen, können wir den Algorithmus importieren, ihn an die Daten anpassen und dann die Entfernungen und Indizes jedes Punkts extrahieren kneighbors() Verfahren:

from sklearn.neighbors import NearestNeighbors
import numpy as np nn = NearestNeighbors(n_neighbors=4) nbrs = nn.fit(scaled_customer_data)
distances, indices = nbrs.kneighbors(scaled_customer_data)

Nachdem wir die Entfernungen gefunden haben, können wir sie vom größten zum kleinsten sortieren. Da die erste Spalte des Abstands-Arrays der Punkt zu sich selbst ist (was bedeutet, dass alle 0 sind) und die zweite Spalte die kleinsten Abstände enthält, gefolgt von der dritten Spalte, die größere Abstände als die zweite hat, und so weiter, können wir nur die auswählen Werte der zweiten Spalte und speichern Sie sie in der distances Variable:

distances = np.sort(distances, axis=0)
distances = distances[:,1] 

Nachdem wir nun unsere sortierten kleinsten Entfernungen haben, können wir importieren matplotlib, zeichnen Sie die Abstände auf und zeichnen Sie eine rote Linie an der Stelle, an der sich die „Ellbogenbeuge“ befindet:

import matplotlib.pyplot as plt plt.figure(figsize=(6,3))
plt.plot(distances)
plt.axhline(y=0.24, color='r', linestyle='--', alpha=0.4) plt.title('Kneighbors distance graph')
plt.xlabel('Data points')
plt.ylabel('Epsilon value')
plt.show();

Das ist das Ergebnis:

Beachten Sie, dass wir beim Zeichnen der Linie den ε-Wert herausfinden, in diesem Fall ist es 0.24.

Endlich haben wir unsere Mindestpunkte und ε. Mit beiden Variablen können wir das DBSCAN-Modell erstellen und ausführen.

Erstellen eines DBSCAN-Modells

Um das Modell zu erstellen, können wir es aus Scikit-Learn importieren, es mit ε erstellen, was dasselbe wie das ist eps Argument, und das Minimum an Punkten, die die ist mean_samples Streit. Wir können es dann in einer Variablen speichern, nennen wir es dbs und passen Sie es an die skalierten Daten an:

from sklearn.cluster import DBSCAN dbs = DBSCAN(eps=0.24, min_samples=5)
dbs.fit(scaled_customer_data)

So wurde unser DBSCAN-Modell erstellt und mit den Daten trainiert! Um die Ergebnisse zu extrahieren, greifen wir auf die labels_ Eigentum. Wir können auch eine neue erstellen labels Spalte in der scaled_customer_data Datenrahmen und füllen Sie ihn mit den vorhergesagten Beschriftungen:

labels = dbs.labels_ scaled_customer_data['labels'] = labels
scaled_customer_data.head()

Das ist das Endergebnis:

 Annual Income (k$) Spending Score (1-100) labels
0 -1.738999 -0.434801 -1
1 -1.738999 1.195704 0
2 -1.700830 -1.715913 -1
3 -1.700830 1.040418 0
4 -1.662660 -0.395980 -1

Beachten Sie, dass wir Etiketten mit haben -1 Werte; Dies sind die Geräuschpunkte, die zu keinem Cluster gehören. Um zu wissen, wie viele Rauschpunkte der Algorithmus gefunden hat, können wir zählen, wie oft der Wert -1 in unserer Etikettenliste erscheint:

labels_list = list(scaled_customer_data['labels'])
n_noise = labels_list.count(-1)
print("Number of noise points:", n_noise)

Dies gibt aus:

Number of noise points: 62

Wir wissen bereits, dass 62 Punkte unserer ursprünglichen Daten von 200 Punkten als Rauschen angesehen wurden. Das ist viel Rauschen, was darauf hindeutet, dass das DBSCAN-Clustering vielleicht nicht viele Punkte als Teil eines Clusters berücksichtigt hat. Wir werden bald verstehen, was passiert ist, wenn wir die Daten grafisch darstellen.

Als wir die Daten zunächst beobachteten, schienen sie 5 Punktcluster zu haben. Um zu wissen, wie viele Cluster DBSCAN gebildet hat, können wir die Anzahl der Labels zählen, die nicht -1 sind. Es gibt viele Möglichkeiten, diesen Code zu schreiben; hier haben wir eine for-Schleife geschrieben, die auch für Daten funktioniert, in denen DBSCAN viele Cluster gefunden hat:

total_labels = np.unique(labels) n_labels = 0
for n in total_labels: if n != -1: n_labels += 1
print("Number of clusters:", n_labels)

Dies gibt aus:

Number of clusters: 6

Wir können sehen, dass der Algorithmus die Daten mit 6 Clustern mit vielen Rauschpunkten vorhergesagt hat. Lassen Sie uns das visualisieren, indem wir es mit Seaborn darstellen scatterplot:

sns.scatterplot(data=scaled_customer_data, x='Annual Income (k$)', y='Spending Score (1-100)', hue='labels', palette='muted').set_title('DBSCAN found clusters');

Das führt zu:

Wenn wir uns das Diagramm ansehen, können wir sehen, dass DBSCAN die Punkte erfasst hat, die dichter verbunden waren, und Punkte, die als Teil desselben Clusters betrachtet werden könnten, waren entweder Rauschen oder wurden als ein weiterer kleinerer Cluster betrachtet.

Wenn wir die Cluster hervorheben, beachten Sie, wie DBSCAN Cluster 1 vollständig erhält, das ist der Cluster mit weniger Platz zwischen den Punkten. Dann erhält es die Teile der Cluster 0 und 3, wo die Punkte eng beieinander liegen, wobei Punkte mit größerem Abstand als Rauschen betrachtet werden. Es betrachtet auch die Punkte in der unteren linken Hälfte als Rauschen und teilt die Punkte in der unteren rechten Hälfte in 3 Cluster, wobei wiederum die Cluster 4, 2 und 5 erfasst werden, wo die Punkte näher beieinander liegen.

Wir können zu dem Schluss kommen, dass DBSCAN großartig war, um die dichten Bereiche der Cluster zu erfassen, aber nicht so sehr, um das größere Schema der Daten, die Abgrenzungen der 5 Cluster, zu identifizieren. Es wäre interessant, weitere Clustering-Algorithmen mit unseren Daten zu testen. Mal sehen, ob eine Metrik diese Hypothese bestätigt.

Bewertung des Algorithmus

Um DBSCAN auszuwerten, verwenden wir die Silhouettenpunktzahl die den Abstand zwischen Punkten eines gleichen Clusters und die Abstände zwischen Clustern berücksichtigt.

Erstens können wir importieren silhouette_score von Scikit-Learn, übergeben Sie es dann an unsere Spalten und Beschriftungen:

from sklearn.metrics import silhouette_score s_score = silhouette_score(scaled_customer_data, labels)
print(f"Silhouette coefficient: {s_score:.3f}")

Dies gibt aus:

Silhouette coefficient: 0.506

Gemäß dieser Punktzahl scheint DBSCAN etwa 50 % der Daten erfassen zu können.

Zusammenfassung

DBSCAN Vor- und Nachteile

DBSCAN ist ein sehr einzigartiger Clustering-Algorithmus oder -Modell.

Wenn wir uns seine Vorteile ansehen, ist es sehr gut, dichte Bereiche in Daten und Punkten zu erfassen, die weit von anderen entfernt sind. Das bedeutet, dass die Daten keine bestimmte Form haben müssen und von anderen Punkten umgeben sein können, solange sie auch dicht verbunden sind.

Es erfordert, dass wir Mindestpunkte und ε angeben, aber es ist nicht notwendig, die Anzahl der Cluster vorher anzugeben, wie zum Beispiel in K-Means. Es kann auch mit sehr großen Datenbanken verwendet werden, da es für hochdimensionale Daten konzipiert wurde.

Was seine Nachteile betrifft, so haben wir gesehen, dass es keine unterschiedlichen Dichten im selben Cluster erfassen konnte, sodass es bei großen Dichteunterschieden schwer ist. Sie ist auch abhängig von der Entfernungsmetrik und Skalierung der Punkte. Das heißt, wenn die Daten nicht gut verstanden werden, mit Unterschieden im Maßstab und mit einer Distanzmetrik, die keinen Sinn ergibt, werden sie sie wahrscheinlich nicht verstehen.

DBSCAN-Erweiterungen

Es gibt andere Algorithmen, wie z Hierarchischer DBSCAN (HDBSCAN) und Bestellpunkte zur Identifizierung der Clusterstruktur (OPTICS), die als Erweiterungen von DBSCAN gelten.

Sowohl HDBSCAN als auch OPTICS können in der Regel eine bessere Leistung erbringen, wenn Cluster unterschiedlicher Dichte in den Daten vorhanden sind, und sind auch weniger empfindlich gegenüber der Auswahl oder dem anfänglichen Mindestwert. Punkte und ε Parameter.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• Platoblockkette. Web3-Metaverse-Intelligenz. Wissen verstärkt. Hier zugreifen.
• Quelle: https://stackabuse.com/dbscan-with-scikit-learn-in-python/