Sparse Inverse Kovarianzschätzung

Einführung

In diesem Lab wird gezeigt, wie der GraphicalLasso-Schätzer verwendet werden kann, um aus einer geringen Anzahl von Proben eine Kovarianz und eine spärliche Präzision zu lernen. Der Tutorial umfasst das Generieren von Daten, die Schätzung der Kovarianz und das Plotten der Ergebnisse.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Daten generieren

Der erste Schritt besteht darin, die Daten zu generieren. In diesem Fall generieren wir einen kleinen Datensatz mit 60 Proben und 20 Merkmalen. Wir verwenden eine spärliche Inverse Kovarianzmatrix, um günstige Wiederherstellungsbedingungen zu gewährleisten.

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)

Kovarianz schätzen

Der zweite Schritt besteht darin, die Kovarianz zu schätzen. Wir verwenden GraphicalLassoCV, um die spärliche Präzisionsmatrix zu lernen. Wir vergleichen auch die Ergebnisse mit dem Ledoit-Wolf-Schätzer.

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

Ergebnisse plotten

Der dritte Schritt besteht darin, die Ergebnisse zu plotten. Wir plotten die Kovarianzen und die Präzisionen. Wir plotten auch das Modellauswahlmaß.

import matplotlib.pyplot as plt

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

## plot the covariances
covs = [
    ("Empirisch", emp_cov),
    ("Ledoit-Wolf", lw_cov_),
    ("GraphicalLassoCV", cov_),
    ("Wahr", 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 Kovarianz" % name)


## plot the precisions
precs = [
    ("Empirisch", linalg.inv(emp_cov)),
    ("Ledoit-Wolf", lw_prec_),
    ("GraphicalLasso", prec_),
    ("Wahr", 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 Präzision" % 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("Modellauswahl")
plt.ylabel("Quersvalidierungsscore")
plt.xlabel("alpha")

plt.show()

Zusammenfassung

In diesem Lab wurde gezeigt, wie der GraphicalLasso-Schätzer verwendet werden kann, um aus einer geringen Anzahl von Proben eine Kovarianz und eine spärliche Präzision zu lernen. Das Tutorial umfasste das Generieren von Daten, die Schätzung der Kovarianz und das Plotten der Ergebnisse.