Modelos de Mistura Gaussiana: Tipos de Covariância

Introdução

Este tutorial demonstra o uso de diferentes tipos de covariância para modelos de mistura gaussiana (GMMs). Os GMMs são frequentemente usados para agrupamento, e podemos comparar os clusters obtidos com as classes reais do conjunto de dados. Inicializamos as médias das gaussianas com as médias das classes do conjunto de treinamento para tornar esta comparação válida. Plotamos as etiquetas previstas nos dados de treinamento e nos dados de teste mantidos de fora usando uma variedade de tipos de covariância GMM no conjunto de dados iris. Comparamos GMMs com matrizes de covariância esférica, diagonal, completa e ligada em ordem crescente de desempenho.

Embora se espere que a covariância completa tenha melhor desempenho em geral, ela é propensa a superajuste em conjuntos de dados pequenos e não generaliza bem para dados de teste mantidos de fora.

Nos gráficos, os dados de treinamento são mostrados como pontos, enquanto os dados de teste são mostrados como cruzes. O conjunto de dados iris é quadridimensional. Apenas as duas primeiras dimensões são mostradas aqui, e portanto alguns pontos são separados em outras dimensões.

Dicas de Máquina Virtual

Após o término do inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

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

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos prontamente o problema para você.

Importar Bibliotecas

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.mixture import GaussianMixture
from sklearn.model_selection import StratifiedKFold

Carregar o conjunto de dados Iris

iris = datasets.load_iris()

Preparar dados de treino e teste

skf = StratifiedKFold(n_splits=4)
train_index, test_index = next(iter(skf.split(iris.data, iris.target)))

X_train = iris.data[train_index]
y_train = iris.target[train_index]
X_test = iris.data[test_index]
y_test = iris.target[test_index]

Configurar estimadores GMM para diferentes tipos de covariância

colors = ["navy", "turquoise", "darkorange"]
n_classes = len(np.unique(y_train))

estimators = {
    cov_type: GaussianMixture(
        n_components=n_classes, covariance_type=cov_type, max_iter=20, random_state=0
    )
    for cov_type in ["spherical", "diag", "tied", "full"]
}

n_estimators = len(estimators)

Definir uma função para plotar elipses para GMMs

def make_ellipses(gmm, ax):
    for n, color in enumerate(colors):
        if gmm.covariance_type == "full":
            covariances = gmm.covariances_[n][:2, :2]
        elif gmm.covariance_type == "tied":
            covariances = gmm.covariances_[:2, :2]
        elif gmm.covariance_type == "diag":
            covariances = np.diag(gmm.covariances_[n][:2])
        elif gmm.covariance_type == "spherical":
            covariances = np.eye(gmm.means_.shape[1]) * gmm.covariances_[n]
        v, w = np.linalg.eigh(covariances)
        u = w[0] / np.linalg.norm(w[0])
        angle = np.arctan2(u[1], u[0])
        angle = 180 * angle / np.pi
        v = 2.0 * np.sqrt(2.0) * np.sqrt(v)
        ell = mpl.patches.Ellipse(
            gmm.means_[n, :2], v[0], v[1], angle=180 + angle, color=color
        )
        ell.set_clip_box(ax.bbox)
        ell.set_alpha(0.5)
        ax.add_artist(ell)
        ax.set_aspect("equal", "datalim")

Plotar GMMs para diferentes tipos de covariância

plt.figure(figsize=(3 * n_estimators // 2, 6))
plt.subplots_adjust(
    bottom=0.01, top=0.95, hspace=0.15, wspace=0.05, left=0.01, right=0.99
)

for index, (name, estimator) in enumerate(estimators.items()):
    estimator.means_init = np.array(
        [X_train[y_train == i].mean(axis=0) for i in range(n_classes)]
    )

    estimator.fit(X_train)

    h = plt.subplot(2, n_estimators // 2, index + 1)
    make_ellipses(estimator, h)

    for n, color in enumerate(colors):
        data = iris.data[iris.target == n]
        plt.scatter(
            data[:, 0], data[:, 1], s=0.8, color=color, label=iris.target_names[n]
        )

    for n, color in enumerate(colors):
        data = X_test[y_test == n]
        plt.scatter(data[:, 0], data[:, 1], marker="x", color=color)

    y_train_pred = estimator.predict(X_train)
    train_accuracy = np.mean(y_train_pred.ravel() == y_train.ravel()) * 100
    plt.text(0.05, 0.9, "Precisão de treino: %.1f" % train_accuracy, transform=h.transAxes)

    y_test_pred = estimator.predict(X_test)
    test_accuracy = np.mean(y_test_pred.ravel() == y_test.ravel()) * 100
    plt.text(0.05, 0.8, "Precisão de teste: %.1f" % test_accuracy, transform=h.transAxes)

    plt.xticks(())
    plt.yticks(())
    plt.title(name)

plt.legend(scatterpoints=1, loc="lower right", prop=dict(size=12))
plt.show()

Resumo

Este tutorial demonstrou o uso de diferentes tipos de covariância para modelos de mistura gaussiana (GMMs) em Python. Usamos o conjunto de dados Iris como exemplo e comparamos GMMs com matrizes de covariância esférica, diagonal, completa e ligada em ordem crescente de desempenho. Plotamos as etiquetas previstas nos dados de treino e nos dados de teste mantidos de fora e mostramos que a covariância completa é propensa a sobreajuste em conjuntos de dados pequenos e não generaliza bem para dados de teste mantidos de fora.