Dimensionalitätsreduzierung mit Pipeline und GridSearchCV

Einführung

In diesem Lab wird die Verwendung von Pipeline und GridSearchCV in scikit-learn demonstriert, um in einem einzelnen CV-Lauf über verschiedene Klassen von Schätzern zu optimieren. Wir werden einen Support-Vektor-Klassifizierer verwenden, um handschriftliche Ziffern aus dem populären MNIST-Datensatz zu prognostizieren.

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.

Importieren der erforderlichen Bibliotheken und Laden der Daten

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken und dem Laden des Digits-Datensatzes aus scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
from sklearn.decomposition import PCA, NMF
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.preprocessing import MinMaxScaler

X, y = load_digits(return_X_y=True)

Erstellen eines Pipelines und Definieren eines Parameter-Grids

Wir werden eine Pipeline erstellen, die zunächst eine Dimensionsreduzierung durchführt und anschließend mit einem Support-Vektor-Klassifizierer eine Vorhersage macht. Wir werden uns auf die unsupervised PCA- und NMF-Dimensionsreduzierungen stützen und zusätzlich eine einvariate Merkmalsauswahl während der Grid-Suche durchführen.

pipe = Pipeline(
    [
        ("scaling", MinMaxScaler()),
        ## der reduce_dim-Schritt wird durch das param_grid befüllt
        ("reduce_dim", "passthrough"),
        ("classify", LinearSVC(dual=False, max_iter=10000)),
    ]
)

N_FEATURES_OPTIONS = [2, 4, 8]
C_OPTIONS = [1, 10, 100, 1000]
param_grid = [
    {
        "reduce_dim": [PCA(iterated_power=7), NMF(max_iter=1_000)],
        "reduce_dim__n_components": N_FEATURES_OPTIONS,
        "classify__C": C_OPTIONS,
    },
    {
        "reduce_dim": [SelectKBest(mutual_info_classif)],
        "reduce_dim__k": N_FEATURES_OPTIONS,
        "classify__C": C_OPTIONS,
    },
]
reducer_labels = ["PCA", "NMF", "KBest(mutual_info_classif)"]

Erstellen eines GridSearchCV-Objekts und Anpassen der Daten

Wir werden ein GridSearchCV-Objekt mit der Pipeline und dem Parameter-Grid erstellen, die wir im vorherigen Schritt definiert haben. Anschließend werden wir die Daten an das Objekt anpassen.

grid = GridSearchCV(pipe, n_jobs=1, param_grid=param_grid)
grid.fit(X, y)

Ergebnisse grafisch darstellen

Wir werden die Ergebnisse von GridSearchCV mithilfe eines Balkendiagramms darstellen. Dies wird uns ermöglichen, die Genauigkeit unterschiedlicher Merkmalsreduktionstechniken zu vergleichen.

import pandas as pd

mean_scores = np.array(grid.cv_results_["mean_test_score"])
## Die Scores folgen der Reihenfolge der param_grid-Iteration, was alphabetisch ist
mean_scores = mean_scores.reshape(len(C_OPTIONS), -1, len(N_FEATURES_OPTIONS))
## Wähle den Score für das beste C
mean_scores = mean_scores.max(axis=0)
## Erstelle einen DataFrame, um die Grafik zu erleichtern
mean_scores = pd.DataFrame(
    mean_scores.T, index=N_FEATURES_OPTIONS, columns=reducer_labels
)

ax = mean_scores.plot.bar()
ax.set_title("Vergleich von Merkmalsreduktionstechniken")
ax.set_xlabel("Reduzierte Anzahl der Merkmale")
ax.set_ylabel("Genauigkeit der Zifferklassifizierung")
ax.set_ylim((0, 1))
ax.legend(loc="upper left")

plt.show()

Cachen von Transformatoren in einer Pipeline

Wir werden nun demonstrieren, wie der Zustand eines bestimmten Transformators gespeichert werden kann, da er wieder verwendet werden könnte. Das Verwenden einer Pipeline in GridSearchCV löst solche Situationen aus. Daher verwenden wir das Argument memory, um das Caching zu aktivieren.

from joblib import Memory
from shutil import rmtree

## Erstelle einen temporären Ordner, um die Transformatoren der Pipeline zu speichern
location = "cachedir"
memory = Memory(location=location, verbose=10)
cached_pipe = Pipeline(
    [("reduce_dim", PCA()), ("classify", LinearSVC(dual=False, max_iter=10000))],
    memory=memory,
)

## Diesmal wird eine gecachte Pipeline im Grid-Search verwendet

## Lösche den temporären Cache vor dem Beenden
memory.clear(warn=False)
rmtree(location)

Zusammenfassung

In diesem Lab haben wir Pipeline und GridSearchCV in scikit-learn verwendet, um in einem einzelnen CV-Lauf über verschiedene Klassen von Schätzern zu optimieren. Wir haben auch gezeigt, wie der Zustand eines bestimmten Transformators mithilfe des memory-Arguments gespeichert werden kann, um das Caching zu aktivieren. Dies kann besonders nützlich sein, wenn das Anpassen eines Transformators aufwendig ist.