Desvende o Poder da Modelagem de Mistura Gaussiana Bayesiana

Introdução

Este laboratório demonstra como utilizar a classe BayesianGaussianMixture do scikit-learn para ajustar um conjunto de dados de brinquedo contendo uma mistura de três gaussianas. A classe pode adaptar automaticamente o número de componentes da mistura usando uma prior de concentração, especificada pelo parâmetro weight_concentration_prior_type. Este laboratório mostra a diferença entre usar uma prior de distribuição Dirichlet e uma prior de processo Dirichlet para selecionar o número de componentes com pesos não nulos.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Importar Bibliotecas

Neste passo, iremos importar as bibliotecas necessárias, que são numpy, matplotlib, gridspec e BayesianGaussianMixture de sklearn.mixture.

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

Definir Funções

Neste passo, definimos duas funções. A primeira função plota elipses obtidas a partir do conjunto de dados de brinquedo ajustado pelos modelos da classe BayesianGaussianMixture. A segunda função plota os resultados para três valores diferentes da prior de concentração de peso.

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("Misturas Estimadas")
        ax2.set_ylabel("Peso de cada componente")

Definir Parâmetros para o Conjunto de Dados de Brinquedo

Neste passo, definimos os parâmetros para o conjunto de dados de brinquedo, incluindo o estado aleatório, o número de componentes, o número de características, as cores, as covariâncias, as amostras e as médias.

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

Definir Estimadores

Neste passo, definimos dois estimadores. O primeiro estimador utiliza uma distribuição Dirichlet como prior para definir o número de componentes com pesos não nulos. O segundo estimador utiliza uma prior de processo Dirichlet para selecionar o número de componentes.

estimators = [
    (
        "Mistura finita com uma distribuição Dirichlet\nprior e " 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],
    ),
    (
        "Mistura infinita com uma prior de processo Dirichlet e" 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],
    ),
]

Gerar Dados

Neste passo, geramos dados utilizando a função numpy.random.RandomState e os parâmetros definidos no Passo 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)])

Plotar Resultados

Neste passo, plotamos os resultados para cada estimador utilizando a função plot_results definida no Passo 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()

Resumo

Este laboratório demonstrou como utilizar a classe BayesianGaussianMixture do scikit-learn para ajustar um conjunto de dados de brinquedo contendo uma mistura de três gaussianas. A classe pode adaptar automaticamente o número de componentes da mistura usando um parâmetro de concentração anterior, especificado pelo parâmetro weight_concentration_prior_type. Este laboratório mostrou a diferença entre usar uma distribuição Dirichlet como prior e um processo Dirichlet para selecionar o número de componentes com pesos não nulos.

Plotar Prior de Concentração