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.
# Trainieren eines Modells
In diesem Schritt wählen Sie einen Trainingsalgorithmus aus und führen einen Trainingsjob für das Modell aus. Das [ Amazon SageMaker Python SDK ](https://sagemaker.readthedocs.io/en/stable) bietet Kurse, mit denen Sie Ihr Modell trainieren und gleichzeitig den Lebenszyklus des maschinellen Lernens (ML) orchestrieren und auf die SageMaker KI-Funktionen für das Training und die AWS Infrastrukturen wie Amazon Elastic Container Registry (Amazon ECR), Amazon Elastic Compute Cloud (Amazon EC2) und Amazon Simple Storage Service (Amazon S3) zugreifen können. Weitere Informationen zu integrierten Algorithmen finden Sie unter [Built-in Algorithmen und vortrainierte Modelle in Amazon SageMaker](algos.md).
**Topics**
+ [Auswählen des Trainingsalgorithmus](#ex1-train-model-select-algorithm)
+ [Erstellen und Ausführen eines Trainingsauftrags](#ex1-train-model-sdk)
## Auswählen des Trainingsalgorithmus
Um den richtigen Algorithmus für Ihren Datensatz auszuwählen, müssen Sie in der Regel verschiedene Modelle auswerten, um die für Ihre Daten am besten geeigneten Modelle zu finden. Der Einfachheit halber wird in diesem Tutorial der [XGBoost-Algorithmus mit Amazon AI SageMaker](xgboost.md) integrierte SageMaker KI-Algorithmus verwendet, ohne dass Modelle vorab evaluiert werden müssen.
**Tipp**
Wenn Sie möchten, dass SageMaker KI ein geeignetes Modell für Ihren tabellarischen Datensatz findet, verwenden Sie Amazon SageMaker Autopilot, das eine maschinelle Lernlösung automatisiert. Weitere Informationen finden Sie unter [SageMaker Autopilot](autopilot-automate-model-development.md).
## Erstellen und Ausführen eines Trainingsauftrags
Nachdem Sie herausgefunden haben, welches Modell Sie verwenden sollten, beginnen Sie mit der Erstellung eines Trainingsjobs. Dieses Tutorial verwendet den eingebauten XGBoost-Algorithmus.
**So führen Sie einen Modelltrainingsauftrag aus**
1. Importieren Sie das [ Amazon SageMaker Python SDK ](https://sagemaker.readthedocs.io/en/stable) und rufen Sie zunächst die grundlegenden Informationen aus Ihrer aktuellen SageMaker AI-Sitzung ab.
```
from sagemaker.core.helper.session_helper import Session, get_execution_role
sagemaker_session = Session()
region = sagemaker_session.boto_region_name
print(f"AWS Region: {region}")
role = get_execution_role()
print(f"RoleArn: {role}")
```
**Anmerkung**
Überprüfen Sie die SageMaker Python-SDK-Version, indem Sie Folgendes ausführen`sagemaker.__version__`. Dieses Tutorial basiert auf `sagemaker>=3.0`. Wenn das SDK veraltet ist, installieren Sie die neueste Version, indem Sie den folgenden Befehl ausführen:
```
! pip install -qU sagemaker
```
Wenn Sie diese Installation in Ihren vorhandenen SageMaker Studio- oder Notebook-Instanzen ausführen, müssen Sie den Kernel manuell aktualisieren, um die Installation des Versionsupdates abzuschließen.
Dies gibt folgende Informationen zurück:
+ `region`— Die aktuelle AWS Region, in der die SageMaker AI-Notebook-Instanz ausgeführt wird.
+ `role` – Die von der Notebook-Instance verwendete IAM-Rolle.
1. Erstellen Sie eine Trainingskonfiguration und legen Sie Hyperparameter für den XGBoost-Algorithmus fest.
Erstellen Sie eine, `ModelTrainer` indem Sie die `sagemaker.train.ModelTrainer` Klasse mit Hyperparametern verwenden, die direkt im Konstruktor übergeben werden. Im folgenden Beispielcode ModelTrainer ist der benannt. `xgb_model_trainer`
```
from sagemaker.train import ModelTrainer
from sagemaker.train.configs import Compute, OutputDataConfig
from sagemaker.core import image_uris
s3_output_location='s3://{}/{}/{}'.format(bucket, prefix, 'xgboost_model')
container = image_uris.retrieve("xgboost", region, "1.2-1")
print(container)
compute = Compute(
instance_type='ml.m4.xlarge',
instance_count=1,
volume_size_in_gb=5
)
xgb_model_trainer = ModelTrainer(
training_image=container,
role=role,
compute=compute,
output_data_config=OutputDataConfig(s3_output_path=s3_output_location),
hyperparameters={
"max_depth": "5",
"eta": "0.2",
"gamma": "4",
"min_child_weight": "6",
"subsample": "0.7",
"objective": "binary:logistic",
"num_round": "1000"
}
)
```
Um die SageMaker KI zu konstruieren`ModelTrainer`, geben Sie die folgenden Parameter an:
+ `training_image` – Geben Sie den Image-URI des Trainingscontainers an. In diesem Beispiel wird der SageMaker AI XGBoost-Trainingscontainer-URI mit angegeben. `image_uris.retrieve`
+ `role`— Die AWS Identity and Access Management (IAM-) Rolle, die SageMaker KI verwendet, um Aufgaben in Ihrem Namen auszuführen (z. B. das Lesen von Trainingsergebnissen, das Aufrufen von Modellartefakten aus Amazon S3 und das Schreiben von Trainingsergebnissen in Amazon S3).
+ `compute`— Ein `Compute` Konfigurationsobjekt, das den Typ und die Anzahl der Amazon EC2 ML-Recheninstanzen angibt, die für das Modelltraining verwendet werden sollen. Für diese Trainingsübung verwenden Sie eine einzelne `ml.m4.xlarge` Instance mit 4 CPUs, 16 GB Arbeitsspeicher, einem Amazon Elastic Block Store (Amazon EBS)-Speicher und einer hohen Netzwerkleistung. Weitere Informationen zu EC2-Rechen-Instance-Typen finden Sie unter [Amazon-EC2-Instance-Typen](https://aws.amazon.com/ec2/instance-types/). Weitere Informationen zur Abrechnung finden Sie unter [ SageMaker Amazon-Preise](https://aws.amazon.com/sagemaker/pricing/).
+ `hyperparameters`— Ein Wörterbuch mit Hyperparametern für den Trainingsalgorithmus. Alle Werte müssen Zeichenketten sein.
**Tipp**
Wenn Sie große Deep-Learning-Modelle wie CNN- (Convolutional Neural Networks) und NLP-Modelle (Natural Language Processing) verteilt trainieren möchten, verwenden Sie SageMaker AI Distributed für Daten- oder Modellparallelität. Weitere Informationen finden Sie unter [Verteilte Schulung in Amazon SageMaker AI](distributed-training.md).
**Tipp**
Sie können die Hyperparameter auch mithilfe der KI-Funktion zur Hyperparameter-Optimierung optimieren. SageMaker Weitere Informationen finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
1. Konfigurieren Sie die Dateneingabe für das Training.
Verwenden Sie die `InputData` Klasse, um einen Dateneingabefluss für das Training zu konfigurieren. Der folgende Beispielcode zeigt, wie Sie `InputData` Objekte für die Verwendung der Trainings- und Validierungsdatensätze konfigurieren, die Sie im [Teilen Sie den Datensatz in Trainings-, Validierungs- und Testdatensätze auf](ex1-preprocess-data.md#ex1-preprocess-data-transform) Abschnitt auf Amazon S3 hochgeladen haben.
```
from sagemaker.train.configs import InputData
train_input = InputData(
channel_name="train",
data_source="s3://{}/{}/{}".format(bucket, prefix, "data/train.csv")
)
validation_input = InputData(
channel_name="validation",
data_source="s3://{}/{}/{}".format(bucket, prefix, "data/validation.csv")
)
```
1. Starten Sie das Modelltraining.
Um das Modelltraining zu starten, rufen Sie die `train` Methode des Trainers mit den Trainings- und Validierungsdatensätzen auf. Standardmäßig zeigt die `train` Methode Fortschrittsprotokolle an und wartet, bis das Training abgeschlossen ist.
```
xgb_model_trainer.train(input_data_config=[train_input, validation_input])
```
Weitere Informationen zum Modelltraining finden Sie unter [Trainiere ein Modell mit Amazon SageMaker](how-it-works-training.md). Dieser Tutorial-Trainingsjob kann bis zu 10 Minuten dauern.
Nach Abschluss der Trainingsaufgabe können Sie einen XGBoost-Trainingsbericht und einen vom Debugger generierten Profilerstellungsbericht herunterladen. SageMaker Der XGBoost-Trainingsbericht bietet Ihnen Einblicke in den Trainingsfortschritt und die Ergebnisse, z. B. die Verlustfunktion in Bezug auf die Iteration, die Bedeutung der Merkmale, die Konfusionsmatrix, Genauigkeitskurven und andere statistische Ergebnisse des Trainings. Im XGBoost-Trainingsbericht finden Sie zum Beispiel die folgende Verlustkurve, die deutlich darauf hinweist, dass ein Überfitnessproblem vorliegt.
Führen Sie den folgenden Code aus, um den S3-Bucket-URI anzugeben, unter dem die Debugger-Trainingsberichte generiert werden, und überprüfen Sie, ob die Berichte vorhanden sind.
```
training_job = xgb_model_trainer._latest_training_job
rule_output_path = training_job.output_data_config.s3_output_path + "/" + training_job.training_job_name + "/rule-output"
! aws s3 ls {rule_output_path} --recursive
```
Laden Sie die Debugger-XGBoost-Trainings- und Profilerstellungsberichte in den aktuellen Workspace herunter:
```
! aws s3 cp {rule_output_path} ./ --recursive
```
Führen Sie das folgende IPython-Skript aus, um den Dateilink des XGBoost-Trainingsberichts abzurufen:
```
from IPython.display import FileLink, FileLinks
display("Click link below to view the XGBoost Training report", FileLink("CreateXgboostReport/xgboost_report.html"))
```
Das folgende IPython-Skript gibt den Dateilink des Debugger-Profilerstellungsberichts zurück, der Zusammenfassungen und Details zur Ressourcenauslastung der EC2-Instance, zu den Ergebnissen der Erkennung von Systemengpässen und zur Profilerstellung für Python-Operationen enthält:
```
# Note: In V3, debugger rule outputs can be accessed via the SageMaker console
# or the boto3 DescribeTrainingJob API (DebugRuleEvaluationStatuses field).
# Example using boto3:
# import boto3
# sm = boto3.client("sagemaker")
# resp = sm.describe_training_job(TrainingJobName=training_job.training_job_name)
# rule_statuses = resp["DebugRuleEvaluationStatuses"]
profiler_report_name = "ProfilerReport-1234567890"
display("Click link below to view the profiler report", FileLink(profiler_report_name+"/profiler-output/profiler-report.html"))
```
**Tipp**
Wenn die HTML-Berichte keine Zeichnungen in der JupyterLab Ansicht rendern, müssen Sie oben in den Berichten die Option HTML ** ** vertrauen auswählen.
Verwenden Sie den SageMaker Debugger und führen Sie beim Prototyping und Training Ihrer ML-Modelle automatische Aktionen durch, um Trainingsprobleme wie Überanpassung, verschwindende Farbverläufe und andere Probleme zu identifizieren, die die Konvergenz Ihres Modells verhindern. Weitere Informationen finden Sie unter [SageMaker Amazon-Debugger](train-debugger.md). Eine vollständige Analyse der Modellparameter finden Sie im Beispielnotizbuch „[Erklärbarkeit mit Amazon Debugger“. SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html#Explainability-with-Amazon-SageMaker-Debugger)
Sie haben jetzt ein trainiertes XGBoost-Modell. SageMaker AI speichert das Modellartefakt in Ihrem S3-Bucket. Um die Position des Modellartefakts zu ermitteln, führen Sie den folgenden Code aus, um das `model_data` Attribut zu drucken:
```
xgb_model_trainer._latest_training_job.model_artifacts.s3_model_artifacts
```
**Tipp**
Verwenden SageMaker Sie Clarify, um Verzerrungen zu messen, die in jeder Phase des ML-Lebenszyklus auftreten können (Datenerfassung, Modelltraining und -optimierung sowie Überwachung der ML-Modelle, die zu Prognosezwecken eingesetzt werden). Weitere Informationen finden Sie unter [Erklärbarkeit des Modells](clarify-model-explainability.md). Ein durchgängiges Beispiel finden Sie im [ Beispielnotizbuch Fairness und Erklärbarkeit mit SageMaker Clarify. ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.html)