Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Integrierte SageMaker-AI-Algorithmen für tabellarische Daten
Amazon SageMaker AI bietet integrierte Algorithmen, die auf die Analyse von Tabellendaten zugeschnitten sind. Tabellendaten beziehen sich auf alle Datensätze, die in Tabellen organisiert sind, die aus Zeilen (Beobachtungen) und Spalten (Features) bestehen. Die integrierten SageMaker-AI-Algorithmen für Tabellendaten können entweder für Klassifikations- oder Regressionsprobleme verwendet werden.
+ [AutoGluon-Tabellarisch](autogluon-tabular.md) – Ein Open-Source-AutoML-Framework, das erfolgreich ist, indem es Modelle zusammenfügt und sie in mehreren Ebenen stapelt.
+ [CatBoost](catboost.md) – Eine Implementierung des Gradient-Boosted Trees-Algorithmus, der ein geordnetes Boosting und einen innovativen Algorithmus für die Verarbeitung kategorischer Features einführt.
+ [Faktorisierungsmaschinen Algorithmus](fact-machines.md) – Eine Erweiterung eines linearen Modells ist darauf ausgelegt, Interaktionen zwischen Funktionen innerhalb von hochdimensionalen Datensätzen mit geringer Dichte automatisch wirtschaftlich zu erfassen.
+ [K-nearest neighbors (k-NN)-Algorithmus](k-nearest-neighbors.md) – Eine nicht-parametrische Methode, bei der die k nächstgelegenen beschrifteten Punkte verwendet werden, um einem neuen Datenpunkt zur Klassifizierung oder einem prognostizierten Zielwert aus dem Durchschnitt der k nächstgelegenen Punkte für die Regression eine Markierung zuzuweisen.
+ [LightGBM](lightgbm.md) – Eine Implementierung des Gradient-Boosted Trees-Algorithmus, der zwei neuartige Techniken zur Verbesserung der Effizienz und Skalierbarkeit hinzufügt: Gradient-Based One-Side Sampling (GOSS) und Exclusive Feature Bundling (EFB).
+ [Algorithmus für lineares Lernen](linear-learner.md) – lernt eine lineare Funktion für die Regression oder eine lineare Schwellenwertfunktion für die Klassifizierung.
+ [TabTransformer](tabtransformer.md) – Eine neuartige, tiefgründige, tabellarische Datenmodellierungsarchitektur, die auf Transformatoren basiert, die Eigenverantwortung übernehmen.
+ [XGBoost Algorithmus mit Amazon SageMaker AI](xgboost.md) – Eine Implementierung des Gradient-Boosted Trees-Algorithmus, der eine Reihe einfacherer und schwächerer Modelle kombiniert.
| Name des Algorithmus | Kanalname | Trainingseingabemodus | Dateityp | Instance-Klasse | Parallelisierbar |
| --- | --- | --- | --- | --- | --- |
| AutoGluon – Tabular | "train" und (optional) "validation" | Datei | CSV | CPU oder GPU (nur einzelne Instance) | Nein |
| Cat Boost | "train" und (optional) "validation" | Datei | CSV | CPU (nur einzelne Instance) | Nein |
| Factorization Machines | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf | CPU (GPU für Daten mit hoher Dichte) | Ja |
| K-Nearest-Neighbors (k-NN) | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU- oder GPU (einzelnes GPU-Gerät auf einer oder mehreren Instances) | Ja |
| LightGBM | train und (optional) validation | Datei | CSV | CPU (nur einzelne Instance) | Nein |
| Lineares Lernen | "train" und (optional) "validation", "test" oder beides | Datei oder Pipe | recordIO-protobuf oder CSV | CPU oder GPU | Ja |
| Tab-Transformator | "train" und (optional) "validation" | Datei | CSV | CPU oder GPU (nur einzelne Instance) | Nein |
| XGBoost (0.90-1, 0.90-2, 1.0-1, 1.2-1, 1.2-21) | "train" und (optional) "validation" | Datei oder Pipe | CSV, LibSVM oder Parquet | CPU (oder GPU für 1.2-1) | Ja |
# AutoGluon-Tabellarisch
[AutoGluon-Tabular](https://auto.gluon.ai/stable/index.html) ist ein beliebtes Open-Source-AutoML-Framework, das hochgenaue Modelle für maschinelles Lernen auf einem unverarbeiteten tabellarischen Datensatz trainiert. Im Gegensatz zu bestehenden AutoML-Frameworks, die sich hauptsächlich auf die Auswahl von Modellen und Hyperparametern konzentrieren, gelingt es AutoGluon -Tabular, mehrere Modelle zusammenzufügen und sie in mehreren Schichten zu stapeln. Diese Seite enthält Informationen zu Amazon EC2 EC2-Instance-Empfehlungen und Beispielnotizbücher für AutoGluon -Tabular.
# Wie benutzt man AI -Tabular SageMaker AutoGluon
Sie können AutoGluon -Tabular als integrierten Algorithmus von Amazon SageMaker AI verwenden. Im folgenden Abschnitt wird beschrieben, wie Sie AutoGluon -Tabular mit dem SageMaker Python-SDK verwenden. Informationen zur Verwendung von AutoGluon -Tabular über die Amazon SageMaker Studio Classic-Benutzeroberfläche finden Sie unter. [SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md)
+ **Verwenden Sie AutoGluon -Tabular als integrierten Algorithmus**
Verwenden Sie den integrierten Algorithmus AutoGluon -Tabular, um einen AutoGluon -Tabular-Trainingscontainer zu erstellen, wie im folgenden Codebeispiel gezeigt. Sie können den Bild-URI für den integrierten Algorithmus AutoGluon -Tabular mithilfe der SageMaker `image_uris.retrieve` KI-API (oder der `get_image_uri` API, wenn Sie [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Version 2 verwenden) automatisch erkennen.
Nachdem Sie den AutoGluon -Tabular-Image-URI angegeben haben, können Sie den AutoGluon -Tabular-Container verwenden, um mithilfe der SageMaker AI Estimator-API einen Schätzer zu erstellen und einen Trainingsjob zu starten. Der integrierte Algorithmus AutoGluon -Tabular wird im Skriptmodus ausgeführt, aber das Trainingsskript wird für Sie bereitgestellt und muss nicht ersetzt werden. Wenn Sie umfangreiche Erfahrung mit der Erstellung eines SageMaker Trainingsjobs im Skriptmodus haben, können Sie Ihre eigenen AutoGluon -Tabular-Schulungsskripte integrieren.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "autogluon-classification-ensemble", "*", "training"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_binary/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"auto_stack"
] = "True"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Weitere Informationen zum Einrichten von AutoGluon -Tabular als integrierten Algorithmus finden Sie in den folgenden Notebook-Beispielen. Jeder in diesen Beispielen verwendete S3-Bucket muss sich in derselben AWS Region befinden wie die Notebook-Instanz, auf der sie ausgeführt wurden.
+ [Tabellarische Klassifizierung mit Amazon SageMaker AI AutoGluon — Tabellarischer Algorithmus](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb)
+ [Tabellarische Regression mit Amazon SageMaker AI AutoGluon — Tabellarischer Algorithmus](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb)
# Eingabe- und Ausgabeschnittstelle für den -Tabular-Algorithmus AutoGluon
Gradient Boosting arbeitet mit tabellarischen Daten, wobei die Zeilen die Beobachtungen repräsentieren, eine Spalte die Zielvariable oder die Kennzeichnung darstellt und die verbleibenden Spalten die Funktionen.
Die SageMaker KI-Implementierung von AutoGluon -Tabular unterstützt CSV für Training und Inferenz:
+ *Für das **Training ContentType** müssen gültige Eingaben text/csv sein.*
+ *Für **Inference ContentType** müssen gültige Eingaben text/csv sein.*
**Anmerkung**
Bei der CSV-Training geht der Algorithmus davon aus, dass die Zielvariable in der ersten Spalte zu finden ist und CSV keinen Header-Datensatz aufweist.
Bei der CSV-Inferenz geht der Algorithmus davon aus, dass die CSV-Eingabe keine Kennzeichnungsspalte hat.
**Eingabeformat für Trainingsdaten, Validierungsdaten und kategoriale Features**
Achten Sie darauf, wie Sie Ihre Trainingsdaten für die Eingabe in das -Tabularmodell formatieren. AutoGluon Sie müssen den Pfad zu einem Amazon-S3-Bucket angeben, der Ihre Trainings- und Validierungsdaten enthält. Sie können auch eine Liste von kategorialen Funktionen einschließen. Verwenden Sie sowohl `training` als auch den `validation` Kanal, um Ihre Eingabedaten bereitzustellen. Alternativ können Sie aber auch nur den `training` Kanal verwenden.
**Verwenden Sie sowohl den `training` als auch den `validation` Kanal**
Sie können Ihre Eingabedaten über zwei S3-Pfade bereitstellen, einen für den `training` Kanal und einen für den `validation` Kanal. Jeder S3-Pfad kann entweder ein S3-Präfix sein oder ein vollständiger S3-Pfad, der auf eine bestimmte CSV-Datei verweist. Die Zielvariablen sollten sich in der ersten Spalte Ihrer CSV-Datei befinden. Die Prädiktorvariablen (Features) sollten sich in den verbleibenden Spalten befinden. Die Validierungsdaten werden verwendet, um am Ende jeder Boosting-Iteration eine Validierungspunktzahl zu berechnen. Early-Stopping wird angewendet, wenn sich der Validierungsscore nicht mehr verbessert.
Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Trainingsdatendatei. Wenn Sie eine JSON-Datei für kategorische Features bereitstellen, muss Ihr `training`-Kanal auf ein S3-Präfix verweisen und nicht auf eine spezifische CSV-Datei. Diese Datei sollte ein Python-Wörterbuch enthalten, in dem der Schlüssel die Zeichenfolge `"cat_index_list"` und der Wert eine Liste eindeutiger Ganzzahlen ist. Jede Ganzzahl in der Werteliste sollte den Spaltenindex der entsprechenden kategorischen Features in Ihrer CSV-Datei mit Trainingsdaten angeben. Jeder Wert sollte eine positive Ganzzahl (größer als Null, weil Null den Zielwert darstellt), kleiner als `Int32.MaxValue` (2147483647) und kleiner als die Gesamtzahl der Spalten sein. Es sollte nur eine JSON-Datei mit dem kategorischen Index geben.
**Benutze nur den `training` Kanal**:
Sie können Ihre Eingabedaten alternativ über einen einzigen S3-Pfad für den `training` Kanal bereitstellen. Dieser S3-Pfad sollte auf ein Verzeichnis mit einem Unterverzeichnis mit dem Namen `training/` verweisen, das eine CSV-Datei enthält. Sie können optional ein weiteres Unterverzeichnis am selben Speicherort namens `validation/` einschließen, das auch eine CSV-Datei enthält. Wenn die Validierungsdaten nicht angegeben werden, werden 20% Ihrer Trainingsdaten nach dem Zufallsprinzip als Validierungsdaten ausgewählt. Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Datenunterverzeichnisse.
**Anmerkung**
Beim CSV-Trainingseingangsmodus muss der für den Algorithmus verfügbare Gesamtarbeitsspeicher (Instance-Zählung verfügbarer Arbeitsspeicher im `InstanceType`) in der Lage sein, den Trainingsdatensatz aufzunehmen.
SageMaker AI AutoGluon -Tabular verwendet das `autogluon.tabular.TabularPredictor` Modul, um das Modell zu serialisieren oder zu deserialisieren, was zum Speichern oder Laden des Modells verwendet werden kann.
**Um ein mit AI -Tabular trainiertes Modell mit dem SageMaker Framework zu verwenden AutoGluon AutoGluon**
+ Verwenden Sie den folgenden Python-Code:
```
import tarfile
from autogluon.tabular import TabularPredictor
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = TabularPredictor.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Amazon EC2 EC2-Instance-Empfehlung für den AutoGluon -Tabular-Algorithmus
SageMaker AI AutoGluon -Tabular unterstützt Einzelinstanz-CPU- und Einzelinstanz-GPU-Training. Trotz der höheren Kosten pro Instanz sollten Sie schneller GPUs trainieren, was sie kostengünstiger macht. Um die Vorteile des GPU-Trainings zu nutzen, geben Sie den Instanztyp als eine der GPU-Instanzen an (z. B. P3). SageMaker AI AutoGluon -Tabular unterstützt derzeit kein Multi-GPU-Training.
## AutoGluon-Tabellarische Beispielnotizbücher
In der folgenden Tabelle sind verschiedene Beispielnotizbücher aufgeführt, die sich mit verschiedenen Anwendungsfällen des Amazon SageMaker AutoGluon AI-Tabular-Algorithmus befassen.
****
| **Titel des Notebooks** | **Beschreibung** |
| --- | --- |
| [Tabellarische Klassifizierung mit Amazon SageMaker AI AutoGluon — Tabellarischer Algorithmus](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker AutoGluon AI-Tabular-Algorithmus zum Trainieren und Hosten eines tabellarischen Klassifikationsmodells. |
| [Tabellarische Regression mit Amazon SageMaker AI AutoGluon — Tabellarischer Algorithmus](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker AutoGluon AI-Tabular-Algorithmus zum Trainieren und Hosten eines tabellarischen Regressionsmodells. |
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instances, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
# Wie funktioniert AutoGluon -Tabular
AutoGluon-Tabular führt fortschrittliche Datenverarbeitungs-, Deep Learning- und mehrschichtige Modellensemble-Methoden durch. Es erkennt automatisch den Datentyp in jeder Spalte und ermöglicht so eine robuste Datenvorverarbeitung, einschließlich einer speziellen Behandlung von Textfeldern.
AutoGluon eignet sich für verschiedene Modelle, die von off-the-shelf Boost-Trees bis hin zu maßgeschneiderten neuronalen Netzwerken reichen. Diese Modelle sind auf neuartige Weise zusammengesetzt: Modelle werden in mehreren Schichten gestapelt und schichtweise trainiert, sodass gewährleistet ist, dass Rohdaten innerhalb einer bestimmten Zeitbeschränkung in qualitativ hochwertige Voraussagen übersetzt werden können. Dieser Prozess verhindert Überanpassungen, indem die Daten auf verschiedene Arten aufgeteilt und die Beispiele sorgfältig verfolgt werden. out-of-fold
Der AutoGluon -Tabular-Algorithmus schneidet bei Wettbewerben im Bereich maschinelles Lernen aufgrund seiner robusten Verarbeitung einer Vielzahl von Datentypen, Beziehungen und Verteilungen gut ab. Sie können AutoGluon -Tabular für Regressions-, Klassifizierungs- (binär- und Mehrklassenprobleme) und Ranking-Probleme verwenden.
Das folgende Diagramm zeigt, wie die Strategie für mehrschichtiges Stapeln funktioniert.
![\[AutoGluonDie mehrschichtige Stapelstrategie wird anhand von zwei Stapelebenen dargestellt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/autogluon_tabular_illustration.png)
Weitere Informationen finden Sie unter *[AutoGluon-Tabular: Robustes und genaues AutoML für](https://arxiv.org/pdf/2003.06505.pdf)* strukturierte Daten.
# AutoGluon-Tabellarische Hyperparameter
Die folgende Tabelle enthält die Teilmenge der Hyperparameter, die für den Amazon SageMaker AI AutoGluon -Tabular-Algorithmus erforderlich sind oder am häufigsten verwendet werden. Dies sind Parameter, die von Benutzern festgelegt werden, um die Schätzung der Modellparameter aus Daten zu erleichtern. [Der SageMaker AI AutoGluon -Tabular-Algorithmus ist eine Implementierung des Open-Source-Pakets -Tabular. AutoGluon](https://github.com/awslabs/autogluon)
**Anmerkung**
Die Standard-Hyperparameter basieren auf Beispieldatensätzen in der [AutoGluon-Tabellarische Beispielnotizbücher](autogluon-tabular.md#autogluon-tabular-sample-notebooks).
Standardmäßig wählt der SageMaker AutoGluon AI-Tabular-Algorithmus automatisch eine Bewertungsmetrik aus, die auf der Art des Klassifizierungsproblems basiert. Der Algorithmus erkennt die Art des Klassifizierungsproblems basierend auf der Anzahl von Labels in Ihren Daten. Bei Regressionsproblemen ist die Bewertungsmetrik der quadratische Mittelwert des Fehlers. Bei binären Klassifikationsproblemen entspricht die Bewertungsmetrik der Fläche unter der Betriebskennlinie (AUC) des Empfängers. Bei Mehrklassen-Klassifizierungsproblemen ist Genauigkeit die Bewertungsmetrik. Sie können den `eval_metric` Hyperparameter verwenden, um die Standard-Bewertungsmetrik zu ändern. In der folgenden Tabelle finden Sie weitere Informationen zu AutoGluon -Tabular-Hyperparametern, einschließlich Beschreibungen, gültiger Werte und Standardwerte.
| Name des Parameters | Description |
| --- | --- |
| eval\$1metric | Die Bewertungsmetrik für Validierungsdaten. Wenn `eval_metric` auf den Standardwert `"auto"` gesetzt ist, wählt der Algorithmus automatisch eine Bewertungsmetrik aus, die auf der Art des Klassifizierungsproblems basiert: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) Gültige Werte: Zeichenfolge, gültige Werte finden Sie in der [AutoGluon Dokumentation](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html). Standardwert: `"auto"`. |
| presets | Liste der voreingestellten Konfigurationen für verschiedene Argumente in `fit()`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) Weitere Informationen finden Sie unter [AutoGluon Prädiktoren](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html). Gültige Werte: Zeichenfolge, einer der folgenden Werte: (`"best_quality"`, `"high_quality"`, `good_quality"`, `"medium_quality"`, `"optimize_for_deployment"`,` or "interpretable"`). Standardwert: `"medium_quality"`. |
| auto\$1stack | Ob zur Erhöhung der AutoGluon Vorhersagegenauigkeit automatisch Verpackungsmaterial und mehrlagiges Stack-Ensembling eingesetzt werden sollten. Setzen Sie `auto_stack` auf `"True"`, wenn Sie bereit sind, längere Trainingszeiten in Kauf zu nehmen, um die Vorhersagegenauigkeit zu maximieren. Dadurch werden die Argumente `num_bag_folds` und `num_stack_levels` automatisch auf der Grundlage der Datensatz-Eigenschaften festgelegt. Gültige Werte: Zeichenfolge, `"True"` oder `"False"`. Standardwert: `"False"`. |
| num\$1bag\$1folds | Anzahl von beim Verpacken von Modellen verwendeten Falten. Wenn `num_bag_folds` gleich wie `k` ist, erhöht sich die Trainingszeit ungefähr um den Faktor von `k`. Auf 0 setzen `num_bag_folds`, um das Einpacken zu deaktivieren. Dies ist standardmäßig deaktiviert, wir empfehlen jedoch, Werte zwischen 5 und 10 zu verwenden, um die Prognoseleistung zu maximieren. Zunehmende `num_bag_folds` Ergebnisse bei Modellen mit geringerer Verzerrung, die jedoch anfälliger für Überanpassungen sind. Eins ist ein ungültiger Wert für diesen Parameter und führt zu einem `ValueError`. Werte größer als 10 können zu sinkenden Renditen führen und aufgrund einer zu hohen Anpassung sogar die Gesamtergebnisse beeinträchtigen. Um die Voraussagen weiter zu verbessern, vermeiden Sie es, `num_bag_folds` zu erhöhen, und erhöhen Sie stattdessen `num_bag_sets`. Gültige Werte: Zeichenfolge, eine beliebige Ganzzahl zwischen (und einschließlich) `"0"` und`"10"`. Standardwert: `"0"`. |
| num\$1bag\$1sets | Anzahl von Wiederholungen von kfold bagging (Werte müssen größer als oder gleich 1 sein). Die Gesamtzahl der beim Einpacken trainierten Modelle ist gleich `num_bag_folds` \$1 `num_bag_sets`. Dieser Parameter ist standardmäßig auf eins voreingestellt, wenn `time_limit` nicht angegeben ist. Dieser Parameter ist deaktiviert, wenn `num_bag_folds` nicht angegeben ist. Werte, die größer als eins sind, führen zu einer besseren Vorhersageleistung, insbesondere bei kleineren Problemen und wenn Stacking aktiviert ist. Gültige Werte: Ganzzahl, Bereich: [`1`, `20`]. Standardwert: `1`. |
| num\$1stack\$1levels | Anzahl von Stapelebenen, die im Stack-Ensemble verwendet werden sollen. Erhöht die Trainingszeit des Modells grob um den Faktor `num_stack_levels` \$1 1. Setzen Sie diesen Parameter auf 0, um das Stack-Ensembling zu deaktivieren. Dieser Parameter ist standardmäßig deaktiviert, wir empfehlen jedoch, Werte zwischen 1 und 3 zu verwenden, um die Vorhersageleistung zu maximieren. Um eine Überanpassung zu vermeiden, muss `ValueError`, `num_bag_folds` größer als oder gleich 2 sein. Gültige Werte: Float, Bereich: [`0`, `3`]. Standardwert: `0`. |
| refit\$1full | Gibt an, ob alle Modelle nach dem normalen Trainingsverfahren anhand aller Daten (Training und Validierung) neu trainiert werden sollen oder nicht. [Weitere Informationen finden Sie unter Prädiktoren. AutoGluon ](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) Gültige Werte: Zeichenfolge, `"True"` oder `"False"`. Standardwert: `"False"`. |
| set\$1best\$1to\$1refit\$1full | Ob das Standardmodell, das der Prädiktor für die Vorhersage verwendet, geändert werden soll oder nicht. Wenn `set_best_to_refit_full` auf `"True"` gesetzt ist, wird das Standardmodell auf das Modell umgestellt, das als Ergebnis der Neuanpassung (aktiviert von `refit_full`) den höchsten Validierungsscore aufwies. Nur gültig, wenn `refit_full` gesetzt ist. Gültige Werte: Zeichenfolge, `"True"` oder `"False"`. Standardwert: `"False"`. |
| save\$1space | Angabe, ob die Speicher- und Festplattengröße des Predictors durch Löschen von Hilfsmodelldateien, die für die Voraussage neuer Daten nicht benötigt werden, reduziert werden soll. Dies hat keine Auswirkungen auf die Genauigkeit der Inferenz. Wir empfehlen die Einstellung `save_space` auf `"True"`, wenn das einzige Ziel darin besteht, das trainierte Modell für Voraussagen zu verwenden. Bestimmte erweiterte Funktionen sind möglicherweise nicht mehr verfügbar, wenn `save_space` auf `"True"`. eingestellt ist. Weitere Details finden Sie in der `[predictor.save\$1space()](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.save_space.html)` Dokumentation. Gültige Werte: Zeichenfolge, `"True"` oder `"False"`. Standardwert: `"False"`. |
| verbosity | Die Ausführlichkeit der Druckmeldungen. `verbosity` Stufen reichen von `0` bis `4`, wobei höhere Stufen ausführlichere Druckanweisungen bedeuten. A `verbosity` von `0` unterdrückt Warnungen. Gültige Werte: Ganzzahl, einer der folgenden Werte: (`0`, `1`, `2`, `3`, oder `4`). Standardwert: `2`. |
# Optimieren eines AutoGluon tabellarischen Modells
AutoGluon-Tabular kann zwar bei der Modelloptimierung verwendet werden, sein Design kann jedoch mit Stacking- und Ensemble-Methoden eine gute Leistung erzielen, sodass eine Hyperparameter-Optimierung nicht erforderlich ist. Anstatt sich auf die Modelloptimierung zu konzentrieren, gelingt es AutoGluon -Tabular, Modelle in mehreren Ebenen zu stapeln und schichtweise zu trainieren.
Weitere Hinweise zu -Tabular-Hyperparametern finden Sie unter. AutoGluon [AutoGluon-Tabellarische Hyperparameter](autogluon-tabular-hyperparameters.md)
# CatBoost
[CatBoost](https://catboost.ai/)ist eine beliebte und leistungsstarke Open-Source-Implementierung des Gradient Boosting Decision Tree (GBDT) -Algorithmus. GBDT ist ein überwachter Lernalgorithmus, der versucht, eine Zielvariable genau vorherzusagen, indem Schätzungen aus einer Menge einfacherer und schwächerer Modelle kombiniert werden.
CatBoost führt zwei wichtige algorithmische Verbesserungen für GBDT ein:
1. Die Implementierung von Ordered Boosting, einer permutationsgesteuerten Alternative zum klassischen Algorithmus
1. Ein innovativer Algorithmus zur Verarbeitung kategorischer Features
Beide Techniken wurden entwickelt, um einer Verschiebung der Voraussage entgegenzuwirken, die durch eine besondere Art von Zielleckage verursacht wird, die in allen derzeit vorhandenen Implementierungen von Gradienten-Boosting-Algorithmen auftritt. Diese Seite enthält Informationen zu Amazon EC2 EC2-Instance-Empfehlungen und Beispiel-Notebooks für CatBoost.
# Wie benutzt man KI SageMaker CatBoost
Sie können den integrierten Algorithmus von Amazon SageMaker AI verwenden CatBoost . Im folgenden Abschnitt wird die Verwendung CatBoost mit dem SageMaker Python-SDK beschrieben. Informationen zur Verwendung CatBoost von der Amazon SageMaker Studio Classic-Benutzeroberfläche aus finden Sie unter[SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md).
+ ** CatBoost Als integrierten Algorithmus verwenden**
Verwenden Sie den CatBoost integrierten Algorithmus, um einen CatBoost Trainingscontainer zu erstellen, wie im folgenden Codebeispiel gezeigt. Sie können den CatBoost integrierten Algorithmus-Image-URI mithilfe der SageMaker `image_uris.retrieve` KI-API (oder der `get_image_uri` API, wenn Sie [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Version 2 verwenden) automatisch erkennen.
Nachdem Sie die CatBoost Bild-URI angegeben haben, können Sie den CatBoost Container verwenden, um mithilfe der SageMaker AI Estimator API einen Schätzer zu erstellen und einen Trainingsjob zu starten. Der CatBoost integrierte Algorithmus wird im Skriptmodus ausgeführt, aber das Trainingsskript wird für Sie bereitgestellt und muss nicht ersetzt werden. Wenn Sie umfangreiche Erfahrung mit der Erstellung eines SageMaker Trainingsjobs im Skriptmodus haben, können Sie Ihre eigenen CatBoost Trainingsskripte integrieren.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "catboost-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"iterations"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Weitere Informationen zur Einrichtung CatBoost eines integrierten Algorithmus finden Sie in den folgenden Notebook-Beispielen.
+ [Tabellarische Klassifizierung mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Tabellarische Regression mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Eingabe- und Ausgabeschnittstelle für den Algorithmus CatBoost
Gradient Boosting arbeitet mit tabellarischen Daten, wobei die Zeilen die Beobachtungen repräsentieren, eine Spalte die Zielvariable oder die Kennzeichnung darstellt und die verbleibenden Spalten die Funktionen.
Die SageMaker KI-Implementierung von CatBoost unterstützt CSV für Training und Inferenz:
+ Für **Schulungen ContentType** müssen gültige Eingaben *text/csv* sein.
+ *Für **Inference ContentType** müssen gültige Eingaben Text/CSV sein.*
**Anmerkung**
Bei der CSV-Training geht der Algorithmus davon aus, dass die Zielvariable in der ersten Spalte zu finden ist und CSV keinen Header-Datensatz aufweist.
Bei der CSV-Inferenz geht der Algorithmus davon aus, dass die CSV-Eingabe keine Kennzeichnungsspalte hat.
**Eingabeformat für Trainingsdaten, Validierungsdaten und kategoriale Features**
Achten Sie darauf, wie Sie Ihre Trainingsdaten für die Eingabe in das Modell formatieren. CatBoost Sie müssen den Pfad zu einem Amazon-S3-Bucket angeben, der Ihre Trainings- und Validierungsdaten enthält. Sie können auch eine Liste von kategorialen Funktionen einschließen. Verwenden Sie sowohl `training` als auch den `validation` Kanal, um Ihre Eingabedaten bereitzustellen. Alternativ können Sie aber auch nur den `training` Kanal verwenden.
**Verwenden Sie sowohl den `training` als auch den `validation` Kanal**
Sie können Ihre Eingabedaten über zwei S3-Pfade bereitstellen, einen für den `training` Kanal und einen für den `validation` Kanal. Jeder S3-Pfad kann entweder ein S3-Präfix sein, das auf eine oder mehrere CSV-Dateien verweist, oder ein vollständiger S3-Pfad, der auf eine bestimmte CSV-Datei verweist. Die Zielvariablen sollten sich in der ersten Spalte Ihrer CSV-Datei befinden. Die Prädiktorvariablen (Features) sollten sich in den verbleibenden Spalten befinden. Wenn mehrere CSV-Dateien für die `validation` Kanäle `training` oder bereitgestellt werden, verkettet der CatBoost Algorithmus die Dateien. Die Validierungsdaten werden verwendet, um am Ende jeder Boosting-Iteration eine Validierungspunktzahl zu berechnen. Early-Stopping wird angewendet, wenn sich der Validierungsscore nicht mehr verbessert.
Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Trainingsdatendatei (en). Wenn Sie eine JSON-Datei für kategorische Features bereitstellen, muss Ihr `training`-Kanal auf ein S3-Präfix verweisen und nicht auf eine spezifische CSV-Datei. Diese Datei sollte ein Python-Wörterbuch enthalten, in dem der Schlüssel die Zeichenfolge `"cat_index_list"` und der Wert eine Liste eindeutiger Ganzzahlen ist. Jede Ganzzahl in der Werteliste sollte den Spaltenindex der entsprechenden kategorischen Features in Ihrer CSV-Datei mit Trainingsdaten angeben. Jeder Wert sollte eine positive Ganzzahl (größer als Null, weil Null den Zielwert darstellt), kleiner als `Int32.MaxValue` (2147483647) und kleiner als die Gesamtzahl der Spalten sein. Es sollte nur eine JSON-Datei mit dem kategorischen Index geben.
**Benutze nur den `training` Kanal**:
Sie können Ihre Eingabedaten alternativ über einen einzigen S3-Pfad für den `training` Kanal bereitstellen. Dieser S3-Pfad sollte auf ein Verzeichnis mit einem Unterverzeichnis mit dem Namen `training/` verweisen, das eine oder mehrere CSV-Dateien enthält. Sie können optional ein weiteres Unterverzeichnis am selben Speicherort namens `validation/` einschließen, das auch eine oder mehrere CSV-Dateien enthält. Wenn die Validierungsdaten nicht angegeben werden, werden 20% Ihrer Trainingsdaten nach dem Zufallsprinzip als Validierungsdaten ausgewählt. Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Datenunterverzeichnisse.
**Anmerkung**
Beim CSV-Trainingseingangsmodus muss der für den Algorithmus verfügbare Gesamtarbeitsspeicher (Instance-Zählung verfügbarer Arbeitsspeicher im `InstanceType`) in der Lage sein, den Trainingsdatensatz aufzunehmen.
SageMaker KI CatBoost verwendet die `catboost.CatBoostRegressor` Module `catboost.CatBoostClassifier` und, um das Modell zu serialisieren oder zu deserialisieren, was zum Speichern oder Laden des Modells verwendet werden kann.
**Um ein mit KI trainiertes Modell zu verwenden mit SageMaker CatBoost `catboost`**
+ Verwenden Sie den folgenden Python-Code:
```
import tarfile
from catboost import CatBoostClassifier
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
file_path = os.path.join(model_file_path, "model")
model = CatBoostClassifier()
model.load_model(file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Amazon EC2 EC2-Instance-Empfehlung für den Algorithmus CatBoost
SageMaker KI trainiert CatBoost derzeit nur mit CPUs. CatBoost ist ein speichergebundener (im Gegensatz zu rechengebundener) Algorithmus. Daher ist eine Allzweck-Datenverarbeitungs-Instance (z. B. M5) die bessere Wahl gegenüber einer für Datenverarbeitung optimierten Instance (z. B. C5). Des Weiteren empfehlen wir, dass Sie in ausgewählten Instances genügend Gesamtspeicher zur Verfügung haben, um das Trainingsdaten aufzunehmen.
## CatBoost Beispiel-Notizbücher
In der folgenden Tabelle sind verschiedene Beispielnotizbücher aufgeführt, die sich mit verschiedenen Anwendungsfällen des Amazon SageMaker CatBoost AI-Algorithmus befassen.
****
| **Titel des Notebooks** | **Beschreibung** |
| --- | --- |
| [Tabellarische Klassifizierung mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker CatBoost AI-Algorithmus zum Trainieren und Hosten eines tabellarischen Klassifikationsmodells. |
| [Tabellarische Regression mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker CatBoost AI-Algorithmus zum Trainieren und Hosten eines tabellarischen Regressionsmodells. |
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instances, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
# Wie CatBoost funktioniert
CatBoost implementiert einen konventionellen GBDT-Algorithmus (Gradient Boosting Decision Tree) und fügt zwei wichtige algorithmische Verbesserungen hinzu:
1. Die Implementierung von Ordered Boosting, einer permutationsgesteuerten Alternative zum klassischen Algorithmus
1. Ein innovativer Algorithmus zur Verarbeitung kategorischer Features
Beide Techniken wurden entwickelt, um einer Verschiebung der Voraussage entgegenzuwirken, die durch eine besondere Art von Zielleckage verursacht wird, die in allen derzeit vorhandenen Implementierungen von Gradienten-Boosting-Algorithmen auftritt.
Der CatBoost Algorithmus schneidet bei Wettbewerben im Bereich maschinelles Lernen aufgrund seiner robusten Verarbeitung einer Vielzahl von Datentypen, Beziehungen und Verteilungen sowie der Vielzahl von Hyperparametern, die Sie feinabstimmen können, gut ab. Sie können ihn CatBoost für Regressions-, Klassifizierungs- (binär- und Mehrklassenprobleme) und Ranking-Probleme verwenden.
Weitere Informationen zur Gradientenverstärkung finden Sie unter [Wie funktioniert der SageMaker XGBoost KI-Algorithmus](xgboost-HowItWorks.md). Ausführliche Informationen zu den zusätzlichen in der CatBoost Methode verwendeten GOSS- und EFB-Techniken finden Sie unter *[CatBoost: Unvoreingenommenes](https://arxiv.org/pdf/1706.09516.pdf)* Boosting mit kategorialen Merkmalen.
# CatBoost Hyperparameter
Die folgende Tabelle enthält die Teilmenge der Hyperparameter, die für den Amazon SageMaker CatBoost AI-Algorithmus erforderlich sind oder am häufigsten verwendet werden. Dies sind Parameter, die von Benutzern festgelegt werden, um die Schätzung der Modellparameter aus Daten zu erleichtern. Der SageMaker CatBoost KI-Algorithmus ist eine Implementierung des [CatBoost](https://github.com/catboost/catboost)Open-Source-Pakets.
**Anmerkung**
Die Standard-Hyperparameter basieren auf Beispieldatensätzen in der [CatBoost Beispiel-Notizbücher](catboost.md#catboost-sample-notebooks).
Standardmäßig wählt der SageMaker CatBoost KI-Algorithmus automatisch eine Bewertungsmetrik und eine Verlustfunktion aus, die auf der Art des Klassifizierungsproblems basieren. Der CatBoost Algorithmus erkennt die Art des Klassifizierungsproblems anhand der Anzahl der Labels in Ihren Daten. Bei Regressionsproblemen entsprechen die Bewertungsmetrik und die Verlustfunktionen beide dem quadratischen Mittelwert des Fehlers. Bei binären Klassifikationsproblemen lautet die Bewertungsmetrik Area Under the Curve (AUC) und die Verlustfunktion ist logarithmischer Verlust. Bei Mehrklassen-Klassifizierungsproblemen mit mehreren Klassen entsprechen die Bewertungsmetrik und die Verlustfunktionen der Kreuzentropie mehrerer Klassen. Sie können den `eval_metric` Hyperparameter verwenden, um die Standard-Bewertungsmetrik zu ändern. In der folgenden Tabelle finden Sie weitere Informationen zu LightGBM-Hyperparametern, einschließlich Beschreibungen, gültiger Werte und Standardwerte.
| Name des Parameters | Description |
| --- | --- |
| iterations | Die maximale Anzahl von Bäumen, die gebaut werden können. Gültige Werte: Ganzzahl, Bereich: Positive Ganzzahl. Standardwert: `500`. |
| early\$1stopping\$1rounds | Das Training wird beendet, wenn sich eine Metrik eines Validierungsdatenpunkts in der letzten `early_stopping_rounds` Runde nicht verbessert hat. Wenn `early_stopping_rounds` kleiner als oder gleich Null ist, wird dieser Hyperparameter ignoriert. Gültige Werte: Ganzzahl. Standardwert: `5`. |
| eval\$1metric | Evaluationsmetriken für die Datenvalidierung. Wenn `eval_metric` auf den Standardwert `"auto"` gesetzt ist, wählt der Algorithmus automatisch eine Bewertungsmetrik aus, die auf der Art des Klassifizierungsproblems basiert: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/catboost-hyperparameters.html) Gültige Werte: Zeichenfolge. Gültige Werte finden Sie in der [CatBoost Dokumentation](https://catboost.ai/en/docs/references/eval-metric__supported-metrics). Standardwert: `"auto"`. |
| learning\$1rate | Die Geschwindigkeit, mit der die Modellgewichte aktualisiert werden, nachdem die einzelnen Trainingssbeispiele durchgearbeitet wurden. Gültige Werte: Float, Bereich: (`0.0`, `1.0`). Standardwert: `0.009`. |
| depth | Tiefe des Baumes. Gültige Werte: Ganzzahl, Bereich: (`1`, `16`). Standardwert: `6`. |
| l2\$1leaf\$1reg | Koeffizient für den L2-Regularisierungsterm der Kostenfunktion. Gültige Werte: Ganzzahl, Bereich: Positive Ganzzahl. Standardwert: `3`. |
| random\$1strength | Das Maß an Zufälligkeit, das für die Bewertung von Splits verwendet werden soll, wenn die Baumstruktur ausgewählt ist. Verwenden Sie diesen Parameter, um eine Überanpassung des Modells zu vermeiden. Gültige Werte: Float, Bereich: Positive Gleitkommazahl. Standardwert: `1.0`. |
| max\$1leaves | Die maximale Anzahl von Blättern im resultierenden Baum. Kann nur zusammen mit der `"Lossguide"` Wachstumspolitik verwendet werden. Gültige Werte: Ganzzahl, Bereich: [`2`, `64`]. Standardwert: `31`. |
| rsm | Zufällige Subraummethode. Der Prozentsatz der Features, die bei jeder geteilten Auswahl verwendet werden sollen, wenn Features erneut nach dem Zufallsprinzip ausgewählt werden. Gültige Werte: Float, Bereich: (`0.0`, `1.0`]. Standardwert: `1.0`. |
| sampling\$1frequency | Häufigkeit der Stichprobenerhebung von Gewichten und Objekten beim Bauen von Bäumen. Gültige Werte: String, entweder: (`"PerTreeLevel"` oder `"PerTree"`). Standardwert: `"PerTreeLevel"`. |
| min\$1data\$1in\$1leaf | Die Mindestanzahl von Trainingsproben in einem Blatt. CatBoost sucht nicht nach neuen Splits in Blättern mit einer Stichprobenzahl, die unter dem angegebenen Wert liegt. Kann nur zusammen mit den `"Lossguide"` und `"Depthwise"` wachsenden Richtlinien verwendet werden. Gültige Werte: Ganzzahl, Bereich: (`1` oder `∞`). Standardwert: `1`. |
| bagging\$1temperature | Definiert die Einstellungen des Bayes-Bootstrapping. Verwenden Sie den Bayes-Bootstrap, um Objekten zufällige Gewichtungen zuzuweisen. Wenn `bagging_temperature` auf `1.0` festgelegt ist, werden die Gewichtungen anhand einer Exponentialverteilung ausgewählt. Wenn `bagging_temperature` auf `0.0` festgelegt ist, dann haben alle Gewichtungen den Wert 1,0. Gültige Werte: Float, Bereich: Nicht-negativer Float. Standardwert: `1.0`. |
| boosting\$1type | Das Boosting-Programm. „Automatisch“ bedeutet, dass `boosting_type` auf der Grundlage des Typs der Verarbeitungseinheit, der Anzahl der Objekte im Trainingsdatensatz und des ausgewählten Learn-Modus ausgewählt wird. Gültige Werte: String, einer der folgenden Werte: (`"Auto"`, `"Ordered"`, `"Plain"`). Standardwert: `"Auto"`. |
| scale\$1pos\$1weight | Die Gewichtung der positiven Klasse in der binären Klassifikation. Der Wert wird als Multiplikator für die Gewichte von Objekten der positiven Klasse verwendet. Gültige Werte: Float, Bereich: Positiver Float. Standardwert: `1.0`. |
| max\$1bin | Die Anzahl von Aufteilungen für numerische Features. `"Auto"` bedeutet, dass `max_bin` auf der Grundlage des Typs der Verarbeitungseinheit und anderer Parameter ausgewählt wird. Einzelheiten finden Sie in der CatBoost Dokumentation. Gültige Werte: String, entweder: (`"Auto"` oder String einer Ganzzahl von `"1"` bis `"65535"` einschließlich). Standardwert: `"Auto"`. |
| grow\$1policy | Die Politik des Baumwachstums. Definiert, wie man gierige Bäume baut. Gültige Werte: String, einer der folgenden Werte: (`"SymmetricTree"`, `"Depthwise"`, oder `"Lossguide"`). Standardwert: `"SymmetricTree"`. |
| random\$1seed | Der zufällige Startwert, der für das Training benutzt wird. Gültige Werte: Ganzzahl, Bereich: Nicht-negative Ganzzahl. Standardwert: `1.0`. |
| thread\$1count | Die Anzahl von Threads, die während des Trainings verwendet werden sollen. Wenn `thread_count` gleich `-1` ist, entspricht die Anzahl der Threads der Anzahl der Prozessorkerne. `thread_count` kann nicht `0` sein. Gültige Werte: Ganzzahl, entweder: (`-1` oder positive Ganzzahl). Standardwert: `-1`. |
| verbose | Die Ausführlichkeit von Drucknachrichten, wobei höhere Stufen detaillierteren Druckanweisungen entsprechen. Gültige Werte: Ganzzahl, Bereich: Positive Ganzzahl. Standardwert: `1`. |
# Tunen Sie ein CatBoost Modell
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Die Modelloptimierung konzentriert sich auf die folgenden Hyperparameter:
**Anmerkung**
Die Lernverlust-Funktion wird automatisch auf der Grundlage der Art der Klassifikationsaufgabe zugewiesen, die durch die Anzahl der eindeutigen Ganzzahlen in der Beschriftungsspalte bestimmt wird. Weitere Informationen finden Sie unter [CatBoost Hyperparameter](catboost-hyperparameters.md).
+ Eine Lernverlust-Funktion zur Optimierung beim Modelltraining
+ Eine Bewertungsmetrik, die verwendet wird, um die Modellleistung während der Validierung zu bewerten
+ Ein Satz von Hyperparametern und ein Wertebereich für jeden, der bei der automatischen Abstimmung des Modells verwendet werden kann
Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.
**Anmerkung**
Die automatische Modelloptimierung für CatBoost ist nur bei Amazon verfügbar SageMaker SDKs, nicht über die SageMaker KI-Konsole.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Vom Algorithmus berechnete Bewertungsmetriken CatBoost
Der SageMaker CatBoost KI-Algorithmus berechnet die folgenden Metriken, die für die Modellvalidierung verwendet werden sollen. Die Bewertungsmetrik wird automatisch auf der Grundlage der Art der Klassifizierungsaufgabe zugewiesen, die durch die Anzahl der eindeutigen Ganzzahlen in der Beschriftungspalte bestimmt wird.
| Metrikname | Description | Optimierungsrichtung | Regex-Muster |
| --- | --- | --- | --- |
| RMSE | Wurzel des mittleren quadratischen Fehlers | Minimieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| MAE | Mittlerer absoluter Fehler. | Minimieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| MedianAbsoluteError | Mittlerer absoluter Fehler. | Minimieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| R2 | R2-Wert | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| Logloss | Binärkreuzentropie | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| Precision | precision | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| Recall | Rückruf | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| F1 | F1-Ergebnis | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| AUC | AUC-Wert | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| MultiClass | Kreuzentropie mit mehreren Klassen | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| Accuracy | Richtigkeit | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
| BalancedAccuracy | ausgewogene Genauigkeit | Maximieren | "bestTest = ([0-9\$1\$1.]\$1)" |
## Einstellbare Hyperparameter CatBoost
Optimieren Sie das CatBoost Modell mit den folgenden Hyperparametern. Die Hyperparameter, die den größten Einfluss auf die Optimierung der CatBoost Bewertungsmetriken haben, sind:`learning_rate`, `depth``l2_leaf_reg`, und. `random_strength` Eine Liste aller CatBoost Hyperparameter finden Sie unter. [CatBoost Hyperparameter](catboost-hyperparameters.md)
| Name des Parameters | Parametertyp | Empfohlene Bereiche |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| depth | IntegerParameterRanges | MinValue: 4, MaxValue: 10 |
| l2\$1leaf\$1reg | IntegerParameterRanges | MinValue: 2, MaxValue: 10 |
| random\$1strength | ContinuousParameterRanges | MinValue: 0, MaxValue: 10 |
# Faktorisierungsmaschinen Algorithmus
Eine Factorization Machines ist ein allgemeiner überwachter Lernalgorithmus, der sowohl für Klassifizierungs- als auch Regressionsaufgaben eingesetzt werden kann. Diese Erweiterung eines linearen Modells ist darauf ausgelegt, Interaktionen zwischen Funktionen innerhalb von hochdimensionalen Datensätzen mit geringer Dichte wirtschaftlich zu erfassen. Beispielsweise kann das Factorization Machine-Modell in einem System zur Klickprognose die Klickratenmuster erfassen, die bei der Platzierung von Werbung einer bestimmten Werbekategorie auf Seiten einer bestimmten Seitenkategorie beobachtet werden. Factorization Machines sind bei Aufgaben, die hochdimensionale Datensätze mit geringer Dichte umfassen (z. B. Klickprognosen und Artikelempfehlungen), eine gute Wahl.
**Anmerkung**
Die Amazon SageMaker AI-Implementierung des Factorization Machines-Algorithmus berücksichtigt nur paarweise Interaktionen (2. Ordnung) zwischen Funktionen.
**Topics**
+ [E/A-Schnittstelle für den Factorization Machines-Algorithmus](#fm-inputoutput)
+ [EC2-Instance-Empfehlung für den Factorization Machines-Algorithmus](#fm-instances)
+ [Factorization Machines-Beispiel-Notebook](#fm-sample-notebooks)
+ [Funktionsweise von Factorization Machines](fact-machines-howitworks.md)
+ [Factorization Machines-Hyperparameter](fact-machines-hyperparameters.md)
+ [Optimieren eines Factorization Machines-Modells](fm-tuning.md)
+ [Factorization Machines Antwortformate](fm-in-formats.md)
## E/A-Schnittstelle für den Factorization Machines-Algorithmus
Der Factorization Machines-Algorithmus lässt sich entweder im binären Klassifizierungs- oder im Regressionsmodus ausführen. In beiden Modi kann neben dem Datensatz für den Trainingskanal auch eines für den **Testkanal** bereitgestellt werden. Die Bewertung hängt vom verwendeten Modus ab. Im Regressionsmodus wird der Testdatensatz mithilfe von RMSE (Root Mean Square Error, Wurzel des mittleren quadratischen Prognosefehlers) bewertet. Im binären Klassifizierungsmodus wird der Testdatensatz anhand von binärer Kreuzentropie (Protokollverlust), Genauigkeit (Grenzwert = 0,5) und F1-Bewertung (Schwellenwert = 0,5) bewertet.
Für das **Training** unterstützt der Factorization Machines-Algorithmus derzeit nur das `recordIO-protobuf` Format mit `Float32` Tensoren. Da als Anwendungsfall in erster Linie Daten mit geringer Dichte in Frage kommen, ist `CSV` keine gute Wahl. Trainings sowohl im Datei- als auch im Pipe-Modus werden im vom recordIO umschlossenen protobuf-Format unterstützt.
Für die **Inferenz** unterstützen Factorization Machines die `application/json` und `x-recordio-protobuf` Formate.
+ Für das Problem der **binären Klassifizierung** sagt der Algorithmus eine Bewertung und eine Bezeichnung voraus. Die Bezeichnung ist eine Zahl und kann entweder `0` oder `1` sein. Die Bewertung ist eine Zahl, die angibt, wie stark der Algorithmus glaubt, dass die Bezeichnung `1` sein sollte. Der Algorithmus berechnet zuerst die Bewertung und leitet aus dem Wert die Bezeichnung ab. Wenn die Punktzahl größer oder gleich 0,5 ist, ist die Bezeichnung `1`.
+ Für das Problem der **Regression** wird nur eine Punktzahl zurückgegeben. Dies ist dann der vorausgesagte Wert. Beispiel: Wenn Factorization Machines verwendet wird, um eine Filmbewertung vorherzusagen, ist die Punktzahl die vorausgesagte Bewertung.
Weitere Informationen zu Trainings- und Inferenzdateiformaten finden Sie unter [Factorization Machines-Beispiel-Notebook](#fm-sample-notebooks).
## EC2-Instance-Empfehlung für den Factorization Machines-Algorithmus
Der Amazon SageMaker AI Factorization Machines-Algorithmus ist hochgradig skalierbar und kann über verteilte Instanzen hinweg trainiert werden. Wir empfehlen, für Training und Inferenz CPU-Instances bei Datensätzen mit sowohl geringer als auch hoher Dichte zu verwenden. Unter bestimmten Umständen kann das Training mit einem oder mehreren GPUs Daten mit hoher Datendichte einige Vorteile bieten. Das Training mit GPUs ist nur für dichte Daten verfügbar. Verwenden Sie bei Daten mit geringer Dichte CPU-Instances. Der Factorization Machines-Algorithmus unterstützt P2-, P3-, G4dn- und G5-Instances für Training und Inferenz.
## Factorization Machines-Beispiel-Notebook
Ein Beispielnotizbuch, das den Algorithmus SageMaker AI Factorization Machines verwendet, um die Bilder handgeschriebener Ziffern von Null bis Neun im MNIST-Datensatz zu analysieren, finden Sie unter [Eine Einführung in Faktorisierungsmaschinen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html) mit MNIST. Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele** aus, um eine Liste aller KI-Beispiele zu sehen. SageMaker Die Beispiel-Notebooks für die Themenmodellierung, die NTM-Algorithmen verwenden, befinden sich im Abschnitt **Einführung in Amazon-Algorithmen**. Zum Öffnen eines Notebooks klicken Sie auf die Registerkarte **Use (Verwenden)** und wählen Sie **Create copy (Kopie erstellen)** aus.
# Funktionsweise von Factorization Machines
Die Prognosenaufgabe für ein Factorization Machine-Modell besteht darin, eine Funktion ŷ aus einem Funktionsumfang x i für eine Zieldomain zu schätzen. Diese Domain ist reellwertig für die Regression und binär für die Klassifizierung. Das Factorization Machine-Modell wird überwacht und verfügt somit über ein Trainingsdatensatz (xi,yj). Die Vorteile dieses Modells liegen in der Art und Weise, wie es eine faktorisierte Parametrisierung zum Erfassen der paarweisen Funktionsinteraktionen verwendet. Dies kann mathematisch wie folgt dargestellt werden:
![\[Ein Bild, das die Gleichung für das Modell Factorization Machines enthält.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/FM1.jpg)
Die drei Ausdrücke in dieser Gleichung entsprechen den drei Komponenten des Modells:
+ Der w0 -Ausdruck stellt den globalen Bias-Wert dar.
+ Die wi linearen Ausdrücke modellieren die Stärke der ithVariable.
+ Die Faktorisierungsbegriffe modellieren die paarweise Interaktion zwischen der ith und jth Variablen.
Die globalen Bias- und linearen Ausdrücke gleichen denen in einem linearen Modell. Die paarweisen Funktionsinteraktionen werden im dritten Ausdruck als inneres Produkt der korrespondierenden Faktoren, die für jede Funktion gelernt wurden, modelliert. Diese gelernten Faktoren können auch als einbettende Vektoren der einzelnen Funktion betrachtet werden. Wenn beispielsweise in einer Klassifizierungsaufgabe ein Funktionspaar häufiger gemeinsam in Stichproben mit positiver Bezeichnung vorkommt, ist das innere Produkt von deren Faktoren groß. Mit anderen Worten: Die einbettenden Vektoren liegen in Kosinus-Ähnlichkeit nahe zusammen. Weitere Informationen über das Factorization Machine-Modell finden Sie unter [Factorization Machines](https://www.ismll.uni-hildesheim.de/pub/pdfs/Rendle2010FM.pdf).
Bei Regressionsaufgaben wird das Modell trainiert, indem der quadratische Fehler zwischen der Modellvorhersage ŷn und dem Zielwert yn minimiert wird. Dies wird als quadratischer Verlust bezeichnet:
![\[Ein Abbild mit der Gleichung für den quadratischen Verlust.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/FM2.jpg)
Für eine Klassifizierungsaufgabe wird das Modell trainiert, indem der Kreuz-Entropie-Verlust, auch als Protokollverlust bezeichnet, minimiert wird:
![\[Ein Abbild mit der Gleichung für den Protokollverlust.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/FM3.jpg)
Wobei:
![\[Ein Abbild mit der Logistikfunktion der prognostizierten Werte.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/FM4.jpg)
Weitere Informationen zu Verlustfunktionen für die Klassifizierung finden Sie unter [Loss functions for classification](https://en.wikipedia.org/wiki/Loss_functions_for_classification).
# Factorization Machines-Hyperparameter
Die folgende Tabelle enthält die Hyperparameter für den Algorithmus Factorization Machines. Dies sind Parameter, die von Benutzern festgelegt werden, um die Schätzung der Modellparameter aus Daten zu erleichtern. Die obligatorischen Hyperparameter, die festgelegt werden müssen, sind zuerst aufgelistet (in alphabetischer Reihenfolge). Die optionalen Hyperparameter, die festgelegt werden können, sind als Nächstes aufgeführt (ebenfalls in alphabetischer Reihenfolge).
| Name des Parameters | Description |
| --- | --- |
| feature\$1dim | Die Dimension des Eingabefunktionsraums. Dies kann bei geringen Eingaben sehr hoch sein. **Erforderlich** Gültige Werte: positive Ganzzahl. Vorgeschlagener Wertebereich: [10000,10000000] |
| num\$1factors | Die Dimensionalität der Faktorisierung. **Erforderlich** Gültige Werte: positive Ganzzahl. Empfohlener Wertebereich: [2,1000], 64 liefert in der Regel gute Ergebnisse und ist ein guter Ausgangspunkt. |
| predictor\$1type | Der Prognosetyp. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Erforderlich** Gültige Werte: Zeichenfolge: `binary_classifier` oder `regressor` |
| bias\$1init\$1method | Die Initialisierungsmethode für den Bias-Ausdruck: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Optional** Gültige Werte: `uniform`, `normal` oder `constant` Standardwert: `normal` |
| bias\$1init\$1scale | Initialisierungsbereich für den Bias-Ausdruck. Wird wirksam, wenn `bias_init_method` auf `uniform` gesetzt ist. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: Keine |
| bias\$1init\$1sigma | Die Standardabweichung bei der Initialisierung des Bias-Ausdrucks. Wird wirksam, wenn `bias_init_method` auf `normal` gesetzt ist. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.01 |
| bias\$1init\$1value | Der Initialwert des Bias-Ausdrucks. Wird wirksam, wenn `bias_init_method` auf `constant` gesetzt ist. **Optional** Gültige Werte: Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: Keine |
| bias\$1lr | Die Lernrate für den Bias-Ausdruck. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.1 |
| bias\$1wd | Der Zerfall der Gewichtung für den Bias-Ausdruck. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.01 |
| clip\$1gradient | Clipping Optimizer Gradient-Parameter. Schneidet den Gradienten durch Projektion von [-`clip_gradient`, \$1`clip_gradient`] auf das Intervall. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: Keine |
| epochs | Die Anzahl der auszuführenden Trainingsepochen. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 1 |
| eps | Epsilon-Parameter zur Vermeidung der Division durch 0. **Optional** Gültige Werte: Gleitkommazahl. Vorgeschlagener Wert: klein. Standardwert: Keine |
| factors\$1init\$1method | Die Initialisierungsmethode für Faktorisierungsausdrücke: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Optional** Gültige Werte: `uniform`, `normal` oder `constant`. Standardwert: `normal` |
| factors\$1init\$1scale | Der Initialisierungsbereich für Faktorisierungsausdrücke. Wird wirksam, wenn `factors_init_method` auf `uniform` gesetzt ist. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: Keine |
| factors\$1init\$1sigma | Die Standardabweichung bei der Initialisierung von Faktorisierungsausdrücken. Wird wirksam, wenn `factors_init_method` auf `normal` gesetzt ist. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.001 |
| factors\$1init\$1value | Der Initialwert der Faktorisierungsausdrücke. Wird wirksam, wenn `factors_init_method` auf `constant` gesetzt ist. **Optional** Gültige Werte: Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: Keine |
| factors\$1lr | Die Lernrate für Faktorisierungsausdrücke. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.0001 |
| factors\$1wd | Der Zerfall der Gewichtung für Faktorisierungsausdrücke. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.00001 |
| linear\$1lr | Die Lernrate für lineare Ausdrücke. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.001 |
| linear\$1init\$1method | Die Initialisierungsmethode für lineare Ausdrücke: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Optional** Gültige Werte: `uniform`, `normal` oder `constant`. Standardwert: `normal` |
| linear\$1init\$1scale | Initialisierungsbereich für lineare Ausdrücke. Wird wirksam, wenn `linear_init_method` auf `uniform` gesetzt ist. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: Keine |
| linear\$1init\$1sigma | Die Standardabweichung bei der Initialisierung linearer Ausdrücke. Wird wirksam, wenn `linear_init_method` auf `normal` gesetzt ist. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.01 |
| linear\$1init\$1value | Der Initialwert der linearen Ausdrücke. Wird wirksam, wenn `linear_init_method` auf *constant* gesetzt ist. **Optional** Gültige Werte: Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: Keine |
| linear\$1wd | Der Zerfall der Gewichtung für lineare Bias-Ausdrücke. **Optional** Gültige Werte: positive Gleitkommazahl. Vorgeschlagener Wertebereich: [1e-8, 512]. Standardwert: 0.001 |
| mini\$1batch\$1size | Die Größe des im Rahmen des Trainings verwendeten Mini-Stapels. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 1000 |
| rescale\$1grad | Gradient Rescaling Optimizer-Parameter. Falls gesetzt, wird der Gradient vor der Aktualisierung mit `rescale_grad` multipliziert. Häufige Auswahl ist 1,0/`batch_size`. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: Keine |
# Optimieren eines Factorization Machines-Modells
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Vom Factorization Machines-Algorithmus berechnete Metriken
Der Factorization Machines-Algorithmus verfügt sowohl über binäre Klassifikations- als auch Regressionsprädiktoren. Der Prognosetyp bestimmt, welche Metrik Sie für die automatische Modelloptimierung verwenden können. Der Algorithmus meldet eine `test:rmse` regressor-Metrik, die während des Trainings berechnet wird. Wählen Sie diese Metrik beim Optimieren des Modells für Regressionsaufgaben als objektive Metrik aus.
| Metrikname | Description | Optimierungsrichtung |
| --- | --- | --- |
| test:rmse | Wurzel des mittleren quadratischen Prognosefehlers (Root Mean Square Error) | Minimieren |
Der Factorization Machines-Algorithmus liefert drei binäre Klassifikationsmetriken, die während des Trainings berechnet werden. Beim Optimieren des Modells für binäre Klassifikationsaufgaben wählen Sie eine der folgenden Optionen als objektive Metrik aus.
| Metrikname | Description | Optimierungsrichtung |
| --- | --- | --- |
| test:binary\$1classification\$1accuracy | Accuracy | Maximieren |
| test:binary\$1classification\$1cross\$1entropy | Kreuz-Entropie | Minimieren |
| test:binary\$1f\$1beta | Beta | Maximieren |
## Optimierbare Factorization Machines-Hyperparameter
Sie können die folgenden Hyperparameter für den Algorithmus Factorization Machines einstellen. Die Initialisierungsparameter, die die Begriffe "bias", "linear" und "factorization" enthalten, hängen von ihrer Initialisierungsmethode ab. Es gibt drei Initialisierungsmethoden: `uniform`, `normal` und `constant`. Diese Initialisierungsmethoden sind nicht optimierbar. Die Parameter, die optimierbar sind, hängen von der Wahl der Initialisierungsmethode ab. Beispiel: Wenn die Initialisierungsmethode `uniform` lautet, dann sind nur die `scale`-Parameter optimierbar. Insbesondere bei `bias_init_method==uniform` sind `bias_init_scale`, `linear_init_scale` und `factors_init_scale` optimierbar. Wenn die Initialisierungsmethode entsprechend `normal` lautet, dann sind nur die `sigma`-Parameter optimierbar. Wenn die Initialisierungsmethode `constant` lautet, dann sind nur die `value`-Parameter optimierbar. Diese Abhängigkeiten werden in der folgenden Tabelle aufgeführt.
| Name des Parameters | Parametertyp | Empfohlene Bereiche | -Abhängigkeit |
| --- | --- | --- | --- |
| bias\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==uniform |
| bias\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==normal |
| bias\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==constant |
| bias\$1lr | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | Keine |
| bias\$1wd | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | Keine |
| epoch | IntegerParameterRange | MinValue: 1, MaxValue: 100 | Keine |
| factors\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method==uniform |
| factors\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==normal |
| factors\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==constant |
| factors\$1lr | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | Keine |
| factors\$1wd | ContinuousParameterRange | MinValue: 1e-8,: 512] MaxValue | Keine |
| linear\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==uniform |
| linear\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==normal |
| linear\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | bias\$1init\$1method==constant |
| linear\$1lr | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | Keine |
| linear\$1wd | ContinuousParameterRange | MinValue: 1e-8,: 512 MaxValue | Keine |
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 100, MaxValue: 1000 | Keine |
# Factorization Machines Antwortformate
Amazon SageMaker AI bietet verschiedene Antwortformate, um Rückschlüsse aus dem Factorization Machines-Modell zu ziehen, wie JSON, JSONLINES und RECORDIO, mit spezifischen Strukturen für binäre Klassifizierungs- und Regressionsaufgaben.
## JSON-Antwortformat
Binäre Klassifikation
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
Regression
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## JSONLINES-Antwortformat
Binäre Klassifikation
```
{"score": 0.4, "predicted_label": 0}
```
Regression
```
{"score": 0.4}
```
## RECORDIO-Antwortformat
Binäre Klassifikation
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
Regression
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
}
}
}
]
```
# K-nearest neighbors (k-NN)-Algorithmus
Der Amazon SageMaker AI-Algorithmus für k-Nearest Neighbors (k-NN) ist ein indexbasierter Algorithmus. Er verwendet eine nicht parametrische Methode zur Klassifizierung oder Regression. Bei Klassifizierungsproblemen fragt der Algorithmus die *k*-Punkte ab, die dem Stichprobenpunkt am nächsten liegen, und gibt die am häufigsten verwendeten Bezeichnungen ihrer Klasse als prognostizierte Bezeichnung zurück. Bei Regressionsproblemen fragt der Algorithmus die *k*-Punkte ab, die dem Stichprobenpunkt am nächsten liegen, und gibt den Durchschnitt ihrer Funktionswerte als prognostizierten Wert zurück.
Das Training mit dem k-NN-Algorithmus umfasst drei Schritte: Sampling, Dimensionsreduzierung und Indexerstellung. Durch Sampling wird die Größe des anfänglichen Datensatzes reduziert, sodass es in den Arbeitsspeicher passt. Für die Dimensionsreduzierung verringert der Algorithmus die Funktionsdimension der Daten, um den Ressourcenbedarf des k-NN-Modells im Speicher und die Inferenzlatenz zu senken. Wir stellen zwei-Methoden der Dimensionsreduzierung zur Verfügung: zufällige Projektion und die schnelle Johnson-Lindenstrauss-Transformation. In der Regel verwenden Sie die Dimensionsreduzierung für hochdimensionale Datensätze (d > 1000), um die Nachteile der Dimensionalität zu vermeiden, die die statistische Analyse von Daten beeinträchtigt, deren Dichte mit steigender Dimensionalität geringer wird. Das Hauptziel des k-NN-Trainings ist die Erstellung des Index. Der Index ermöglicht ein effizientes Suchen von Entfernungen zwischen Punkten, deren Werte oder Klassenbezeichnungen noch nicht festgelegt wurden, und den k nächstgelegenen Punkten zur Inferenz.
**Topics**
+ [E/A-Schnittstelle für den k-NN-Algorithmus](#kNN-input_output)
+ [k-NN-Beispiel-Notebooks](#kNN-sample-notebooks)
+ [So funktioniert der k-NN-Algorithmus](kNN_how-it-works.md)
+ [EC2-Instance-Empfehlung für den k-NN-Algorithmus](#kNN-instances)
+ [k-NN-Hyperparameter](kNN_hyperparameters.md)
+ [Optimieren eines k-NN-Modells](kNN-tuning.md)
+ [Datenformate für k-NN-Trainingseingaben](kNN-in-formats.md)
+ [k-NN-Anforderungs- und Antwortformate](kNN-inference-formats.md)
## E/A-Schnittstelle für den k-NN-Algorithmus
SageMaker AI k-NN unterstützt Train- und Testdatenkanäle.
+ Verwenden Sie einen *Trainingskanal* für Daten, die Sie als Stichproben erfassen und in den die k-NN-Index einbauen möchten.
+ Verwenden Sie ein *Testkanal,* um Punktzahlen in Protokolldateien auszugeben. Punktzahlen werden als eine Zeile pro Mini-Stapel aufgeführt: Genauigkeit für `classifier`, mittlerer quadratischer Fehler (MSE) für `regressor` für die Punktzahl.
Für Trainingseingaben unterstützt k-NN – `text/csv`und `application/x-recordio-protobuf`-Datenformate. Für den Eingabetyp `text/csv` werden die ersten `label_size` Spalten als Bezeichnungsvektor für diese Zeile interpretiert. Sie können entweder den Datei- oder den Pipe-Modus verwenden, um Modelle mit Daten, die als `recordIO-wrapped-protobuf` oder `CSV` formatiert sind, zu trainieren.
Für Inferenzeingaben unterstützt k-NN die `application/json`-, – `application/x-recordio-protobuf`und `text/csv`-Datenformate. Das `text/csv`-Format akzeptiert eine `label_size` und einen Codierungsparameter. Es setzt eine `label_size` von 0 und eine UTF-8-Codierung voraus.
Für Inferenzausgaben unterstützt k-NN die – `application/json`und `application/x-recordio-protobuf`-Datenformate. Diese beiden Datenformate unterstützen auch einen Verbose-Ausgabemodus. Im Verbose-Ausgabemodus stellt die API die Suchergebnisse mit dem Entfernungsvektor aufsteigend sortiert und die entsprechenden Elemente im Bezeichnungsvektor bereit.
Für die Stapeltransformation unterstützt k-NN das `application/jsonlines`-Datenformat für die Ein- und Ausgabe. Die Eingabe lautet z. B.:
```
content-type: application/jsonlines
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
Die Ausgabe lautet z. B.:
```
accept: application/jsonlines
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
Weitere Informationen zu den Ein- und Ausgabedateiformaten finden Sie unter [Datenformate für k-NN-Trainingseingaben](kNN-in-formats.md) für das Training, [k-NN-Anforderungs- und Antwortformate](kNN-inference-formats.md) für Inferenz und [k-NN-Beispiel-Notebooks](#kNN-sample-notebooks).
## k-NN-Beispiel-Notebooks
Ein Beispiel für ein Notizbuch, das den SageMaker KI-Algorithmus k-Nearest Neighbor verwendet, um anhand von geologischen Daten und forstwirtschaftlichen Daten die Art der Wildnisbedeckung vorherzusagen, finden Sie unter [K-Nearest Neighbor](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) Covertype.
Verwenden Sie eine Jupyter-Notebook-Instanz, um das Beispiel in KI auszuführen. SageMaker Informationen zum Erstellen und Öffnen einer Jupyter-Notebook-Instanz in KI finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele** aus, um eine Liste aller SageMaker KI-Beispiel-Notebooks anzuzeigen. Suchen Sie nach K-Nearest Neighbor Notebooks im Abschnitt **Einführung in Amazon-Algorithmen**. Zum Öffnen eines Notebooks klicken Sie auf die Registerkarte **Use (Verwenden)** und wählen Sie **Create copy (Kopie erstellen)** aus.
# So funktioniert der k-NN-Algorithmus
Der Amazon SageMaker AI-Algorithmus k-Nearest Neighbors (k-NN) folgt einem mehrstufigen Trainingsprozess, der die Stichprobenerhebung der Eingabedaten, die Dimensionsreduzierung und die Erstellung eines Index umfasst. Die indizierten Daten werden dann während der Inferenz verwendet, um effizient die k-nächsten Nachbarn für einen bestimmten Datenpunkt zu finden und Vorhersagen auf der Grundlage der benachbarten Bezeichnungen oder Werte zu treffen.
## Schritt 1: Stichprobe
Verwenden Sie den `sample_size`-Parameter, um die Gesamtanzahl der Datenpunkte anzugeben, die als Stichprobe vom Trainingsdatensatz genommen werden sollen. Beispiel: Wenn der erste Datensatz über 1 000 Datenpunkte verfügt und `sample_size` auf 100 festgelegt ist, wobei die Gesamtanzahl der Instances 2 beträgt, nimmt jeder Worker Stichproben von 50 Punkten. Es würde eine Reihe von insgesamt 100 Datenpunkten erfasst werden. Die Stichprobenerfassung erfolgt in linearer Zeit in Bezug auf die Anzahl der Datenpunkte.
## Schritt 2: Ausführen der Dimensionsreduzierung
Die aktuelle Implementierung des k-NN-Algorithmus verfügt über zwei Methoden der Dimensionsreduzierung. Sie geben die Methode im `dimension_reduction_type`-Hyperparameter an. Die `sign`-Methode gibt eine zufällige Projektion an, die eine lineare Projektion mithilfe einer Matrix von zufälligen Zeichen verwendet. Die `fjlt`-Methode gibt eine schnelle Johnson-Lindenstrauss-Transformation an, eine Methode auf der Grundlage der Fourier-Transformation. Beide Methoden bewahren die L2- und inneren Produktentfernungen. Die `fjlt`-Methode sollte verwendet werden, wenn die Zieldimension groß ist, und bietet eine bessere Leistung mit CPU-Inferenzen. Die Methoden unterscheiden sich in ihren Rechenkomplexitä. Die `sign`-Methode erfordert O(ndk)-Zeit, um die Dimension eines Stapels von n Punkten der Dimension d auf eine Ziel-Dimension k zu reduzieren. Die `fjlt`-Methode erfordert O(nd log(d)) Zeit, doch die beteiligten Konstanten sind größer. Durch die Dimensionsreduzierung werden die Daten verzerrt, wodurch sich die Prognosegenauigkeit verringern kann.
## Schritt 3: Erstellen eines Index
Während der Inferenz fragt der Algorithmus den Index für einen Stichprobenpunkt ab k-nearest-neighbors. Basierend auf den Verweisen auf die Punkte nimmt der Algorithmus die Klassifizierungs- oder Regressionsprognose vor. Seine Prognose basiert auf den bereitgestellten Klassenbezeichnungen oder Werten. k-NN bietet drei verschiedene Arten von Indizes: einen flachen Index, einen umgekehrten Index und einen umgekehrten Index mit Produktquantisierung. Sie geben den Typ mit dem `index_type`-Parameter an.
## Serialisieren des Modells
Wenn der k-NN-Algorithmus Trainings abgeschlossen hat, serialisiert er drei Dateien zur Vorbereitung der Inferenz.
+ model\$1algo-1: Enthält den serialisierten Index zur Berechnung der nächsten Nachbarn.
+ model\$1alg-1.labels: Enthält serialisierte Bezeichnungen (np.float32-Binärformat) zum Berechnen der prognostizierten Bezeichnung basierend auf dem Abfrageergebnis aus dem Index.
+ model\$1algo-1.json: Enthält die Modellmetadaten im JSON-Format, in dem die – `k`und `predictor_type`-Hyperparameter aus den Trainings für Inferenz zusammen mit anderen relevanten Zuständen gespeichert werden.
Mit der aktuellen Implementierung von k-NN können Sie die Metadatendatei ändern, um die Art zu ändern, wie Prognosen berechnet werden. So können Sie z. B. `k` in 10 oder `predictor_type` in *regressor* ändern.
```
{
"k": 5,
"predictor_type": "classifier",
"dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20},
"normalize": False,
"version": "1.0"
}
```
## EC2-Instance-Empfehlung für den k-NN-Algorithmus
Wir empfehlen, auf einer CPU-Instance (wie ml.m5.2xlarge) oder auf einer GPU-Instance zu trainieren. Der k-NN-Algorithmus unterstützt die GPU-Instancefamilien P2, P3, G4dn und G5 für Training und Inferenz.
Inferenzanfragen von haben CPUs im Allgemeinen eine geringere durchschnittliche Latenz als Anfragen von, GPUs da bei Verwendung von GPU-Hardware eine CPU-to-GPU Belastung der Kommunikation anfällt. GPUs Im Allgemeinen weisen sie jedoch bei größeren Batches einen höheren Durchsatz auf.
# k-NN-Hyperparameter
In der folgenden Tabelle sind die Hyperparameter aufgeführt, die Sie für den Amazon SageMaker AI-Algorithmus k-Nearest Neighbors (k-NN) festlegen können.
| Name des Parameters | Description |
| --- | --- |
| feature\$1dim | Die Anzahl der Merkmale der Eingabedaten. **Erforderlich** Gültige Werte: positive Ganzzahl. |
| k | Die Anzahl der nächsten Nachbarn. **Erforderlich** Gültige Werte: positive Ganzzahl |
| predictor\$1type | Der Inferenztyp, der für die Datenbezeichnungen verwendet werden soll. **Erforderlich** Gültige Werte: *Classifier* für die Klassifizierung oder *regressor* für die Regression. |
| sample\$1size | Die Anzahl der Datenpunkte, die aus dem Trainingsdatensatz gesampelt werden soll. **Erforderlich** Gültige Werte: positive Ganzzahl |
| dimension\$1reduction\$1target | Die Zieldimension, auf die reduziert werden soll. **Erforderlich**, wenn Sie den `dimension_reduction_type`-Parameter angeben. Gültige Werte: positive Ganzzahl größer als 0 und kleiner als `feature_dim`. |
| dimension\$1reduction\$1type | Der Typ der Dimensionsreduzierungsmethode. **Optional** Gültige Werte: *sign* für zufällige Projektion oder *fjlt* für die schnelle Johnson-Lindenstrauss-Transformation. Standardwert: Keine Dimensionsreduzierung |
| faiss\$1index\$1ivf\$1nlists | *Die Anzahl der Zentroide, die im Index erstellt werden sollen, wenn er nicht erreicht ist. `index_type` *IVFFlat*oder Faiss.IVFPQ.* **Optional** Gültige Werte: positive Ganzzahl Standardwert: *auto*, der in `sqrt(sample_size)` aufgelöst wird. |
| faiss\$1index\$1pq\$1m | Die Anzahl der Vektorsubkomponenten zur Erstellung im Index, wenn `index_type` auf *faiss.IVFPQ* eingestellt ist. Die FAISS-Bibliothek ( FaceBook AI Similarity Search) erfordert, dass der Wert von ein Divisor der `faiss_index_pq_m` Datendimension ist. Wenn `faiss_index_pq_m` kein Divisor der Datendimension ist, erhöhen wir die Datendimension auf die kleinste Ganzzahl, die durch `faiss_index_pq_m` teilbar ist. Wenn keine Dimensionsreduzierung angewendet wird, fügt der Algorithmus eine Auffüllung mit Nullen hinzu. Wenn die Dimensionsreduzierung angewendet wird, erhöht der Algorithmus den Wert des `dimension_reduction_target`-Hyperparameters. **Optional** Gültige Werte: Eine der folgenden positiven Ganzzahlen: 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96 |
| index\$1metric | Die Metrik, um den Abstand zwischen den Punkten bei der Suche nach den nächsten Nachbarn zu messen. Wenn Trainings mit dem Wert `index_type` auf `faiss.IVFPQ` ausgeführt werden, werden `INNER_PRODUCT`-Entfernung und `COSINE`-Ähnlichkeit nicht unterstützt. **Optional** Gültige Werte: *L2* für die euklidische Entfernung, *INNER\$1PRODUCT* für die innere Produktentfernung, *COSINE* für Kosinusähnlichkeit. Standardwert: *L2* |
| index\$1type | Der Typ des Index. **Optional** *Gültige Werte: *faiss.Flat, faiss*. *IVFFlat*,* faiss.IVFPQ. Standardwerte: *faiss.Flat* |
| mini\$1batch\$1size | Die Anzahl der Beobachtungen pro Mini-Stapel für den Dateniterator. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 5000 |
# Optimieren eines k-NN-Modells
Der Amazon SageMaker AI K-Nearest Neighbors-Algorithmus ist ein überwachter Algorithmus. Der Algorithmus verbraucht ein Testdatensatz und gibt eine Metrik über die Genauigkeit für eine Klassifizierungsaufgabe oder über den mittleren quadratischen Fehler für eine Regressionsaufgabe aus. Diese Genauigkeitsmetriken vergleichen die Modellprognosen für ihre jeweilige Aufgabe mit den Referenzdaten, die anhand der empirischen Testdaten bereitgestellt werden. Führen Sie einen Hyperparameter-Optimierungsauftrag für k-NN aus, um das beste Modell zu suchen, das die höchste Genauigkeit oder den geringsten Fehler im Testdatensatz meldet.
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik für die Prognoseaufgabe des Algorithmus aus. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert. Die Hyperparameter werden nur verwendet, um Modellparameter zu schätzen. Sie werden nicht vom trainierten Modell verwendet, um Prognosen zu treffen.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Vom k-NN-Algorithmus berechnete Metriken
Der k-nearest neighbors-Algorithmus berechnet eine von zwei Metriken in der folgenden Tabelle während des Trainings abhängig von der Art der durch den `predictor_type`-Hyperparameter angegebenen Aufgabe.
+ *Classifier* gibt eine Klassifizierungsaufgabe an und berechnet `test:accuracy`.
+ *Regressor* gibt eine Regressionsaufgabe an und berechnet `test:mse`.
Wählen Sie den für die Art der Aufgabe geeigneten `predictor_type`-Wert aus, mit der die relevante objektive Metrik beim Optimieren eines Modells berechnet wird.
| Metrikname | Description | Optimierungsrichtung |
| --- | --- | --- |
| test:accuracy | Wenn `predictor_type` auf *classifier* festgelegt ist, vergleicht k-NN die prognostizierte Bezeichnung, basierend auf dem Durchschnitt der k-nearest neighbors-Bezeichnungen, mit den in den Testkanaldaten angegebenen Referenzdaten. Die gemeldete Genauigkeit liegt im Bereich von 0,0 (0 %) bis 1,0 (100 %). | Maximieren |
| test:mse | Wenn `predictor_type` auf *regressor* festgelegt ist, vergleicht k-NN die prognostizierte Bezeichnung, basierend auf dem Durchschnitt der k-nearest neighbors-Bezeichnungen, mit den in den Testkanaldaten angegebenen Referenzdaten. Der mittlere quadratische Fehler wird berechnet, indem die beiden Bezeichnungen verglichen werden. | Minimieren |
## Optimierbare k-NN-Hyperparameter
Optimieren Sie das Amazon SageMaker AI K-Nearest Neighbor-Modell mit den folgenden Hyperparametern.
| Name des Parameters | Parametertyp | Empfohlene Bereiche |
| --- | --- | --- |
| k | IntegerParameterRanges | MinValue: 1, MaxValue: 1024 |
| sample\$1size | IntegerParameterRanges | MinValue: 256, MaxValue: 2000000 |
# Datenformate für k-NN-Trainingseingaben
Alle integrierten Algorithmen von Amazon SageMaker AI halten sich an die gängigen Eingabe-Trainingsformate, die unter [Common Data Formats — Training](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html) beschrieben sind. Dieses Thema enthält eine Liste der verfügbaren Eingabeformate für den SageMaker k-nearest-neighbor KI-Algorithmus.
## CSV-Datenformate
Inhaltstyp: text/csv; label\$1size=1
```
4,1.2,1.3,9.6,20.3
```
Die ersten `label_size` Spalten werden als Bezeichnungsvektor für diese Zeile interpretiert.
## RECORDIO-Datenformat
Inhaltstyp: Anwendung/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [1.2, 1.3, 9.6, 20.3] # float32
}
},
label = {
'values': {
values: [4] # float32
}
}
}
]
}
```
# k-NN-Anforderungs- und Antwortformate
Alle integrierten Algorithmen von Amazon SageMaker AI halten sich an das gemeinsame Eingabe-Inferenzformat, das unter [Common Data Formats — Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) beschrieben ist. Dieses Thema enthält eine Liste der verfügbaren Ausgabeformate für den SageMaker k-nearest-neighbor KI-Algorithmus.
## EINGABE: CSV-Anforderungsformat
Inhaltstyp: text/csv
```
1.2,1.3,9.6,20.3
```
Dieser Parameter akzeptiert eine `label_size` oder einen Codierungsparameter. Es setzt eine `label_size` von 0 und eine UTF-8-Codierung voraus.
## EINGABE: JSON-Anforderungsformat
Inhaltstyp: application/json
```
{
"instances": [
{"data": {"features": {"values": [-3, -1, -4, 2]}}},
{"features": [3.0, 0.1, 0.04, 0.002]}]
}
```
## EINGABE: JSONLINES-Anforderungsformat
Inhaltstyp: application/jsonlines
```
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
## EINGABE: RECORDIO-Anforderungsformat
Inhaltstyp: Anwendung/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [-3, -1, -4, 2] # float32
}
},
label = {}
},
Record = {
features = {
'values': {
values: [3.0, 0.1, 0.04, 0.002] # float32
}
},
label = {}
},
]
```
## AUSGABE: JSON-Antwortformat
Akzeptiert: application/json
```
{
"predictions": [
{"predicted_label": 0.0},
{"predicted_label": 2.0}
]
}
```
## AUSGABE: JSONLINES-Antwortformat
Akzeptiert: application/jsonlines
```
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
## AUSGABE: VERBOSE-JSON-Antwortformat
Im Verbose-Modus stellt die API die Suchergebnisse mit dem Entfernungsvektor aufsteigend sortiert und die entsprechenden Elemente im Bezeichnungsvektor bereit. In diesem Beispiel wird "k" auf 3 festgelegt.
Akzeptiert: application/json;verbose=true
```
{
"predictions": [
{
"predicted_label": 0.0,
"distances": [3.11792408, 3.89746071, 6.32548437],
"labels": [0.0, 1.0, 0.0]
},
{
"predicted_label": 2.0,
"distances": [1.08470316, 3.04917915, 5.25393973],
"labels": [2.0, 2.0, 0.0]
}
]
}
```
## AUSGABE: RECORDIO PROTOBUF-Antwortformat
Inhaltstyp: Anwendung/ x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [2.0] # float32
}
}
}
]
```
## AUSGABE: VERBOSE RECORDIO PROTOBUF-Antwortformat
Im Verbose-Modus stellt die API die Suchergebnisse mit dem Entfernungsvektor aufsteigend sortiert und die entsprechenden Elemente im Bezeichnungsvektor bereit. In diesem Beispiel wird "k" auf 3 festgelegt.
akzeptieren: Anwendung/; verbose=true x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [3.11792408, 3.89746071, 6.32548437] # float32
},
'labels': {
values: [0.0, 1.0, 0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [1.08470316, 3.04917915, 5.25393973] # float32
},
'labels': {
values: [2.0, 2.0, 0.0] # float32
}
}
}
]
```
## BEISPIELAUSGABE für den k-NN-Algorithmus
Für regressor-Aufgaben:
```
[06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334)
```
Für classifier-Aufgaben:
```
[06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669)
```
# LightGBM
[LightGBM](https://lightgbm.readthedocs.io/en/latest/) ist eine beliebte und effiziente Open-Source-Implementierung eines Baumalgorithmus mit Gradient Boosting. GBDT ist ein überwachter Lernalgorithmus, der versucht, eine Zielvariable genau vorherzusagen, indem Schätzungen aus einer Menge einfacherer und schwächerer Modelle kombiniert werden. LightGBM verwendet zusätzliche Techniken, um die Effizienz und Skalierbarkeit herkömmlicher GBDT erheblich zu verbessern. Diese Seite enthält Informationen zu Empfehlungen für Amazon-EC2-Instances und Beispiel-Notebooks für LightGBM.
# Wie benutzt man SageMaker AI LightGBM
Sie können LightGBM als in Amazon SageMaker AI integrierten Algorithmus verwenden. Im folgenden Abschnitt wird beschrieben, wie LightGBM mit dem SageMaker Python-SDK verwendet wird. Informationen zur Verwendung von LightGBM über die Amazon SageMaker Studio Classic-Benutzeroberfläche finden Sie unter. [SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md)
+ **Verwenden von LightGBM als integrierten Algorithmus**
Sie können den integrierten LightGBM-Algorithmus zur Erstellung eines LightGBM-Trainingscontainers verwenden wie im folgenden Codebeispiel gezeigt. Sie können den Bild-URI des integrierten LightGBM-Algorithmus mithilfe der SageMaker `image_uris.retrieve` KI-API (oder der `get_image_uri` API, wenn Sie [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Version 2 verwenden) automatisch erkennen.
Nachdem Sie den LightGBM-Image-URI angegeben haben, können Sie den LightGBM-Container verwenden, um mithilfe der SageMaker AI Estimator API einen Schätzer zu erstellen und einen Trainingsjob zu starten. Der integrierte LightGBM-Algorithmus wird im Skriptmodus ausgeführt, aber das Trainingsskript wird für Sie bereitgestellt und muss nicht ersetzt werden. Wenn Sie umfangreiche Erfahrung mit der Verwendung des Skriptmodus zur Erstellung eines SageMaker Trainingsjobs haben, können Sie Ihre eigenen LightGBM-Schulungsskripte integrieren.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"num_boost_round"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1, # for distributed training, specify an instance_count greater than 1
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"train": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Weitere Informationen zum Einrichten von LightGBM als integriertem Algorithmus finden Sie in den folgenden Notebook-Beispielen.
+ [Tabellarische Klassifizierung mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Tabellarische Regression mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Eingabe- und Ausgabeschnittstelle für den LightGBM-Algorithmus
Gradient Boosting arbeitet mit tabellarischen Daten, wobei die Zeilen die Beobachtungen repräsentieren, eine Spalte die Zielvariable oder die Kennzeichnung darstellt und die verbleibenden Spalten die Funktionen.
Die SageMaker KI-Implementierung von LightGBM unterstützt CSV für Training und Inferenz:
+ *Für **Schulungen ContentType** müssen gültige Eingaben text/csv sein.*
+ *Für **Inference ContentType** müssen gültige Eingaben text/csv sein.*
**Anmerkung**
Bei der CSV-Training geht der Algorithmus davon aus, dass die Zielvariable in der ersten Spalte zu finden ist und CSV keinen Header-Datensatz aufweist.
Bei der CSV-Inferenz geht der Algorithmus davon aus, dass die CSV-Eingabe keine Kennzeichnungsspalte hat.
**Eingabeformat für Trainingsdaten, Validierungsdaten und kategoriale Features**
Achten Sie darauf, wie Sie Ihre Trainingsdaten für die Eingabe in das LightGBM-Modell formatieren. Sie müssen den Pfad zu einem Amazon-S3-Bucket angeben, der Ihre Trainings- und Validierungsdaten enthält. Sie können auch eine Liste von kategorialen Funktionen einschließen. Verwenden Sie sowohl `train` als auch den `validation` Kanal, um Ihre Eingabedaten bereitzustellen. Alternativ können Sie auch nur den `train` Kanal verwenden.
**Anmerkung**
Beide `train` und `training` sind gültige Kanalnamen für LightGBM-Trainings.
**Verwenden Sie sowohl den `train` als such den `validation` Kanal**
Sie können Ihre Eingabedaten über zwei S3-Pfade bereitstellen, einen für den `train` Kanal und einen für den `validation` Kanal. Jeder S3-Pfad kann entweder ein S3-Präfix sein, das auf eine oder mehrere CSV-Dateien verweist, oder ein vollständiger S3-Pfad, der auf eine bestimmte CSV-Datei verweist. Die Zielvariablen sollten sich in der ersten Spalte Ihrer CSV-Datei befinden. Die Prädiktorvariablen (Features) sollten sich in den verbleibenden Spalten befinden. Wenn mehrere CSV-Dateien für die `train` oder `validation` Kanäle bereitgestellt werden, verkettet der LightGBM-Algorithmus die Dateien. Die Validierungsdaten werden verwendet, um am Ende jeder Boosting-Iteration einen Validierungsscore zu berechnen. Early-Stopping wird angewendet, wenn sich der Validierungsscore nicht mehr verbessert.
Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Trainingsdatendatei (en). Wenn Sie eine JSON-Datei für kategorische Features bereitstellen, muss Ihr `train`-Kanal auf ein S3-Präfix verweisen und nicht auf eine spezifische CSV-Datei. Diese Datei sollte ein Python-Wörterbuch enthalten, in dem der Schlüssel die Zeichenfolge `"cat_index_list"` und der Wert eine Liste eindeutiger Ganzzahlen ist. Jede Ganzzahl in der Werteliste sollte den Spaltenindex der entsprechenden kategorischen Features in Ihrer CSV-Datei mit Trainingsdaten angeben. Jeder Wert sollte eine positive Ganzzahl (größer als Null, weil Null den Zielwert darstellt), kleiner als `Int32.MaxValue` (2147483647) und kleiner als die Gesamtzahl der Spalten sein. Es sollte nur eine JSON-Datei mit dem kategorischen Index geben.
**Benutze nur den `train` Kanal**:
Sie können Ihre Eingabedaten alternativ über einen einzigen S3-Pfad für den `train` Kanal bereitstellen. Dieser S3-Pfad sollte auf ein Verzeichnis mit einem Unterverzeichnis mit dem Namen `train/` verweisen, das eine oder mehrere CSV-Dateien enthält. Sie können optional ein weiteres Unterverzeichnis am selben Speicherort namens `validation/` einschließen, das auch eine oder mehrere CSV-Dateien enthält. Wenn die Validierungsdaten nicht angegeben werden, werden 20% Ihrer Trainingsdaten nach dem Zufallsprinzip als Validierungsdaten ausgewählt. Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Datenunterverzeichnisse.
**Anmerkung**
Beim CSV-Trainingseingangsmodus muss der für den Algorithmus verfügbare Gesamtarbeitsspeicher (Instance-Zählung verfügbarer Arbeitsspeicher im `InstanceType`) in der Lage sein, den Trainingsdatensatz aufzunehmen.
SageMaker AI LightGBM verwendet das Python-Modul Joblib, um das Modell zu serialisieren oder zu deserialisieren, das zum Speichern oder Laden des Modells verwendet werden kann.
**Um ein mit AI LightGBM trainiertes Modell mit dem Modul zu verwenden SageMaker JobLib**
+ Verwenden Sie den folgenden Python-Code:
```
import joblib
import tarfile
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = joblib.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Amazon-EC2-Instance-Empfehlung für den LightGBM-Algorithmus
SageMaker AI LightGBM unterstützt derzeit CPU-Training mit einer Instanz und mehreren Instanzen. Geben Sie für CPU-Training mit mehreren Instances (verteiltes Training) einen `instance_count` größer als 1 an, wenn Sie Ihren Schätzer definieren. Weitere Informationen zu verteiltem Training mit LightGBM finden Sie unter [Amazon SageMaker AI LightGBM Distributed](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) Training using Dask.
LightGBM ist ein speichergebundenes Algorithmus (im Gegensatz zu einem rechnergebundenen). Daher ist eine Allzweck-Datenverarbeitungs-Instance (z. B. M5) die bessere Wahl gegenüber einer rechneroptimierten Instance (z. B. C5). Des Weiteren empfehlen wir, dass Sie in ausgewählten Instances genügend Gesamtspeicher zur Verfügung haben, um das Trainingsdaten aufzunehmen.
## LightGBM-Beispiel-Notebooks
In der folgenden Tabelle sind verschiedene Beispielnotizbücher aufgeführt, die sich mit verschiedenen Anwendungsfällen des Amazon SageMaker AI LightGBM-Algorithmus befassen.
****
| **Titel des Notebooks** | **Beschreibung** |
| --- | --- |
| [Tabellarische Klassifizierung mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.html) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker AI LightGBM-Algorithmus zum Trainieren und Hosten eines tabellarischen Klassifikationsmodells. |
| [Tabellarische Regression mit Amazon SageMaker AI LightGBM und Algorithmus CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.html) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker AI LightGBM-Algorithmus zum Trainieren und Hosten eines tabellarischen Regressionsmodells. |
| [Amazon SageMaker AI LightGBM Verteilte Schulungen mit Dask](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) | Dieses Notizbuch demonstriert verteiltes Training mit dem Amazon SageMaker AI LightGBM-Algorithmus unter Verwendung des Dask-Frameworks. |
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instances, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
# Wie LightGBM funktioniert
LightGBM implementiert einen konventionellen Gradient Boosting Decision Tree (GBDT) Algorithmus mit zwei neuen Techniken: Gradient-based One-Side Sampling (GOSS) und Exclusive Feature Bundling (EFB). Diese Techniken wurden entwickelt, um die Effizienz und Skalierbarkeit von GBDT deutlich zu verbessern.
Der LightGBM-Algorithmus ist aufgrund seiner robusten Verarbeitung zahlreicher Datentypen, Beziehungen und Verteilungen und der Vielzahl von optimierbaren Hyperparametern gut für Machine-Learning-Wettbewerbe geeignet. Sie können LightGBM für Regressions-, Binär- und Multiclass-Klassifizierungs- und Ranglistenprobleme verwenden.
Weitere Informationen zur Gradientenverstärkung finden Sie unter [Wie funktioniert der SageMaker XGBoost KI-Algorithmus](xgboost-HowItWorks.md). Ausführliche Informationen zu den zusätzlichen GOSS- und EFB-Techniken, die bei der LightGBM-Methode verwendet werden, finden Sie unter *[LightGBM: Ein Entscheidungsbaum für hocheffiziente Gradientenverstärkung](https://proceedings.neurips.cc/paper/2017/file/6449f44a102fde848669bdd9eb6b76fa-Paper.pdf)* .
# LightGBM-Hyperparameter
Die folgende Tabelle enthält die Teilmenge der Hyperparameter, die für den Amazon SageMaker AI LightGBM-Algorithmus erforderlich sind oder am häufigsten verwendet werden. Dies sind Parameter, die von Benutzern festgelegt werden, um die Schätzung der Modellparameter aus Daten zu erleichtern. [Der SageMaker AI LightGBM-Algorithmus ist eine Implementierung des Open-Source-LightGBM-Pakets.](https://github.com/microsoft/LightGBM)
**Anmerkung**
Die Standard-Hyperparameter basieren auf Beispieldatensätzen in der [LightGBM-Beispiel-Notebooks](lightgbm.md#lightgbm-sample-notebooks).
Standardmäßig wählt der SageMaker AI LightGBM-Algorithmus automatisch eine Bewertungsmetrik und eine Zielfunktion aus, die auf der Art des Klassifikationsproblems basieren. Der LightGBM-Algorithmus erkennt die Art des Klassifizierungsproblems anhand der Anzahl der Beschriftungen in Ihren Daten. Bei Regressionsproblemen ist die Bewertungsmetrik der quadratische Mittelwert des Fehlers und die Zielfunktion der L2-Verlust. Bei binären Klassifikationsproblemen entsprechen die Bewertungsmetrik und die Zielfunktion beide der binären Kreuzentropie. Bei Klassifikationsproblemen mit mehreren Klassen ist die Bewertungsmetrik die Mehrklassen-Kreuzentropie und die Zielfunktion Softmax. Sie können den `metric` Hyperparameter verwenden, um die Standard-Bewertungsmetrik zu ändern. In der folgenden Tabelle finden Sie weitere Informationen zu LightGBM-Hyperparametern, einschließlich Beschreibungen, gültiger Werte und Standardwerte.
| Name des Parameters | Description |
| --- | --- |
| num\$1boost\$1round | Die maximale Anzahl von Booster-Iterationen. **Hinweis:** Intern erstellt LightGBM `num_class * num_boost_round` Bäume für Klassifikationsprobleme mit mehreren Klassen. Gültige Werte: Ganzzahl, Bereich: Positive Ganzzahl. Standardwert: `100`. |
| early\$1stopping\$1rounds | Das Training wird beendet, wenn sich eine Metrik eines Validierungsdatenpunkts in der letzten `early_stopping_rounds` Runde nicht verbessert hat. Wenn `early_stopping_rounds` kleiner als oder gleich Null ist, wird dieser Hyperparameter ignoriert. Gültige Werte: Ganzzahl. Standardwert: `10`. |
| metric | Evaluationsmetriken für die Datenvalidierung. Wenn `metric` auf den Standardwert `"auto"` gesetzt ist, wählt der Algorithmus automatisch eine Bewertungsmetrik aus, die auf der Art des Klassifizierungsproblems basiert: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/lightgbm-hyperparameters.html) Gültige Werte: String, einer der folgenden Werte: (`"auto"`, `"rmse"`, `"l1"`, `"l2"`, `"huber"`, `"fair"`, `"binary_logloss"`, `"binary_error"`, `"auc"`, `"average_precision"`, `"multi_logloss"`, `"multi_error"`, `"auc_mu"`, oder `"cross_entropy"`). Standardwert: `"auto"`. |
| learning\$1rate | Die Geschwindigkeit, mit der die Modellgewichte aktualisiert werden, nachdem die einzelnen Trainingssbeispiele durchgearbeitet wurden. Gültige Werte: Float, Bereich: (`0.0`, `1.0`). Standardwert: `0.1`. |
| num\$1leaves | Die maximale Anzahl von Blättern in einem Baum. Gültige Werte: Ganzzahl, Bereich: (`1`,`131072`). Standardwert: `64`. |
| feature\$1fraction | Eine Teilmenge von Features, die bei jeder Iteration ausgewählt werden müssen (Baum). Muss kleiner als 1.0 sein. Gültige Werte: Float, Bereich: (`0.0`, `1.0`). Standardwert: `0.9`. |
| bagging\$1fraction | Eine Teilmenge von Features, die einem Teil der Daten ähnlich sind zu `feature_fraction`, aber `bagging_fraction` ohne Resampling zufällig ausgewählt wird. Gültige Werte: Float, Bereich: (`0.0`, `1.0`]. Standardwert: `0.9`. |
| bagging\$1freq | Die Häufigkeit, mit der das Einpacken durchgeführt wird. Bei jeder `bagging_freq` Iteration wählt LightGBM nach dem Zufallsprinzip einen Prozentsatz der Daten aus, die für die nächste `bagging_freq` Iteration verwendet werden sollen. Dieser Prozentsatz wird durch den `bagging_fraction` Hyperparameter bestimmt. Wenn `bagging_freq` der Wert Null ist, ist das Einpacken deaktiviert. Gültige Werte: Ganzzahl, Bereich: Nicht-negative ganze Zahl. Standardwert: `1`. |
| max\$1depth | Die maximale Tiefe eines Baummodells. Dies wird verwendet, um Überanpassungen zu vermeiden, wenn die Datenmenge klein ist. Wenn `max_depth` kleiner oder gleich Null ist, bedeutet dies, dass es keine Grenze für die maximale Tiefe gibt. Gültige Werte: Ganzzahl. Standardwert: `6`. |
| min\$1data\$1in\$1leaf | Die minimale Datenmenge in einem Blatt. Kann für Überanpassungen verwendet werden. Gültige Werte: Ganzzahl, Bereich: Nicht-negative ganze Zahl. Standardwert: `3`. |
| max\$1delta\$1step | Wird verwendet, um die maximale Leistung von Baumblättern zu begrenzen. Wenn `max_delta_step` kleiner als oder gleich 0 ist, gibt es keine Einschränkung. Die endgültige maximale Leistung von Blättern beträgt `learning_rate * max_delta_step`. Gültige Werte: Gleitkommazahl. Standardwert: `0.0`. |
| lambda\$1l1 | L1-Regularisation. Gültige Werte: Float, Bereich: Nicht-negativer Float. Standardwert: `0.0`. |
| lambda\$1l2 | L2-Regularisation. Gültige Werte: Float, Bereich: Nicht-negativer Float. Standardwert: `0.0`. |
| boosting | Boosting-Typ Gültige Werte: String, einer der folgenden Werte: (`"gbdt"`, `"rf"`, `"dart"`, or `"goss"`). Standardwert: `"gbdt"`. |
| min\$1gain\$1to\$1split | Die Mindestverstärkung für die Durchführung einer Teilung. Kann verwendet werden, um das Training zu beschleunigen. Gültige Werte: Ganzzahl, Float: Nicht-negativer Float. Standardwert: `0.0`. |
| scale\$1pos\$1weight | Das Gewicht der Etiketten mit positiver Klasse. Wird nur für binäre Klassifikationsaufgaben verwendet. `scale_pos_weight` kann nicht verwendet werden, wenn `is_unbalance` auf `"True"` gesetzt ist. Gültige Werte: Float, Bereich: Positiver Float. Standardwert: `1.0`. |
| tree\$1learner | Baumschüler-Typ. Gültige Werte: String, einer der folgenden Werte: (`"serial"`, `"feature"`, `"data"`, or `"voting"`). Standardwert: `"serial"`. |
| feature\$1fraction\$1bynode | Wählt eine Teilmenge zufälliger Features auf jedem Baumknoten aus. Ist beispielsweise `feature_fraction_bynode` gleich `0.8`, so werden 80 % der Features ausgewählt. Kann für Überanpassungen verwendet werden. Gültige Werte: Ganzzahl, Bereich: (`0.0`, `1.0`]. Standardwert: `1.0`. |
| is\$1unbalance | Wird auf `"True"` eingestellt, wenn die Trainingsdaten unausgewogen sind. Wird nur für binäre Klassifikationsaufgaben verwendet. `is_unbalance` kann nicht mit `scale_pos_weight` verwendet werden. Gültige Werte: String, entweder: (`"True"` or `"False"`). Standardwert: `"False"`. |
| max\$1bin | Die maximale Anzahl von Bins, die verwendet werden, um Feature-Werte zusammenzufassen. Eine geringe Anzahl von Bins kann die Trainingsgenauigkeit verringern, aber die allgemeine Leistung erhöhen. Kann für Überanpassungen verwendet werden. Gültige Werte: Ganzzahl, Bereich: (1, ∞). Standardwert: `255`. |
| tweedie\$1variance\$1power | Steuert die Varianz der Tweedie-Verteilung. Stellen Sie dies näher an `2.0`, um in Richtung einer Gamma-Verteilung zu wechseln. Stellen Sie dies näher an `1.0`, um in Richtung einer Poisson-Verteilung zu wechseln. Wird nur für Regressionsaufgaben verwendet. Gültige Werte: Float, Bereich: [`1.0`, `2.0`). Standardwert: `1.5`. |
| num\$1threads | Anzahl der parallelen Threads zum Ausführen von LightGBM. Der Wert 0 bedeutet die Standardanzahl von Threads in OpenMP. Gültige Werte: Ganzzahl, Bereich: Nicht-negative ganze Zahl. Standardwert: `0`. |
| verbosity | Die Ausführlichkeit von Drucknachrichten. Ist `verbosity` kleiner als `0`, werden in Drucknachrichten nur schwerwiegende Fehler angezeigt. Ist `verbosity` auf `0` gesetzt, enthalten Drucknachrichten Fehler und Warnungen. Ist`verbosity` gleich `1`, werden Drucknachrichten mit weiteren Informationen angezeigt. Ein `verbosity` größer als `1` zeigt die meisten Informationen in gedruckten Nachrichten an und kann zum Debuggen verwendet werden. Gültige Werte: Ganzzahl Standardwert: `1`. |
# Optimieren Sie ein LightGBM-Modell
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Die Modelloptimierung konzentriert sich auf die folgenden Hyperparameter:
**Anmerkung**
Die Lernzielfunktion wird automatisch auf der Grundlage der Art der Klassifikationsaufgabe zugewiesen, die durch die Anzahl der eindeutigen Ganzzahlen in der Beschriftungsspalte bestimmt wird. Weitere Informationen finden Sie unter [LightGBM-Hyperparameter](lightgbm-hyperparameters.md).
+ Eine Lernzielfunktion zur Optimierung beim Modelltraining
+ Eine Bewertungsmetrik, die verwendet wird, um die Modellleistung während der Validierung zu bewerten
+ Ein Satz von Hyperparametern und ein Wertebereich für jeden, der bei der automatischen Abstimmung des Modells verwendet werden kann
Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.
**Anmerkung**
Die automatische Modelloptimierung für LightGBM ist nur bei Amazon verfügbar SageMaker SDKs, nicht über die SageMaker KI-Konsole.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Mit dem LightGBM-Algorithmus berechnete Bewertungsmetriken
Der SageMaker AI LightGBM-Algorithmus berechnet die folgenden Metriken, die für die Modellvalidierung verwendet werden sollen. Die Bewertungsmetrik wird automatisch auf der Grundlage der Art der Klassifizierungsaufgabe zugewiesen, die durch die Anzahl der eindeutigen Ganzzahlen in der Beschriftungspalte bestimmt wird.
| Metrikname | Description | Optimierungsrichtung | Regex-Muster |
| --- | --- | --- | --- |
| rmse | Wurzel des mittleren quadratischen Fehlers | Minimieren | "rmse: ([0-9\$1\$1.]\$1)" |
| l1 | Mittlerer absoluter Fehler. | Minimieren | "l1: ([0-9\$1\$1.]\$1)" |
| l2 | Mittlerer quadratischer Fehler. | Minimieren | "l2: ([0-9\$1\$1.]\$1)" |
| huber | Huber-Verlust | Minimieren | "huber: ([0-9\$1\$1.]\$1)" |
| fair | fairer Verlust | Minimieren | "fair: ([0-9\$1\$1.]\$1)" |
| binary\$1logloss | Binärkreuzentropie | Maximieren | "binary\$1logloss: ([0-9\$1\$1.]\$1)" |
| binary\$1error | Binärfehler | Minimieren | "binary\$1error: ([0-9\$1\$1.]\$1)" |
| auc | AUC | Maximieren | "auc: ([0-9\$1\$1.]\$1)" |
| average\$1precision | durchschnittliche Präzisionspunktzahl | Maximieren | "average\$1precision: ([0-9\$1\$1.]\$1)" |
| multi\$1logloss | Kreuzentropie mit mehreren Klassen | Maximieren | "multi\$1logloss: ([0-9\$1\$1.]\$1)" |
| multi\$1error | Mehrklassen-Fehlerbewertung | Minimieren | "multi\$1error: ([0-9\$1\$1.]\$1)" |
| auc\$1mu | AUC-MU | Maximieren | "auc\$1mu: ([0-9\$1\$1.]\$1)" |
| cross\$1entropy | Kreuz-Entropie | Minimieren | "cross\$1entropy: ([0-9\$1\$1.]\$1)" |
## Optimierbare LightGBM-Hyperparameter
Optimieren Sie das LightGBM-Modell mit den folgenden Hyperparametern. Die Hyperparameter, die den größten Einfluss auf die Optimierung der LightGBM-Bewertungsmetriken haben, sind: `learning_rate`, `num_leaves`, `feature_fraction`, `bagging_fraction`, `bagging_freq`, `max_depth` and `min_data_in_leaf`. Eine Liste aller LightGBM-Hyperparameter finden Sie unter [LightGBM-Hyperparameter](lightgbm-hyperparameters.md).
| Name des Parameters | Parametertyp | Empfohlene Bereiche |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001,: 0,01 MaxValue |
| num\$1leaves | IntegerParameterRanges | MinValue: 10, MaxValue: 100 |
| feature\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue: 1,0 |
| bagging\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue: 1,0 |
| bagging\$1freq | IntegerParameterRanges | MinValue: 0, MaxValue: 10 |
| max\$1depth | IntegerParameterRanges | MinValue: 15, MaxValue: 10 |
| min\$1data\$1in\$1leaf | IntegerParameterRanges | MinValue: 10, MaxValue: 20 |
# Algorithmus für lineares Lernen
*Lineare Modelle* sind überwachte Lernalgorithmen, die zur Lösung von Klassifizierungs- oder Regressionsproblemen verwendet werden. Für die Eingabe stellen Sie dem Modell Beispiele mit Kennzeichen (*x*, *y*) zur Verfügung. *x* ist ein hochdimensionaler Vektor und *y* ist eine numerische Kennzeichnung. Bei binären Klassifizierungsproblemen muss das Kennzeichen 0 oder 1 sein. Für Mehrklassen-Klassifizierungsprobleme müssen die Kennzeichen zwischen 0 und `num_classes` – 1 liegen. Bei Regressionsproblemen ist *y* eine Realzahl. Der Algorithmus erlernt eine lineare Funktion oder lineare Schwellenwertfunktion bei Klassifizierungsproblemen und weist einen Vektor *x* einer Approximation der Kennzeichnung *y* zu.
Der lineare Lernalgorithmus von Amazon SageMaker AI bietet eine Lösung sowohl für Klassifizierungs- als auch für Regressionsprobleme. Mit dem SageMaker KI-Algorithmus können Sie gleichzeitig verschiedene Trainingsziele untersuchen und die beste Lösung aus einem Validierungssatz auswählen. Sie können auch eine große Anzahl von Modellen erkunden und das beste auswählen. Das beste Modell optimiert eine der folgenden Größen:
+ Kontinuierliche Ziele wie mittlerer quadratischer Fehler, Kreuz-Entropie-Verlust, absoluter Fehler usw.
+ Diskrete Ziele, die für die Klassifizierung geeignet sind, wie z. B. F1-Maß, Präzision, Abruf und Genauigkeit.
Im Vergleich zu Methoden, die nur für kontinuierliche Lernziele eine Lösung bieten, bietet der SageMaker KI-Algorithmus für lineare Lernende eine deutliche Geschwindigkeitssteigerung im Vergleich zu naiven Techniken zur Optimierung von Hyperparametern. Außerdem ermöglicht er eine vereinfachte Handhabung.
Der Algorithmus für lineares Lernen erfordert eine Datenmatrix, deren Zeilen die Beobachtungen und deren Spalten die Dimensionen der Merkmale darstellen. Außerdem ist eine zusätzliche Spalte mit den Kennzeichnungen erforderlich, die den Datenpunkten entsprechen. Amazon SageMaker AI Linear Learner verlangt mindestens, dass Sie die Speicherorte der Eingabe- und Ausgabedaten sowie den Zieltyp (Klassifizierung oder Regression) als Argumente angeben. Die Merkmalsdimension ist ebenfalls erforderlich. Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Sie können zusätzliche Parameter in der `HyperParameters`-Zeichenfolge des Anforderungstexts angeben. Diese Parameter steuern das Optimierungsverfahren oder geben die Zielfunktion an, für die Sie das Training ausführen. Zu den Beispielen gehören die Anzahl der Epochen, Regularisierung und Verlusttyp.
Wenn Sie [Managed Spot Training](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html) verwenden, unterstützt der lineare Lerneralgorithmus die Verwendung von [Checkpoints, um eine Momentaufnahme des Status des Modells](https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html) zu erstellen.
**Topics**
+ [Input/Output-Schnittstelle für den linearen Lernalgorithmus](#ll-input_output)
+ [EC2-Instance-Empfehlung für den Linear Learner-Algorithmus](#ll-instances)
+ [Muster-Notebooks für lineare Lerner](#ll-sample-notebooks)
+ [So funktioniert der lineare Learner](ll_how-it-works.md)
+ [Hyperparameter für den linearen Lerner](ll_hyperparameters.md)
+ [Abstimmen eines linearen Learner-Modells](linear-learner-tuning.md)
+ [Antwortformate von linearen Learnern](LL-in-formats.md)
## Input/Output-Schnittstelle für den linearen Lernalgorithmus
Der lineare Lernalgorithmus von Amazon SageMaker AI unterstützt drei Datenkanäle: Training, Validierung (optional) und Test (optional). Wenn Sie Validierungsdaten bereitstellen, sollte der `S3DataDistributionType` `FullyReplicated` sein. Der Algorithmus protokolliert den Validierungsverlust für jede Epoche und verwendet eine Stichprobe der Validierungsdaten zur Kalibrierung und Auswahl des besten Modells. Wenn Sie keine Validierungsdaten bereitstellen, verwendet der Algorithmus eine Stichprobe der Trainingsdaten, um das Modell zu kalibrieren und auszuwählen. Wenn Sie Testdaten bereitstellen, enthalten die Algorithmusprotokolle das Testergebnis für das endgültige Modell.
**Für Trainings** unterstützt der Algorithmus für lineares Lernen sowohl das – `recordIO-wrapped protobuf`als auch das `CSV`-Format. Für den `application/x-recordio-protobuf`Eingabetyp werden nur Float32-Tensoren unterstützt. Beim Eingabetyp `text/csv` wird angenommen, dass die erste Spalte die Kennzeichnung ist. Dies ist die Zielvariable für eine Prognose. Sie können entweder den Datei- oder den Pipe-Modus zum Trainieren linearer Lernmodelle mit Daten verwenden, die als `recordIO-wrapped-protobuf` oder `CSV` formatiert sind.
**Bei Inferenzen** unterstützt der Algorithmus für lineares Lernen die Formate `application/json`, `application/x-recordio-protobuf` und `text/csv`. Wenn Sie Voraussagen mit neuen Daten treffen, hängt das Format der Antwort von der Art des Modells ab. **Bei der Regression** (`predictor_type='regressor'`) ist `score` die Voraussage des Modells. **Bei der Klassifizierung** (`predictor_type='binary_classifier'` oder `predictor_type='multiclass_classifier'`) gibt das Modell `score` und auch `predicted_label` zurück. `predicted_label` ist die Klasse, die vom Modell vorausgesagt wird, und `score` misst die Stärke der Voraussage.
+ **Für die binäre Klassifikation** ist `predicted_label` `0` oder `1`, und `score` ist eine einzelne Gleitkommazahl, die angibt, wie stark der Algorithmus glaubt, dass die Bezeichnung 1 sein sollte.
+ **Bei der Mehrklassen-Klassifizierung** ist `predicted_class` eine Ganzzahl von `0` bis `num_classes-1` und `score` entspricht einer Liste mit einer Gleitkommazahl pro Klasse.
Zur Interpretation von `score` bei Klassifizierungsproblemen müssen Sie die verwendete Verlustfunktion berücksichtigen. Wenn der Hyperparameter-Wert von `loss` bei der binären Klassifizierung `logistic` und bei der Mehrklassen-Klassifizierung `softmax_loss` ist, kann `score` als Wahrscheinlichkeit der entsprechenden Klasse interpretiert werden. Dies sind die Verlustwerte, die vom linearen Lernen verwendet werden, wenn der `loss`-Wert dem Standardwert `auto` entspricht. Wenn der Verlust aber auf `hinge_loss` festgelegt ist, kann die Punktzahl nicht als Wahrscheinlichkeit interpretiert werden. Dies liegt daran, dass "hinge loss" einer Support Vector-Klassifizierung entspricht, die keine Wahrscheinlichkeitsschätzungen vornimmt.
Weitere Informationen zu den Ein- und Ausgabedateiformaten finden Sie unter [Antwortformate von linearen Learnern](LL-in-formats.md). Weitere Informationen zu Inferenzformaten finden Sie unter [Muster-Notebooks für lineare Lerner](#ll-sample-notebooks).
## EC2-Instance-Empfehlung für den Linear Learner-Algorithmus
Der lineare Lerneralgorithmus unterstützt sowohl CPU- als auch GPU-Instances für Training und Inferenz. Für GPU unterstützt der lineare Learner-Algorithmus die GPU-Familien P2, P3, G4dn und G5.
Während der Tests haben wir keine wesentlichen Hinweise darauf gefunden, dass Multi-GPU-Instances schneller sind als Single-GPU-Instances. Die Ergebnisse können abhängig vom jeweiligen Anwendungsfall variieren.
## Muster-Notebooks für lineare Lerner
In der folgenden Tabelle sind verschiedene Beispielnotizbücher aufgeführt, die sich mit verschiedenen Anwendungsfällen des Amazon SageMaker AI Linear Learner-Algorithmus befassen.
| **Titel des Notebooks** | **Beschreibung** |
| --- | --- |
| [Eine Einführung in den MNIST-Datensatz](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/linear_learner_mnist/linear_learner_mnist.html) | Mithilfe des MNIST-Datensatzes trainieren wir einen binären Klassifikator, um eine einzelne Ziffer vorherzusagen. |
| [Wie erstellt man einen Multiklassen-Klassifikator?](https://sagemaker-examples.readthedocs.io/en/latest/scientific_details_of_algorithms/linear_learner_multiclass_classification/linear_learner_multiclass_classification.html) | Anhand des Covertype-Datensatzes von UCI zeigen wir, wie ein Multiklassen-Klassifikator trainiert wird. |
| [Wie erstellt man eine Machine Learning (ML) -Pipeline für Inferenz?](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.html) | Anhand eines Scikit-Learn-Containers demonstrieren wir, wie man eine ML-Pipeline erstellt. end-to-end |
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Die Beispiel-Notebooks zur Themenmodellierung unter Verwendung des Algorithmus für lineares Lernen finden Sie im Abschnitt **Einführung in die Amazon-Algorithmen**. Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
# So funktioniert der lineare Learner
Es gibt drei Schritte bei der Implementierung des Algorithmus für lineares Lernen: Vorverarbeitung, Training und Validierung.
## Schritt 1: Vorverarbeitung
Normalisierung ist ein wichtiger Vorbereitungsschritt für verschiedene Verlustmerkmale, der sicherstellt, dass das anhand eines Datensatzes trainierte Modell nicht aufgrund seiner Gewichtung von einem einzelnen Merkmal dominiert wird. Der Amazon SageMaker AI Linear Learner-Algorithmus verfügt über eine Normalisierungsoption, die diesen Vorverarbeitungsschritt unterstützt. Wenn die Normalisierung aktiviert wird, verarbeitet der Algorithmus zunächst eine kleine Stichprobe der Daten, um den Mittelwert und die Standardabweichung für jedes Merkmal und für die Bezeichnung zu ermitteln. Jedes der Merkmale im gesamten Datensatz wird dann verschoben, um einen Mittelwert von 0 zu erreichen, und skaliert, um eine einheitliche Standardabweichung zu erzielen.
**Anmerkung**
Für beste Ergebnisse sollten die Daten vor dem Training gemischt werden. Ein Training mit nicht gemischten Daten kann zum Fehlschlagen des Trainings führen.
Sie können konfigurieren, ob der Algorithmus für lineares Lernen die Merkmalsdaten und die Bezeichnungen mit den Hyperparametern `normalize_data` und `normalize_label` normalisiert. Die Normalisierung ist standardmäßig für Merkmale und für Bezeichnungen für die Regression aktiviert. Nur die Merkmale können für die binäre Klassifikation normalisiert werden. Dies ist das Standardverhalten.
## Schritt 2: Training
Für das Training mit dem Algorithmus für lineares Lernen wird eine verteilten Implementierung des stochastischen Gradientenverfahrens (Stochastic Gradient Descent, SGD) verwendet. Sie können den Optimierungsprozess durch Auswählen des Optimierungsalgorithmus steuern. Sie können sich beispielsweise dafür entscheiden, Adam, AdaGrad stochastischen Gradientenabstieg oder andere Optimierungsalgorithmen zu verwenden. Außerdem geben Sie ihre Hyperparameter, wie z. B. Impuls, Lernrate und Lernraten-Scheduler an. Wenn Sie sich nicht sicher sind, welchen Algorithmus oder Hyperparameterwert Sie verwenden sollten, wählen Sie einen Standardwert aus, der für die meisten Datensätze funktioniert.
Während des Trainings optimieren Sie gleichzeitig mehrere Modelle mit jeweils etwas anderen Zielen. Beispiel: Sie variieren L1- oder L2-Regularisation und versuchen, verschiedene Optimierereinstellungen zu finden.
## Schritt 3: Validierung und Festlegung des Schwellenwerts
Wenn mehrere Modelle parallel trainiert werden, werden die Modelle anhand eines Validierungssatzes ausgewertet, um nach Abschluss des Trainings das beste Modell auszuwählen. Für die Regression ist das beste Modell dasjenige, das den besten Verlust für den Validierungssatz erzielt. Für die Klassifizierung wird eine Stichprobe des Validierungssatzes verwendet, um den Klassifizierungsschwellenwert zu kalibrieren. Das ausgewählte beste Modell ist das Modell, das die besten Auswahlkriterien für die binäre Klassifikation des Validierungssatzes erreicht. Beispiele für diese Kriterien sind F1-Maß, Genauigkeit und Kreuzentropieverlust.
**Anmerkung**
Wenn dem Algorithmus kein Validierungssatz übergeben wird, sind Auswertung und Auswahl des besten Modells nicht möglich. Um die Vorteile des parallelen Trainings und der Modellauswahl nutzen zu können, muss ein Validierungssatz für den Algorithmus bereitgestellt werden.
# Hyperparameter für den linearen Lerner
Die folgende Tabelle enthält die Hyperparameter für den Algorithmus für das lineare Lernen. Dies sind Parameter, die von Benutzern festgelegt werden, um die Schätzung der Modellparameter aus Daten zu erleichtern. Die obligatorischen Hyperparameter, die festgelegt werden müssen, sind zuerst aufgelistet (in alphabetischer Reihenfolge). Die optionalen Hyperparameter, die festgelegt werden können, sind als Nächstes aufgeführt (ebenfalls in alphabetischer Reihenfolge). Wenn ein Hyperparameter auf eingestellt ist`auto`, berechnet Amazon SageMaker AI automatisch den Wert dieses Hyperparameters und legt ihn fest.
| Name des Parameters | Description |
| --- | --- |
| num\$1classes | Die Anzahl der Klassen für die Antwortvariable. Der Algorithmus geht davon aus, dass Klassen mit `0`, ..., `num_classes - 1` bezeichnet werden. **Erforderlich**, wenn `predictor_type` mit `multiclass_classifier` angegeben ist. Andernfalls wird dies vom Algorithmus ignoriert. Gültige Werte: Ganzzahlen zwischen 3 und 1 000 000 |
| predictor\$1type | Gibt den Typ der Zielvariable als binäre Klassifikation, Mehrklassen-Klassifizierung oder Regression an. **Erforderlich** Gültige Werte: `binary_classifier`, `multiclass_classifier` oder `regressor` |
| accuracy\$1top\$1k | Bei der Berechnung der Top-K-Genauigkeitsmetrik für die Mehrklassen-Klassifizierung der Wert von *k*. Wenn das Modell der tatsächlichen Bezeichnung eines der Top-K-Punktzahlen zuweist, wird ein Beispiel als korrekt bewertet. **Optional** Gültige Werte: positive Ganzzahlen Standardwert: 3 |
| balance\$1multiclass\$1weights | Gibt an, ob die Klassengewichtungen verwendet werden sollen, wodurch jede Klasse in der Verlustfunktion gleiches Gewicht erhält. Wird nur verwendet, wenn `predictor_type` `multiclass_classifier` ist. **Optional** Zulässige Werte: `true`, `false` Standardwert: `false` |
| beta\$11 | Die exponentielle Zerfallsrate für Schätzwerte im ersten Schritt. Nur anwendbar, wenn der Wert von `optimizer` gleich `adam` ist. **Optional** Gültige Werte: `auto` oder Gleitkommawert zwischen 0 und 1,0 Standardwert: `auto` |
| beta\$12 | Die exponentielle Zerfallsrate für Schätzwerte im zweiten Schritt. Nur anwendbar, wenn der Wert von `optimizer` gleich `adam` ist. **Optional** Gültige Werte: `auto` oder Gleitkomma-Ganzzahl zwischen 0 und 1,0 Standardwert: `auto` |
| bias\$1lr\$1mult | Ermöglicht eine andere Lernrate für die Verzerrungsbedingung. Die tatsächliche Lernrate für die Verzerrung ist `learning_rate` \$1 `bias_lr_mult`. **Optional** Gültige Werte: `auto` oder positive Gleitkomma-Ganzzahl Standardwert: `auto` |
| bias\$1wd\$1mult | Ermöglicht andere Regularisierung für die Verzerrungsbedingung. Die tatsächliche L2-Regularisierungsgewichtung für die Verzerrung ist `wd` \$1 `bias_wd_mult`. Standardmäßig gibt es keine Regularisierung der Verzerrungsbedingung. **Optional** Gültige Werte: `auto` oder nicht negative Gleitkomma-Ganzzahl Standardwert: `auto` |
| binary\$1classifier\$1model\$1selection\$1criteria | Wenn `predictor_type` auf `binary_classifier` festgelegt ist, die Modellbewertungskriterien für den Validierungsdatensatz (oder für den Trainingsdatensatz, wenn Sie keinen Validierungdatensatz angeben). Kriterien sind: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/ll_hyperparameters.html) **Optional** Gültige Werte: `accuracy`, `f_beta`, `precision_at_target_recall`, `recall_at_target_precision` oder `loss_function` Standardwert: `accuracy` |
| early\$1stopping\$1patience | Die Anzahl der abzuwartenden Epochen, bevor das Training endet, wenn keine Verbesserung in der entsprechenden Metrik erzielt wird. Wenn Sie einen Wert für binary\$1classifier\$1model\$1selection\$1criteria angegeben haben, entspricht die Metrik diesem Wert. Andernfalls entspricht die Metrik dem für den loss-Hyperparameter angegebenen Wert. Die Metrik wird für die Validierungsdaten ausgewertet. Wenn Sie keine Validierungsdaten angegeben haben, entspricht die Metrik immer dem für den `loss`-Hyperparameter angegebenen Wert und wird anhand der Trainingsdaten ausgewertet. Zum Deaktivieren des frühzeitigen Beendens legen Sie `early_stopping_patience` auf einen Wert fest, der größer als der für `epochs` angegebene Wert ist.**Optional**Gültige Werte: Positive GanzzahlStandardwert: 3 |
| early\$1stopping\$1tolerance | Die relative Toleranz zur Messung von Verlustverbesserungen. Wenn das Verhältnis der Verlustverbesserung dividiert durch den vorherigen besten Verlust kleiner als dieser Wert ist, betrachtet der Prozess zum frühzeitigen Beenden die Verbesserung als null. **Optional** Gültige Werte: positive Gleitkomma-Ganzzahl Standardwert: 0.001 |
| epochs | Die maximale Anzahl von Durchläufen der Trainingsdaten. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 15 |
| f\$1beta | Der Wert von Beta zur Berechnung von F-Bewertungsmetriken für binäre oder Mehrklassen-Klassifizierung. Dieser wird auch verwendet, wenn der für `binary_classifier_model_selection_criteria` angegebene Wert `f_beta` lautet. **Optional** Gültige Werte: positive Gleitkomma-Ganzzahlen Standardwert: 1.0 |
| feature\$1dim | Die Anzahl der Merkmale der Eingabedaten. **Optional** Gültige Werte: `auto` oder positive Ganzzahl Standardwerte: `auto` |
| huber\$1delta | Der Parameter für Huber-Verlust. Während der Trainings- und der Metrikevaluation wird mit einem L2-Verlust für Fehler gerechnet, die kleiner sind als Delta und einem L1-Verlust für Fehler, die größer als Delta sind. **Optional** Gültige Werte: positive Gleitkomma-Ganzzahl Standardwert: 1.0 |
| init\$1bias | Initiale Gewichtung für die Verzerrungsbedingung. **Optional** Gültige Werte: Gleitkomma-Ganzzahl Standardwert: 0 |
| init\$1method | Legt die anfängliche Verteilungsfunktion für Modellgewichtungen fest. Zu den Funktionen gehören: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/ll_hyperparameters.html) **Optional** Gültige Werte: `uniform` oder `normal`. Standardwert: `uniform` |
| init\$1scale | Skaliert eine erste einheitliche Verteilung für Modellgewichtungen. Gilt nur, wenn der `init_method`-Hyperparameter auf `uniform` festgelegt ist. **Optional** Gültige Werte: positive Gleitkomma-Ganzzahl Standardwert: 0.07 |
| init\$1sigma | Die anfängliche Standardabweichung für die Normalverteilung. Gilt nur, wenn der `init_method`-Hyperparameter auf `normal` festgelegt ist. **Optional** Gültige Werte: positive Gleitkomma-Ganzzahl Standardwert: 0.01 |
| l1 | Der L1-Regularisierungsparameter. Wenn Sie die L1-Regularisation nicht verwenden möchten, legen Sie diesen Wert auf 0 fest. **Optional** Gültige Werte: `auto` oder nicht negative Gleitkommazahl Standardwert: `auto` |
| learning\$1rate | Die Schrittgröße, die der Optimierer für Parameteraktualisierungen verwendet. **Optional** Gültige Werte: `auto` oder positive Gleitkomma-Ganzzahl Standardwert: `auto`, dessen Wert vom ausgewählten Optimierer abhängt. |
| loss | Gibt die Verlustfunktion an. Die verfügbaren Verlustfunktionen und deren Standardwerte hängen von dem Wert von `predictor_type` ab: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/ll_hyperparameters.html) Gültige Werte: `auto`, `logistic`, `squared_loss`, `absolute_loss`, `hinge_loss`, `eps_insensitive_squared_loss`, `eps_insensitive_absolute_loss`, `quantile_loss` oder `huber_loss` **Optional** Standardwert: `auto` |
| loss\$1insensitivity | Der Parameter für den Epsilon-unempfindlichen Verlusttyp. Während der Trainings- und der Metrikevaluation werden Fehler, die kleiner als dieser Wert sind, als null betrachtet. **Optional** Gültige Werte: positive Gleitkomma-Ganzzahl Standardwert: 0.01 |
| lr\$1scheduler\$1factor | Bei jedem `lr_scheduler_step`-Hyperparameter verringert sich die Lernrate um diese Menge. Gilt nur, wenn der `use_lr_scheduler`-Hyperparameter auf `true` festgelegt ist. **Optional** Gültige Werte: `auto` oder positive Gleitkomma-Ganzzahl zwischen 0 und 1 Standardwert: `auto` |
| lr\$1scheduler\$1minimum\$1lr | Die Lernrate sinkt niemals auf einen Wert kleiner als der für `lr_scheduler_minimum_lr` festgelegte Wert. Gilt nur, wenn der `use_lr_scheduler`-Hyperparameter auf `true` festgelegt ist. **Optional** Gültige Werte: `auto` oder positive Gleitkomma-Ganzzahl Standardwerte: `auto` |
| lr\$1scheduler\$1step | Die Anzahl der Schritte zwischen der Verringerung der Lernrate. Gilt nur, wenn der `use_lr_scheduler`-Hyperparameter auf `true` festgelegt ist. **Optional** Gültige Werte: `auto` oder positive Ganzzahl Standardwert: `auto` |
| margin | Der Rand für die `hinge_loss`-Funktion **Optional** Gültige Werte: positive Gleitkomma-Ganzzahl Standardwert: 1.0 |
| mini\$1batch\$1size | Die Anzahl der Beobachtungen pro Mini-Stapel für den Dateniterator. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 1000 |
| momentum | Die Dynamik des `sgd`-Optimierers. **Optional** Gültige Werte: `auto` oder eine Gleitkomma-Ganzzahl zwischen 0 und 1,0 Standardwert: `auto` |
| normalize\$1data | Normalisiert die Merkmalsdaten vor dem Training. Die Datennormalisierung verschiebt die Daten für jedes Merkmal auf einen Mittelwert von 0 und skaliert so, dass sich eine einheitliche Standardabweichung ergibt. **Optional** Gültige Werte: `auto`, `true` oder `false` Standardwert: `true` |
| normalize\$1label | Normalisiert die Kennzeichnung. Durch die Normalisierung wird die Bezeichnung auf einen Mittelwert von 0 verschoben und skaliert, um eine einheitliche Standardabweichung zu erreichen. Der Standardwert `auto` normalisiert die Bezeichnung für Regressionsprobleme, nicht aber für Klassifizierungsprobleme. Wenn Sie den `normalize_label`-Hyperparameter bei Klassifizierungsproblemen auf `true` festlegen, wird er vom Algorithmus ignoriert. **Optional** Gültige Werte: `auto`, `true` oder `false` Standardwert: `auto` |
| num\$1calibration\$1samples | Die Anzahl der aus dem Validierungsdatensatz für die Modellkalibrierung zu verwendenden Beobachtungen (beim Suchen des besten Schwellenwerts). **Optional** Gültige Werte: `auto` oder positive Ganzzahl Standardwert: `auto` |
| num\$1models | Die Anzahl der parallel zu schulenden Modelle. Beim Standardwert `auto` entscheidet der Algorithmus über die Anzahl der parallel zu schulenden Modelle. Ein Modell wird entsprechend den vorgegebenen Trainingsparametern trainiert (Regularisierung, Optimierer, Verlust) und die übrigen durch ähnliche Parameter. **Optional** Gültige Werte: `auto` oder positive Ganzzahl Standardwerte: `auto` |
| num\$1point\$1for\$1scaler | Die Anzahl der Datenpunkte, die zur Berechnung der Normalisierung oder Entzerrung der Bedingungen verwendet werden. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 10,000 |
| optimizer | Der Optimierungsalgorithmus, der verwendet werden soll. **Optional** Zulässige Werte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/ll_hyperparameters.html) Standardwert: `auto`. Die Standardeinstellung für `auto` ist `adam`. |
| positive\$1example\$1weight\$1mult | Die Gewichtung, die positiven Beispielen beim Training mit binärer Klassifizierung zugewiesen wird. Das Gewichtung von negativen Beispielen ist auf 1 festgelegt. Wenn der Algorithmus eine Gewichtung auswählen soll, mit der Fehler bei der Klassifizierung positiver *und* negativer Beispiele den gleichen Einfluss auf den Trainingsverlust haben, geben Sie `balanced` an. Wenn Sie möchten, dass der Algorithmus die Gewichtung auswählt, mit der die Leistung optimiert wird, geben Sie `auto` an. **Optional** Gültige Werte: `balanced`, `auto`oder eine positive Gleitkomma-Ganzzahl Standardwert: 1.0 |
| quantile | Das Quantil für Quantilverlust. Das Modell versucht für das Quantil q Prognosen zu erstellen, sodass der Wert von `true_label` größer ist als die Prognose mit der Wahrscheinlichkeit q. **Optional** Gültige Werte: Gleitkomma-Ganzzahl zwischen 0 und 1 Standardwert: 0.5 |
| target\$1precision | Die Zielpräzision. Wenn `binary_classifier_model_selection_criteria` den Wert `recall_at_target_precision` hat, wird die Präzision auf diesem Wert gehalten, während der Recall maximiert wird. **Optional** Gültige Werte: Gleitkomma-Ganzzahl zwischen 0 und 1.0 Standardwert: 0.8 |
| target\$1recall | Der Ziel-Recall. Wenn `binary_classifier_model_selection_criteria` den Wert `precision_at_target_recall` hat, wird der Recall auf diesem Wert gehalten, während die Präzision maximiert wird. **Optional** Gültige Werte: Gleitkomma-Ganzzahl zwischen 0 und 1.0 Standardwert: 0.8 |
| unbias\$1data | Entfernt Verzerrungen der Merkmale vor dem Training, sodass der Mittelwert 0 ist. Standardmäßig sind die Daten unverzerrt, wenn der `use_bias`-Hyperparameter auf `true` gesetzt wurde. **Optional** Gültige Werte: `auto`, `true` oder `false` Standardwert: `auto` |
| unbias\$1label | Entfernt Verzerrungen der Kennzeichnungen vor dem Training, sodass der Mittelwert 0 ist. Gilt nur bei Regression, wenn der `use_bias`-Hyperparameter auf `true` festgelegt ist. **Optional** Gültige Werte: `auto`, `true` oder `false` Standardwert: `auto` |
| use\$1bias | Gibt an, ob das Modell eine Verzerrungsbedingung enthalten soll. Dabei handelt es sich um die Intercept-Bedingung in der linearen Gleichung. **Optional** Gültige Werte: `true` oder `false`. Standardwert: `true` |
| use\$1lr\$1scheduler | Gibt an, ob ein Scheduler für die Lernrate verwendet werden soll. Wenn Sie einen Scheduler verwenden möchten, geben Sie `true` an. **Optional** Gültige Werte: `true` oder `false`. Standardwert: `true` |
| wd | Der Weight-Decay-Parameter, auch bekannt als L2-Regularisationsparameter. Wenn Sie die L2-Regularisation nicht verwenden möchten, legen Sie diesen Wert auf 0 fest. **Optional** Gültige Werte: `auto` oder nicht negative Gleitkomma-Ganzzahl Standardwert: `auto` |
# Abstimmen eines linearen Learner-Modells
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.
Der Algorithmus für lineares Lernen verfügt außerdem über einen internen Mechanismus für Optimierungshyperparameter, der von der hier beschriebenen automatischen Funktion zur Modelloptimierung getrennt ist. Standardmäßig optimiert der Algorithmus für lineares Lernen Hyperparameter durch paralleles Schulen mehrerer Modelle. Wenn Sie die automatische Modelloptimierung verwenden, die wird der interne Optimierungsmechanismus für lineares Lernen automatisch ausgeschaltet. Dadurch wird die Anzahl der parallelen Modelle, `num_models`, auf 1 festgelegt. Der Algorithmus ignoriert jeden Wert, den Sie für `num_models` festgelegt haben.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Mit dem linearen Learner-Algorithmus berechnete Metriken
Der Algorithmus für lineares Lernen meldet die Metriken in der folgenden Tabelle (berechnet während des Trainings). Wählen Sie eine dieser Metriken als objektive Metrik aus. Um Überanpassung zu vermeiden, empfehlen wir, das Modell anhand einer Validierungs- anstelle einer Trainingsmetrik zu optimieren.
| Metrikname | Description | Optimierungsrichtung |
| --- | --- | --- |
| test:absolute\$1loss | Der absolute Verlust des endgültigen Modells auf dem Testdatensatz. Diese objektive Metrik gilt nur für die Regression. | Minimieren |
| test:binary\$1classification\$1accuracy | Die Genauigkeit des endgültigen Modells im Testdatensatz. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| test:binary\$1f\$1beta | Der F-Betawert des endgültigen Modells für den Testdatensatz. Standardmäßig handelt es sich um die F1-Bewertung. Dies ist das harmonische Mittel von Genauigkeit und Wiedererkennung. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| test:dcg | Der abgezinste kumulative Gewinn des endgültigen Modells aus dem Testdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| test:macro\$1f\$1beta | Der F-Betawert des endgültigen Modells für den Testdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| test:macro\$1precision | Die Genauigkeit des endgültigen Modells für den Testdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| test:macro\$1recall | Der Recall-Wert des endgültigen Modells für den Testdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| test:mse | Der mittlere quadratische Fehler des endgültigen Modells für den Testdatensatz. Diese objektive Metrik gilt nur für die Regression. | Minimieren |
| test:multiclass\$1accuracy | Die Genauigkeit des endgültigen Modells im Testdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| test:multiclass\$1top\$1k\$1accuracy | Die Genauigkeit unter den obersten k Labels, die im Testdatensatz vorhergesagt wurde. Wenn Sie diese Metrik als Ziel wählen, empfehlen wir, den Wert von k mithilfe des `accuracy_top_k` Hyperparameters festzulegen. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| test:objective\$1loss | Der Mittelwert der objektiven Verlustfunktion im Testdatensatz, nachdem das Modell trainiert wurde. Standardmäßig ist der Verlust ein logistischer Verlust für die binäre Klassifikation und ein quadratischer Verlust für die Regression. Um den Verlust auf andere Typen festzulegen, verwenden Sie den `loss`-Hyperparameter. | Minimieren |
| test:precision | Die Präzision des endgültigen Modells im Testdatensatz. Wenn Sie diese Metrik als objektive Metrik auswählen, empfehlen wir Ihnen, einen Ziel-Recall festzulegen, indem Sie die `binary_classifier_model_selection`-Hyperparameter auf `precision_at_target_recall` festlegen und den Wert für den `target_recall`-Hyperparameter angeben. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| test:recall | Der Recall des endgültigen Modells im Testdatensatz. Wenn Sie diese Metrik als Ziel auswählen, empfehlen wir Ihnen, eine Zielpräzision festzulegen, indem Sie die Hyperparameter `binary_classifier_model_selection` auf `recall_at_target_precision` festlegen und den Wert für den Hyperparameter `target_precision` angeben. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| test:roc\$1auc\$1score | Die Fläche unter der Empfangskennlinie (ROC-Kurve) des endgültigen Modells auf dem Testdatensatz. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| validation:absolute\$1loss | Der absolute Verlust des endgültigen Modells auf dem Validierungsdatensatz. Diese objektive Metrik gilt nur für die Regression. | Minimieren |
| validation:binary\$1classification\$1accuracy | Die Genauigkeit des endgültigen Modells im Validierungsdatensatz. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| validation:binary\$1f\$1beta | Der F-Betawert des endgültigen Modells für den Validierungsdatensatz. Standardmäßig ist der F-Beta-Score der F1-Score, der das harmonische Mittel der `validation:precision` and `validation:recall` Metriken ist. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| validation:dcg | Der abgezinste kumulative Gewinn des endgültigen Modells aus dem Validierungsdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| validation:macro\$1f\$1beta | Der F-Betawert des endgültigen Modells für den Validierungsdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| validation:macro\$1precision | Die Genauigkeit des endgültigen Modells für den Validierungsdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| validation:macro\$1recall | Der Recall-Wert des endgültigen Modells für den Validierungsdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| validation:mse | Der mittlere quadratische Fehler des endgültigen Modells für den Validierungsdatensatz. Diese objektive Metrik gilt nur für die Regression. | Minimieren |
| validation:multiclass\$1accuracy | Die Genauigkeit des endgültigen Modells im Validierungsdatensatz. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| validation:multiclass\$1top\$1k\$1accuracy | Die Genauigkeit unter den obersten k Labels, die im Validierungsdatensatz vorhergesagt wurde. Wenn Sie diese Metrik als Ziel wählen, empfehlen wir, den Wert von k mithilfe des `accuracy_top_k` Hyperparameters festzulegen. Diese objektive Metrik ist nur für die Mehrklassen-Klassifizierung gültig. | Maximieren |
| validation:objective\$1loss | Der Mittelwert der objektiven Verlustfunktion im Validierungsdatensatz jeder Epoche. Standardmäßig ist der Verlust ein logistischer Verlust für die binäre Klassifikation und ein quadratischer Verlust für die Regression. Um den Verlust auf andere Typen festzulegen, verwenden Sie den `loss`-Hyperparameter. | Minimieren |
| validation:precision | Die Genauigkeit des endgültigen Modells im Validierungsdatensatz. Wenn Sie diese Metrik als objektive Metrik auswählen, empfehlen wir Ihnen, einen Ziel-Recall festzulegen, indem Sie die `binary_classifier_model_selection`-Hyperparameter auf `precision_at_target_recall` festlegen und den Wert für den `target_recall`-Hyperparameter angeben. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| validation:recall | Die Sensitivität des endgültigen Modells im Validierungsdatensatz. Wenn Sie diese Metrik als Ziel auswählen, empfehlen wir Ihnen, eine Zielpräzision festzulegen, indem Sie die Hyperparameter `binary_classifier_model_selection` auf `recall_at_target_precision` festlegen und den Wert für den Hyperparameter `target_precision` angeben. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
| validation:rmse | Der mittlere quadratische Fehler des endgültigen Modells für den Validierungsdatensatz. Diese objektive Metrik gilt nur für die Regression. | Minimieren |
| validation:roc\$1auc\$1score | Die Fläche unter der Empfangscharakteristikkurve (ROC-Kurve) des endgültigen Modells auf dem Validierungsdatensatz. Diese objektive Metrik ist nur für die binäre Klassifikation gültig. | Maximieren |
## Abstimmung von Hyperparametern für lineare Learner
Sie können ein Modell für lineares Lernen mit den folgenden Hyperparametern optimieren.
| Name des Parameters | Parametertyp | Empfohlene Bereiche |
| --- | --- | --- |
| wd | `ContinuousParameterRanges` | `MinValue: ``1e-7`, `MaxValue`: `1` |
| l1 | `ContinuousParameterRanges` | `MinValue`: `1e-7`, `MaxValue`: `1` |
| learning\$1rate | `ContinuousParameterRanges` | `MinValue`: `1e-5`, `MaxValue`: `1` |
| mini\$1batch\$1size | `IntegerParameterRanges` | `MinValue`: `100`, `MaxValue`: `5000` |
| use\$1bias | `CategoricalParameterRanges` | `[True, False]` |
| positive\$1example\$1weight\$1mult | `ContinuousParameterRanges` | `MinValue`: 1e-5, `MaxValue`: `1e5` |
# Antwortformate von linearen Learnern
## JSON-Antwortformat
Alle integrierten Algorithmen von Amazon SageMaker AI halten sich an das gemeinsame Eingabe-Inferenzformat, das unter [Common Data Formats — Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) beschrieben ist. Im Folgenden sind die verfügbaren Ausgabeformate für den SageMaker AI-Algorithmus für lineare Lernende aufgeführt.
**Binäre Klassifikation**
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
**Mehrklassen-Klassifizierung**
```
let response = {
"predictions": [
{
"score": [0.1, 0.2, 0.4, 0.3],
"predicted_label": 2
}
]
}
```
**Regression**
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## JSONLINES-Antwortformat
**Binäre Klassifikation**
```
{"score": 0.4, "predicted_label": 0}
```
**Mehrklassen-Klassifizierung**
```
{"score": [0.1, 0.2, 0.4, 0.3], "predicted_label": 2}
```
**Regression**
```
{"score": 0.4}
```
## RECORDIO-Antwortformat
**Binäre Klassifikation**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
**Mehrklassen-Klassifizierung**
```
[
Record = {
"features": [],
"label": {
"score": {
"values": [0.1, 0.2, 0.3, 0.4]
},
"predicted_label": {
"values": [3]
}
},
"uid": "abc123",
"metadata": "{created_at: '2017-06-03'}"
}
]
```
**Regression**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
}
}
}
]
```
# TabTransformer
[TabTransformer](https://arxiv.org/abs/2012.06678)ist eine neuartige tiefgründige tabellarische Datenmodellierungsarchitektur für überwachtes Lernen. Die TabTransformer Architektur basiert auf self-attention-based Transformers. Die Transformer-Ebenen wandeln die Einbettungen kategorischer Features in robuste kontextuelle Einbettungen um, um eine höhere Vorhersagegenauigkeit zu erreichen. Darüber hinaus TabTransformer sind die daraus gewonnenen kontextuellen Einbettungen äußerst robust gegenüber fehlenden und verrauschten Datenmerkmalen und bieten eine bessere Interpretierbarkeit. Diese Seite enthält Informationen zu Amazon EC2 EC2-Instance-Empfehlungen und Beispiel-Notebooks für TabTransformer.
# Wie benutzt man KI SageMaker TabTransformer
Sie können den integrierten Algorithmus von Amazon SageMaker AI verwenden TabTransformer . Im folgenden Abschnitt wird die Verwendung TabTransformer mit dem SageMaker Python-SDK beschrieben. Informationen zur Verwendung TabTransformer von der Amazon SageMaker Studio Classic-Benutzeroberfläche aus finden Sie unter[SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md).
+ ** TabTransformer Als integrierten Algorithmus verwenden**
Verwenden Sie den TabTransformer integrierten Algorithmus, um einen TabTransformer Trainingscontainer zu erstellen, wie im folgenden Codebeispiel gezeigt. Sie können den TabTransformer integrierten Algorithmus-Image-URI mithilfe der SageMaker `image_uris.retrieve` KI-API (oder der `get_image_uri` API, wenn Sie [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Version 2 verwenden) automatisch erkennen.
Nachdem Sie die TabTransformer Bild-URI angegeben haben, können Sie den TabTransformer Container verwenden, um mithilfe der SageMaker AI Estimator API einen Schätzer zu erstellen und einen Trainingsjob zu starten. Der TabTransformer integrierte Algorithmus wird im Skriptmodus ausgeführt, aber das Trainingsskript wird für Sie bereitgestellt und muss nicht ersetzt werden. Wenn Sie umfangreiche Erfahrung mit der Erstellung eines SageMaker Trainingsjobs im Skriptmodus haben, können Sie Ihre eigenen TabTransformer Trainingsskripte integrieren.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "pytorch-tabtransformerclassification-model", "*", "training"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_binary/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"n_epochs"
] = "50"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Weitere Informationen dazu, wie Sie den TabTransformer als integrierten Algorithmus einrichten, finden Sie in den folgenden Notebook-Beispielen.
+ [Tabellarische Klassifizierung mit dem Amazon SageMaker AI-Algorithmus TabTransformer](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb)
+ [Tabellarische Regression mit dem Amazon AI-Algorithmus SageMaker TabTransformer](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb)
# Eingabe- und Ausgabeschnittstelle für den Algorithmus TabTransformer
TabTransformer arbeitet mit Tabellendaten, wobei die Zeilen Beobachtungen, eine Spalte die Zielvariable oder Bezeichnung und die übrigen Spalten Merkmale darstellen.
Die SageMaker KI-Implementierung von TabTransformer unterstützt CSV für Training und Inferenz:
+ Für **Schulungen ContentType** müssen gültige Eingaben *text/csv* sein.
+ *Für **Inference ContentType** müssen gültige Eingaben text/csv sein.*
**Anmerkung**
Bei der CSV-Training geht der Algorithmus davon aus, dass die Zielvariable in der ersten Spalte zu finden ist und CSV keinen Header-Datensatz aufweist.
Bei der CSV-Inferenz geht der Algorithmus davon aus, dass die CSV-Eingabe keine Kennzeichnungsspalte hat.
**Eingabeformat für Trainingsdaten, Validierungsdaten und kategoriale Features**
Achten Sie darauf, wie Sie Ihre Trainingsdaten für die Eingabe in das Modell formatieren. TabTransformer Sie müssen den Pfad zu einem Amazon-S3-Bucket angeben, der Ihre Trainings- und Validierungsdaten enthält. Sie können auch eine Liste von kategorialen Funktionen einschließen. Verwenden Sie sowohl `training` als auch den `validation` Kanal, um Ihre Eingabedaten bereitzustellen. Alternativ können Sie aber auch nur den `training` Kanal verwenden.
**Verwenden Sie sowohl den `training` als auch den `validation` Kanal**
Sie können Ihre Eingabedaten über zwei S3-Pfade bereitstellen, einen für den `training` Kanal und einen für den `validation` Kanal. Jeder S3-Pfad kann entweder ein S3-Präfix sein, das auf eine oder mehrere CSV-Dateien verweist, oder ein vollständiger S3-Pfad, der auf eine bestimmte CSV-Datei verweist. Die Zielvariablen sollten sich in der ersten Spalte Ihrer CSV-Datei befinden. Die Prädiktorvariablen (Features) sollten sich in den verbleibenden Spalten befinden. Wenn mehrere CSV-Dateien für die `validation` Kanäle `training` oder bereitgestellt werden, verkettet der TabTransformer Algorithmus die Dateien. Die Validierungsdaten werden verwendet, um am Ende jeder Boosting-Iteration eine Validierungspunktzahl zu berechnen. Early-Stopping wird angewendet, wenn sich der Validierungsscore nicht mehr verbessert.
Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Trainingsdatendatei (en). Wenn Sie eine JSON-Datei für kategorische Features bereitstellen, muss Ihr `training`-Kanal auf ein S3-Präfix verweisen und nicht auf eine spezifische CSV-Datei. Diese Datei sollte ein Python-Wörterbuch enthalten, in dem der Schlüssel die Zeichenfolge `"cat_index_list"` und der Wert eine Liste eindeutiger Ganzzahlen ist. Jede Ganzzahl in der Werteliste sollte den Spaltenindex der entsprechenden kategorischen Features in Ihrer CSV-Datei mit Trainingsdaten angeben. Jeder Wert sollte eine positive Ganzzahl (größer als Null, weil Null den Zielwert darstellt), kleiner als `Int32.MaxValue` (2147483647) und kleiner als die Gesamtzahl der Spalten sein. Es sollte nur eine JSON-Datei mit dem kategorischen Index geben.
**Benutze nur den `training` Kanal**:
Sie können Ihre Eingabedaten alternativ über einen einzigen S3-Pfad für den `training` Kanal bereitstellen. Dieser S3-Pfad sollte auf ein Verzeichnis mit einem Unterverzeichnis mit dem Namen `training/` verweisen, das eine oder mehrere CSV-Dateien enthält. Sie können optional ein weiteres Unterverzeichnis am selben Speicherort namens `validation/` einschließen, das auch eine oder mehrere CSV-Dateien enthält. Wenn die Validierungsdaten nicht angegeben werden, werden 20% Ihrer Trainingsdaten nach dem Zufallsprinzip als Validierungsdaten ausgewählt. Wenn Ihre Predictors kategorische Features enthalten, können Sie eine JSON-Datei bereitstellen, die `categorical_index.json` an derselben Stelle benannt ist wie Ihre Datenunterverzeichnisse.
**Anmerkung**
Beim CSV-Trainingseingangsmodus muss der für den Algorithmus verfügbare Gesamtarbeitsspeicher (Instance-Zählung verfügbarer Arbeitsspeicher im `InstanceType`) in der Lage sein, den Trainingsdatensatz aufzunehmen.
## Amazon EC2 EC2-Instance-Empfehlung für den Algorithmus TabTransformer
SageMaker KI TabTransformer unterstützt Einzelinstanz-CPU- und Einzelinstanz-GPU-Training. Trotz der höheren Kosten pro Instanz sollten Sie schneller GPUs trainieren, was sie kostengünstiger macht. Um die Vorteile des GPU-Trainings zu nutzen, geben Sie den Instanztyp als eine der GPU-Instanzen an (z. B. P3). SageMaker KI unterstützt TabTransformer derzeit kein Multi-GPU-Training.
## TabTransformer Beispiel-Notizbücher
In der folgenden Tabelle sind verschiedene Beispielnotizbücher aufgeführt, die sich mit verschiedenen Anwendungsfällen des Amazon SageMaker TabTransformer AI-Algorithmus befassen.
****
| **Titel des Notebooks** | **Beschreibung** |
| --- | --- |
| [Tabellarische Klassifizierung mit dem Amazon SageMaker AI-Algorithmus TabTransformer ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker TabTransformer AI-Algorithmus zum Trainieren und Hosten eines tabellarischen Klassifikationsmodells. |
| [Tabellarische Regression mit dem Amazon AI-Algorithmus SageMaker TabTransformer ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb) | Dieses Notizbuch demonstriert die Verwendung des Amazon SageMaker TabTransformer AI-Algorithmus zum Trainieren und Hosten eines tabellarischen Regressionsmodells. |
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instances, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
# Wie TabTransformer funktioniert
TabTransformer ist eine neuartige tiefgründige tabellarische Datenmodellierungsarchitektur für überwachtes Lernen. Sie TabTransformer basiert auf Transformers, die auf Selbstaufmerksamkeit basieren. Die Transformer-Ebenen wandeln die Einbettungen kategorischer Features in robuste kontextuelle Einbettungen um, um eine höhere Vorhersagegenauigkeit zu erreichen. Darüber hinaus TabTransformer sind die daraus gewonnenen kontextuellen Einbettungen äußerst robust gegenüber fehlenden und verrauschten Datenmerkmalen und bieten eine bessere Interpretierbarkeit.
TabTransformer schneidet bei Wettbewerben im Bereich maschinelles Lernen aufgrund der robusten Verarbeitung einer Vielzahl von Datentypen, Beziehungen und Verteilungen sowie der Vielzahl von Hyperparametern, die Sie feinabstimmen können, gut ab. Sie können es TabTransformer für Regressions-, Klassifizierungs- (binär- und Mehrklassenprobleme) und Ranking-Probleme verwenden.
Das folgende Diagramm veranschaulicht die TabTransformer Architektur.
![\[Die Architektur von TabTransformer.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/tabtransformer_illustration.png)
Weitere Informationen finden Sie unter *[TabTransformer: Tabellarische Datenmodellierung mithilfe kontextueller](https://arxiv.org/abs/2012.06678)* Einbettungen.
# TabTransformer Hyperparameter
Die folgende Tabelle enthält die Teilmenge der Hyperparameter, die für den Amazon SageMaker TabTransformer AI-Algorithmus erforderlich sind oder am häufigsten verwendet werden. Dies sind Parameter, die von Benutzern festgelegt werden, um die Schätzung der Modellparameter aus Daten zu erleichtern. Der SageMaker TabTransformer KI-Algorithmus ist eine Implementierung des [TabTransformer](https://github.com/jrzaurin/pytorch-widedeep)Open-Source-Pakets.
**Anmerkung**
Die Standard-Hyperparameter basieren auf Beispieldatensätzen in der [TabTransformer Beispiel-Notizbücher](tabtransformer.md#tabtransformer-sample-notebooks).
Der SageMaker TabTransformer KI-Algorithmus wählt automatisch eine Bewertungsmetrik und eine Zielfunktion aus, die auf der Art des Klassifikationsproblems basieren. Der TabTransformer Algorithmus erkennt die Art des Klassifizierungsproblems anhand der Anzahl der Labels in Ihren Daten. Bei Regressionsproblemen ist die Bewertungsmetrik das Quadrat r und die Zielfunktion der quadratische Mittelwert. Bei binären Klassifikationsproblemen entsprechen die Bewertungsmetrik und die Zielfunktion beide der binären Kreuzentropie. Bei Klassifikationsproblemen mit mehreren Klassen entsprechen die Bewertungsmetrik und die Zielfunktion beide einer Mehrklassen-Kreuzentropie.
**Anmerkung**
Die Funktionen TabTransformer Bewertungsmetrik und Zielsetzung sind derzeit nicht als Hyperparameter verfügbar. Stattdessen erkennt der TabTransformer integrierte SageMaker KI-Algorithmus anhand der Anzahl der eindeutigen Ganzzahlen in der Labelspalte automatisch die Art der Klassifikationsaufgabe (Regression, Binär oder Mehrklassenfunktion) und weist eine Bewertungsmetrik und eine Zielfunktion zu.
| Name des Parameters | Description |
| --- | --- |
| n\$1epochs | Anzahl der Epochen, in denen das tiefe neuronale Netzwerk trainiert werden soll. Gültige Werte: Ganzzahl, Bereich: Positive Ganzzahl. Standardwert: `5`. |
| patience | Das Training wird beendet, wenn sich eine Metrik eines Validierungsdatenpunkts in der letzten `patience` Runde nicht verbessert hat. Gültige Werte: Ganzzahl, Bereich: (`2`,`60`). Standardwert: `10`. |
| learning\$1rate | Die Geschwindigkeit, mit der die Modellgewichte aktualisiert werden, nachdem die einzelnen Trainingsbeispiele durchgearbeitet wurden. Gültige Werte: float, range: Positive float. Standardwert: `0.001`. |
| batch\$1size | Die Anzahl der Beispiele, die im Netzwerk verbreitet wurden. Gültige Werte: Ganzzahl, Bereich: (`1`,`2048`). Standardwert: `256`. |
| input\$1dim | Die Dimension der Einbettungen zur Kodierung der kategorialen und/oder kontinuierlichen Spalten. Gültige Werte: String, einer der folgenden Werte:`"16"`, `"32"`, `"64"`, `"128"`, `"256"`, or `"512"`. Standardwert: `"32"`. |
| n\$1blocks | Die Anzahl der Transformer-Encoder-Blöcke. Gültige Werte: Ganzzahl, Bereich: (`1`,`12`). Standardwert: `4`. |
| attn\$1dropout | Die Dropout-Rate wurde auf die Multi-Head Attention-Ebenen angewendet. Gültige Werte: Float, Bereich: (`0`, `1`). Standardwert: `0.2`. |
| mlp\$1dropout | Die Dropout-Rate wird auf das FeedForward Netzwerk innerhalb der Encoder-Schichten und der letzten MLP-Schichten über den Transformer-Encodern angewendet. Gültige Werte: Float, Bereich: (`0`, `1`). Standardwert: `0.1`. |
| frac\$1shared\$1embed | Der Anteil der Einbettungen, die sich alle verschiedenen Kategorien für eine bestimmte Spalte teilen. Gültige Werte: Float, Bereich: (`0`, `1`). Standardwert: `0.25`. |
# Optimieren Sie ein Modell TabTransformer
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Die Modelloptimierung konzentriert sich auf die folgenden Hyperparameter:
**Anmerkung**
Die Lernzielfunktion und die Bewertungsmetrik werden beide automatisch auf der Grundlage der Art der Klassifikationsaufgabe zugewiesen, die durch die Anzahl der eindeutigen Ganzzahlen in der Beschriftungspalte bestimmt wird. Weitere Informationen finden Sie unter [TabTransformer Hyperparameter](tabtransformer-hyperparameters.md).
+ Eine Lernzielfunktion zur Optimierung beim Modelltraining
+ Eine Bewertungsmetrik, die verwendet wird, um die Modellleistung während der Validierung zu bewerten
+ Ein Satz von Hyperparametern und ein Wertebereich für jeden, der bei der automatischen Abstimmung des Modells verwendet werden kann
Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.
**Anmerkung**
Die automatische Modelloptimierung für TabTransformer ist nur bei Amazon verfügbar SageMaker SDKs, nicht über die SageMaker KI-Konsole.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Vom Algorithmus berechnete Bewertungsmetriken TabTransformer
Der SageMaker TabTransformer KI-Algorithmus berechnet die folgenden Metriken, die für die Modellvalidierung verwendet werden sollen. Die Bewertungsmetrik wird automatisch auf der Grundlage der Art der Klassifizierungsaufgabe zugewiesen, die durch die Anzahl der eindeutigen Ganzzahlen in der Beschriftungspalte bestimmt wird.
| Metrikname | Description | Optimierungsrichtung | Regex-Muster |
| --- | --- | --- | --- |
| r2 | Oder quadratisch | Maximieren | "metrics=\$1'r2': (\$1\$1S\$1)\$1" |
| f1\$1score | Binärkreuzentropie | Maximieren | "metrics=\$1'f1': (\$1\$1S\$1)\$1" |
| accuracy\$1score | Kreuzentropie mit mehreren Klassen | Maximieren | "metrics=\$1'accuracy': (\$1\$1S\$1)\$1" |
## Einstellbare Hyperparameter TabTransformer
Optimieren Sie das TabTransformer Modell mit den folgenden Hyperparametern. Die Hyperparameter, die den größten Einfluss auf die Optimierung der TabTransformer Bewertungsmetriken haben, sind:`learning_rate`,`input_dim`,`n_blocks`, `attn_dropout``mlp_dropout`, und. `frac_shared_embed` Eine Liste aller TabTransformer Hyperparameter finden Sie unter. [TabTransformer Hyperparameter](tabtransformer-hyperparameters.md)
| Name des Parameters | Parametertyp | Empfohlene Bereiche |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| input\$1dim | CategoricalParameterRanges | [16, 32, 64, 128, 256, 512] |
| n\$1blocks | IntegerParameterRanges | MinValue: 1, MaxValue: 12 |
| attn\$1dropout | ContinuousParameterRanges | MinValue: 0,0, MaxValue: 0,8 |
| mlp\$1dropout | ContinuousParameterRanges | MinValue: 0,0, MaxValue: 0,8 |
| frac\$1shared\$1embed | ContinuousParameterRanges | MinValue: 0,0, MaxValue: 0,5 |
# XGBoost Algorithmus mit Amazon SageMaker AI
Das [XGBoost](https://github.com/dmlc/xgboost)(eXtreme Gradient Boosting) ist eine beliebte und effiziente Open-Source-Implementierung des Gradient Boosted Trees-Algorithmus. Gradient Boosting ist ein überwachter Lernalgorithmus, der versucht, eine Zielvariable genau vorherzusagen, indem mehrere Schätzungen aus einer Menge einfacherer Modelle kombiniert werden. Der XGBoost Algorithmus schneidet bei Wettbewerben im Bereich maschinelles Lernen aus den folgenden Gründen gut ab:
+ Er bietet einen robusten Umgang mit einer Vielzahl von Datentypen, Beziehungen und Verteilungen.
+ Er ermöglicht die Optimierung einer Vielzahl von Hyperparametern.
Sie können ihn XGBoost für Regressions-, Klassifizierungs- (binär- und Mehrklassenprobleme) und Ranking-Probleme verwenden.
Sie können die neue Version des XGBoost Algorithmus wie folgt verwenden:
+ Ein in Amazon SageMaker AI integrierter Algorithmus.
+ als Framework zum Ausführen von Trainingsskripten in Ihren lokalen Umgebungen.
Diese Implementierung bietet einen kleineren Speicherbedarf, eine bessere Protokollierung, eine verbesserte Hyperparameter-Validierung und einen größeren Satz von Metriken als die ursprünglichen Versionen. Es bietet einen XGBoost `estimator`, der ein Trainingsskript in einer verwalteten XGBoost Umgebung ausführt. Die aktuelle Version von SageMaker AI XGBoost basiert auf den XGBoost Originalversionen 1.0, 1.2, 1.3, 1.5, 1.7 und 3.0.
Weitere Informationen zum Amazon SageMaker XGBoost AI-Algorithmus finden Sie in den folgenden Blogbeiträgen:
+ [Vorstellung des Open-Source-Containers für Amazon SageMaker XGBoost AI-Algorithmen](https://aws.amazon.com/blogs/machine-learning/introducing-the-open-source-amazon-sagemaker-xgboost-algorithm-container/)
+ [Amazon SageMaker AI bietet XGBoost jetzt vollständig verteiltes GPU-Training](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-xgboost-now-offers-fully-distributed-gpu-training/)
## Unterstützte Versionen
Weitere Informationen finden Sie in unseren [Support-Richtlinien](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-support-policy.html#pre-built-containers-support-policy-ml-framework).
+ Framework-Modus (Open Source): 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1, 3.0-5
+ Algorithmusmodus: 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1, 3.0-5
**Warnung**
Aufgrund der erforderlichen Rechenkapazität ist Version 3.0-5 von SageMaker AI zu Trainings- oder Inferenzzwecken nicht mit GPU-Instances aus der XGBoost P3-Instanzfamilie kompatibel.
**Warnung**
Aufgrund der Paketkompatibilität unterstützt Version 3.0-5 von SageMaker AI keinen Debugger. XGBoost SageMaker
**Warnung**
Aufgrund der erforderlichen Rechenkapazität XGBoost ist Version 1.7-1 von SageMaker AI nicht mit GPU-Instances aus der P2-Instanzfamilie für Trainings- oder Inferenzzwecke kompatibel.
**Warnung**
Netzwerkisolationsmodus: Führen Sie kein Upgrade von Pip über Version 25.2 hinaus durch. Neuere Versionen versuchen möglicherweise, während der Modulinstallation Setuptools von PyPI abzurufen.
**Wichtig**
Wenn Sie den SageMaker XGBoost AI-Image-URI abrufen, verwenden Sie nicht `:latest` oder `:1` für das Image-URI-Tag. Sie müssen einen der Container angeben[Unterstützte Versionen](#xgboost-supported-versions), um den SageMaker KI-verwalteten XGBoost Container mit der nativen XGBoost Paketversion auszuwählen, die Sie verwenden möchten. Informationen zur Paketversion, die in die SageMaker XGBoost AI-Container migriert wurde, finden Sie unter [Docker-Registrierungspfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html). Wählen Sie dann Ihre AWS-Region aus und navigieren Sie zum Abschnitt **XGBoost (Algorithmus)**.
**Warnung**
Die Versionen XGBoost 0.90 sind veraltet. Die Unterstützung für Sicherheitsupdates oder Bugfixes für XGBoost 0.90 wurde eingestellt. Wir empfehlen dringend, dass Sie die XGBoost Version auf eine der neueren Versionen aktualisieren.
**Anmerkung**
XGBoost v1.1 wird auf SageMaker KI nicht unterstützt. XGBoost 1.1 hat eine defekte Fähigkeit, Vorhersagen auszuführen, wenn die Testeingabe weniger Merkmale aufweist als die Trainingsdaten in den LIBSVM-Eingaben. Diese Fähigkeit wurde in XGBoost Version 1.2 wiederhergestellt. Erwägen Sie die Verwendung von SageMaker AI XGBoost 1.2-2 oder höher.
**Anmerkung**
Sie können XGBoost v1.0-1 verwenden, aber es wird nicht offiziell unterstützt.
## Empfehlung für eine EC2-Instanz für den Algorithmus XGBoost
SageMaker KI XGBoost unterstützt CPU- und GPU-Training und Inferenz. Die Instanzempfehlungen hängen von den Schulungs- und Inferenzanforderungen sowie von der Version des XGBoost Algorithmus ab. Wählen Sie eine der folgenden Optionen aus, um mehr Informationen zu erhalten:
+ [CPU-Training](#Instance-XGBoost-training-cpu)
+ [GPU-Training](#Instance-XGBoost-training-gpu)
+ [Verteilte GPU-Training](#Instance-XGBoost-distributed-training-cpu)
+ [Verteiltes GPU-Training](#Instance-XGBoost-distributed-training-gpu)
+ [Inferenz](#Instance-XGBoost-inference)
### Training
Der SageMaker XGBoost KI-Algorithmus unterstützt CPU- und GPU-Training.
#### CPU-Training
SageMaker AI XGBoost 1.0-1 oder früher trainiert nur mit. CPUs Es handelt sich um einen speichergebundenen Algorithmus (im Gegensatz zu einem rechnergebundenen). Daher ist eine Allzweck-Datenverarbeitungs-Instance (z. B. M5) die bessere Wahl gegenüber einer rechneroptimierten Instance (z. B. C4). Des Weiteren empfehlen wir, dass Sie in ausgewählten Instances genügend Gesamtspeicher zur Verfügung haben, um das Trainingsdaten aufzunehmen. Diese Version unterstützt die Verwendung von Festplattenspeicher zur Verarbeitung von Daten, die nicht in den Hauptspeicher passen. Dies ist ein Ergebnis der out-of-core Funktion, die im libsvm-Eingabemodus verfügbar ist. Trotzdem verlangsamt das Schreiben von Cache-Dateien auf die Festplatte die Verarbeitungszeit des Algorithmus.
#### GPU-Training
SageMaker XGBoost AI-Version 1.2-2 oder höher unterstützt GPU-Training. Trotz der höheren Kosten pro Instanz sollten Sie schneller GPUs trainieren, was sie kostengünstiger macht.
SageMaker XGBoost Die KI-Version 1.2-2 oder höher unterstützt die GPU-Instanzfamilien P2, P3, G4dn und G5.
SageMaker XGBoost AI-Version 1.7-1 oder höher unterstützt die GPU-Instanzfamilien P3, G4dn und G5. Beachten Sie, dass Version 1.7-1 oder höher aufgrund von Rechenkapazitätsanforderungen die P2-Instance-Familie nicht unterstützt.
SageMaker XGBoost AI-Version 3.0-5 oder höher unterstützt die G4dn- und G5-GPU-Instanzfamilien. Beachten Sie, dass Version 3.0-5 oder höher aufgrund von Anforderungen an die Rechenkapazität die P3-Instance-Familie nicht unterstützt.
So nutzen Sie die Vorteile des GPU-Trainings:
+ Geben Sie den Instanztyp als eine der GPU-Instanzen an (z. B. G4dn)
+ Stellen Sie den `tree_method` Hyperparameter in Ihrem vorhandenen Skript `gpu_hist` auf ein XGBoost
### Verteilte Trainings
SageMaker KI XGBoost unterstützt CPU- und GPU-Instanzen für verteiltes Training.
#### Verteilte GPU-Training
Um das CPU-Training auf mehreren Instances auszuführen, setzen Sie den `instance_count` Parameter für die Schätzfunktion auf einen Wert größer als eins. Die Eingabedaten müssen auf die Gesamtzahl der Instances aufgeteilt werden.
##### Teilen Sie die Eingabedaten auf mehrere Instances auf
Teilen Sie die Eingabedaten mithilfe der folgenden Schritte auf:
1. Teilen Sie die Eingabedaten in kleinere Dateien auf. Die Anzahl der Dateien sollte mindestens der Anzahl der Instances entsprechen, die für verteilte Trainings verwendet werden. Durch die Verwendung mehrerer kleinerer Dateien im Gegensatz zu einer großen Datei wird auch die Zeit für das Herunterladen von Daten für den Trainingsauftrag verringert.
1. Stellen Sie bei der Erstellung Ihres [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)den Verteilungsparameter auf ein`ShardedByS3Key`. Jede Instance erhält ungefähr *1/n* der Anzahl der Dateien in S3, wenn im Trainingsjob *n* Instances angegeben sind.
#### Verteiltes GPU-Training
Sie können verteilte Trainings entweder mit einer oder mehreren GPU-Instances verwenden.
**Verteiltes Training mit Einzel-GPU-Instances **
SageMaker Die XGBoost KI-Versionen 1.2-2 bis 1.3-1 unterstützen nur Einzel-GPU-Instanztraining. Das bedeutet, dass selbst wenn Sie eine Multi-GPU-Instance auswählen, nur eine GPU pro Instance verwendet wird.
In folgenden Fällen müssen Sie Ihre Eingabedaten auf die Gesamtzahl der Instances aufteilen:
+ Sie verwenden die XGBoost Versionen 1.2-2 bis 1.3-1.
+ Sie benötigen keine Multi-GPU-Instances.
Weitere Informationen finden Sie unter [Teilen Sie die Eingabedaten auf mehrere Instances auf](#Instance-XGBoost-distributed-training-divide-data).
**Anmerkung**
Die Versionen 1.2-2 bis 1.3-1 von SageMaker AI verwenden XGBoost nur eine GPU pro Instanz, auch wenn Sie eine Multi-GPU-Instanz wählen.
**Verteilte Trainings mit Einzel-GPU-Instances **
[Ab Version 1.5-1 XGBoost bietet SageMaker AI verteiltes GPU-Training mit Dask an.](https://www.dask.org/) Mit Dask können Sie alle nutzen, GPUs wenn Sie eine oder mehrere Multi-GPU-Instanzen verwenden. Dask funktioniert auch bei der Verwendung von Single-GPU-Instances.
Trainieren Sie mit Dask und gehen Sie dazu wie folgt vor:
1. Lassen Sie den `distribution` Parameter entweder in Ihrem weg [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)oder setzen Sie ihn auf. `FullyReplicated`
1. Stellen Sie bei der Definition Ihrer Hyperparameter `use_dask_gpu_training` bis `"true"` ein.
**Wichtig**
Das verteilte Training mit Dask unterstützt nur die Eingabeformate CSV und Parquet. Wenn Sie andere Datenformate wie LIBSVM oder PROTOBUF verwenden, schlägt der Trainingsauftrag fehl.
Stellen Sie bei Parquet-Daten sicher, dass die Spaltennamen als Zeichenfolgen gespeichert werden. Spalten, die Namen anderer Datentypen haben, können nicht geladen werden.
**Wichtig**
Das verteilte Training mit Dask unterstützt den Pipe-Modus nicht. Wenn der Pipe-Modus angegeben ist, schlägt der Trainingsauftrag fehl.
Beim SageMaker KI-Training XGBoost mit Dask sind einige Überlegungen zu beachten. Achten Sie darauf, Ihre Daten in kleinere Dateien aufzuteilen. Dask liest jede Parquet-Datei als Partition. Für jede GPU gibt es einen Dask-Worker. Daher sollte die Anzahl der Dateien größer sein als die Gesamtzahl von GPUs (Anzahl der Instanzen x Anzahl GPUs pro Instanz). Eine sehr große Anzahl von Dateien kann auch die Leistung beeinträchtigen. Weitere Informationen finden Sie unter [Bewährte Methoden für Dask](https://docs.dask.org/en/stable/best-practices.html).
#### Variationen in der Ausgabe
Der angegebene `tree_method` Hyperparameter bestimmt den Algorithmus, der für das XGBoost Training verwendet wird. Bei den Baummethoden `approx`, `hist` und `gpu_hist` handelt es sich allesamt um Näherungsmethoden, bei denen das Skizzieren zur Quantilberechnung verwendet wird. Weitere Informationen finden Sie in der XGBoost Dokumentation unter [Tree Methods](https://xgboost.readthedocs.io/en/stable/treemethod.html). Beim Skizzieren handelt es sich um einen Näherungsalgorithmus. Daher ist mit Abweichungen im Modell zu rechnen, die von Faktoren wie der Anzahl der Mitarbeiter abhängen, die für verteilte Trainings ausgewählt wurden. Die Signifikanz der Variation ist datenabhängig.
### Inferenz
SageMaker AI XGBoost unterstützt CPU- und GPU-Instanzen für Inferenz. Informationen zu den Instance-Typen für Inferenz finden Sie unter [Amazon SageMaker AI ML Instance Types](https://aws.amazon.com/sagemaker/pricing/).
# Wie benutzt man KI SageMaker XGBoost
Mit SageMaker KI können Sie ihn XGBoost als integrierten Algorithmus oder Framework verwenden. XGBoost Als Framework haben Sie mehr Flexibilität und Zugriff auf komplexere Szenarien, da Sie Ihre eigenen Trainingsskripte anpassen können. In den folgenden Abschnitten wird die Verwendung XGBoost mit dem SageMaker Python-SDK und der input/output Schnittstelle für den XGBoost Algorithmus beschrieben. Informationen zur Verwendung XGBoost von der Amazon SageMaker Studio Classic-Benutzeroberfläche aus finden Sie unter[SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md).
**Topics**
+ [XGBoost Als Framework verwenden](#xgboost-how-to-framework)
+ [XGBoost Als integrierten Algorithmus verwenden](#xgboost-how-to-built-in)
+ [Eingabe-/Ausgabeschnittstelle für den Algorithmus XGBoost](#InputOutput-XGBoost)
## XGBoost Als Framework verwenden
Verwenden Sie es XGBoost als Framework, um Ihre benutzerdefinierten Schulungsskripte auszuführen, die zusätzliche Datenverarbeitung in Ihre Trainingsaufgaben integrieren können. Im folgenden Codebeispiel stellt das SageMaker Python-SDK die XGBoost API als Framework bereit. Dies funktioniert ähnlich wie SageMaker KI andere Frameworks wie APIs TensorFlow MXNet, und bereitstellt PyTorch.
```
import boto3
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput
# initialize hyperparameters
hyperparameters = {
"max_depth":"5",
"eta":"0.2",
"gamma":"4",
"min_child_weight":"6",
"subsample":"0.7",
"verbosity":"1",
"objective":"reg:squarederror",
"num_round":"50"}
# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-framework'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-framework')
# construct a SageMaker AI XGBoost estimator
# specify the entry_point to your xgboost training script
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py",
framework_version='1.7-1',
hyperparameters=hyperparameters,
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.m5.2xlarge',
output_path=output_path)
# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```
Ein end-to-end Beispiel für die Verwendung von SageMaker KI XGBoost als Framework finden Sie unter [Regression with Amazon SageMaker AI XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone_dist_script_mode.html).
## XGBoost Als integrierten Algorithmus verwenden
Verwenden Sie den XGBoost integrierten Algorithmus, um einen XGBoost Trainingscontainer zu erstellen, wie im folgenden Codebeispiel gezeigt. Mithilfe der `image_uris.retrieve` AI-API können Sie den XGBoost integrierten SageMaker Bild-URI des Algorithmus automatisch erkennen. Wenn Sie [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Version 1 verwenden, verwenden Sie die `get_image_uri` API. Um sicherzustellen, dass die `image_uris.retrieve` API den richtigen URI findet, siehe [Allgemeine Parameter für integrierte Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html). Suchen Sie dann in `xgboost` der vollständigen Liste der integrierten Algorithmus-Images URIs und der verfügbaren Regionen nach.
Nachdem Sie die XGBoost Bild-URI angegeben haben, verwenden Sie den XGBoost Container, um mithilfe der SageMaker AI Estimator-API einen Schätzer zu erstellen und einen Trainingsjob zu starten. Dieser XGBoost integrierte Algorithmusmodus beinhaltet kein eigenes XGBoost Trainingsskript und wird direkt auf den Eingabedatensätzen ausgeführt.
**Wichtig**
Verwenden Sie beim Abrufen der SageMaker XGBoost AI-Bild-URI nicht `:latest` oder `:1` für das Bild-URI-Tag. Sie müssen einen der Container angeben[Unterstützte Versionen](xgboost.md#xgboost-supported-versions), um den SageMaker KI-verwalteten XGBoost Container mit der nativen XGBoost Paketversion auszuwählen, die Sie verwenden möchten. Informationen zur Paketversion, die in die SageMaker XGBoost AI-Container migriert wurde, finden Sie unter [Docker-Registrierungspfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html). Wählen Sie dann Ihre AWS-Region aus und navigieren Sie zum Abschnitt **XGBoost(Algorithmus)**.
```
import sagemaker
import boto3
from sagemaker import image_uris
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput
# initialize hyperparameters
hyperparameters = {
"max_depth":"5",
"eta":"0.2",
"gamma":"4",
"min_child_weight":"6",
"subsample":"0.7",
"objective":"reg:squarederror",
"num_round":"50"}
# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-built-in-algo'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-built-in-algo')
# this line automatically looks for the XGBoost image URI and builds an XGBoost container.
# specify the repo_version depending on your preference.
xgboost_container = sagemaker.image_uris.retrieve("xgboost", region, "1.7-1")
# construct a SageMaker AI estimator that calls the xgboost-container
estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container,
hyperparameters=hyperparameters,
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.m5.2xlarge',
volume_size=5, # 5 GB
output_path=output_path)
# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```
Weitere Informationen dazu, wie Sie den XGBoost als integrierten Algorithmus einrichten, finden Sie in den folgenden Notebook-Beispielen.
+ [Verwaltetes Spot-Training für XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_managed_spot_training.html)
+ [Regression mit Amazon SageMaker AI XGBoost (Parquet-Eingabe)](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_parquet_input_training.html)
## Eingabe-/Ausgabeschnittstelle für den Algorithmus XGBoost
Gradient Boosting arbeitet mit tabellarischen Daten, wobei die Zeilen die Beobachtungen repräsentieren, eine Spalte die Zielvariable oder die Kennzeichnung darstellt und die verbleibenden Spalten die Funktionen.
Die SageMaker KI-Implementierung von XGBoost unterstützt die folgenden Datenformate für Training und Inferenz:
+ *text/libsvm* (Standard)
+ *text/csv*
+ *application/x-parquet*
+ *Anwendung/ x-recordio-protobuf*
**Anmerkung**
In Bezug auf Training und Inferenz sind einige Überlegungen zu beachten:
Für eine höhere Leistung empfehlen wir die Verwendung XGBoost mit dem *Dateimodus*, in dem Ihre Daten aus Amazon S3 auf den Volumes der Trainingsinstanz gespeichert werden.
Für Trainings mit spaltenförmiger Eingabe geht der Algorithmus davon aus, dass es sich bei der Zielvariablen (Label) um die erste Spalte handelt. Bei der Inferenz geht der Algorithmus davon aus, dass die Eingabe keine Kennzeichnungsspalte hat.
Bei CSV-Daten sollte die Eingabe keinen Header-Datensatz enthalten.
Für das LIBSVM-Training geht der Algorithmus davon aus, dass die nachfolgenden Spalten nach der Labelspalte die auf Null basierenden Indexwertpaare für Features enthalten. Folglich hat jede Zeile das Format: :