Diese Seite wurde von der Cloud Translation API übersetzt.

Hyperparameter-Abstimmung

Beim maschinellen Lernen ermittelt die Hyperparameter-Abstimmung eine Reihe optimaler Hyperparameter für einen Lernalgorithmus. Ein Hyperparameter ist ein Modellargument, dessen Wert vor dem Beginn des Lernprozesses festgelegt wird. Im Gegensatz dazu werden die Werte anderer Parameter erlernt, z. B. Koeffizienten eines linearen Modells.

Dank der Hyperparameter-Abstimmung können Sie weniger Zeit für die manuelle Iteration von Hyperparametern aufwenden und sich verstärkt auf die Datenauswertung konzentrieren.

Sie können Optionen für die Hyperparameter-Abstimmung für die folgenden Modelltypen angeben:

Für diese Arten von Modellen ist die Hyperparameter-Abstimmung aktiviert, wenn Sie einen Wert für dieNUM_TRIALS-Option in der CREATE MODEL-Anweisung angeben.

Informationen zum Ausführen der Hyperparameter-Abstimmung für ein lineares Regressionsmodell finden Sie unter Mit der Hyperparameter-Abstimmung von BigQuery ML die Modellleistung verbessern.

Die folgenden Modelle unterstützen auch die Hyperparameterabstimmung, aber Sie können keine bestimmten Werte angeben:

In AutoML Tables-Modellen ist die automatische Abstimmung der Hyperparameter standardmäßig im Modelltraining eingebettet.
Bei ARIMA_PLUS-Modellen können Sie das AUTO_ARIMA-Argument festlegen, um die Hyperparameter mit dem auto.ARIMA-Algorithmus abzustimmen. Dieser Algorithmus führt eine Hyperparameter-Abstimmung für das Trendmodul durch. Die Hyperparameter-Abstimmung wird nicht für die gesamte Modellierungs-Pipeline unterstützt.

Informationen zu den unterstützten SQL-Anweisungen und -Funktionen für die einzelnen Modelltypen erhalten Sie unter End-to-End-Nutzerpfad für jedes Modell.

Standorte

Informationen dazu, an welchen Standorten die Hyperparameter-Abstimmung unterstützt wird, finden Sie unter BigQuery ML-Standorte.

Hyperparameter festlegen

Wenn Sie einen Hyperparameter abstimmen möchten, müssen Sie einen Wertebereich für diesen Hyperparameter angeben, den das Modell für eine Reihe von Tests verwenden kann. Dazu können Sie beim Festlegen des Hyperparameters in der CREATE MODEL-Anweisung eines der folgenden Keywords verwenden, anstatt einen einzelnen Wert anzugeben:

HPARAM_RANGE: Ein ARRAY(FLOAT64)-Wert mit zwei Elementen, der die Mindest- und Höchstgrenzen des Suchraums für kontinuierliche Werte für einen Hyperparameter definiert. Mit dieser Option können Sie einen Wertebereich für einen Hyperparameter angeben, z. B. LEARN_RATE = HPARAM_RANGE(0.0001, 1.0).
HPARAM_CANDIDATES: Ein ARRAY(STRUCT)-Wert, der die Gruppe einzelner Werte für den Hyperparameter angibt. Mit dieser Option können Sie einen Satz von Werten für einen Hyperparameter angeben, z. B. OPTIMIZER = HPARAM_CANDIDATES(['ADAGRAD', 'SGD', 'FTRL']).

Hyperparameter und Zielvorhaben

In der folgenden Tabelle sind die unterstützten Hyperparameter und Ziele für jeden Modelltyp aufgeführt, der die Hyperparameter-Abstimmung unterstützt:

Modelltyp	Hyperparameterziele	Hyperparameter	Gültiger Bereich	Standardbereich	Skalentyp
`LINEAR_REG`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (Standard) `EXPLAINED_VARIANCE`	`L1_REG` `L2_REG`	`(0, ∞]` `(0, ∞]`	`(0, 10]` `(0, 10]`	`LOG` `LOG`
`LOGISTIC_REG`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (Standard)	`L1_REG` `L2_REG`	`(0, ∞]` `(0, ∞]`	`(0, 10]` `(0, 10]`	`LOG` `LOG`
`KMEANS`	`DAVIES_BOULDIN_INDEX`	`NUM_CLUSTERS`	`[2, 100]`	`[2, 10]`	`LINEAR`
`MATRIX_ FACTORIZATION` (explizit)	`MEAN_SQUARED_ERROR`	`NUM_FACTORS` `L2_REG`	`[2, 200]` `(0, ∞)`	`[2, 20]` `(0, 10]`	`LINEAR` `LOG`
`MATRIX_ FACTORIZATION` (implizit)	`MEAN_AVERAGE_PRECISION` (Standard) `MEAN_SQUARED_ERROR` `NORMALIZED_DISCOUNTED_CUMULATIVE_GAIN` `AVERAGE_RANK`	`NUM_FACTORS` `L2_REG` `WALS_ALPHA`	`[2, 200]` `(0, ∞)` `[0, ∞)`	`[2, 20]` `(0, 10]` `[0, 100]`	`LINEAR` `LOG` `LINEAR`
`AUTOENCODER`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` (Standard) `MEAN_SQUARED_LOG_ERROR`	`LEARN_RATE` `BATCH_SIZE` `L1_REG` `L2_REG` `L1_REG_ACTIVATION` `DROPOUT` `HIDDEN_UNITS` `OPTIMIZER` `ACTIVATION_FN`	`[0, 1]` `(0, ∞)` `(0, ∞)` `(0, ∞)` `(0, ∞)` `[0, 1)` Array von `[1, ∞)` {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} {`RELU`, `RELU6`, `CRELU`, `ELU`, `SELU`, `SIGMOID`, `TANH`}	`[0, 1]` `[16, 1024]` `(0, 10]` `(0, 10]` `(0, 10]` `[0, 0.8]` – {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} –	`LOG` `LOG` `LOG` `LOG` `LOG` `LINEAR` – – –
`DNN_CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (Standard)	`BATCH_SIZE` `DROPOUT` `HIDDEN_UNITS` `LEARN_RATE` `OPTIMIZER` `L1_REG` `L2_REG` `ACTIVATION_FN`	`(0, ∞)` `[0, 1)` Array von `[1, ∞)` `[0, 1]` {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} `(0, ∞)` `(0, ∞)` {`RELU`, `RELU6`, `CRELU`, `ELU`, `SELU`, `SIGMOID`, `TANH`}	`[16, 1024]` `[0, 0.8]` – `[0, 1]` {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} `(0, 10]` `(0, 10]` –	`LOG` `LINEAR` – `LINEAR` – `LOG` `LOG` –
`DNN_REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (Standard) `EXPLAINED_VARIANCE`				`LOG` `LINEAR` – `LINEAR` – `LOG` `LOG` –
`DNN_LINEAR_ COMBINED_ CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (Standard)	`BATCH_SIZE` `DROPOUT` `HIDDEN_UNITS` `L1_REG` `L2_REG` `ACTIVATION_FN`	`(0, ∞)` `[0, 1)` Array von `[1, ∞)` `(0, ∞)` `(0, ∞)` {`RELU`, `RELU6`, `CRELU`, `ELU`, `SELU`, `SIGMOID`, `TANH`}	`[16, 1024]` `[0, 0.8]` – `(0, 10]` `(0, 10]` –	`LOG` `LINEAR` – `LOG` `LOG` –
`DNN_LINEAR_ COMBINED_ REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (Standard) `EXPLAINED_VARIANCE`			`[16, 1024]` `[0, 0.8]` – `(0, 10]` `(0, 10]` –	`LOG` `LINEAR` – `LOG` `LOG` –
`BOOSTED_TREE_ CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (Standard)	`LEARN_RATE` `L1_REG` `L2_REG` `DROPOUT` `MAX_TREE_DEPTHMAX_TREE_DEPTH` `SUBSAMPLE` `MIN_SPLIT_LOSS` `NUM_PARALLEL_TREE` `MIN_TREE_CHILD_WEIGHT` `COLSAMPLE_BYTREE` `COLSAMPLE_BYLEVEL` `COLSAMPLE_BYNODE` `BOOSTER_TYPE` `DART_NORMALIZE_TYPE` `TREE_METHOD`	`[0, ∞)` `(0, ∞)` `(0, ∞)` `[0, 1]` `[1, 20]` `(0, 1]` `[0, ∞)` `[1, ∞)` `[0, ∞)` `[0, 1]` `[0, 1]` `[0, 1]` {`GBTREE`, `DART`} {`TREE`, `FOREST`} {`AUTO`, `EXACT`, `APPROX`, `HIST`}	`[0, 1]` `(0, 10]` `(0, 10]` – `[1, 10]` `(0, 1]` – – – – – – – – –	`LINEAR` `LOG` `LOG` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` – – –
`BOOSTED_TREE_ REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (Standard) `EXPLAINED_VARIANCE`
`RANDOM_FOREST_ CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (Standard)	`L1_REG` `L2_REG` `MAX_TREE_DEPTH` `SUBSAMPLE` `MIN_SPLIT_LOSS` `NUM_PARALLEL_TREE` `MIN_TREE_CHILD_WEIGHT` `COLSAMPLE_BYTREE` `COLSAMPLE_BYLEVEL` `COLSAMPLE_BYNODE` `TREE_METHOD`	`(0, ∞)` `(0, ∞)` `[1, 20]` `(0, 1)` `[0, ∞)` `[2, ∞)` `[0, ∞)` `[0, 1]` `[0, 1]` `[0, 1]` {`AUTO`, `EXACT`, `APPROX`, `HIST`}	`(0, 10]` `(0, 10]` `[1, 20]` `(0, 1)` – `[2, 200]` – – – – –	`LOG` `LOG` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` –
`RANDOM_FOREST_ REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (Standard) `EXPLAINED_VARIANCE`

Bei den meisten LOG-Skalierungshyperparametern wird die offene untere Grenze von 0 verwendet. Sie können 0 auch als untere Grenze festlegen. Verwenden Sie dazu das Keyword HPARAM_RANGE, um den Hyperparameter-Bereich festzulegen. In einem Boosted Tree-Klassifizierungsmodell können Sie beispielsweise den Bereich für den L1_REG-Hyperparameter auf L1_REG = HPARAM_RANGE(0, 5) festlegen. Ein Wert von 0 wird in 1e-14 konvertiert.

Bedingte Hyperparameter werden unterstützt. In einem Boosted Tree-Regressormodell können Sie beispielsweise nur die Abstimmung der DART_NORMALIZE_TYPE Hyperparameter vornehmen, wenn der Wert des Hyperparameters BOOSTER_TYPE DART ist. In diesem Fall geben Sie beide Suchbereiche an und die Bedingungen werden automatisch verarbeitet, wie im folgenden Beispiel gezeigt:

BOOSTER_TYPE = HPARAM_CANDIDATES(['DART', 'GBTREE'])
DART_NORMALIZE_TYPE = HPARAM_CANDIDATES(['TREE', 'FOREST'])

Startpunkt der Suche

Wenn Sie keinen Suchbereich für einen Hyperparameter mit HPARAM_RANGE oder HPARAM_CANDIDATES angeben, beginnt die Suche ab dem Standardwert dieses Hyperparameters, wie im Thema CREATE MODEL für diesen Modelltyp dokumentiert. Wenn Sie beispielsweise Hyperparameter-Abstimmung für ein Boosted Tree-Modell ausführen und Sie keinen Wert für den Hyperparameter L1_REG angeben, beginnt die Suche ab dem Standardwert 0.

Wenn Sie mit HPARAM_RANGE oder HPARAM_CANDIDATES einen Suchbereich für einen Hyperparameter angeben, hängt der Startpunkt der Suche davon ab, ob der angegebene Suchbereich den Standardwert für diesen Hyperparameter enthält, wie im Thema CREATE MODEL für diesen Modelltyp dokumentiert:

Wenn der angegebene Bereich den Standardwert enthält, beginnt die Suche an dieser Stelle. Wenn Sie beispielsweise die Abstimmung der Hyperparameter für ein implizites Matrixfaktorisierungsmodell durchführen und den Wert [20, 30, 40, 50] für den Hyperparameter WALS_ALPHA angeben, beginnt die Suche bei dem Standardwert 40.
Wenn der angegebene Bereich den Standardwert nicht enthält, beginnt die Suche an dem Punkt im angegebenen Bereich, der dem Standardwert am nächsten ist. Wenn Sie beispielsweise den Wert [10, 20, 30] für den Hyperparameter WALS_ALPHA angeben, beginnt die Suche bei 30, dem nächstgelegenen Wert zum Standardwert von 40.

Datenaufteilung

Wenn Sie einen Wert für die Option NUM_TRIALS angeben, erkennt der Dienst, dass Sie die Hyperparameter-Abstimmung durchführen, und führt automatisch eine dreifache Aufteilung der Eingabedaten durch, um sie in Trainings-, Auswertungs- und Test-Datasets aufzuteilen. Standardmäßig werden die Eingabedaten nach dem Zufallsprinzip ausgewählt und dann in 80 % für das Training, 10 % für die Bewertung und 10 % für Tests aufgeteilt.

Die Trainings- und Bewertungssätze werden bei jedem Testtraining verwendet, genau wie bei Modellen, bei denen keine Hyperparameter-Abstimmung verwendet wird. Die Vorschläge für die Test-Hyperparameter werden anhand der Modellbewertungsmesswerte für diesen Modelltyp berechnet. Am Ende jedes Testtrainings wird der Testsatz verwendet, um den Test zu testen und die Messwerte im Modell zu erfassen. Dadurch wird die Objektivität der Messwerte für die endgültige Berichterstellung sichergestellt, da Daten verwendet werden, die noch nicht vom Modell analysiert wurden. Die Auswertungsdaten werden verwendet, um die Zwischenmesswerte für den Vorschlag von Hyperparametern zu berechnen, während die Testdaten zur Berechnung der endgültigen, objektiven Modellmesswerte verwendet werden.

Wenn Sie nur ein Trainingsset verwenden möchten, geben Sie NO_SPLIT für die DATA_SPLIT_METHOD-Option der CREATE MODEL-Anweisung an.

Wenn Sie nur Trainings- und Bewertungs-Datasets verwenden möchten, geben Sie 0 für die DATA_SPLIT_TEST_FRACTION-Option der CREATE MODEL-Anweisung an. Wenn der Testsatz leer ist, wird der Bewertungssatz als Testsatz für die Berichte zu den endgültigen Bewertungsmesswerten verwendet.

Die Messwerte von Modellen, die aus einem normalen Trainingsjob generiert werden, und die aus einem Trainingsjob mit Hyperparameter-Abstimmung sind nur vergleichbar, wenn die Fraktionen der Datenaufteilung gleich sind. Die folgenden Modelle sind beispielsweise vergleichbar:

Feinabstimmung ohne Hyperparameter: DATA_SPLIT_METHOD='RANDOM', DATA_SPLIT_EVAL_FRACTION=0.2
Hyperparameter-Feinabstimmung: DATA_SPLIT_METHOD='RANDOM', DATA_SPLIT_EVAL_FRACTION=0.2, DATA_SPLIT_TEST_FRACTION=0

Leistung

Die Modellleistung bei Verwendung der Hyperparameter-Abstimmung ist in der Regel nicht schlechter als die Modellleistung bei Verwendung des Standardsuchbereichs und ohne Hyperparameter-Abstimmung. Ein Modell, das den Standardsuchbereich und keine Hyperparameter-Abstimmung nutzt, verwendet immer die Standard-Hyperparameter im ersten Test.

Um die durch die Hyperparameter-Abstimmung erzielten Leistungsverbesserungen zu bestätigen, vergleichen Sie den optimalen Test für das Modell mit Hyperparameter-Abstimmung mit dem ersten Test für das Modell ohne Hyperparameter-Abstimmung.

Lerntransfer

Lerntransfer ist standardmäßig aktiviert, wenn Sie die Option HPARAM_TUNING_ALGORITHM in der Anweisung CREATE MODEL auf VIZIER_DEFAULT setzen. Die Hyperparameter-Abstimmung für ein Modell profitiert vom Lernen aus zuvor abgestimmten Modellen, wenn es die folgenden Anforderungen erfüllt:

Es hat denselben Modelltyp wie zuvor abgestimmte Modelle.
Es befindet sich im selben Projekt wie zuvor optimierte Modelle.
Es verwendet denselben Hyperparameter-Suchbereich ODER eine Teilmenge des Hyperparameter-Suchbereichs zuvor abgestimmter Modelle. Für einen Teilsatz werden dieselben Hyperparameternamen und ‑typen verwendet, aber nicht unbedingt dieselben Bereiche. Beispiel: (a:[0, 10]) wird als Teilmenge von (a:[-1, 1], b:[0, 1]) betrachtet.

Für den Lerntransfer müssen die Eingabedaten nicht identisch sein.

Der Lerntransfer hilft, das Kaltstartproblem zu lösen, bei dem das System während des ersten Testbatches eine zufällige explorative Datenanalyse ausführt. Der Lerntransfer stellt dem System ein grundlegendes Wissen über die Hyperparameter und deren Ziele bereit. Um die Modellqualität kontinuierlich zu verbessern, trainieren Sie immer ein neues Hyperparameter-Abstimmungsmodell mit denselben oder einer Teilmenge von Hyperparametern.

Mit dem Lerntransfer wird die Hyperparameter-Abstimmung beschleunigt, anstatt Teilmodelle bei der Konvergenz zu unterstützen.

Fehlerbehandlung

Bei der Hyperparameter-Abstimmung werden Fehler auf folgende Weise gehandhabt:

Abbruch: Wenn ein Trainingsjob während der Ausführung abgebrochen wird, bleiben alle erfolgreichen Tests nutzbar.
Ungültige Eingabe: Wenn die Nutzereingabe ungültig ist, gibt der Dienst einen Nutzerfehler zurück.
Ungültige Hyperparameter: Wenn die Hyperparameter für einen Test ungültig sind, wird der Test übersprungen und in der Ausgabe der Funktion ML.TRIAL_INFO als INFEASIBLE markiert.
Interner Testfehler: Wenn mehr als 10 % des Werts NUM_TRIALS aufgrund von INTERNAL_ERROR fehlschlagen, wird der Trainingsjob beendet und ein Nutzerfehler zurückgegeben.
Wenn weniger als 10 % des NUM_TRIALS-Werts aufgrund von INTERNAL_ERROR fehlschlagen, wird das Training mit den fehlgeschlagenen Tests fortgesetzt, die in der Ausgabe der Funktion ML.TRIAL_INFO als FAILED markiert sind.

Funktionen für die Modellbereitstellung

Sie können Ausgabemodelle aus der Hyperparameterabstimmung mit einer Reihe vorhandener Funktionen zur Modellbereitstellung verwenden. Beachten Sie bei der Verwendung dieser Funktionen die folgenden Regeln:

Wenn die Funktion Eingabedaten annimmt, wird nur das Ergebnis eines Tests zurückgegeben. Standardmäßig ist dies der optimale Test. Sie können aber auch einen bestimmten Test auswählen, indem Sie TRIAL_ID als Argument für die jeweilige Funktion angeben. Sie können die TRIAL_ID aus der Ausgabe der Funktion ML.TRIAL_INFO abrufen. Folgende Funktionen werden unterstützt:
Wenn die Funktion keine Eingabedaten annimmt, werden alle Testergebnisse zurückgegeben und die erste Ausgabespalte ist TRIAL_ID. Folgende Funktionen werden unterstützt:

Die Ausgabe von ML.FEATURE_INFO ändert sich nicht, da alle Tests dieselben Eingabedaten verwenden.

Die Bewertungsmesswerte von ML.EVALUATE und ML.TRIAL_INFO können aufgrund der Aufteilung der Eingabedaten unterschiedlich sein. Standardmäßig wird ML.EVALUATE anhand der Testdaten ausgeführt, während ML.TRIAL_INFO anhand der Bewertungsdaten ausgeführt wird. Weitere Informationen finden Sie unter Datenaufteilung.

Nicht unterstützte Funktionen

Die ML.TRAINING_INFO-Funktion gibt Informationen für jede Iteration zurück. Die Iterationsergebnisse werden nicht in Modellen zur Hyperparameter-Optimierung gespeichert. Stattdessen werden die Testergebnisse gespeichert. Mit der Funktion ML.TRIAL_INFO können Sie Informationen zu Testergebnissen abrufen.

Modellexport

Mit der EXPORT MODEL-Anweisung können Sie Modelle, die mithilfe der Hyperparameteroptimierung erstellt wurden, an Cloud Storage-Speicherorte exportieren. Sie können den standardmäßigen optimalen Test oder einen beliebigen angegebenen Test exportieren.

Preise

Die Kosten für die Hyperparameter-Abstimmung sind die Summe der Kosten aller ausgeführten Tests. Die Preise für einen Testzeitraum entsprechen dem BigQuery ML-Preismodell.

FAQ

In diesem Abschnitt finden Sie Antworten auf einige häufig gestellte Fragen zur Hyperparameteroptimierung.

Wie viele Versuche brauche ich, um ein Modell zu optimieren?

Wir empfehlen, für einen Hyperparameter mindestens 10 Tests auszuführen. Die Gesamtzahl der Tests sollte also mindestens 10 * num_hyperparameters betragen. Wenn Sie den Standardsuchbereich verwenden, finden Sie in der Spalte Hyperparameter in der Tabelle Hyperparameter und Ziele die Anzahl der Hyperparameter, die standardmäßig für einen bestimmten Modelltyp abgestimmt sind.

Was passiert, wenn ich mit der Hyperparameter-Abstimmung keine Leistungsverbesserungen erziele?

Folgen Sie der Anleitung in diesem Dokument, um einen fairen Vergleich zu erhalten. Wenn Sie immer noch keine Leistungsverbesserungen feststellen, funktionieren die Standardhyperparameter möglicherweise schon gut für Sie. Sie können sich auf die Feature-Entwicklung konzentrieren oder andere Modelltypen ausprobieren, bevor Sie eine weitere Hyperparameter-Feinabstimmung versuchen.

Wie kann ich ein Modell weiter optimieren?

Trainieren Sie ein neues Hyperparameter-Abstimmungsmodell mit demselben Suchraum. Mit dem Lerntransfer können Sie die Abstimmung auf der Grundlage Ihrer zuvor abgestimmten Modelle fortsetzen.

Muss ich das Modell mit allen Daten und den optimalen Hyperparametern neu trainieren?

Das hängt von folgenden Faktoren ab:

Bei K-Means-Modellen werden bereits alle Daten als Trainingsdaten verwendet. Daher muss das Modell nicht noch einmal trainiert werden.
Bei Matrixfaktorisierungsmodellen können Sie das Modell mit den ausgewählten Hyperparametern und allen Eingabedaten neu trainieren, um eine bessere Abdeckung von Nutzern und Artikeln zu erzielen.
Bei allen anderen Modelltypen ist eine Neuschulung in der Regel nicht erforderlich. Der Dienst behält bereits 80 % der Eingabedaten für das Training während der standardmäßigen zufälligen Datenaufteilung bei. Sie können das Modell immer noch mit mehr Trainingsdaten und den ausgewählten Hyperparametern neu trainieren, wenn Ihr Dataset klein ist. Wenn Sie jedoch nur wenige Auswertungsdaten für ein frühzeitiges Anhalten übrig lassen, kann dies zu einer Überanpassung führen.

Nächste Schritte

Informationen zum Ausführen der Hyperparameter-Abstimmung finden Sie unter Mit der Hyperparameter-Abstimmung von BigQuery ML die Modellleistung verbessern.