DBSCAN-Clustering-Algorithmus

Einführung

In diesem Lab verwenden wir den DBSCAN (Density-Based Spatial Clustering of Applications with Noise)-Algorithmus, um einen synthetischen Datensatz zu gruppieren. DBSCAN ist ein Clustering-Algorithmus, der Kernpunkte in Gebieten hoher Dichte identifiziert und von ihnen ausgehende Cluster erweitert. Dieser Algorithmus eignet sich für Daten, die Cluster ähnlicher Dichte enthalten.

VM-Tipps

Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Datenerzeugung

Wir werden die make_blobs-Funktion aus dem sklearn.datasets-Modul verwenden, um einen synthetischen Datensatz mit drei Clustern zu generieren. Der Datensatz wird aus 750 Proben bestehen, wobei die Clusterstandardabweichung 0,4 beträgt. Wir werden die Daten auch mithilfe des StandardScaler aus dem sklearn.preprocessing-Modul standardisieren.

from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler

centers = [[1, 1], [-1, -1], [1, -1]]
X, labels_true = make_blobs(
    n_samples=750, centers=centers, cluster_std=0.4, random_state=0
)

X = StandardScaler().fit_transform(X)

Datenvisualisierung

Wir können die resultierenden Daten mit dem matplotlib.pyplot-Modul visualisieren.

import matplotlib.pyplot as plt

plt.scatter(X[:, 0], X[:, 1])
plt.show()

DBSCAN berechnen

Wir werden die DBSCAN-Klasse aus dem sklearn.cluster-Modul verwenden, um die Cluster zu berechnen. Wir werden den eps-Parameter auf 0,3 und den min_samples-Parameter auf 10 setzen. Wir können die von DBSCAN zugewiesenen Labels über das labels-Attribut zugreifen. Rauschproben erhalten das Label -1. Wir werden auch die Anzahl der Cluster und die Anzahl der Rauschpunkte berechnen.

import numpy as np
from sklearn.cluster import DBSCAN
from sklearn import metrics

db = DBSCAN(eps=0.3, min_samples=10).fit(X)
labels = db.labels_

n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
n_noise_ = list(labels).count(-1)

print("Estimated number of clusters: %d" % n_clusters_)
print("Estimated number of noise points: %d" % n_noise_)

Evaluationsmetriken

Wir können Evaluationsmetriken verwenden, um die Qualität der resultierenden Cluster zu quantifizieren. Wir werden die Homogenität, Vollständigkeit, V-Maß, angepassten Randindex, angepasste gegenseitige Information und Silhouettenkoeffizient-Metriken verwenden. Wir werden diese Metriken aus dem sklearn.metrics-Modul zugreifen. Wenn die wahren Labels unbekannt sind, kann die Evaluation nur mithilfe der Modellresultate selbst durchgeführt werden. In diesem Fall kommt der Silhouettenkoeffizient sehr praktisch.

print(f"Homogenität: {metrics.homogeneity_score(labels_true, labels):.3f}")
print(f"Vollständigkeit: {metrics.completeness_score(labels_true, labels):.3f}")
print(f"V-Maß: {metrics.v_measure_score(labels_true, labels):.3f}")
print(f"Angepasster Randindex: {metrics.adjusted_rand_score(labels_true, labels):.3f}")
print(f"Angepasste gegenseitige Information: {metrics.adjusted_mutual_info_score(labels_true, labels):.3f}")
print(f"Silhouettenkoeffizient: {metrics.silhouette_score(X, labels):.3f}")

Ergebnisse plotten

Wir werden das matplotlib.pyplot-Modul verwenden, um die Ergebnisse zu plotten. Kerndatenpunkte (große Punkte) und Nicht-Kerndatenpunkte (kleine Punkte) werden entsprechend dem zugewiesenen Cluster farblich kodiert. Datenpunkte, die als Rausch markiert sind, werden in Schwarz dargestellt.

unique_labels = set(labels)
core_samples_mask = np.zeros_like(labels, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True

colors = [plt.cm.Spectral(each) for each in np.linspace(0, 1, len(unique_labels))]
for k, col in zip(unique_labels, colors):
    if k == -1:
        col = [0, 0, 0, 1]

    class_member_mask = labels == k

    xy = X[class_member_mask & core_samples_mask]
    plt.plot(
        xy[:, 0],
        xy[:, 1],
        "o",
        markerfacecolor=tuple(col),
        markeredgecolor="k",
        markersize=14,
    )

    xy = X[class_member_mask & ~core_samples_mask]
    plt.plot(
        xy[:, 0],
        xy[:, 1],
        "o",
        markerfacecolor=tuple(col),
        markeredgecolor="k",
        markersize=6,
    )

plt.title(f"Geschätzte Anzahl der Cluster: {n_clusters_}")
plt.show()

Zusammenfassung

In diesem Lab haben wir den DBSCAN-Clustering-Algorithmus verwendet, um einen synthetischen Datensatz zu gruppieren. Wir haben einen Datensatz erzeugt, die Daten visualisiert, die Cluster berechnet, die Metriken ausgewertet und die Ergebnisse geplottet.