Méthodes d'initialisation des modèles de mélange gaussien

Introduction

Dans ce laboratoire, nous allons apprendre les différentes méthodes d'initialisation des modèles de mélange gaussien (GMM). Nous utiliserons la bibliothèque scikit-learn pour générer des données d'échantillonnage et visualiser les résultats de regroupement. Il existe quatre méthodes différentes pour le paramètre d'initialisation init_param : kmeans (valeur par défaut), random, random_from_data et k-means++.

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 Notebook 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 des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques et génération de données d'échantillonnage

Nous commencerons par importer les bibliothèques nécessaires et en générer quelques données d'échantillonnage en utilisant la fonction make_blobs de scikit-learn.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.mixture import GaussianMixture
from sklearn.utils.extmath import row_norms
from sklearn.datasets._samples_generator import make_blobs
from timeit import default_timer as timer

## Générer quelques données
X, y_true = make_blobs(n_samples=4000, centers=4, cluster_std=0.60, random_state=0)
X = X[:, ::-1]

n_samples = 4000
n_components = 4
x_squared_norms = row_norms(X, squared=True)

Définir une fonction pour obtenir les moyennes initiales

Ensuite, nous allons définir une fonction get_initial_means qui prend les données d'échantillonnage, la méthode d'initialisation et l'état aléatoire en entrée et renvoie les moyennes d'initialisation.

def get_initial_means(X, init_params, r):
    ## Exécutez un GaussianMixture avec max_iter=0 pour afficher les moyennes d'initialisation
    gmm = GaussianMixture(
        n_components=4, init_params=init_params, tol=1e-9, max_iter=0, random_state=r
    ).fit(X)
    return gmm.means_

Tracer les données d'échantillonnage et les centres d'initialisation

Nous allons maintenant tracer les données d'échantillonnage et les centres d'initialisation pour chaque méthode d'initialisation en utilisant des couleurs différentes. Nous calculerons également le temps pris pour l'initialisation et le nombre d'itérations nécessaires pour que le GMM converge.

methods = ["kmeans", "random_from_data", "k-means++", "random"]
colors = ["navy", "turquoise", "cornflowerblue", "darkorange"]
times_init = {}
relative_times = {}

plt.figure(figsize=(4 * len(methods) // 2, 6))
plt.subplots_adjust(
    bottom=0.1, top=0.9, hspace=0.15, wspace=0.05, left=0.05, right=0.95
)

for n, method in enumerate(methods):
    r = np.random.RandomState(seed=1234)
    plt.subplot(2, len(methods) // 2, n + 1)

    start = timer()
    ini = get_initial_means(X, method, r)
    end = timer()
    init_time = end - start

    gmm = GaussianMixture(
        n_components=4, means_init=ini, tol=1e-9, max_iter=2000, random_state=r
    ).fit(X)

    times_init[method] = init_time
    for i, color in enumerate(colors):
        data = X[gmm.predict(X) == i]
        plt.scatter(data[:, 0], data[:, 1], color=color, marker="x")

    plt.scatter(
        ini[:, 0], ini[:, 1], s=75, marker="D", c="orange", lw=1.5, edgecolors="black"
    )
    relative_times[method] = times_init[method] / times_init[methods[0]]

    plt.xticks(())
    plt.yticks(())
    plt.title(method, loc="left", fontsize=12)
    plt.title(
        "Iter %i | Init Time %.2fx" % (gmm.n_iter_, relative_times[method]),
        loc="right",
        fontsize=10,
    )
plt.suptitle("GMM iterations and relative time taken to initialize")
plt.show()

Interpréter les résultats

On peut voir sur le tracé que k-means++ est performant tant en termes de temps d'initialisation faible qu'en termes de nombre d'itérations du GaussianMixture pour converger. Lorsqu'il est initialisé avec random_from_data ou random, le modèle prend plus d'itérations pour converger. Les trois autres méthodes alternatives prennent moins de temps pour s'initialiser par rapport à kmeans.

Sommaire

Dans ce laboratoire, nous avons appris les différentes méthodes d'initialisation des modèles de mélange gaussien (Gaussian Mixture Models - GMM) et comment les utiliser pour regrouper des données d'échantillonnage à l'aide de la bibliothèque scikit-learn. Nous avons tracé les données d'échantillonnage et les centres d'initialisation pour chaque méthode d'initialisation et interprété les résultats.