Auswahl von Gaußschen Mischmodellen

Einführung

In diesem Lab werden wir lernen, wie wir mit Hilfe von Informationstheorie-Kriterien die Modellauswahl mit Gaussian Mixture Models (GMM) durchführen. Die Modellauswahl betrifft sowohl den Kovarianztyp als auch die Anzahl der Komponenten im Modell. Wir werden das Akaike Information Criterion (AIC) und das Bayes Information Criterion (BIC) verwenden, um das beste Modell auszuwählen. Wir werden zwei Komponenten generieren, indem wir die Standardnormalverteilung zufällig abprobieren. Eine Komponente bleibt sphärisch, wird jedoch verschoben und neu skaliert. Die andere wird deformiert, um eine allgemeinere Kovarianzmatrix zu haben.

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

Skills Graph

Datenerzeugung

Wir generieren zwei Komponenten (jedoch eine enthält n_samples), indem wir die Standardnormalverteilung zufällig abprobieren, wie von numpy.random.randn zurückgegeben. Eine Komponente bleibt sphärisch, wird jedoch verschoben und neu skaliert. Die andere wird deformiert, um eine allgemeinere Kovarianzmatrix zu haben.

import numpy as np

n_samples = 500
np.random.seed(0)
C = np.array([[0.0, -0.1], [1.7, 0.4]])
component_1 = np.dot(np.random.randn(n_samples, 2), C)  ## allgemein
component_2 = 0.7 * np.random.randn(n_samples, 2) + np.array([-4, 1])  ## sphärisch

X = np.concatenate([component_1, component_2])

Visualisierung

Wir können die verschiedenen Komponenten mit Matplotlib visualisieren.

import matplotlib.pyplot as plt

plt.scatter(component_1[:, 0], component_1[:, 1], s=0.8)
plt.scatter(component_2[:, 0], component_2[:, 1], s=0.8)
plt.title("Gaussian Mixture Komponenten")
plt.axis("equal")
plt.show()

Modelltraining und -auswahl

Wir variieren die Anzahl der Komponenten von 1 bis 6 und den Typ der Kovarianzparameter, die verwendet werden sollen:

• "full": jede Komponente hat ihre eigene allgemeine Kovarianzmatrix.
• "tied": alle Komponenten teilen die gleiche allgemeine Kovarianzmatrix.
• "diag": jede Komponente hat ihre eigene diagonale Kovarianzmatrix.
• "spherical": jede Komponente hat ihre eigene einfache Varianz.

Wir bewerten die verschiedenen Modelle und behalten das beste Modell (den niedrigsten BIC) bei. Dies wird durch die Verwendung von GridSearchCV und einer benutzerdefinierten Score-Funktion erreicht, die den negativen BIC-Wert zurückgibt. Der beste Parameterensatz und der Schätzer werden jeweils in best_parameters_ und best_estimator_ gespeichert.

from sklearn.mixture import GaussianMixture
from sklearn.model_selection import GridSearchCV

def gmm_bic_score(estimator, X):
    """Aufrufbar, um an GridSearchCV zu übergeben, der den BIC-Wert verwenden wird."""
    ## Machen Sie es negativ, da GridSearchCV erwartet, dass ein Score maximiert wird
    return -estimator.bic(X)

param_grid = {
    "n_components": range(1, 7),
    "covariance_type": ["spherical", "tied", "diag", "full"],
}
grid_search = GridSearchCV(
    GaussianMixture(), param_grid=param_grid, scoring=gmm_bic_score
)
grid_search.fit(X)

Zeichnen Sie die BIC-Werte

Wir erstellen ein pandas.DataFrame aus den Ergebnissen der Kreuzvalidierung, die durch die Grid-Suche durchgeführt wurde. Wir kehren das Vorzeichen des BIC-Werts um, um die Wirkung der Minimierung zu zeigen. Wir verwenden seaborn, um die BIC-Werte zu zeichnen.

import pandas as pd
import seaborn as sns

df = pd.DataFrame(grid_search.cv_results_)[
    ["param_n_components", "param_covariance_type", "mean_test_score"]
]
df["mean_test_score"] = -df["mean_test_score"]
df = df.rename(
    columns={
        "param_n_components": "Anzahl der Komponenten",
        "param_covariance_type": "Typ der Kovarianz",
        "mean_test_score": "BIC-Wert",
    }
)
df.sort_values(by="BIC-Wert").head()

sns.catplot(
    data=df,
    kind="bar",
    x="Anzahl der Komponenten",
    y="BIC-Wert",
    hue="Typ der Kovarianz",
)
plt.show()

Zeichnen Sie das beste Modell

Wir zeichnen eine Ellipse, um jede Gaußsche Komponente des ausgewählten Modells anzuzeigen. Zu diesem Zweck muss man die Eigenwerte der Kovarianzmatrizen finden, die vom Attribut covariances_ zurückgegeben werden. Die Form dieser Matrizen hängt vom covariance_type ab:

• "full": (n_components, n_features, n_features)
• "tied": (n_features, n_features)
• "diag": (n_components, n_features)
• "spherical": (n_components,)

from matplotlib.patches import Ellipse
from scipy import linalg

color_iter = sns.color_palette("tab10", 2)[::-1]
Y_ = grid_search.predict(X)

fig, ax = plt.subplots()

for i, (mean, cov, color) in enumerate(
    zip(
        grid_search.best_estimator_.means_,
        grid_search.best_estimator_.covariances_,
        color_iter,
    )
):
    v, w = linalg.eigh(cov)
    if not np.any(Y_ == i):
        continue
    plt.scatter(X[Y_ == i, 0], X[Y_ == i, 1], 0.8, color=color)

    angle = np.arctan2(w[0][1], w[0][0])
    angle = 180.0 * angle / np.pi  ## convert to degrees
    v = 2.0 * np.sqrt(2.0) * np.sqrt(v)
    ellipse = Ellipse(mean, v[0], v[1], angle=180.0 + angle, color=color)
    ellipse.set_clip_box(fig.bbox)
    ellipse.set_alpha(0.5)
    ax.add_artist(ellipse)

plt.title(
    f"Ausgewähltes GMM: {grid_search.best_params_['covariance_type']} Modell, "
    f"{grid_search.best_params_['n_components']} Komponenten"
)
plt.axis("equal")
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Modellauswahl mit Gaußschen Mischmodellen (GMM) unter Verwendung von informationstheoretischen Kriterien durchführt. Wir haben das Akaike-Informationskriterium (AIC) und das Bayes-Informationskriterium (BIC) verwendet, um das beste Modell auszuwählen. Wir haben zwei Komponenten erzeugt, indem wir die Standardnormalverteilung zufällig abgesucht haben. Eine Komponente blieb sphärisch, wurde jedoch verschoben und neu skaliert. Die andere wurde deformiert, um eine allgemeinere Kovarianzmatrix zu haben. Wir haben die verschiedenen Komponenten visualisiert, das beste Modell trainiert und ausgewählt, die BIC-Werte geplottet und das beste Modell geplottet.