Modellkomplexität und durch Kreuzvalidierung ermittelter Score im Gleichgewicht bringen

Einführung

In diesem Lab werden wir lernen, wie wir die Modellkomplexität und die durch Kreuzvalidierung ermittelte Punktzahl im Verhältnis zueinander abstimmen, indem wir eine annehmbare Genauigkeit innerhalb von 1 Standardabweichung von der besten Genauigkeitspunkzahl finden und dabei die Anzahl der PCA-Komponenten minimieren. Wir werden den digits-Datensatz aus scikit-learn und eine Pipeline verwenden, die aus PCA und LinearSVC besteht.

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 der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Bibliotheken importieren

Wir beginnen mit dem Import der erforderlichen Bibliotheken für dieses Lab.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC

Funktionen definieren

Wir werden zwei Funktionen definieren, die später im Lab verwendet werden.

def lower_bound(cv_results):
    """
    Berechnet die untere Grenze innerhalb von 1 Standardabweichung
    der besten `mean_test_scores`.

    Parameter
    ----------
    cv_results : dict von numpy(masked) ndarrays
        Siehe Attribut cv_results_ von `GridSearchCV`

    Rückgabe
    -------
    float
        Untere Grenze innerhalb von 1 Standardabweichung der
        besten `mean_test_score`.
    """
    best_score_idx = np.argmax(cv_results["mean_test_score"])

    return (
        cv_results["mean_test_score"][best_score_idx]
        - cv_results["std_test_score"][best_score_idx]
    )


def best_low_complexity(cv_results):
    """
    Stellt ein Gleichgewicht zwischen Modellkomplexität und
    durch Kreuzvalidierung ermittelter Punktzahl her.

    Parameter
    ----------
    cv_results : dict von numpy(masked) ndarrays
        Siehe Attribut cv_results_ von `GridSearchCV`.

    Rückgabe
    ------
    int
        Index eines Modells, das die wenigsten PCA-Komponenten hat,
        während dessen Testscore innerhalb von 1 Standardabweichung der besten
        `mean_test_score` liegt.
    """
    threshold = lower_bound(cv_results)
    candidate_idx = np.flatnonzero(cv_results["mean_test_score"] >= threshold)
    best_idx = candidate_idx[
        cv_results["param_reduce_dim__n_components"][candidate_idx].argmin()
    ]
    return best_idx

Daten laden und Pipeline definieren

Wir werden den digits-Datensatz aus scikit-learn laden und eine Pipeline definieren, die aus PCA und LinearSVC besteht.

pipe = Pipeline(
    [
        ("reduce_dim", PCA(random_state=42)),
        ("classify", LinearSVC(random_state=42, C=0.01, dual="auto")),
    ]
)

X, y = load_digits(return_X_y=True)

Parameter für GridSearchCV definieren

Wir werden die Parameter für GridSearchCV definieren.

param_grid = {"reduce_dim__n_components": [6, 8, 10, 12, 14]}

GridSearchCV-Objekt definieren

Wir werden das GridSearchCV-Objekt definieren und das Modell anpassen.

grid = GridSearchCV(
    pipe,
    cv=10,
    n_jobs=1,
    param_grid=param_grid,
    scoring="accuracy",
    refit=best_low_complexity,
)

grid.fit(X, y)

Ergebnisse visualisieren

Wir werden die Ergebnisse visualisieren, indem wir die Genauigkeit gegen die Anzahl der PCA-Komponenten aufzeichnen.

n_components = grid.cv_results_["param_reduce_dim__n_components"]
test_scores = grid.cv_results_["mean_test_score"]

plt.figure()
plt.bar(n_components, test_scores, width=1.3, color="b")

lower = lower_bound(grid.cv_results_)
plt.axhline(np.max(test_scores), linestyle="--", color="y", label="Best score")
plt.axhline(lower, linestyle="--", color=".5", label="Best score - 1 std")

plt.title("Balance model complexity and cross-validated score")
plt.xlabel("Number of PCA components used")
plt.ylabel("Digit classification accuracy")
plt.xticks(n_components.tolist())
plt.ylim((0, 1.0))
plt.legend(loc="upper left")

best_index_ = grid.best_index_

print("The best_index_ is %d" % best_index_)
print("The n_components selected is %d" % n_components[best_index_])
print(
    "The corresponding accuracy score is %.2f"
    % grid.cv_results_["mean_test_score"][best_index_]
)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Modellkomplexität und die durch Kreuzvalidierung ermittelte Score mit Hilfe von PCA und LinearSVC in einem ausgewogenen Verhältnis halten kann. Wir haben GridSearchCV verwendet, um die optimale Anzahl von PCA-Komponenten zu finden, während wir den Genauigkeitsscore innerhalb eines Standardabweichungsbereichs um den besten Score maximierten. Wir haben die Ergebnisse auch visualisiert, um den Kompromiss zwischen Modellkomplexität und Genauigkeit besser zu verstehen.