Hierarchische Clusteranalyse mit Python | Scikit-Learn Tutorial

Einführung

In diesem Lab verwenden wir die scikit-learn-Bibliothek von Python, um hierarchische Clusteranalyse auf einigen Toy-Datasets durchzuführen. Hierarchische Clusteranalyse ist eine Methode der Clusteranalyse, bei der Sie eine Hierarchie von Clustern entweder von oben nach unten oder von unten nach oben aufbauen. Ziel der hierarchischen Clusteranalyse ist es, Cluster von Punkten zu finden, die untereinander ähnlich sind und von Punkten in anderen Clustern unterschiedlich.

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

Bibliotheken importieren und Daten laden

Wir beginnen mit dem Import der erforderlichen Bibliotheken und dem Laden der Toy-Datasets, die wir für unsere Beispiele zur hierarchischen Clusteranalyse verwenden werden.

import time
import warnings

import numpy as np
import matplotlib.pyplot as plt

from sklearn import cluster, datasets
from sklearn.preprocessing import StandardScaler
from itertools import cycle, islice

np.random.seed(0)

## %%
## Generieren von Datasets. Wir wählen eine Größe, die groß genug ist, um die Skalierbarkeit
## der Algorithmen zu sehen, aber nicht zu groß, um zu lange Laufzeiten zu vermeiden

n_samples = 1500
noisy_circles = datasets.make_circles(n_samples=n_samples, factor=0.5, noise=0.05)
noisy_moons = datasets.make_moons(n_samples=n_samples, noise=0.05)
blobs = datasets.make_blobs(n_samples=n_samples, random_state=8)
no_structure = np.random.rand(n_samples, 2), None

## Anisotrop verteiltes Data
random_state = 170
X, y = datasets.make_blobs(n_samples=n_samples, random_state=random_state)
transformation = [[0.6, -0.6], [-0.4, 0.8]]
X_aniso = np.dot(X, transformation)
aniso = (X_aniso, y)

## Blobs mit unterschiedlichen Varianzen
varied = datasets.make_blobs(
    n_samples=n_samples, cluster_std=[1.0, 2.5, 0.5], random_state=random_state
)

Hierarchische Clusteranalyse durchführen

Wir werden nun hierarchische Clusteranalyse auf den Toy-Datasets durchführen, die wir in Schritt 1 geladen haben. Wir werden verschiedene Verknüpfungsmethoden wie Single, Average, Complete und Ward verwenden, um unsere Cluster zu bilden.

## Set up cluster parameters
plt.figure(figsize=(9 * 1.3 + 2, 14.5))
plt.subplots_adjust(
    left=0.02, right=0.98, bottom=0.001, top=0.96, wspace=0.05, hspace=0.01
)

plot_num = 1

default_base = {"n_neighbors": 10, "n_clusters": 3}

datasets = [
    (noisy_circles, {"n_clusters": 2}),
    (noisy_moons, {"n_clusters": 2}),
    (varied, {"n_neighbors": 2}),
    (aniso, {"n_neighbors": 2}),
    (blobs, {}),
    (no_structure, {}),
]

for i_dataset, (dataset, algo_params) in enumerate(datasets):
    ## update parameters with dataset-specific values
    params = default_base.copy()
    params.update(algo_params)

    X, y = dataset

    ## normalize dataset for easier parameter selection
    X = StandardScaler().fit_transform(X)

    ## ============
    ## Create cluster objects
    ## ============
    ward = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="ward"
    )
    complete = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="complete"
    )
    average = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="average"
    )
    single = cluster.AgglomerativeClustering(
        n_clusters=params["n_clusters"], linkage="single"
    )

    clustering_algorithms = (
        ("Single Linkage", single),
        ("Average Linkage", average),
        ("Complete Linkage", complete),
        ("Ward Linkage", ward),
    )

    for name, algorithm in clustering_algorithms:
        t0 = time.time()

        ## catch warnings related to kneighbors_graph
        with warnings.catch_warnings():
            warnings.filterwarnings(
                "ignore",
                message="the number of connected components of the "
                + "connectivity matrix is [0-9]{1,2}"
                + " > 1. Completing it to avoid stopping the tree early.",
                category=UserWarning,
            )
            algorithm.fit(X)

        t1 = time.time()
        if hasattr(algorithm, "labels_"):
            y_pred = algorithm.labels_.astype(int)
        else:
            y_pred = algorithm.predict(X)

        plt.subplot(len(datasets), len(clustering_algorithms), plot_num)
        if i_dataset == 0:
            plt.title(name, size=18)

        colors = np.array(
            list(
                islice(
                    cycle(
                        [
                            "#377eb8",
                            "#ff7f00",
                            "#4daf4a",
                            "#f781bf",
                            "#a65628",
                            "#984ea3",
                            "#999999",
                            "#e41a1c",
                            "#dede00",
                        ]
                    ),
                    int(max(y_pred) + 1),
                )
            )
        )
        plt.scatter(X[:, 0], X[:, 1], s=10, color=colors[y_pred])

        plt.xlim(-2.5, 2.5)
        plt.ylim(-2.5, 2.5)
        plt.xticks(())
        plt.yticks(())
        plt.text(
            0.99,
            0.01,
            ("%.2fs" % (t1 - t0)).lstrip("0"),
            transform=plt.gca().transAxes,
            size=15,
            horizontalalignment="right",
        )
        plot_num += 1

plt.show()

Die Ergebnisse analysieren

Wir werden nun die Ergebnisse unserer hierarchischen Clusteranalyse analysieren. Basierend auf den Toy-Datasets, die wir verwendet haben, können wir die folgenden Beobachtungen machen:

Single Linkage ist schnell und kann bei nicht-kugelförmigen Daten gut funktionieren, ist jedoch bei Vorhandensein von Rauschen schlecht.
Average und Complete Linkage funktionieren gut bei sauber voneinander getrennten kugelförmigen Clustern, haben jedoch sonst gemischte Ergebnisse.
Ward ist die effektivste Methode für rauschende Daten.

Es ist wichtig zu beachten, dass diese Beobachtungen uns zwar einige Intuition über die Algorithmen vermitteln, diese Intuition möglicherweise nicht auf sehr hochdimensionale Daten zutrifft.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man hierarchische Clusteranalyse mit der scikit-learn-Bibliothek von Python durchführt. Wir haben verschiedene Verknüpfungsmethoden wie Single, Average, Complete und Ward verwendet, um unsere Cluster zu bilden, und die Ergebnisse anhand einiger Toy-Datasets analysiert. Hierarchische Clusteranalyse ist eine leistungsstarke Technik, die verwendet werden kann, um Cluster ähnlicher Datenpunkte zu identifizieren, und kann in verschiedenen Bereichen wie Biologie, Marketing und Finanzwesen nützlich sein.

Hierarchische Clusteranalyse mit Scikit-Learn