Hinweis

Zum Ende springen, um den vollständigen Beispielcode herunterzuladen oder dieses Beispiel über JupyterLite oder Binder in Ihrem Browser auszuführen.

Successive Halving Iterations#

Dieses Beispiel veranschaulicht, wie eine successive Halving-Suche (HalvingGridSearchCV und HalvingRandomSearchCV) iterativ die beste Parameterkombination aus mehreren Kandidaten auswählt.

# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from scipy.stats import randint

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.experimental import enable_halving_search_cv  # noqa: F401
from sklearn.model_selection import HalvingRandomSearchCV

Wir definieren zunächst den Parameterraum und trainieren eine Instanz von HalvingRandomSearchCV.

rng = np.random.RandomState(0)

X, y = datasets.make_classification(n_samples=400, n_features=12, random_state=rng)

clf = RandomForestClassifier(n_estimators=20, random_state=rng)

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

rsh = HalvingRandomSearchCV(
    estimator=clf, param_distributions=param_dist, factor=2, random_state=rng
)
rsh.fit(X, y)

HalvingRandomSearchCV(estimator=RandomForestClassifier(n_estimators=20,
                                                       random_state=RandomState(MT19937) at 0x7FB4A1A89640),
                      factor=2,
                      param_distributions={'bootstrap': [True, False],
                                           'criterion': ['gini', 'entropy'],
                                           'max_depth': [3, None],
                                           'max_features': <scipy.stats._distn_infrastructure.rv_discrete_frozen object at 0x7fb4a02efb10>,
                                           'min_samples_split': <scipy.stats._distn_infrastructure.rv_discrete_frozen object at 0x7fb4c038efd0>},
                      random_state=RandomState(MT19937) at 0x7FB4A1A89640)

In einer Jupyter-Umgebung führen Sie diese Zelle bitte erneut aus, um die HTML-Darstellung anzuzeigen, oder vertrauen Sie dem Notebook.
Auf GitHub kann die HTML-Darstellung nicht gerendert werden. Versuchen Sie bitte, diese Seite mit nbviewer.org zu laden.

Wir können nun das Attribut ``cv_results_`` des Such-Estimators verwenden, um die Entwicklung der Suche zu inspizieren und zu plotten.

results = pd.DataFrame(rsh.cv_results_)
results["params_str"] = results.params.apply(str)
results.drop_duplicates(subset=("params_str", "iter"), inplace=True)
mean_scores = results.pivot(
    index="iter", columns="params_str", values="mean_test_score"
)
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()

Anzahl der Kandidaten und Menge der Ressource in jeder Iteration#

In der ersten Iteration wird eine kleine Menge an Ressourcen verwendet. Die Ressource ist hier die Anzahl der Samples, auf denen die Estimators trainiert werden. Alle Kandidaten werden ausgewertet.

In der zweiten Iteration wird nur die beste Hälfte der Kandidaten ausgewertet. Die Anzahl der zugewiesenen Ressourcen wird verdoppelt: Die Kandidaten werden auf doppelt so vielen Samples ausgewertet.

Dieser Prozess wird bis zur letzten Iteration wiederholt, in der nur noch 2 Kandidaten übrig sind. Der beste Kandidat ist der Kandidat, der in der letzten Iteration die beste Punktzahl erzielt.

Gesamtlaufzeit des Skripts: (0 Minuten 5,524 Sekunden)

Verwandte Beispiele

Vergleich zwischen Gitter-Suche und sukzessiver Halbierung

Vergleich von zufälliger Suche und Gitter-Suche zur Hyperparameter-Schätzung

Release Highlights für scikit-learn 0.24

Benutzerdefinierte Refit-Strategie einer Gitter-Suche mit Kreuzvalidierung

Galerie generiert von Sphinx-Gallery

	estimator estimator: Estimator-Objekt Es wird angenommen, dass dies die scikit-learn-Estimator-Schnittstelle implementiert. Entweder muss der Estimator eine ``score``-Funktion bereitstellen, oder ``scoring`` muss übergeben werden.	RandomForestC...x7FB4A1A89640)
	param_distributions param_distributions: dict oder Liste von dicts Dictionary mit Parameternamen (`str`) als Schlüssel und Distributionen oder Listen von zu versuchenden Parametern. Distributionen müssen eine ``rvs``-Methode zum Sampling bereitstellen (wie die von scipy.stats.distributions). Wenn eine Liste gegeben wird, wird diese gleichmäßig gesampelt. Wenn eine Liste von dicts gegeben wird, wird zuerst ein dict gleichmäßig gesampelt und dann ein Parameter unter Verwendung dieses dicts wie oben gesampelt.	{'bootstrap': [True, False], 'criterion': ['gini', 'entropy'], 'max_depth': [3, None], 'max_features': <scipy.stats....x7fb4a02efb10>, ...}
	n_candidates n_candidates: "exhaust" oder int, Standard="exhaust" Die Anzahl der zu samplenden Kandidatenparameter in der ersten Iteration. Die Verwendung von 'exhaust' sammelt genügend Kandidaten, sodass die letzte Iteration so viele Ressourcen wie möglich verbraucht, basierend auf `min_resources`, `max_resources` und `factor`. In diesem Fall kann `min_resources` nicht 'exhaust' sein.	'exhaust'
	factor factor: int oder float, Standard=3 Der 'Halving'-Parameter, der den Anteil der Kandidaten bestimmt, die für jede nachfolgende Iteration ausgewählt werden. Zum Beispiel bedeutet ``factor=3``, dass nur ein Drittel der Kandidaten ausgewählt wird.	2
	resource resource: ``'n_samples'`` oder str, Standard='n_samples' Definiert die Ressource, die mit jeder Iteration zunimmt. Standardmäßig ist die Ressource die Anzahl der Samples. Sie kann auch auf jeden Parameter des Basis-Estimators gesetzt werden, der positive Ganzzahlwerte akzeptiert, z.B. 'n_iterations' oder 'n_estimators' für einen Gradient-Boosting-Estimator. In diesem Fall kann ``max_resources`` nicht 'auto' sein und muss explizit gesetzt werden.	'n_samples'
	max_resources max_resources: int, Standard='auto' Die maximale Anzahl an Ressourcen, die jeder Kandidat für eine gegebene Iteration verwenden darf. Standardmäßig ist dies auf ``n_samples`` gesetzt, wenn ``resource='n_samples'`` (Standard), andernfalls wird ein Fehler ausgelöst.	'auto'
	min_resources min_resources: {'exhaust', 'smallest'} oder int, Standard='smallest' Die minimale Menge an Ressource, die jeder Kandidat für eine gegebene Iteration verwenden darf. Äquivalent dazu definiert dies die Ressourcenmenge `r0`, die jeder Kandidat in der ersten Iteration zugewiesen bekommt. - 'smallest' ist eine Heuristik, die `r0` auf einen kleinen Wert setzt: - ``n_splits * 2``, wenn ``resource='n_samples'`` für ein Regressionsproblem - ``n_classes * n_splits * 2``, wenn ``resource='n_samples'`` für ein Klassifizierungsproblem - ``1``, wenn ``resource != 'n_samples'`` - 'exhaust' setzt `r0` so, dass die letzte Iteration so viele Ressourcen wie möglich verbraucht. Nämlich wird die letzte Iteration den höchsten Wert kleiner als ``max_resources`` verwenden, der ein Vielfaches von sowohl ``min_resources`` als auch ``factor`` ist. Im Allgemeinen führt die Verwendung von 'exhaust' zu einem genaueren Estimator, ist aber etwas zeitaufwändiger. 'exhaust' ist nicht verfügbar, wenn `n_candidates='exhaust'`. Beachten Sie, dass die Menge der in jeder Iteration verwendeten Ressourcen immer ein Vielfaches von ``min_resources`` ist.	'smallest'
	aggressive_elimination aggressive_elimination: bool, Standard=False Dies ist nur relevant, wenn nicht genügend Ressourcen vorhanden sind, um die verbleibenden Kandidaten nach der letzten Iteration auf maximal `factor` zu reduzieren. Wenn ``True``, wird der Suchprozess die erste Iteration so lange 'wiederholen', bis die Anzahl der Kandidaten klein genug ist. Dies ist standardmäßig ``False``, was bedeutet, dass die letzte Iteration mehr als ``factor`` Kandidaten auswerten kann. Siehe :ref:`aggressive_elimination` für weitere Details.	False
	cv cv: int, Kreuzvalidierungsgenerator oder iterierbar, Standard=5 Bestimmt die Strategie der Kreuzvalidierung. Mögliche Eingaben für cv sind: - Ganzzahl, um die Anzahl der Folds in einem `(Stratified)KFold` anzugeben, - :term:`CV-Splitter`, - Ein iterierbares Objekt, das (train, test) Splits als Array von Indizes liefert. Für Ganzzahl-/None-Eingaben wird, wenn der Estimator ein Klassifikator ist und ``y`` entweder binär oder multiklass ist, :class:`StratifiedKFold` verwendet. In allen anderen Fällen wird :class:`KFold` verwendet. Diese Splitter werden mit `shuffle=False` initialisiert, sodass die Splits bei mehreren Aufrufen gleich sind. Siehe :ref:`User Guide ` für die verschiedenen Kreuzvalidierungsstrategien, die hier verwendet werden können. .. note:: Aufgrund von Implementierungsdetails müssen die von `cv` erzeugten Folds über mehrere Aufrufe von `cv.split()` hinweg gleich sein. Für eingebaute `scikit-learn`-Iteratoren kann dies durch Deaktivieren des Shuffelns (`shuffle=False`) oder durch Setzen des `cv`-Parameters `random_state` auf eine Ganzzahl erreicht werden.	5
	scoring scoring: str oder aufrufbar, Standard=None Bewertungsmethode zur Auswertung der Vorhersagen auf dem Testdatensatz. - str: siehe :ref:`scoring_string_names` für Optionen. - aufrufbar: ein aufrufbares Scorer-Objekt (z.B. Funktion) mit der Signatur ``scorer(estimator, X, y)``. Siehe :ref:`scoring_callable` für Details. - `None`: das :ref:`standardmäßige Bewertungskriterium ` des ``estimator`` wird verwendet.	None
	refit refit: bool oder aufrufbar, Standard=True Rücktrainieren eines Estimators mit den besten gefundenen Parametern auf dem gesamten Datensatz. Wenn es andere Überlegungen als die maximale Punktzahl bei der Wahl eines besten Estimators gibt, kann ``refit`` auf eine Funktion gesetzt werden, die den ausgewählten ``best_index_`` basierend auf ``cv_results_`` zurückgibt. In diesem Fall werden der ``best_estimator_`` und die ``best_params_`` gemäß dem zurückgegebenen ``best_index_`` gesetzt, während das Attribut ``best_score_`` nicht verfügbar ist. Der rücktrainierte Estimator ist unter dem Attribut ``best_estimator_`` verfügbar und erlaubt die direkte Verwendung von ``predict`` auf dieser ``HalvingRandomSearchCV``-Instanz. Siehe :ref:`dieses Beispiel ` für ein Beispiel, wie ``refit=callable`` verwendet wird, um Modellkomplexität und kreuzvalidierte Punktzahl auszubalancieren.	True
	error_score error_score: 'raise' oder numerisch Wert, der der Punktzahl zugewiesen wird, wenn beim Anpassen des Estimators ein Fehler auftritt. Wenn auf 'raise' gesetzt, wird der Fehler ausgelöst. Wenn ein numerischer Wert angegeben wird, wird FitFailedWarning ausgelöst. Dieser Parameter beeinflusst den Refit-Schritt nicht, der immer den Fehler auslösen wird. Standard ist ``np.nan``.	nan
	return_train_score return_train_score: bool, Standard=False Wenn ``False``, enthält das Attribut ``cv_results_`` keine Trainingspunktzahlen. Das Berechnen von Trainingspunktzahlen wird verwendet, um Einblicke zu gewinnen, wie sich verschiedene Parametereinstellungen auf den Kompromiss zwischen Überanpassung und Unteranpassung auswirken. Das Berechnen der Punktzahlen auf dem Trainingssatz kann jedoch rechnerisch aufwendig sein und ist nicht unbedingt erforderlich, um die Parameter auszuwählen, die die beste Generalisierungsleistung erzielen.	True
	random_state random_state: int, RandomState-Instanz oder None, Standard=None Pseudozufallszahlengenerator-Zustand, der zum Subsampling des Datensatzes verwendet wird, wenn `resources != 'n_samples'`. Wird auch für das zufällige gleichmäßige Sampling aus Listen möglicher Werte anstelle von scipy.stats-Distributionen verwendet. Geben Sie eine Ganzzahl für reproduzierbare Ausgaben über mehrere Funktionsaufrufe an. Siehe :term:`Glossar `.	RandomState(M...0x7FB4A1A89640
	n_jobs n_jobs: int oder None, Standard=None Anzahl der parallel auszuführenden Jobs. ``None`` bedeutet 1, es sei denn, Sie befinden sich in einem :obj:`joblib.parallel_backend` Kontext. ``-1`` bedeutet die Verwendung aller Prozessoren. Siehe :term:`Glossar ` für weitere Details.	None
	verbose verbose: int Steuert die Ausführlichkeit: je höher, desto mehr Nachrichten.	0

	n_estimators n_estimators: int, default=100 Die Anzahl der Bäume im Wald. .. versionchanged:: 0.22 Der Standardwert von ``n_estimators`` hat sich von 10 auf 100 in 0.22 geändert.	20
	criterion criterion: {"gini", "entropy", "log_loss"}, default="gini" Die Funktion zur Messung der Qualität eines Splits. Unterstützte Kriterien sind "gini" für die Gini-Unreinheit und "log_loss" und "entropy" sowohl für die Shannon-Informationsgewinnung, siehe :ref:`tree_mathematical_formulation`. Hinweis: Dieser Parameter ist baumspezifisch.	'entropy'
	max_depth max_depth: int, default=None Die maximale Tiefe des Baumes. Wenn None, werden Knoten erweitert, bis alle Blätter rein sind oder bis alle Blätter weniger als min_samples_split Stichproben enthalten.	None
	min_samples_split min_samples_split: int oder float, default=2 Die Mindestanzahl von Stichproben, die für einen internen Knoten zum Aufteilen erforderlich sind: - Wenn int, dann betrachten Sie `min_samples_split` als die Mindestanzahl. - Wenn float, dann ist `min_samples_split` ein Bruchteil und `ceil(min_samples_split * n_samples)` sind die Mindestanzahl von Stichproben für jeden Split. .. versionchanged:: 0.18 Hinzugefügte Gleitkommawerte für Brüche.	5
	min_samples_leaf min_samples_leaf: int oder float, default=1 Die Mindestanzahl von Stichproben, die an einem Blattknoten erforderlich sind. Ein Aufteilungspunkt in beliebiger Tiefe wird nur dann berücksichtigt, wenn er mindestens ``min_samples_leaf`` Trainingsstichproben in jedem der linken und rechten Zweige hinterlässt. Dies kann den Effekt haben, das Modell zu glätten, insbesondere bei der Regression. - Wenn int, dann betrachten Sie `min_samples_leaf` als die Mindestanzahl. - Wenn float, dann ist `min_samples_leaf` ein Bruchteil und `ceil(min_samples_leaf * n_samples)` sind die Mindestanzahl von Stichproben für jeden Knoten. .. versionchanged:: 0.18 Hinzugefügte Gleitkommawerte für Brüche.	1
	min_weight_fraction_leaf min_weight_fraction_leaf: float, Standard=0.0 Der minimale gewichtete Bruchteil der Gesamtsumme der Gewichte (aller Eingangsstichproben), der in einem Blattknoten erforderlich ist. Stichproben haben gleiches Gewicht, wenn sample_weight nicht angegeben ist.	0.0
	max_features max_features: {"sqrt", "log2", None}, int oder float, default="sqrt" Die Anzahl der Merkmale, die bei der Suche nach dem besten Split berücksichtigt werden: - Wenn int, dann betrachten Sie `max_features` Merkmale bei jedem Split. - Wenn float, dann ist `max_features` ein Bruchteil und `max(1, int(max_features * n_features_in_))` Merkmale werden bei jedem Split berücksichtigt. - Wenn "sqrt", dann `max_features=sqrt(n_features)`. - Wenn "log2", dann `max_features=log2(n_features)`. - Wenn None, dann `max_features=n_features`. .. versionchanged:: 1.1 Der Standardwert von `max_features` hat sich von `"auto"` zu `"sqrt"` geändert. Hinweis: Die Suche nach einem Split stoppt nicht, bis mindestens eine gültige Partition der Knoten-Stichproben gefunden wurde, selbst wenn dies erforderlich ist, mehr als ``max_features`` Merkmale zu inspizieren.	4
	max_leaf_nodes max_leaf_nodes: int, Standard=None Wächst Bäume mit ``max_leaf_nodes`` im Best-First-Verfahren. Beste Knoten werden als relative Reduktion der Unreinheit definiert. Wenn None, dann unbegrenzte Anzahl von Blattknoten.	None
	min_impurity_decrease min_impurity_decrease: float, Standard=0.0 Ein Knoten wird geteilt, wenn diese Teilung eine Verringerung der Unreinheit von größer oder gleich diesem Wert bewirkt. Die Gleichung für die gewichtete Verringerung der Unreinheit lautet: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) wobei ``N`` die Gesamtzahl der Stichproben, ``N_t`` die Anzahl der Stichproben am aktuellen Knoten, ``N_t_L`` die Anzahl der Stichproben im linken Kind und ``N_t_R`` die Anzahl der Stichproben im rechten Kind ist. ``N``, ``N_t``, ``N_t_R`` und ``N_t_L`` beziehen sich alle auf die gewichtete Summe, wenn ``sample_weight`` übergeben wird. .. versionadded:: 0.19	0.0
	bootstrap bootstrap: bool, default=True Ob Bootstrap-Stichproben beim Aufbau von Bäumen verwendet werden. Wenn False, wird der gesamte Datensatz zum Aufbau jedes Baumes verwendet.	False
	oob_score oob_score: bool oder aufrufbar, default=False Ob Out-of-Bag-Stichproben zur Schätzung des Generalisierungs-Scores verwendet werden. Standardmäßig wird :func:`~sklearn.metrics.accuracy_score` verwendet. Stellen Sie eine aufrufbare Funktion mit der Signatur `metric(y_true, y_pred)` bereit, um eine benutzerdefinierte Metrik zu verwenden. Nur verfügbar, wenn `bootstrap=True`. Zur Veranschaulichung der Out-of-Bag (OOB)-Fehlerschätzung siehe das Beispiel :ref:`sphx_glr_auto_examples_ensemble_plot_ensemble_oob.py`.	False
	n_jobs n_jobs: int, default=None Die Anzahl der parallel auszuführenden Jobs. :meth:`fit`, :meth:`predict`, :meth:`decision_path` und :meth:`apply` werden alle parallel über die Bäume ausgeführt. ``None`` bedeutet 1, es sei denn, Sie befinden sich in einem :obj:`joblib.parallel_backend` Kontext. ``-1`` bedeutet die Verwendung aller Prozessoren. Siehe :term:`Glossary ` für weitere Details.	None
	random_state random_state: int, RandomState-Instanz oder None, default=None Steuert sowohl die Zufälligkeit des Bootstrapping der Stichproben, die beim Aufbau von Bäumen verwendet werden (wenn ``bootstrap=True``), als auch die Stichprobenziehung der Merkmale, die bei der Suche nach dem besten Split in jedem Knoten berücksichtigt werden (wenn ``max_features < n_features``). Siehe :term:`Glossary ` für Details.	RandomState(M...0x7FB4BA3B0440
	verbose verbose: int, Standard=0 Steuert die Ausführlichkeit beim Anpassen und Vorhersagen.	0
	warm_start warm_start: bool, Standard=False Wenn auf ``True`` gesetzt, wird die Lösung des vorherigen Aufrufs von fit wiederverwendet und weitere Estimators zum Ensemble hinzugefügt, andernfalls wird nur ein ganz neuer Wald angepasst. Siehe :term:`Glossary ` und :ref:`tree_ensemble_warm_start` für Details.	False
	class_weight class_weight: {"balanced", "balanced_subsample"}, dict oder Liste von dicts, Standard=None Gewichte, die den Klassen zugeordnet sind, in der Form ``{class_label: weight}``. Wenn nicht angegeben, wird angenommen, dass alle Klassen das Gewicht eins haben. Bei Multi-Output-Problemen kann eine Liste von dicts in der gleichen Reihenfolge wie die Spalten von y angegeben werden. Beachten Sie, dass bei Multi-Output (einschließlich Multilabel) die Gewichte für jede Klasse jeder Spalte in einem eigenen dict definiert werden sollten. Zum Beispiel sollten bei einer Multilabel-Klassifikation mit vier Klassen die Gewichte [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] statt [{1:1}, {2:5}, {3:1}, {4:1}] sein. Der Modus "balanced" verwendet die Werte von y, um die Gewichte automatisch invers proportional zu den Klassenverteilungen in den Eingabedaten als ``n_samples / (n_classes * np.bincount(y))`` anzupassen. Der Modus "balanced_subsample" ist derselbe wie "balanced", außer dass die Gewichte basierend auf dem Bootstrap-Sample für jeden gezüchteten Baum berechnet werden. Bei Multi-Output werden die Gewichte jeder Spalte von y multipliziert. Beachten Sie, dass diese Gewichte mit sample_weight (übergeben durch die fit-Methode) multipliziert werden, wenn sample_weight angegeben ist.	None
	ccp_alpha ccp_alpha: nicht-negative Gleitkommazahl, default=0.0 Komplexitätsparameter für Minimal Cost-Complexity Pruning. Der Teilbaum mit der größten Kostenkomplexität, die kleiner ist als ``ccp_alpha``, wird ausgewählt. Standardmäßig erfolgt kein Pruning. Siehe :ref:`minimal_cost_complexity_pruning` für Details. Siehe :ref:`sphx_glr_auto_examples_tree_plot_cost_complexity_pruning.py` für ein Beispiel für ein solches Pruning. .. versionadded:: 0.22	0.0
	max_samples max_samples: int oder float, default=None Wenn bootstrap True ist, die Anzahl der Stichproben, die aus X gezogen werden, um jeden Basisschätzer zu trainieren. - Wenn None (Standard), dann werden `X.shape[0]` Stichproben gezogen. - Wenn int, dann werden `max_samples` Stichproben gezogen. - Wenn float, dann werden `max(round(n_samples * max_samples), 1)` Stichproben gezogen. Daher sollte `max_samples` im Intervall `(0.0, 1.0]` liegen. .. versionadded:: 0.22	None
	monotonic_cst monotonic_cst: Array-ähnlich von int der Form (n_features), default=None Gibt die Monotonie-Beschränkung an, die für jedes Merkmal durchgesetzt werden soll. - 1: monoton steigend - 0: keine Beschränkung - -1: monoton fallend Wenn monotonic_cst None ist, werden keine Beschränkungen angewendet. Monotonie-Beschränkungen werden nicht unterstützt für: - Multiklassen-Klassifizierungen (d.h. wenn `n_classes > 2`), - Multi-Output-Klassifizierungen (d.h. wenn `n_outputs_ > 1`), - Klassifizierungen, die auf Daten mit fehlenden Werten trainiert wurden. Die Beschränkungen gelten für die Wahrscheinlichkeit der positiven Klasse. Lesen Sie mehr im :ref:`Benutzerhandbuch `. .. versionadded:: 1.4	None

Successive Halving Iterations#

Anzahl der Kandidaten und Menge der Ressource in jeder Iteration#

Diese Seite