Grid Search in Python zur Hyperparameter-Optimierung

Das Tuning von Hyperparametern ist ein zentraler Bestandteil, um Machine-Learning-Modelle zu verbessern. Eine der verlässlichsten Methoden dafür ist die Grid Search, bei der Kombinationen von Hyperparametern systematisch geprüft werden, um die leistungsstärkste Konfiguration zu ermitteln.

In dieser Anleitung erfährst du, wie du Grid Search in Python mit GridSearchCV aus scikit-learn einsetzt, welche Unterschiede es zwischen Grid Search und Random Search gibt und welche bewährten Vorgehensweisen helfen, Overfitting zu reduzieren und die Laufzeit effizienter zu gestalten.

Was ist Grid Search in Python?

Im Machine Learning ist ein Hyperparameter ein Wert, der bereits vor dem Training eines Modells festgelegt wird. Typische Beispiele für Hyperparameter sind die Lernrate, die Batch-Größe oder die Anzahl versteckter Schichten in einem neuronalen Netzwerk.

Welche Hyperparameter gewählt werden, hat oft großen Einfluss auf die Qualität eines Modells. Grid Search ist ein Verfahren, mit dem sich die beste Kombination von Hyperparametern finden lässt, indem alle möglichen Varianten innerhalb eines definierten Bereichs systematisch durchgespielt werden. Da jede festgelegte Kombination überprüft wird, hilft diese vollständige Suche dabei, genau die Parameterkonstellation zu finden, die das beste Modellergebnis liefert.

So funktioniert Grid Search

Der Ablauf einer Grid Search lässt sich in die folgenden Schritte unterteilen:

Hyperparameter-Werte festlegen

Zunächst wird für jeden Hyperparameter eine Auswahl möglicher Werte definiert, die getestet werden soll. Wenn du beispielsweise die Lernrate eines neuronalen Netzwerks optimieren möchtest, könntest du Werte zwischen 0.001 und 0.1 festlegen.

Das Modell mit allen Kombinationen trainieren

Im nächsten Schritt trainiert die Grid Search das Modell mit jeder möglichen Kombination der ausgewählten Hyperparameter. Gibt es zum Beispiel 3 Hyperparameter mit jeweils 5 möglichen Werten, dann wird das Modell insgesamt 5^3 = 125 Mal trainiert.

Leistung per Cross-Validation bewerten

Nachdem das Modell mit jeder Kombination trainiert wurde, bewertet die Grid Search die Ergebnisse mithilfe von Cross-Validation. Dieses Verfahren dient dazu, einzuschätzen, wie gut das Modell wahrscheinlich mit unbekannten Daten umgehen wird.

Die beste Kombination auswählen

Am Ende wird die Kombination gewählt, die die stärksten Ergebnisse liefert. Häufig geschieht das auf Basis der höchsten Accuracy, möglich ist aber auch die Auswahl anhand anderer Kennzahlen wie Precision, Recall oder F1-Score.

Die folgende Tabelle verdeutlicht das Grundprinzip der Grid Search:

Jede Zeile in dieser Tabelle steht für eine eindeutige Hyperparameter-Kombination, während die letzte Spalte die Leistung des Modells mit genau dieser Konfiguration zeigt. Ziel der Grid Search ist es, die Kombination zu finden, die das beste Ergebnis liefert.

Grid Search in Python umsetzen

In diesem Abschnitt gehst du Schritt für Schritt durch eine praktische Umsetzung von Grid Search in Python mit der Klasse GridSearchCV aus scikit-learn. Das Beispiel konzentriert sich auf das Tuning eines Support-Vector-Machine-Modells (SVM).

Schritt 1 – Bibliotheken importieren

Zu Beginn werden die benötigten Bibliotheken importiert. In diesem Beispiel wird scikit-learn für das SVM-Modell und die Grid Search verwendet, während numpy für die Datenverarbeitung zuständig ist.

import numpy as np
from sklearn import svm
from sklearn.model_selection import GridSearchCV

Schritt 2 – Daten laden

Als Nächstes wird der Datensatz geladen. In diesem Beispiel kommt der Iris-Datensatz zum Einsatz, da er zu den bekanntesten Datensätzen im Machine Learning gehört.

from sklearn import datasets
iris = datasets.load_iris()
# Inspect the dataset
print("Dataset loaded successfully.")
print("Dataset shape:", iris.data.shape)
print("Number of classes:", len(np.unique(iris.target)))
print("Class names:", iris.target_names)
print("Feature names:", iris.feature_names)

Ausgabe

Dataset loaded successfully.
Dataset shape: (150, 4)
Number of classes: 3
Class names: ['setosa' 'versicolor' 'virginica']
Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

Schritt 3 – Modell und Hyperparameter definieren

Jetzt werden das SVM-Modell und die Hyperparameter festgelegt, die optimiert werden sollen. In diesem Fall werden die Parameter kernel und C abgestimmt.

# This block creates a Support Vector Machine (SVM) model and sets up a parameter grid for hyperparameter tuning.
# The SVM model is initialized with the svm.SVC() function from scikit-learn.
# The parameter grid is defined as a dictionary containing the hyperparameters to tune and their candidate values.
# Here, the hyperparameters are 'C' (the regularization parameter) and 'kernel' (the kernel type).
# The values for 'C' are [1, 10, 100, 1000], so the model will be trained with several regularization strengths.
# The values for 'kernel' are ['linear', 'rbf'], so the model will be tested with both a linear kernel and an RBF kernel.
model = svm.SVC()
param_grid = {'C': [1, 10, 100, 1000], 'kernel': ['linear', 'rbf']}

Schritt 4 – Grid Search ausführen

In diesem Schritt wird die Grid Search mit der Klasse GridSearchCV aus scikit-learn ausgeführt. Das Ziel besteht darin, die besten Hyperparameter zu finden, indem jede erlaubte Kombination systematisch bewertet und per Cross-Validation verglichen wird.

In diesem Beispiel wird eine 5-fache Cross-Validation mit cv=5 verwendet. Das bedeutet, dass der Datensatz in 5 Teile aufgeteilt wird und das Modell über diese Aufteilungen hinweg wiederholt trainiert und validiert wird. Aus dem Durchschnitt der Ergebnisse über alle Folds hinweg wird dann die beste Hyperparameter-Kombination bestimmt.

grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(iris.data, iris.target)

Der oben gezeigte Code erstellt ein GridSearchCV-Objekt mit folgenden Parametern:

• model: Das zuvor definierte SVM-Modell.
• param_grid: Das Dictionary mit den zu testenden Hyperparametern und ihren möglichen Werten.
• cv=5: Die Anzahl der Folds für die Cross-Validation.

Danach wird die Methode fit auf dem grid_search-Objekt aufgerufen und erhält die Merkmalsdaten (iris.data) sowie die Zielwerte (iris.target). Dadurch startet der vollständige Suchprozess, jede Hyperparameter-Kombination wird bewertet und die effektivste Variante wird identifiziert.

Schritt 5 – Ergebnisse anzeigen

Zum Schluss lassen sich die Resultate der Grid Search ausgeben. Dazu gehören sowohl die besten Hyperparameter-Werte als auch der zugehörige Accuracy-Wert.

print("Best hyperparameters: ", grid_search.best_params_)
print("Best accuracy: ", grid_search.best_score_)

# Visualizing the best hyperparameters
import matplotlib.pyplot as plt
import numpy as np

C_values = [1, 10, 100, 1000]
kernel_values = ['linear', 'rbf']
scores = grid_search.cv_results_['mean_test_score'].reshape(len(C_values), len(kernel_values))

plt.figure(figsize=(8, 6))
plt.subplots_adjust(left=.2, right=0.95, bottom=0.15, top=0.95)
plt.imshow(scores, interpolation='nearest', cmap=plt.cm.hot)
plt.xlabel('kernel')
plt.ylabel('C')
plt.colorbar()
plt.xticks(np.arange(len(kernel_values)), kernel_values)
plt.yticks(np.arange(len(C_values)), C_values)
plt.title('Grid Search Mean Test Scores')
plt.show()

Ausgabe

Best hyperparameters:  {'C': 1, 'kernel': 'linear'}
Best accuracy:  0.9800000000000001
plot of performance

Der beste Wert für den Hyperparameter C ist 1. Dieser Wert steuert die Stärke der Regularisierung. Ein kleinerer C-Wert bedeutet eine stärkere Regularisierung. Der beste Wert für kernel ist linear, also der Kernel-Typ, der im Algorithmus verwendet wird.

Die höchste Accuracy mit diesen Einstellungen beträgt 0.98. Das bedeutet, dass das Modell während der Cross-Validation 98 % der Instanzen korrekt vorhersagt.

Damit ist die Umsetzung einer Grid Search in Python abgeschlossen. Diese Technik lässt sich auch auf viele andere Machine-Learning-Modelle anwenden, um deren Hyperparameter zu optimieren.

Grid Search vs. Random Search

Eine weitere verbreitete Methode zur Hyperparameter-Optimierung ist Random Search. Im Gegensatz zur vollständigen Prüfung aller Möglichkeiten werden dabei Hyperparameter-Kombinationen zufällig ausgewählt.

from sklearn.model_selection import RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Load dataset and split into training and test sets
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

# Define the parameter grid
param_distributions = {'C': [1, 10, 100, 1000], 'kernel': ['linear', 'rbf']}

# Initialize the RandomizedSearchCV object
random_search = RandomizedSearchCV(SVC(), param_distributions=param_distributions, n_iter=5, cv=5, scoring='accuracy', random_state=42)

# Fit the model
random_search.fit(X_train, y_train)

# Print the best parameters
print("Best Parameters:", random_search.best_params_)

Ausgabe

Best Parameters: {'kernel': 'linear', 'C': 1}

Wann du Grid Search und wann Random Search verwenden solltest

Ob sich eher Grid Search oder Random Search eignet, hängt von mehreren Faktoren ab. Dazu zählen insbesondere die Größe des Hyperparameter-Raums, die verfügbaren Rechenressourcen und die Ziele deines Machine-Learning-Projekts.

Grid Search ist ideal, wenn

der Hyperparameter-Raum klein ist: Wenn nur wenige Hyperparameter und Werte getestet werden müssen, kann Grid Search alle Kombinationen gründlich durchgehen.

ausreichend Rechenleistung vorhanden ist: Da Grid Search rechenintensiv sein kann, eignet sie sich besonders dann, wenn leistungsstarke Hardware oder Cloud-Ressourcen verfügbar sind.

maximale Genauigkeit entscheidend ist: Weil alle Kombinationen geprüft werden, kann Grid Search mitunter die bessere Accuracy erzielen. Das ist vor allem bei Anwendungen relevant, in denen die Leistung höchste Priorität hat.

einfachere Modelle verwendet werden: Für Modelle mit wenigen Hyperparametern ist eine vollständige Suche meist noch praktikabel und dadurch gut umsetzbar.

Random Search ist besser geeignet, wenn

der Hyperparameter-Raum groß ist: Bei Modellen mit vielen Hyperparametern oder sehr breiten Wertebereichen kann Random Search den Raum effizient erkunden, ohne jede einzelne Option testen zu müssen.

nur begrenzte Ressourcen zur Verfügung stehen: Random Search benötigt weniger Rechenleistung und ist daher sinnvoll, wenn Hardware oder Zeit knapp sind.

schnellere Ergebnisse erforderlich sind: Wenn eine rasche Antwort wichtiger ist als das absolut beste Ergebnis, bietet Random Search einen guten Kompromiss zwischen Leistung und Rechenaufwand.

komplexere Modelle eingesetzt werden: Bei Modellen mit vielen Hyperparametern ist Random Search oft realistischer, da eine vollständige Suche zu aufwendig wäre.

Zusammengefasst solltest du Grid Search verwenden, wenn der Hyperparameter-Raum überschaubar ist und du die zusätzlichen Rechenkosten für potenziell bessere Genauigkeit in Kauf nehmen kannst. Random Search ist die bessere Wahl, wenn der Suchraum größer ist, Ressourcen begrenzt sind oder schnellere Ergebnisse benötigt werden.

So lässt sich die Ausführungszeit der Grid Search optimieren

Da Grid Search jede mögliche Hyperparameter-Kombination bewertet, kann sie sehr rechenintensiv sein. Die folgenden Strategien helfen dabei, die Ausführungszeit zu verkürzen:

Einen kleineren Suchraum verwenden

Wenn du die Anzahl der Hyperparameter und deren mögliche Werte reduzierst, sinkt der Rechenaufwand deutlich. Statt sehr breite Wertebereiche zu prüfen, solltest du dich auf kleinere und relevantere Teilmengen konzentrieren. Vorab durchgeführte Tests können helfen, vielversprechende Bereiche zu identifizieren, bevor die eigentliche Grid Search startet.

Parallele Verarbeitung nutzen

Grid Search lässt sich parallelisieren, sodass mehrere CPU-Kerne gleichzeitig arbeiten. In GridSearchCV kannst du dafür den Parameter n_jobs auf -1 setzen. Dadurch werden alle verfügbaren Kerne genutzt, mehrere Hyperparameter-Kombinationen gleichzeitig bewertet und die Gesamtlaufzeit verkürzt.

Für das Tuning einen kleineren Datensatz einsetzen

Eine weitere Möglichkeit besteht darin, die Hyperparameter zunächst auf einer reduzierten Teilmenge der Daten abzustimmen. So lassen sich vielversprechende Parameterkombinationen schneller finden. Sobald die besten Einstellungen feststehen, können diese anschließend auf den vollständigen Datensatz für das finale Modelltraining übertragen werden. Gerade bei sehr großen Datensätzen spart dieser Ansatz viel Zeit.

Early-Stopping-Techniken einsetzen

Einige Machine-Learning-Bibliotheken wie XGBoost unterstützen Early Stopping. Dabei wird das Training vorzeitig beendet, wenn sich die Leistung des Modells auf einem Validierungsdatensatz nicht weiter verbessert. Durch das frühzeitige Stoppen unnötiger Iterationen lässt sich die Laufzeit reduzieren, ohne auf sinnvolle Hyperparameter-Ergebnisse verzichten zu müssen.

Mit diesen Strategien wird der Einsatz von Grid Search auch bei größeren Datensätzen und komplexeren Modellen praktikabler und effizienter.

FAQs

1. Was macht GridSearchCV()?

GridSearchCV automatisiert das Hyperparameter-Tuning, indem per Cross-Validation die beste Kombination von Hyperparametern ermittelt wird.

2. Wie wird Grid Search in Python eingesetzt?

Du kannst Grid Search in Python anwenden, indem du GridSearchCV aus scikit-learn nutzt, um ein Modell mit verschiedenen Hyperparameter-Werten zu trainieren und anschließend die beste Variante auszuwählen.

3. Worin liegt der Unterschied zwischen Randomized Search und Grid Search?

• Grid Search testet jede mögliche Kombination vollständig.
• Random Search wählt zufällige Kombinationen aus und reduziert dadurch die Rechenzeit.

4. Was macht grid() in Python?

In matplotlib oder in GUI-Frameworks dient .grid() dazu, ein Rasterlayout zu erzeugen. Mit Grid Search im Machine Learning hat das nichts zu tun.

5. Wie wendest du Grid Search an?

Um Grid Search in Python einzusetzen, kannst du die Klasse GridSearchCV aus scikit-learn in folgenden Schritten nutzen:

1. Importiere die benötigten Bibliotheken.
2. Definiere dein Modell und die Hyperparameter, die optimiert werden sollen.
3. Erstelle ein GridSearchCV-Objekt und übergib dabei das Modell, ein Hyperparameter-Dictionary sowie die gewünschten Cross-Validation-Einstellungen.
4. Fitte das GridSearchCV-Objekt mit deinem Datensatz.
5. Rufe die besten Hyperparameter ab und bewerte dein Modell.

Das folgende Beispiel zeigt diesen Ablauf:

import numpy as np
from sklearn import svm, datasets
from sklearn.model_selection import GridSearchCV

# Load the iris dataset
iris = datasets.load_iris()

# Define the SVM model
model = svm.SVC()

# Set up the hyperparameter grid
param_grid = {
    'C': [1, 10, 100],
    'kernel': ['linear', 'rbf']
}

# Create a GridSearchCV object with 5-fold cross-validation
grid_search = GridSearchCV(model, param_grid, cv=5)

# Fit the grid search to the data
grid_search.fit(iris.data, iris.target)

# Retrieve and display the best hyperparameters and corresponding score
print("Best hyperparameters:", grid_search.best_params_)
print("Best cross-validation score:", grid_search.best_score_)

In diesem Beispiel wird ein SVM-Klassifikator auf dem Iris-Datensatz abgestimmt, indem verschiedene Werte für den Regularisierungsparameter und den Kernel-Typ getestet werden.

6. Wie funktioniert eine Grid Search bei vermissten Personen?

Obwohl der Begriff „Grid Search“ im Machine Learning vor allem für Hyperparameter-Tuning bekannt ist, lässt sich das Grundprinzip auch auf die Suche nach vermissten Personen übertragen. In der Praxis bedeutet das, ein Suchgebiet in ein Raster einzuteilen und jeden Bereich systematisch zu untersuchen. So kann ein solcher Ansatz aussehen:

• Teile das Suchgebiet in gleich große Rasterfelder auf, damit jeder Bereich abgedeckt wird.
• Ordne jedem Rasterabschnitt Teams oder Ressourcen wie Drohnen oder Freiwillige zu.
• Durchsuche jede Zelle methodisch, um Lücken und unnötige Überschneidungen zu vermeiden.
• Passe das Raster anhand von Gelände, Daten oder neuen Hinweisen an, damit Zonen mit höherer Priorität gezielt untersucht werden können.

Diese rasterbasierte Vorgehensweise unterstützt eine bessere Organisation und eine vollständigere Abdeckung des Suchgebiets, wobei reale Suchaktionen zusätzlich von der Zusammenarbeit mit lokalen Behörden und Rettungsdiensten abhängen.

Fazit

Grid Search ist eine leistungsstarke Methode für das Hyperparameter-Tuning in Machine-Learning-Modellen. Auch wenn sich damit sehr gute Parameterkombinationen finden lassen, kann der Rechenaufwand hoch sein. Deshalb ist Random Search in vielen Fällen eine wertvolle Alternative. Wenn du bewährte Strategien wie die Begrenzung des Suchraums und parallele Verarbeitung einsetzt, kannst du die Modellleistung effizienter optimieren.