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. # 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).