Entdecken des HDBSCAN-Clustering-Algorithmus

Einführung

In diesem Lab werden wir das HDBSCAN-Clustering-Algorithmus kennenlernen, der eine Verbesserung gegenüber dem DBSCAN-Algorithmus ist. Wir werden beide Algorithmen auf bestimmten Datensätzen vergleichen und die Empfindlichkeit von HDBSCAN gegenüber bestimmten Hyperparametern evaluieren.

Tipps für die VM

Nachdem der VM-Start abgeschlossen 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 der 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.

Importieren erforderlicher Bibliotheken und Generieren von Beispiel-Daten

Wir werden zunächst die erforderlichen Bibliotheken importieren und Beispiel-Daten generieren. Wir werden einen Datensatz aus einer Mischung von drei zweidimensionalen und isotropen Gauß-Verteilungen erstellen.

import numpy as np
from sklearn.cluster import HDBSCAN, DBSCAN
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

centers = [[1, 1], [-1, -1], [1.5, -1.5]]
X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=[0.4, 0.1, 0.75], random_state=0)
plt.scatter(X[:,0], X[:,1])
plt.show()

Skaleninvarianz

Wir werden zeigen, dass HDBSCAN im Gegensatz zu DBSCAN skaleninvariant ist. DBSCAN erfordert, dass der Parameter eps für den spezifischen zu verwendenden Datensatz eingestellt wird. Wir werden die Clusterung vergleichen, die mit dem gleichen Wert erhalten wird, aber auf skalierten Versionen des Datensatzes angewendet wird.

fig, axes = plt.subplots(3, 1, figsize=(10, 12))
dbs = DBSCAN(eps=0.3)
for idx, scale in enumerate((1, 0.5, 3)):
    dbs.fit(X * scale)
    plot(X * scale, dbs.labels_, parameters={"scale": scale, "eps": 0.3}, ax=axes[idx])

fig, axis = plt.subplots(1, 1, figsize=(12, 5))
dbs = DBSCAN(eps=0.9).fit(3 * X)
plot(3 * X, dbs.labels_, parameters={"scale": 3, "eps": 0.9}, ax=axis)

fig, axes = plt.subplots(3, 1, figsize=(10, 12))
hdb = HDBSCAN()
for idx, scale in enumerate((1, 0.5, 3)):
    hdb.fit(X)
    plot(X, hdb.labels_, hdb.probabilities_, ax=axes[idx], parameters={"scale": scale})

Mehrskalen-Clustering

Wir werden zeigen, dass HDBSCAN in der Lage ist, Mehrskalen-Clustering durchzuführen, was Cluster mit unterschiedlicher Dichte berücksichtigt. Traditionelles DBSCAN geht davon aus, dass alle potenziellen Cluster in ihrer Dichte homogen sind.

centers = [[-0.85, -0.85], [-0.85, 0.85], [3, 3], [3, -3]]
X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=[0.2, 0.35, 1.35, 1.35], random_state=0)

fig, axes = plt.subplots(2, 1, figsize=(10, 8))
params = {"eps": 0.7}
dbs = DBSCAN(**params).fit(X)
plot(X, dbs.labels_, parameters=params, ax=axes[0])
params = {"eps": 0.3}
dbs = DBSCAN(**params).fit(X)
plot(X, dbs.labels_, parameters=params, ax=axes[1])

hdb = HDBSCAN().fit(X)
plot(X, hdb.labels_, hdb.probabilities_)

Hyperparameter-Robustheit

Wir werden zeigen, dass HDBSCAN dank der Parameter min_cluster_size und min_samples, deren klare Bedeutung es erleichtert, sie zu optimieren, relativ robust gegenüber verschiedenen realen Beispielen ist.

PARAM = ({"min_cluster_size": 5}, {"min_cluster_size": 3}, {"min_cluster_size": 25})
fig, axes = plt.subplots(3, 1, figsize=(10, 12))
for i, param in enumerate(PARAM):
    hdb = HDBSCAN(**param).fit(X)
    labels = hdb.labels_

    plot(X, labels, hdb.probabilities_, param, ax=axes[i])

PARAM = (
    {"min_cluster_size": 20, "min_samples": 5},
    {"min_cluster_size": 20, "min_samples": 3},
    {"min_cluster_size": 20, "min_samples": 25},
)
fig, axes = plt.subplots(3, 1, figsize=(10, 12))
for i, param in enumerate(PARAM):
    hdb = HDBSCAN(**param).fit(X)
    labels = hdb.labels_

    plot(X, labels, hdb.probabilities_, param, ax=axes[i])

PARAM = (
    {"cut_distance": 0.1},
    {"cut_distance": 0.5},
    {"cut_distance": 1.0},
)
hdb = HDBSCAN()
hdb.fit(X)
fig, axes = plt.subplots(len(PARAM), 1, figsize=(10, 12))
for i, param in enumerate(PARAM):
    labels = hdb.dbscan_clustering(**param)

    plot(X, labels, hdb.probabilities_, param, ax=axes[i])

Zusammenfassung

In diesem Lab haben wir uns mit dem HDBSCAN-Clustering-Algorithmus und seinen Vorteilen gegenüber dem DBSCAN-Algorithmus beschäftigt. Wir haben gesehen, dass HDBSCAN skaleninvariant ist, in der Lage zu Mehrskalen-Clustering und aufgrund der Parameter min_cluster_size und min_samples relativ robust gegenüber verschiedenen realen Beispielen ist.

Demo des HDBSCAN-Clustering-Algorithmus