Vergleich von Grid Search und Successive Halving Algorithmen

Einführung

In diesem Lab werden zwei beliebte Parameter-Suchalgorithmen in der Maschinellen Lernen verglichen: Grid Search und Successive Halving. Wir werden die scikit-learn-Bibliothek in Python verwenden, um den Vergleich durchzuführen. Diese Algorithmen werden verwendet, um die besten Hyperparameter für ein gegebenes maschinelles Lernmodell zu finden.

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 des Datensatzes

Wir importieren zunächst die erforderlichen Bibliotheken und den Datensatz, der für dieses Lab benötigt wird. Wir werden die scikit-learn-Bibliothek verwenden, um einen synthetischen Datensatz zu generieren und die Parameter-Suche durchzuführen.

from time import time
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.model_selection import GridSearchCV
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV

rng = np.random.RandomState(0)
X, y = datasets.make_classification(n_samples=1000, random_state=rng)

gammas = [1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7]
Cs = [1, 10, 100, 1e3, 1e4, 1e5]
param_grid = {"gamma": gammas, "C": Cs}

clf = SVC(random_state=rng)

Führen Sie das Grid Search durch

Wir werden Grid Search verwenden, um eine Parameter-Suche auf dem SVC-Modell durchzuführen. Wir werden den generierten synthetischen Datensatz und das in Schritt 1 generierte Parameter-Gitter verwenden.

tic = time()
gs = GridSearchCV(estimator=clf, param_grid=param_grid)
gs.fit(X, y)
gs_time = time() - tic

Führen Sie Successive Halving durch

Wir werden nun eine Parameter-Suche mit Successive Halving auf dem gleichen SVC-Modell und Datensatz durchführen, der in Schritt 2 verwendet wurde.

tic = time()
gsh = HalvingGridSearchCV(
    estimator=clf, param_grid=param_grid, factor=2, random_state=rng
)
gsh.fit(X, y)
gsh_time = time() - tic

Visualisieren der Ergebnisse

Wir werden nun die Ergebnisse der Parameter-Suchalgorithmen mit Hilfe von Heatmaps visualisieren. Die Heatmaps zeigen die durchschnittlichen Test-Scores der Parameterkombinationen für die SVC-Instanz. Die Successive-Halving-Heatmap zeigt auch die Iteration, in der die Kombinationen zuletzt verwendet wurden.

def make_heatmap(ax, gs, is_sh=False, make_cbar=False):
    """Helper to make a heatmap."""
    results = pd.DataFrame(gs.cv_results_)
    results[["param_C", "param_gamma"]] = results[["param_C", "param_gamma"]].astype(
        np.float64
    )
    if is_sh:
        ## SH dataframe: get mean_test_score values for the highest iter
        scores_matrix = results.sort_values("iter").pivot_table(
            index="param_gamma",
            columns="param_C",
            values="mean_test_score",
            aggfunc="last",
        )
    else:
        scores_matrix = results.pivot(
            index="param_gamma", columns="param_C", values="mean_test_score"
        )

    im = ax.imshow(scores_matrix)

    ax.set_xticks(np.arange(len(Cs)))
    ax.set_xticklabels(["{:.0E}".format(x) for x in Cs])
    ax.set_xlabel("C", fontsize=15)

    ax.set_yticks(np.arange(len(gammas)))
    ax.set_yticklabels(["{:.0E}".format(x) for x in gammas])
    ax.set_ylabel("gamma", fontsize=15)

    ## Rotate the tick labels and set their alignment.
    plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")

    if is_sh:
        iterations = results.pivot_table(
            index="param_gamma", columns="param_C", values="iter", aggfunc="max"
        ).values
        for i in range(len(gammas)):
            for j in range(len(Cs)):
                ax.text(
                    j,
                    i,
                    iterations[i, j],
                    ha="center",
                    va="center",
                    color="w",
                    fontsize=20,
                )

    if make_cbar:
        fig.subplots_adjust(right=0.8)
        cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
        fig.colorbar(im, cax=cbar_ax)
        cbar_ax.set_ylabel("mean_test_score", rotation=-90, va="bottom", fontsize=15)


fig, axes = plt.subplots(ncols=2, sharey=True)
ax1, ax2 = axes

make_heatmap(ax1, gsh, is_sh=True)
make_heatmap(ax2, gs, make_cbar=True)

ax1.set_title("Successive Halving\ntime = {:.3f}s".format(gsh_time), fontsize=15)
ax2.set_title("GridSearch\ntime = {:.3f}s".format(gs_time), fontsize=15)

plt.show()

Zusammenfassung

Wir haben zwei beliebte Parameter-Suchalgorithmen in der Maschinellen Lernung verglichen: Grid Search und Successive Halving. Wir haben die scikit-learn-Bibliothek in Python verwendet, um den Vergleich durchzuführen. Wir haben einen synthetischen Datensatz generiert und die Parameter-Suche auf dem SVC-Modell mit beiden Algorithmen durchgeführt. Anschließend haben wir die Ergebnisse mit Hilfe von Heatmaps visualisiert. Wir haben festgestellt, dass der Successive-Halving-Algorithmus in viel weniger Zeit Parameterkombinationen finden konnte, die genauso genau wie Grid Search sind.

Vergleich zwischen Grid Search und Successive Halving