Covariances du modèle de mélange gaussien

Introduction

Ce tutoriel montre l'utilisation de différents types de covariance pour les modèles de mélange gaussien (GMM). Les GMM sont souvent utilisés pour le regroupement, et nous pouvons comparer les groupes obtenus avec les classes réelles du jeu de données. Nous initialisons les moyennes des Gaussiennes avec les moyennes des classes de l'ensemble d'entraînement pour que cette comparaison soit valide. Nous traçons les étiquettes prédites sur les données d'entraînement et de test de validation en utilisant différents types de covariance GMM sur l'ensemble de données iris. Nous comparons les GMM avec des matrices de covariance sphérique, diagonale, complète et liée dans l'ordre croissant de performance.

Bien que l'on s'attende à ce que la covariance complète offre généralement les meilleures performances, elle tend à surajuster sur de petits jeux de données et ne généralise pas bien aux données de test de validation.

Sur les graphiques, les données d'entraînement sont représentées par des points, tandis que les données de test sont représentées par des croix. L'ensemble de données iris est à quatre dimensions. Seules les deux premières dimensions sont montrées ici, et donc certains points sont séparés dans les autres dimensions.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

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

Charger l'ensemble de données Iris

iris = datasets.load_iris()

Préparer les données d'entraînement et de test

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]

Configurer des estimateurs GMM pour différents types de covariance

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)

Définir une fonction pour tracer des ellipses pour les GMM

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

Tracer des GMM pour différents types de covariance

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

Sommaire

Ce tutoriel a démontré l'utilisation de différents types de covariance pour les modèles de mélange gaussien (GMM) en Python. Nous avons utilisé l'ensemble de données Iris comme exemple et comparé les GMM avec des matrices de covariance sphérique, diagonale, complète et liée dans l'ordre croissant de performance. Nous avons tracé les étiquettes prédites sur les données d'entraînement et de test conservées et montré que la covariance complète est propice au surapprentissage sur de petits ensembles de données et ne généralise pas bien aux données de test conservées.