Découvrez le pouvoir de la modélisation bayésienne des mélanges gaussiens

Introduction

Ce laboratoire montre comment utiliser la classe BayesianGaussianMixture de scikit-learn pour ajuster un jeu de données d'entraînement contenant un mélange de trois Gaussiennes. Cette classe peut adapter automatiquement le nombre de composants de mélange en utilisant une loi a priori de concentration, qui est spécifiée en utilisant le paramètre weight_concentration_prior_type. Ce laboratoire montre la différence entre l'utilisation d'une loi a priori de distribution de Dirichlet et d'un processus de Dirichlet pour sélectionner le nombre de composants avec des poids non nuls.

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

Importation des bibliothèques

Dans cette étape, nous allons importer les bibliothèques nécessaires, qui sont numpy, matplotlib, gridspec et BayesianGaussianMixture de sklearn.mixture.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
from sklearn.mixture import BayesianGaussianMixture

Définition de fonctions

Dans cette étape, nous définissons deux fonctions. La première fonction trace des ellipsoïdes obtenus à partir du jeu de données d'entraînement ajusté par les modèles de la classe BayesianGaussianMixture. La deuxième fonction trace les résultats pour trois valeurs différentes de la loi a priori de concentration des poids.

def plot_ellipses(ax, weights, means, covars):
    for n in range(means.shape[0]):
        eig_vals, eig_vecs = np.linalg.eigh(covars[n])
        unit_eig_vec = eig_vecs[0] / np.linalg.norm(eig_vecs[0])
        angle = np.arctan2(unit_eig_vec[1], unit_eig_vec[0])
        angle = 180 * angle / np.pi
        eig_vals = 2 * np.sqrt(2) * np.sqrt(eig_vals)
        ell = mpl.patches.Ellipse(
            means[n], eig_vals[0], eig_vals[1], angle=180 + angle, edgecolor="black"
        )
        ell.set_clip_box(ax.bbox)
        ell.set_alpha(weights[n])
        ell.set_facecolor("#56B4E9")
        ax.add_artist(ell)

def plot_results(ax1, ax2, estimator, X, y, title, plot_title=False):
    ax1.set_title(title)
    ax1.scatter(X[:, 0], X[:, 1], s=5, marker="o", color=colors[y], alpha=0.8)
    ax1.set_xlim(-2.0, 2.0)
    ax1.set_ylim(-3.0, 3.0)
    ax1.set_xticks(())
    ax1.set_yticks(())
    plot_ellipses(ax1, estimator.weights_, estimator.means_, estimator.covariances_)

    ax2.get_xaxis().set_tick_params(direction="out")
    ax2.yaxis.grid(True, alpha=0.7)
    for k, w in enumerate(estimator.weights_):
        ax2.bar(
            k,
            w,
            width=0.9,
            color="#56B4E9",
            zorder=3,
            align="center",
            edgecolor="black",
        )
        ax2.text(k, w + 0.007, "%.1f%%" % (w * 100.0), horizontalalignment="center")
    ax2.set_xlim(-0.6, 2 * n_components - 0.4)
    ax2.set_ylim(0.0, 1.1)
    ax2.tick_params(axis="y", which="both", left=False, right=False, labelleft=False)
    ax2.tick_params(axis="x", which="both", top=False)
    if plot_title:
        ax1.set_ylabel("Estimated Mixtures")
        ax2.set_ylabel("Weight of each component")

Définir les paramètres pour le jeu de données d'entraînement

Dans cette étape, nous définissons les paramètres pour le jeu de données d'entraînement, qui comprennent l'état aléatoire, le nombre de composants, le nombre de caractéristiques, les couleurs, les covariances, les échantillons et les moyennes.

random_state, n_components, n_features = 2, 3, 2
colors = np.array(["#0072B2", "#F0E442", "#D55E00"])
covars = np.array(
    [[[0.7, 0.0], [0.0, 0.1]], [[0.5, 0.0], [0.0, 0.1]], [[0.5, 0.0], [0.0, 0.1]]]
)
samples = np.array([200, 500, 200])
means = np.array([[0.0, -0.70], [0.0, 0.0], [0.0, 0.70]])

Définir les estimateurs

Dans cette étape, nous définissons deux estimateurs. Le premier estimateur utilise une loi a priori de distribution de Dirichlet pour définir le nombre de composants avec des poids non nuls. Le second estimateur utilise un processus de Dirichlet pour sélectionner le nombre de composants.

estimators = [
    (
        "Finite mixture with a Dirichlet distribution\nprior and " r"$\gamma_0=$",
        BayesianGaussianMixture(
            weight_concentration_prior_type="dirichlet_distribution",
            n_components=2 * n_components,
            reg_covar=0,
            init_params="random",
            max_iter=1500,
            mean_precision_prior=0.8,
            random_state=random_state,
        ),
        [0.001, 1, 1000],
    ),
    (
        "Infinite mixture with a Dirichlet process\n prior and" r"$\gamma_0=$",
        BayesianGaussianMixture(
            weight_concentration_prior_type="dirichlet_process",
            n_components=2 * n_components,
            reg_covar=0,
            init_params="random",
            max_iter=1500,
            mean_precision_prior=0.8,
            random_state=random_state,
        ),
        [1, 1000, 100000],
    ),
]

Générer les données

Dans cette étape, nous générons des données en utilisant la fonction numpy.random.RandomState et les paramètres définis dans l'Étape 3.

rng = np.random.RandomState(random_state)
X = np.vstack(
    [
        rng.multivariate_normal(means[j], covars[j], samples[j])
        for j in range(n_components)
    ]
)
y = np.concatenate([np.full(samples[j], j, dtype=int) for j in range(n_components)])

Tracer les résultats

Dans cette étape, nous traçons les résultats pour chaque estimateur en utilisant la fonction plot_results définie dans l'Étape 2.

for title, estimator, concentrations_prior in estimators:
    plt.figure(figsize=(4.7 * 3, 8))
    plt.subplots_adjust(
        bottom=0.04, top=0.90, hspace=0.05, wspace=0.05, left=0.03, right=0.99
    )

    gs = gridspec.GridSpec(3, len(concentrations_prior))
    for k, concentration in enumerate(concentrations_prior):
        estimator.weight_concentration_prior = concentration
        estimator.fit(X)
        plot_results(
            plt.subplot(gs[0:2, k]),
            plt.subplot(gs[2, k]),
            estimator,
            X,
            y,
            r"%s$%.1e$" % (title, concentration),
            plot_title=k == 0,
        )

plt.show()

Sommaire

Ce laboratoire a démontré comment utiliser la classe BayesianGaussianMixture dans scikit-learn pour ajuster un jeu de données d'entraînement contenant un mélange de trois Gaussiennes. Cette classe peut adapter automatiquement le nombre de composants de mélange en utilisant une loi a priori de concentration, qui est spécifiée en utilisant le paramètre weight_concentration_prior_type. Ce laboratoire a montré la différence entre l'utilisation d'une loi a priori de distribution de Dirichlet et d'un processus de Dirichlet pour sélectionner le nombre de composants avec des poids non nuls.

Tracer la loi a priori de concentration