Sukzessive Halbierung von Iterationen

Einführung

In diesem Lab lernst du, wie du die sukzessive Halbierungsmethode verwenden kannst, um iterativ die beste Parameterkombination aus mehreren Kandidaten auszuwählen. Diese Methode wird in den Klassen HalvingGridSearchCV und HalvingRandomSearchCV aus der Scikit-learn-Bibliothek implementiert. In diesem Lab wird die Klasse HalvingRandomSearchCV verwendet.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicke in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal musst du 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 du während des Lernens Probleme hast, kannst du Labby gerne fragen. Gib nach der Sitzung Feedback, und wir werden das Problem für dich prompt beheben.

Skills Graph

Importieren der erforderlichen Bibliotheken

In diesem Lab werden die folgenden Bibliotheken verwendet: pandas, numpy, matplotlib, sklearn.datasets, RandomForestClassifier, randint und HalvingRandomSearchCV. Importiere sie mit dem folgenden Code:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import randint
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingRandomSearchCV

Laden des Datensatzes

Die Funktion make_classification aus dem Modul sklearn.datasets wird verwendet, um einen Klassifizierungsdatensatz zu generieren. Der Datensatz enthält 400 Proben mit 12 Merkmalen. Der Code zum Laden des Datensatzes lautet wie folgt:

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

Definieren des Parameterspaces

Definiere ein Dictionary param_dist, das die Hyperparameter und ihre jeweiligen Werte enthält, durch die gesucht werden soll. Die Hyperparameter sind max_depth, max_features, min_samples_split, bootstrap und criterion. Der Suchbereich für max_features und min_samples_split wird mit der Funktion randint aus dem Modul scipy.stats definiert. Der Code zum Definieren des Parameterspaces lautet wie folgt:

param_dist = {
    "max_depth": [3, None],
    "max_features": randint(1, 6),
    "min_samples_split": randint(2, 11),
    "bootstrap": [True, False],
    "criterion": ["gini", "entropy"],
}

Erstellen eines Objekts für die sukzessive Zufallssuche

Erstelle ein HalvingRandomSearchCV-Objekt, um durch den Parameterspace zu durchsuchen. Das Objekt nimmt die folgenden Argumente entgegen:

• estimator: der Optimierungsalgorithmus
• param_distributions: der Parameterspace, durch den gesucht werden soll
• factor: der Faktor, um den die Anzahl der Kandidaten in jeder Iteration reduziert wird
• random_state: der Zufallszustand, der für die Suche verwendet wird

Der Code zum Erstellen des Objekts lautet wie folgt:

clf = RandomForestClassifier(n_estimators=20, random_state=rng)
rsh = HalvingRandomSearchCV(
    estimator=clf, param_distributions=param_dist, factor=2, random_state=rng
)

Anpassen des Objekts für die sukzessive Zufallssuche

Passe das HalvingRandomSearchCV-Objekt an den Datensatz an, indem du die fit-Methode verwendest. Der Code zum Anpassen des Objekts lautet wie folgt:

rsh.fit(X, y)

Analysieren der Ergebnisse

Das Attribut cv_results_ des Suchobjekts enthält die Ergebnisse der Suche. Konvertiere es in einen pandas-DataFrame mit dem folgenden Code:

results = pd.DataFrame(rsh.cv_results_)

Die Spalte params_str wird erstellt, indem die Spalte params in einen String umgewandelt wird. Entferne doppelte Zeilen, die die gleichen params_str- und iter-Werte haben:

results["params_str"] = results.params.apply(str)
results.drop_duplicates(subset=("params_str", "iter"), inplace=True)

Die durchschnittlichen Testscores werden dann mithilfe der pivot-Methode in Bezug auf die Iterationsnummer und die Parameterkombination umgeformt:

mean_scores = results.pivot(
    index="iter", columns="params_str", values="mean_test_score"
)

Schließlich werden die durchschnittlichen Testscores über die Iterationen mit dem folgenden Code geplottet:

ax = mean_scores.plot(legend=False, alpha=0.6)

labels = [
    f"iter={i}\nn_samples={rsh.n_resources_[i]}\nn_candidates={rsh.n_candidates_[i]}"
    for i in range(rsh.n_iterations_)
]

ax.set_xticks(range(rsh.n_iterations_))
ax.set_xticklabels(labels, rotation=45, multialignment="left")
ax.set_title("Scores of candidates over iterations")
ax.set_ylabel("mean test score", fontsize=15)
ax.set_xlabel("iterations", fontsize=15)
plt.tight_layout()
plt.show()

Interpretation der Ergebnisse

Das Diagramm zeigt die durchschnittlichen Testscores der Kandidaten über die Iterationen. Bei der ersten Iteration werden alle Kandidaten mit einer geringen Menge an Ressourcen ausgewertet. Bei der zweiten Iteration werden nur die besten Hälfte der Kandidaten mit doppelter Menge an Ressourcen ausgewertet. Dieser Prozess wird wiederholt, bis zur letzten Iteration, bei der nur noch 2 Kandidaten übrig bleiben. Der beste Kandidat ist derjenige mit dem höchsten durchschnittlichen Testscore bei der letzten Iteration.

Zusammenfassung

In diesem Lab hast du gelernt, wie du die sukzessive Halbierungsmethode der Suche verwendest, um iterativ die beste Parameterkombination aus mehreren Kandidaten auszuwählen. Die Klasse HalvingRandomSearchCV aus der Scikit-learn-Bibliothek wurde verwendet, um die Suchmethode zu implementieren. Die Ergebnisse der Suche wurden mithilfe eines Diagramms der durchschnittlichen Testscores über die Iterationen analysiert und interpretiert.