Kreuzvalidierung mit linearen Modellen

Einführung

In diesem Lab verwenden wir Kreuzvalidierung mit linearen Modellen. Wir verwenden den Diabetes-Datensatz und wenden GridSearchCV an, um den besten Alpha-Wert für die Lasso-Regression zu finden. Anschließend werden wir die Fehler plotten und LassoCV verwenden, um zu sehen, wie vertrauenswürdig die Auswahl von Alpha ist.

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

Laden und Vorbereiten des Datensatzes

Zunächst werden wir den Diabetes-Datensatz laden und vorbereiten. Für diese Übung verwenden wir nur die ersten 150 Stichproben.

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets

X, y = datasets.load_diabetes(return_X_y=True)
X = X[:150]
y = y[:150]

Anwenden von GridSearchCV

Als nächstes werden wir GridSearchCV anwenden, um den besten Alpha-Wert für die Lasso-Regression zu finden. Wir werden einen Bereich von Alpha-Werten von 10^-4 bis 10^-0,5 mit 30 Werten dazwischen verwenden. Wir werden 5 Folds für die Kreuzvalidierung verwenden.

from sklearn.linear_model import Lasso
from sklearn.model_selection import GridSearchCV

lasso = Lasso(random_state=0, max_iter=10000)
alphas = np.logspace(-4, -0.5, 30)

tuned_parameters = [{"alpha": alphas}]
n_folds = 5

clf = GridSearchCV(lasso, tuned_parameters, cv=n_folds, refit=False)
clf.fit(X, y)

Fehler plotten

Wir werden nun die Fehler plotten, um den besten Alpha-Wert zu sehen. Wir werden die durchschnittlichen Test-Scores und die Standardfehler der Scores plotten.

scores = clf.cv_results_["mean_test_score"]
scores_std = clf.cv_results_["std_test_score"]

plt.figure().set_size_inches(8, 6)
plt.semilogx(alphas, scores)

std_error = scores_std / np.sqrt(n_folds)

plt.semilogx(alphas, scores + std_error, "b--")
plt.semilogx(alphas, scores - std_error, "b--")

plt.fill_between(alphas, scores + std_error, scores - std_error, alpha=0.2)

plt.ylabel("CV score +/- std error")
plt.xlabel("alpha")
plt.axhline(np.max(scores), linestyle="--", color=".5")
plt.xlim([alphas[0], alphas[-1]])

Verwenden von LassoCV, um die Alpha-Auswahl zu überprüfen

Schließlich werden wir LassoCV verwenden, um zu sehen, wie vertrauenswürdig die Auswahl von Alpha ist. Wir werden KFold mit 3 Folds verwenden.

from sklearn.linear_model import LassoCV
from sklearn.model_selection import KFold

lasso_cv = LassoCV(alphas=alphas, random_state=0, max_iter=10000)
k_fold = KFold(3)

print("Antwort auf die Bonus-Frage:", "wie vertrauenswürdig ist die Auswahl von Alpha?")
print()
print("Alpha-Parameter, die die Verallgemeinerungsscore auf verschiedenen")
print("Teilmengen der Daten maximieren:")
for k, (train, test) in enumerate(k_fold.split(X, y)):
    lasso_cv.fit(X[train], y[train])
    print(
        "[Fold {0}] alpha: {1:.5f}, score: {2:.5f}".format(
            k, lasso_cv.alpha_, lasso_cv.score(X[test], y[test])
        )
    )

print()
print("Antwort: Nicht sehr, da wir für verschiedene Teilmengen der Daten unterschiedliche Alphas erhalten haben und darüber hinaus die Scores für diese Alphas sich erheblich unterscheiden.")

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Kreuzvalidierung mit linearen Modellen anwendet. Wir haben GridSearchCV verwendet, um den besten Alpha-Wert für die Lasso-Regression zu finden und die Fehler geplottet, um die Auswahl zu visualisieren. Wir haben auch LassoCV verwendet, um die Auswahl von Alpha zu überprüfen.