Selección de Modelos de Mezcla Gaussiana

Introducción

En este laboratorio, aprenderemos a realizar la selección de modelos con Modelos Mixtos Gausianos (GMM, por sus siglas en inglés) utilizando criterios de teoría de la información. La selección de modelos aborda tanto el tipo de covarianza como el número de componentes en el modelo. Utilizaremos el Criterio de Información de Akaike (AIC) y el Criterio de Información Bayesiano (BIC) para seleccionar el mejor modelo. Generaremos dos componentes mediante la muestra aleatoria de la distribución normal estándar. Una componente se mantiene esférica pero desplazada y reescalada. La otra se deforma para tener una matriz de covarianza más general.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Generación de datos

Generamos dos componentes (cada uno contiene n_samples) mediante la muestra aleatoria de la distribución normal estándar devuelta por numpy.random.randn. Una componente se mantiene esférica pero desplazada y reescalada. La otra se deforma para tener una matriz de covarianza más general.

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)  ## general
component_2 = 0.7 * np.random.randn(n_samples, 2) + np.array([-4, 1])  ## spherical

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

Visualización

Podemos visualizar los diferentes componentes utilizando 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("Gaussian Mixture components")
plt.axis("equal")
plt.show()

Entrenamiento y selección de modelos

Variamos el número de componentes de 1 a 6 y el tipo de parámetros de covarianza a utilizar:

• "full": cada componente tiene su propia matriz de covarianza general.
• "tied": todos los componentes comparten la misma matriz de covarianza general.
• "diag": cada componente tiene su propia matriz de covarianza diagonal.
• "spherical": cada componente tiene su propia varianza única.

Evaluamos los diferentes modelos y mantenemos el mejor modelo (el BIC más bajo). Esto se hace utilizando GridSearchCV y una función de puntuación definida por el usuario que devuelve la puntuación negativa del BIC. El mejor conjunto de parámetros y el estimador se almacenan en best_parameters_ y best_estimator_, respectivamente.

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

def gmm_bic_score(estimator, X):
    """Callable to pass to GridSearchCV that will use the BIC score."""
    ## Make it negative since GridSearchCV expects a score to maximize
    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)

Grafica las puntuaciones BIC

Creamos un pandas.DataFrame a partir de los resultados de la validación cruzada realizada por la búsqueda en cuadrícula. Volvemos a invertir el signo de la puntuación BIC para mostrar el efecto de minimizarla. Utilizamos seaborn para graficar las puntuaciones 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": "Número de componentes",
        "param_covariance_type": "Tipo de covarianza",
        "mean_test_score": "Puntuación BIC",
    }
)
df.sort_values(by="Puntuación BIC").head()

sns.catplot(
    data=df,
    kind="bar",
    x="Número de componentes",
    y="Puntuación BIC",
    hue="Tipo de covarianza",
)
plt.show()

Grafica el mejor modelo

Graficamos una elipse para mostrar cada componente gaussiana del modelo seleccionado. Para este propósito, es necesario encontrar los autovalores de las matrices de covarianza devueltas por el atributo covariances_. La forma de tales matrices depende del 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  ## 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"Selected GMM: {grid_search.best_params_['covariance_type']} model, "
    f"{grid_search.best_params_['n_components']} components"
)
plt.axis("equal")
plt.show()

Resumen

En este laboratorio, aprendimos cómo realizar la selección de modelos con los Modelos de Mezcla Gaussiana (GMM) utilizando criterios de teoría de la información. Utilizamos el Criterio de Información de Akaike (AIC) y el Criterio de Información Bayesiano (BIC) para seleccionar el mejor modelo. Generamos dos componentes mediante la muestra aleatoria de la distribución normal estándar. Una componente se mantuvo esférica pero se desplazó y se reescaló. La otra se deformó para tener una matriz de covarianza más general. Visualizamos los diferentes componentes, entrenamos y seleccionamos el mejor modelo, graficamos las puntuaciones BIC y graficamos el mejor modelo.