Sélection de modèle de mélange gaussien

Introduction

Dans ce laboratoire, nous allons apprendre à effectuer la sélection de modèles avec des modèles de mélange gaussien (GMM) en utilisant des critères d'information théorique. La sélection de modèles concerne à la fois le type de covariance et le nombre de composants dans le modèle. Nous utiliserons le critère d'information d'Akaike (AIC) et le critère d'information bayésien (BIC) pour sélectionner le meilleur modèle. Nous allons générer deux composants en échantillonnant aléatoirement la distribution normale standard. Un composant est conservé sphérique mais déplacé et redimensionné. L'autre est déformé pour avoir une matrice de covariance plus générale.

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 au carnet Jupyter pour la pratique.

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

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églerons rapidement le problème pour vous.

Skills Graph

Génération des données

Nous générons deux composants (chaque composant contenant n_samples) en échantillonnant aléatoirement la distribution normale standard renvoyée par numpy.random.randn. Un composant est conservé sphérique mais déplacé et redimensionné. L'autre est déformé pour avoir une matrice de covariance plus générale.

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)  ## général
component_2 = 0.7 * np.random.randn(n_samples, 2) + np.array([-4, 1])  ## sphérique

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

Visualisation

Nous pouvons visualiser les différents composants à l'aide de Matplotlib.

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("Composants de mélange gaussien")
plt.axis("égal")
plt.show()

Entraînement et sélection du modèle

Nous faisons varier le nombre de composants de 1 à 6 et le type de paramètres de covariance à utiliser :

• "full" : chaque composant a sa propre matrice de covariance générale.
• "tied" : tous les composants partagent la même matrice de covariance générale.
• "diag" : chaque composant a sa propre matrice de covariance diagonale.
• "spherical" : chaque composant a sa propre variance unique.

Nous évaluons les différents modèles et conservons le meilleur modèle (celui avec le BIC le plus bas). Cela est fait en utilisant GridSearchCV et une fonction de score définie par l'utilisateur qui renvoie le score BIC négatif. Le meilleur ensemble de paramètres et l'estimateur sont stockés respectivement dans best_parameters_ et best_estimator_.

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

def gmm_bic_score(estimator, X):
    """Callable à passer à GridSearchCV qui utilisera le score BIC."""
    ## Rendre négatif car GridSearchCV attend un score à maximiser
    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)

Tracer les scores BIC

Nous créons un pandas.DataFrame à partir des résultats de la validation croisée effectuée par la recherche en grille. Nous inversons à nouveau le signe du score BIC pour montrer l'effet de sa minimisation. Nous utilisons seaborn pour tracer les scores BIC.

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": "Nombre de composants",
        "param_covariance_type": "Type de covariance",
        "mean_test_score": "Score BIC",
    }
)
df.sort_values(by="Score BIC").head()

sns.catplot(
    data=df,
    kind="bar",
    x="Nombre de composants",
    y="Score BIC",
    hue="Type de covariance",
)
plt.show()

Tracer le meilleur modèle

Nous traçons une ellipse pour montrer chaque composant gaussien du modèle sélectionné. Pour cet objectif, il faut trouver les valeurs propres des matrices de covariance renvoyées par l'attribut covariances_. La forme de ces matrices dépend du covariance_type :

• "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  ## convertir en degrés
    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"Meilleur GMM sélectionné : modèle {grid_search.best_params_['covariance_type']}, "
    f"{grid_search.best_params_['n_components']} composants"
)
plt.axis("égal")
plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à effectuer la sélection de modèle avec des modèles de mélange gaussien (GMM) à l'aide de critères issus de la théorie de l'information. Nous avons utilisé le critère d'information d'Akaike (AIC) et le critère d'information bayésien (BIC) pour sélectionner le meilleur modèle. Nous avons généré deux composants en échantillonnant aléatoirement la distribution normale standard. Un composant a été conservé sphérique mais déplacé et ré-échelle. L'autre a été déformé pour avoir une matrice de covariance plus générale. Nous avons visualisé les différents composants, entraîné et sélectionné le meilleur modèle, tracé les scores BIC et tracé le meilleur modèle.