Estimação de Covariância Inversa Esparsa

Introdução

Este laboratório demonstra como usar o estimador GraphicalLasso para aprender uma covariância e uma precisão esparsa a partir de um pequeno número de amostras. O tutorial cobre a geração de dados, a estimativa da covariância e o plote dos resultados.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para praticar.

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 a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Gerar os Dados

O primeiro passo é gerar os dados. Neste caso, estamos a gerar um pequeno conjunto de dados de 60 amostras com 20 características. Usamos uma matriz de covariância inversa esparsa para garantir condições favoráveis de recuperação.

import numpy as np
from scipy import linalg
from sklearn.datasets import make_sparse_spd_matrix

n_samples = 60
n_features = 20

prng = np.random.RandomState(1)
prec = make_sparse_spd_matrix(
    n_features, alpha=0.98, smallest_coef=0.4, largest_coef=0.7, random_state=prng
)
cov = linalg.inv(prec)
d = np.sqrt(np.diag(cov))
cov /= d
cov /= d[:, np.newaxis]
prec *= d
prec *= d[:, np.newaxis]
X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples)
X -= X.mean(axis=0)
X /= X.std(axis=0)

Estimar a Covariância

O segundo passo é estimar a covariância. Usamos o GraphicalLassoCV para aprender a matriz de precisão esparsa. Também comparamos os resultados com o estimador Ledoit-Wolf.

from sklearn.covariance import GraphicalLassoCV, ledoit_wolf

emp_cov = np.dot(X.T, X) / n_samples

model = GraphicalLassoCV()
model.fit(X)
cov_ = model.covariance_
prec_ = model.precision_

lw_cov_, _ = ledoit_wolf(X)
lw_prec_ = linalg.inv(lw_cov_)

Representar os Resultados

O terceiro passo é representar os resultados. Representamos as matrizes de covariância e precisão. Também representamos a métrica de seleção do modelo.

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
plt.subplots_adjust(left=0.02, right=0.98)

## plot the covariances
covs = [
    ("Empírica", emp_cov),
    ("Ledoit-Wolf", lw_cov_),
    ("GraphicalLassoCV", cov_),
    ("Verdadeira", cov),
]
vmax = cov_.max()
for i, (name, this_cov) in enumerate(covs):
    plt.subplot(2, 4, i + 1)
    plt.imshow(
        this_cov, interpolation="nearest", vmin=-vmax, vmax=vmax, cmap=plt.cm.RdBu_r
    )
    plt.xticks(())
    plt.yticks(())
    plt.title("%s covariância" % name)


## plot the precisions
precs = [
    ("Empírica", linalg.inv(emp_cov)),
    ("Ledoit-Wolf", lw_prec_),
    ("GraphicalLasso", prec_),
    ("Verdadeira", prec),
]
vmax = 0.9 * prec_.max()
for i, (name, this_prec) in enumerate(precs):
    ax = plt.subplot(2, 4, i + 5)
    plt.imshow(
        np.ma.masked_equal(this_prec, 0),
        interpolation="nearest",
        vmin=-vmax,
        vmax=vmax,
        cmap=plt.cm.RdBu_r,
    )
    plt.xticks(())
    plt.yticks(())
    plt.title("%s precisão" % name)
    if hasattr(ax, "set_facecolor"):
        ax.set_facecolor(".7")
    else:
        ax.set_axis_bgcolor(".7")

## plot the model selection metric
plt.figure(figsize=(4, 3))
plt.axes([0.2, 0.15, 0.75, 0.7])
plt.plot(model.cv_results_["alphas"], model.cv_results_["mean_test_score"], "o-")
plt.axvline(model.alpha_, color=".5")
plt.title("Seleção do modelo")
plt.ylabel("Pontuação de validação cruzada")
plt.xlabel("alpha")

plt.show()

Resumo

Este laboratório demonstrou como usar o estimador GraphicalLasso para aprender uma covariância e uma precisão esparsa a partir de um pequeno número de amostras. O tutorial cobriu a geração de dados, a estimativa da covariância e a representação dos resultados.