Vergleich von BIRCH und MiniBatchKMeans

Einführung

In diesem Lab werden die Laufzeiten zweier Clustering-Algorithmen, BIRCH und MiniBatchKMeans, auf einem synthetischen Datensatz verglichen. Beide Algorithmen sind skalierbar und können große Datensätze effizient clusteren. Der synthetische Datensatz hat 25.000 Samples und zwei Merkmale, die mit make_blobs erzeugt wurden.

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 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

Bibliotheken importieren

Der erste Schritt besteht darin, die erforderlichen Bibliotheken zu importieren. Wir werden die folgenden Bibliotheken importieren:

• numpy
• matplotlib
• sklearn

from joblib import cpu_count
from itertools import cycle
from time import time
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors

from sklearn.cluster import Birch, MiniBatchKMeans
from sklearn.datasets import make_blobs

Blobs generieren

Als nächster Schritt werden Blobs generiert, um einen Vergleich zwischen MiniBatchKMeans und BIRCH durchzuführen. Wir werden alle Farben verwenden, die matplotlib standardmäßig zur Verfügung stellt.

## Generate centers for the blobs so that it forms a 10 X 10 grid.
xx = np.linspace(-22, 22, 10)
yy = np.linspace(-22, 22, 10)
xx, yy = np.meshgrid(xx, yy)
n_centers = np.hstack((np.ravel(xx)[:, np.newaxis], np.ravel(yy)[:, np.newaxis]))

## Generate blobs to do a comparison between MiniBatchKMeans and BIRCH.
X, y = make_blobs(n_samples=25000, centers=n_centers, random_state=0)

## Use all colors that matplotlib provides by default.
colors_ = cycle(colors.cnames.keys())

Birch-Modell

Als dritten Schritt wird die Clustering- Berechnung mit BIRCH mit und ohne den letzten Clustering- Schritt durchgeführt und geplottet. Wir werden zwei Birch- Modelle erstellen, eines ohne den globalen Clustering- Schritt und eines mit dem globalen Clustering- Schritt.

## Compute clustering with BIRCH with and without the final clustering step and plot.
birch_models = [
    Birch(threshold=1.7, n_clusters=None),
    Birch(threshold=1.7, n_clusters=100),
]
final_step = ["without global clustering", "with global clustering"]

for ind, (birch_model, info) in enumerate(zip(birch_models, final_step)):
    t = time()
    birch_model.fit(X)
    print("BIRCH %s as the final step took %0.2f seconds" % (info, (time() - t)))

    ## Plot result
    labels = birch_model.labels_
    centroids = birch_model.subcluster_centers_
    n_clusters = np.unique(labels).size
    print("n_clusters : %d" % n_clusters)

    ax = fig.add_subplot(1, 3, ind + 1)
    for this_centroid, k, col in zip(centroids, range(n_clusters), colors_):
        mask = labels == k
        ax.scatter(X[mask, 0], X[mask, 1], c="w", edgecolor=col, marker=".", alpha=0.5)
        if birch_model.n_clusters is None:
            ax.scatter(this_centroid[0], this_centroid[1], marker="+", c="k", s=25)
    ax.set_ylim([-25, 25])
    ax.set_xlim([-25, 25])
    ax.set_autoscaley_on(False)
    ax.set_title("BIRCH %s" % info)

MiniBatchKMeans-Modell

Als vierten Schritt wird die Clustering- Berechnung mit MiniBatchKMeans durchgeführt. Wir werden das Modell auf unseren Datensatz anpassen und die Zeit, die MiniBatchKMeans benötigt, ausgeben.

## Compute clustering with MiniBatchKMeans.
mbk = MiniBatchKMeans(
    init="k-means++",
    n_clusters=100,
    batch_size=256 * cpu_count(),
    n_init=10,
    max_no_improvement=10,
    verbose=0,
    random_state=0,
)
t0 = time()
mbk.fit(X)
t_mini_batch = time() - t0
print("Time taken to run MiniBatchKMeans %0.2f seconds" % t_mini_batch)
mbk_means_labels_unique = np.unique(mbk.labels_)

ax = fig.add_subplot(1, 3, 3)
for this_centroid, k, col in zip(mbk.cluster_centers_, range(n_clusters), colors_):
    mask = mbk.labels_ == k
    ax.scatter(X[mask, 0], X[mask, 1], marker=".", c="w", edgecolor=col, alpha=0.5)
    ax.scatter(this_centroid[0], this_centroid[1], marker="+", c="k", s=25)
ax.set_xlim([-25, 25])
ax.set_ylim([-25, 25])
ax.set_title("MiniBatchKMeans")
ax.set_autoscaley_on(False)
plt.show()

Zusammenfassung

In diesem Lab wurden die Laufzeiten zweier Clustering- Algorithmen, BIRCH und MiniBatchKMeans, auf einem synthetischen Datensatz verglichen. BIRCH ist ein hierarchisches Clustering- Algorithmus, das es ermöglicht, große Datensätze effizient zu gruppieren. MiniBatchKMeans ist eine Variation des KMeans- Algorithmus, der ebenfalls in der Lage ist, große Datensätze effizient zu gruppieren. Beide Algorithmen waren in der Lage, den Datensatz innerhalb eines vernünftigen Zeitraums zu gruppieren.