Hinweis

Gehe zum Ende, um den vollständigen Beispielcode herunterzuladen oder dieses Beispiel über JupyterLite oder Binder in deinem Browser auszuführen.

Benutzerdefinierte Refit-Strategie für Grid Search mit Kreuzvalidierung#

Dieses Beispiel zeigt, wie ein Klassifikator mittels Kreuzvalidierung optimiert wird, was mit dem Objekt GridSearchCV auf einem Entwicklungssatz durchgeführt wird, der nur die Hälfte der verfügbaren gelabelten Daten umfasst.

Die Leistung der ausgewählten Hyperparameter und des trainierten Modells wird anschließend auf einem dedizierten Evaluationssatz gemessen, der während des Modellauswahlschritts nicht verwendet wurde.

Weitere Details zu Werkzeugen für die Modellauswahl finden Sie in den Abschnitten zur Kreuzvalidierung: Bewertung der Schätzleistung und zur Optimierung der Hyperparameter eines Schätzers.

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

Der Datensatz#

Wir arbeiten mit dem digits Datensatz. Das Ziel ist die Klassifizierung von Bildern handschriftlicher Ziffern. Wir transformieren das Problem in eine binäre Klassifikation, um es einfacher verständlich zu machen: Das Ziel ist zu identifizieren, ob eine Ziffer eine 8 ist oder nicht.

from sklearn import datasets

digits = datasets.load_digits()

Um einen Klassifikator auf Bildern zu trainieren, müssen wir sie zu Vektoren abflachen. Jedes Bild mit 8 x 8 Pixeln muss in einen Vektor mit 64 Pixeln umgewandelt werden. Somit erhalten wir ein finales Datenarray der Form (n_images, n_pixels).

n_samples = len(digits.images)
X = digits.images.reshape((n_samples, -1))
y = digits.target == 8
print(
    f"The number of images is {X.shape[0]} and each image contains {X.shape[1]} pixels"
)

The number of images is 1797 and each image contains 64 pixels

Wie in der Einleitung dargestellt, werden die Daten in einen Trainings- und einen Testsatz gleicher Größe aufgeteilt.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)

Definieren unserer Grid-Search-Strategie#

Wir wählen einen Klassifikator aus, indem wir die besten Hyperparameter auf den Folds des Trainingssatzes suchen. Dazu müssen wir die Scores definieren, um den besten Kandidaten auszuwählen.

scores = ["precision", "recall"]

Wir können auch eine Funktion definieren, die dem Parameter refit der GridSearchCV-Instanz übergeben wird. Diese implementiert die benutzerdefinierte Strategie zur Auswahl des besten Kandidaten aus dem Attribut cv_results_ des GridSearchCV. Sobald der Kandidat ausgewählt ist, wird er automatisch vom GridSearchCV-Objekt neu angepasst.

Hierbei ist die Strategie, die Modelle, die in Bezug auf Präzision und Recall am besten sind, zu einer engeren Auswahl zusammenzufassen. Aus den ausgewählten Modellen wählen wir schließlich das schnellste Modell bei der Vorhersage aus. Beachten Sie, dass diese benutzerdefinierten Auswahlmöglichkeiten rein willkürlich sind.

import pandas as pd


def print_dataframe(filtered_cv_results):
    """Pretty print for filtered dataframe"""
    for mean_precision, std_precision, mean_recall, std_recall, params in zip(
        filtered_cv_results["mean_test_precision"],
        filtered_cv_results["std_test_precision"],
        filtered_cv_results["mean_test_recall"],
        filtered_cv_results["std_test_recall"],
        filtered_cv_results["params"],
    ):
        print(
            f"precision: {mean_precision:0.3f} (±{std_precision:0.03f}),"
            f" recall: {mean_recall:0.3f} (±{std_recall:0.03f}),"
            f" for {params}"
        )
    print()


def refit_strategy(cv_results):
    """Define the strategy to select the best estimator.

    The strategy defined here is to filter-out all results below a precision threshold
    of 0.98, rank the remaining by recall and keep all models with one standard
    deviation of the best by recall. Once these models are selected, we can select the
    fastest model to predict.

    Parameters
    ----------
    cv_results : dict of numpy (masked) ndarrays
        CV results as returned by the `GridSearchCV`.

    Returns
    -------
    best_index : int
        The index of the best estimator as it appears in `cv_results`.
    """
    # print the info about the grid-search for the different scores
    precision_threshold = 0.98

    cv_results_ = pd.DataFrame(cv_results)
    print("All grid-search results:")
    print_dataframe(cv_results_)

    # Filter-out all results below the threshold
    high_precision_cv_results = cv_results_[
        cv_results_["mean_test_precision"] > precision_threshold
    ]

    print(f"Models with a precision higher than {precision_threshold}:")
    print_dataframe(high_precision_cv_results)

    high_precision_cv_results = high_precision_cv_results[
        [
            "mean_score_time",
            "mean_test_recall",
            "std_test_recall",
            "mean_test_precision",
            "std_test_precision",
            "rank_test_recall",
            "rank_test_precision",
            "params",
        ]
    ]

    # Select the most performant models in terms of recall
    # (within 1 sigma from the best)
    best_recall_std = high_precision_cv_results["mean_test_recall"].std()
    best_recall = high_precision_cv_results["mean_test_recall"].max()
    best_recall_threshold = best_recall - best_recall_std

    high_recall_cv_results = high_precision_cv_results[
        high_precision_cv_results["mean_test_recall"] > best_recall_threshold
    ]
    print(
        "Out of the previously selected high precision models, we keep all the\n"
        "the models within one standard deviation of the highest recall model:"
    )
    print_dataframe(high_recall_cv_results)

    # From the best candidates, select the fastest model to predict
    fastest_top_recall_high_precision_index = high_recall_cv_results[
        "mean_score_time"
    ].idxmin()

    print(
        "\nThe selected final model is the fastest to predict out of the previously\n"
        "selected subset of best models based on precision and recall.\n"
        "Its scoring time is:\n\n"
        f"{high_recall_cv_results.loc[fastest_top_recall_high_precision_index]}"
    )

    return fastest_top_recall_high_precision_index

Optimieren von Hyperparametern#

Nachdem wir unsere Strategie zur Auswahl des besten Modells definiert haben, definieren wir die Werte der Hyperparameter und erstellen die Grid-Search-Instanz

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

tuned_parameters = [
    {"kernel": ["rbf"], "gamma": [1e-3, 1e-4], "C": [1, 10, 100, 1000]},
    {"kernel": ["linear"], "C": [1, 10, 100, 1000]},
]

grid_search = GridSearchCV(
    SVC(), tuned_parameters, scoring=scores, refit=refit_strategy
)
grid_search.fit(X_train, y_train)

All grid-search results:
precision: 1.000 (±0.000), recall: 0.854 (±0.063), for {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.257 (±0.061), for {'C': 1, 'gamma': 0.0001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 0.968 (±0.039), recall: 0.780 (±0.083), for {'C': 10, 'gamma': 0.0001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 0.905 (±0.058), recall: 0.889 (±0.074), for {'C': 100, 'gamma': 0.0001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 1000, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 0.904 (±0.058), recall: 0.890 (±0.073), for {'C': 1000, 'gamma': 0.0001, 'kernel': 'rbf'}
precision: 0.695 (±0.073), recall: 0.743 (±0.065), for {'C': 1, 'kernel': 'linear'}
precision: 0.643 (±0.066), recall: 0.757 (±0.066), for {'C': 10, 'kernel': 'linear'}
precision: 0.611 (±0.028), recall: 0.744 (±0.044), for {'C': 100, 'kernel': 'linear'}
precision: 0.618 (±0.039), recall: 0.744 (±0.044), for {'C': 1000, 'kernel': 'linear'}

Models with a precision higher than 0.98:
precision: 1.000 (±0.000), recall: 0.854 (±0.063), for {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.257 (±0.061), for {'C': 1, 'gamma': 0.0001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 1000, 'gamma': 0.001, 'kernel': 'rbf'}

Out of the previously selected high precision models, we keep all the
the models within one standard deviation of the highest recall model:
precision: 1.000 (±0.000), recall: 0.854 (±0.063), for {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}
precision: 1.000 (±0.000), recall: 0.877 (±0.069), for {'C': 1000, 'gamma': 0.001, 'kernel': 'rbf'}


The selected final model is the fastest to predict out of the previously
selected subset of best models based on precision and recall.
Its scoring time is:

mean_score_time                                           0.005081
mean_test_recall                                          0.877206
std_test_recall                                           0.069196
mean_test_precision                                            1.0
std_test_precision                                             0.0
rank_test_recall                                                 3
rank_test_precision                                              1
params                 {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}
Name: 4, dtype: object

GridSearchCV(estimator=SVC(),
             param_grid=[{'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001],
                          'kernel': ['rbf']},
                         {'C': [1, 10, 100, 1000], 'kernel': ['linear']}],
             refit=<function refit_strategy at 0x7fb4a19725c0>,
             scoring=['precision', 'recall'])

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.

Die von der Grid-Search mit unserer benutzerdefinierten Strategie ausgewählten Parameter sind

grid_search.best_params_

{'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}

Schließlich bewerten wir das feinabgestimmte Modell auf dem zurückbehaltenen Evaluationsdatensatz: Das Objekt grid_search **wurde automatisch** mit den Parametern, die von unserer benutzerdefinierten Refit-Strategie ausgewählt wurden, auf dem gesamten Trainingsdatensatz **neu angepasst**.

Wir können den Klassifikationsbericht verwenden, um Standard-Klassifikationsmetriken auf dem zurückbehaltenen Satz zu berechnen

from sklearn.metrics import classification_report

y_pred = grid_search.predict(X_test)
print(classification_report(y_test, y_pred))

              precision    recall  f1-score   support

       False       0.99      1.00      0.99       807
        True       1.00      0.87      0.93        92

    accuracy                           0.99       899
   macro avg       0.99      0.93      0.96       899
weighted avg       0.99      0.99      0.99       899

Hinweis

Das Problem ist zu einfach: Das Plateau der Hyperparameter ist zu flach und das Ausgabemodell ist dasselbe für Präzision und Recall bei Gleichstand in der Qualität.

Gesamtlaufzeit des Skripts: (0 Minuten 10,200 Sekunden)

Verwandte Beispiele

Präzisions-Rückruf

Modellkomplexität und kreuzvalidierter Score ausbalancieren

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

Rekursive Merkmalseliminierung 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.	SVC()
	param_grid param_grid: dict oder Liste von Dictionaries Dictionary mit Parameternamen (`str`) als Schlüssel und Listen von zu versuchenden Parametereinstellungen als Werte, oder eine Liste solcher Dictionaries, in welchem Fall die von jedem Dictionary im Gitter aufgespannten Gitter durchsucht werden. Dies ermöglicht die Suche über jede Sequenz von Parametereinstellungen.	[{'C': [1, 10, ...], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']}, {'C': [1, 10, ...], 'kernel': ['linear']}]
	scoring scoring: str, callable, list, tuple oder dict, default=None Strategie zur Bewertung der Leistung des kreuzvalidierten Modells auf dem Testdatensatz. Wenn `scoring` eine einzelne Punktzahl darstellt, kann man verwenden: - einen einzelnen String (siehe :ref:`scoring_string_names`); - ein Callable (siehe :ref:`scoring_callable`), das einen einzelnen Wert zurückgibt; - `None`, das :ref:`Standard-Bewertungskriterium des Estimators ` wird verwendet. Wenn `scoring` mehrere Punktzahlen darstellt, kann man verwenden: - eine Liste oder ein Tupel eindeutiger Strings; - ein Callable, das ein Dictionary zurückgibt, dessen Schlüssel die Metriknamen und dessen Werte die Metrikpunktzahlen sind; - ein Dictionary mit Metriknamen als Schlüssel und Callables als Werte. Siehe :ref:`multimetric_grid_search` für ein Beispiel.	['precision', 'recall']
	n_jobs n_jobs: int, default=None Anzahl der parallel auszuführenden Jobs. ``None`` bedeutet 1, es sei denn, es befindet sich in einem :obj:`joblib.parallel_backend`-Kontext. ``-1`` bedeutet die Verwendung aller Prozessoren. Siehe :term:`Glossar ` für weitere Details. .. versionchanged:: v0.20 Standardwert von `n_jobs` wurde von 1 auf None geändert.	None
	refit refit: bool, str, oder callable, Standard=True Passt einen Schätzer mit den besten gefundenen Parametern auf dem gesamten Datensatz erneut an. Bei mehreren Metrikevaluierungen muss dies ein `str` sein, der den Scorrer bezeichnet, der verwendet würde, um die besten Parameter für die erneute Anpassung des Schätzers am Ende zu finden. Wenn neben der maximalen Punktzahl andere Erwägungen bei der Auswahl eines besten Schätzers bestehen, kann ``refit`` auf eine Funktion gesetzt werden, die den ausgewählten ``best_index_`` basierend auf ``cv_results_`` zurückgibt. In diesem Fall werden ``best_estimator_`` und ``best_params_`` gemäß dem zurückgegebenen ``best_index_`` gesetzt, während das Attribut ``best_score_`` nicht verfügbar sein wird. Der neu angepasste Schätzer ist unter dem Attribut ``best_estimator_`` verfügbar und ermöglicht die direkte Verwendung von ``predict`` auf dieser ``GridSearchCV``-Instanz. Auch bei mehreren Metrikevaluierungen sind die Attribute ``best_index_``, ``best_score_`` und ``best_params_`` nur verfügbar, wenn ``refit`` gesetzt ist, und alle werden in Bezug auf diesen spezifischen Scorrer bestimmt. Siehe den Parameter ``scoring``, um mehr über die mehrfache Metrikevaluierung zu erfahren. Siehe :ref:`sphx_glr_auto_examples_model_selection_plot_grid_search_digits.py`, um zu sehen, wie eine benutzerdefinierte Auswahlstrategie mit einem Callable über `refit` entworfen wird. Siehe :ref:`dieses Beispiel `, um zu sehen, wie ``refit=callable`` verwendet wird, um Modellkomplexität und kreuzvalidierte Punktzahlen auszugleichen. .. versionchanged:: 0.20 Unterstützung für Callable hinzugefügt.	<function ref...x7fb4a19725c0>
	cv cv: int, cross-validation generator oder ein Iterable, default=None Bestimmt die Kreuzvalidierungs-Splitting-Strategie. Mögliche Eingaben für cv sind: - None, um die Standard-5-Falt-Kreuzvalidierung zu verwenden, - Ganzzahl, um die Anzahl der Faltungen in einem `(Stratified)KFold` anzugeben, - :term:`CV-Splitter`, - Ein Iterable, das (Trainings-, Test-)Splits als Index-Arrays liefert. Bei 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` instanziiert, sodass die Splits über Aufrufe hinweg gleich sind. Siehe das :ref:`Benutzerhandbuch ` für die verschiedenen Kreuzvalidierungsstrategien, die hier verwendet werden können. .. versionchanged:: 0.22 Standardwert von ``cv``, wenn None, wurde von 3-Falt auf 5-Falt geändert.	None
	verbose verbose: int Steuert die Ausführlichkeit: Je höher, desto mehr Nachrichten. - >1 : Die Berechnungszeit für jede Faltung und jeden Parameterkandidaten wird angezeigt; - >2 : Die Punktzahl wird ebenfalls angezeigt; - >3 : Die Faltungs- und Parameterkandidatenindizes werden ebenfalls angezeigt, zusammen mit der Startzeit der Berechnung.	0
	pre_dispatch pre_dispatch: int oder str, default='2n_jobs' Steuert die Anzahl der Jobs, die während der parallelen Ausführung ausgeliefert werden. Die Reduzierung dieser Anzahl kann nützlich sein, um eine Explosion des Speicherverbrauchs zu vermeiden, wenn mehr Jobs ausgeliefert werden, als CPUs verarbeiten können. Dieser Parameter kann sein: - None, in diesem Fall werden alle Jobs sofort erstellt und gespawnt. Verwenden Sie dies für leichte und schnell laufende Jobs, um Verzögerungen durch On-Demand- Spawning der Jobs zu vermeiden - Eine Ganzzahl, die die genaue Gesamtzahl der gespawnten Jobs angibt - Ein String, der einen Ausdruck als Funktion von n_jobs angibt, z. B. '2n_jobs'	'2*n_jobs'
	error_score error_score: 'raise' oder numerisch, default=np.nan Wert, der der Punktzahl zugewiesen wird, wenn beim Anpassen des Estimators ein Fehler auftritt. Wenn auf 'raise' gesetzt, wird der Fehler ausgelöst. Wenn eine numerische Zahl angegeben wird, wird FitFailedWarning ausgelöst. Dieser Parameter beeinflusst den Refit-Schritt nicht, der immer den Fehler auslösen wird.	nan
	return_train_score return_train_score: bool, default=False Wenn ``False``, enthält das Attribut ``cv_results_`` keine Trainingspunktzahlen. Die Berechnung von Trainingspunktzahlen wird verwendet, um Einblicke zu gewinnen, wie verschiedene Parametereinstellungen den Kompromiss zwischen Überanpassung/Unteranpassung beeinflussen. Die Berechnung der Punktzahlen auf dem Trainingsdatensatz kann jedoch rechenintensiv sein und ist nicht unbedingt erforderlich, um die Parameter auszuwählen, die die beste Generalisierungsleistung erzielen. .. versionadded:: 0.19 .. versionchanged:: 0.21 Der Standardwert wurde von ``True`` auf ``False`` geändert.	False

	C C: float, Standard=1.0 Regularisierungsparameter. Die Stärke der Regularisierung ist umgekehrt proportional zu C. Muss strikt positiv sein. Die Strafe ist eine quadratische l2-Strafe. Für eine intuitive Visualisierung der Auswirkungen der Skalierung des Regularisierungsparameters C siehe :ref:`sphx_glr_auto_examples_svm_plot_svm_scale_c.py`.	100
	kernel kernel: {'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'} oder callable, Standard='rbf' Gibt den zu verwendenden Kernel-Typ im Algorithmus an. Wenn keiner angegeben ist, wird 'rbf' verwendet. Wenn ein Callable angegeben ist, wird es verwendet, um die Kernel-Matrix aus Datenmatrizen vorab zu berechnen; diese Matrix sollte ein Array der Form ``(n_samples, n_samples)`` sein. Für eine intuitive Visualisierung verschiedener Kernel-Typen siehe :ref:`sphx_glr_auto_examples_svm_plot_svm_kernels.py`.	'rbf'
	degree degree: int, Standard=3 Grad der polynomialen Kernel-Funktion ('poly'). Muss nicht-negativ sein. Ignoriert von allen anderen Kernels.	3
	gamma gamma: {'scale', 'auto'} oder float, Standard='scale' Kernel-Koeffizient für 'rbf', 'poly' und 'sigmoid'. - Wenn ``gamma='scale'`` (Standard) übergeben wird, verwendet es 1 / (n_features * X.var()) als Wert von gamma, - Wenn 'auto', verwendet es 1 / n_features - Wenn float, muss es nicht-negativ sein. .. versionchanged:: 0.22 Der Standardwert von ``gamma`` hat sich von 'auto' zu 'scale' geändert.	0.001
	coef0 coef0: float, Standard=0.0 Unabhängiger Term in der Kernel-Funktion. Er ist nur bei 'poly' und 'sigmoid' signifikant.	0.0
	shrinking shrinking: bool, Standard=True Ob die Schrumpfungsheuristik verwendet werden soll. Siehe das :ref:`Benutzerhandbuch `.	True
	probability probability: bool, Standard=False Ob Wahrscheinlichkeitsschätzungen aktiviert werden sollen. Dies muss vor dem Aufruf von `fit` aktiviert werden und verlangsamt diese Methode, da sie intern eine 5-fache Kreuzvalidierung verwendet, und `predict_proba` kann inkonsistent mit `predict` sein. Lesen Sie mehr im :ref:`Benutzerhandbuch `.	False
	tol tol: float, Standard=1e-3 Toleranz für das Abbruchkriterium.	0.001
	cache_size cache_size: float, Standard=200 Gibt die Größe des Kernel-Caches an (in MB).	200
	class_weight class_weight: dict oder 'balanced', Standard=None Setzt den Parameter C der Klasse i auf class_weight[i]C für SVC. Wenn nicht angegeben, wird angenommen, dass alle Klassen das Gewicht eins haben. Der Modus "balanced" verwendet die Werte von y, um die Gewichte automatisch invers proportional zu den Klassenhäufigkeiten in den Eingabedaten als ``n_samples / (n_classes np.bincount(y))`` anzupassen.	None
	verbose verbose: bool, Standard=False Detaillierte Ausgabe aktivieren. Beachten Sie, dass diese Einstellung eine prozessweite Laufzeiteinstellung in libsvm nutzt, die, wenn sie aktiviert ist, in einem Multithreading-Kontext möglicherweise nicht richtig funktioniert.	False
	max_iter max_iter: int, Standard=-1 Harte Grenze für Iterationen innerhalb des Lösers oder -1 für keine Grenze.	-1
	decision_function_shape decision_function_shape: {'ovo', 'ovr'}, Standard='ovr' Gibt zurück, ob eine One-vs-Rest ('ovr') Entscheidungsfunktion der Form (n_samples, n_classes) wie bei allen anderen Klassifikatoren zurückgegeben werden soll, oder die ursprüngliche One-vs-One ('ovo') Entscheidungsfunktion von libsvm, die die Form (n_samples, n_classes * (n_classes - 1) / 2) hat. Beachten Sie jedoch, dass intern One-vs-One ('ovo') immer als Multi-Class-Strategie zum Trainieren von Modellen verwendet wird; eine ovr-Matrix wird nur aus der ovo-Matrix konstruiert. Der Parameter wird für die binäre Klassifikation ignoriert. .. versionchanged:: 0.19 decision_function_shape ist standardmäßig 'ovr'. .. versionadded:: 0.17 decision_function_shape='ovr' wird empfohlen. .. versionchanged:: 0.17 Deprecated decision_function_shape='ovo' und None.	'ovr'
	break_ties break_ties: bool, Standard=False Wenn true, ``decision_function_shape='ovr'`` und die Anzahl der Klassen > 2 ist, ``predict`` wird Bindungen gemäß den Konfidenzwerten von ``decision_function`` auflösen; andernfalls wird die erste Klasse unter den gebundenen Klassen zurückgegeben. Bitte beachten Sie, dass das Auflösen von Bindungen mit relativ hohen Rechenkosten im Vergleich zu einem einfachen Predict verbunden ist. Siehe :ref:`sphx_glr_auto_examples_svm_plot_svm_tie_breaking.py` für ein Beispiel seiner Verwendung mit ``decision_function_shape='ovr'``. .. versionadded:: 0.22	False
	random_state random_state: int, RandomState-Instanz oder None, Standard=None Steuert die pseudo-zufällige Zahlengenerierung zum Mischen der Daten für Wahrscheinlichkeitsschätzungen. Ignoriert, wenn `probability` False ist. Geben Sie eine Ganzzahl für reproduzierbare Ergebnisse über mehrere Funktionsaufrufe an. Siehe :term:`Glossar `.	None

Benutzerdefinierte Refit-Strategie für Grid Search mit Kreuzvalidierung#

Der Datensatz#

Definieren unserer Grid-Search-Strategie#

Optimieren von Hyperparametern#

Diese Seite