Gaussian Mixture Model Kovarianzen

Einführung

In diesem Tutorial wird die Verwendung verschiedener Kovarianztypen für Gaußsche Mischmodelle (GMMs) demonstriert. GMMs werden häufig zur Clusteranalyse verwendet, und wir können die erhaltenen Cluster mit den tatsächlichen Klassen aus dem Datensatz vergleichen. Wir initialisieren die Mittelwerte der Gaußverteilungen mit den Mittelwerten der Klassen aus dem Trainingsset, um diesen Vergleich gültig zu machen. Wir zeichnen vorhergesagte Labels sowohl auf Trainings- als auch auf Testdaten mit einer Vielzahl von GMM-Kovarianztypen auf dem Iris-Datensatz. Wir vergleichen GMMs mit sphärischen, diagonalen, vollen und geketteten Kovarianzmatrizen in aufsteigender Reihenfolge der Leistung.

Obwohl man im Allgemeinen erwarten würde, dass die volle Kovarianz am besten performt, neigt sie dazu, auf kleinen Datensätzen zu overfitten und generalisiert sich nicht gut auf Testdaten.

Auf den Diagrammen werden Trainingsdaten als Punkte und Testdaten als Kreuze dargestellt. Der Iris-Datensatz ist vierdimensional. Hier werden nur die ersten beiden Dimensionen gezeigt, und daher sind einige Punkte in anderen Dimensionen getrennt.

VM-Tipps

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 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 sofort beheben.

Skills Graph

Bibliotheken importieren

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.mixture import GaussianMixture
from sklearn.model_selection import StratifiedKFold

Lädt den Iris-Datensatz

iris = datasets.load_iris()

Vorbereiten von Trainings- und Testdaten

skf = StratifiedKFold(n_splits=4)
train_index, test_index = next(iter(skf.split(iris.data, iris.target)))

X_train = iris.data[train_index]
y_train = iris.target[train_index]
X_test = iris.data[test_index]
y_test = iris.target[test_index]

Einrichten von GMM-Schätzern für verschiedene Kovarianztypen

colors = ["navy", "turquoise", "darkorange"]
n_classes = len(np.unique(y_train))

estimators = {
    cov_type: GaussianMixture(
        n_components=n_classes, covariance_type=cov_type, max_iter=20, random_state=0
    )
    for cov_type in ["spherical", "diag", "tied", "full"]
}

n_estimators = len(estimators)

Definiere eine Funktion, um Ellipsen für GMMs zu zeichnen

def make_ellipses(gmm, ax):
    for n, color in enumerate(colors):
        if gmm.covariance_type == "full":
            covariances = gmm.covariances_[n][:2, :2]
        elif gmm.covariance_type == "tied":
            covariances = gmm.covariances_[:2, :2]
        elif gmm.covariance_type == "diag":
            covariances = np.diag(gmm.covariances_[n][:2])
        elif gmm.covariance_type == "spherical":
            covariances = np.eye(gmm.means_.shape[1]) * gmm.covariances_[n]
        v, w = np.linalg.eigh(covariances)
        u = w[0] / np.linalg.norm(w[0])
        angle = np.arctan2(u[1], u[0])
        angle = 180 * angle / np.pi
        v = 2.0 * np.sqrt(2.0) * np.sqrt(v)
        ell = mpl.patches.Ellipse(
            gmm.means_[n, :2], v[0], v[1], angle=180 + angle, color=color
        )
        ell.set_clip_box(ax.bbox)
        ell.set_alpha(0.5)
        ax.add_artist(ell)
        ax.set_aspect("equal", "datalim")

Zeichne GMMs für verschiedene Kovarianztypen

plt.figure(figsize=(3 * n_estimators // 2, 6))
plt.subplots_adjust(
    bottom=0.01, top=0.95, hspace=0.15, wspace=0.05, left=0.01, right=0.99
)

for index, (name, estimator) in enumerate(estimators.items()):
    estimator.means_init = np.array(
        [X_train[y_train == i].mean(axis=0) for i in range(n_classes)]
    )

    estimator.fit(X_train)

    h = plt.subplot(2, n_estimators // 2, index + 1)
    make_ellipses(estimator, h)

    for n, color in enumerate(colors):
        data = iris.data[iris.target == n]
        plt.scatter(
            data[:, 0], data[:, 1], s=0.8, color=color, label=iris.target_names[n]
        )

    for n, color in enumerate(colors):
        data = X_test[y_test == n]
        plt.scatter(data[:, 0], data[:, 1], marker="x", color=color)

    y_train_pred = estimator.predict(X_train)
    train_accuracy = np.mean(y_train_pred.ravel() == y_train.ravel()) * 100
    plt.text(0.05, 0.9, "Train accuracy: %.1f" % train_accuracy, transform=h.transAxes)

    y_test_pred = estimator.predict(X_test)
    test_accuracy = np.mean(y_test_pred.ravel() == y_test.ravel()) * 100
    plt.text(0.05, 0.8, "Test accuracy: %.1f" % test_accuracy, transform=h.transAxes)

    plt.xticks(())
    plt.yticks(())
    plt.title(name)

plt.legend(scatterpoints=1, loc="lower right", prop=dict(size=12))
plt.show()

Zusammenfassung

In diesem Tutorial wurde die Verwendung verschiedener Kovarianztypen für Gaussian mixture models (GMMs) in Python demonstriert. Wir haben den Iris-Datensatz als Beispiel verwendet und GMMs mit sphärischen, diagonalen, vollen und geketteten Kovarianzmatrizen in aufsteigender Reihenfolge der Leistung verglichen. Wir haben vorhergesagte Labels auf sowohl Trainings- als auch auf die getrennten Testdaten geplottet und gezeigt, dass die vollständige Kovarianz auf kleinen Datensätzen anfällig für Overfitting ist und sich nicht gut auf die getrennten Testdaten verallgemeinert.