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.
# Docker-Container für das Training und die Bereitstellung von Modellen
Amazon SageMaker AI verwendet in großem Umfang *Docker-Container* für Build- und Runtime-Aufgaben. SageMaker AI bietet vorgefertigte Docker-Images für seine integrierten Algorithmen und die unterstützten Deep-Learning-Frameworks, die für Training und Inferenz verwendet werden. Durch die Verwendung von Containern können Sie Machine-Learning-Algorithmen trainieren und Modelle in jeder Größenordnung schnell und zuverlässig bereitstellen. Die Themen in diesem Abschnitt zeigen, wie Sie diese Container für Ihre eigenen Anwendungsfälle einsetzen können. Informationen darüber, wie Sie Ihre eigenen Container zur Verwendung mit Amazon SageMaker Studio Classic mitbringen können, finden Sie unter[Benutzerdefinierte Bilder in Amazon SageMaker Studio Classic](studio-byoi.md).
**Topics**
+ [Szenarien für das Ausführen von Skripten, das Trainieren von Algorithmen oder das Bereitstellen von Modellen mit SageMaker KI](#container-scenarios)
+ [Grundlagen zum Docker-Container](docker-basics.md)
+ [Vorgefertigte KI-Docker-Images SageMaker](docker-containers-prebuilt.md)
+ [Benutzerdefinierte Docker-Container mit KI SageMaker](docker-containers-adapt-your-own.md)
+ [Erstellen eines Containers mit Ihren eigenen Algorithmen und Modellen](docker-containers-create.md)
+ [Beispiele und weitere Informationen: Verwenden Sie Ihren eigenen Algorithmus oder Ihr eigenes Modell](docker-containers-notebooks.md)
+ [Fehlerbehebung für Ihre Docker-Container und -Bereitstellungen](#docker-containers-troubleshooting)
## Szenarien für das Ausführen von Skripten, das Trainieren von Algorithmen oder das Bereitstellen von Modellen mit SageMaker KI
Amazon SageMaker AI verwendet bei der Ausführung von Skripten, beim Trainieren von Algorithmen und beim Bereitstellen von Modellen immer Docker-Container. Wie intensiv Sie mit Containern umgehen, hängt von Ihrem Anwendungsfall ab.
Der folgende Entscheidungsbaum veranschaulicht drei Hauptszenarien: **Anwendungsfälle für die Verwendung vorgefertigter Docker-Container mit SageMaker KI**; **Anwendungsfälle für die Erweiterung eines vorgefertigten Docker-Containers; **Anwendungsfall für** die Erstellung Ihres eigenen Containers**.
![\[Entscheidungsbaum für Container-Anwendungsfälle.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/your-algorithm-containers-flowchart-diagram.png)
**Topics**
+ [Anwendungsfälle für die Verwendung vorgefertigter Docker-Container mit KI SageMaker](#container-scenarios-use-prebuilt)
+ [Anwendungsfälle für die Erweiterung eines vorgefertigten Docker-Containers](#container-scenarios-extend-prebuilt)
+ [Anwendungsfall für den Bau Ihres eigenen Containers](#container-scenarios-byoc)
### Anwendungsfälle für die Verwendung vorgefertigter Docker-Container mit KI SageMaker
Beachten Sie bei der Verwendung von Containern mit SageMaker KI die folgenden Anwendungsfälle:
+ **Vordefinierter SageMaker KI-Algorithmus** — Verwenden Sie das Image, das mit dem integrierten Algorithmus geliefert wird. Weitere Informationen finden [Sie unter Verwenden der in Amazon SageMaker AI integrierten Algorithmen oder vortrainierten Modellen](https://docs.aws.amazon.com//sagemaker/latest/dg/algos.html).
+ **Benutzerdefiniertes Modell mit SageMaker vorgefertigtem KI-Container** — Wenn Sie ein benutzerdefiniertes Modell trainieren oder einsetzen, aber ein Framework verwenden, das über einen vorgefertigten SageMaker KI-Container mit TensorFlow und verfügt PyTorch, wählen Sie eine der folgenden Optionen:
+ Wenn Sie kein benutzerdefiniertes Paket benötigen und der Container bereits alle erforderlichen Pakete enthält: Verwenden Sie das vorgefertigte Docker-Image, das mit Ihrem Framework verknüpft ist. Weitere Informationen finden Sie unter [Vorgefertigte KI-Docker-Images SageMaker](docker-containers-prebuilt.md).
+ Wenn Sie ein benutzerdefiniertes Paket in einem der vorgefertigten Container installieren müssen: Vergewissern Sie sich, dass das vorgefertigte Docker-Image eine Datei requirements.txt zulässt, oder erweitern Sie den vorgefertigten Container auf der Grundlage der folgenden Anwendungsfälle.
### Anwendungsfälle für die Erweiterung eines vorgefertigten Docker-Containers
Im Folgenden finden Sie Anwendungsfälle für die Erweiterung eines vorgefertigten Docker-Containers:
+ **Sie können die Abhängigkeiten nicht importieren** – Erweitern Sie das vorgefertigte Docker-Image, das Ihrem Framework zugeordnet ist. Weitere Informationen finden Sie unter [Erweitern eines vorgefertigten Containers](prebuilt-containers-extend.md).
+ **Sie können die Abhängigkeiten im vorgefertigten Container nicht importieren und der vorgefertigte Container unterstützt requirements.txt** – Fügen Sie alle erforderlichen Abhängigkeiten in requirements.txt hinzu. Die folgenden Frameworks unterstützen die Verwendung von requirements.txt.
+ [TensorFlow](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/tensorflow/using_tf.html)
+ [Chainer](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/chainer/using_chainer.html?highlight=requirements.txt)
+ [Sci-Kit lernen](https://sagemaker.readthedocs.io/en/stable/frameworks/sklearn/using_sklearn.html?highlight=requirements.txt)
+ [PyTorch](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/pytorch/using_pytorch.html?highlight=requirements.txt)
+ [Apache MXNet](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/mxnet/using_mxnet.html?highlight=requirements.txt)
### Anwendungsfall für den Bau Ihres eigenen Containers
Wenn Sie ein benutzerdefiniertes Modell erstellen oder trainieren und ein benutzerdefiniertes Framework benötigen, das kein vorgefertigtes Image hat, erstellen Sie einen benutzerdefinierten Container.
Als Beispiel für einen Anwendungsfall für das Training und die Bereitstellung eines TensorFlow Modells zeigt der folgende Leitfaden, wie Sie ermitteln können, welche Option aus den vorherigen Abschnitten von **Anwendungsfällen für den jeweiligen Fall** geeignet ist.
Gehen Sie davon aus, dass Sie die folgenden Anforderungen für das Training und die Bereitstellung eines TensorFlow Modells erfüllen.
+ Ein TensorFlow Modell ist ein benutzerdefiniertes Modell.
+ Da ein TensorFlow Modell im Framework erstellt wird, verwenden Sie den TensorFlow vorgefertigten TensorFlow Framework-Container, um das Modell zu trainieren und zu hosten.
+ Wenn Sie benutzerdefinierte Pakete in Ihrem [Einstiegs](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#train-a-model-with-tensorflow)- oder [Inferenzskript benötigen, erweitern Sie entweder den vorgefertigten Container oder verwenden Sie eine Datei requirements.txt, um Abhängigkeiten zur Laufzeit zu installieren.](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#how-to-implement-the-pre-and-or-post-processing-handler-s)
Nachdem Sie den benötigten Containertyp bestimmt haben, finden Sie in der folgenden Liste Einzelheiten zu den zuvor aufgeführten Optionen.
+ **Verwenden Sie einen integrierten SageMaker KI-Algorithmus oder ein integriertes KI-Framework**. In den meisten Anwendungsfällen können Sie die integrierten Algorithmen und Frameworks verwenden, ohne sich Gedanken über Container machen zu müssen. Sie können diese Algorithmen über die SageMaker KI-Konsole, das AWS Command Line Interface (AWS CLI), ein Python-Notizbuch oder das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) trainieren und bereitstellen. Sie können dies tun, indem Sie bei der Erstellung Ihres Schätzers den Algorithmus oder die Framework-Version angeben. Die verfügbaren integrierten Algorithmen werden unter dem Thema [Integrierte Algorithmen und vortrainierte Modelle in Amazon SageMaker](algos.md) einzeln aufgeführt und beschrieben. Weitere Informationen über die verfügbaren Frameworks finden Sie unter [ML-Frameworks und Sprachen](frameworks.md). Ein Beispiel für das Trainieren und Bereitstellen eines integrierten Algorithmus mithilfe eines Jupyter-Notebooks, das in einer SageMaker Notebook-Instance ausgeführt wird, finden Sie im Thema. [Leitfaden für die Einrichtung von Amazon SageMaker AI](gs.md)
+ **Verwenden Sie vorgefertigte KI-Container-Images SageMaker **. Alternativ können Sie die integrierten Algorithmen und Frameworks mithilfe von Docker-Containern verwenden. SageMaker AI stellt Container für seine integrierten Algorithmen und vorgefertigte Docker-Images für einige der gängigsten Frameworks für maschinelles Lernen wie Apache,, und MXNet TensorFlow Chainer bereit. PyTorch Eine vollständige Liste der verfügbaren SageMaker Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Auch Machine-Learning-Bibliotheken wie scikit-learn und SparkML werden unterstützt. Wenn Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) verwenden, können Sie die Container bereitstellen, indem Sie den vollständigen Container-URI an die jeweilige SageMaker `Estimator` SDK-Klasse übergeben. Die vollständige Liste der Deep-Learning-Frameworks, die derzeit von SageMaker KI unterstützt werden, finden Sie unter[Vorgefertigte SageMaker KI-Docker-Images für Deep Learning](pre-built-containers-frameworks-deep-learning.md). Weitere Informationen über die vordefinierten Container-Images von scikit-learn und SparkML finden Sie unter [Zugriff auf Docker-Images für Scikit-learn und Spark ML](pre-built-docker-containers-scikit-learn-spark.md). Weitere Informationen zur Verwendung von Frameworks mit dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) finden Sie in den entsprechenden Themen unter[Frameworks und Sprachen für Machine Learning](frameworks.md).
+ **Erweitern Sie ein vorgefertigtes SageMaker AI-Container-Image**. Wenn Sie einen vorgefertigten SageMaker KI-Algorithmus erweitern oder ein Docker-Image modellieren möchten, können Sie das SageMaker Image an Ihre Bedürfnisse anpassen. Ein Beispiel finden Sie unter [Erweiterung unserer PyTorch Container](https://github.com/aws/amazon-sagemaker-examples-community/blob/215215eb25b40eadaf126d055dbb718a245d7603/bring-your-own-container/pytorch_extending_our_containers/pytorch_extending_our_containers.ipynb).
+ **Passen Sie ein vorhandenes Container-Image** an: Wenn Sie ein bereits vorhandenes Container-Image so anpassen möchten, dass es mit SageMaker KI funktioniert, müssen Sie den Docker-Container ändern, um entweder das SageMaker Training- oder das Inference-Toolkit zu aktivieren. Ein Beispiel, wie Sie eigene Container zum Trainieren und Hosten eines Algorithmus erstellen können, finden Sie unter [Bring Your Own R Algorithm](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb).
# Grundlagen zum Docker-Container
Die folgende Seite beschreibt die wichtigsten Aspekte der Verwendung von Docker-Containern mit Amazon SageMaker AI.
Docker ist ein Programm, das für die Installation, Verteilung und Verwaltung von Software eine Virtualisierung auf Betriebssystemebene durchführt. Anwendungen und ihre Abhängigkeiten werden in virtuelle Container gepackt, die Isolation, Portierbarkeit und Sicherheit bieten. Mit Docker können Sie Code schneller versenden, Anwendungsvorgänge standardisieren, Code nahtlos verschieben und durch bessere Ressourcennutzung Einsparungen erzielen. Allgemeinere Informationen zu Docker finden Sie in dieser [Übersicht zu Docker](https://docs.docker.com/engine/docker-overview/).
**SageMaker-AI-Funktionen**
SageMaker AI verwendet Docker-Container im Backend, um Trainings- und Inferenzprozesse zu verwalten. SageMaker AI abstrahiert von diesem Prozess weg, sodass er automatisch abläuft, wenn ein Schätzer verwendet wird. Für die meisten Anwendungsfälle müssen Sie Docker-Container zwar nicht explizit mit SageMaker AI verwenden, aber Sie können Docker-Container verwenden, um die SageMaker-AI-Funktionalität zu erweitern und anzupassen.
**Container mit Amazon SageMaker Studio Classic**
Studio Classic wird in einem Docker-Container ausgeführt und verwendet ihn zur Verwaltung der Funktionalität. Daher müssen Sie Ihren Docker-Container gemäß den in [Benutzerdefinierte Bilder in Amazon SageMaker Studio Classic](studio-byoi.md) beschriebenen Schritten erstellen.
# Vorgefertigte KI-Docker-Images SageMaker
Amazon SageMaker AI bietet Container für seine integrierten Algorithmen und vorgefertigte Docker-Images für einige der gängigsten Frameworks für maschinelles Lernen wie Apache MXNet, TensorFlow PyTorch, und Chainer. Auch Machine-Learning-Bibliotheken wie scikit-learn und SparkML werden unterstützt.
Sie können diese Images von Ihrer SageMaker Notebook-Instance oder Studio aus verwenden. SageMaker Sie können die vorgefertigten SageMaker Images auch um Bibliotheken und benötigte Funktionen erweitern. In den folgenden Themen finden Sie Informationen zu den verfügbaren Images und wie man sie benutzt.
Den Docker-Registrierungspfad und andere Parameter für jeden der von Amazon SageMaker AI bereitgestellten Algorithmen und Deep Learning Containers (DLC) finden Sie unter [Docker-Registrierungspfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths).
[Informationen zu Docker-Images für die Entwicklung von Reinforcement-Learning-Lösungen (RL) in SageMaker KI finden Sie unter SageMaker AI RL Containers.](https://github.com/aws/sagemaker-rl-container)
**Anmerkung**
Vorgefertigte Container-Images gehören der SageMaker KI und enthalten in einigen Fällen proprietären Code. Funktionen wie Schulungs- und Verarbeitungsjobs, Batch-Transformation und Inferenz in Echtzeit verwenden diensteigene Anmeldeinformationen, um Images auf verwalteten SageMaker KI-Instanzen abzurufen und auszuführen. Da keine Kundenanmeldedaten verwendet werden, verhindern alle AWS IAM-Richtlinien (einschließlich Service- und Ressourcenkontrollrichtlinien), die Amazon ECR-Berechtigungen verweigern, die Verwendung von vorgefertigten Images nicht.
**Topics**
+ [Richtlinie zur Unterstützung SageMaker vorgefertigter Bilder](pre-built-containers-support-policy.md)
+ [Vorgefertigte SageMaker KI-Docker-Images für Deep Learning](pre-built-containers-frameworks-deep-learning.md)
+ [Zugriff auf Docker-Images für Scikit-learn und Spark ML](pre-built-docker-containers-scikit-learn-spark.md)
+ [Deep Graph-Netzwerke](deep-graph-library.md)
+ [Erweitern eines vorgefertigten Containers](prebuilt-containers-extend.md)
# Richtlinie zur Unterstützung SageMaker vorgefertigter Bilder
Alle [vorgefertigten SageMaker Images](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html), einschließlich Framework-spezifischer Container, integrierter Algorithmuscontainer, Algorithmen und Modellpakete, die in aufgeführt sind, sowie [AWS Deep Learning Containers](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) werden regelmäßig auf häufig auftretende Sicherheitslücken gescannt AWS Marketplace, die vom Common [Vulnerabilities and Exposures (CVE) Program und der [National Vulnerability](https://nvd.nist.gov/) Database (NVD)](https://www.cve.org/) aufgeführt sind. Weitere Informationen zu finden Sie unter Häufig gestellte Fragen zu CVEs [CVE](https://www.cve.org/ResourcesSupport/FAQs) (). FAQs Unterstützte vorgefertigte Container-Images erhalten nach allen Sicherheitspatches eine aktualisierte Nebenversion.
Alle unterstützten Container-Images werden routinemäßig aktualisiert, um kritische Probleme zu beheben. CVEs Bei Szenarien mit hohem Schweregrad empfehlen wir Kunden, eine gepatchte Version des Containers in ihrer eigenen [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) zu erstellen und zu hosten.
Wenn Sie eine Container-Image-Version ausführen, die nicht mehr unterstützt wird, verfügen Sie möglicherweise nicht über die zuletzt aktualisierten Treiber, Bibliotheken und relevanten Pakete. Für eine höhere up-to-date Version empfehlen wir, ein Upgrade auf eines der unterstützten Frameworks durchzuführen und dabei das neueste Image Ihrer Wahl zu verwenden.
SageMaker KI veröffentlicht keine neuen out-of-patch Images für Container AWS-Regionen.
**Anmerkung**
Seit August 2024 erhält der `forecasting-deepar`-Container keine Sicherheitspatches oder Aktualisierungen mehr. Sie können diesen Container zwar weiterhin verwenden, gehen jedoch zusätzliche Risiken ein. Container sind veraltet, wenn das gesamte Framework oder die Algorithmen nicht mehr unterstützt werden und das dem Container zugrunde liegende MXNet Framework erreicht ist. end-of-maintenance
**Topics**
+ [AWS Supportrichtlinie für Deep Learning Containers (DLC)](#pre-built-containers-support-policy-dlc)
+ [SageMaker Richtlinie zur Unterstützung von AI ML Framework Containern](#pre-built-containers-support-policy-ml-framework)
+ [SageMaker Richtlinie zur Unterstützung von Containern mit integriertem KI-Algorithmus](#pre-built-containers-support-policy-built-in)
+ [Supportrichtlinie für LLM-Hosting-Container](#pre-built-containers-support-policy-llm-hosting)
+ [Nicht unterstützte Container und Veraltung](#pre-built-containers-support-policy-deprecation)
## AWS Supportrichtlinie für Deep Learning Containers (DLC)
AWS Deep Learning Containers sind eine Reihe von Docker-Images für das Training und die Bereitstellung von Deep-Learning-Modellen. Informationen zur Anzeige verfügbarer Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) im Deep Learning Containers GitHub Learning-Container-Repository.
DLCs das Ende des Patches wurde 365 Tage nach dem GitHub Veröffentlichungsdatum erreicht. Bei Patch-Updates für DLCs handelt es sich nicht um „direkte“ Updates. Sie müssen das vorhandene Image auf Ihrer Instance löschen und das neueste Container-Image abrufen, ohne Ihre Instance zu beenden. Weitere Informationen finden Sie unter [Framework-Supportrichtlinie](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html) im *Entwicklerhandbuch zu Deep-Learning-Containern von AWS *.
In der [Tabelle AWS Deep Learning Containers Framework Support Policy](https://aws.amazon.com/releasenotes/dlc-support-policy/) können Sie überprüfen, für welche Frameworks und Versionen aktiv unterstützt werden AWS DLCs. Für alle Images, die nicht explizit aufgeführt sind, können Sie in der Tabelle zur Supportrichtlinie nach dem Framework suchen, das einem DLC zugeordnet ist. **PyTorch**In der Tabelle mit den Support-Richtlinien für DLC-Images können Sie beispielsweise auf `huggingface-pytorch-inference` und `stabilityai-pytorch-inference` verweisen.
**Anmerkung**
Wenn ein DLC das HuggingFace [Transformers](https://huggingface.co/docs/transformers/en/index) SDK verwendet, wird nur das Image mit der neuesten Transformers-Version unterstützt. Weitere Informationen finden Sie unter **HuggingFace** auf der Seite [Docker-Registry-Pfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) für die Region Ihrer Wahl.
## SageMaker Richtlinie zur Unterstützung von AI ML Framework Containern
Bei den SageMaker AI ML Framework-Containern handelt es sich um eine Reihe von Docker-Images für das Training und die Bereitstellung von Workloads für maschinelles Lernen in Umgebungen, die für gängige Frameworks wie XGBoost Scikit Learn optimiert sind. Die verfügbaren SageMaker AI ML Framework-Container finden Sie unter [Docker-Registrierungspfade](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) und Beispielcode. Navigieren Sie zu der AWS Region Ihrer Wahl und suchen Sie nach Bildern mit dem Tag **(Algorithmus)**. SageMaker AI ML Framework-Container halten sich auch an die [Richtlinien zur Unterstützung des AWS Deep Learning Containers Frameworks](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Verwenden Sie die folgenden SageMaker Python SDK-Befehle, um die neueste Image-Version für XGBoost 1.7-1 im Framework-Modus abzurufen:
```
from sagemaker import image_uris
image_uris.retrieve(framework='xgboost',region='us-east-1',version='3.0-5')
```
| Framework | Aktuelle Version | GitHub GA | Patch-Enddatum |
| --- | --- | --- | --- |
| XGBoost | 3,0-5 | 17.11.2025 | 17.11.2026 |
| XGBoost | 1,7-1 | 03/06/2023 | 03/06/2025 |
| XGBoost | 1,5-1 | 21.02.2022 | 21.02.2023 |
| XGBoost | 1,3-1 | 21.05.2021 | 21.05.2022 |
| XGBoost | 1,2-2 | 20.09.2020 | 20.09.2021 |
| XGBoost | 1,2-1 | 19.07.2020 | 19.07.2021 |
| XGBoost | 1,0-1 | > 4 Jahre | Nicht unterstützt |
| Scikit-learn | 1,4-2 | 30.10.2025 | 30.10.2026 |
| Scikit-learn | 1,2-1 | 03/06/2023 | 03/06/2025 |
| Scikit-learn | 1,0-1 | 04/07/2022 | 04/07/2023 |
| Scikit-learn | 0,23-1 | 06.03.2023 | 06.02.2021 |
| Scikit-learn | 0,20-1 | > 4 Jahre | Nicht unterstützt |
## SageMaker Richtlinie zur Unterstützung von Containern mit integriertem KI-Algorithmus
Bei den integrierten SageMaker KI-Algorithmus-Containern handelt es sich um eine Reihe von Docker-Images für das Training und die Bereitstellung [der integrierten SageMaker KI-Algorithmen für maschinelles Lernen](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html). Die verfügbaren integrierten SageMaker KI-Algorithmus-Container finden Sie unter [Docker-Registrierungspfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html). Navigieren Sie zu der AWS Region Ihrer Wahl und suchen Sie nach Bildern mit dem Tag **(Algorithmus)**.
Patch-Aktualisierungen für integrierte Container-Images sind „direkte“ Aktualisierungen. Um auf up-to-date dem neuesten Stand der Sicherheitspatches zu bleiben, empfehlen wir, die neueste Version des integrierten Algorithmus-Image-Images mithilfe des `latest` Image-Tags zu testen.
| Container-Image | Patch-Enddatum |
| --- | --- |
| `blazingtext:latest` | 15.05.2024 |
| `factorization-machines:latest` | 15.05.2024 |
| `forecasting-deepar:latest` | 26.08.2025 |
| `image-classification:latest` | 15.05.2024 |
| `instance-segmentation:latest` | 15.05.2024 |
| `ipembeddings:latest` | 15.05.2024 |
| `ipinsights:latest` | 15.05.2024 |
| `kmeans:latest` | 15.05.2024 |
| `knn:latest` | 15.05.2024 |
| `linear-learner:inference-cpu-1/training-cpu-1` | 15.05.2024 |
| `linear-learner:latest` | 15.05.2024 |
| `mxnet-algorithms:training-cpu/inference-cpu` | 15.05.2024 |
| `ntm:latest` | 15.05.2024 |
| `object-detection:latest` | 15.05.2024 |
| `object2vec:latest` | 15.05.2024 |
| `pca:latest` | 15.05.2024 |
| `randomcutforest:latest` | 15.05.2024 |
| `semantic-segmentation:latest` | 15.05.2024 |
| `seq2seq:latest` | 15.05.2024 |
## Supportrichtlinie für LLM-Hosting-Container
[LLM-Hosting-Container](https://github.com/awslabs/llm-hosting-container) wie die TGI-Container (HuggingFaceText Generation Inference) haben das Ende des Patches 30 Tage nach ihrem Veröffentlichungsdatum erreicht. GitHub
**Wichtig**
Bei größeren Versionsaktualisierungen wird eine Ausnahme gemacht. Wenn das HuggingFace Text Generation Inference (TGI) -Toolkit beispielsweise auf TGI 2.0 aktualisiert wird, unterstützen wir weiterhin die neueste Version von TGI 1.4 für einen Zeitraum von drei Monaten ab dem Datum der Veröffentlichung. GitHub
| Toolkit-Container | Aktuelle Version | GitHub GA | Patch-Enddatum |
| --- | --- | --- | --- |
| TGI | tgi2.3.1 | 14.10.2024 | 14.11.2024 |
| TGI | optimal 0.0.25 | 10.04.2024 | 11.04.2024 |
| TGI | tgi2.2.0 | 26.07.2024 | 30.08.2024 |
| TGI | tgi2.0.0 | 15.05.2024 | 15.08.2024 |
| TGI | tgi1.4.5 | 04.03.2024 | 07.03.2024 |
| TGI | tgi1.4.2 | 22.02.2024 | 22.03.2024 |
| TGI | tgi1.4.0 | 29.01.2024 | 29.02.2024 |
| TGI | tgi1.3.3 | 19.12.2023 | 19.01.2024 |
| TGI | tgi1.3.1 | 11.12.2023 | 01.11.2024 |
| TGI | tgi1.2.0 | 12.04.2023 | 01.04.2024 |
| TGI | optimal 0.0.24 | 23.08.2024 | 30.09.2024 |
| TGI | optimal 0.0.23 | 26.07.2024 | 30.08.2024 |
| TGI | optimal 0.0.21 | 10.05.2024 | 15.08.2024 |
| TGI | optimal 0.0.19 | 19.02.2024 | 19.03.2024 |
| TGI | optimal 0.0.18 | 01.02.2024 | 01.03.2024 |
| TGI | optimal 0.0.17 | 24.01.2024 | 24.02.2024 |
| TGI | optimal 0.0.16 | 18.01.2024 | 18.02.2024 |
| TEI | tei1.4.0 | 01.08.2024 | 09.01.2024 |
| TEI | tei1.2.3 | 26.04.2024 | 26.05.2024 |
## Nicht unterstützte Container und Veraltung
Wenn ein Container das Enddatum für Patches erreicht oder veraltet ist, erhält er keine Sicherheitspatches mehr. Container sind veraltet, wenn ganze Frameworks oder Algorithmen nicht mehr unterstützt werden.
Die folgenden Container werden nicht mehr unterstützt:
+ Seit August 2024 erhält der `forecasting-deepar` Container keine Sicherheitspatches oder Updates mehr, da das MXNet Framework, das dem Container zugrunde liegt, erreicht. end-of-maintenance
+ Ab April 2024 werden [Container für SageMaker KI Reinforcement Learning (RL)](https://github.com/aws/sagemaker-rl-container) nicht mehr unterstützt. Informationen zum Erstellen eigener RL-Images finden Sie unter [Erstellen Ihres Images](https://github.com/aws/sagemaker-rl-container#building-your-image) im SageMaker AI GitHub RL-Container-Repository.
+ Stand September 2023, JumpStart Branche: Finanzcontainer werden nicht mehr unterstützt.
# Vorgefertigte SageMaker KI-Docker-Images für Deep Learning
Amazon SageMaker AI bietet vorgefertigte Docker-Images, die Deep-Learning-Frameworks und andere Abhängigkeiten enthalten, die für Training und Inferenz benötigt werden. Eine vollständige Liste der vorgefertigten Docker-Images, die von SageMaker AI verwaltet werden, finden Sie unter [Docker-Registrierungspfade](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) und Beispielcode.
## Verwenden des SageMaker KI-Python-SDK
Mit dem [SageMaker Python-SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk) können Sie Modelle mit diesen beliebten Deep-Learning-Frameworks trainieren und bereitstellen. Anweisungen zur Installation und Verwendung des SDK finden Sie unter [https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk). In der folgenden Tabelle sind die verfügbaren Frameworks und Anweisungen zu ihrer Verwendung mit dem [SageMaker Python-SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk) aufgeführt:
| Framework | Anleitungen |
| --- | --- |
| TensorFlow | [Verwendung TensorFlow mit dem SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html) |
| MXNet | [Verwendung MXNet mit dem SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html) |
| PyTorch | [Verwendung PyTorch mit dem SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html) |
| Chainer | [Chainer mit dem SageMaker Python SDK verwenden](https://sagemaker.readthedocs.io/en/stable/frameworks/chainer/using_chainer.html) |
| Hugging Face | [Hugging Face mit dem Python-SDK verwenden SageMaker ](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html) |
## Erweiterung vorgefertigter KI-Docker-Images SageMaker
Sie können diese vorgefertigten Container nach Bedarf anpassen oder erweitern. Mit dieser Anpassung können Sie alle zusätzlichen funktionalen Anforderungen für Ihren Algorithmus oder Ihr Modell erfüllen, die das vorgefertigte SageMaker KI-Docker-Image nicht unterstützt. Ein Beispiel hierfür finden Sie unter [Feinabstimmung und Bereitstellung eines BERTopic Modells auf SageMaker KI mit Ihren eigenen Skripten und Datensätzen durch Erweiterung vorhandener](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/pytorch_extend_container_train_deploy_bertopic/BERTtopic_extending_container.html) Container. PyTorch
Sie können auch vorgefertigte Container verwenden, um Ihre benutzerdefinierten Modelle oder Modelle bereitzustellen, die in einem anderen Framework als SageMaker KI trainiert wurden. Einen Überblick über den Prozess finden Sie unter [Bring Your Own Pretrained MXNet or TensorFlow Models into Amazon SageMaker](https://aws.amazon.com/blogs/machine-learning/bring-your-own-pre-trained-mxnet-or-tensorflow-models-into-amazon-sagemaker/). In diesem Tutorial geht es darum, die trainierten Modellartefakte in SageMaker KI zu integrieren und sie an einem Endpunkt zu hosten.
# Zugriff auf Docker-Images für Scikit-learn und Spark ML
SageMaker AI bietet vorgefertigte Docker-Images, die die Scikit-Learn- und Spark-ML-Bibliotheken installieren. Diese Bibliotheken enthalten auch die Abhängigkeiten, die zum Erstellen von Docker-Images erforderlich sind, die mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) mit SageMaker KI kompatibel sind. Mit dem SDK können Sie Scikit-learn für Machine-Learning-Aufgaben und Spark ML zum Erstellen und Optimieren von Machine-Learning-Pipelines verwenden. Weitere Informationen zur Installation und Verwendung des SDK finden Sie unter [SageMaker Python SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk).
Sie können auch von einem Amazon-ECR-Repository in Ihrer eigenen Umgebung aus auf die Images zugreifen.
Verwenden Sie die folgenden Befehle, um herauszufinden, welche Versionen der Images verfügbar sind. Verwenden Sie beispielsweise Folgendes, um das verfügbare `sagemaker-sparkml-serving`-Image in der Region `ca-central-1` zu finden:
```
aws \
ecr describe-images \
--region ca-central-1 \
--registry-id 341280168497 \
--repository-name sagemaker-sparkml-serving
```
## Zugreifen auf ein Bild über das SageMaker AI Python SDK
Die folgende Tabelle enthält Links zu den GitHub Repositorys mit dem Quellcode für die Scikit-Learn- und Spark-ML-Container. Die Tabelle enthält auch Links zu Anweisungen, die zeigen, wie Sie diese Container mit Python-SDK-Schätzern verwenden, um Ihre eigenen Trainingsalgorhythmen auszuführen und Ihre eigenen Modelle zu hosten.
| Bibliothek | Quellcode des vorkonfigurierten Docker-Images | Anleitungen |
| --- | --- | --- |
| Scikit-learn | [SageMaker KI-Scikit-Learn-Container](https://github.com/aws/sagemaker-scikit-learn-container) | [Scikit-learn mit dem Amazon Python SDK verwenden SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html) |
| Spark ML | [SageMaker AI Spark ML Servierbehälter](https://github.com/aws/sagemaker-sparkml-serving-container) | [SparkML-Python-SDK-Dokumentation](https://sagemaker.readthedocs.io/en/stable/sagemaker.sparkml.html) |
Weitere Informationen und Links zu Github-Repositorys finden Sie unter [Ressourcen für die Verwendung von Scikit-Learn mit Amazon AI SageMaker](sklearn.md) und [Ressourcen für die Verwendung von SparkML Serving mit Amazon AI SageMaker](sparkml-serving.md).
## Manuelles Angeben der vordefinierten Images
Wenn Sie das SageMaker Python-SDK und einen seiner Schätzer nicht zur Verwaltung des Containers verwenden, müssen Sie den entsprechenden vorgefertigten Container manuell abrufen. Die SageMaker vorgefertigten KI-Docker-Images werden in Amazon Elastic Container Registry (Amazon ECR) gespeichert. Sie können sie mithilfe ihrer vollständigen Registrierungsadressen per Push oder Pull übertragen. SageMaker AI verwendet die folgenden Docker-Image-URL-Muster für Scikit-Learn und Spark ML:
+ `.dkr.ecr..amazonaws.com/sagemaker-scikit-learn:-cpu-py`
Beispiel: `746614075791.dkr.ecr.us-west-1.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3`
+ `.dkr.ecr..amazonaws.com/sagemaker-sparkml-serving:`
Beispiel: `341280168497.dkr.ecr.ca-central-1.amazonaws.com/sagemaker-sparkml-serving:2.4`
Informationen zu Konto IDs - und AWS Regionsnamen finden Sie unter [Docker-Registrierungspfade](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) und Beispielcode.
# Deep Graph-Netzwerke
Deep Graph-Netzwerke beziehen sich auf eine Art neuronales Netzwerk, das trainiert wird, um Probleme mit Graphs zu lösen. Ein Deep Graph-Netzwerk nutzt ein zugrundeliegendes Deep-Learning-Framework wie PyTorch oder MXNet. Das Potenzial von Graphennetzen für praktische KI-Anwendungen wird in den Tutorials zu Amazon SageMaker AI für die [Deep Graph Library](https://www.dgl.ai/) (DGL) hervorgehoben. Beispiele für Trainingsmodelle anhand von Graph-Datensätzen sind soziale Netzwerke, Wissensdatenbanken, Biologie und Chemie.
![\[The Deep Graph Library (DGL) ecosystem.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/dgl_white_background_bold.png)
*Abbildung 1. Das DGL-Ökosystem*
Mehrere Beispiele werden mit den Deep-Learning-Containern von Amazon SageMaker AI bereitgestellt, die mit DGL vorkonfiguriert sind. Wenn Sie spezielle Module haben, die Sie mit DGL verwenden möchten, können Sie auch einen eigenen Container erstellen. Die Beispiele umfassen Heterografien, also Graphen, die mehrere Arten von Knoten und Kanten aufweisen, und beziehen sich auf eine Vielzahl von Anwendungen in unterschiedlichen wissenschaftlichen Bereichen, wie Bioinformatik und Analyse sozialer Netzwerke. DGL bietet eine breite Palette von [Implementierungen neuraler Graph-Netzwerke für verschiedene Modelltypen](https://docs.dgl.ai/tutorials/models/index.html). Einige der Highlights sind:
+ Graph convolutional network (GCN)
+ Relational graph convolutional network (R-GCN)
+ Graph attention network (GAT)
+ Deep generative models of graphs (DGMG)
+ Junction tree neural network (JTNN)
# Erste Schritte beim Training eines Deep-Graph-Netzwerks
DGL ist als Deep-Learning-Container in Amazon ECR verfügbar. Sie können Deep-Learning-Container auswählen, wenn Sie Ihre Schätzfunktion in ein Amazon SageMaker-Notebook schreiben. Sie können mit DGL auch Ihren eigenen Container erstellen, indem Sie der Anleitung [Bring Your Own Container](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html) folgen. Der einfachste Weg, mit einem Deep-Graph-Netzwerk zu beginnen, verwendet einen der DGL-Container in Amazon Elastic Container Registry.
**Anmerkung**
Die Unterstützung des Backend-Frameworks ist auf PyTorch und MXNet beschränkt.
**Aufstellen**
Wenn Sie Amazon SageMaker Studio verwenden, müssen Sie zunächst das Beispiel-Repository klonen. Wenn Sie eine Notebook-Instance verwenden, können Sie die Beispiele über das SageMaker-AI-Symbol unten in der linken Symbolleiste aufrufen.
**So klonen Sie das Amazon SageMaker SDK- und Notebook-Beispiel-Repository**
1. Gehen Sie in der **JupyterLab**-Ansicht in Amazon SageMaker AI zum **Dateibrowser** oben in der linken Symbolleiste. Im **Datei-Browser-Bereich** können Sie eine neue Navigation oben im Bereich sehen.
1. Wählen Sie das Symbol ganz rechts, um ein Git-Repository zu klonen.
1. Fügen Sie die Repository-URL hinzu: [https://github.com/awslabs/amazon-sagemaker-examples.git](https://github.com/awslabs/amazon-sagemaker-examples.git)
1. Durchsuchen Sie den neu hinzugefügten Ordner und dessen Inhalt. Die DGL-Beispiele sind im Ordner **sagemaker-python-sdk** gespeichert.
**Trainieren**
Nach der Einrichtung können Sie das Deep-Graph-Netzwerk trainieren.
**So trainieren Sie ein Deep Graph-Netzwerk**
1. Durchsuchen Sie in der **JupyterLab**-Ansicht in Amazon SageMaker AI die [Beispiel-Notebooks](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk) und suchen Sie nach DGL-Ordnern. Es können mehrere Dateien enthalten sein, um ein Beispiel zu unterstützen. Überprüfen Sie die README auf alle Voraussetzungen.
1. Führen Sie das .ipynb-Notebook-Beispiel aus.
1. Suchen Sie die Schätzfunktion und notieren Sie sich die Zeile, in der sie einen Amazon ECR-Container für DGL und einen bestimmten Instance-Typ verwendet. Möglicherweise möchten Sie dies aktualisieren, um einen Container in Ihrer bevorzugten Region zu verwenden.
1. Führen Sie die Funktion aus, um die Instance zu starten, und verwenden Sie den DGL-Container für das Training eines Graph-Netzwerks. Für den Start dieser Instance fallen Gebühren an. Die Instance beendet sich selbst, wenn das Training abgeschlossen ist.
Ein Beispiel für die Wissensgraph-Einbettung (KGE) wird bereitgestellt. Es verwendet den Freebase-Datensatz, eine Wissensdatenbank allgemeiner Fakten. Ein Anwendungsfallbeispiel wäre, die Beziehungen von Personen grafisch darzustellen und ihre Nationalität vorherzusagen.
Ein Beispiel für die Implementierung eines Graph Convolutional Network (GCN) zeigt, wie Sie ein Graph-Netzwerk trainieren können, um Toxizität vorherzusagen. Der physiologische Datensatz Tox21 liefert Toxizitätsmessungen für die Auswirkung von Substanzen auf biologische Reaktionen.
Ein weiteres GCN-Beispiel zeigt Ihnen, wie Sie ein Graph-Netzwerk anhand eines Literaturverzeichnis-Datensatzes wissenschaftlicher Publikationen trainieren, das als Cora bekannt ist. Sie können damit Beziehungen zwischen Autoren, Themen und Konferenzen aufdecken.
Das erste Beispiel ist ein Empfehlungssystem für Filmrezensionen. Es verwendet ein Graph Convolutional Matrix Completion (GCMC)-Netzwerk, das mit MovieLens-Datasets trainiert wurde. Diese Datensätze bestehen aus Filmtiteln, Genres und Bewertungen von Benutzern.
# Erweitern eines vorgefertigten Containers
Wenn ein vorgefertigter SageMaker KI-Container nicht alle Ihre Anforderungen erfüllt, können Sie das vorhandene Image an Ihre Bedürfnisse anpassen. Auch wenn es direkte Unterstützung für Ihre Umgebung oder Ihr Framework gibt, möchten Sie vielleicht zusätzliche Funktionen hinzufügen oder Ihre Container-Umgebung anders konfigurieren. Durch die Erweiterung eines vorgefertigten Images können Sie die enthaltenen Deep-Learning-Bibliotheken und -Einstellungen nutzen, ohne ein Image von Grund auf neu erstellen zu müssen. Sie können den Container erweitern, um Bibliotheken hinzuzufügen, Einstellungen zu ändern und zusätzliche Abhängigkeiten zu installieren.
Das folgende Tutorial zeigt, wie Sie ein vorgefertigtes SageMaker Image erweitern und in Amazon ECR veröffentlichen.
**Topics**
+ [Anforderungen für die Erweiterung eines vorgefertigten Containers](#prebuilt-containers-extend-required)
+ [SageMaker KI-Container erweitern, um ein Python-Skript auszuführen](#prebuilt-containers-extend-tutorial)
## Anforderungen für die Erweiterung eines vorgefertigten Containers
Um ein vorgefertigtes SageMaker Image zu erweitern, müssen Sie die folgenden Umgebungsvariablen in Ihrem Dockerfile festlegen. Weitere Informationen zu Umgebungsvariablen mit SageMaker AI-Containern finden Sie im [SageMaker Training](https://github.com/aws/sagemaker-training-toolkit/blob/master/ENVIRONMENT_VARIABLES.md) Toolkit-Repo. GitHub
+ `SAGEMAKER_SUBMIT_DIRECTORY`: Das Verzeichnis innerhalb des Containers, in dem sich das Python-Skript für das Training befindet.
+ `SAGEMAKER_PROGRAM`: Das Python-Skript, das aufgerufen und als Eintrittspunkt für das Training verwendet werden soll.
Sie können auch zusätzliche Bibliotheken installieren, indem Sie Folgendes in Ihrem Dockerfile aufnehmen:
```
RUN pip install
```
Das folgende Tutorial zeigt, wie diese Umgebungsvariablen verwendet werden.
## SageMaker KI-Container erweitern, um ein Python-Skript auszuführen
In diesem Tutorial erfahren Sie, wie Sie den SageMaker PyTorch AI-Container mit einer Python-Datei erweitern, die den CIFAR-10-Datensatz verwendet. Durch die Erweiterung des SageMaker PyTorch KI-Containers nutzen Sie die bestehende Trainingslösung, die für die Arbeit mit SageMaker KI entwickelt wurde. In diesem Tutorial wird ein Trainings-Image erweitert, es können jedoch dieselben Schritte unternommen werden, um ein Inferenz-Image zu erweitern. Die vollständige Liste der verfügbaren Images finden Sie unter [Verfügbare Deep-Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Um Ihr eigenes Trainingsmodell mithilfe der SageMaker KI-Container auszuführen, erstellen Sie einen Docker-Container über eine SageMaker Notebook-Instanz.
### Schritt 1: Erstellen Sie eine SageMaker Notebook-Instanz
1. Öffnen Sie die [SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im linken Navigationsbereich **Notebook**, wählen Sie danach **Notebook-Instances** und anschließend **Notebook-Instance erstellen**.
1. Geben Sie auf der Seite **Notebook-Instance erstellen** folgende Informationen ein:
1. Geben Sie unter **Notebook instance name (Name der Notebook-Instance)** **RunScriptNotebookInstance** ein.
1. Wählen Sie für **Notebook instance type (Typ der Notebook-Instance)** **ml.t2.medium** aus.
1. Im Abschnitt **Berechtigungen und Verschlüsselung** gehen Sie wie folgt vor:
1. Wählen Sie für **IAM Role (IAM-Rolle)** die Option **Create a New Role (Neue Rolle erstellen)** aus.
1. Wählen Sie auf der Seite **IAM-Rolle erstellen** die Option **Spezifische S3-Buckets** aus, spezifizieren Sie einen S3-Bucket mit dem Namen **sagemaker-run-script** und wählen Sie dann **Rolle erstellen** aus.
SageMaker AI erstellt eine IAM-Rolle mit `AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS` dem Namen. `AmazonSageMaker-ExecutionRole-20190429T110788` Beachten Sie, dass bei der Namenskonvention für Ausführungsrollen das Datum und die Uhrzeit verwendet werden, zu denen die Rolle erstellt wurde, getrennt durch einen `T`.
1. Wählen Sie für **Root-Zugriff** die Option **Aktiviert** aus.
1. Wählen Sie **Create notebook instance (Notebook-Instance erstellen)** aus.
1. Auf der Seite **Notebook-Instances** lautet der **Status** **Ausstehend**. Es kann einige Minuten dauern, bis Amazon SageMaker AI eine Recheninstanz für maschinelles Lernen startet — in diesem Fall startet sie eine Notebook-Instance — und ihr ein ML-Speichervolume anhängt. Die Notebook-Instance verfügt über einen vorkonfigurierten Jupyter-Notebook-Server und mehrere Anaconda-Bibliotheken. Weitere Informationen finden Sie unter [ CreateNotebookInstance](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html).
1. Kopieren Sie im Abschnitt **Berechtigungen und Verschlüsselung** **die ARN-Nummer der IAM-Rolle** und fügen Sie sie in eine Notepad-Datei ein, um sie vorübergehend zu speichern. Sie verwenden diese IAM-Rollen-ARN-Nummer später, um einen lokalen Trainingsschätzer in der Notebook-Instance zu konfigurieren. **Die ARN-Nummer der IAM-Rolle** sieht wie folgt aus: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`
1. Nachdem sich der Status der Notebook-Instanz auf geändert hat **InService**, wählen Sie **Öffnen JupyterLab**.
### Schritt 2: Erstellen und Hochladen der Dockerdatei und der Python-Trainingsskripte
1. Erstellen Sie nach dem JupyterLab Öffnen einen neuen Ordner im Home-Verzeichnis Ihres JupyterLab. Wählen Sie links oben das Symbol **Neuer Ordner** und geben Sie dann den Ordnernamen `docker_test_folder` ein.
1. Erstellen Sie in dem Verzeichnis `docker_test_folder` eine Datei namens `Dockerfile`.
1. Wählen Sie das Symbol **Neuer Launcher** (\$1) in der oberen linken Ecke.
1. Wählen Sie im rechten Bereich unter dem Abschnitt **Andere** die Option **Textdatei**.
1. Fügen Sie den folgenden `Dockerfile`-Beispielcode in Ihre Textdatei ein.
```
# SageMaker PyTorch image
FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04
ENV PATH="/opt/ml/code:${PATH}"
# this environment variable is used by the SageMaker PyTorch container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
# /opt/ml and all subdirectories are utilized by SageMaker, use the /code subdirectory to store your user code.
COPY cifar10.py /opt/ml/code/cifar10.py
# Defines cifar10.py as script entrypoint
ENV SAGEMAKER_PROGRAM cifar10.py
```
Das Dockerfile-Skript führt die folgenden Aufgaben aus:
+ `FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04`— Lädt das SageMaker PyTorch AI-Basisimage herunter. Sie können dies durch ein beliebiges SageMaker AI-Basisimage ersetzen, das Sie zum Erstellen von Containern verwenden möchten.
+ `ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code` – Legt `/opt/ml/code` als Trainingsskriptverzeichnis fest.
+ `COPY cifar10.py /opt/ml/code/cifar10.py`— Kopiert das Skript an die Stelle innerhalb des Containers, die von der SageMaker KI erwartet wird. Das Skript muss sich in diesem Ordner befinden.
+ `ENV SAGEMAKER_PROGRAM cifar10.py` – Legt Ihr `cifar10.py`-Trainingsskript als Einstiegsskript fest.
1. In der linken Verzeichnisnavigation wird der Name der Textdatei automatisch auf `untitled.txt` festgelegt. Um die Datei umzubenennen, klicken Sie mit der rechten Maustaste auf die Datei, wählen Sie **Umbenennen**, benennen Sie die Datei in `Dockerfile` ohne die `.txt`-Erweiterung um und drücken Sie dann auf `Ctrl+s` oder `Command+s`, um die Datei zu speichern.
1. Erstellen Sie oder laden Sie ein Trainingsskript `cifar10.py` in der `docker_test_folder` hoch. Sie können das folgende Beispiel-Skript für diese Übung nutzen.
```
import ast
import argparse
import logging
import os
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
import torchvision.models
import torchvision.transforms as transforms
import torch.nn.functional as F
logger=logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
classes=('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# https://github.com/pytorch/tutorials/blob/master/beginner_source/blitz/cifar10_tutorial.py#L118
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1=nn.Conv2d(3, 6, 5)
self.pool=nn.MaxPool2d(2, 2)
self.conv2=nn.Conv2d(6, 16, 5)
self.fc1=nn.Linear(16 * 5 * 5, 120)
self.fc2=nn.Linear(120, 84)
self.fc3=nn.Linear(84, 10)
def forward(self, x):
x=self.pool(F.relu(self.conv1(x)))
x=self.pool(F.relu(self.conv2(x)))
x=x.view(-1, 16 * 5 * 5)
x=F.relu(self.fc1(x))
x=F.relu(self.fc2(x))
x=self.fc3(x)
return x
def _train(args):
is_distributed=len(args.hosts) > 1 and args.dist_backend is not None
logger.debug("Distributed training - {}".format(is_distributed))
if is_distributed:
# Initialize the distributed environment.
world_size=len(args.hosts)
os.environ['WORLD_SIZE']=str(world_size)
host_rank=args.hosts.index(args.current_host)
dist.init_process_group(backend=args.dist_backend, rank=host_rank, world_size=world_size)
logger.info(
'Initialized the distributed environment: \'{}\' backend on {} nodes. '.format(
args.dist_backend,
dist.get_world_size()) + 'Current host rank is {}. Using cuda: {}. Number of gpus: {}'.format(
dist.get_rank(), torch.cuda.is_available(), args.num_gpus))
device='cuda' if torch.cuda.is_available() else 'cpu'
logger.info("Device Type: {}".format(device))
logger.info("Loading Cifar10 dataset")
transform=transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset=torchvision.datasets.CIFAR10(root=args.data_dir, train=True,
download=False, transform=transform)
train_loader=torch.utils.data.DataLoader(trainset, batch_size=args.batch_size,
shuffle=True, num_workers=args.workers)
testset=torchvision.datasets.CIFAR10(root=args.data_dir, train=False,
download=False, transform=transform)
test_loader=torch.utils.data.DataLoader(testset, batch_size=args.batch_size,
shuffle=False, num_workers=args.workers)
logger.info("Model loaded")
model=Net()
if torch.cuda.device_count() > 1:
logger.info("Gpu count: {}".format(torch.cuda.device_count()))
model=nn.DataParallel(model)
model=model.to(device)
criterion=nn.CrossEntropyLoss().to(device)
optimizer=torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
for epoch in range(0, args.epochs):
running_loss=0.0
for i, data in enumerate(train_loader):
# get the inputs
inputs, labels=data
inputs, labels=inputs.to(device), labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs=model(inputs)
loss=criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss=0.0
print('Finished Training')
return _save_model(model, args.model_dir)
def _save_model(model, model_dir):
logger.info("Saving the model.")
path=os.path.join(model_dir, 'model.pth')
# recommended way from http://pytorch.org/docs/master/notes/serialization.html
torch.save(model.cpu().state_dict(), path)
def model_fn(model_dir):
logger.info('model_fn')
device="cuda" if torch.cuda.is_available() else "cpu"
model=Net()
if torch.cuda.device_count() > 1:
logger.info("Gpu count: {}".format(torch.cuda.device_count()))
model=nn.DataParallel(model)
with open(os.path.join(model_dir, 'model.pth'), 'rb') as f:
model.load_state_dict(torch.load(f))
return model.to(device)
if __name__ == '__main__':
parser=argparse.ArgumentParser()
parser.add_argument('--workers', type=int, default=2, metavar='W',
help='number of data loading workers (default: 2)')
parser.add_argument('--epochs', type=int, default=2, metavar='E',
help='number of total epochs to run (default: 2)')
parser.add_argument('--batch-size', type=int, default=4, metavar='BS',
help='batch size (default: 4)')
parser.add_argument('--lr', type=float, default=0.001, metavar='LR',
help='initial learning rate (default: 0.001)')
parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='momentum (default: 0.9)')
parser.add_argument('--dist-backend', type=str, default='gloo', help='distributed backend (default: gloo)')
# The parameters below retrieve their default values from SageMaker environment variables, which are
# instantiated by the SageMaker containers framework.
# https://github.com/aws/sagemaker-containers#how-a-script-is-executed-inside-the-container
parser.add_argument('--hosts', type=str, default=ast.literal_eval(os.environ['SM_HOSTS']))
parser.add_argument('--current-host', type=str, default=os.environ['SM_CURRENT_HOST'])
parser.add_argument('--model-dir', type=str, default=os.environ['SM_MODEL_DIR'])
parser.add_argument('--data-dir', type=str, default=os.environ['SM_CHANNEL_TRAINING'])
parser.add_argument('--num-gpus', type=int, default=os.environ['SM_NUM_GPUS'])
_train(parser.parse_args())
```
### Schritt 3: Erstellen des Containers
1. Öffnen Sie im JupyterLab Home-Verzeichnis ein Jupyter-Notizbuch. Um ein neues Notebook zu öffnen, wählen Sie das Symbol **Neuer Start** und dann **conda\$1pytorch\$1p39** im Abschnitt **Notebook**.
1. Führen Sie den folgenden Befehl in der ersten Notebook-Zelle aus, um in das Verzeichnis `docker_test_folder` zu wechseln:
```
% cd ~/SageMaker/docker_test_folder
```
Dies gibt Ihr aktuelles Verzeichnis wie folgt zurück:
```
! pwd
```
`output: /home/ec2-user/SageMaker/docker_test_folder`
1. Melden Sie sich bei Docker an, um auf den Basis-Container zuzugreifen:
```
! aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```
1. Zum Erstellen des Docker-Containers führen Sie den folgenden Docker-Build-Befehl, einschließlich des Punkts am Ende, aus:
```
! docker build -t pytorch-extended-container-test .
```
Der Docker-Build-Befehl muss von der von Ihnen erstellten Docker-Registry aus ausgeführt werden. In diesem Fall ist dies `docker_test_folder`.
**Anmerkung**
Wenn Sie die folgende Fehlermeldung erhalten, dass Docker das Dockerfile nicht finden kann, stellen Sie sicher, dass das Dockerfile den richtigen Namen hat und im Verzeichnis gespeichert wurde.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory
```
Denken Sie daran, dass `docker` im aktuellen Verzeichnis spezifisch nach einer Datei namens `Dockerfile` ohne Erweiterung sucht. Wenn Sie sie anders benannt haben, können Sie den Dateinamen manuell mit dem `-f`-Flag übergeben. Wenn Sie Ihre Docker-Datei beispielsweise `Dockerfile-text.txt` benannt haben, führen Sie den folgenden Befehl aus:
```
! docker build -t tf-custom-container-test -f Dockerfile-text.txt .
```
### Schritt 4: Testen des Containers
1. Um den Container lokal für die Notebook-Instance zu testen, öffnen Sie ein Jupyter Notebook. Wählen Sie **Neuer Launcher** und dann **Notebook** im **`conda_pytorch_p39`**-Framework aus. Der Rest der Codeausschnitte muss von der Jupyter-Notebook-Instance aus ausgeführt werden.
1. Laden Sie den CIFAR-10-Datensatz herunter.
```
import torch
import torchvision
import torchvision.transforms as transforms
def _get_transform():
return transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
def get_train_data_loader(data_dir='/tmp/pytorch/cifar-10-data'):
transform=_get_transform()
trainset=torchvision.datasets.CIFAR10(root=data_dir, train=True,
download=True, transform=transform)
return torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
def get_test_data_loader(data_dir='/tmp/pytorch/cifar-10-data'):
transform=_get_transform()
testset=torchvision.datasets.CIFAR10(root=data_dir, train=False,
download=True, transform=transform)
return torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
trainloader=get_train_data_loader('/tmp/pytorch-example/cifar-10-data')
testloader=get_test_data_loader('/tmp/pytorch-example/cifar-10-data')
```
1. Setzen Sie `role` auf die Rolle, mit der Sie Ihr Jupyter Notebook erstellt haben. Dies wird verwendet, um Ihren SageMaker AI Estimator zu konfigurieren.
```
from sagemaker import get_execution_role
role=get_execution_role()
```
1. Fügen Sie das folgende Beispielskript in die Notebook-Codezelle ein, um einen SageMaker AI Estimator mithilfe Ihres erweiterten Containers zu konfigurieren.
```
from sagemaker.estimator import Estimator
hyperparameters={'epochs': 1}
estimator=Estimator(
image_uri='pytorch-extended-container-test',
role=role,
instance_count=1,
instance_type='local',
hyperparameters=hyperparameters
)
estimator.fit('file:///tmp/pytorch-example/cifar-10-data')
```
1. Führen Sie die Code-Zelle aus. Dieser Test gibt die Konfiguration der Trainingsumgebung, die Werte für die Umgebungsvariablen, die Quelle der Daten sowie den Verlust und die Genauigkeit aus, die bei dem Training erreicht wurden.
### Schritt 5: Senden des Containers in die Amazon Elastic Container Registry (Amazon ECR)
1. Nachdem Sie den Test im lokalen Modus erfolgreich durchgeführt haben, können Sie den Docker-Container an [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) senden und ihn zur Ausführung von Trainingsaufträgen verwenden.
Führen Sie die folgenden Befehlszeilen in einer Notebook-Zelle aus.
```
%%sh
# Specify an algorithm name
algorithm_name=pytorch-extended-container-test
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Log into Docker
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
1. Nachdem Sie den Container gepusht haben, können Sie das Amazon ECR-Image von überall in der SageMaker KI-Umgebung aufrufen. Führen Sie das folgende Codebeispiel in der nächsten Notebook-Zelle aus.
Wenn Sie diesen Trainingscontainer mit SageMaker Studio verwenden möchten, um seine Visualisierungsfunktionen zu nutzen, können Sie auch den folgenden Code in einer Studio-Notebookzelle ausführen, um das Amazon ECR-Image Ihres Trainingscontainers aufzurufen.
```
import boto3
client=boto3.client('sts')
account=client.get_caller_identity()['Account']
my_session=boto3.session.Session()
region=my_session.region_name
algorithm_name="pytorch-extended-container-test"
ecr_image='{}.dkr.ecr.{}.amazonaws.com/{}:latest'.format(account, region, algorithm_name)
ecr_image
# This should return something like
# 12-digits-of-your-account.dkr.ecr.us-east-2.amazonaws.com/tf-2.2-test:latest
```
1. Verwenden Sie das aus dem vorherigen Schritt `ecr_image` abgerufene Objekt, um ein SageMaker AI-Estimator-Objekt zu konfigurieren. Das folgende Codebeispiel konfiguriert einen SageMaker PyTorch AI-Schätzer.
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator=Estimator(
image_uri=ecr_image,
role=get_execution_role(),
base_job_name='pytorch-extended-container-test',
instance_count=1,
instance_type='ml.p2.xlarge'
)
# start training
estimator.fit()
# deploy the trained model
predictor=estimator.deploy(1, instance_type)
```
### Schritt 6: Bereinigen von Ressourcen
**So bereinigen Sie die Ressourcen, wenn Sie mit dem Beispiel Erste Schritte fertig sind**
1. **Öffnen Sie die [SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/), wählen Sie die Notebook-Instanz aus **RunScriptNotebookInstance**, wählen Sie **Aktionen** und dann Stopp aus.** Das Anhalten der Instance kann einige Minuten dauern.
1. Nachdem sich der Instance-**Status** auf **Gestoppt** geändert hat, wählen Sie **Aktionen**, dann **Löschen** und anschließend im Dialogfeld **Löschen** aus. Das Löschen der Instance kann einige Minuten dauern. Die Notebook-Instance verschwindet aus der Tabelle, wenn sie gelöscht wurde.
1. Öffnen Sie die [Amazon S3-Konsole](https://console.aws.amazon.com/s3/) und löschen Sie den Bucket, den Sie zum Speichern von Modellartefakten und dem Trainingsdatensatz erstellt haben.
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/) und löschen Sie die IAM-Rolle. Wenn Sie Berechtigungsrichtlinien erstellt haben, können Sie diese ebenfalls löschen.
**Anmerkung**
Der Docker-Container wird nach seiner Ausführung automatisch beendet. Sie müssen ihn nicht löschen.
# Benutzerdefinierte Docker-Container mit KI SageMaker
Sie können ein vorhandenes Docker-Image so anpassen, dass es mit KI funktioniert. SageMaker Möglicherweise müssen Sie ein vorhandenes, externes Docker-Image mit SageMaker KI verwenden, wenn Sie über einen Container verfügen, der Funktions- oder Sicherheitsanforderungen erfüllt, die derzeit nicht von einem vorgefertigten SageMaker KI-Image unterstützt werden. Es gibt zwei Toolkits, mit denen Sie Ihren eigenen Container mitbringen und ihn an die Arbeit mit KI anpassen können: SageMaker
+ [SageMaker Schulungs-Toolkit](https://github.com/aws/sagemaker-training-toolkit) — Verwenden Sie dieses Toolkit für das Training von Modellen mit KI. SageMaker
+ [SageMaker AI Inference Toolkit — Verwenden Sie dieses Toolkit](https://github.com/aws/sagemaker-inference-toolkit) für die Bereitstellung von Modellen mit KI. SageMaker
In den folgenden Themen wird gezeigt, wie Sie Ihr vorhandenes Image mithilfe der Toolkits SageMaker Training und Inference anpassen können:
**Topics**
+ [Einzelne Framework-Bibliotheken](#docker-containers-adapt-your-own-frameworks)
+ [SageMaker Schulungs- und Inferenz-Toolkits](amazon-sagemaker-toolkits.md)
+ [Den eigenen Trainingscontainer anpassen](adapt-training-container.md)
+ [Passen Sie Ihren eigenen Inferenzcontainer für Amazon SageMaker AI an](adapt-inference-container.md)
## Einzelne Framework-Bibliotheken
Neben dem SageMaker Training Toolkit und dem SageMaker AI Inference Toolkit bietet SageMaker AI auch Toolkits, die auf,, und Chainer spezialisiert sind. TensorFlow MXNet PyTorch Die folgende Tabelle enthält Links zu den GitHub Repositorys, die den Quellcode für jedes Framework und die jeweiligen Serving-Toolkits enthalten. Die verlinkten Anweisungen beziehen sich auf die Verwendung des Python-SDK zum Ausführen von Trainingsalgorithmen und Hostmodellen auf SageMaker KI. Die Funktionalität für diese einzelnen Bibliotheken ist im SageMaker AI Training Toolkit und im SageMaker AI Inference Toolkit enthalten.
| Framework | Toolkit-Quellcode |
| --- | --- |
| TensorFlow | [SageMaker KI-Schulung TensorFlow ](https://github.com/aws/sagemaker-tensorflow-training-toolkit) [SageMaker TensorFlow KI-Dienste](https://github.com/aws/sagemaker-tensorflow-serving-container) |
| MXNet | [SageMaker MXNet KI-Schulung](https://github.com/aws/sagemaker-mxnet-training-toolkit) [SageMaker MXNet KI-Inferenz](https://github.com/aws/sagemaker-mxnet-inference-toolkit) |
| PyTorch | [SageMaker KI-Schulung PyTorch ](https://github.com/aws/sagemaker-pytorch-training-toolkit) [SageMaker PyTorch KI-Inferenz](https://github.com/aws/sagemaker-pytorch-inference-toolkit) |
| Chainer | [SageMaker AI Chainer SageMaker KI-Container](https://github.com/aws/sagemaker-chainer-container) |
# SageMaker Schulungs- und Inferenz-Toolkits
Die Toolkits [SageMaker Training](https://github.com/aws/sagemaker-training-toolkit) und [SageMaker AI Inference](https://github.com/aws/sagemaker-inference-toolkit) implementieren die Funktionen, die Sie benötigen, um Ihre Container an die Ausführung von Skripten, das Trainieren von Algorithmen und die Bereitstellung von Modellen auf KI anzupassen. SageMaker Bei der Installation definiert die Bibliothek Folgendes für Benutzer:
+ Die Speicherorte für das Speichern von Code und anderen Ressourcen.
+ Der Eintrittspunkt, der den Code enthält, der beim Starten des Containers ausgeführt werden soll. Ihr Dockerfile muss den Code, der ausgeführt werden muss, an den Speicherort kopieren, den ein mit KI kompatibler Container erwartet. SageMaker
+ Andere Informationen, die ein Container für die Verwaltung von Bereitstellungen für Training und Inferenz benötigt.
## SageMaker Struktur der Container in den KI-Toolkits
Wenn SageMaker KI ein Modell trainiert, erstellt es die folgende Dateiordnerstruktur im `/opt/ml` Verzeichnis des Containers.
```
/opt/ml
├── input
│ ├── config
│ │ ├── hyperparameters.json
│ │ └── resourceConfig.json
│ └── data
│ └──
│ └──
├── model
│
├── code
│
├── output
│
└── failure
```
Wenn Sie einen *Modelltrainingsjob* ausführen, verwendet der SageMaker AI-Container das `/opt/ml/input/` Verzeichnis, das die JSON-Dateien enthält, mit denen die Hyperparameter für den Algorithmus und das für das verteilte Training verwendete Netzwerklayout konfiguriert werden. Das `/opt/ml/input/` Verzeichnis enthält auch Dateien, die die Kanäle angeben, über die SageMaker KI auf die Daten zugreift, die in Amazon Simple Storage Service (Amazon S3) gespeichert sind. Die SageMaker AI-Container-Bibliothek platziert die Skripts, die der Container ausführen wird, im `/opt/ml/code/` Verzeichnis. Ihr Skript sollte das von Ihrem Algorithmus generierte Modell in das Verzeichnis `/opt/ml/model/` schreiben. Weitere Informationen finden Sie unter [Container mit benutzerdefinierten Trainingsalgorhythmen](your-algorithms-training-algo.md).
Wenn Sie ein trainiertes Modell auf SageMaker KI *hosten*, um daraus Schlüsse zu ziehen, stellen Sie das Modell auf einem HTTP-Endpunkt bereit. Das Modell erstellt Echtzeitprognosen als Antwort auf Inferenzanforderungen. Der Container muss einen Serving-Stack enthalten, um diese Anforderungen zu verarbeiten.
In einem Hosting- oder Batch-Transformationscontainer befinden sich die Modelldateien im selben Ordner, in den sie während des Trainings geschrieben wurden.
```
/opt/ml/model
│
└──
```
Weitere Informationen finden Sie unter [Container mit benutzerdefiniertem Inferenzcode](your-algorithms-inference-main.md).
## Einzelne versus mehrere Container
Sie können entweder separate Docker-Images für den Trainingsalgorithmus und Inferenzcode bereitstellen oder beides in einem einzigen Docker-Image kombinieren. Beachten Sie bei der Erstellung von Docker-Images für die Verwendung mit SageMaker KI Folgendes:
+ Durch die Bereitstellung von zwei Docker-Images können die Speicheranforderungen sowie die Kosten steigen, da allgemeine Bibliotheken möglicherweise dupliziert werden.
+ Im Allgemeinen starten kleinere Container für Training und Hosting schneller. Modelle lernen schneller und der Hosting-Service kann durch die automatische Skalierung schneller auf erhöhten Datenverkehr reagieren.
+ Sie können unter Umständen einen Inferenzcontainer schreiben, der erheblich kleiner ist als der Trainingscontainer. Dies ist besonders häufig der Fall, wenn Sie es GPUs für Schulungen verwenden, Ihr Inferenzcode jedoch dafür optimiert ist. CPUs
+ SageMaker KI erfordert, dass Docker-Container ohne privilegierten Zugriff ausgeführt werden.
+ Sowohl von Ihnen erstellte als auch von SageMaker KI bereitgestellte Docker-Container können Nachrichten an die Dateien `Stdout` und `Stderr` senden. SageMaker KI sendet diese Nachrichten an CloudWatch Amazon-Logs in Ihrem AWS Konto.
Weitere Informationen zur Erstellung von SageMaker KI-Containern und zur Ausführung von Skripten in ihnen finden Sie in den Repositorys [SageMaker AI Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) und [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) unter. GitHub Sie enthalten auch Listen mit wichtigen Umgebungsvariablen und den Umgebungsvariablen, die von KI-Containern bereitgestellt werden. SageMaker
# Den eigenen Trainingscontainer anpassen
Um Ihr eigenes Trainingsmodell auszuführen, erstellen Sie mithilfe des [Amazon SageMaker Training Toolkit über eine SageMaker Amazon-Notebook-Instance](https://github.com/aws/sagemaker-training-toolkit) einen Docker-Container.
## Schritt 1: Erstellen Sie eine SageMaker Notebook-Instance
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im linken Navigationsbereich **Notebook**, wählen Sie danach **Notebook-Instances** und anschließend **Notebook-Instance erstellen**.
1. Geben Sie auf der Seite **Notebook-Instance erstellen** folgende Informationen ein:
1. Geben Sie unter **Notebook instance name (Name der Notebook-Instance)** **RunScriptNotebookInstance** ein.
1. Wählen Sie für **Notebook instance type (Typ der Notebook-Instance)** **ml.t2.medium** aus.
1. Im Abschnitt **Berechtigungen und Verschlüsselung** gehen Sie wie folgt vor:
1. Wählen Sie für **IAM Role (IAM-Rolle)** die Option **Create a New Role (Neue Rolle erstellen)** aus. Dies öffnet ein neues Fenster.
1. Wählen Sie auf der Seite **IAM-Rolle erstellen** die Option **Bestimmte S3-Buckets** aus, geben Sie einen Amazon-S3-Bucket mit dem Namen **sagemaker-run-script** an und wählen Sie dann **Rolle erstellen** aus.
SageMaker AI erstellt eine IAM-Rolle mit dem Namen`AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS`. Beispiel, `AmazonSageMaker-ExecutionRole-20190429T110788`. Beachten Sie, dass bei der Namenskonvention für Ausführungsrollen das Datum und die Uhrzeit verwendet werden, zu denen die Rolle erstellt wurde, getrennt durch einen `T`.
1. Wählen Sie für **Root Access (Root-Zugriff)** die Option **Enabled (Aktiviert)** aus.
1. Wählen Sie **Create notebook instance (Notebook-Instance erstellen)** aus.
1. Auf der Seite **Notebook-Instances** lautet der **Status** **Ausstehend**. Es kann einige Minuten dauern, bis Amazon SageMaker AI eine Recheninstanz für maschinelles Lernen startet — in diesem Fall startet sie eine Notebook-Instance — und ihr ein ML-Speichervolume anhängt. Die Notebook-Instance verfügt über einen vorkonfigurierten Jupyter-Notebook-Server und mehrere Anaconda-Bibliotheken. Weitere Informationen finden Sie unter [ CreateNotebookInstance](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html).
1. Klicken Sie auf den **Namen** des Notebooks, das Sie gerade erstellt haben. Dies öffnet eine neue Seite.
1. Kopieren Sie im Abschnitt **Berechtigungen und Verschlüsselung** **die ARN-Nummer der IAM-Rolle** und fügen Sie sie in eine Notepad-Datei ein, um sie vorübergehend zu speichern. Sie verwenden diese IAM-Rollen-ARN-Nummer später, um einen lokalen Trainingsschätzer in der Notebook-Instance zu konfigurieren. **Die ARN-Nummer der IAM-Rolle** sieht wie folgt aus: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`
1. Nachdem sich der Status der Notebook-Instanz auf geändert hat **InService**, wählen Sie **Öffnen JupyterLab**.
## Schritt 2: Erstellen und Hochladen der Dockerdatei und der Python-Trainingsskripte
1. Erstellen Sie nach dem JupyterLab Öffnen einen neuen Ordner im Home-Verzeichnis Ihres JupyterLab. Wählen Sie links oben das Symbol **Neuer Ordner** und geben Sie dann den Ordnernamen `docker_test_folder` ein.
1. Erstellen Sie in dem Verzeichnis `docker_test_folder` eine Datei namens `Dockerfile`.
1. Wählen Sie das Symbol **Neuer Launcher** (\$1) in der oberen linken Ecke.
1. Wählen Sie im rechten Bereich unter dem Abschnitt **Andere** die Option **Textdatei**.
1. Fügen Sie den folgenden `Dockerfile`-Beispielcode in Ihre Textdatei ein.
```
#Download an open source TensorFlow Docker image
FROM tensorflow/tensorflow:latest-gpu-jupyter
# Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker AI and the Python SDK.
RUN pip3 install sagemaker-training
# Copies the training code inside the container
COPY train.py /opt/ml/code/train.py
# Defines train.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```
Das Dockerfile-Skript führt die folgenden Aufgaben aus:
+ `FROM tensorflow/tensorflow:latest-gpu-jupyter`— Lädt das neueste TensorFlow Docker-Basis-Image herunter. Sie können dies durch jedes Docker-Basis-Image ersetzen, das Sie zum Erstellen von Containern verwenden möchten, sowie durch AWS vorgefertigte Container-Basis-Images.
+ `RUN pip install sagemaker-training`— Installiert das [SageMaker AI Training Toolkit](https://github.com/aws/sagemaker-training-toolkit), das die allgemeinen Funktionen enthält, die zur Erstellung eines mit KI kompatiblen Containers erforderlich sind. SageMaker
+ `COPY train.py /opt/ml/code/train.py`— Kopiert das Skript an die Stelle innerhalb des Containers, die von der SageMaker KI erwartet wird. Das Skript muss sich in diesem Ordner befinden.
+ `ENV SAGEMAKER_PROGRAM train.py` – Verwendet Ihr Trainingsskript `train.py` als Einstiegsskript, das in den `/opt/ml/code` Ordner des Containers kopiert wird. Dies ist die einzige Umgebungsvariable, die Sie angeben müssen, wenn Sie Ihren eigenen Container erstellen.
1. In der linken Verzeichnisnavigation wird der Name der Textdatei automatisch auf `untitled.txt` festgelegt. Um die Datei umzubenennen, klicken Sie mit der rechten Maustaste auf die Datei, wählen Sie **Umbenennen**, benennen Sie die Datei in `Dockerfile` um ohne die `.txt`-Erweiterung, und drücken Sie dann auf `Ctrl+s` oder `Command+s`, um die Datei zu speichern.
1. Laden Sie ein Trainingsskript `train.py` in den `docker_test_folder` hoch. Sie können das folgende Beispielskript verwenden, um ein Modell zu erstellen, das handgeschriebene Ziffern liest, die mit dem [MNIST-Datensatz](https://en.wikipedia.org/wiki/MNIST_database) für diese Übung trainiert wurden.
```
import tensorflow as tf
import os
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=1)
model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"
model.evaluate(x_test, y_test)
tf.saved_model.save(model, model_save_dir)
```
## Schritt 3: Erstellen des Containers
1. Öffnen Sie im JupyterLab Home-Verzeichnis ein Jupyter-Notizbuch. Um ein neues Notebook zu öffnen, wählen Sie das Symbol **New Launch** und wählen Sie dann im Abschnitt **Notebook** die neueste Version von **conda\$1tensorflow2** aus.
1. Führen Sie den folgenden Befehl in der ersten Notebook-Zelle aus, um in das Verzeichnis `docker_test_folder` zu wechseln:
```
cd ~/SageMaker/docker_test_folder
```
Dies gibt Ihr aktuelles Verzeichnis wie folgt zurück:
```
! pwd
```
`output: /home/ec2-user/SageMaker/docker_test_folder`
1. Zum Erstellen des Docker-Containers führen Sie den folgenden Docker-Build-Befehl, einschließlich der Leertaste gefolgt vom Punkt am Ende, aus.
```
! docker build -t tf-custom-container-test .
```
Der Docker-Build-Befehl muss von der von Ihnen erstellten Docker-Registry aus ausgeführt werden. In diesem Fall ist dies `docker_test_folder`.
**Anmerkung**
Wenn Sie die folgende Fehlermeldung erhalten, dass Docker das Dockerfile nicht finden kann, stellen Sie sicher, dass das Dockerfile den richtigen Namen hat und im Verzeichnis gespeichert wurde.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory
```
Denken Sie daran, dass `docker` im aktuellen Verzeichnis spezifisch nach einer Datei namens `Dockerfile` ohne Erweiterung sucht. Wenn Sie sie anders benannt haben, können Sie den Dateinamen manuell mit dem `-f`-Argument übergeben. Wenn Sie Ihre Docker-Datei beispielsweise als benannt `Dockerfile-text.txt` haben, führen Sie den folgenden Befehl aus:
```
! docker build -t tf-custom-container-test -f Dockerfile-text.txt .
```
## Schritt 4: Testen des Containers
1. Um den Container lokal für die Notebook-Instance zu testen, öffnen Sie ein Jupyter Notebook. Wählen Sie **New Launcher** und wählen Sie im Bereich **Notebook** die neueste Version von **conda\$1tensorflow2** aus.
1. Fügen Sie das folgende Beispielskript in die Notebook-Codezelle ein, um einen SageMaker AI Estimator zu konfigurieren.
```
import sagemaker
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri='tf-custom-container-test',
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='local')
estimator.fit()
```
Im vorherigen Codebeispiel `sagemaker.get_execution_role()` wird für das `role` Argument angegeben, automatisch die für die SageMaker AI-Sitzung eingerichtete Rolle abzurufen. Sie können ihn auch durch den String-Wert der **ARN-Nummer der IAM-Rolle** ersetzen, die Sie bei der Konfiguration der Notebook-Instance verwendet haben. Der ARN sollte wie folgt aussehen: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`.
1. Führen Sie die Code-Zelle aus. Dieser Test gibt die Konfiguration der Trainingsumgebung, die Werte für die Umgebungsvariablen, die Quelle der Daten sowie den Verlust und die Genauigkeit aus, die bei dem Training erreicht wurden.
## Schritt 5: Senden des Containers an die Amazon Elastic Container Registry (Amazon ECR)
1. Nachdem Sie diesen lokalen Modus-Test erfolgreich ausgeführt haben, können Sie den Docker-Container zu [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) senden und ihn zum Ausführen von Trainingsaufträgen verwenden. Wenn Sie anstelle von Amazon ECR eine private Docker-Registry verwenden möchten, finden Sie weitere Informationen unter [Senden Sie Ihren Training-Container zu einem privaten Verzeichnis](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry.html).
Führen Sie die folgenden Befehlszeilen in einer Notebook-Zelle aus.
```
%%sh
# Specify an algorithm name
algorithm_name=tf-custom-container-test
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
**Anmerkung**
Dieses Bash-Shell-Skript kann ein Berechtigungsproblem auslösen, das der folgenden Fehlermeldung ähnelt:
```
"denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"
```
Wenn dieser Fehler auftritt, müssen Sie die **EC2ContainerRegistryFullAccessAmazon-Richtlinie** an Ihre IAM-Rolle anhängen. Gehen Sie zur [IAM-Konsole](https://console.aws.amazon.com/iam/home), wählen Sie im linken Navigationsbereich **Rollen** aus und suchen Sie nach der Instance, die IAMrole Sie für die Notebook-Instance verwendet haben. Wählen Sie auf der Registerkarte „**Genehmigung**“ die Schaltfläche „**Richtlinien anhängen**“ und suchen Sie nach der **EC2ContainerRegistryFullAccessAmazon-Richtlinie**. Aktivieren Sie das Kontrollkästchen für die Richtlinie und wählen Sie zum Abschluss **Berechtigungen hinzufügen** aus.
1. Führen Sie den folgenden Code in einer Studio-Notebook-Zelle aus, um das Amazon-ECR-Image Ihres Trainingscontainers aufzurufen.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest
```
1. Verwenden Sie das aus dem vorherigen Schritt `ecr_image` abgerufene Objekt, um ein SageMaker AI-Estimator-Objekt zu konfigurieren. Das folgende Codebeispiel konfiguriert einen SageMaker AI-Schätzer mit dem `byoc_image_uri` und initiiert einen Trainingsjob auf einer Amazon EC2 EC2-Instance.
------
#### [ SageMaker Python SDK v1 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
#### [ SageMaker Python SDK v2 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
1. Wenn Sie Ihr Modell mithilfe Ihres eigenen Containers bereitstellen möchten, finden Sie weitere Informationen unter [Anpassung Ihres eigenen Inferenz-Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-inference-container.html). Sie können auch einen AWS Framework-Container verwenden, der ein Modell bereitstellen kann. TensorFlow Um das Beispielmodell zum Lesen handgeschriebener Ziffern bereitzustellen, geben Sie das folgende Beispielskript in dasselbe Notizbuch ein, mit dem Sie Ihr Modell im vorherigen Teilschritt trainiert haben, um das für die Bereitstellung benötigte Image URIs (Universal Resource Identifiers) zu erhalten, und stellen Sie das Modell bereit.
```
import boto3
import sagemaker
#obtain image uris
from sagemaker import image_uris
container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
image_scope='inference',instance_type='ml.g4dn.xlarge')
#create the model entity, endpoint configuration and endpoint
predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)
```
Testen Sie Ihr Modell anhand einer handgeschriebenen Beispielziffer aus dem MNIST-Datensatz anhand des folgenden Codebeispiels.
```
#Retrieve an example test dataset to test
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
# Load the MNIST dataset and split it into training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Select a random example from the training set
example_index = np.random.randint(0, x_train.shape[0])
example_image = x_train[example_index]
example_label = y_train[example_index]
# Print the label and show the image
print(f"Label: {example_label}")
plt.imshow(example_image, cmap='gray')
plt.show()
```
Wandeln Sie die handgeschriebene Testziffer in ein Formular um, das Daten aufnehmen und eine Testprognose erstellen TensorFlow kann.
```
from sagemaker.serializers import JSONSerializer
data = {"instances": example_image.tolist()}
predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
predictor.predict(data) #make the prediction
```
Ein vollständiges Beispiel, das zeigt, wie ein benutzerdefinierter Container lokal getestet und auf ein Amazon ECR-Image übertragen wird, finden Sie im Beispielnotizbuch [Building Your TensorFlow Own Container](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.html).
**Tipp**
Verwenden Sie Amazon Debugger, um Trainingsjobs zu profilieren und zu debuggen, um Probleme mit der Systemauslastung (wie CPU-Engpässe und GPU-Unterauslastung) zu überwachen und Trainingsprobleme zu identifizieren (wie Überanpassung, Übertraining, explodierende Tensoren und verschwindende Gradienten). SageMaker Weitere Informationen finden Sie unter [Verwenden Sie den Debugger mit benutzerdefinierten Trainingscontainern](debugger-bring-your-own-container.md).
## Schritt 6: Bereinigen von Ressourcen
**So bereinigen Sie Ressourcen im Anschluss an das Einstiegsbeispiel**
1. ****Öffnen Sie die [SageMaker AI-Konsole, wählen Sie die Notebook-Instance](https://console.aws.amazon.com/sagemaker/) aus, wählen Sie Aktionen und dann Stopp. **RunScriptNotebookInstance****** Das Anhalten der Instance kann einige Minuten dauern.
1. Nachdem sich der Instance-**Status** auf **Gestoppt** geändert hat, wählen Sie **Aktionen**, dann **Löschen** und anschließend im Dialogfeld **Löschen** aus. Das Löschen der Instance kann einige Minuten dauern. Die Notebook-Instance verschwindet aus der Tabelle, wenn sie gelöscht wurde.
1. Öffnen Sie die [Amazon S3-Konsole](https://console.aws.amazon.com/s3/) und löschen Sie den Bucket, den Sie zum Speichern von Modellartefakten und dem Trainingsdatensatz erstellt haben.
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/) und löschen Sie die IAM-Rolle. Wenn Sie Berechtigungsrichtlinien erstellt haben, können Sie diese ebenfalls löschen.
**Anmerkung**
Der Docker-Container wird nach seiner Ausführung automatisch beendet. Sie müssen ihn nicht löschen.
## Blogs und Fallstudien
In den folgenden Blogs werden Fallstudien zur Verwendung von benutzerdefinierten Trainingscontainern in Amazon SageMaker AI behandelt.
+ [Warum sollten Sie Ihren eigenen Container zu Amazon SageMaker AI bringen und wie Sie es richtig machen](https://medium.com/@pandey.vikesh/why-bring-your-own-container-to-amazon-sagemaker-and-how-to-do-it-right-bc158fe41ed1), *Medium* (20. Januar 2023)
# Passen Sie Ihren Trainingsauftrag so an, dass Sie auf Images in einer privaten Docker-Registry zugreifen können
Sie können eine private [Docker-Registry](https://docs.docker.com/registry/) anstelle einer Amazon Elastic Container Registry (Amazon ECR) verwenden, um Ihre Images für SageMaker AI Training zu hosten. Die folgenden Anweisungen zeigen Ihnen, wie Sie eine Docker-Registry erstellen, Ihre Virtual Private Cloud (VPC) und Ihren Trainingsjob konfigurieren, Images speichern und SageMaker KI Zugriff auf das Trainings-Image in der privaten Docker-Registry gewähren. Diese Anweisungen zeigen Ihnen auch, wie Sie eine Docker-Registry verwenden, für die eine Authentifizierung für einen Trainingsjob erforderlich ist. SageMaker
## Erstellen und Speichern Ihrer Images in einer privaten Docker-Registry
Erstellen Sie eine private Docker-Registry, um Ihre Images zu speichern. Ihre Registry muss:
+ das Protokoll [Docker Registry HTTP API](https://docs.docker.com/registry/spec/api/) verwenden
+ von derselben VPC aus zugänglich sein, die im [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)Parameter in der `CreateTrainingJob` API angegeben ist. Geben Sie `VpcConfig` ein, wenn Sie Ihren Trainingsauftrag erstellen.
+ gesichert mit einem [TLS-Zertifikat](https://aws.amazon.com/what-is/ssl-certificate/) einer bekannten öffentlichen Zertifizierungsstelle.
Weitere Informationen zum Erstellen einer Docker-Registry finden Sie unter [Bereitstellen eines Registry-Servers](https://docs.docker.com/registry/deploying/).
## Konfigurieren Sie Ihre VPC und Ihren SageMaker Trainingsjob
SageMaker KI verwendet eine Netzwerkverbindung innerhalb Ihrer VPC, um auf Images in Ihrer Docker-Registry zuzugreifen. Um die Images in Ihrer Docker-Registry für Training zu verwenden, muss das Verzeichnis von einer Amazon-VPC in Ihrem Konto aus zugänglich sein. Weitere Informationen finden Sie unter [Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist](docker-containers-adapt-your-own-private-registry-authentication.md).
Sie müssen Ihren Trainingsauftrag auch so konfigurieren, dass er eine Verbindung zu derselben VPC herstellt, auf die Ihre Docker-Registry Zugriff hat. Weitere Informationen finden Sie unter [Einen Trainingsauftrag für Amazon VPC Access konfigurieren](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure).
## Erstellen Sie einen Trainingsauftrag mit einem Image aus Ihrer privaten Docker-Registry
Um ein Image aus Ihrer privaten Docker-Registry für Training zu verwenden, folgen Sie der folgenden Anleitung, um Ihr Image zu konfigurieren, und einen Trainingsauftrag zu konfigurieren und erstellen. In den folgenden Codebeispielen wird der AWS SDK für Python (Boto3) Client verwendet.
1. Erstellen Sie ein Trainings-Image-Konfigurationsobjekt und geben Sie `Vpc` in das `TrainingRepositoryAccessMode` Feld wie folgt ein.
```
training_image_config = {
'TrainingRepositoryAccessMode': 'Vpc'
}
```
**Anmerkung**
Wenn Ihre private Docker-Registry eine Authentifizierung erfordert, müssen Sie dem Trainings-Image-Konfigurationsobjekt ein `TrainingRepositoryAuthConfig` Objekt hinzufügen. Sie müssen auch den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion angeben, die mithilfe des `TrainingRepositoryCredentialsProviderArn` Felds des `TrainingRepositoryAuthConfig` Objekts Zugangsdaten für SageMaker KI bereitstellt. Weitere Informationen finden Sie in der nachstehenden Beispiel-Code-Struktur.
```
training_image_config = {
'TrainingRepositoryAccessMode': 'Vpc',
'TrainingRepositoryAuthConfig': {
'TrainingRepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName'
}
}
```
Weitere Informationen zum Erstellen der Lambda-Funktion für die Authentifizierung finden Sie unter [Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist](docker-containers-adapt-your-own-private-registry-authentication.md).
1. Verwenden Sie einen Boto3-Client, um einen Trainingsauftrag zu erstellen und die richtige Konfiguration an die [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)-API zu übergeben. Die folgenden Anweisungen zeigen Ihnen, wie Sie die Komponenten konfigurieren und einen Trainingsauftrag erstellen.
1. Erstellen Sie das `AlgorithmSpecification` Objekt, das Sie an `create_training_job` senden möchten. Verwenden Sie das Trainings-Image-Konfigurationsobjekt, das Sie im vorherigen Schritt erstellt haben, wie im folgenden Codebeispiel gezeigt.
```
algorithm_specification = {
'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:',
'TrainingImageConfig': training_image_config,
'TrainingInputMode': 'File'
}
```
**Anmerkung**
Wenn Sie statt einer aktualisierten Version eines Images eine feste Version verwenden möchten, beziehen Sie sich auf den [Digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) des Images und nicht auf den Namen oder das Tag.
1. Geben Sie den Namen des Trainingsauftrags und der Rolle an, den Sie an `create_training_job` senden möchten, wie im folgenden Codebeispiel gezeigt.
```
training_job_name = 'private-registry-job'
execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole'
```
1. Geben Sie eine Sicherheitsgruppe und ein Subnetz für die VPC-Konfiguration für Ihren Trainingsauftrag an. Ihre private Docker-Registry muss eingehenden Datenverkehr von den von Ihnen angegebenen Sicherheitsgruppen zulassen, wie im folgenden Codebeispiel gezeigt.
```
vpc_config = {
'SecurityGroupIds': ['sg-0123456789abcdef0'],
'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
}
```
**Anmerkung**
Wenn sich Ihr Subnetz nicht in derselben VPC wie Ihre private Docker-Registry befindet, müssen Sie eine Netzwerkverbindung zwischen den beiden einrichten. VPCs SeeConnect VPCs Verwenden Sie [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) für weitere Informationen.
1. Geben Sie die Ressourcenkonfiguration an, einschließlich Rechen-Instances für Machine Learning und Speichervolumes, die für das Training verwendet werden sollen, wie im folgenden Codebeispiel gezeigt.
```
resource_config = {
'InstanceType': 'ml.m4.xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 10,
}
```
1. Geben Sie die Konfiguration der Eingabe- und Ausgabedaten an, wo der Trainingsdatensatz gespeichert wird und wo Sie Modellartefakte speichern möchten, wie im folgenden Codebeispiel gezeigt.
```
input_data_config = [
{
"ChannelName": "training",
"DataSource":
{
"S3DataSource":
{
"S3DataDistributionType": "FullyReplicated",
"S3DataType": "S3Prefix",
"S3Uri": "s3://your-training-data-bucket/training-data-folder"
}
}
}
]
output_data_config = {
'S3OutputPath': 's3://your-output-data-bucket/model-folder'
}
```
1. Geben Sie die maximale Anzahl von Sekunden an, für die ein Modelltrainingsauftrag ausgeführt werden kann, wie im folgenden Codebeispiel gezeigt.
```
stopping_condition = {
'MaxRuntimeInSeconds': 1800
}
```
1. Erstellen Sie abschließend den Trainingsauftrag mit den Parametern, die Sie in den vorherigen Schritten angegeben haben, wie im folgenden Codebeispiel gezeigt.
```
import boto3
sm = boto3.client('sagemaker')
try:
resp = sm.create_training_job(
TrainingJobName=training_job_name,
AlgorithmSpecification=algorithm_specification,
RoleArn=execution_role_arn,
InputDataConfig=input_data_config,
OutputDataConfig=output_data_config,
ResourceConfig=resource_config,
VpcConfig=vpc_config,
StoppingCondition=stopping_condition
)
except Exception as e:
print(f'error calling CreateTrainingJob operation: {e}')
else:
print(resp)
```
# Verwenden Sie einen SageMaker KI-Schätzer, um einen Trainingsjob auszuführen
Sie können auch einen [Schätzer](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) aus dem SageMaker Python-SDK verwenden, um die Konfiguration und Ausführung Ihres SageMaker Trainingsjobs zu übernehmen. In den folgenden Codebeispielen wird gezeigt, wie ein Schätzer mithilfe von Images aus einer privaten Docker-Registry konfiguriert und ausführt wird.
1. Importieren Sie die erforderlichen Bibliotheken und Abhängigkeiten wie im folgenden Codebeispiel:
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
session = sagemaker.Session()
role = sagemaker.get_execution_role()
```
1. Geben Sie einen Uniform Resource Identifier (URI) für Ihr Trainings-Image, Ihre Sicherheitsgruppen und Subnetze für die VPC-Konfiguration für Ihren Trainingsauftrag ein, wie im folgenden Codebeispiel gezeigt.
```
image_uri = "myteam.myorg.com/docker-local/my-training-image:"
security_groups = ["sg-0123456789abcdef0"]
subnets = ["subnet-0123456789abcdef0", "subnet-0123456789abcdef0"]
```
Weitere Informationen zu `security_group_ids` und `subnets` finden Sie in der entsprechenden Parameterbeschreibung im Abschnitt [Estimators](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) des SageMaker Python-SDK.
**Anmerkung**
SageMaker KI verwendet eine Netzwerkverbindung innerhalb Ihrer VPC, um auf Images in Ihrer Docker-Registry zuzugreifen. Um die Images in Ihrer Docker-Registry für Training zu verwenden, muss das Verzeichnis von einer Amazon-VPC in Ihrem Konto aus zugänglich sein.
1. Wenn Ihre Docker-Registry eine Authentifizierung erfordert, müssen Sie optional auch den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion angeben, die Zugangsdaten für SageMaker KI bereitstellt. Das folgende Codebeispiel zeigt, wie der ARN anzugeben ist.
```
training_repository_credentials_provider_arn = "arn:aws:lambda:us-west-2:1234567890:function:test"
```
Weitere Informationen zur Verwendung von Images in einer Docker-Registry, für die eine Authentifizierung erforderlich ist, finden Sie weiter unten unter **Verwenden einer Docker-Registry, für die eine Authentifizierung erforderlich ist**.
1. Verwenden Sie die Codebeispiele aus den vorherigen Schritten, um einen Schätzer zu konfigurieren, wie im folgenden Codebeispiel gezeigt.
```
# The training repository access mode must be 'Vpc' for private docker registry jobs
training_repository_access_mode = "Vpc"
# Specify the instance type, instance count you want to use
instance_type="ml.m5.xlarge"
instance_count=1
# Specify the maximum number of seconds that a model training job can run
max_run_time = 1800
# Specify the output path for the model artifacts
output_path = "s3://your-output-bucket/your-output-path"
estimator = Estimator(
image_uri=image_uri,
role=role,
subnets=subnets,
security_group_ids=security_groups,
training_repository_access_mode=training_repository_access_mode,
training_repository_credentials_provider_arn=training_repository_credentials_provider_arn, # remove this line if auth is not needed
instance_type=instance_type,
instance_count=instance_count,
output_path=output_path,
max_run=max_run_time
)
```
1. Starten Sie Ihren Trainingsauftrag, indem Sie `estimator.fit` mit Ihrem Auftragsnamen und Eingabepfad als Parameter aufrufen, wie im folgenden Codebeispiel gezeigt.
```
input_path = "s3://your-input-bucket/your-input-path"
job_name = "your-job-name"
estimator.fit(
inputs=input_path,
job_name=job_name
)
```
# Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist
Wenn Ihre Docker-Registry eine Authentifizierung erfordert, müssen Sie eine AWS Lambda Funktion erstellen, die Zugangsdaten für KI bereitstellt. SageMaker Erstellen Sie dann einen Trainingsauftrag und geben Sie den ARN dieser Lambda-Funktion in der [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)-API an. Schließlich können Sie optional einen VPC-Schnittstellen-Endpunkt erstellen, sodass Ihre VPC mit Ihrer Lambda-Funktion kommunizieren kann, ohne Datenverkehr über das Internet zu senden. Die folgende Anleitung zeigt, wie Sie eine Lambda-Funktion erstellen, ihr die richtige Rolle zuweisen und einen Schnittstellen-VPC-Endpunkt erstellen.
## So erstellen Sie die Lambda-Funktion:
Erstellen Sie eine AWS Lambda Funktion, die Zugangsdaten an SageMaker KI weitergibt und eine Antwort zurückgibt. Im folgenden Codebeispiel wird der Lambda-Funktionshandler wie folgt erstellt.
```
def handler(event, context):
response = {
"Credentials": {"Username": "username", "Password": "password"}
}
return response
```
Die Art der Authentifizierung, die zum Einrichten Ihrer privaten Docker-Registry verwendet wird, bestimmt den Inhalt der Antwort, die von Ihrer Lambda-Funktion zurückgegeben wird, wie folgt.
+ Wenn Ihre private Docker-Registry die Standardauthentifizierung verwendet, gibt die Lambda-Funktion den Benutzernamen und das Passwort zurück, die für die Authentifizierung bei der Registrierung erforderlich sind.
+ Wenn Ihre private Docker-Registry die [Bearer-Token-Authentifizierung](https://docs.docker.com/registry/spec/auth/token/) verwendet, werden der Benutzername und das Passwort an Ihren Autorisierungsserver gesendet, der dann ein Bearer-Token zurückgibt. Dieses Token wird dann zur Authentifizierung bei Ihrer privaten Docker-Registry verwendet.
**Anmerkung**
Wenn Sie mehr als eine Lambda-Funktion für Ihre Verzeichnisse in demselben Konto haben und die Ausführungsrolle für Ihre Trainingsaufträge dieselbe ist, dann hätten Trainingsaufträge für Registry One Zugriff auf die Lambda-Funktionen für andere Verzeichnisse.
## Gewähren Sie der Lambda-Funktion die korrekte Rolle.
Die [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html), die Sie in der `create_training_job` API verwenden, muss über die Berechtigung zum Aufrufen einer AWS Lambda Funktion verfügen. Das folgende Codebeispiel zeigt, wie die Berechtigungsrichtlinie einer IAM-Rolle erweitert werden kann, um `myLambdaFunction` aufzurufen.
```
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:*myLambdaFunction*"
]
}
```
Weitere Informationen zum Bearbeiten von Rollenberechtigungsrichtlinien finden Sie unter [Modifizierung einer Rollenberechtigungsrichtline (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) in dem *AWS Benutzerhandbuch für Identitäts- und Zugriffsmanagement*.
**Anmerkung**
Eine IAM-Rolle mit einer angehängten **AmazonSageMakerFullAccess**verwalteten Richtlinie ist berechtigt, jede Lambda-Funktion aufzurufen, deren Name „SageMaker AI“ enthält.
## So erstellen Sie einen Schnittstellen-VPC-Endpunkt für Lambda
Wenn Sie einen Schnittstellenendpunkt erstellen, kann Ihre Amazon VPC mit Ihrer Lambda-Funktion kommunizieren, ohne Datenverkehr über das Internet zu senden. Weitere Informationen finden Sie unter[Konfigurieren von Schnittstellen-VPC-Endpunkten für Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html)im*AWS Lambda Entwicklerhandbuch*.
Nachdem Ihr Schnittstellenendpunkt erstellt wurde, ruft das SageMaker Training Ihre Lambda-Funktion auf, indem eine Anfrage über Ihre VPC an gesendet wird. `lambda.region.amazonaws.com` Wenn Sie bei der Erstellung Ihres Schnittstellenendpunkts die Option **DNS-Name aktivieren** auswählen, leitet [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) den Anruf an den Lambda-Schnittstellenendpunkt weiter. Wenn Sie einen anderen DNS-Anbieter verwenden, müssen Sie `lambda.region.amazonaws.co`, Ihrem Lambda-Schnittstellenendpunkt zuordnen.
# Passen Sie Ihren eigenen Inferenzcontainer für Amazon SageMaker AI an
Wenn Sie keines der in [Vorgefertigte KI-Docker-Images SageMaker](docker-containers-prebuilt.md) Amazon SageMaker AI aufgelisteten Images für Ihren Anwendungsfall verwenden können, können Sie Ihren eigenen Docker-Container erstellen und ihn innerhalb von SageMaker AI für Schulungen und Inferenzen verwenden. Um mit SageMaker KI kompatibel zu sein, muss Ihr Container die folgenden Eigenschaften aufweisen:
+ Ihr Container muss über einen Webserver verfügen, der auf Port `8080` gelistet ist.
+ Ihr Container muss `POST`-Anforderungen an die Echtzeit-Endpunkte `/invocations` und `/ping` akzeptieren. Die Anforderungen, die Sie an diese Endpunkte senden, müssen für reguläre Antworten innerhalb von 60 Sekunden und für Streaming-Antworten innerhalb von 8 Minuten zurückgegeben werden und eine maximale Größe von 25 MB haben.
Weitere Informationen und ein Beispiel dafür, wie Sie Ihren eigenen Docker-Container für Training und Inferenz mit SageMaker KI erstellen, finden Sie unter [Erstellen eines eigenen Algorithmus-Containers](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb).
Die folgende Anleitung zeigt Ihnen, wie Sie einen `JupyterLab` Space mit Amazon SageMaker Studio Classic verwenden, um einen Inferenzcontainer an die Arbeit mit SageMaker KI-Hosting anzupassen. Das Beispiel verwendet einen NGINX-Webserver Gunicorn als Python Webserver Gateway Interface und Flask als Webanwendungs-Framework. Sie können verschiedene Anwendungen verwenden, um Ihren Container anzupassen, solange er die zuvor aufgeführten Anforderungen erfüllt. Weitere Informationen zur Verwendung Ihres eigenen Inferenzcodes finden Sie unter [Benutzerdefinierter Inferenzcode mit Hosting-Services](your-algorithms-inference-code.md).
**Anpassen Ihres Inferenzcontainers**
Verwenden Sie die folgenden Schritte, um Ihren eigenen Inferenzcontainer so anzupassen, dass er mit SageMaker KI-Hosting funktioniert. Das in den folgenden Schritten gezeigte Beispiel verwendet ein vortrainiertes [Named Entity Recognition (NER)-Modell](https://spacy.io/universe/project/video-spacys-ner-model-alt), das die Natural Language Processing (NLP)-Bibliothek [spaCy](https://spacy.io/) für `Python` und Folgendes verwendet:
+ eine Dockerfile, um den Container zu erstellen, der das NER-Modell enthält
+ Inferenzskripte zur Ausführung des NER-Modells
Wenn Sie dieses Beispiel für Ihren Anwendungsfall anpassen, müssen Sie eine Dockerfile und Inferenzskripte verwenden, die für die Bereitstellung und Ausführung Ihres Modells erforderlich sind.
1. Schaffen Sie JupyterLab Speicherplatz mit Amazon SageMaker Studio Classic (optional).
Sie können jedes Notizbuch verwenden, um Skripte auszuführen, um Ihren Inferenzcontainer mit SageMaker KI-Hosting anzupassen. Dieses Beispiel zeigt Ihnen, wie Sie einen JupyterLab Bereich in Amazon SageMaker Studio Classic verwenden, um eine JupyterLab Anwendung zu starten, die mit einem SageMaker AI Distribution-Image geliefert wird. Weitere Informationen finden Sie unter [SageMaker JupyterLab](studio-updated-jl.md).
1. Laden Sie eine Docker-Datei und Inferenzskripte hoch.
1. Erstellen Sie einen neuen Ordner in Ihrem Home-Verzeichnis. Wenn Sie JupyterLab verwenden, wählen Sie in der oberen linken Ecke das Symbol **Neuer Ordner** und geben Sie einen Ordnernamen ein, in dem Ihre Dockerfile abgelegt werden soll. In diesem Beispiel heißt der Ordner `docker_test_folder`.
1. Laden Sie eine Dockerfile-Textdatei in Ihren neuen Ordner hoch. Im Folgenden finden Sie eine Beispiel-Dockerfile, die einen Docker-Container mit einem vortrainierten [Named Entity Recognition (NER)-Modell](https://spacy.io/universe/project/video-spacys-ner-model) von [spaCy](https://spacy.io/) sowie den Anwendungen und Umgebungsvariablen erstellt, die für die Ausführung des Beispiels erforderlich sind:
```
FROM python:3.8
RUN apt-get -y update && apt-get install -y --no-install-recommends \
wget \
python3 \
nginx \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*
RUN wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && \
pip install flask gevent gunicorn && \
rm -rf /root/.cache
#pre-trained model package installation
RUN pip install spacy
RUN python -m spacy download en
# Set environment variables
ENV PYTHONUNBUFFERED=TRUE
ENV PYTHONDONTWRITEBYTECODE=TRUE
ENV PATH="/opt/program:${PATH}"
COPY NER /opt/program
WORKDIR /opt/program
```
Im vorherigen Codebeispiel verhindert die Umgebungsvariable `PYTHONUNBUFFERED`, dass Pythonden Standardausgabestream puffert, was eine schnellere Übermittlung von Protokollen an den Benutzer ermöglicht. Die Umgebungsvariable `PYTHONDONTWRITEBYTECODE` verhindert, dass Python kompilierte `.pyc`-Bytecode-Dateien schreibt, die für diesen Anwendungsfall unnötig sind. Die Umgebungsvariable `PATH` wird verwendet, um den Speicherort der `serve`- und `train`-Programme und zu identifizieren, wenn der Container aufgerufen wird.
1. Erstellen Sie in Ihrem neuen Ordner ein neues Verzeichnis, das Skripte für Ihr Modell enthält. In diesem Beispiel wird ein Verzeichnis namens `NER` verwendet, das die folgenden Skripte enthält, die für die Ausführung dieses Beispiels erforderlich sind:
+ `predictor.py` – ein Python-Skript, das die Logik zum Laden und Durchführen von Inferenzen mit Ihrem Modell enthält
+ `nginx.conf` – ein Skript zur Konfiguration eines Webservers
+ `serve` – ein Skript, das einen Inferenzserver startet
+ `wsgi.py` – ein Hilfsskript zur Ausführung eines Modells
**Wichtig**
Wenn Sie Ihre Inferenzskripten in ein Notizbuch mit der Endung kopieren `.ipynb` und sie umbenennen, kann Ihr Skript Formatierungszeichen enthalten, die verhindern, dass Ihr Endpunkt bereitgestellt wird. Erstellen Sie stattdessen eine Textdatei und benennen Sie sie um.
1. Laden Sie ein Skript hoch, um Ihr Modell für Inferenzen verfügbar zu machen. Im Folgenden finden Sie ein Beispielskript mit dem Namen `predictor.py`, das Flask zur Bereitstellung der `/invocations`- und `/ping`-Endpunkte und verwendet:
```
from flask import Flask
import flask
import spacy
import os
import json
import logging
#Load in model
nlp = spacy.load('en_core_web_sm')
#If you plan to use a your own model artifacts,
#your model artifacts should be stored in /opt/ml/model/
# The flask app for serving predictions
app = Flask(__name__)
@app.route('/ping', methods=['GET'])
def ping():
# Check if the classifier was loaded correctly
health = nlp is not None
status = 200 if health else 404
return flask.Response(response= '\n', status=status, mimetype='application/json')
@app.route('/invocations', methods=['POST'])
def transformation():
#Process input
input_json = flask.request.get_json()
resp = input_json['input']
#NER
doc = nlp(resp)
entities = [(X.text, X.label_) for X in doc.ents]
# Transform predictions to JSON
result = {
'output': entities
}
resultjson = json.dumps(result)
return flask.Response(response=resultjson, status=200, mimetype='application/json')
```
Der `/ping`-Endpunkt im vorherigen Skriptbeispiel gibt den Statuscode `200` zurück, wenn das Modell korrekt geladen wurde, und `404`, wenn das Modell falsch geladen wurde. Der `/invocations`-Endpunkt verarbeitet eine in JSON formatierte Anforderung, extrahiert das Eingabefeld und verwendet das NER-Modell, um Entitäten in den variablen Entitäten zu identifizieren und zu speichern. Die Flask-Anwendung gibt die Antwort zurück, die diese Entitäten enthält. Weitere Informationen zu diesen erforderlichen Zustandsanfragen finden Sie unter [So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren](your-algorithms-inference-code.md#your-algorithms-inference-algo-ping-requests).
1. Laden Sie ein Skript hoch, um einen Inferenzserver zu starten. Das folgende Skriptbeispiel ruft `serve` auf und verwendet dabei Gunicorn als Anwendungsserver und Nginx als Webserver:
```
#!/usr/bin/env python
# This file implements the scoring service shell. You don't necessarily need to modify it for various
# algorithms. It starts nginx and gunicorn with the correct configurations and then simply waits until
# gunicorn exits.
#
# The flask server is specified to be the app object in wsgi.py
#
# We set the following parameters:
#
# Parameter Environment Variable Default Value
# --------- -------------------- -------------
# number of workers MODEL_SERVER_WORKERS the number of CPU cores
# timeout MODEL_SERVER_TIMEOUT 60 seconds
import multiprocessing
import os
import signal
import subprocess
import sys
cpu_count = multiprocessing.cpu_count()
model_server_timeout = os.environ.get('MODEL_SERVER_TIMEOUT', 60)
model_server_workers = int(os.environ.get('MODEL_SERVER_WORKERS', cpu_count))
def sigterm_handler(nginx_pid, gunicorn_pid):
try:
os.kill(nginx_pid, signal.SIGQUIT)
except OSError:
pass
try:
os.kill(gunicorn_pid, signal.SIGTERM)
except OSError:
pass
sys.exit(0)
def start_server():
print('Starting the inference server with {} workers.'.format(model_server_workers))
# link the log streams to stdout/err so they will be logged to the container logs
subprocess.check_call(['ln', '-sf', '/dev/stdout', '/var/log/nginx/access.log'])
subprocess.check_call(['ln', '-sf', '/dev/stderr', '/var/log/nginx/error.log'])
nginx = subprocess.Popen(['nginx', '-c', '/opt/program/nginx.conf'])
gunicorn = subprocess.Popen(['gunicorn',
'--timeout', str(model_server_timeout),
'-k', 'sync',
'-b', 'unix:/tmp/gunicorn.sock',
'-w', str(model_server_workers),
'wsgi:app'])
signal.signal(signal.SIGTERM, lambda a, b: sigterm_handler(nginx.pid, gunicorn.pid))
# Exit the inference server upon exit of either subprocess
pids = set([nginx.pid, gunicorn.pid])
while True:
pid, _ = os.wait()
if pid in pids:
break
sigterm_handler(nginx.pid, gunicorn.pid)
print('Inference server exiting')
# The main routine to invoke the start function.
if __name__ == '__main__':
start_server()
```
Das vorherige Skriptbeispiel definiert die Signal-Handler-Funktion `sigterm_handler`, die Nginx- und Gunicorn-Unterprozesse herunterfährt, wenn sie ein `SIGTERM`-Signal empfängt. Eine `start_server`-Funktion startet den Signal-Handler, startet und überwacht die Nginx- und Gunicorn-Unterprozesse und erfasst Protokollstreams.
1. Laden Sie ein Skript hoch, um Ihren Webserver zu konfigurieren. Das folgende Skriptbeispiel namens `nginx.conf` konfiguriert einen Nginx-Webserver, der Gunicorn als Anwendungsserver verwendet, um Ihr Modell als Inferenz auszuführen:
```
worker_processes 1;
daemon off; # Prevent forking
pid /tmp/nginx.pid;
error_log /var/log/nginx/error.log;
events {
# defaults
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log combined;
upstream gunicorn {
server unix:/tmp/gunicorn.sock;
}
server {
listen 8080 deferred;
client_max_body_size 5m;
keepalive_timeout 5;
proxy_read_timeout 1200s;
location ~ ^/(ping|invocations) {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
proxy_pass http://gunicorn;
}
location / {
return 404 "{}";
}
}
}
```
Das vorherige Skriptbeispiel konfiguriert Nginx, um im Vordergrund ausgeführt zu werden, legt den Speicherort für die `error_log`-Erfassung fest und definiert `upstream` als Socket-Sock des Gunicorn-Servers. Der Server konfiguriert den Serverblock so, dass er den Port `8080` abhört, und legt Grenzwerte für die Textgröße der Client-Anfrage und die Timeout-Werte fest. Der Serverblock leitet Anforderungen, die entweder `/invocations`- oder `/ping`-Pfade enthalten, an den Gunicorn `server http://gunicorn` weiter und gibt bei anderen Pfaden einen `404`-Fehler zurück.
1. Laden Sie alle anderen Skripte hoch, die für Ihr Modell erforderlich sind. In diesem Beispiel ist das folgende Beispielskript namens `wsgi.py` erforderlich, damit Gunicorn Ihre Anwendung findet:
```
import predictor as myapp
# This is just a simple wrapper for gunicorn to find your app.
# If you want to change the algorithm file, simply change "predictor" above to the
# new file.
app = myapp.app
```
Unter dem Ordner `docker_test_folder` sollte Ihre Verzeichnisstruktur eine Dockerfile und den Ordner NER enthalten. Der NER-Ordner sollte wie folgt die Dateien `nginx.conf`, `predictor.py`, `serve` und `wsgi.py` enthalten:
![\[The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/docker-file-struct-adapt-ex.png)
1. Erstellen Sie Ihren eigenen Container.
Erstellen Sie unter dem Ordner `docker_test_folder` Ihren Docker-Container. Der folgende Beispielbefehl erstellt den Docker-Container, der in Ihrer Dockerfile konfiguriert ist:
```
! docker build -t byo-container-test .
```
Der vorherige Befehl erstellt einen Container namens `byo-container-test` im aktuellen Arbeitsverzeichnis. Weitere Informationen zu den Docker-Build-Parametern finden Sie unter [Build arguments](https://docs.docker.com/build/guide/build-args/).
**Anmerkung**
Wenn Sie die folgende Fehlermeldung erhalten, dass Docker die Dockerfile nicht finden kann, stellen Sie sicher, dass die Dockerfile den richtigen Namen hat und im Verzeichnis gespeichert wurde.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker_test_folder/Dockerfile: no such file or directory
```
Docker sucht im aktuellen Verzeichnis spezifisch nach einer Datei namens Dockerfile ohne Erweiterung. Wenn Sie sie anders benannt haben, können Sie den Dateinamen manuell mit dem -f-Flag übergeben. Wenn Sie Ihre Dockerfile beispielsweise Dockerfile-text.txt genannt haben, erstellen Sie wie folgt Ihren Docker-Container mit dem `-f`-Flag, gefolgt von Ihrer Datei:
```
! docker build -t byo-container-test -f Dockerfile-text.txt .
```
1. Verschieben Sie Ihr Docker-Image in ein Amazon Elastic Container Registry (Amazon ECR).
Übertragen Sie Ihr Docker-Image in einer Notebook-Zelle auf eine ECR. Das folgende Codebeispiel zeigt Ihnen, wie Sie Ihren Container lokal erstellen, sich anmelden und ihn an eine ECR übertragen:
```
%%sh
# Name of algo -> ECR
algorithm_name=sm-pretrained-spacy
#make serve executable
chmod +x NER/serve
account=$(aws sts get-caller-identity --query Account --output text)
# Region, defaults to us-west-2
region=$(aws configure get region)
region=${region:-us-east-1}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/nullfi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
Im vorherigen Beispiel wird gezeigt, wie Sie die folgenden Schritte ausführen, die erforderlich sind, um den Docker-Beispielcontainer an eine ECR zu übertragen:
1. Verwenden Sie als Algorithmusnamen `sm-pretrained-spacy`.
1. Machen Sie die `serve`-Datei im NER-Ordner ausführbar.
1. Stellen Sie das ein AWS-Region.
1. Erstellen Sie eine ECR, falls noch nicht vorhanden.
1. Melden Sie sich bei der ECR an.
1. Erstellen Sie den Docker-Container lokal.
1. Verschieben Sie das Docker-Image in die ECR.
1. Richten Sie den SageMaker KI-Client ein
Wenn Sie SageMaker KI-Hosting-Dienste für Inferenzen verwenden möchten, müssen Sie [ein Modell, eine](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html) [Endpunktkonfiguration und einen Endpunkt](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#) [erstellen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html#). Um Rückschlüsse von Ihrem Endpunkt zu erhalten, können Sie den SageMaker AI boto3 Runtime-Client verwenden, um Ihren Endpunkt aufzurufen. Der folgende Code zeigt Ihnen, wie Sie sowohl den SageMaker AI-Client als auch den SageMaker Runtime-Client mithilfe des [SageMaker AI-Boto3-Clients](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html) einrichten:
```
import boto3
from sagemaker import get_execution_role
sm_client = boto3.client(service_name='sagemaker')
runtime_sm_client = boto3.client(service_name='sagemaker-runtime')
account_id = boto3.client('sts').get_caller_identity()['Account']
region = boto3.Session().region_name
#used to store model artifacts which SageMaker AI will extract to /opt/ml/model in the container,
#in this example case we will not be making use of S3 to store the model artifacts
#s3_bucket = ''
role = get_execution_role()
```
Im vorherigen Codebeispiel wird der Amazon-S3-Bucket nicht verwendet, sondern als Kommentar eingefügt, um zu zeigen, wie Modellartefakte gespeichert werden.
Wenn Sie nach der Ausführung des vorherigen Codebeispiels einen Berechtigungsfehler erhalten, müssen Sie Ihrer IAM-Rolle möglicherweise Berechtigungen hinzufügen. Weitere Informationen zu IAM-Rollen finden Sie unter [Amazon SageMaker Rollenmanager](role-manager.md). Weitere Informationen zum Hinzufügen von Berechtigungen zu Ihrer aktuellen Rolle finden Sie unter [AWS verwaltete Richtlinien für Amazon SageMaker AI](security-iam-awsmanpol.md).
1. Erstellen Sie Ihr Modell.
Wenn Sie SageMaker KI-Hosting-Dienste für Inferenzen verwenden möchten, müssen Sie ein Modell in KI erstellen. SageMaker Das folgende Codebeispiel zeigt Ihnen, wie Sie das spaCy NER Modell innerhalb von SageMaker AI erstellen:
```
from time import gmtime, strftime
model_name = 'spacy-nermodel-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
# MODEL S3 URL containing model atrifacts as either model.tar.gz or extracted artifacts.
# Here we are not
#model_url = 's3://{}/spacy/'.format(s3_bucket)
container = '{}.dkr.ecr.{}.amazonaws.com/sm-pretrained-spacy:latest'.format(account_id, region)
instance_type = 'ml.c5d.18xlarge'
print('Model name: ' + model_name)
#print('Model data Url: ' + model_url)
print('Container image: ' + container)
container = {
'Image': container
}
create_model_response = sm_client.create_model(
ModelName = model_name,
ExecutionRoleArn = role,
Containers = [container])
print("Model Arn: " + create_model_response['ModelArn'])
```
Das vorherige Codebeispiel zeigt, wie Sie mit dem `s3_bucket` eine `model_url` definieren, wenn Sie den Amazon-S3-Bucket aus den Kommentaren in Schritt 5 verwenden. Außerdem wird der ECR-URI für das Container-Image definiert. In den vorherigen Codebeispielen wird `ml.c5d.18xlarge` als Instance-Typ definiert. Sie können auch einen anderen Instance-Typ auswählen. Weitere Informationen über verfügbare Instance-Typen finden Sie unter [Amazon-EC2-Instance-Typen](https://aws.amazon.com/ec2/instance-types/).
Im vorherigen Codebeispiel verweist der `Image`-Schlüssel auf den Container-Image-URI. Die `create_model_response`-Definition verwendet die `create_model method`, um ein Modell zu erstellen und den Modellnamen, die Rolle und eine Liste mit den Containerinformationen zurückzugeben.
Hier eine Beispielausgabe aus dem vorherigen Skript:
```
Model name: spacy-nermodel-YYYY-MM-DD-HH-MM-SS
Model data Url: s3://spacy-sagemaker-us-east-1-bucket/spacy/
Container image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/sm-pretrained-spacy:latest
Model Arn: arn:aws:sagemaker:us-east-2:123456789012:model/spacy-nermodel-YYYY-MM-DD-HH-MM-SS
```
1.
1.
**Einen Endpunkt konfigurieren und erstellen**
Um SageMaker KI-Hosting für Inferenzen zu verwenden, müssen Sie auch einen Endpunkt konfigurieren und erstellen. SageMaker KI wird diesen Endpunkt für Inferenzen verwenden. Das folgende Konfigurationsbeispiel zeigt, wie Sie einen Endpunkt mit dem zuvor definierten Instance-Typ und Modellnamen generieren und konfigurieren:
```
endpoint_config_name = 'spacy-ner-config' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint config name: ' + endpoint_config_name)
create_endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ProductionVariants=[{
'InstanceType': instance_type,
'InitialInstanceCount': 1,
'InitialVariantWeight': 1,
'ModelName': model_name,
'VariantName': 'AllTraffic'}])
print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn'])
```
Im vorherigen Konfigurationsbeispiel verknüpft `create_endpoint_config_response` den `model_name` mit einem eindeutigen Endpunktkonfigurationsnamen `endpoint_config_name`, der mit einem Zeitstempel erstellt wurde.
Hier eine Beispielausgabe aus dem vorherigen Skript:
```
Endpoint config name: spacy-ner-configYYYY-MM-DD-HH-MM-SS
Endpoint config Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint-config/spacy-ner-config-MM-DD-HH-MM-SS
```
Weitere Informationen zu Endpunktfehlern finden Sie unter [Warum wechselt mein Amazon SageMaker AI-Endpunkt in den Status „Fehlgeschlagen“, wenn ich einen Endpunkt erstelle oder aktualisiere?](https://repost.aws/knowledge-center/sagemaker-endpoint-creation-fail)
1.
**Erstellen Sie einen Endpunkt und warten Sie, bis der Endpunkt betriebsbereit ist.**
Das folgende Codebeispiel erstellt den Endpunkt mithilfe der Konfiguration aus dem vorherigen Konfigurationsbeispiel und stellt das Modell bereit:
```
%%time
import time
endpoint_name = 'spacy-ner-endpoint' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint name: ' + endpoint_name)
create_endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
print('Endpoint Arn: ' + create_endpoint_response['EndpointArn'])
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp['EndpointStatus']
print("Endpoint Status: " + status)
print('Waiting for {} endpoint to be in service...'.format(endpoint_name))
waiter = sm_client.get_waiter('endpoint_in_service')
waiter.wait(EndpointName=endpoint_name)
```
Im vorherigen Codebeispiel erstellt die `create_endpoint`-Methode den Endpunkt mit dem generierten Endpunktnamen, der im vorherigen Codebeispiel erstellt wurde, und gibt den Amazon-Ressourcennamen des Endpunkts aus. Die `describe_endpoint`-Methode gibt Informationen über den Endpunkt und seinen Status zurück. Ein SageMaker KI-Kellner wartet darauf, dass der Endpunkt betriebsbereit ist.
1. Testen Sie Ihren Endpunkt.
Sobald Ihr Endpunkt in Betrieb ist, senden Sie eine [Aufrufanfrage](https://boto3.amazonaws.com/v1/documentation/api/1.9.42/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) an Ihren Endpunkt. Das folgende Codebeispiel zeigt, wie man eine Testanforderung an Ihren Endpunkt sendet.
```
import json
content_type = "application/json"
request_body = {"input": "This is a test with NER in America with \
Amazon and Microsoft in Seattle, writing random stuff."}
#Serialize data for endpoint
#data = json.loads(json.dumps(request_body))
payload = json.dumps(request_body)
#Endpoint invocation
response = runtime_sm_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload)
#Parse results
result = json.loads(response['Body'].read().decode())['output']
result
```
Im vorherigen Codebeispiel serialisiert die Methode `json.dumps` den `request_body` in eine in JSON formatierte Zeichenfolge und speichert sie in der variablen Nutzlast. Dann verwendet der SageMaker AI Runtime-Client die Methode „[Endpoint aufrufen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html)“, um Nutzdaten an Ihren Endpunkt zu senden. Das Ergebnis enthält die Antwort von Ihrem Endpunkt nach dem Extrahieren des Ausgabefeldes.
Das vorherige Codebeispiel sollte die folgende Ausgabe zurückgeben:
```
[['NER', 'ORG'],
['America', 'GPE'],
['Amazon', 'ORG'],
['Microsoft', 'ORG'],
['Seattle', 'GPE']]
```
1. Löschen Sie Ihren Endpunkt.
Nachdem Sie Ihre Aufrufe abgeschlossen haben, löschen Sie Ihren Endpunkt, um Ressourcen zu schonen. Das folgende Codebeispiel zeigt, wie Sie Ihren Endpunkt löschen.
```
sm_client.delete_endpoint(EndpointName=endpoint_name)
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)
```
Ein vollständiges Notebook, das den Code in diesem Beispiel enthält, finden Sie unter [BYOC-Single-Model](https://github.com/aws-samples/sagemaker-hosting/tree/main/Bring-Your-Own-Container/BYOC-Single-Model).
# Erstellen eines Containers mit Ihren eigenen Algorithmen und Modellen
Wenn keiner der vorhandenen SageMaker KI-Container Ihren Anforderungen entspricht und Sie keinen eigenen Container haben, müssen Sie möglicherweise einen neuen Docker-Container erstellen. In den folgenden Abschnitten wird gezeigt, wie Sie Docker-Container mit Ihren Trainings- und Inferenzalgorithmen für die Verwendung mit KI erstellen. SageMaker
**Topics**
+ [Container mit benutzerdefinierten Trainingsalgorhythmen](your-algorithms-training-algo.md)
+ [Container mit benutzerdefiniertem Inferenzcode](your-algorithms-inference-main.md)
# Container mit benutzerdefinierten Trainingsalgorhythmen
In diesem Abschnitt wird erklärt, wie Amazon SageMaker AI mit einem Docker-Container interagiert, auf dem Ihr benutzerdefinierter Trainingsalgorithmus ausgeführt wird. Verwenden Sie diese Informationen zum Schreiben von Trainingscode und zum Erstellen eines Docker-Images für Ihre Trainingsalgorithmen.
**Topics**
+ [So steuert Amazon SageMaker AI Ihr Trainingsimage](your-algorithms-training-algo-dockerfile.md)
+ [Wie Amazon SageMaker AI Schulungsinformationen bereitstellt](your-algorithms-training-algo-running-container.md)
+ [Training mit EFA durchführen](your-algorithms-training-efa.md)
+ [Wie Amazon SageMaker AI Erfolg und Misserfolg von Algorithmen signalisiert](your-algorithms-training-signal-success-failure.md)
+ [Wie Amazon SageMaker AI die Trainingsergebnisse verarbeitet](your-algorithms-training-algo-output.md)
# So steuert Amazon SageMaker AI Ihr Trainingsimage
Sie können ein benutzerdefiniertes Eintrittspunkt-Skript verwenden, um die Infrastruktur für das Training in einer Produktionsumgebung zu automatisieren. Wenn Sie Ihr Einstiegs-Skript in Ihren Docker-Container übergeben, können Sie es auch als eigenständiges Skript ausführen, ohne Ihre Images neu erstellen zu müssen. SageMaker KI verarbeitet Ihr Trainingsimage mithilfe eines Docker-Container-Einstiegspunktskripts.
In diesem Abschnitt erfahren Sie, wie Sie einen benutzerdefinierten Eintrittspunkt verwenden, ohne das Trainingstoolkit zu verwenden. [Wenn Sie einen benutzerdefinierten Einstiegspunkt verwenden möchten, aber nicht mit der manuellen Konfiguration eines Docker-Containers vertraut sind, empfehlen wir Ihnen, stattdessen die Training Toolkit-Bibliothek zu verwenden. SageMaker ](https://github.com/aws/sagemaker-training-toolkit) Weitere Informationen zur Verwendung des Trainingstoolkits finden Sie unter [Den eigenen Trainingscontainer anpassen](adapt-training-container.md).
Standardmäßig sucht SageMaker AI nach einem Skript, das in Ihrem Container aufgerufen wird. `train` Sie können Ihren eigenen benutzerdefinierten Einstiegspunkt auch manuell angeben, indem Sie die `ContainerEntrypoint` Parameter `ContainerArguments` und der [AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API verwenden.
Sie haben die folgenden zwei Optionen, um Ihren Docker-Container manuell für die Ausführung Ihres Images zu konfigurieren.
+ Verwenden Sie die [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API und einen Docker-Container mit einer darin enthaltenen Entrypoint-Anweisung.
+ Verwenden Sie die `CreateTrainingJob` API und übergeben Sie Ihr Trainingsskript von außerhalb Ihres Docker-Containers.
Wenn Sie Ihr Trainingsskript von außerhalb Ihres Docker-Containers übergeben, müssen Sie den Docker-Container nicht neu erstellen, wenn Sie Ihr Skript aktualisieren. Sie können auch mehrere verschiedene Skripte verwenden, um sie im selben Container auszuführen.
Ihr Einstiegsskript sollte Trainingscode für Ihr Image enthalten. Wenn Sie den optionalen `source_dir` Parameter in einem [Schätzer](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) verwenden, sollte er auf den relativen Amazon S3-Pfad zu dem Ordner verweisen, der Ihr Einstiegsskript enthält. Mit dem Parameter `source_dir` können Sie auf mehrere Dateien verweisen. Wenn Sie `source_dir` nicht verwenden, können Sie den Eintrittspunkt mithilfe des `entry_point` Parameters angeben. Ein Beispiel für ein benutzerdefiniertes Einstiegspunkt-Skript, das einen Schätzer enthält, finden Sie unter [Bring Your Own](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-script-mode/sagemaker-script-mode.html) Model with AI Script Mode. SageMaker
SageMaker Das KI-Modelltraining unterstützt leistungsstarke S3 Express One Zone-Verzeichnis-Buckets als Dateneingabeort für den Dateimodus, den Schnelldateimodus und den Pipe-Modus. Sie können Verzeichnis-Buckets von S3 Express One Zone auch zum Speichern Ihrer Trainingsdaten verwenden. Um S3 Express One Zone zu verwenden, geben Sie den URI eines Verzeichnis-Buckets von S3 Express One Zone anstelle eines Allzweck-Buckets von Amazon S3 an. Sie können Ihre SageMaker KI-Ausgabedaten in Verzeichnis-Buckets nur mit serverseitiger Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) verschlüsseln. Die serverseitige Verschlüsselung mit AWS KMS Schlüsseln (SSE-KMS) wird derzeit nicht für das Speichern von KI-Ausgabedaten in Verzeichnis-Buckets unterstützt. SageMaker Weitere Informationen finden Sie unter [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).
## Führen Sie einen Trainingsjob mit einem Entrypoint-Skript aus, das im Docker-Container gebündelt ist
SageMaker AI kann ein Entrypoint-Skript ausführen, das in Ihrem Docker-Container gebündelt ist.
+ Standardmäßig führt Amazon SageMaker AI den folgenden Container aus.
```
docker run image train
```
+ SageMaker AI überschreibt alle standardmäßigen [CMD-Anweisungen](https://docs.docker.com/engine/reference/builder/#cmd) in einem Container, indem das `train` Argument hinter dem Bildnamen angegeben wird. Verwenden Sie in Ihrem Docker-Container die folgende `exec` Form der `ENTRYPOINT` Anweisung.
```
ENTRYPOINT ["executable", "param1", "param2", ...]
```
Das folgende Beispiel zeigt, wie Sie eine `k-means-algorithm.py` genannte Python-Eintrittspunktanweisung angeben.
```
ENTRYPOINT ["python", "k-means-algorithm.py"]
```
Das `exec`-Formular der `ENTRYPOINT`-Anweisung startet die ausführbare Datei direkt, nicht als untergeordnetes Element von `/bin/sh`. Dadurch kann es Signale wie `SIGTERM` und `SIGKILL` von empfangen. SageMaker APIs Die folgenden Bedingungen gelten für die Verwendung von SageMaker APIs.
+ Die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API hat eine Stoppbedingung, die die SageMaker KI anweist, das Modelltraining nach einer bestimmten Zeit zu beenden.
+ Im Folgenden wird die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html) API dargestellt. Diese API gibt das Äquivalent des `docker stop` mit einer 2-minütigen Zeitüberschreitung aus, um den angegebenen Container ordnungsgemäß zu beenden.
```
docker stop -t 120
```
Der Befehl versucht, den ausgeführten Container durch das Senden eines `SIGTERM`-Signals zu beenden. Nach der 2-minütigen Zeitüberschreitung sendet die API `SIGKILL` und hält die Container zwangsweise an. Wenn der Container `SIGTERM` ordnungsgemäß verarbeitet und sich innerhalb von 120 Sekunden nach Erhalt der Meldung beendet, wird kein `SIGKILL` gesendet.
Wenn Sie auf die Artefakte des Zwischenmodells zugreifen möchten, nachdem SageMaker KI das Training beendet hat, fügen Sie Code für das Speichern von Artefakten in Ihrem `SIGTERM` Handler hinzu.
+ Wenn Sie vorhaben, GPU-Geräte für das Modelltraining zu verwenden, stellen Sie sicher, dass Ihre Container `nvidia-docker`-kompatibel sind. Binden Sie nur das CUDA-Toolkit in Container ein; bündeln Sie keine NVIDIA-Treiber mit dem Image. Mehr Informationen über `nvidia-docker` finden Sie unter [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Sie können den `tini` Initialisierer nicht als Einstiegsskript in SageMaker AI-Containern verwenden, da er durch die Argumente und verwirrt wird. `train` `serve`
+ `/opt/ml`und alle Unterverzeichnisse sind durch Training reserviert. SageMaker Achten Sie beim Erstellen des Docker-Images Ihres Algorithmus darauf, dass Sie keine Daten, die für Ihren Algorithmus erforderlich sind, in diesem Verzeichnis ablegen. Denn wenn Sie dies tun, sind die Daten während des Trainings möglicherweise nicht mehr sichtbar.
Um Ihre Shell- oder Python-Skripte in Ihrem Docker-Image zu bündeln oder das Skript in einem Amazon S3 S3-Bucket oder mithilfe der AWS Command Line Interface (CLI) bereitzustellen, fahren Sie mit dem folgenden Abschnitt fort.
### Bündeln Sie Ihr Shell-Skript in einem Docker-Container
Wenn Sie ein benutzerdefiniertes Shell-Skript in Ihrem Docker-Image bündeln möchten, gehen Sie wie folgt vor.
1. Kopieren Sie Ihr Shell-Skript aus Ihrem Arbeitsverzeichnis in Ihren Docker-Container. Der folgende Codeausschnitt kopiert ein benutzerdefiniertes Eintrittspunktskript `custom_entrypoint.sh` aus dem aktuellen Arbeitsverzeichnis in einen Docker-Container, der sich in `mydir` befindet. Im folgenden Beispiel wird davon ausgegangen, dass auf dem Docker-Basis-Image Python installiert ist.
```
FROM :
# Copy custom entrypoint from current dir to /mydir on container
COPY ./custom_entrypoint.sh /mydir/
```
1. Erstellen Sie einen Docker-Container und übertragen Sie ihn in die Amazon Elastic Container Registry ([Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)), indem Sie den Anweisungen unter [Pushing a Docker-Image](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) im *Amazon ECR-Benutzerhandbuch* folgen.
1. Starten Sie den Trainingsjob, indem Sie den folgenden AWS CLI Befehl ausführen.
```
aws --region sagemaker create-training-job \
--training-job-name \
--role-arn \
--algorithm-specification '{ \
"TrainingInputMode": "File", \
"TrainingImage": "", \
"ContainerEntrypoint": ["/bin/sh"], \
"ContainerArguments": ["/mydir/custom_entrypoint.sh"]}' \
--output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
--resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
--stopping-condition '{"MaxRuntimeInSeconds": 180}'
```
### Bündeln Sie Ihr Python-Skript in einem Docker-Container
Gehen Sie wie folgt vor, um ein benutzerdefiniertes Python-Skript in Ihrem Docker-Image zu bündeln.
1. Kopieren Sie Ihr Python-Skript aus Ihrem Arbeitsverzeichnis in Ihren Docker-Container. Der folgende Codeausschnitt kopiert ein benutzerdefiniertes Eintrittspunktskript `custom_entrypoint.py` aus dem aktuellen Arbeitsverzeichnis in einen Docker-Container, der sich in `mydir` befindet.
```
FROM :
# Copy custom entrypoint from current dir to /mydir on container
COPY ./custom_entrypoint.py /mydir/
```
1. Starten Sie den Trainingsjob, indem Sie den folgenden AWS CLI Befehl ausführen.
```
--algorithm-specification '{ \
"TrainingInputMode": "File", \
"TrainingImage": "", \
"ContainerEntrypoint": ["python"], \
"ContainerArguments": ["/mydir/custom_entrypoint.py"]}' \
```
## Führen Sie einen Trainingsjob mit einem Eintrittspunktskript außerhalb des Docker-Containers aus
Sie können Ihren eigenen Docker-Container für das Training verwenden und ein Entrypoint-Skript von außerhalb des Docker-Containers übergeben. Die Strukturierung Ihres Entrypoint-Skripts außerhalb des Containers bietet einige Vorteile. Wenn Sie Ihr Einstiegs-Skript aktualisieren, müssen Sie den Docker-Container nicht neu erstellen. Sie können auch mehrere verschiedene Skripte verwenden, um sie im selben Container auszuführen.
Geben Sie den Speicherort Ihres Trainingsskripts mithilfe der `ContainerArguments` Parameter `ContainerEntrypoint` und der [AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API an. Diese Eintrittspunkte und Argumente verhalten sich genauso wie Docker-Eintrittspunkte und Argumente. Die Werte in diesen Parametern überschreiben die entsprechenden Werte `ENTRYPOINT` oder `CMD` die als Teil des Docker-Containers bereitgestellten Werte.
Wenn Sie Ihr benutzerdefiniertes Eintrittspunkt-Skript an Ihren Docker-Trainingscontainer übergeben, bestimmen die von Ihnen angegebenen Eingaben das Verhalten des Containers.
+ Wenn Sie beispielsweise nur angeben, lautet die Anforderungssyntax`ContainerEntrypoint`, die die CreateTrainingJob API verwendet, wie folgt.
```
{
"AlgorithmSpecification": {
"ContainerEntrypoint": ["string"],
...
}
}
```
Anschließend führt das SageMaker Trainings-Backend Ihren benutzerdefinierten Einstiegspunkt wie folgt aus.
```
docker run --entrypoint image
```
**Anmerkung**
Wenn `ContainerEntrypoint` angegeben, führt das SageMaker Trainings-Backend das Image mit dem angegebenen Einstiegspunkt aus und überschreibt den Standard im Bild. `ENTRYPOINT`
+ Wenn Sie nur angeben, geht SageMaker AI davon aus`ContainerArguments`, dass der Docker-Container ein Einstiegspunktskript enthält. Die Anfragesyntax, die die `CreateTrainingJob` API verwendet, lautet wie folgt.
```
{
"AlgorithmSpecification": {
"ContainerArguments": ["arg1", "arg2"],
...
}
}
```
Das SageMaker Trainings-Backend führt Ihren benutzerdefinierten Einstiegspunkt wie folgt aus.
```
docker run image
```
+ Wenn Sie sowohl `ContainerEntrypoint` als auch `ContainerArguments`angeben, lautet die Anfragesyntax mithilfe der `CreateTrainingJob` API wie folgt.
```
{
"AlgorithmSpecification": {
"ContainerEntrypoint": ["string"],
"ContainerArguments": ["arg1", "arg2"],
...
}
}
```
Das SageMaker Trainings-Backend führt Ihren benutzerdefinierten Einstiegspunkt wie folgt aus.
```
docker run --entrypoint image
```
Sie können jede unterstützte `InputDataConfig` Quelle in der `CreateTrainingJob` API verwenden, um ein Einstiegsskript zur Ausführung Ihres Trainings-Images bereitzustellen.
### Stellen Sie Ihr Einstiegs-Skript in einem Amazon-S3-Bucket bereit
Um ein benutzerdefiniertes Einstiegspunktskript mithilfe eines S3-Buckets bereitzustellen, verwenden Sie den `S3DataSource` [DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)API-Parameter, um den Speicherort des Skripts anzugeben. Wenn Sie den `S3DataSource` Parameter verwenden, ist Folgendes erforderlich.
+ Das [InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)muss vom Typ sein. `File`
+ Das [S3 DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource) muss sein`FullyReplicated`.
Im folgenden Beispiel befindet sich ein Skript namens custom\$1entrypoint.sh in einem Pfad zu einem `s3:////custom_entrypoint.sh` S3-Bucket.
```
#!/bin/bash
echo "Running custom_entrypoint.sh"
echo "Hello you have provided the following arguments: " "$@"
```
Als Nächstes müssen Sie die Konfiguration des Eingabedatenkanals für die Ausführung eines Trainingsjobs festlegen. Tun Sie dies entweder AWS CLI direkt oder mit einer JSON-Datei.
#### Konfigurieren Sie den Eingabedatenkanal AWS CLI mithilfe einer JSON-Datei
Um Ihren Eingabedatenkanal mit einer JSON-Datei zu konfigurieren, verwenden Sie AWS CLI ihn wie in der folgenden Codestruktur gezeigt. Stellen Sie sicher, dass alle folgenden Felder die in der [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)API definierte Anfragesyntax verwenden.
```
// run-my-training-job.json
{
"[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-AlgorithmSpecification)": {
"ContainerEntrypoint": ["/bin/sh"],
"ContainerArguments": ["/opt/ml/input/data//custom_entrypoint.sh"],
...
},
"[InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-InputDataConfig)": [
{
"[ChannelName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-ChannelName)": "",
"[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-DataSource)": {
"[S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)": {
"[S3DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataDistributionType)": "FullyReplicated",
"[S3DataType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataType)": "S3Prefix",
"[S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri)": "s3:///"
}
},
"[InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)": "File",
},
...]
}
```
Führen Sie als Nächstes den AWS CLI Befehl aus, um den Trainingsjob aus der JSON-Datei wie folgt zu starten.
```
aws sagemaker create-training-job --cli-input-json file://run-my-training-job.json
```
#### Konfigurieren Sie den Eingabedatenkanal AWS CLI direkt
Verwenden Sie die folgende AWS CLI Codestruktur, um Ihren Eingabedatenkanal ohne JSON-Datei zu konfigurieren.
```
aws --region sagemaker create-training-job \
--training-job-name \
--role-arn \
--algorithm-specification '{ \
"TrainingInputMode": "File", \
"TrainingImage": "", \
"ContainerEntrypoint": ["/bin/sh"], \
"ContainerArguments": ["/opt/ml/input/data//custom_entrypoint.sh"]}' \
--input-data-config '[{ \
"ChannelName":"", \
"DataSource":{ \
"S3DataSource":{ \
"S3DataType":"S3Prefix", \
"S3Uri":"s3:///", \
"S3DataDistributionType":"FullyReplicated"}}}]' \
--output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
--resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
--stopping-condition '{"MaxRuntimeInSeconds": 180}'
```
# Wie Amazon SageMaker AI Schulungsinformationen bereitstellt
In diesem Abschnitt wird erklärt, wie SageMaker KI Trainingsinformationen wie Trainingsdaten, Hyperparameter und andere Konfigurationsinformationen für Ihren Docker-Container verfügbar macht.
Wenn Sie eine [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)Anfrage an SageMaker KI senden, um das Modelltraining zu starten, geben Sie den Amazon Elastic Container Registry (Amazon ECR) -Pfad des Docker-Images an, das den Trainingsalgorithmus enthält. Sie geben auch den Speicherort des Amazon Simple Storage Service (Amazon S3) an, an dem Trainingsdaten gespeichert werden, sowie algorithmusspezifische Parameter. SageMaker KI stellt diese Informationen dem Docker-Container zur Verfügung, sodass Ihr Trainingsalgorithmus sie verwenden kann. In diesem Abschnitt wird erklärt, wie wir diese Informationen Ihrem Docker-Container verfügbar machen können. Informationen zum Erstellen eines Trainingsauftrags finden Sie unter `CreateTrainingJob`. Weitere Informationen darüber, wie SageMaker KI-Container Informationen organisieren, finden Sie unter[SageMaker Schulungs- und Inferenz-Toolkits](amazon-sagemaker-toolkits.md).
**Topics**
+ [Hyperparameter](#your-algorithms-training-algo-running-container-hyperparameters)
+ [Umgebungsvariablen](#your-algorithms-training-algo-running-container-environment-variables)
+ [Eingabedatenkonfiguration](#your-algorithms-training-algo-running-container-inputdataconfig)
+ [Trainingsdaten](#your-algorithms-training-algo-running-container-trainingdata)
+ [Konfiguration für verteiltes Training](#your-algorithms-training-algo-running-container-dist-training)
## Hyperparameter
SageMaker AI stellt die Hyperparameter in einer `CreateTrainingJob` Anfrage im Docker-Container in der `/opt/ml/input/config/hyperparameters.json` Datei zur Verfügung.
Im Folgenden finden Sie ein Beispiel für eine Hyperparameter-Konfiguration `hyperparameters.json` zur Angabe der `eta` Hyperparameter `num_round` und in der Operation für. `CreateTrainingJob` [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)
```
{
"num_round": "128",
"eta": "0.001"
}
```
[Eine vollständige Liste der Hyperparameter, die für den integrierten SageMaker XGBoost KI-Algorithmus verwendet werden können, finden Sie unter Hyperparameter. XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost_hyperparameters.html)
Die Hyperparameter, die Sie einstellen können, hängen vom Algorithmus ab, den Sie trainieren. Eine Liste der Hyperparameter, die für einen integrierten SageMaker KI-Algorithmus verfügbar sind, finden Sie unter **Hyperparameter** unter dem Algorithmus-Link unter [Integrierte Amazon SageMaker AI-Algorithmen oder vortrainierte Modelle verwenden](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
## Umgebungsvariablen
SageMaker AI legt die folgenden Umgebungsvariablen in Ihrem Container fest:
+ TRAINING\$1JOB\$1NAME – Wird im Parameter `TrainingJobName` der Anforderung `CreateTrainingJob`angegeben.
+ TRAINING\$1JOB\$1ARN – Der Amazon Resource Name (ARN) des Trainingsjobs, der als `TrainingJobArn` in der `CreateTrainingJob`-Antwort zurückgegeben wird.
+ Alle Umgebungsvariablen, die im Parameter [Environment](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-Environment) in der Anforderung `CreateTrainingJob` angegeben sind.
## Eingabedatenkonfiguration
SageMaker AI stellt die Datenkanalinformationen im `InputDataConfig` Parameter aus Ihrer `CreateTrainingJob` Anfrage in der `/opt/ml/input/config/inputdataconfig.json` Datei in Ihrem Docker-Container zur Verfügung.
Nehmen wir beispielsweise an, dass Sie in Ihrer Anfrage drei Datenkanäle (`train``evaluation`, und`validation`) angeben. SageMaker AI stellt das folgende JSON bereit:
```
{
"train" : {"ContentType": "trainingContentType",
"TrainingInputMode": "File",
"S3DistributionType": "FullyReplicated",
"RecordWrapperType": "None"},
"evaluation" : {"ContentType": "evalContentType",
"TrainingInputMode": "File",
"S3DistributionType": "FullyReplicated",
"RecordWrapperType": "None"},
"validation" : {"TrainingInputMode": "File",
"S3DistributionType": "FullyReplicated",
"RecordWrapperType": "None"}
}
```
**Anmerkung**
SageMaker KI stellt dem Container nur relevante Informationen zu jedem Datenkanal (z. B. den Kanalnamen und den Inhaltstyp) zur Verfügung, wie im vorherigen Beispiel gezeigt. `S3DistributionType`wird so eingestellt, als `FullyReplicated` ob Sie EFS oder FSx Lustre als Eingabedatenquellen angeben würden.
## Trainingsdaten
Der `TrainingInputMode` Parameter in `AlgorithmSpecification` der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)Anfrage gibt an, wie der Trainingsdatensatz Ihrem Container zur Verfügung gestellt wird. Die folgenden Eingabemodi sind verfügbar.
+ **`File` Modus**
Wenn Sie `File` mode als `TrainingInputMode` Wert verwenden, legt SageMaker AI die folgenden Parameter in Ihrem Container fest.
+ Ihr `TrainingInputMode` Parameter wird `inputdataconfig.json` als „Datei“ geschrieben.
+ Ihr Datenkanalverzeichnis wird in `/opt/ml/input/data/channel_name` geschrieben.
Wenn Sie den `File` Modus verwenden, erstellt SageMaker AI für jeden Kanal ein Verzeichnis. Wenn Sie beispielsweise drei Kanäle mit dem Namen`training`, und haben `validation``testing`, erstellt SageMaker AI die folgenden drei Verzeichnisse in Ihrem Docker-Container:
+ `/opt/ml/input/data/training`
+ `/opt/ml/input/data/validation`
+ `/opt/ml/input/data/testing`
`File` Modus unterstützt auch die folgenden Datenquellen:
+ Amazon Simple Storage Service (Amazon-S3)
+ Amazon Elastic File System (Amazon EFS)
+ Amazon FSx für Lustre
**Anmerkung**
Kanäle, die Dateisystem-Datenquellen wie Amazon EFS und Amazon verwenden, FSx müssen `File` den Modus verwenden. In diesem Fall wird der im Kanal angegebene Verzeichnispfad unter `/opt/ml/input/data/channel_name` bereitgestellt.
+ **`FastFile` Modus**
Wenn Sie den `FastFile` Modus als Ihren verwenden`TrainingInputNodeParameter`, legt SageMaker AI die folgenden Parameter in Ihrem Container fest.
+ Ähnlich wie im `File` Modus wird im Modus `FastFile` Ihr Parameter `TrainingInputMode` im `inputdataconfig.json` als „Datei“ geschrieben.
+ Ihr Datenkanalverzeichnis wird in `/opt/ml/input/data/channel_name` geschrieben.
`FastFile` unterstützt die folgenden Datenquellen:
+ Amazon S3
Wenn Sie den `FastFile` Modus verwenden, wird das Kanalverzeichnis nur mit Lesezugriff bereitgestellt.
Historisch gesehen ging der `File` Modus dem Modus `FastFile` voraus. Um die Abwärtskompatibilität zu gewährleisten, können Algorithmen, die den `File` Modus unterstützen, auch problemlos mit dem `FastFile` Modus arbeiten, sofern der `TrainingInputMode` Parameter auf `File` in `inputdataconfig.json.` gesetzt ist.
**Anmerkung**
Kanäle, die den `FastFile` Modus verwenden, müssen ein `S3DataType` vom „S3Prefix“ verwenden.
`FastFile` mode präsentiert eine Ordneransicht, die den Schrägstrich (`/`) als Trennzeichen für die Gruppierung von Amazon S3-Objekten in Ordnern verwendet. `S3Uri` Präfixe dürfen keinem Teil des Ordnernamens entsprechen. Wenn ein Amazon S3-Datensatz beispielsweise `s3://amzn-s3-demo-bucket/train-01/data.csv` enthält, dann sind weder `s3://amzn-s3-demo-bucket/train` noch `s3://amzn-s3-demo-bucket/train-01` Präfixe noch als `S3Uri` Präfixe zulässig.
Ein abschließender Schrägstrich wird empfohlen, um einen Kanal zu definieren, der einem Ordner entspricht. Zum Beispiel der `s3://amzn-s3-demo-bucket/train-01/` Kanal für den `train-01` Ordner. Ohne den abschließenden Schrägstrich wäre der Kanal mehrdeutig, wenn es einen anderen Ordner `s3://amzn-s3-demo-bucket/train-011/` oder eine andere Datei `s3://amzn-s3-demo-bucket/train-01.txt/` gäbe.
+ **`Pipe` Modus**
+ `TrainingInputMode` Parameter geschrieben in `inputdataconfig.json`: „Pipe“
+ Datenkanal-Verzeichnis im Docker-Container: `/opt/ml/input/data/channel_name_epoch_number`
+ Unterstützte Datenquellen: Amazon S3
Sie müssen für jeden Kanal aus einer separaten Pipe lesen. Wenn Sie beispielsweise über drei Kanäle mit den Namen `training`, `validation` und `testing` verfügen, müssen Sie aus den folgenden Pipes lesen:
+ `/opt/ml/input/data/training_0, /opt/ml/input/data/training_1, ...`
+ `/opt/ml/input/data/validation_0, /opt/ml/input/data/validation_1, ...`
+ `/opt/ml/input/data/testing_0, /opt/ml/input/data/testing_1, ...`
Lesen Sie die Pipes sequenziell. Wenn Sie beispielsweise über einen Kanal mit dem Namen `training` verfügen, lesen Sie die Pipes in dieser Reihenfolge:
1. Öffnen Sie `/opt/ml/input/data/training_0` im Lesemodus und lesen Sie es in end-of-file (EOF) oder, wenn Sie mit der ersten Epoche fertig sind, schließen Sie die Pipe-Datei vorzeitig.
1. Nachdem Sie die erste Pipe-Datei geschlossen haben, suchen Sie nach `/opt/ml/input/data/training_1` und lesen Sie sie bis zum Ende der zweiten Epoche usw.
Wenn die Datei für eine bestimmte Epoche noch nicht existiert, muss Ihr Code möglicherweise erneut versuchen, bis die Pipe erstellt ist. Sie können zum Beispiel mehrere Epochen für den `training` -Kanal lesen und erst dann mit dem Lesen des `validation`-Kanals beginnen, wenn Sie bereit sind. Oder Sie können sie gleichzeitig lesen, wenn Ihr Algorithmus dies erfordert.
Ein Beispiel für ein Jupyter-Notizbuch, das zeigt, wie Sie den Pipe-Modus verwenden, wenn Sie Ihren eigenen Container [mitbringen, finden Sie unter Bring your own pipe-mode](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb) algorithm to Amazon AI. SageMaker
SageMaker Das KI-Modelltraining unterstützt leistungsstarke S3 Express One Zone-Verzeichnis-Buckets als Dateneingabeort für den Dateimodus, den Schnelldateimodus und den Pipe-Modus. Um S3 Express One Zone zu verwenden, geben Sie den Speicherort des Verzeichnis-Buckets von S3 Express One Zone anstelle eines Allzweck-Buckets von Amazon S3 ein. Stellen Sie den ARN für die IAM-Rolle mit den erforderlichen Zugriffskontroll- und Berechtigungsrichtlinien bereit. Weitere Einzelheiten finden Sie unter [AmazonSageMakerFullAccesspolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html). Sie können Ihre SageMaker KI-Ausgabedaten in Verzeichnis-Buckets nur mit serverseitiger Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) verschlüsseln. Die serverseitige Verschlüsselung mit AWS KMS Schlüsseln (SSE-KMS) wird derzeit nicht für das Speichern von KI-Ausgabedaten in Verzeichnis-Buckets unterstützt. SageMaker Weitere Informationen finden Sie unter [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).
## Konfiguration für verteiltes Training
Wenn Sie ein verteiltes Training mit mehreren Containern durchführen, stellt SageMaker KI Informationen zu allen Containern in der Datei zur Verfügung. `/opt/ml/input/config/resourceconfig.json`
Um die Kommunikation zwischen Containern zu ermöglichen, enthält diese JSON-Datei Informationen für alle Container. SageMaker AI stellt diese Datei sowohl für als auch `File` für `Pipe` Modus-Algorithmen zur Verfügung. Die Datei enthält die folgenden Informationen:
+ `current_host`–Der Name des aktuellen Containers im Containernetzwerk. Beispiel, `algo-1`. Host-Werte können sich jederzeit ändern. Schreiben Sie keinen Code mit spezifischen Werten für diese Variable.
+ `hosts`–Liste der Namen aller Container im Containernetzwerk, lexikografisch sortiert. Beispiel: `["algo-1", "algo-2", "algo-3"]` für einen Cluster mit drei Knoten. Container können diese Namen verwenden, um andere Container im Containernetzwerk anzugeben. Host-Werte können sich jederzeit ändern. Schreiben Sie keinen Code mit spezifischen Werten für diese Variablen.
+ `network_interface_name`– Der Name der Netzwerkschnittstelle, die für Ihren Container verfügbar ist. Beispielsweise können Container, die das Message Passing Interface (MPI) ausführen, diese Informationen verwenden, um den Namen der Netzwerkschnittstelle festzulegen.
+ Verwenden Sie nicht die Informationen in `/etc/hostname` oder `/etc/hosts`, da sie möglicherweise ungenau sind.
+ Die Informationen zum Hostnamen sind möglicherweise für den Algorithmus-Container nicht sofort verfügbar. Wir empfehlen, eine Wiederholungsrichtlinie für Operationen zur Auflösung des Hostnamens hinzuzufügen, sobald Knoten im Cluster verfügbar werden.
Nachfolgend sehen Sie eine Beispieldatei auf Knoten 1 in einem Cluster mit drei Knoten:
```
{
"current_host": "algo-1",
"hosts": ["algo-1","algo-2","algo-3"],
"network_interface_name":"eth1"
}
```
# Training mit EFA durchführen
SageMaker KI ermöglicht die Integration mit [EFA-Geräten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), um High Performance Computing (HPC) und maschinelles Lernen zu beschleunigen. Diese Integration ermöglicht es Ihnen, ein EFA-Gerät bei der Durchführung Ihrer verteilten Trainingsaufträge zu nutzen. Sie können die EFA-Integration zu einem vorhandenen Docker-Container hinzufügen, den Sie in KI integrieren. SageMaker In den folgenden Informationen wird beschrieben, wie Sie Ihren eigenen Container so konfigurieren, dass er ein EFA-Gerät für Ihre verteilten Trainingsaufträge verwendet.
## Voraussetzungen
Ihr Container muss der Spezifikation für den [SageMaker Trainingscontainer](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-dockerfile.html) entsprechen.
## EFA und erforderliche Pakete installieren
Ihr Container muss die [EFA-Software](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) downloaden und installieren. Dadurch kann Ihr Container das EFA-Gerät erkennen und bietet kompatible Versionen von Libfabric und Open MPI.
Alle Tools wie MPI und NCCL müssen innerhalb des Containers installiert und verwaltet werden, damit sie im Rahmen Ihres EFA-fähigen Trainingsauftrags verwendet werden können. Eine Liste aller verfügbaren EFA-Versionen finden Sie unter [Überprüfen des EFA-Installationsprogramms anhand einer Prüfsumme](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-verify.html). Das folgende Beispiel zeigt, wie Sie das Dockerfile Ihres EFA-fähigen Containers ändern, um EFA, MPI, OFI, NCCL und NCCL-TEST zu installieren.
**Anmerkung**
Bei der Verwendung PyTorch mit EFA auf Ihrem Container sollte die NCCL-Version Ihres Containers mit der NCCL-Version Ihrer Installation übereinstimmen. PyTorch Verwenden Sie den folgenden Befehl, um die PyTorch NCCL-Version zu überprüfen:
```
torch.cuda.nccl.version()
```
```
ARG OPEN_MPI_PATH=/opt/amazon/openmpi/
ENV NCCL_VERSION=2.7.8
ENV EFA_VERSION=1.30.0
ENV BRANCH_OFI=1.1.1
#################################################
## EFA and MPI SETUP
RUN cd $HOME \
&& curl -O https://s3-us-west-2.amazonaws.com/aws-efa-installer/aws-efa-installer-${EFA_VERSION}.tar.gz \
&& tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
&& cd aws-efa-installer \
&& ./efa_installer.sh -y --skip-kmod -g \
ENV PATH="$OPEN_MPI_PATH/bin:$PATH"
ENV LD_LIBRARY_PATH="$OPEN_MPI_PATH/lib/:$LD_LIBRARY_PATH"
#################################################
## NCCL, OFI, NCCL-TEST SETUP
RUN cd $HOME \
&& git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
&& cd nccl \
&& make -j64 src.build BUILDDIR=/usr/local
RUN apt-get update && apt-get install -y autoconf
RUN cd $HOME \
&& git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
&& cd aws-ofi-nccl \
&& ./autogen.sh \
&& ./configure --with-libfabric=/opt/amazon/efa \
--with-mpi=/opt/amazon/openmpi \
--with-cuda=/usr/local/cuda \
--with-nccl=/usr/local --prefix=/usr/local \
&& make && make install
RUN cd $HOME \
&& git clone https://github.com/NVIDIA/nccl-tests \
&& cd nccl-tests \
&& make MPI=1 MPI_HOME=/opt/amazon/openmpi CUDA_HOME=/usr/local/cuda NCCL_HOME=/usr/local
```
## Überlegungen zur Erstellung Ihres Containers
Das EFA-Gerät ist wie `/dev/infiniband/uverbs0` in der Liste der Geräte aufgeführt, auf die der Container zugreifen kann, in den Container eingebunden. Auf P4d-Instances hat der Container Zugriff auf 4 EFA-Geräte. Die EFA-Geräte befinden sich in der Liste der Geräte, auf die der Container zugreifen kann, als:
+ `/dev/infiniband/uverbs0`
+ `/dev/infiniband/uverbs1`
+ `/dev/infiniband/uverbs2`
+ `/dev/infiniband/uverbs3`
Informationen zu Hostnamen, Peer-Hostnamen und Netzwerkschnittstelle (für MPI) finden Sie in der `resourceconfig.json` Datei, die den einzelnen Container-Instances zur Verfügung gestellt wird, unter [Konfiguration für verteilte Trainings](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training). Ihr Container verarbeitet den regulären TCP-Verkehr zwischen Peers über die standardmäßigen Elastic-Network-Schnittstellen (ENI) und den OFI-Verkehr (Kernel-Bypass) über das EFA-Gerät.
## Stellen Sie sicher, dass Ihr EFA-Gerät erkannt wird
Um zu überprüfen, ob das EFA-Gerät erkannt wird, führen Sie den folgenden Befehl in Ihrem Container aus.
```
/opt/amazon/efa/bin/fi_info -p efa
```
Ihre Ausgabe sollte in etwa wie folgt aussehen.
```
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-rdm
version: 2.0
type: FI_EP_RDM
protocol: FI_PROTO_EFA
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 2.0
type: FI_EP_DGRAM
protocol: FI_PROTO_EFA
provider: efa;ofi_rxd
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 1.0
type: FI_EP_RDM
protocol: FI_PROTO_RXD
```
## Ausführen eines Trainingsauftrags mit EFA
Sobald Sie einen EFA-fähigen Container erstellt haben, können Sie einen Trainingsjob mit EFA mithilfe eines SageMaker AI Estimators genauso ausführen wie mit jedem anderen Docker-Image. Weitere Informationen zur Registrierung Ihres Containers und seiner Verwendung für Trainings finden Sie unter [Anpassung Ihres eigenen Trainingscontainers](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5).
# Wie Amazon SageMaker AI Erfolg und Misserfolg von Algorithmen signalisiert
Ein Trainingsalgorithmus gibt mithilfe des Beendigungscodes seines Prozesses an, ob er erfolgreich war oder nicht.
Eine erfolgreiche Trainingsausführung sollte mit dem Beendigungscode 0 und eine fehlgeschlagene Trainingsausführung sollte mit einem Beendigungscode ungleich 0 beendet werden. Diese werden in `Completed` und `Failed` in der von `TrainingJobStatus` zurückgegebenen `DescribeTrainingJob` umgewandelt. Diese Beendigungscodekonvention ist Standard und einfach in alle Sprachen zu implementieren. Sie können beispielsweise in Python mithilfe von `sys.exit(1)` eine fehlerhafte Beendigung signalisieren und ein einfaches Ausführen bis zum Ende der Hauptroutine wird dazu führen, dass Python mit dem Code 0 beendet wird.
Im Fall eines Fehlers kann der Algorithmus eine Beschreibung des Fehlers in die Fehlerdatei schreiben. Details finden Sie im nächsten Abschnitt.
# Wie Amazon SageMaker AI die Trainingsergebnisse verarbeitet
Da Ihr Algorithmus in einem Container ausgeführt wird, generiert er Ausgaben, einschließlich des Status des Trainingsauftrags und -modells und der Ausgabeartefakte. Der Algorithmus sollte diese Informationen in die folgenden Dateien schreiben, die sich im `/output`-Verzeichnis des Containers befinden. Amazon SageMaker AI verarbeitet die in diesem Verzeichnis enthaltenen Informationen wie folgt:
+ `/opt/ml/model`— Ihr Algorithmus sollte alle endgültigen Modellartefakte in dieses Verzeichnis schreiben. SageMaker AI kopiert diese Daten als einzelnes Objekt im komprimierten Tar-Format an den S3-Speicherort, den Sie in der `CreateTrainingJob` Anfrage angegeben haben. Wenn mehrere Container in einem einzigen Trainingsjob in dieses Verzeichnis schreiben, sollten sie sicherstellen, dass keine `file/directory` Namen kollidieren. SageMaker AI fasst das Ergebnis in einer TAR-Datei zusammen und lädt es am Ende des Trainingsjobs auf S3 hoch.
+ `/opt/ml/output/data`— Ihr Algorithmus sollte Artefakte, die Sie speichern möchten, außer dem endgültigen Modell, in dieses Verzeichnis schreiben. SageMaker AI kopiert diese Daten als einzelnes Objekt im komprimierten Tar-Format an den S3-Speicherort, den Sie in der `CreateTrainingJob` Anfrage angegeben haben. Wenn mehrere Container in einem einzigen Trainingsjob in dieses Verzeichnis schreiben, sollten sie sicherstellen, dass keine `file/directory` Namen kollidieren. SageMaker AI fasst das Ergebnis in einer TAR-Datei zusammen und lädt es am Ende des Trainingsjobs auf S3 hoch.
+ `/opt/ml/output/failure` – Wenn das Training fehlschlägt, sollte Ihr Algorithmus nach Abschluss aller Algorithmusausgaben (z. B. der Protokollierung) die Fehlerbeschreibung in diese Datei schreiben. In einer `DescribeTrainingJob` Antwort gibt SageMaker AI die ersten 1024 Zeichen aus dieser Datei als zurück. `FailureReason`
Sie können entweder einen S3-Allzweck-Bucket oder einen S3-Verzeichnis-Bucket zum Speichern Ihrer Trainingsausgabe angeben. Verzeichnis-Buckets verwenden die Speicherklasse Amazon S3 Express One Zone, die für Workloads oder leistungskritische Anwendungen konzipiert ist, die eine konsistente Latenz im einstelligen Millisekundenbereich erfordern. Wählen Sie den Bucket-Typ, der am besten zu Ihren Anwendungs- und Leistungsanforderungen passt. Weitere Informationen über S3-Verzeichnis-Buckets finden Sie unter [Verzeichnis-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.
**Anmerkung**
Sie können Ihre SageMaker KI-Ausgabedaten in S3-Verzeichnis-Buckets nur mit serverseitiger Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) verschlüsseln. Die serverseitige Verschlüsselung mit AWS KMS Schlüsseln (SSE-KMS) wird derzeit nicht für das Speichern von KI-Ausgabedaten in Verzeichnis-Buckets unterstützt. SageMaker
# Container mit benutzerdefiniertem Inferenzcode
Sie können Amazon SageMaker AI zum Interagieren mit Docker-Containern verwenden und Ihren eigenen Inferenzcode ausführen. Hierfür stehen zwei Optionen zur Verfügung:
+ Um Ihren eigenen Inferenzcode mit einem persistenten Endpunkt zu nutzen und jeweils eine Voraussage zu erhalten, verwenden Sie die Hosting-Services von SageMaker AI.
+ Wenn Sie Ihren eigenen Inferenzcode nutzen möchten, um Vorhersagen für einen ganzen Datensatz zu treffen, verwenden Sie die Batch-Transformation von SageMaker AI.
**Topics**
+ [Benutzerdefinierter Inferenzcode mit Hosting-Services](your-algorithms-inference-code.md)
+ [Benutzerdefinierter Inferenzcode mit Stapeltransformation](your-algorithms-batch-code.md)
# Benutzerdefinierter Inferenzcode mit Hosting-Services
In diesem Abschnitt wird erklärt, wie Amazon SageMaker AI mit einem Docker-Container interagiert, der Ihren eigenen Inferenzcode für Hosting-Dienste ausführt. Verwenden Sie diese Informationen zum Schreiben von Inferenzcode und zum Erstellen eines Docker-Images.
**Topics**
+ [Wie SageMaker KI Ihr Inferenz-Image ausführt](#your-algorithms-inference-code-run-image)
+ [Wie SageMaker KI Ihre Modellartefakte lädt](#your-algorithms-inference-code-load-artifacts)
+ [So sollte Ihr Container auf Inferenzanforderungen reagieren](#your-algorithms-inference-code-container-response)
+ [So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren](#your-algorithms-inference-algo-ping-requests)
+ [Container-Vertrag zur Support bidirektionaler Streaming-Funktionen](#your-algorithms-inference-algo-bidi)
+ [Verwenden Sie eine private Docker-Registry für Echtzeit-Inferenzcontainer](your-algorithms-containers-inference-private.md)
## Wie SageMaker KI Ihr Inferenz-Image ausführt
Um einen Container so zu konfigurieren, dass er als ausführbare Datei ausgeführt wird, verwenden Sie eine `ENTRYPOINT`-Anweisung in einer Dockerfile. Beachten Sie Folgendes:
+ Für die Modellinferenz führt SageMaker KI den Container wie folgt aus:
```
docker run image serve
```
SageMaker AI überschreibt `CMD` Standardanweisungen in einem Container, indem das `serve` Argument hinter dem Bildnamen angegeben wird. Das `serve`-Argument überschreibt Argumente, die Sie mit dem `CMD`-Befehl in der Dockerfile bereitstellen.
+ SageMaker AI erwartet, dass alle Container mit Root-Benutzern ausgeführt werden. Erstellen Sie Ihren Container so, dass er nur Root-Benutzer verwendet. Wenn SageMaker KI Ihren Container ausführt, können Benutzer, die keinen Zugriff auf Root-Ebene haben, zu Berechtigungsproblemen führen.
+ Es wird empfohlen, das `exec`-Formular der `ENTRYPOINT`-Anleitung zu verwenden:
```
ENTRYPOINT ["executable", "param1", "param2"]
```
Beispiel:
```
ENTRYPOINT ["python", "k_means_inference.py"]
```
Das `exec`-Formular der `ENTRYPOINT`-Anweisung startet die ausführbare Datei direkt, nicht als untergeordnetes Element von `/bin/sh`. Dadurch kann es Signale wie `SIGTERM` und `SIGKILL` von den SageMaker API-Operationen empfangen, was eine Voraussetzung ist.
Wenn Sie beispielsweise die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API verwenden, um einen Endpunkt zu erstellen, stellt SageMaker KI die Anzahl der ML-Compute-Instanzen bereit, die für die Endpunktkonfiguration erforderlich sind, die Sie in der Anfrage angeben. SageMaker AI führt den Docker-Container auf diesen Instanzen aus.
Wenn Sie die Anzahl der Instanzen reduzieren, die den Endpunkt unterstützen (indem Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)API aufrufen), führt SageMaker AI einen Befehl aus, um den Docker-Container auf den Instanzen zu stoppen, die beendet werden. Der Befehl sendet das `SIGTERM`-Signal und dann dreißig Sekunden später das `SIGKILL`-Signal.
Wenn Sie den Endpunkt aktualisieren (indem Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API aufrufen), startet SageMaker KI einen weiteren Satz von ML-Compute-Instances und führt die Docker-Container, die Ihren Inferenzcode enthalten, auf ihnen aus. Anschließend wird ein Befehl zum Beenden der vorherigen Docker-Container ausgeführt. Um einen Docker-Container anzuhalten, sendet der Befehl das Signal `SIGTERM` und 30 Sekunden später das Signal `SIGKILL`.
+ SageMaker AI verwendet die Container-Definition, die Sie in Ihrer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)Anfrage angegeben haben, um Umgebungsvariablen und den DNS-Hostnamen für den Container wie folgt festzulegen:
+ Es legt Umgebungsvariablen mithilfe der `ContainerDefinition.Environment` string-to-string Map fest.
+ Es legt den DNS-Hostnamen mithilfe von `ContainerDefinition.ContainerHostname` fest.
+ Wenn Sie planen, GPU-Geräte für Modellinferenzen zu verwenden (indem Sie GPU-basierte ML-Rechen-Instances in Ihrer `CreateEndpointConfig`-Anforderung angeben), stellen Sie sicher, dass Ihre Container `nvidia-docker`-kompatibel sind. Bündeln Sie NVIDIA-Treiber nicht mit dem Abbild. Mehr Informationen über `nvidia-docker` finden Sie unter [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Sie können den `tini` Initialisierer nicht als Einstiegspunkt in SageMaker KI-Container verwenden, da er durch die Argumente `train` und `serve` verwirrt wird.
## Wie SageMaker KI Ihre Modellartefakte lädt
In Ihrer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API-Anfrage können Sie entweder den `S3DataSource` Parameter `ModelDataUrl` oder verwenden, um den S3-Speicherort zu identifizieren, an dem Modellartefakte gespeichert sind. SageMaker AI kopiert Ihre Modellartefakte vom S3-Speicherort in das `/opt/ml/model` Verzeichnis, sodass sie von Ihrem Inferenzcode verwendet werden können. Ihr Container hat schreibgeschützten Zugriff auf `/opt/ml/model`. Schreiben Sie nicht in dieses Verzeichnis.
Die `ModelDataUrl` muss auf eine TAR.GZ-Datei zeigen. Andernfalls wird SageMaker AI die Datei nicht herunterladen.
Wenn Sie Ihr Modell in SageMaker KI trainiert haben, werden die Modellartefakte als eine einzige komprimierte TAR-Datei in Amazon S3 gespeichert. Wenn Sie Ihr Modell außerhalb von SageMaker KI trainiert haben, müssen Sie diese einzelne komprimierte TAR-Datei erstellen und an einem S3-Speicherort speichern. SageMaker AI dekomprimiert diese Tar-Datei in das opt/ml/model Verzeichnis/, bevor Ihr Container gestartet wird.
Wir empfehlen, für die Bereitstellung großer Modelle [Bereitstellung unkomprimierter Modelle](large-model-inference-uncompressed.md) zu befolgen.
## So sollte Ihr Container auf Inferenzanforderungen reagieren
Um Rückschlüsse zu ziehen, sendet die Client-Anwendung eine POST-Anfrage an den SageMaker AI-Endpunkt. SageMaker AI leitet die Anfrage an den Container weiter und gibt das Inferenzergebnis vom Container an den Client zurück.
Weitere Informationen zu den Inferenzanfragen, die Ihr Container erhält, finden Sie in den folgenden Aktionen in der *Amazon SageMaker AI API-Referenz:*
+ [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)
+ [ InvokeEndpointAsync](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointAsync.html)
+ [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html)
+ [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithBidirectionalStream.html)
**Anforderungen für Inferenzcontainer**
Um auf Inferenzanfragen zu antworten, muss Ihr Container die folgenden Anforderungen erfüllen:
+ SageMaker AI entfernt alle `POST` Header außer denen, die von unterstützt werden. `InvokeEndpoint` SageMaker KI fügt möglicherweise zusätzliche Header hinzu. Inferenzcontainer müssen diese zusätzlichen Header einfach ignorieren können.
+ Um Inferenzanfragen zu erhalten, muss der Container über einen Webserver verfügen, der auf Port 8080 lauscht, und er muss `POST`-Anfragen an die Endpunkte `/invocations` und `/ping` akzeptieren.
+ Ein Containermodell des Kunden muss Socket-Verbindungsanfragen innerhalb von 250 ms akzeptieren.
+ Die Modellcontainer eines Kunden müssen innerhalb von 60 Sekunden auf Anforderungen reagieren. Das Modell selbst kann eine maximale Bearbeitungszeit von 60 Sekunden haben, bevor es auf die `/invocations` antwortet. Wenn Ihr Modell 50 bis 60 Sekunden Verarbeitungszeit benötigt, legen Sie das SDK-Socket-Timeout auf 70 Sekunden fest.
+ Der Modellcontainer eines Kunden, der bidirektionales Streaming unterstützt, muss:
+ unterstützt WebSockets standardmäßig Verbindungen auf Port 8080 bis/invocations-bidirectional-stream .
+ einen Webserver haben, der auf Port 8080 wartet und POST-Anfragen an die /ping-Endpunkte akzeptieren muss.
+ Zusätzlich zu den Integritätsprüfungen des Containers über HTTP muss der Container mit Pong Frame per ([RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) antworten, damit der Ping-Frame gesendet wird. WebSocket
**Example Aufruf-Funktionen**
Die folgenden Beispiele zeigen, wie der Code in Ihrem Container Inferenzanfragen verarbeiten kann. In diesen Beispielen werden Anfragen behandelt, die Client-Anwendungen mithilfe der InvokeEndpoint Aktion senden.
FastAPI ist ein Web-Framework zum Bauen APIs mit Python.
```
from fastapi import FastAPI, status, Request, Response
. . .
app = FastAPI()
. . .
@app.post('/invocations')
async def invocations(request: Request):
# model() is a hypothetical function that gets the inference output:
model_resp = await model(Request)
response = Response(
content=model_resp,
status_code=status.HTTP_200_OK,
media_type="text/plain",
)
return response
. . .
```
In diesem Beispiel verarbeitet die `invocations` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet.
Flask ist ein Framework für die Entwicklung von Webanwendungen mit Python.
```
import flask
. . .
app = flask.Flask(__name__)
. . .
@app.route('/invocations', methods=["POST"])
def invoke(request):
# model() is a hypothetical function that gets the inference output:
resp_body = model(request)
return flask.Response(resp_body, mimetype='text/plain')
```
In diesem Beispiel verarbeitet die `invoke` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet.
**Example Aufruffunktionen für Streaming-Anfragen**
Die folgenden Beispiele zeigen, wie der Code in Ihrem Inferenzcontainer Streaming-Inferenzanfragen verarbeiten kann. Diese Beispiele behandeln Anfragen, die Client-Anwendungen mithilfe der InvokeEndpointWithResponseStream Aktion senden.
Wenn ein Container eine Streaming-Inferenzanforderung verarbeitet, gibt er die Inferenz des Modells inkrementell als eine Reihe von Teilen zurück, während das Modell sie generiert. Client-Anwendungen erhalten sofort Antworten, wenn sie verfügbar sind. Sie müssen nicht warten, bis das Modell die gesamte Antwort generiert hat. Sie können Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, virtuelle Assistenten und Musikgeneratoren zu unterstützen.
FastAPI ist ein Web-Framework zum Bauen APIs mit Python.
```
from starlette.responses import StreamingResponse
from fastapi import FastAPI, status, Request
. . .
app = FastAPI()
. . .
@app.post('/invocations')
async def invocations(request: Request):
# Streams inference response using HTTP chunked encoding
async def generate():
# model() is a hypothetical function that gets the inference output:
yield await model(Request)
yield "\n"
response = StreamingResponse(
content=generate(),
status_code=status.HTTP_200_OK,
media_type="text/plain",
)
return response
. . .
```
In diesem Beispiel verarbeitet die `invocations` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet. Um die Antwort zu streamen, verwendet das Beispiel die Klasse `StreamingResponse` aus dem Starlette-Framework.
Flask ist ein Framework für die Entwicklung von Webanwendungen mit Python.
```
import flask
. . .
app = flask.Flask(__name__)
. . .
@app.route('/invocations', methods=["POST"])
def invocations(request):
# Streams inference response using HTTP chunked encoding
def generate():
# model() is a hypothetical function that gets the inference output:
yield model(request)
yield "\n"
return flask.Response(
flask.stream_with_context(generate()), mimetype='text/plain')
. . .
```
In diesem Beispiel verarbeitet die `invocations` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet. Um die Antwort zu streamen, verwendet das Beispiel die Funktion `flask.stream_with_context` aus dem Flask-Framework.
**Example Beispiel für Aufruffunktionen für bidirektionales Streaming**
Die folgenden Beispiele zeigen, wie der Code in Ihrem Container Streaming-Inferenzanfragen und -antworten verarbeiten kann. In diesen Beispielen werden Streaming-Anfragen behandelt, die Client-Anwendungen mithilfe der InvokeEndpointWithBidirectionalStream Aktion senden.
Ein Container mit bidirektionaler Streaming-Funktion verarbeitet Streaming-Inferenzanforderungen, bei denen Teile inkrementell auf dem Client generiert und in den Container gestreamt werden. Er gibt die Inferenz des Modells in Form einer Reihe von Teilen an den Client zurück, sobald das Modell sie generiert. Client-Anwendungen erhalten sofort Antworten, wenn sie verfügbar sind. Sie müssen nicht auf die Anfrage warten, die vollständig auf dem Client generiert wurde, oder darauf, dass das Modell die gesamte Antwort generiert. Sie können bidirektionales Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, interaktive KI-Sprachassistenten und Übersetzungen in Echtzeit zu unterstützen und so ein Erlebnis in Echtzeit zu ermöglichen.
FastAPI ist ein Web-Framework zum Bauen APIs mit Python.
```
import sys
import asyncio
import json
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import JSONResponse
import uvicorn
app = FastAPI()
...
@app.websocket("/invocations-bidirectional-stream")
async def websocket_invoke(websocket: WebSocket):
"""
WebSocket endpoint with RFC 6455 ping/pong and fragmentation support
Handles:
- Text messages (JSON) - including fragmented frames
- Binary messages - including fragmented frames
- Ping frames (automatically responds with pong)
- Pong frames (logs receipt)
- Fragmented frames per RFC 6455 Section 5.4
"""
await manager.connect(websocket)
# Fragment reassembly buffers per RFC 6455 Section 5.4
text_fragments = []
binary_fragments = []
while True:
# Use receive() to handle all WebSocket frame types
message = await websocket.receive()
print(f"Received message: {message}")
if message["type"] == "websocket.receive":
if "text" in message:
# Handle text frames (including fragments)
text_data = message["text"]
more_body = message.get("more_body", False)
if more_body:
# This is a fragment, accumulate it
text_fragments.append(text_data)
print(f"Received text fragment: {len(text_data)} chars (more coming)")
else:
# This is the final frame or a complete message
if text_fragments:
# Reassemble fragmented message
text_fragments.append(text_data)
complete_text = "".join(text_fragments)
text_fragments.clear()
print(f"Reassembled fragmented text message: {len(complete_text)} chars total")
await handle_text_message(websocket, complete_text)
else:
# Complete message in single frame
await handle_text_message(websocket, text_data)
elif "bytes" in message:
# Handle binary frames (including fragments)
binary_data = message["bytes"]
more_body = message.get("more_body", False)
if more_body:
# This is a fragment, accumulate it
binary_fragments.append(binary_data)
print(f"Received binary fragment: {len(binary_data)} bytes (more coming)")
else:
# This is the final frame or a complete message
if binary_fragments:
# Reassemble fragmented message
binary_fragments.append(binary_data)
complete_binary = b"".join(binary_fragments)
binary_fragments.clear()
print(f"Reassembled fragmented binary message: {len(complete_binary)} bytes total")
await handle_binary_message(websocket, complete_binary)
else:
# Complete message in single frame
await handle_binary_message(websocket, binary_data)
elif message["type"] == "websocket.ping":
# Handle ping frames - RFC 6455 Section 5.5.2
ping_data = message.get("bytes", b"")
print(f"Received PING frame with payload: {ping_data}")
# FastAPI automatically sends pong response
elif message["type"] == "websocket.pong":
# Handle pong frames
pong_data = message.get("bytes", b"")
print(f"Received PONG frame with payload: {pong_data}")
elif message["type"] == "websocket.close":
# Handle close frames - RFC 6455 Section 5.5.1
close_code = message.get("code", 1000)
close_reason = message.get("reason", "")
print(f"Received CLOSE frame - Code: {close_code}, Reason: '{close_reason}'")
# Send close frame response if not already closing
try:
await websocket.close(code=close_code, reason=close_reason)
print(f"Sent CLOSE frame response - Code: {close_code}")
except Exception as e:
print(f"Error sending close frame: {e}")
break
elif message["type"] == "websocket.disconnect":
print("Client initiated disconnect")
break
else:
print(f"Received unknown message type: {message['type']}")
break
async def handle_binary_message(websocket: WebSocket, binary_data: bytes):
"""Handle incoming binary messages (complete or reassembled from fragments)"""
print(f"Processing complete binary message: {len(binary_data)} bytes")
try:
# Echo back the binary data
await websocket.send_bytes(binary_data)
except Exception as e:
print(f"Error handling binary message: {e}")
async def handle_text_message(websocket: WebSocket, data: str):
"""Handle incoming text messages"""
try:
# Send response back to the same client
await manager.send_personal_message(data, websocket)
except Exception as e:
print(f"Error handling text message: {e}")
def main():
if len(sys.argv) > 1 and sys.argv[1] == "serve":
print("Starting server on port 8080...")
uvicorn.run(app, host="0.0.0.0", port=8080)
else:
print("Usage: python app.py serve")
sys.exit(1)
if __name__ == "__main__":
main()
```
In diesem Beispiel verarbeitet die `websocket_invoke` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations-bidirectional-stream` Endpunkt sendet. Es zeigt die Bearbeitung von Stream-Anfragen und Stream-Antworten zurück an den Client.
## So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren
SageMaker KI startet in den folgenden Situationen neue Inferenzcontainer:
+ Reagieren auf die API-Aufrufe `CreateEndpoint`, `UpdateEndpoint` und `UpdateEndpointWeightsAndCapacities`
+ Ausführen von Sicherheits-Patching
+ Ersetzen fehlerhafter Instances
Kurz nach dem Start des Containers beginnt SageMaker KI, regelmäßige GET-Anfragen an den `/ping` Endpunkt zu senden.
Die einfachste Anforderung für den Container besteht darin, mit einem HTTP 200-Statuscode ohne Text zu antworten. Dies zeigt SageMaker AI an, dass der Container bereit ist, Inferenzanfragen am `/invocations` Endpunkt anzunehmen.
Wenn der Container in den ersten 8 Minuten nach dem Start nicht beginnt, die Zustandsprüfungen zu bestehen, in dem er durchweg mit 200s antwortet, schlägt der Start der neuen Instance fehl. Dies führt zu einem Fehlschlag von `CreateEndpoint` und der Endpunkt befindet sich in einem ausgefallenen Zustand. Die von `UpdateEndpoint` angeforderte Aktualisierung wird nicht abgeschlossen, die Sicherheitspatches werden nicht angewendet und fehlerhafte Instances werden nicht ersetzt.
Die Mindestgrenze besteht darin, dass der Container statische 200 zurückgibt, ein Containerentwickler kann diese Funktionalität jedoch nutzen, um umfassendere Prüfungen durchzuführen. Das Anforderungstimeout bei `/ping`-Versuchen beträgt 2 Sekunden.
Darüber hinaus muss ein Container, der bidirektionale Streaming-Anfragen verarbeiten kann, mit einem Pong-Frame (pro WebSocket Protokoll [RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) auf einen Ping-Frame antworten. Wenn für 5 aufeinanderfolgende Pings kein Pong Frame empfangen wird, wird die Verbindung zum Container von der AI-Plattform geschlossen. SageMaker SageMaker Die KI-Plattform reagiert auch auf Ping-Frames aus dem Modellcontainer mit Pong Frames.
## Container-Vertrag zur Support bidirektionaler Streaming-Funktionen
Wenn Sie Ihren Modellcontainer als SageMaker KI-Endpunkt hosten möchten, der bidirektionale Streaming-Funktionen unterstützt, muss der Modellcontainer den folgenden Vertrag unterstützen:
**1. Bidirektionales Docker-Label**
Der Modellcontainer sollte ein Docker-Label haben, das der SageMaker KI-Plattform mitteilt, dass die bidirektionale Streaming-Funktion auf diesem Container unterstützt wird.
```
com.amazonaws.sagemaker.capabilities.bidirectional-streaming=true
```
**2. WebSocket Support-Verbindung für Aufrufe**
Der Modellcontainer eines Kunden, der bidirektionales Streaming unterstützt, muss standardmäßig WebSockets Verbindungen über Port 8080 bis unterstützen. `/invocations-bidirectional-stream`
Dieser Pfad kann überschrieben werden, indem beim X-Amzn-SageMaker-Model Aufrufen der API der Header -Invocation-Path übergeben wird. InvokeEndpointWithBidirectionalStream Darüber hinaus können Benutzer eine Abfragezeichenfolge angeben, die an diesen Pfad angehängt werden soll, indem sie beim Aufrufen der API den Header -Query-String übergeben. X-Amzn-SageMaker-Model InvokeEndpointWithBidirectionalStream
**3. Stream-Behandlung anfragen**
Die InvokeEndpointWithBidirectionalStream API-Eingabe-Payloads werden als eine Reihe von Dateien gestreamt PayloadParts, was nur ein Wrapper eines binären Chunks („Bytes“:) ist: ******
```
{
"PayloadPart": {
"Bytes": ,
"DataType": ,
"CompletionState":
"P":
}
}
```
**3.1. Datenrahmen**
SageMaker AI übergibt die Eingabe als WebSocket Datenrahmen PayloadParts an den Modellcontainer ([RFC6455-Abschnitt-5.6](https://datatracker.ietf.org/doc/html/rfc6455#section-5.6))
1. SageMaker KI untersucht den binären Chunk nicht.
1. Beim Empfang einer Eingabe PayloadPart
+ SageMaker KI erstellt genau einen WebSocket Datenrahmen aus `PayloadPart.Bytes` und übergibt ihn dann an den Modellcontainer.
+ Wenn`PayloadPart.DataType = UTF8`, SageMaker KI einen Textdatenrahmen erstellt
+ Wenn `PayloadPart.DataType` kein oder vorhanden ist`PayloadPart.DataType = BINARY`, erstellt SageMaker AI einen binären Datenrahmen
1. Bei einer Sequenz aus „ PayloadParts mit`PayloadPart.CompletionState = PARTIAL`“ und einer abschließend durch ein „ PayloadPart mit`PayloadPart.CompletionState = COMPLETE`“ übersetzt SageMaker KI sie in eine WebSocket fragmentierte Nachricht. [RFC6455— Abschnitt-5.4](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4): Fragmentierung:
+ Das erste PayloadPart mit `PayloadPart.CompletionState = PARTIAL` wird in einen WebSocket Datenrahmen übersetzt, wobei das FIN-Bit leer ist.
+ Das darauffolgende PayloadParts mit `PayloadPart.CompletionState = PARTIAL` wird in WebSocket Continuation-Frames übersetzt, wobei das FIN-Bit leer ist.
+ Das letzte PayloadPart mit `PayloadPart.CompletionState = COMPLETE` wird in ein WebSocket Continuation Frame übersetzt, bei dem das FIN-Bit gesetzt ist.
1. SageMaker AI kodiert oder dekodiert den binären Chunk aus der Eingabe nicht PayloadPart, die Bytes werden unverändert an den Modellcontainer übergeben.
1. SageMaker KI kombiniert nicht mehrere Eingaben zu einer. PayloadParts BinaryDataFrame
1. SageMaker KI teilt eine Eingabe nicht PayloadPart in mehrere BinaryDataFrames auf.
**Beispiel: Fragmentierter Nachrichtenfluss**
```
Client sends:
PayloadPart 1: {Bytes: "Hello ", DataType: "UTF8", CompletionState: "PARTIAL"}
PayloadPart 2: {Bytes: "World", DataType: "UTF8", CompletionState: "COMPLETE"}
Container receives:
Frame 1: Text Data Frame with "Hello " (FIN=0)
Frame 2: Continuation Frame with "World" (FIN=1)
```
**3.2. Kontrollrahmen**
Neben Datenrahmen sendet SageMaker KI auch Kontrollrahmen an den Modellcontainer ([RFC6455-Sektion-5.5](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5)):
1. Frame schließen: SageMaker KI kann Close Frame ([RFC6455-Section-5.5.1) an den](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1) Modellcontainer senden, falls die Verbindung aus irgendeinem Grund geschlossen wird.
1. Ping-Frame: SageMaker KI sendet Ping Frame ([RFC6455-Section-5.5.2](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2)) einmal alle 60 Sekunden, der Modellcontainer muss mit Pong Frame antworten. Wenn für 5 aufeinanderfolgende Pings kein Pong Frame ([RFC6455-Section-5.5.3](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) empfangen wird, wird die Verbindung von KI geschlossen. SageMaker
1. Pong Frame: Die SageMaker KI reagiert auf Ping-Frames aus dem Modellcontainer mit Pong Frames.
**4. Verarbeitung von Antwortstreams**
Die Ausgabe wird als eine Reihe von PayloadParts ModelStreamErrors oder InternalStreamFailures gestreamt.
```
{
"PayloadPart": {
"Bytes": ,
"DataType": ,
"CompletionState": ,
},
"ModelStreamError": {
"ErrorCode": ,
"Message":
},
"InternalStreamFailure": {
"Message":
}
}
```
**4.1. Datenrahmen**
SageMaker KI konvertiert vom Modellcontainer empfangene Datenrahmen in eine Ausgabe PayloadParts:
1. Beim Empfang eines WebSocket Textdatenrahmens aus dem Modellcontainer ruft SageMaker AI die Rohbytes aus dem Textdatenrahmen ab und verpackt sie in eine Antwort PayloadPart, die inzwischen eingestellt `PayloadPart.DataType = UTF8` ist.
1. Beim Empfang eines WebSocket binären Datenrahmens aus dem Modellcontainer verpackt SageMaker KI die Bytes aus dem Datenrahmen direkt in eine Antwort PayloadPart, die inzwischen gesetzt ist. `PayloadPart.DataType = BINARY`
1. Für fragmentierte Nachrichten, wie in [RFC6455-Abschnitt-5.4](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4): Fragmentierung definiert:
+ Der anfängliche Datenrahmen mit FIN-Bit clear wird in ein With-Zeichen übersetzt. PayloadPart `PayloadPart.CompletionState = PARTIAL`
+ Die nachfolgenden Continuation-Frames, bei denen das FIN-Bit frei ist, werden in „ PayloadParts mit`PayloadPart.CompletionState = PARTIAL`“ übersetzt.
+ Der letzte Continuation-Frame mit gesetztem FIN-Bit wird in „ PayloadPart mit“ übersetzt`PayloadPart.CompletionState = COMPLETE`.
1. SageMaker AI kodiert oder dekodiert die von Modellcontainern empfangenen Bytes nicht, die Bytes werden unverändert an den Modellcontainer übergeben.
1. SageMaker KI kombiniert nicht mehrere vom Modellcontainer empfangene Datenrahmen zu einer Antwort. PayloadPart
1. SageMaker KI teilt einen vom Modellcontainer empfangenen Datenrahmen nicht in mehrere Antworten auf PayloadParts.
**Beispiel: Streaming-Antwortfluss**
```
Container sends:
Frame 1: Text Data Frame with "Generating" (FIN=0)
Frame 2: Continuation Frame with " response..." (FIN=1)
Client receives:
PayloadPart 1: {Bytes: "Generating", DataType: "UTF8", CompletionState: "PARTIAL"}
PayloadPart 2: {Bytes: " response...", DataType: "UTF8", CompletionState: "COMPLETE"}
```
**4.2. Kontrollrahmen**
SageMaker AI reagiert auf die folgenden Control Frames aus dem Modellcontainer:
1. Beim Empfang eines Close Frame ([RFC6455-Section-5.5.1](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1)) vom Modellcontainer verpackt SageMaker AI den Statuscode ([RFC6455-Section-7.4) und die](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4) Fehlermeldungen in und streamt ihn zurück an den ModelStreamError Endbenutzer.
1. Beim Empfang eines Ping-Frames ([RFC6455-Section-5.5.2) vom Modellcontainer antwortet AI](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2) mit Pong Frame. SageMaker
1. Pong Frame ([RFC6455-Section-5.5.3): Wenn für 5 aufeinanderfolgende](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3) Pings kein Pong Frame empfangen wird, wird die Verbindung von KI geschlossen. SageMaker
# Verwenden Sie eine private Docker-Registry für Echtzeit-Inferenzcontainer
Mit Amazon SageMaker AI-Hosting können Sie standardmäßig in Amazon ECR gespeicherte Bilder verwenden, um Ihre Container für Echtzeit-Inferenzen zu erstellen. Optional können Sie Container für Echtzeit-Inferenzen aus Images in einer privaten Docker-Registry erstellen. Die private Registry muss von einer Amazon VPC in Ihrem Konto aus zugänglich sein. Modelle, die Sie basierend auf den in Ihrer privaten Docker-Registry gespeicherten Images erstellen, müssen so konfiguriert sein, dass sie eine Verbindung zu derselben VPC herstellen, über die auf die private Docker-Registry zugegriffen werden kann. Informationen zum Herstellen einer Verbindung Ihres Modells mit einem VPC finden Sie unter [Geben Sie SageMaker KI-gehosteten Endpunkten Zugriff auf Ressourcen in Ihrer Amazon VPC](host-vpc.md).
Ihre Docker-Registry muss mit einem TLS-Zertifikat einer bekannten öffentlichen Zertifizierungsstelle (CA) gesichert werden.
**Anmerkung**
Ihre private Docker-Registry muss eingehenden Datenverkehr von den Sicherheitsgruppen zulassen, die Sie in der VPC-Konfiguration für Ihr Modell angeben, damit SageMaker KI-Hosting Modellimages aus Ihrer Registrierung abrufen kann.
SageMaker KI kann Modellbilder abrufen, DockerHub wenn es in Ihrer VPC einen Pfad zum offenen Internet gibt.
**Topics**
+ [Speichern Sie Images in einer privaten Docker-Registry, bei der es sich nicht um Amazon Elastic-Container-Registry handelt](#your-algorithms-containers-inference-private-registry)
+ [Verwenden Sie ein Image aus einer privaten Docker-Registry für Echtzeit-Inferenz](#your-algorithms-containers-inference-private-use)
+ [Erlauben Sie der SageMaker KI, sich bei einer privaten Docker-Registry zu authentifizieren](#inference-private-docker-authenticate)
+ [So erstellen Sie die Lambda-Funktion:](#inference-private-docker-lambda)
+ [Lambda die Berechtigung für Ihre Ausführungsrolle erteilen](#inference-private-docker-perms)
+ [Einen Schnittstellen-VPC-Endpunkt für Lambda erstellen](#inference-private-docker-vpc-interface)
## Speichern Sie Images in einer privaten Docker-Registry, bei der es sich nicht um Amazon Elastic-Container-Registry handelt
Um eine private Docker-Registry zum Speichern Ihrer Bilder für SageMaker KI-Echtzeit-Inferenzen zu verwenden, erstellen Sie eine private Registry, auf die von Ihrer Amazon VPC aus zugegriffen werden kann. Informationen zum Erstellen einer Docker-Registry finden Sie in der Docker-Dokumentation unter [Bereitstellen eines Registry-Servers](https://docs.docker.com/registry/deploying/). Die Docker-Registry muss den folgenden Anforderungen entsprechen:
+ Bei der Registrierung muss es sich um eine [Docker Registry HTTP API V2](https://docs.docker.com/registry/spec/api/)-Registrierung handeln.
+ Auf die Docker-Registry muss von derselben VPC aus zugegriffen werden können, die Sie in dem `VpcConfig` Parameter angeben, den Sie bei der Erstellung Ihres Modells angeben.
## Verwenden Sie ein Image aus einer privaten Docker-Registry für Echtzeit-Inferenz
Wenn Sie ein Modell erstellen und es für SageMaker KI-Hosting bereitstellen, können Sie angeben, dass es ein Image aus Ihrer privaten Docker-Registry verwendet, um den Inferenzcontainer zu erstellen. Geben Sie dies im `ImageConfig` Objekt in dem `PrimaryContainer` Parameter an, den Sie an einen Aufruf der [create\$1model-Funktion](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) übergeben.
**Um ein in Ihrer privaten Docker-Registry gespeichertes Image für Ihren Inferenzcontainer zu verwenden,**
1. erstellen Sie das Image-Konfigurationsobjekt und geben Sie einen Wert von `Vpc` für das `RepositoryAccessMode` Feld an.
```
image_config = {
'RepositoryAccessMode': 'Vpc'
}
```
1. Wenn Ihre private Docker-Registry eine Authentifizierung erfordert, fügen Sie dem Image-Konfigurationsobjekt ein `RepositoryAuthConfig`-Objekt hinzu. Geben Sie für das `RepositoryCredentialsProviderArn` Feld des `RepositoryAuthConfig` Objekts den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion an, die Anmeldeinformationen bereitstellt, mit denen sich SageMaker KI bei Ihrer privaten Docker-Registry authentifizieren kann. Weitere Informationen zum Erstellen der Lambda-Funktion für die Authentifizierung finden Sie unter [Erlauben Sie der SageMaker KI, sich bei einer privaten Docker-Registry zu authentifizieren](#inference-private-docker-authenticate).
```
image_config = {
'RepositoryAccessMode': 'Vpc',
'RepositoryAuthConfig': {
'RepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName'
}
}
```
1. Erstellen Sie das primäre Container-Objekt, das Sie an `create_model` übergeben wollen, unter Verwendung des Image-Konfigurationsobjekts, das Sie im vorherigen Schritt erstellt haben.
Stellen Sie Ihr Image in [Digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier)-Form bereit. Wenn Sie Ihr Bild mithilfe des `:latest` Tags bereitstellen, besteht das Risiko, dass SageMaker KI eine neuere Version des Images als beabsichtigt abruft. Durch die Verwendung des Digest-Formulars wird sichergestellt, dass SageMaker KI die beabsichtigte Bildversion abruft.
```
primary_container = {
'ContainerHostname': 'ModelContainer',
'Image': 'myteam.myorg.com/docker-local/my-inference-image:',
'ImageConfig': image_config
}
```
1. Geben Sie den Modellnamen und die Ausführungsrolle an, die Sie an `create_model` übergeben wollen.
```
model_name = 'vpc-model'
execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole'
```
1. Geben Sie eine oder mehrere Sicherheitsgruppen und Subnetze für die VPC-Konfiguration für Ihr Modell an. Ihre private Docker-Registry muss eingehenden Datenverkehr von den Sicherheitsgruppen zulassen, die Sie angeben. Die Subnetze, die Sie angeben, müssen sich in derselben VPC wie Ihre private Docker-Registry befinden.
```
vpc_config = {
'SecurityGroupIds': ['sg-0123456789abcdef0'],
'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
}
```
1. Holen Sie sich einen Boto3 AI-Client SageMaker .
```
import boto3
sm = boto3.client('sagemaker')
```
1. Erstellen Sie das Modell, indem Sie `create_model` aufrufen und dabei die Werte verwenden, die Sie in den vorherigen Schritten für die Parameter `PrimaryContainer` und `VpcConfig` angegeben haben.
```
try:
resp = sm.create_model(
ModelName=model_name,
PrimaryContainer=primary_container,
ExecutionRoleArn=execution_role_arn,
VpcConfig=vpc_config,
)
except Exception as e:
print(f'error calling CreateModel operation: {e}')
else:
print(resp)
```
1. Rufen Sie abschließend [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) und [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) auf, um den Hosting-Endpunkt zu erstellen. Verwenden Sie dabei das Modell, das Sie im vorherigen Schritt erstellt haben.
```
endpoint_config_name = 'my-endpoint-config'
sm.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
'VariantName': 'MyVariant',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.t2.medium'
},
],
)
endpoint_name = 'my-endpoint'
sm.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
sm.describe_endpoint(EndpointName=endpoint_name)
```
## Erlauben Sie der SageMaker KI, sich bei einer privaten Docker-Registry zu authentifizieren
[Um ein Inferenz-Image aus einer privaten Docker-Registry abzurufen, für die eine Authentifizierung erforderlich ist, erstellen Sie eine AWS Lambda Funktion, die Anmeldeinformationen bereitstellt, und geben Sie den Amazon-Ressourcennamen (ARN) der Lambda-Funktion an, wenn Sie create\$1model aufrufen.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) Wenn SageMaker AI ausgeführt wird`create_model`, ruft es die Lambda-Funktion auf, die Sie angegeben haben, um Anmeldeinformationen für die Authentifizierung bei Ihrer Docker-Registry abzurufen.
## So erstellen Sie die Lambda-Funktion:
Erstellen Sie eine AWS Lambda Funktion, die eine Antwort mit der folgenden Form zurückgibt:
```
def handler(event, context):
response = {
"Credentials": {"Username": "username", "Password": "password"}
}
return response
```
Je nachdem, wie Sie die Authentifizierung für Ihre private Docker-Registry einrichten, können die Anmeldeinformationen, die Ihre Lambda-Funktion zurückgibt, eine der folgenden Bedeutungen haben:
+ Wenn Sie Ihre private Docker-Registry für die Verwendung der grundlegenden Authentifizierung einrichten, geben Sie die Anmeldeinformationen für die Authentifizierung bei der Registrierung ein.
+ Wenn Sie Ihre private Docker-Registry für die Verwendung der Bearer-Token-Authentifizierung einrichten, werden die Anmeldeinformationen an Ihren Autorisierungsserver gesendet, der ein Bearer-Token zurückgibt, das dann zur Authentifizierung bei der privaten Docker-Registry verwendet werden kann.
## Lambda die Berechtigung für Ihre Ausführungsrolle erteilen
Die Ausführungsrolle, die Sie zum Aufrufen verwenden, `create_model` muss über Berechtigungen zum Aufrufen von AWS Lambda Funktionen verfügen. Fügen Sie der Berechtigungsrichtlinie Ihrer Ausführungsrolle Folgendes hinzu.
```
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:*myLambdaFunction*"
]
}
```
Wo *myLambdaFunction*ist der Name Ihrer Lambda-Funktion. Informationen zum Bearbeiten einer Rollenberechtigungsrichtlinie finden Sie unter [Abändern einer Rollenberechtigungsrichtlinie (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) im *AWS Identity and Access Management Benutzerhandbuch*.
**Anmerkung**
Eine Ausführungsrolle, an die die `AmazonSageMakerFullAccess` verwaltete Richtlinie angehängt ist, hat die Berechtigung, jede Lambda-Funktion aufzurufen, die **SageMaker**in ihrem Namen steht.
## Einen Schnittstellen-VPC-Endpunkt für Lambda erstellen
Erstellen Sie einen Schnittstellenendpunkt, damit Ihre Amazon VPC mit Ihrer AWS Lambda Funktion kommunizieren kann, ohne Traffic über das Internet zu senden. Informationen dazu finden Sie unter [Konfigurieren von Schnittstellen-VPC-Endpunkten für Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) im *AWS Lambda Entwicklerhandbuch*.
SageMaker KI-Hosting sendet über Ihre VPC eine Anfrage an`lambda.region.amazonaws.com`, um Ihre Lambda-Funktion aufzurufen. Wenn Sie bei der Erstellung Ihres Schnittstellenendpunkts den privaten DNS-Namen wählen, leitet Amazon Route 53 den Anruf an den Lambda-Schnittstellenendpunkt weiter. Wenn Sie einen anderen DNS-Anbieter verwenden, stellen Sie sicher, dass Sie `lambda.region.amazonaws.com` Ihrem Lambda-Schnittstellenendpunkt zuordnen.
# Benutzerdefinierter Inferenzcode mit Stapeltransformation
In diesem Abschnitt wird erklärt, wie Amazon SageMaker AI mit einem Docker-Container interagiert, der Ihren eigenen Inferenzcode für die Batch-Transformation ausführt. Verwenden Sie diese Informationen zum Schreiben von Inferenzcode und zum Erstellen eines Docker-Images.
**Topics**
+ [Wie SageMaker KI Ihr Inferenz-Image ausführt](#your-algorithms-batch-code-run-image)
+ [Wie SageMaker KI Ihre Modellartefakte lädt](#your-algorithms-batch-code-load-artifacts)
+ [So bearbeiten Container Anforderungen](#your-algorithms-batch-code-how-containe-serves-requests)
+ [So sollte Ihr Container auf Inferenzanforderungen reagieren](#your-algorithms-batch-code-how-containers-should-respond-to-inferences)
+ [So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren](#your-algorithms-batch-algo-ping-requests)
## Wie SageMaker KI Ihr Inferenz-Image ausführt
Um einen Container so zu konfigurieren, dass er als ausführbare Datei ausgeführt wird, verwenden Sie eine `ENTRYPOINT`-Anweisung in einer Dockerfile. Beachten Sie Folgendes:
+ Bei Batch-Transformationen ruft SageMaker KI das Modell in Ihrem Namen auf. SageMaker AI führt den Container wie folgt aus:
```
docker run image serve
```
Die Eingabe für Batch-Transformationen muss ein Format haben, das in kleinere Dateien aufgeteilt werden kann, um sie parallel zu verarbeiten. Zu diesen Formaten gehören CSV, [JSON](https://www.json.org/json-en.html), [JSON Lines [TFRecord](https://www.tensorflow.org/tutorials/load_data/tfrecord)](https://jsonlines.org/)und [RecordIO](https://mesos.apache.org/documentation/latest/recordio/).
SageMaker AI überschreibt `CMD` Standardanweisungen in einem Container, indem das `serve` Argument hinter dem Bildnamen angegeben wird. Das `serve`-Argument überschreibt Argumente, die Sie mit dem `CMD`-Befehl in der Dockerfile bereitstellen.
+ Es wird empfohlen, das `exec`-Formular der `ENTRYPOINT`-Anleitung zu verwenden:
```
ENTRYPOINT ["executable", "param1", "param2"]
```
Beispiel:
```
ENTRYPOINT ["python", "k_means_inference.py"]
```
+ SageMaker AI legt Umgebungsvariablen fest, die in [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)und [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)auf Ihrem Container angegeben sind. Zusätzlich werden die folgenden Umgebungsvariablen ausgefüllt:
+ `SAGEMAKER_BATCH` wird auf `true` gesetzt, wenn der Container Batch-Transformationen durchführt.
+ `SAGEMAKER_MAX_PAYLOAD_IN_MB` wird auf die größte Nutzlast gesetzt, die über HTTP an den Container gesendet wird.
+ `SAGEMAKER_BATCH_STRATEGY` wird auf `SINGLE_RECORD` gesetzt, wenn der Container einen einzigen Datensatz pro Aufruf erhält, und auf `MULTI_RECORD`, wenn der Container so viele Datensätze erhält, wie in die Nutzlast passen.
+ `SAGEMAKER_MAX_CONCURRENT_TRANSFORMS` ist auf die maximale Anzahl von `/invocations`-Anfragen festgelegt, die gleichzeitig geöffnet werden können.
**Anmerkung**
Die letzten drei Umgebungsvariablen stammen aus dem API-Aufruf durch den Benutzer. Wenn der Benutzer hierfür keine Werte festlegt, werden sie nicht übergeben. In diesem Fall werden entweder die Standardwerte oder die vom Algorithmus (als Antwort auf `/execution-parameters`) angeforderten Werte verwendet.
+ Wenn Sie planen, GPU-Geräte für Modellinferenzen zu verwenden (durch Angabe GPU-basierter ML-Datenverarbeitungs-Instances in Ihrer `CreateTransformJob`-Anforderung), stellen Sie sicher, dass Ihre Container nvidia-docker-kompatibel sind. Bündeln Sie NVIDIA-Treiber nicht mit dem Abbild. Mehr Informationen über nvidia-docker finden Sie unter [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Sie können den `init` Initialisierer nicht als Ihren Einstiegspunkt in SageMaker KI-Containern verwenden, da er durch die Train-and-Serve-Argumente verwirrt wird.
## Wie SageMaker KI Ihre Modellartefakte lädt
In einer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)-Anforderung enthalten Containerdefinitionen den `ModelDataUrl`-Parameter, der den Speicherort in Amazon S3 angibt, an dem die Modellartefakte gespeichert werden. Wenn Sie SageMaker KI verwenden, um Schlussfolgerungen zu ziehen, verwendet sie diese Informationen, um zu bestimmen, von wo aus die Modellartefakte kopiert werden sollen. Es kopiert die Artefakte für die Verwendung durch Ihren Inferenzcode in das `/opt/ml/model`-Verzeichnis im Docker-Container.
Der `ModelDataUrl`-Parameter muss auf eine tar.gz-Datei verweisen. Andernfalls kann SageMaker AI die Datei nicht herunterladen. Wenn Sie ein Modell in SageMaker KI trainieren, werden die Artefakte als einzelne komprimierte TAR-Datei in Amazon S3 gespeichert. Wenn Sie ein Modell in einem anderen Framework trainieren, müssen Sie die Modellartefakte in Amazon S3 als komprimierte TAR-Datei speichern. SageMaker AI dekomprimiert diese TAR-Datei und speichert sie im `/opt/ml/model` Verzeichnis im Container, bevor der Batch-Transformationsjob gestartet wird.
## So bearbeiten Container Anforderungen
Für Container muss ein Webserver implementiert werden, der auf Aufrufe und Ping-Anfragen auf Port 8080 reagiert. Bei Batch-Transformationen haben Sie die Möglichkeit, Algorithmen zur Implementierung von Ausführungsparameteranforderungen festzulegen, um KI eine dynamische Laufzeitkonfiguration bereitzustellen. SageMaker SageMaker KI verwendet die folgenden Endpunkte:
+ `ping`— Wird verwendet, um den Zustand des Containers regelmäßig zu überprüfen. SageMaker KI wartet auf einen `200` HTTP-Statuscode und einen leeren Text auf eine erfolgreiche Ping-Anfrage, bevor sie eine Aufrufanforderung sendet. Sie können eine Ping-Anfrage senden, um ein Modell in den Speicher zu laden und Interferenzen zu erzeugen, wenn Aufrufanforderungen gesendet werden.
+ (Optional) `execution-parameters` – Ermöglicht es dem Algorithmus, die optimalen Abstimmungsparameter für einen Auftrag zur Laufzeit bereitzustellen. Auf der Grundlage des für einen Container CPUs verfügbaren Speichers wählt der Algorithmus die entsprechenden `MaxConcurrentTransforms``BatchStrategy`, und `MaxPayloadInMB` Werte für den Job aus.
Vor dem Aufrufen der Aufrufanforderung versucht SageMaker AI, die Anfrage mit den Ausführungsparametern aufzurufen. Wenn Sie einen Batch-Transformationsauftrag erstellen, können Sie Werte für die `MaxConcurrentTransforms` Parameter, und angeben. `BatchStrategy` `MaxPayloadInMB` SageMaker AI bestimmt die Werte für diese Parameter anhand dieser Rangfolge:
1. Die Parameterwerte, die Sie beim Erstellen der `CreateTransformJob`-Anforderung angeben.
1. Die Werte, die der Modellcontainer zurückgibt, wenn SageMaker AI den Endpunkt der Ausführungsparameter aufruft
1. Die Standardparameterwerte sind in der folgenden Tabelle aufgeführt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/your-algorithms-batch-code.html)
Die Antwort auf eine `GET`-Ausführungsparameter-Anforderung ist ein JSON-Objekt mit Schlüsseln für die `MaxConcurrentTransforms`-, – `BatchStrategy`und `MaxPayloadInMB`-Parameter. Dies ist ein Beispiel für eine gültige Antwort:
```
{
“MaxConcurrentTransforms”: 8,
“BatchStrategy": "MULTI_RECORD",
"MaxPayloadInMB": 6
}
```
## So sollte Ihr Container auf Inferenzanforderungen reagieren
Um Rückschlüsse zu erhalten, sendet Amazon SageMaker AI eine POST-Anfrage an den Inferenzcontainer. Der POST-Anforderungstext enthält Daten aus Amazon S3. Amazon SageMaker AI leitet die Anfrage an den Container weiter und gibt das Inferenzergebnis aus dem Container zurück, wobei die Daten aus der Antwort in Amazon S3 gespeichert werden.
Zum Empfangen von Inferenzanforderungen muss der Container über einen Webserver verfügen, der den Port 8080 überwacht, und muss POST-Anforderungen an den `/invocations`-Endpunkt akzeptieren. Das Timeout für Inferenzanforderungen und die maximale Anzahl an Wiederholungen können über `[ModelClientConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html)` konfiguriert werden.
## So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren
Die einfachste Anforderung für den Container besteht darin, mit einem HTTP 200-Statuscode ohne Text zu antworten. Dies zeigt SageMaker AI an, dass der Container bereit ist, Inferenzanfragen am Endpunkt anzunehmen. `/invocations`
Die Mindestgrenze besteht darin, dass der Container statische 200 zurückgibt, ein Containerentwickler kann diese Funktionalität jedoch nutzen, um umfassendere Prüfungen durchzuführen. Das Anforderungstimeout bei `/ping`-Versuchen beträgt 2 Sekunden.
# Beispiele und weitere Informationen: Verwenden Sie Ihren eigenen Algorithmus oder Ihr eigenes Modell
Die folgenden Jupyter-Notebooks und zusätzliche Informationen zeigen, wie Sie Ihre eigenen Algorithmen oder vortrainierten Modelle aus einer Amazon-Notebook-Instance verwenden können. SageMaker Links zu den GitHub Repositorys mit den vorgefertigten Dockerfiles für die Frameworks TensorFlow, MXNet, Chainer und PyTorch Frameworks sowie Anweisungen zur Verwendung der AWS SDK für Python (Boto3) Schätzer zur Ausführung Ihrer eigenen Trainingsalgorhythmen auf AI Learner und Ihrer eigenen Modelle auf SageMaker KI-Hosting finden Sie unter SageMaker [Vorgefertigte SageMaker KI-Docker-Images für Deep Learning](pre-built-containers-frameworks-deep-learning.md)
## Einrichtung
1. Erstellen SageMaker Sie eine Notebook-Instanz. Anweisungen zum Erstellen von Jupyter-Notebook-Instances und zum Zugriff darauf finden Sie unter [SageMaker Amazon-Notebook-Instanzen](nbi.md).
1. Öffnen Sie die Notebook-Instance, die Sie erstellt haben.
1. Wählen Sie den Tab **SageMaker KI-Beispiele** für eine Liste aller SageMaker KI-Beispiel-Notebooks.
1. Öffnen Sie die Beispielnotizbücher im Bereich **Erweiterte Funktionen** in Ihrer Notebook-Instanz oder GitHub über die bereitgestellten Links. Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Use (Verwenden)** und dann **Create copy (Kopie erstellen)**.
## Hosten Sie Modelle, die in Scikit-Learn trainiert wurden
In den folgenden Beispielnotizbüchern erfahren Sie, wie Sie in Scikit-Learn trainierte Modelle hosten können, um Vorhersagen in SageMaker KI zu treffen, indem Sie sie in K-Means und XGBoost Container von Erstanbietern injizieren.
+ [kmeans\$1bring\$1your\$1own\$1model](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/kmeans_bring_your_own_model)
+ [xgboost\$1bring\$1your\$1own\$1model](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/xgboost_bring_your_own_model)
## Package TensorFlow - und SciKit-Learn-Modelle für den Einsatz in KI SageMaker
In den folgenden Notebooks erfahren Sie, wie Sie Algorithmen, die Sie in Frameworks entwickelt haben, TensorFlow und Scikit-Learn-Frameworks für Training und Einsatz in der SageMaker KI-Umgebung verpacken. Sie zeigen Ihnen, wie Sie Ihre eigenen Docker-Container mithilfe von Dockerfiles erstellen, registrieren und bereitstellen können.
+ [tensorflow\$1bring\$1your\$1own](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/tensorflow_iris_byom/tensorflow_BYOM_iris.ipynb)
+ [scikit\$1bring\$1your\$1own](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/scikit_bring_your_own)
## Trainieren und implementieren Sie ein neuronales Netzwerk auf KI SageMaker
In den folgenden Notebooks erfahren Sie TensorFlow, wie Sie ein neuronales Netzwerk lokal mit MXNet oder trainieren und anschließend aus dem trainierten Modell einen Endpunkt erstellen und ihn auf SageMaker KI bereitstellen. Das MXNet Modell ist darauf trainiert, handgeschriebene Zahlen aus dem MNIST-Datensatz zu erkennen. Das TensorFlow Modell ist darauf trainiert, Iris zu klassifizieren.
+ [mxnet\$1mnist\$1byom](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html)
+ [tensorflow\$1BYOM\$1iris](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/tensorflow_iris_byom/tensorflow_BYOM_iris.ipynb)
## Trainieren mit Pipe-Modus
Um zu erfahren, wie Sie eine Dockerfile zum Erstellen eines Containers verwenden, der das `train.py script` aufruft und den Pipe-Modus zum benutzerdefinierten Training eines Algorithmus verwendet, beachten Sie das folgende Notebook. Im Pipe-Modus werden die Eingabedaten während des Trainings auf den Algorithmus übertragen. Dadurch kann sich die Trainingszeit im Vergleich zum Dateimodus verkürzen.
+ [pipe\$1bring\$1your\$1own](https://github.com/aws/amazon-sagemaker-examples/blob/0efd885ef2a5c04929d10c5272681f4ca17dac17/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb)
## Bringen Sie Ihr eigenes R-Modell mit
Wie man ein benutzerdefiniertes R-Image hinzufügt, um ein Modell in einem AWS SMS -Notebook zu erstellen und zu trainieren, erfahren Sie im folgenden Blogbeitrag. In diesem Blogbeitrag wird ein R-Dockerfile-Beispiel aus einer Bibliothek von [SageMaker AI Studio Classic Custom Image](https://github.com/aws-samples/sagemaker-studio-custom-image-samples) Samples verwendet.
+ [Bringen Sie Ihre eigene R-Umgebung zu Amazon SageMaker Studio Classic](https://aws.amazon.com/blogs/machine-learning/bringing-your-own-r-environment-to-amazon-sagemaker-studio/)
## Erweitern Sie ein vorgefertigtes PyTorch Container-Image
Im folgenden Notizbuch erfahren Sie, wie Sie ein vorgefertigtes SageMaker PyTorch KI-Container-Image erweitern können, wenn Sie zusätzliche funktionale Anforderungen an Ihren Algorithmus oder Ihr Modell haben, die das vorgefertigte Docker-Image nicht unterstützt.
+ [BERTtopic\$1extending\$1container](https://github.com/aws/amazon-sagemaker-examples/blob/0efd885ef2a5c04929d10c5272681f4ca17dac17/advanced_functionality/pytorch_extend_container_train_deploy_bertopic/BERTtopic_extending_container.ipynb)
Weitere Informationen zum Erweitern eines Containers finden Sie unter [Erweitern eines vorgefertigten Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html).
## Trainieren und debuggen Sie Trainingsaufträge in einem benutzerdefinierten Container
Informationen zum Trainieren und Debuggen von Trainingsjobs mit SageMaker Debugger finden Sie im folgenden Notizbuch. Ein in diesem Beispiel bereitgestelltes Trainingsskript verwendet das TensorFlow Keras ResNet 50-Modell und den Datensatz. CIFAR10 Ein benutzerdefinierter Docker-Container wird mit dem Trainingsskript erstellt und an Amazon ECR übertragen. Während der Trainingsauftrag ausgeführt wird, sammelt der Debugger die Tensorausgaben und identifiziert Debugging-Probleme. Mit den `smdebug` Client-Bibliothek-Tools können Sie ein `smdebug` Testobjekt einrichten, das den Trainingsauftrag und die Debugging-Informationen aufruft, den Status der Trainings- und Debugger-Regeln überprüfen und in einem Amazon-S3-Bucket gespeicherte Tensoren abrufen, um Trainingsprobleme zu analysieren.
+ [build\$1your\$1own\$1container\$1with\$1debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html)
## Fehlerbehebung für Ihre Docker-Container und -Bereitstellungen
Im Folgenden sind häufig auftretende Fehler aufgeführt, auf die Sie bei der Verwendung von Docker Containern mit SageMaker KI stoßen können. Auf jeden Fehler folgt eine Lösung für den Fehler.
+ **Fehler: SageMaker AI hat den Docker Daemon verloren.**
Starten Sie Docker mit dem folgenden Befehl neu, um diesen Fehler zu beheben.
```
sudo service docker restart
```
+ **Fehler: Im `/tmp`-Verzeichnis Ihres Docker-Containers ist der Speicherplatz knapp geworden.**
Docker-Container verwenden `/`- und `/tmp`-Partitionen, um Code zu speichern. Diese Partitionen können leicht gefüllt werden, wenn große Codemodule im lokalen Modus verwendet werden. Das SageMaker AI Python SDK unterstützt die Angabe eines benutzerdefinierten temporären Verzeichnisses für Ihr Stammverzeichnis im lokalen Modus, um dieses Problem zu vermeiden.
Um das benutzerdefinierte temporäre Verzeichnis im Volume-Speicher Amazon Elastic Block Store anzugeben, erstellen Sie eine Datei im Pfad `~/.sagemaker/config.yaml` und fügen Sie die folgende Konfiguration hinzu. Das Verzeichnis, als das Sie angeben, `container_root` muss bereits vorhanden sein. Das SageMaker AI Python SDK wird nicht versuchen, es zu erstellen.
```
local:
container_root: /home/ec2-user/SageMaker/temp
```
Bei dieser Konfiguration verwendet der lokale Modus das `/temp` Verzeichnis und nicht das `/tmp` Standardverzeichnis.
+ **Fehler bei geringem Speicherplatz auf SageMaker Notebook-Instanzen**
Ein Docker Container, der auf SageMaker Notebook-Instances ausgeführt wird, verwendet standardmäßig das Amazon EBS-Root-Volume der Notebook-Instance. Um Fehler bei geringem Speicherplatz zu beheben, geben Sie den Pfad des Amazon-EBS-Volumes, das an die Notebook-Instance angehängt ist, als Teil des Volume-Parameters von Docker-Befehlen an.
```
docker run -v EBS-volume-path:container-path
```