OPTICS-Clustering-Algorithmus

Einführung

In diesem Lab wird die Verwendung des OPTICS-Clustering-Algorithmus mit der scikit-learn-Bibliothek demonstriert. OPTICS ist die Abkürzung für Ordering Points To Identify the Clustering Structure. Es ist ein auf Dichte basierender Clustering-Algorithmus, der Kernproben hoher Dichte findet und daraus Cluster erweitert. In diesem Lab werden wir Beispiel-Daten generieren, das Reachability-Plot erstellen und DBSCAN verwenden, um die Daten zu gruppieren.

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 öffnen.

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.

Skills Graph

Bibliotheken importieren

Wir beginnen mit dem Import der erforderlichen Bibliotheken für dieses Lab - numpy, matplotlib.pyplot sowie OPTICS und cluster_optics_dbscan aus scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import OPTICS, cluster_optics_dbscan

Beispiel-Daten generieren

Wir werden Beispiel-Daten für das Clustering generieren. In diesem Beispiel generieren wir sechs Cluster mit unterschiedlicher Dichte mithilfe von numpy.

np.random.seed(0)
n_points_per_cluster = 250

C1 = [-5, -2] + 0.8 * np.random.randn(n_points_per_cluster, 2)
C2 = [4, -1] + 0.1 * np.random.randn(n_points_per_cluster, 2)
C3 = [1, -2] + 0.2 * np.random.randn(n_points_per_cluster, 2)
C4 = [-2, 3] + 0.3 * np.random.randn(n_points_per_cluster, 2)
C5 = [3, -2] + 1.6 * np.random.randn(n_points_per_cluster, 2)
C6 = [5, 6] + 2 * np.random.randn(n_points_per_cluster, 2)
X = np.vstack((C1, C2, C3, C4, C5, C6))

OPTICS-Clustering-Algorithmus ausführen

Wir werden nun den OPTICS-Clustering-Algorithmus auf den generierten Daten ausführen. In diesem Beispiel setzen wir min_samples=50, xi=0.05 und min_cluster_size=0.05.

clust = OPTICS(min_samples=50, xi=0.05, min_cluster_size=0.05)
clust.fit(X)

Daten mit DBSCAN gruppieren

Wir werden die Daten mit DBSCAN bei verschiedenen Epsilon-Werten gruppieren. In diesem Beispiel setzen wir Epsilon auf 0,5 und 2.

labels_050 = cluster_optics_dbscan(
    reachability=clust.reachability_,
    core_distances=clust.core_distances_,
    ordering=clust.ordering_,
    eps=0.5,
)
labels_200 = cluster_optics_dbscan(
    reachability=clust.reachability_,
    core_distances=clust.core_distances_,
    ordering=clust.ordering_,
    eps=2,
)

Reachability-Plot und Clustering-Ergebnisse plotten

Wir werden den Reachability-Plot und die Clustering-Ergebnisse für OPTICS und DBSCAN bei verschiedenen Epsilon-Werten plotten.

space = np.arange(len(X))
reachability = clust.reachability_[clust.ordering_]
labels = clust.labels_[clust.ordering_]

plt.figure(figsize=(10, 7))
G = gridspec.GridSpec(2, 3)
ax1 = plt.subplot(G[0, :])
ax2 = plt.subplot(G[1, 0])
ax3 = plt.subplot(G[1, 1])
ax4 = plt.subplot(G[1, 2])

## Reachability-Plot
colors = ["g.", "r.", "b.", "y.", "c."]
for klass, color in zip(range(0, 5), colors):
    Xk = space[labels == klass]
    Rk = reachability[labels == klass]
    ax1.plot(Xk, Rk, color, alpha=0.3)
ax1.plot(space[labels == -1], reachability[labels == -1], "k.", alpha=0.3)
ax1.plot(space, np.full_like(space, 2.0, dtype=float), "k-", alpha=0.5)
ax1.plot(space, np.full_like(space, 0.5, dtype=float), "k-.", alpha=0.5)
ax1.set_ylabel("Reachability (epsilon distance)")
ax1.set_title("Reachability-Plot")

## OPTICS
colors = ["g.", "r.", "b.", "y.", "c."]
for klass, color in zip(range(0, 5), colors):
    Xk = X[clust.labels_ == klass]
    ax2.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax2.plot(X[clust.labels_ == -1, 0], X[clust.labels_ == -1, 1], "k+", alpha=0.1)
ax2.set_title("Automatisches Clustering\nOPTICS")

## DBSCAN bei 0.5
colors = ["g.", "r.", "b.", "c."]
for klass, color in zip(range(0, 4), colors):
    Xk = X[labels_050 == klass]
    ax3.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax3.plot(X[labels_050 == -1, 0], X[labels_050 == -1, 1], "k+", alpha=0.1)
ax3.set_title("Clustering bei 0.5 epsilon-Schnitt\nDBSCAN")

## DBSCAN bei 2.
colors = ["g.", "m.", "y.", "c."]
for klass, color in zip(range(0, 4), colors):
    Xk = X[labels_200 == klass]
    ax4.plot(Xk[:, 0], Xk[:, 1], color, alpha=0.3)
ax4.plot(X[labels_200 == -1, 0], X[labels_200 == -1, 1], "k+", alpha=0.1)
ax4.set_title("Clustering bei 2.0 epsilon-Schnitt\nDBSCAN")

plt.tight_layout()
plt.show()

注：代码中的gridspec未翻译，因为它是Python中特定的模块名，一般保留英文更合适。

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den OPTICS-Clustering-Algorithmus verwendet, um Daten zu gruppieren, und wie man DBSCAN verwendet, um die Daten bei verschiedenen Epsilon-Werten zu gruppieren. Wir haben auch gelernt, wie man den Reachability-Plot und die Clustering-Ergebnisse plotten.