Scikit-Learn Elastic-Net-Regressionsmodell

Einführung

In diesem Lab verwenden wir das Elastic-Net-Regressionsmodell von Scikit-learn, um zu veranschaulichen, dass die Leistung eines Schätzers auf unbekannten Daten (Testdaten) nicht die gleiche ist wie die Leistung auf Trainingsdaten. Wir werden Stichproben-Daten generieren, Trainings- und Testfehler berechnen und die Ergebnissefunktionen plotten.

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 nutzen.

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

Stichproben-Daten generieren

Wir werden Stichproben-Daten mit der Funktion make_regression() aus Scikit-learn generieren. Wir werden die Anzahl der Trainingsstichproben auf 75, die Anzahl der Teststichproben auf 150 und die Anzahl der Merkmale auf 500 setzen. Wir werden auch n_informative auf 50 und shuffle auf False setzen.

import numpy as np
from sklearn import linear_model
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

n_samples_train, n_samples_test, n_features = 75, 150, 500
X, y, coef = make_regression(
    n_samples=n_samples_train + n_samples_test,
    n_features=n_features,
    n_informative=50,
    shuffle=False,
    noise=1.0,
    coef=True,
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=n_samples_train, test_size=n_samples_test, shuffle=False
)

Trainings- und Testfehler berechnen

Wir werden die Trainings- und Testfehler mit dem Elastic-Net-Regressionsmodell von Scikit-learn berechnen. Wir werden den Regularisierungsparameter alpha auf einen Wertebereich von 10^-5 bis 10^1 mit np.logspace() setzen. Wir werden auch das l1_ratio auf 0,7 und max_iter auf 10000 setzen.

alphas = np.logspace(-5, 1, 60)
enet = linear_model.ElasticNet(l1_ratio=0.7, max_iter=10000)
train_errors = list()
test_errors = list()
for alpha in alphas:
    enet.set_params(alpha=alpha)
    enet.fit(X_train, y_train)
    train_errors.append(enet.score(X_train, y_train))
    test_errors.append(enet.score(X_test, y_test))

i_alpha_optim = np.argmax(test_errors)
alpha_optim = alphas[i_alpha_optim]
print("Optimaler Regularisierungsparameter : %s" % alpha_optim)

Ergebnissefunktionen plotten

Wir werden die Ergebnissefunktionen mit der Bibliothek matplotlib plotten. Wir werden die Funktion plt.subplot() verwenden, um zwei Teilplots zu erstellen. Im ersten Teilplot werden wir die Trainings- und Testfehler als Funktion des Regularisierungsparameters plotten. Wir werden auch eine vertikale Linie bei dem optimalen Regularisierungsparameter plotten. Im zweiten Teilplot werden wir die wahren Koeffizienten und die geschätzten Koeffizienten plotten.

import matplotlib.pyplot as plt

plt.subplot(2, 1, 1)
plt.semilogx(alphas, train_errors, label="Train")
plt.semilogx(alphas, test_errors, label="Test")
plt.vlines(
    alpha_optim,
    plt.ylim()[0],
    np.max(test_errors),
    color="k",
    linewidth=3,
    label="Optimum on test",
)
plt.legend(loc="lower right")
plt.ylim([0, 1.2])
plt.xlabel("Regularisierungsparameter")
plt.ylabel("Leistung")

## Zeige geschätzten coef_ vs wahren coef
plt.subplot(2, 1, 2)
plt.plot(coef, label="Wahrer coef")
plt.plot(coef_, label="Geschätzter coef")
plt.legend()
plt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.26)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man das Elastic-Net-Regressionsmodell von Scikit-learn verwendet, um Trainings- und Testfehler zu berechnen und die Ergebnissefunktionen zu plotten. Wir haben auch gelernt, dass die Leistung eines Schätzers auf unbekannten Daten (Testdaten) nicht die gleiche ist wie die Leistung auf Trainingsdaten. Wir haben Stichproben-Daten generiert, Trainings- und Testfehler berechnet und die Ergebnissefunktionen mit den Funktionen make_regression(), linear_model.ElasticNet(), train_test_split(), np.logspace() und matplotlib geplottet.