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.
# Hosting-Optionen
In den folgenden Themen werden die verfügbaren SageMaker KI-Echtzeit-Hosting-Optionen sowie das Einrichten, Aufrufen und Löschen der einzelnen Hosting-Optionen beschrieben.
**Topics**
+ [Endpunkte für ein einzelnes Modell](realtime-single-model.md)
+ [Multimodell-Endpunkte](multi-model-endpoints.md)
+ [Endpunkte mit mehreren Containern](multi-container-endpoints.md)
+ [Inferenz-Pipelines in Amazon AI SageMaker](inference-pipelines.md)
+ [Endpunkte und Ressourcen löschen](realtime-endpoints-delete-resources.md)
# Endpunkte für ein einzelnes Modell
Sie können Echtzeit-Inferenzendpunkte, die ein einzelnes Modell hosten, mit Amazon SageMaker Studio, dem AWS SDK für Python (Boto3), dem SageMaker Python SDK oder der AWS CLI erstellen, aktualisieren und löschen. Das Verfahren und Codebeispiele finden Sie unter [Modelle für Echtzeit-Inferenzen bereitstellen](realtime-endpoints-deploy-models.md).
# Multimodell-Endpunkte
Multimodell-Endpunkte bieten eine skalierbare und kostengünstige Lösung für die Bereitstellung einer großen Anzahl von Modellen. Sie verwenden dieselbe Flotte von Ressourcen und einen gemeinsamen Server-Container, um alle Ihre Modelle zu hosten. Dies reduziert Hosting-Kosten, indem die Endpunktauslastung gegenüber der Verwendung von Einzelmodell-Endpunkten verbessert wird. Es reduziert auch den Bereitstellungsaufwand, da Amazon SageMaker AI das Laden von Modellen im Speicher und deren Skalierung auf der Grundlage der Datenverkehrsmuster zu Ihrem Endpunkt verwaltet.
Das folgende Diagramm zeigt, wie Multimodell-Endpunkte im Vergleich zu Einzelmodell-Endpunkten funktionieren.
![\[Ein Diagramm, das zeigt, wie Multimodell- und Einzelmodell-Endpunkte Modelle hosten.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/multi-model-endpoints-diagram.png)
Multimodell-Endpunkte eignen sich ideal zum Hosten einer großen Anzahl von Modellen, die dasselbe ML-Framework auf einem gemeinsam genutzten Serving-Container verwenden. Wenn Sie eine Mischung von Modellen haben, auf die häufig bzw. selten zugegriffen wird, kann ein Multimodell-Endpunkt diesen Datenverkehr mit weniger Ressourcen und höheren Kosteneinsparungen effizient bedienen. Ihre Anwendung sollte gelegentlich auftretende Latenzeinbußen im durch Kaltstarts tolerieren, die beim Aufrufen selten verwendeter Modelle auftreten.
Multimodell-Endpunkte unterstützen das Hosten von Modellen mit CPU- und GPU-Unterstützung. Durch die Verwendung von GPU-gestützten Modellen können Sie die Kosten für die Modellbereitstellung senken, indem Sie den Endpunkt und die zugrunde liegenden beschleunigten Cpmputing-Instances stärker auslasten.
Multimodell-Endpunkte ermöglichen darüber hinaus die zeitliche gemeinsame Nutzung von Speicherressourcen über Ihre Modelle hinweg. Dies funktioniert am besten, wenn die Modelle in Größe und Aufruflatenz recht ähnlich sind. In diesem Fall können Multimodell-Endpunkte Instances effektiv über alle Modelle hinweg verwenden. Wenn Sie Modelle mit deutlich höheren Transaktionen pro Sekunde (TPS) oder Latenzanforderungen haben, empfehlen wir Ihnen, diese auf dedizierten Endpunkten zu hosten.
Sie können Multimodell-Endpunkte mit den folgenden Features verwenden:
+ [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)und VPCs
+ [Auto-Scaling](multi-model-endpoints-autoscaling.md)
+ [Serielle Inference Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) (es kann jedoch nur ein multimodell-fähiger Container in einer Inference-Pipeline enthalten sein)
+ A/B-Tests
Sie können die AWS SDK für Python (Boto) oder die SageMaker KI-Konsole verwenden, um einen Endpunkt mit mehreren Modellen zu erstellen. Für CPU-gestützte Multimodell-Endpunkte können Sie Ihren Endpunkt mit benutzerdefinierten Containern erstellen, indem Sie die [Multimodell-Server](https://github.com/awslabs/multi-model-server)-Bibliothek integrieren.
**Topics**
+ [Funktionsweise von Multimodell-Endpunkten](#how-multi-model-endpoints-work)
+ [Beispiel-Notebooks für Multimodell-Endpunkte](#multi-model-endpoint-sample-notebooks)
+ [Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte](multi-model-support.md)
+ [Instance-Empfehlungen für Bereitstellungen von Multimodell-Endpunkten](multi-model-endpoint-instance.md)
+ [Erstellen eines Multimodell-Endpunkts](create-multi-model-endpoint.md)
+ [Aufrufen eines Multimodell-Endpunkts](invoke-multi-model-endpoint.md)
+ [Hinzufügen oder Entfernen von Modellen](add-models-to-endpoint.md)
+ [Erstellen Sie Ihren eigenen Container für SageMaker KI-Endpunkte mit mehreren Modellen](build-multi-model-build-container.md)
+ [Sicherheit eines Multimodell-Endpunkts](multi-model-endpoint-security.md)
+ [CloudWatch Metriken für Endpunktbereitstellungen mit mehreren Modellen](multi-model-endpoint-cloudwatch-metrics.md)
+ [Legen Sie das Caching-Verhalten von SageMaker KI-Endpunktmodellen für mehrere Modelle fest](multi-model-caching.md)
+ [Legen Sie Auto-Scaling-Richtlinien für die Bereitstellung von Multimodell-Endpunkten fest](multi-model-endpoints-autoscaling.md)
## Funktionsweise von Multimodell-Endpunkten
SageMaker KI verwaltet den Lebenszyklus von Modellen, die auf Endpunkten mit mehreren Modellen im Speicher des Containers gehostet werden. Anstatt alle Modelle von einem Amazon S3 S3-Bucket in den Container herunterzuladen, wenn Sie den Endpunkt erstellen, lädt SageMaker KI sie dynamisch und speichert sie im Cache, wenn Sie sie aufrufen. Wenn SageMaker AI eine Aufrufanfrage für ein bestimmtes Modell erhält, geht sie wie folgt vor:
1. Er leitet die Anforderung an eine Instance hinter dem Endpunkt weiter.
1. Er lädt das Modell aus dem S3-Bucket auf das Speicher-Volume dieser Instance herunter.
1. Lädt das Modell in den Speicher des Containers (CPU oder GPU, je nachdem, ob Sie über CPU- oder GPU-gestützte Instances verfügen) auf dieser beschleunigten Computing-Instance. Wenn das Modell bereits im Speicher des Containers geladen ist, ist der Aufruf schneller, da SageMaker KI es nicht herunterladen und laden muss.
SageMaker KI leitet Anfragen für ein Modell weiterhin an die Instanz weiter, in der das Modell bereits geladen ist. Wenn das Modell jedoch viele Aufrufanfragen empfängt und es zusätzliche Instanzen für den Endpunkt mit mehreren Modellen gibt, leitet SageMaker KI einige Anfragen an eine andere Instanz weiter, um den Datenverkehr zu berücksichtigen. Wenn das Modell noch nicht auf die zweite Instance geladen wurde, wird das Modell auf das Speicher-Volume dieser Instance heruntergeladen und in den Speicher des Containers geladen.
Wenn die Speicherauslastung einer Instanz hoch ist und SageMaker KI ein anderes Modell in den Speicher laden muss, werden ungenutzte Modelle aus dem Container dieser Instanz entladen, um sicherzustellen, dass genügend Speicher zum Laden des Modells vorhanden ist. Entfernte Modelle verbleiben auf dem Speicher-Volume der Instance und können später in den Speicher des Containers geladen werden, ohne dass sie erneut aus dem S3-Bucket heruntergeladen werden müssen. Wenn das Speichervolumen der Instance seine Kapazität erreicht, löscht SageMaker AI alle ungenutzten Modelle aus dem Speichervolume.
Um ein Modell zu löschen, beenden Sie das Senden von Anfragen und löschen Sie es aus dem S3-Bucket. SageMaker KI bietet Endpunktfunktionen für mehrere Modelle in einem Serving-Container. Das Hinzufügen von Modellen zu einem Multimodell-Endpunkt und ihr Löschen erfordert keine Aktualisierung des Endpunkts selbst. Um ein Modell hinzuzufügen, laden Sie es in den S3-Bucket hoch und rufen Sie es auf. Um sie verwenden zu können, sind keine Codeänderungen erforderlich.
**Anmerkung**
Wenn Sie einen Multimodell-Endpunkt aktualisieren, kann es bei Aufrufanfragen auf dem Endpunkt zunächst zu höheren Latenzen kommen, da sich Smart Routing auf Multimodell-Endpunkten an das Muster Ihres Datenverkehrs anpasst. Sobald es allerdings das Muster Ihres Datenverkehrs kennt, kann es bei den am häufigsten verwendeten Modellen zu niedrigen Latenzen kommen. Bei weniger häufig verwendeten Modellen kann es zu Kaltstart-Latenzen kommen, da die Modelle dynamisch in eine Instance geladen werden.
## Beispiel-Notebooks für Multimodell-Endpunkte
Weitere Informationen zur Verwendung von Multimodell-Endpunkten finden Sie evtl. in den folgenden Beispiel-Notebooks:
+ Beispiele für Multimodell-Endpunkte, die CPU-gestützte Instances verwenden:
+ [ XGBoost Beispielnotizbuch für Endgeräte mit mehreren Modellen](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) — Dieses Notizbuch zeigt, wie mehrere XGBoost Modelle auf einem Endpunkt bereitgestellt werden.
+ [BYOC-Beispielnotizbuch für Endgeräte mit mehreren Modellen — In diesem Notizbuch](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_bring_your_own/multi_model_endpoint_bring_your_own.html) wird gezeigt, wie ein Kundencontainer eingerichtet und bereitgestellt wird, der Endgeräte mit mehreren Modellen in KI unterstützt. SageMaker
+ Beispiel für Multimodell-Endpunkte, die GPU-gestützte Instances verwenden:
+ [Führen Sie mehrere Deep-Learning-Modelle GPUs mit Amazon SageMaker AI Multi-Model Endpoints (MME)](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) aus — Dieses Notizbuch zeigt, wie Sie einen NVIDIA Triton Inference-Container verwenden, um ResNet -50 Modelle auf einem Endpunkt mit mehreren Modellen bereitzustellen.
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instances, mit denen Sie die vorherigen Beispiele in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele zu sehen. SageMaker Die Notebooks für Multimodell-Endpunkte finden Sie im Abschnitt **ADVANCED FUNCTIONALITY**. Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
Weitere Informationen zu Anwendungsfällen für Multimodell-Endpunkte finden Sie in den folgenden Blogs und Ressourcen:
+ Video: [Hosten von Tausenden von Modellen auf SageMaker KI](https://www.youtube.com/watch?v=XqCNTWmHsLc&t=751s)
+ Video: [SageMaker KI ML für SaaS](https://www.youtube.com/watch?v=BytpYlJ3vsQ)
+ Blog: [So skalieren Sie die Inference für Machine Learning für mandantenfähige SaaS-Anwendungsfälle](https://aws.amazon.com/blogs/machine-learning/how-to-scale-machine-learning-inference-for-multi-tenant-saas-use-cases/)
+ Fallstudie: [Veeva Systems](https://aws.amazon.com/partners/success/advanced-clinical-veeva/)
# Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte
Informationen zu den Algorithmen, Frameworks und Instance-Typen, die Sie mit Multimodell-Endpunkten verwenden können, finden Sie in den folgenden Abschnitten.
## Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte, die CPU-gestützte Instances verwenden
Die Inference-Container für die folgenden Algorithmen und Frameworks unterstützen Multimodell-Endpunkte:
+ [XGBoost Algorithmus mit Amazon SageMaker AI](xgboost.md)
+ [K-nearest neighbors (k-NN)-Algorithmus](k-nearest-neighbors.md)
+ [Algorithmus für lineares Lernen](linear-learner.md)
+ [Random Cut Forest (RCF)-Algorithmus](randomcutforest.md)
+ [Ressourcen für die Verwendung TensorFlow mit Amazon SageMaker AI](tf.md)
+ [Ressourcen für die Verwendung von Scikit-Learn mit Amazon AI SageMaker](sklearn.md)
+ [Ressourcen für die Verwendung von Apache MXNet mit Amazon SageMaker AI](mxnet.md)
+ [Ressourcen für die Verwendung PyTorch mit Amazon SageMaker AI](pytorch.md)
Um ein anderes Framework oder einen anderen Algorithmus zu verwenden, verwenden Sie das SageMaker KI-Inferenz-Toolkit, um einen Container zu erstellen, der Endpunkte mit mehreren Modellen unterstützt. Weitere Informationen finden Sie unter [Erstellen Sie Ihren eigenen Container für SageMaker KI-Endpunkte mit mehreren Modellen](build-multi-model-build-container.md).
Multimodell-Endpunkte unterstützen CPU-Instances jedes Typs.
## Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte, die GPU-gestützte Instances verwenden
[Das Hosten mehrerer GPU-gestützter Modelle auf Endpunkten mit mehreren Modellen wird über den AI Triton Inference Server unterstützt. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Dies unterstützt alle wichtigen Inferenz-Frameworks wie NVIDIA® TensorRT™,, Python PyTorch, MXNet ONNX, Scikit-Learn XGBoost, OpenVINO RandomForest, benutzerdefiniertes C\$1\$1 und mehr.
Um ein anderes Framework oder einen anderen Algorithmus zu verwenden, können Sie das Triton-Backend für Python oder C\$1\$1 verwenden, um Ihre Modelllogik zu schreiben und jedes benutzerdefinierte Modell bereitzustellen. Sobald Sie den Server bereit haben, können Sie damit beginnen, Hunderte von Deep-Learning-Modellen hinter einem Endpunkt bereitzustellen.
Multimodell-Endpunkte unterstützen GPU-Instances der folgenden Typen:
| Instance-Familie | Instance-Typ | v CPUs | GiB Arbeitsspeicher pro vCPU | GPUs | GPU-Arbeitsspeicher |
| --- | --- | --- | --- | --- | --- |
| p2 | ml.p2.xlarge | 4 | 15,25 | 1 | 12 |
| p3 | ml.p3.2xlarge | 8 | 7,62 | 1 | 16 |
| g5 | ml.g5.xlarge | 4 | 4 | 1 | 24 |
| g5 | ml.g5.2xlarge | 8 | 4 | 1 | 24 |
| g5 | ml.g5.4xlarge | 16 | 4 | 1 | 24 |
| g5 | ml.g5.8xlarge | 32 | 4 | 1 | 24 |
| g5 | ml.g5.16xlarge | 64 | 4 | 1 | 24 |
| g4dn | ml.g4dn.xlarge | 4 | 4 | 1 | 16 |
| g4dn | ml.g4dn.2xlarge | 8 | 4 | 1 | 16 |
| g4dn | ml.g4dn.4xlarge | 16 | 4 | 1 | 16 |
| g4dn | ml.g4dn.8xlarge | 32 | 4 | 1 | 16 |
| g4dn | ml.g4dn.16xlarge | 64 | 4 | 1 | 16 |
# Instance-Empfehlungen für Bereitstellungen von Multimodell-Endpunkten
Bei der Auswahl eines SageMaker AI ML-Instance-Typs für einen Endpunkt mit mehreren Modellen sind mehrere Punkte zu berücksichtigen:
+ Stellen Sie ausreichend [ Amazon Elastic Block Store (Amazon EBS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)-Kapazität für alle Modelle bereit, die bereitgestellt werden müssen.
+ Wägen Sie Leistung (Minimierung von Kaltstarts) und Kosten (keine übermäßige Bereitstellung von Instance-Kapazität) gegeneinander auf. Informationen zur Größe des Speichervolumens, das SageMaker AI für jeden Instanztyp für einen Endpunkt und für einen Endpunkt mit mehreren Modellen anhängt, finden Sie unter. [Instance-Speicher-Volumes](host-instance-storage.md)
+ Bei einem Container, der für die Ausführung im `MultiModel`-Modus konfiguriert ist, verfügt das für seine Instances bereitgestellte Speichervolume über mehr Speicher als im Standardmodus `SingleModel`. Somit können mehr Modelle im Instance-Speicher zwischengespeichert werden als im `SingleModel`-Modus.
Beachten Sie bei der Auswahl eines SageMaker AI ML-Instanztyps Folgendes:
+ Multimodell-Endpunkte werden derzeit für alle CPU-Instance-Typen und für Single-GPU-Instance-Typen unterstützt.
+ Bei der Datenverkehrsverteilung (Zugriffsmuster) auf die Modelle, die hinter dem Multimodell-Endpunkt gehostet werden sollen, zusammen mit der Modellgröße (wie viele Modelle in den Speicher der Instance geladen werden könnten) ist folgendes zu berücksichtigen:
+ Stellen Sie sich die Speichermenge auf einer Instanz als Cache-Speicherplatz für zu ladende Modelle vor und stellen Sie sich die Anzahl von v CPUs als die Parallelitätsgrenze für die Durchführung von Inferenzen auf die geladenen Modelle vor (vorausgesetzt, das Aufrufen eines Modells ist an die CPU gebunden).
+ Bei CPU-gestützten Instances CPUs wirkt sich die Anzahl von v auf Ihre maximale Anzahl gleichzeitiger Aufrufe pro Instanz aus (vorausgesetzt, das Aufrufen eines Modells ist an die CPU gebunden). Ein höherer Wert von v CPUs ermöglicht es Ihnen, mehr einzigartige Modelle gleichzeitig aufzurufen.
+ Bei GPU-gestützten Instances können Sie mit mehr Instance- und GPU-Speicher mehr Modelle laden und für Inference-Anfragen bereithalten.
+ Halten Sie für CPU- und GPU-gestützte Instances eine gewisse Menge an „Reservespeicher“ bereit, damit nicht genutzte Modelle entladen werden können, insbesondere bei Multimodell-Endpunkten mit mehreren Instances. Wenn eine Instance oder eine Availability Zone ausfällt, werden die Modelle dieser Instances an andere Instances hinter dem Endpunkt umgeleitet.
+ Ermitteln Sie Ihre Toleranz gegenüber loading/downloading Zeiten:
+ Die Instance-Typfamilien d (z. B. m5d, c5d oder r5d) und g5s verfügen über eine SSD NVMe (Non-Volatile Memory Express), die eine hohe I/O Leistung bietet und die Zeit reduzieren kann, die zum Herunterladen von Modellen auf das Speichervolume und zum Laden des Modells durch den Container vom Speichervolume benötigt wird.
+ Da die Instance-Typen d und g5 über einen NVMe SSD-Speicher verfügen, fügt SageMaker KI diesen ML-Compute-Instances, die den Multimodell-Endpunkt hosten, kein Amazon EBS-Speichervolume hinzu. Auto Scaling funktioniert am besten, wenn die Modelle ähnlich dimensioniert und homogen sind, d. h. wenn sie ähnliche Inference-Latenz- und Ressourcenanforderungen haben.
Sie können auch die folgenden Anleitungen verwenden, um das Laden von Modellen auf Ihre Multimodell-Endpunkte zu optimieren:
**Wählen Sie einen Instance-Typ, der nicht alle Zielmodelle im Speicher aufnehmen kann**
In einigen Fällen können Sie sich dafür entscheiden, die Kosten zu senken, indem Sie einen Instance-Typ wählen, der nicht alle Zielmodelle gleichzeitig im Arbeitsspeicher aufnehmen kann. SageMaker KI entlädt Modelle dynamisch, wenn der Speicherplatz knapp wird, um Platz für ein neues Zielmodell zu schaffen. Bei selten angeforderten Modellen verlieren Sie die dynamische Latenz beim Laden. In Fällen mit strengeren Latenzanforderungen können Sie sich für größere Instance-Typen oder mehr Instances entscheiden. Wenn Sie vorab Zeit für Leistungstests und Analysen investieren, können Sie Produktionsbereitstellungen erfolgreich durchführen.
**Auswertung der Treffer im Modell-Cache**
CloudWatch Amazon-Metriken können Ihnen bei der Bewertung Ihrer Modelle helfen. Weitere Informationen zu Kennzahlen, die Sie mit Multimodell-Endpunkten verwenden können, finden Sie unter [CloudWatch Metriken für Endpunktbereitstellungen mit mehreren Modellen](multi-model-endpoint-cloudwatch-metrics.md).
Sie können mithilfe der `Average`-Statistik der Metrik `ModelCacheHit` das Verhältnis von Anforderungen überwachen, bei denen das Modell bereits geladen ist. Sie können mithilfe der `SampleCount`-Statistik für die Metrik `ModelUnloadingTime` die Anzahl der Entladungsanforderungen überwachen, die während eines Zeitraums an den Container gesendet werden. Wenn Modelle zu häufig entladen werden (ein Anzeichen für *Thrashing*, bei dem Modelle entladen und wieder geladen werden, da für den Arbeitssatz von Modellen nicht genügend Cache-Platz zur Verfügung steht), sollten Sie einen größeren Instance-Typ mit mehr Speicher verwenden oder die Anzahl der Instances hinter dem Multimodell-Endpunkt erhöhen. Beachten Sie bei Multimodell-Endpunkten mit mehreren Instances, dass ein Modell möglicherweise auf mehr als eine Instance geladen wird.
# Erstellen eines Multimodell-Endpunkts
Sie können die SageMaker AI-Konsole oder die verwenden, AWS SDK für Python (Boto) um einen Endpunkt mit mehreren Modellen zu erstellen. Informationen dazu, wie ein CPU- oder GPU-gestützter Endpunkt über die Konsole erstellt wird, finden Sie im Konsolenverfahren in den folgenden Abschnitten. Wenn Sie mit dem einen Endpunkt mit mehreren Modellen erstellen möchten AWS SDK für Python (Boto), verwenden Sie entweder das CPU- oder GPU-Verfahren in den folgenden Abschnitten. Die CPU- und GPU-Workflows sind ähnlich, weisen jedoch mehrere Unterschiede auf, z. B. die Container-Anforderungen.
**Topics**
+ [Erstellen eines Multimodell-Endpunkts (Konsole)](#create-multi-model-endpoint-console)
+ [Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von CPUs AWS SDK für Python (Boto3)](#create-multi-model-endpoint-sdk-cpu)
+ [Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von GPUs AWS SDK für Python (Boto3)](#create-multi-model-endpoint-sdk-gpu)
## Erstellen eines Multimodell-Endpunkts (Konsole)
Über die Konsole können Sie CPU- und GPU-gestützte Multimodell-Endpunkte erstellen. Gehen Sie wie folgt vor, um über die SageMaker AI-Konsole einen Endpunkt mit mehreren Modellen zu erstellen.
**So erstellen Sie einen Multimodell-Endpunkt (Konsole)**
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 **Model (Modell)** und wählen Sie dann aus der Gruppe **Inference (Inferenz)** die Option **Create model (Modell erstellen)** aus.
1. Geben Sie für **Model name (Modellname)** einen Namen ein.
1. Wählen Sie für **IAM-Rolle** eine IAM-Rolle bzw. erstellen Sie eine, die mit der `AmazonSageMakerFullAccess` IAM-Richtlinie verknüpft ist.
1. Wählen Sie im Abschnitt **Containerdefinition** für **Modellartefakte und Optionen für Inference-Bilder bereitstellen** die Option **Mehrere Modelle verwenden** aus.
![\[Der Bereich auf der Seite „Modell erstellen“, in dem Sie die Option Mehrere Modelle verwenden auswählen können\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG)
1. Geben Sie für das **Inference-Container-Image** den Amazon ECR-Pfad für Ihr gewünschtes Container-Image ein.
Für GPU-Modelle müssen Sie einen Container verwenden, der vom NVIDIA Triton Inference Server unterstützt wird. Eine Liste der Container-Images, die mit GPU-gestützten Endpunkten funktionieren, finden Sie in den [NVIDIA Triton Inference Containers (nur SM-Unterstützung)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only). Weitere Informationen zum NVIDIA Triton Inference Server finden Sie unter [Verwenden von Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Server mit KI. SageMaker
1. Wählen Sie **Modell erstellen** aus.
1. Stellen Sie Ihren Multimodell-Endpunkt genauso wie einen Einzelmodell-Endpunkt bereit. Detaillierte Anweisungen finden Sie unter [Stellen Sie das Modell für SageMaker AI Hosting Services bereit](ex1-model-deployment.md#ex1-deploy-model).
## Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von CPUs AWS SDK für Python (Boto3)
Erstellen Sie mit Hilfe des folgenden Abschnitts einen durch CPU-Instances unterstützten Multimodell-Endpunkt. Sie erstellen mithilfe der Amazon SageMaker AI einen Endpunkt mit mehreren Modellen [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), und zwar [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs genau so [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), als würden Sie einen Endpunkt mit einem einzigen Modell erstellen, jedoch mit zwei Änderungen. Wenn Sie den Container für das Modell definieren, müssen Sie einen neuen `Mode`-Parameterwert übergeben, `MultiModel`. Sie müssen auch das Feld `ModelDataUrl` übergeben, das das Präfix in Amazon S3 angibt, in dem sich die Modellartefakte befinden, anstatt den Pfad zu einem Artefakt mit nur einem Modell, wie beim Bereitstellen eines einzelnen Modells.
Ein Beispiel-Notizbuch, das SageMaker KI verwendet, um mehrere XGBoost Modelle auf einem Endpunkt bereitzustellen, finden Sie unter [ XGBoost Beispielnotizbuch für Endgeräte mit mehreren Modellen](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html).
Im folgenden Verfahren werden die wichtigsten Schritte beschrieben, die in diesem Beispiel zum Erstellen eines Multimodell-Endpunkts mit CPU-Unterstützung verwendet werden.
**Um das Modell bereitzustellen (AWS SDK für Python (Boto 3))**
1. Besorgen Sie sich einen Container mit einem Image, das die Bereitstellung von Multimodell-Endpunkten unterstützt. Eine Liste der integrierten Algorithmen und Framework-Container, die Multimodell-Endpunkte unterstützen, finden Sie unter [Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte](multi-model-support.md). In diesem Beispiel verwenden wir den integrierten Algorithmus [K-nearest neighbors (k-NN)-Algorithmus](k-nearest-neighbors.md). Wir rufen die [SageMaker Python-SDK-Utility-Funktion](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` auf, um die Adresse für das integrierte K-Nearest Neighbors-Algorithmus-Image abzurufen.
```
import sagemaker
region = sagemaker_session.boto_region_name
image = sagemaker.image_uris.retrieve("knn",region=region)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
```
1. Holen Sie sich einen AWS SDK für Python (Boto3) SageMaker AI-Client und erstellen Sie das Modell, das diesen Container verwendet.
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (Optional) Wenn Sie eine serielle Inferenz-Pipeline verwenden, rufen Sie die zusätzlichen Container ab, die in der Pipeline enthalten sein sollen, und fügen sie in das Argument `Containers` von `CreateModel` ein:
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**Anmerkung**
Sie können nur einen multi-model-enabled Endpunkt in einer seriellen Inferenzpipeline verwenden.
1. (Optional) Wenn Ihr Anwendungsfall vom Modell-Caching nicht profitiert, setzen Sie den Wert des Feldes `ModelCacheSetting` des Parameters `MultiModelConfig` auf `Disabled` und nehmen Sie ihn in das Argument `Container` des Aufrufs von `create_model` auf. Der Wert für das Feld `ModelCacheSetting` ist standardmäßig `Enabled`.
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. Konfigurieren Sie den Multimodell-Endpunkt für das Modell. Wir empfehlen, Ihre Endpunkte mit mindestens zwei Instances zu konfigurieren. Auf diese Weise kann SageMaker KI für die Modelle einen hochverfügbaren Satz von Vorhersagen über mehrere Availability Zones hinweg bereitstellen.
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.m4.xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
**Anmerkung**
Sie können nur einen multi-model-enabled Endpunkt in einer seriellen Inferenzpipeline verwenden.
1. Erstellen Sie den Multimodell-Endpunkt mit den Parametern `EndpointName` und `EndpointConfigName`.
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
## Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von GPUs AWS SDK für Python (Boto3)
Erstellen Sie mit Hilfe des folgenden Abschnitts einen durch GPU unterstützten Multimodell-Endpunkt. Sie erstellen einen Endpunkt mit mehreren Modellen mithilfe der Amazon SageMaker AI [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)und [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs ähnlich wie bei der Erstellung von Einzelmodell-Endpunkten, es gibt jedoch mehrere Änderungen. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) Wenn Sie den Container für das Modell definieren, müssen Sie einen neuen `Mode`-Parameterwert übergeben, `MultiModel`. Sie müssen auch das Feld `ModelDataUrl` übergeben, das das Präfix in Amazon S3 angibt, in dem sich die Modellartefakte befinden, anstatt den Pfad zu einem Artefakt mit nur einem Modell, wie beim Bereitstellen eines einzelnen Modells. Für GPU-gestützte Multimodell-Endpunkte müssen Sie außerdem einen Container mit dem NVIDIA Triton Inference Server verwenden, der für die Ausführung auf GPU-Instances optimiert ist. Eine Liste der Container-Images, die mit GPU-gestützten Endpunkten funktionieren, finden Sie in den [NVIDIA Triton Inference Containers (nur SM-Unterstützung)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only).
Ein Beispiel-Notizbuch, das zeigt, wie Sie einen Multi-Modell-Endpoint erstellen, der von unterstützt wird GPUs, finden Sie unter [Ausführen mehrerer Deep-Learning-Modelle auf GPUs Amazon SageMaker AI Multi-Model Endpoints](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) (MME).
Das folgende Verfahren beschreibt die wichtigsten Schritte zur Erstellung eines GPU-gestützten Multimodell-Endpunkts.
**Um das Modell bereitzustellen (AWS SDK für Python (Boto 3))**
1. Definieren Sie das Container-Image. Um einen Endpunkt mit mehreren Modellen mit GPU-Unterstützung für ResNet Modelle zu erstellen, definieren Sie den Container so, dass er das [NVIDIA Triton Server-Image](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) verwendet. Dieser Container unterstützt Multimodell-Endpunkte und ist für die Ausführung auf GPU-Instances optimiert. Wir rufen die [SageMaker AI Python SDK-Utility-Funktion](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` auf, um die Adresse für das Bild abzurufen. Beispiel:
```
import sagemaker
region = sagemaker_session.boto_region_name
// Find the sagemaker-tritonserver image at
// https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb
// Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only
image = ".dkr.ecr..amazonaws.com/sagemaker-tritonserver:".format(
account_id=account_id_map[region], region=region
)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel',
"Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"},
}
```
1. Holen Sie sich einen AWS SDK für Python (Boto3) SageMaker AI-Client und erstellen Sie das Modell, das diesen Container verwendet.
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (Optional) Wenn Sie eine serielle Inferenz-Pipeline verwenden, rufen Sie die zusätzlichen Container ab, die in der Pipeline enthalten sein sollen, und fügen sie in das Argument `Containers` von `CreateModel` ein:
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**Anmerkung**
Sie können nur einen multi-model-enabled Endpunkt in einer seriellen Inferenzpipeline verwenden.
1. (Optional) Wenn Ihr Anwendungsfall vom Modell-Caching nicht profitiert, setzen Sie den Wert des Feldes `ModelCacheSetting` des Parameters `MultiModelConfig` auf `Disabled` und nehmen Sie ihn in das Argument `Container` des Aufrufs von `create_model` auf. Der Wert für das Feld `ModelCacheSetting` ist standardmäßig `Enabled`.
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. Konfigurieren Sie den Multimodell-Endpunkt mit GPU-gestützten Instances für das Modell. Wir empfehlen, Ihre Endpunkte mit mehr als einer Instance zu konfigurieren, um eine hohe Verfügbarkeit und höhere Cache-Zugriffe zu gewährleisten.
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.g4dn.4xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
1. Erstellen Sie den Multimodell-Endpunkt mit den Parametern `EndpointName` und `EndpointConfigName`.
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
# Aufrufen eines Multimodell-Endpunkts
Um einen Endpunkt mit mehreren Modellen aufzurufen, verwenden Sie den [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint)aus der SageMaker AI Runtime heraus so, als würden Sie einen einzelnen Modellendpunkt aufrufen, mit einer Änderung. Übergeben Sie einen neuen `TargetModel`-Parameter, der angibt, welches der Modelle am Endpunkt Ziel ist. Die SageMaker AI `InvokeEndpoint` Runtime-Anfrage wird `X-Amzn-SageMaker-Target-Model` als neuer Header unterstützt, der den relativen Pfad des für den Aufruf angegebenen Modells verwendet. Das SageMaker KI-System erstellt den absoluten Pfad des Modells, indem es das Präfix, das als Teil des `CreateModel` API-Aufrufs bereitgestellt wird, mit dem relativen Pfad des Modells kombiniert.
Die folgenden Verfahren sind für CPU- und GPU-gestützte Multimodell-Endpunkte identisch.
------
#### [ AWS SDK for Python (Boto 3) ]
In der folgenden Beispiel-Vorhersageanforderung wird das [AWS SDK für Python (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html) im Beispiel-Notebook verwendet.
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName = "",
ContentType = "text/csv",
TargetModel = ".tar.gz",
Body = body)
```
------
#### [ AWS CLI ]
Das folgende Beispiel zeigt, wie Sie mit Hilfe der AWS Command Line Interface (AWS CLI) eine CSV-Anfrage mit zwei Zeilen erstellen:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name "" \
--body "1.0,2.0,5.0"$'\n'"2.0,3.0,4.0" \
--content-type "text/csv" \
--target-model ".tar.gz"
output_file.txt
```
Eine `output_file.txt` mit Angaben zu Ihren Inference-Anfragen wird erstellt, wenn die Inference erfolgreich war. Weitere Beispiele dafür, wie Sie mit dem Vorhersagen treffen können AWS CLI, finden Sie unter [Vorhersagen mit dem](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#making-predictions-with-the-aws-cli) erstellen AWS CLI in der SageMaker Python SDK-Dokumentation.
------
Der Multimodell-Endpunkt lädt Zielmodelle nach Bedarf dynamisch. Dies ist zu beobachten, wenn Sie das [MME-Beispiel-Notebook](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) ausführen, da es zufällige Aufrufe für mehrere Zielmodelle durchläuft, die hinter einem einzelnen Endpunkt gehostet werden. Die erste Anfrage für ein bestimmtes Modell dauert länger, da das Modell von Amazon Simple Storage Service (Amazon S3) heruntergeladen und in den Speicher geladen werden muss. Dies wird als *Kaltstart* bezeichnet und ist bei Multimodell-Endpunkten zu erwarten. Damit soll die Handhabung im Hinblick auf ein besseres Preis-/Leistungsverhältnis für den Kunden optimiert werden. Nachfolgende Aufrufe werden schneller beendet, da nach dem Laden des Modells kein zusätzlicher Overhead vorhanden ist.
**Anmerkung**
Bei GPU-gestützten Instances weist der HTTP-Antwortcode mit 507 aus dem GPU-Container darauf hin, dass zu wenig Arbeitsspeicher oder einer sonstigen Ressource zur Verfügung steht. Dies führt dazu, dass nicht genutzte Modelle aus dem Container entladen werden, um häufiger verwendete Modelle zu laden.
## Anfragen bei Fehlern erneut versuchen ModelNotReadyException
Wenn Sie `invoke_endpoint` zum ersten Mal aufrufen, um ein Modell zu erhalten, wird dieses von Amazon Simple Storage Service heruntergeladen und in den Inference-Container geladen. Daher dauert es länger, bis der erste Anruf abgearbeitet wird. Nachfolgende Aufrufe desselben Modells werden schneller abgearbeitet, da das Modell bereits geladen ist.
SageMaker KI gibt `invoke_endpoint` innerhalb von 60 Sekunden eine Antwort auf einen Anruf zurück. Manche Modelle sind zu groß, um sie innerhalb von 60 Sekunden herunterzuladen. Wenn das Modell nicht vor Ablauf der Zeitüberschreitung nach 60 Sekunden geladen wird, wird die Anfrage nach `invoke_endpoint` mit dem Fehlercode `ModelNotReadyException` zurückgegeben, und das Modell wird bis zu 360 Sekunden lang weiter heruntergeladen und in den Inference-Container geladen. Wenn Sie einen `ModelNotReadyException` Fehlercode auf eine `invoke_endpoint` Anfrage erhalten, versuchen Sie es erneut. Standardmäßig werden die `invoke_endpoint` Wiederholungsanforderungen AWS SDKs für Python (Boto 3) (mit [Legacy-Wiederholungsmodus](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#legacy-retry-mode)) und Java wiederholt, die zu Fehlern führen. `ModelNotReadyException` Sie können die Wiederholungsstrategie so konfigurieren, dass die Anfrage bis zu 360 Sekunden lang wiederholt wird. Wenn Sie davon ausgehen, dass das Herunterladen und Laden Ihres Modells in den Container länger als 60 Sekunden dauert, legen Sie das SDK-Socket-Timeout auf 70 Sekunden fest. Weitere Informationen zur Konfiguration der Wiederholungsstrategie für AWS SDK für Python (Boto3) finden Sie unter [Konfigurieren eines Wiederholungsmodus](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#configuring-a-retry-mode). Der folgende Code zeigt ein Beispiel, bei dem die Wiederholungsstrategie so konfiguriert wird, dass Aufrufe für `invoke_endpoint` bis zu 180 Sekunden lang wiederholt werden.
```
import boto3
from botocore.config import Config
# This example retry strategy sets the retry attempts to 2.
# With this setting, the request can attempt to download and/or load the model
# for upto 180 seconds: 1 orginal request (60 seconds) + 2 retries (120 seconds)
config = Config(
read_timeout=70,
retries={
'max_attempts': 2 # This value can be adjusted to 5 to go up to the 360s max timeout
}
)
runtime_sagemaker_client = boto3.client('sagemaker-runtime', config=config)
```
# Hinzufügen oder Entfernen von Modellen
Sie können zusätzliche Modelle auf einem Multimodell-Endpunkt bereitstellen und diese sofort über diesen Endpunkt aufrufen. Wenn Sie ein neues Modell hinzufügen, müssen Sie den Endpunkt nicht aktualisieren oder herunterfahren, sodass Sie die Kosten für das Erstellen und Ausführen eines separaten Endpunkts für jedes neue Modell vermeiden. Das Verfahren zum Hinzufügen und Entfernen von Modellen ist für CPU- und GPU-gestützte Multimodell-Endpunkte dasselbe.
SageMaker KI entlädt ungenutzte Modelle aus dem Container, wenn die Instance die Speicherkapazität erreicht hat und weitere Modelle in den Container heruntergeladen werden müssen. SageMaker KI löscht auch ungenutzte Modellartefakte aus dem Instance-Speichervolumen, wenn das Volume seine Kapazität erreicht und neue Modelle heruntergeladen werden müssen. Der erste Aufruf eines neu hinzugefügten Modells dauert länger, da der Endpunkt Zeit benötigt, um das Modell aus S3 in den Container-Speicher der Instance herunterzuladen, die den Endpunkt hostet
Wenn der Endpunkt bereits ausgeführt wird, kopieren Sie einen neuen Satz Modellartefakte an den Amazon S3-Speicherort, an dem Sie Ihre Modelle speichern.
```
# Add an AdditionalModel to the endpoint and exercise it
aws s3 cp AdditionalModel.tar.gz s3://amzn-s3-demo-bucket/path/to/artifacts/
```
**Wichtig**
Um ein Modell zu aktualisieren, gehen Sie wie beim Hinzufügen eines neuen Modells vor. Verwenden Sie einen neuen und eindeutigen Namen. Überschreiben Sie keine Modellartefakte in Amazon S3, da die alte Version des Modells ggf. noch in die Container oder in den Speicher der Instances auf dem Endpunkt geladen ist. Aufrufe des neuen Modells könnten dann die alte Version des Modells aufrufen.
Client-Anwendungen können Vorhersagen aus dem zusätzlichen Zielmodell anfordern, sobald es in S3 gespeichert ist.
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName='',
ContentType='text/csv',
TargetModel='AdditionalModel.tar.gz',
Body=body)
```
Um ein Modell von einem Multimodell-Endpunkt zu löschen, beenden Sie den Aufruf des Modells von den Clients und entfernen es aus dem S3-Verzeichnis, in dem Modellartefakte gespeichert werden.
# Erstellen Sie Ihren eigenen Container für SageMaker KI-Endpunkte mit mehreren Modellen
In den folgenden Abschnitten erfahren Sie, wie Sie Ihren eigenen Container und Ihre eigenen Abhängigkeiten in Multimodell-Endpunkte einbringen können.
**Topics**
+ [Bringen Sie Ihre eigenen Abhängigkeiten für Multimodell-Endpunkte auf CPU-gestützten Instances ein](#build-multi-model-container-cpu)
+ [Bringen Sie Ihre eigenen Abhängigkeiten für Multimodell-Endpunkte auf GPU-gestützten Instances mit](#build-multi-model-container-gpu)
+ [Verwenden Sie das AI Inference Toolkit SageMaker](#multi-model-inference-toolkit)
+ [Vertrag für individuelle Container für Multimodell-Endpunkte](mms-container-apis.md)
## Bringen Sie Ihre eigenen Abhängigkeiten für Multimodell-Endpunkte auf CPU-gestützten Instances ein
Wenn keines der vorgefertigten Container-Images Ihren Anforderungen entspricht, können Sie Ihren eigenen Container erstellen und ihn mit CPU-gestützten Multimodell-Endpunkten nutzen.
Von benutzerdefinierten Amazon Elastic Container Registry (Amazon ECR) -Images, die in Amazon SageMaker AI bereitgestellt werden, wird erwartet, [Benutzerdefinierter Inferenzcode mit Hosting-Services](your-algorithms-inference-code.md) dass sie den unter beschriebenen Basisvertrag einhalten, der regelt, wie SageMaker KI mit einem Docker-Container interagiert, der Ihren eigenen Inferenzcode ausführt. Damit ein Container mehrere Modelle gleichzeitig laden und bedienen kann, müssen zusätzliche Verhaltensmuster beachtet APIs werden. Dieser zusätzliche Vertrag beinhaltet neue Modelle APIs zum Laden, Auflisten, Abrufen und Entladen sowie eine andere API zum Aufrufen von Modellen. Es gibt auch unterschiedliche Verhaltensweisen für Fehlerszenarien, die eingehalten werden APIs müssen. Um anzugeben, dass der Container die zusätzlichen Anforderungen erfüllt, können Sie der Dockerfile-Datei den folgenden Befehl hinzufügen:
```
LABEL com.amazonaws.sagemaker.capabilities.multi-models=true
```
SageMaker KI injiziert auch eine Umgebungsvariable in den Container
```
SAGEMAKER_MULTI_MODEL=true
```
Wenn Sie einen Multimodell-Endpunkt für eine serielle Inferenz-Pipline erstellen, muss Ihre Docker-Datei über die erforderlichen Kennzeichnungen für Multimodell- und serielle Inferenz-Pipelines verfügen. Weitere Informationen zu seriellen Informations-Pipelines finden Sie unter [Echtzeit-Prognosen mit einer Inferenz-Pipeline](inference-pipeline-real-time.md).
Damit Sie diese Anforderungen für einen benutzerdefinierten Container implementieren können, stehen zwei Bibliotheken zur Verfügung:
+ [Multi Model Server](https://github.com/awslabs/multi-model-server) ist ein Open-Source-Framework für die Bereitstellung von Modellen für maschinelles Lernen, die in Containern installiert werden können, um das Frontend bereitzustellen, das die Anforderungen für den neuen Endpoint-Container mit mehreren Modellen erfüllt. APIs Es stellt die HTTP-Frontend- und Modellverwaltungsfunktionen bereit, die von Multimodell-Endpunkten benötigt werden, um mehrere Modelle in einem einzigen Container zu hosten, Modelle dynamisch in den Container zu laden und Modelle daraus zu entladen und Inferenzen auf ein spezifiziertes geladenes Modell auszuführen. Es bietet auch ein steckbares Backend, das einen steckbaren benutzerdefinierten Backend-Handler unterstützt, in dem Sie Ihren eigenen Algorithmus implementieren können.
+ [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) ist eine Bibliothek, die Multi Model Server mit einer Konfiguration und Einstellungen bootet, die ihn mit KI-Endpunkten mit mehreren Modellen kompatibel machen. SageMaker Darüber hinaus können Sie wichtige Leistungsparameter, z. B. die Anzahl der Arbeitskräfte pro Modell, je nach den Anforderungen Ihres Szenarios optimieren.
## Bringen Sie Ihre eigenen Abhängigkeiten für Multimodell-Endpunkte auf GPU-gestützten Instances mit
Die BYOC-Funktion (Bring Your Own Container) auf Endpunkten mit mehreren Modellen und GPU-gestützten Instanzen wird derzeit von den Bibliotheken Multi Model Server und AI Inference Toolkit nicht unterstützt. SageMaker
[Für die Erstellung von Endpunkten mit mehreren Modellen mit GPU-gestützten Instanzen können Sie den SageMaker KI-unterstützten [NVIDIA Triton Inference Server mit den NVIDIA Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Containern verwenden.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only) Um Ihre eigenen Abhängigkeiten mitzubringen, können Sie Ihren eigenen Container mit dem SageMaker KI-unterstützten [NVIDIA Triton Inference Server](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) als Basis-Image für Ihre Docker-Datei erstellen:
```
FROM 301217895009.dkr.ecr.us-west-2.amazonaws.com/sagemaker-tritonserver:22.07-py3
```
**Wichtig**
Container mit dem Triton Inference Server sind die einzigen unterstützten Container, die Sie für GPU-gestützte Multimodell-Endpunkte verwenden können.
## Verwenden Sie das AI Inference Toolkit SageMaker
**Anmerkung**
Das SageMaker AI Inference Toolkit wird nur für CPU-gestützte Endpunkte mit mehreren Modellen unterstützt. Das SageMaker AI Inference Toolkit wird derzeit nicht für GPU-gestützte Endpunkte mit mehreren Modellen unterstützt.
Vorgefertigte Container, die Multimodell-Endpunkte unterstützen, sind unter aufgeführt [Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte](multi-model-support.md). Wenn Sie ein anderes Framework oder einen anderen Algorithmus verwenden möchten, müssen Sie einen Container erstellen. Der einfachste Weg, dies zu tun, besteht darin, das [SageMaker AI Inference Toolkit zu verwenden, um einen vorhandenen vorgefertigten Container zu erweitern](https://github.com/aws/sagemaker-inference-toolkit). Das SageMaker KI-Inferenz-Toolkit ist eine Implementierung für den Multi-Model-Server (MMS), der Endpunkte erstellt, die in KI eingesetzt werden können. SageMaker [Ein Beispielnotizbuch, das zeigt, wie ein benutzerdefinierter Container eingerichtet und bereitgestellt wird, der Endpunkte mit mehreren Modellen in SageMaker KI unterstützt, finden Sie im BYOC-Beispielnotizbuch für Multi-Model Endpoint.](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_bring_your_own)
**Anmerkung**
Das SageMaker KI-Inferenz-Toolkit unterstützt nur Python-Modellhandler. Wenn Sie Ihren Handler in einer anderen Sprache implementieren möchten, müssen Sie Ihren eigenen Container erstellen, der den zusätzlichen Multimodell-Endpunkt implementiert. APIs Weitere Informationen finden Sie unter [Vertrag für individuelle Container für Multimodell-Endpunkte](mms-container-apis.md).
**Um einen Container mithilfe des SageMaker AI-Inferenz-Toolkits zu erweitern**
1. Erstellen Sie einen Modell-Handler. MMS erwartet einen Modell-Handler, bei dem es sich um eine Python-Datei handelt, die Funktionen zum Vorverarbeiten, Abrufen von Voraussagen aus dem Modell und Verarbeiten der Ausgabe in einem Modell-Handler implementiert. Ein Beispiel für einen Modell-Handler finden Sie unter [model\$1handler.py](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/model_handler.py) aus dem Beispiel-Notebook.
1. Importieren Sie das Inferenz-Toolkit und verwenden Sie dessen `model_server.start_model_server`-Funktion, um MMS zu starten. Das folgende Beispiel stammt aus der `dockerd-entrypoint.py`-Datei aus dem Beispiel-Notebook. Beachten Sie, dass der Aufruf an `model_server.start_model_server` den im vorherigen Schritt beschriebenen Modell-Handler übergibt:
```
import subprocess
import sys
import shlex
import os
from retrying import retry
from subprocess import CalledProcessError
from sagemaker_inference import model_server
def _retry_if_error(exception):
return isinstance(exception, CalledProcessError or OSError)
@retry(stop_max_delay=1000 * 50,
retry_on_exception=_retry_if_error)
def _start_mms():
# by default the number of workers per model is 1, but we can configure it through the
# environment variable below if desired.
# os.environ['SAGEMAKER_MODEL_SERVER_WORKERS'] = '2'
model_server.start_model_server(handler_service='/home/model-server/model_handler.py:handle')
def main():
if sys.argv[1] == 'serve':
_start_mms()
else:
subprocess.check_call(shlex.split(' '.join(sys.argv[1:])))
# prevent docker exit
subprocess.call(['tail', '-f', '/dev/null'])
main()
```
1. Kopieren Sie in Ihrer `Dockerfile` den Modell-Handler aus dem ersten Schritt und geben Sie die Python-Datei aus dem vorherigen Schritt als Eintrittspunkt in Ihrer `Dockerfile` an. Die folgenden Zeilen stammen aus der [Dockerfile](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/Dockerfile), die im Beispiel-Notebook verwendet wird:
```
# Copy the default custom service file to handle incoming data and inference requests
COPY model_handler.py /home/model-server/model_handler.py
# Define an entrypoint script for the docker image
ENTRYPOINT ["python", "/usr/local/bin/dockerd-entrypoint.py"]
```
1. Erstellen und registrieren Sie Ihren Container. Das folgende Shell-Skript aus dem Beispiel-Notebook erstellt den Container und lädt ihn in ein Amazon-Elastic-Container-Registry-Repository in Ihrem AWS -Konto hoch:
```
%%sh
# The name of our algorithm
algorithm_name=demo-sagemaker-multimodel
cd container
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 --region ${region} --no-include-email)
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -q -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
Sie können diesen Container jetzt verwenden, um Endpunkte mit mehreren Modellen in KI bereitzustellen. SageMaker
**Topics**
+ [Bringen Sie Ihre eigenen Abhängigkeiten für Multimodell-Endpunkte auf CPU-gestützten Instances ein](#build-multi-model-container-cpu)
+ [Bringen Sie Ihre eigenen Abhängigkeiten für Multimodell-Endpunkte auf GPU-gestützten Instances mit](#build-multi-model-container-gpu)
+ [Verwenden Sie das AI Inference Toolkit SageMaker](#multi-model-inference-toolkit)
+ [Vertrag für individuelle Container für Multimodell-Endpunkte](mms-container-apis.md)
# Vertrag für individuelle Container für Multimodell-Endpunkte
Um mehrere Modelle verarbeiten zu können, muss Ihr Container eine Reihe von Modellen unterstützen APIs , die es Amazon SageMaker AI ermöglichen, mit dem Container zu kommunizieren, um Modelle nach Bedarf zu laden, aufzulisten, abzurufen und zu entladen. Der `model_name` wird im neuen Satz von APIs als der wichtigste Eingabeparameter verwendet. Es wird erwartet, dass der Kundencontainer die geladenen Modelle unter Verwendung von `model_name` als Zuordnungsschlüssel verfolgt. Außerdem ist `model_name` ein undurchsichtiger Bezeichner und ist nicht unbedingt der Wert des `TargetModel`-Parameters, der an die `InvokeEndpoint`-API übergeben wird. Der ursprüngliche `TargetModel` Wert in der `InvokeEndpoint` Anfrage wird APIs als `X-Amzn-SageMaker-Target-Model` Header, der für Protokollierungszwecke verwendet werden kann, an den Container im Container übergeben.
**Anmerkung**
Endpunkte mit mehreren Modellen für GPU-gestützte Instances werden derzeit nur mit dem [NVIDIA Triton Inference Server-Container](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) von SageMaker AI unterstützt. Dieser Container implementiert bereits den unten definierten Vertrag. Der Kunde kann diesen Container ohne zusätzlichen Aufwand direkt mit seinen MultimodellGPU-Endpunkten verwenden.
Sie können in Ihren Containern für CPU-gestützte APIs Endpunkte mit mehreren Modellen Folgendes konfigurieren.
**Topics**
+ [Modell API laden](#multi-model-api-load-model)
+ [Modell API auflisten](#multi-model-api-list-model)
+ [Modell API aufrufen](#multi-model-api-get-model)
+ [Modell API entladen](#multi-model-api-unload-model)
+ [Modell API aufrufen](#multi-model-api-invoke-model)
## Modell API laden
Weist den Container an, ein bestimmtes Modell im Feld `url` des Fließtexts in den Speicher des Kundencontainers zu laden und es mit dem zugewiesenen `model_name` zu verfolgen. Nachdem ein Modell geladen wurde, sollte der Container bereit sein, Inferenzanforderungen unter Verwendung dieses `model_name` zu bedienen.
```
POST /models HTTP/1.1
Content-Type: application/json
Accept: application/json
{
"model_name" : "{model_name}",
"url" : "/opt/ml/models/{model_name}/model",
}
```
**Anmerkung**
Wenn `model_name` bereits geladen ist, sollte diese API 409 zurückgeben. Jedes Mal, wenn ein Modell aufgrund von Speichermangel oder einer anderen Ressource nicht geladen werden kann, sollte diese API einen 507-HTTP-Statuscode an SageMaker AI zurückgeben, die dann das Entladen ungenutzter Modelle zur Rückgewinnung initiiert.
## Modell API auflisten
Gibt die Liste der Modelle zurück, die in den Speicher des Kundencontainers geladen werden.
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
Diese API unterstützt auch die Paginierung.
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
SageMaker KI kann die List Models API zunächst aufrufen, ohne einen Wert für anzugeben. `next_page_token` Wenn ein `nextPageToken`-Feld als Teil der Antwort zurückgegeben wird, wird es als Wert für `next_page_token` in einem nachfolgenden Aufruf zum Auflisten der Modelle angegeben. Wenn kein `nextPageToken` zurückgegeben wird, bedeutet dies, dass keine weiteren Modelle zurückgegeben werden müssen.
## Modell API aufrufen
Dies ist eine einfache Lese-API für die Entität `model_name`.
```
GET /models/{model_name} HTTP/1.1
Accept: application/json
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
}
```
**Anmerkung**
Wenn `model_name` nicht geladen ist, sollte diese API 404 zurückgeben.
## Modell API entladen
Weist die SageMaker KI-Plattform an, den Kundencontainer anzuweisen, ein Modell aus dem Speicher zu entladen. Dies löst die Bereinigung eines Kandidatenmodells aus, wie von der Plattform festgelegt, wenn der Prozess des Ladens eines neuen Modells gestartet wird. Die `model_name` bereitgestellten Ressourcen sollten vom Container zurückgerufen werden, wenn diese API eine Antwort zurückgibt.
```
DELETE /models/{model_name}
```
**Anmerkung**
Wenn `model_name` nicht geladen ist, sollte diese API 404 zurückgeben.
## Modell API aufrufen
Stellt eine Vorhersageanforderung von einem bestimmten bereitgestellten `model_name`. Die SageMaker AI `InvokeEndpoint` Runtime-Anfrage wird `X-Amzn-SageMaker-Target-Model` als neuer Header unterstützt, der den relativen Pfad des für den Aufruf angegebenen Modells verwendet. Das SageMaker KI-System erstellt den absoluten Pfad des Modells, indem es das Präfix, das als Teil des `CreateModel` API-Aufrufs bereitgestellt wird, mit dem relativen Pfad des Modells kombiniert.
```
POST /models/{model_name}/invoke HTTP/1.1
Content-Type: ContentType
Accept: Accept
X-Amzn-SageMaker-Custom-Attributes: CustomAttributes
X-Amzn-SageMaker-Target-Model: [relativePath]/{artifactName}.tar.gz
```
**Anmerkung**
Wenn `model_name` nicht geladen ist, sollte diese API 404 zurückgeben.
Darüber hinaus sollte diese API bei GPU-Instanzen, wenn sie aufgrund eines Mangels an Arbeitsspeicher oder anderen Ressourcen `InvokeEndpoint` fehlschlagen, einen 507-HTTP-Statuscode an SageMaker AI zurückgeben, der dann das Entladen ungenutzter Modelle zur Rückgewinnung initiiert.
# Sicherheit eines Multimodell-Endpunkts
Modelle und Daten in einem Multimodell-Endpunkt befinden sich auf einem Instance-Speichervolume und im Containerspeicher. Alle Instances für Amazon SageMaker AI-Endpunkte werden auf einem Einzelmandantencontainer ausgeführt, den Sie besitzen. Nur Ihre Modelle können auf Ihrem Multimodell-Endpunkt ausgeführt werden. Es liegt in Ihrer Verantwortung, die Zuordnung von Anfragen zu Modellen zu verwalten und Benutzern Zugriff auf die richtigen Zielmodelle zu gewähren. SageMaker KI verwendet [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html), um identitätsbasierte IAM-Richtlinien bereitzustellen, mit denen Sie zulässige oder verweigerte Aktionen und Ressourcen sowie die Bedingungen angeben, unter denen Aktionen zulässig oder verweigert werden.
Ein IAM-Principal kann standardmäßig mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)-Berechtigungen für einen Multimodell-Endpunkt jedes beliebige Modell unter der Adresse des in der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)-Operation definierten S3-Präfixes aufrufen, vorausgesetzt, die in der Operation definierte IAM-Ausführungsrolle hat die Berechtigung zum Herunterladen des Modells. Wenn Sie den [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)-Zugriff auf eine begrenzte Anzahl Modelle in S3 beschränken müssen, können Sie einen der folgenden Schritte ausführen:
+ Beschränken Sie `InvokeEndpont`-Aufrufe auf bestimmte Modelle, die auf dem Endpunkt gehostet werden, mithilfe des `sagemaker:TargetModel`-IAM-Bedingungsschlüssels . Beispielsweise lässt die folgende Richtlinie `InvokeEndpont`-Anforderungen nur zu, wenn der Wert des Feldes `TargetModel` mit einem der angegebenen regulären Ausdrücke übereinstimmt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource":
"arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": ["company_a/*", "common/*"]
}
}
}
]
}
```
------
Informationen zu SageMaker AI-Bedingungsschlüsseln finden Sie unter [Bedingungsschlüssel für Amazon SageMaker AI](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) im *AWS Identity and Access Management Benutzerhandbuch*.
+ Erstellen Sie Multimodell-Endpunkte mit restriktiveren S3-Präfixen.
Weitere Informationen darüber, wie SageMaker KI Rollen verwendet, um den Zugriff auf Endgeräte zu verwalten und Operationen in Ihrem Namen durchzuführen, finden Sie unter[Wie verwendet man SageMaker AI-Ausführungsrollen](sagemaker-roles.md). Ihre Kunden haben ggf. auch bestimmte Anforderungen an die Datenisolierung, die durch ihre eigenen Compliance-Anforderungen bestimmt werden, denen mit Hilfe IAM-Identitäten entsprochen werden kann.
# CloudWatch Metriken für Endpunktbereitstellungen mit mehreren Modellen
Amazon SageMaker AI stellt Metriken für Endgeräte bereit, sodass Sie die Cache-Trefferrate, die Anzahl der geladenen Modelle und die Wartezeiten der Modelle beim Laden, Herunterladen und Hochladen an einem Endpunkt mit mehreren Modellen überwachen können. Einige der Metriken unterscheiden sich für CPU- und GPU-gestützte Multimodell-Endpoints. Daher werden in den folgenden Abschnitten die CloudWatch Amazon-Metriken beschrieben, die Sie für jeden Typ von Multimodell-Endpoint verwenden können.
Weitere Informationen zu den Kennzahlen finden Sie unter **Kennzahlen zum Laden von Multimodell-Endpunktmodellen** und **Kennzahlen für Multimodell-Endpunktmodell-Instances** in [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md). Metriken pro Modell werden nicht unterstützt.
## CloudWatch Metriken für CPU-gestützte Endgeräte mit mehreren Modellen
Auf CPU-gestützten Multimodell-Endpunkten können Sie die folgenden Kennzahlen überwachen.
Der `AWS/SageMaker` Namespace umfasst das folgende Modell zum Laden von Metriken aus Aufrufen an. [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)
Die Kennzahlen sind mit einminütiger Frequenz verfügbar.
Informationen darüber, wie lange CloudWatch Metriken aufbewahrt werden, finden Sie [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)in der *Amazon CloudWatch API-Referenz*.
**Kennzahlen zum Laden von Multimodell-Endpunktmodellen**
| Metrik | Description |
| --- | --- |
| ModelLoadingWaitTime | Der Zeitraum , über das hinweg eine Aufrufanforderung darauf gewartet hat, dass das Zielmodell heruntergeladen oder geladen wird, oder beides, um Interferenzen vorzunehmen. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelUnloadingTime | Der Zeitraum , das zum Entladen des Modells über den `UnloadModel`-API-Aufruf des Containers erforderlich war. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelDownloadingTime | Die Dauer, die es brauchte, das Modell von Amazon Simple Storage Service (Amazon S3) herunterzuladen. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelLoadingTime | Der Zeitraum , das zum Laden des Modells über den `LoadModel`-API-Aufruf des Containers erforderlich war. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelCacheHit | Die Anzahl der `InvokeEndpoint`-Anforderungen, die an den Multimodell-Endpunkt gesendet werden, für die das Modell bereits geladen wurde. Die Durchschnittsstatistik zeigt das Verhältnis der Anforderungen an, für die das Modell bereits geladen wurde. Einheiten: keine Gültige Statistiken: Durchschnitt, Datenstichprobe |
**Dimensionen für Kennzahlen zum Laden von Multimodell-Endpunktmodellen**
| Dimension | Description |
| --- | --- |
| EndpointName, VariantName | Filtert die Kennzahlen für den Endpunktaufruf einer `ProductionVariant` für den angegebenen Endpunkt und die Variante. |
Die `/aws/sagemaker/Endpoints`-Namespaces enthalten die folgenden Instance-Metriken aus Aufrufen an [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
Die Kennzahlen sind mit einminütiger Frequenz verfügbar.
Informationen darüber, wie lange CloudWatch Metriken aufbewahrt werden, finden Sie [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)in der *Amazon CloudWatch API-Referenz*.
**Kennzahlen für Modell-Instances von Multimodell-Endpunkten**
| Metrik | Description |
| --- | --- |
| LoadedModelCount | Die Anzahl der Modelle, die in die Container des Multimodell-Endpunkts geladen werden. Diese Metrik wird pro Instance ausgegeben. Die Durchschnittsstatistik mit einem Zeitraum von 1 Minute gibt Ihnen die durchschnittliche Anzahl der pro Instance geladenen Modelle an. Die Summenstatistik gibt Ihnen die Gesamtzahl der Modelle an, die über alle Instances im Endpunkt geladen wurden. Die Modelle, die von dieser Metrik verfolgt werden, sind nicht unbedingt eindeutig, da ein Modell möglicherweise in mehrere Container am Endpunkt geladen wird. Einheiten: keine Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| CPUUtilization | Die Summe der Auslastung jedes einzelnen CPU-Kerns. Die CPU-Auslastung jedes Kernbereichs liegt zwischen 0 und 100. Wenn es beispielsweise vier gibt CPUs, liegt der `CPUUtilization` Bereich zwischen 0% und 400%. Bei Endpunktvarianten ist dieser Wert die Summe der CPU-Auslastung von primären und ergänzenden Containern auf der Instance. Einheiten: Prozent |
| MemoryUtilization | Der Prozentsatz des Speichers, der von den Containern auf einer Instance belegt wird. Dieser Wertebereich liegt zwischen 0 und 100%. Bei Endpunktvarianten ist dieser Wert die Summe der Speichernutzung der primären und ergänzenden Container auf der Instance. Einheiten: Prozent |
| DiskUtilization | Der Prozentsatz des Speicherplatzes, der von den Containern auf einer Instance verwendet wird. Dieser Wertebereich liegt zwischen 0 und 100%. Bei Endpunktvarianten ist dieser Wert die Summe der Speicherplatzauslastung der primären und ergänzenden Container auf der Instance. Einheiten: Prozent |
## CloudWatch Metriken für GPU-Endpunktbereitstellungen mit mehreren Modellen
Auf GPU-gestützten Multimodell-Endpunkten können Sie die folgenden Kennzahlen überwachen.
Der `AWS/SageMaker` Namespace umfasst das folgende Modell zum Laden von Metriken aus Aufrufen von. [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)
Die Kennzahlen sind mit einminütiger Frequenz verfügbar.
Informationen darüber, wie lange CloudWatch Metriken aufbewahrt werden, finden Sie [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)in der *Amazon CloudWatch API-Referenz*.
**Kennzahlen zum Laden von Multimodell-Endpunktmodellen**
| Metrik | Description |
| --- | --- |
| ModelLoadingWaitTime | Der Zeitraum , über das hinweg eine Aufrufanforderung darauf gewartet hat, dass das Zielmodell heruntergeladen oder geladen wird, oder beides, um Interferenzen vorzunehmen. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelUnloadingTime | Der Zeitraum , das zum Entladen des Modells über den `UnloadModel`-API-Aufruf des Containers erforderlich war. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelDownloadingTime | Die Dauer, die es brauchte, das Modell von Amazon Simple Storage Service (Amazon S3) herunterzuladen. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelLoadingTime | Der Zeitraum , das zum Laden des Modells über den `LoadModel`-API-Aufruf des Containers erforderlich war. Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| ModelCacheHit | Die Anzahl der `InvokeEndpoint`-Anforderungen, die an den Multimodell-Endpunkt gesendet werden, für die das Modell bereits geladen wurde. Die Durchschnittsstatistik zeigt das Verhältnis der Anforderungen an, für die das Modell bereits geladen wurde. Einheiten: keine Gültige Statistiken: Durchschnitt, Datenstichprobe |
**Dimensionen für Kennzahlen zum Laden von Multimodell-Endpunktmodellen**
| Dimension | Description |
| --- | --- |
| EndpointName, VariantName | Filtert die Kennzahlen für den Endpunktaufruf einer `ProductionVariant` für den angegebenen Endpunkt und die Variante. |
Die `/aws/sagemaker/Endpoints`-Namespaces enthalten die folgenden Instance-Metriken aus Aufrufen an [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
Die Kennzahlen sind mit einminütiger Frequenz verfügbar.
Informationen darüber, wie lange CloudWatch Metriken aufbewahrt werden, finden Sie [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)in der *Amazon CloudWatch API-Referenz*.
**Kennzahlen für Modell-Instances von Multimodell-Endpunkten**
| Metrik | Description |
| --- | --- |
| LoadedModelCount | Die Anzahl der Modelle, die in die Container des Multimodell-Endpunkts geladen werden. Diese Metrik wird pro Instance ausgegeben. Die Durchschnittsstatistik mit einem Zeitraum von 1 Minute gibt Ihnen die durchschnittliche Anzahl der pro Instance geladenen Modelle an. Die Summenstatistik gibt Ihnen die Gesamtzahl der Modelle an, die über alle Instances im Endpunkt geladen wurden. Die Modelle, die von dieser Metrik verfolgt werden, sind nicht unbedingt eindeutig, da ein Modell möglicherweise in mehrere Container am Endpunkt geladen wird. Einheiten: keine Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| CPUUtilization | Die Summe der Auslastung jedes einzelnen CPU-Kerns. Die CPU-Auslastung jedes Kernbereichs liegt zwischen 0 und 100. Wenn es beispielsweise vier gibt CPUs, liegt der `CPUUtilization` Bereich zwischen 0% und 400%. Bei Endpunktvarianten ist dieser Wert die Summe der CPU-Auslastung von primären und ergänzenden Containern auf der Instance. Einheiten: Prozent |
| MemoryUtilization | Der Prozentsatz des Speichers, der von den Containern auf einer Instance belegt wird. Dieser Wertebereich liegt zwischen 0 und 100%. Bei Endpunktvarianten ist dieser Wert die Summe der Speichernutzung der primären und ergänzenden Container auf der Instance. Einheiten: Prozent |
| GPUUtilization | Der Prozentsatz der GPU-Einheiten, die von den Containern auf einer Instance verwendet werden. Der Wert, der zwischen 0 und 100 liegen kann, wird mit der Anzahl von multipliziert. GPUs Wenn es beispielsweise vier gibt, liegt der `GPUUtilization` Bereich zwischen GPUs 0% und 400%. Bei Endpunktvarianten ist dieser Wert die Summe der GPU-Auslastung von primären und ergänzenden Containern auf der Instance. Einheiten: Prozent |
| GPUMemoryUtilization | Der Prozentsatz des GPU-Speichers, der von den Containern auf einer Instance belegt wird. Der Wertebereich ist 0‐100 und wird mit der Anzahl von multipliziert. GPUs Wenn es beispielsweise vier gibt, ist der `GPUMemoryUtilization` Bereich GPUs 0%‐400%. Bei Endpunktvarianten ist dieser Wert die Summe der GPU-Speichernutzung der primären und ergänzenden Container auf der Instance. Einheiten: Prozent |
| DiskUtilization | Der Prozentsatz des Speicherplatzes, der von den Containern auf einer Instance verwendet wird. Dieser Wertebereich liegt zwischen 0 und 100%. Bei Endpunktvarianten ist dieser Wert die Summe der Speicherplatzauslastung der primären und ergänzenden Container auf der Instance. Einheiten: Prozent |
# Legen Sie das Caching-Verhalten von SageMaker KI-Endpunktmodellen für mehrere Modelle fest
Multimodell-Endpunkte speichern häufig verwendete Modelle standardmäßig im Arbeitsspeicher (CPU oder GPU, je nachdem, ob Sie über CPU- oder GPU-gestützte Instances verfügen) und auf der Festplatte zwischen, um Inferences mit geringer Latenz zu ermöglichen. Die zwischengespeicherten Modelle werden nur dann entladen und von der Festplatte and/or gelöscht, wenn einem Container nicht mehr genügend Arbeitsspeicher oder Festplattenspeicher für ein neues Zielmodell zur Verfügung steht.
Sie können das Caching-Verhalten eines Multimodell-Endpunkts ändern und das Modell-Caching explizit aktivieren oder deaktivieren, indem Sie den Parameter `ModelCacheSetting` beim Aufrufen von [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) festlegen.
Wir empfehlen, den Wert des Parameters `ModelCacheSetting` für Anwendungsfälle, die nicht vom Modell-Caching profitieren, auf `Disabled` festzulegen. Wenn eine große Anzahl von Modellen z. B. vom Endpunkt aus bedient werden müssen, jedes Modell aber nur einmal (oder sehr selten) aufgerufen wird. Bei solchen Anwendungsfällen erlaubt die Einstellung des Parameterwerts `ModelCacheSetting` auf `Disabled` höhere Transaktionen pro Sekunde (TPS) für `invoke_endpoint` Anfragen im Vergleich zum Standard-Caching-Modus. Ein höherer TPS in diesen Anwendungsfällen ist darauf zurückzuführen, dass SageMaker KI nach der Anfrage wie folgt vorgeht: `invoke_endpoint`
+ Es entlädt das Modell asynchron aus dem Speicher und löscht es unmittelbar nach dem Aufruf von der Festplatte.
+ Es bietet eine höhere Parallelität beim Herunterladen und Laden von Modellen in den Inference-Container. Sowohl bei CPU- als auch bei GPU-gestützten Endpunkten ist die Parallelität ein Faktor der Zahl der V CPUs der Container-Instance.
Richtlinien zur Auswahl eines SageMaker AI ML-Instanztyps für einen Endpunkt mit mehreren Modellen finden Sie unter. [Instance-Empfehlungen für Bereitstellungen von Multimodell-Endpunkten](multi-model-endpoint-instance.md)
# Legen Sie Auto-Scaling-Richtlinien für die Bereitstellung von Multimodell-Endpunkten fest
SageMaker KI-Endgeräte mit mehreren Modellen unterstützen vollständig die automatische Skalierung, bei der Modellreplikate verwaltet werden, um sicherzustellen, dass die Modelle auf der Grundlage von Verkehrsmustern skaliert werden. Es wird empfohlen, den Multimodell-Endpunkt und die Größe Ihrer Instances anhand von [Instance-Empfehlungen für Bereitstellungen von Multimodell-Endpunkten](multi-model-endpoint-instance.md) zu konfigurieren und für Ihren Endpunkt auch das Auto Scaling anhand von Instances einzurichten. Die zum Auslösen eines Auto-Scaling-Ereignisses verwendeten Aufrufraten basieren auf dem aggregierten Satz von Vorhersagen über alle Modelle, die von dem Endpunkt bedient werden. Weitere Informationen zur Einrichtung von Endpoint Auto Scaling finden Sie unter [Automatisches Skalieren von Amazon SageMaker KI-Modellen](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html).
Sie können Auto Scaling-Richtlinien mit vordefinierten und benutzerdefinierten Kennzahlen für CPU- und GPU-gestützte Multimodell-Endpunkte einrichten.
**Anmerkung**
SageMaker KI-Endpunktmetriken für mehrere Modelle sind mit einer Genauigkeit von einer Minute verfügbar.
## Definieren einer Skalierungsrichtlinie
Um die Kennzahlen und Zielwerte für eine Skalierungsrichtlinie festzulegen, konfigurieren Sie eine Skalierungsrichtlinie für die Ziel-Nachverfolgung. Sie können entweder eine vor- bzw. eine benutzerdefinierte Kennzahl verwenden.
Die Konfiguration einer Skalierungsrichtlinie wird durch einen JSON-Block dargestellt. Sie speichern Ihre Konfiguration einer Skalierungsrichtlinie als JSON-Block in einer Textdatei. Sie verwenden diese Textdatei, wenn Sie die AWS CLI oder die Application Auto Scaling Scaling-API aufrufen. Weitere Informationen zur Syntax der Richtlinienkonfiguration finden Sie unter `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` in der *API-Referenz für Application Auto Scaling*.
Die folgenden Optionen stehen zur Verfügung, um eine Konfiguration der Skalierungsrichtlinien für die Zielverfolgung zu definieren.
### Verwenden einer vorab definierten Metrik
Zur schnellen Definition einer Skalierungsrichtlinie für die Ziel-Nachverfolgung einer Variante verwenden Sie die vorab definierte Kennzahl `SageMakerVariantInvocationsPerInstance`. `SageMakerVariantInvocationsPerInstance` ist die durchschnittliche Anzahl an Aufrufen jeder Instance für eine Variante pro Minute. Wir empfehlen dringend, diese Kennzahl zu verwenden.
Um eine vorab definierte Kennzahl in einer Skalierungsrichtlinie zu verwenden, erstellen Sie eine Zielverfolgungskonfiguration für Ihre Richtlinie. Beziehen Sie in die Konfiguration einer Ziel-Nachverfolgung eine `PredefinedMetricSpecification` für die vorab definierte Kennzahl ein sowie einen `TargetValue` für den Zielwert dieser Kennzahl..
Im folgenden Beispiel wird eine typische Richtlinienkonfiguration für die Skalierung der Ziel-Nachverfolgung für eine Variante dargestellt. Bei dieser Konfiguration verwenden wir die vordefinierte Kennzahl `SageMakerVariantInvocationsPerInstance`, um die Zahl der Varianten-Instances anzupassen, damit jede Instance eine `InvocationsPerInstance`Kennzahl von `70` hat.
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "InvocationsPerInstance"
}
}
```
**Anmerkung**
Wir empfehlen bei Verwendung von Multimodell-Endpunkten die Verwendung von `InvocationsPerInstance`. Der Wert `TargetValue` für diese Kennzahl hängt von den Latenzanforderungen Ihrer Anwendung ab. Wir empfehlen Ihnen außerdem, Ihre Endpunkte einem Belastungstest zu unterziehen, um geeignete Werte für die Skalierungsparameter einzurichten. Weitere Informationen über Lasttests und die Einrichtung von Autoscaling für Ihre Endgeräte finden Sie im Blog [Configuring Autoscaling Inference Endpoints](https://aws.amazon.com/blogs/machine-learning/configuring-autoscaling-inference-endpoints-in-amazon-sagemaker/) in Amazon AI. SageMaker
### Verwenden einer benutzerdefinierten Metrik
Wenn Sie eine Skalierungsrichtlinie für die Ziel-Nachverfolgung festlegen müssen, die den Anforderungen Ihrer Kunden entspricht, dann definieren Sie eine benutzerdefinierte Kennzahl.. Sie können eine benutzerdefinierte Kennzahl basierend auf einer beliebigen Varianten-Kennzahl definieren, die sich proportional zur Skalierung ändert.
Nicht alle SageMaker KI-Metriken eignen sich für die Zielverfolgung. Die Kennzahl muss eine gültige Auslastungsmetrik sein und beschreiben, wie ausgelastet eine Instance ist. Der Wert der Kennzahl muss sich umgekehrt proportional zur Anzahl der Varianten-Instance erhöhen oder verringern. Das bedeutet, dass sich der Wert der Kennzahl verringern sollte, wenn die Zahl der Instances zunimmt.
**Wichtig**
Vor dem Bereitstellen der automatischen Skalierung in einer Produktionsumgebung müssen Sie die automatische Skalierung mit Ihrer benutzerdefinierten Kennzahl testen.
#### Beispiel für eine benutzerdefinierte Kennzahl für einen CPU-gestützten Multimodell-Endpunkt
Im folgenden Beispiel wird die Konfiguration für die Ziel-Nachverfolgung einer Skalierungsrichtlinie dargestellt. Bei dieser Konfiguration passt eine benutzerdefinierte Kennzahl von `my-model` für ein Modell mit der Bezeichnung `CPUUtilization` die Anzahl der Instances auf dem Endpunkt anhand einer durchschnittlichen CPU-Auslastung von 50% für alle Instances an.
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
#### Beispiel für eine benutzerdefinierte Kennzahl für einen GPU-gestützten Multimodell-Endpunkt
Im folgenden Beispiel wird die Konfiguration für die Ziel-Nachverfolgung einer Skalierungsrichtlinie dargestellt. Bei dieser Konfiguration passt eine benutzerdefinierte Kennzahl von `my-model` für ein Modell mit der Bezeichnung `GPUUtilization` die Anzahl der Instances auf dem Endpunkt anhand einer durchschnittlichen GPU-Auslastung von 50% für alle Instances an.
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "GPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
## Hinzufügen einer Ruhephase
Wenn Sie zum Aufskalieren Ihres Modells eine Ruhephase hinzufügen möchten, legen Sie für `ScaleOutCooldown` einen Wert in Sekunden fest. Entsprechend können Sie für `ScaleInCooldown` einen Wert in Sekunden festlegen, wenn Sie zum Abskalieren Ihres Modells eine Ruhephase hinzufügen möchten. Weitere Informationen über `ScaleInCooldown` und `ScaleOutCooldown` finden Sie unter `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` in der *API-Referenz für Application Auto Scaling*.
Im Folgenden finden Sie eine Beispielkonfiguration für die Ziel-Nachverfolgung für eine Skalierungsrichtlinie. Bei dieser Konfiguration wird die vordefinierte Kennzahl `SageMakerVariantInvocationsPerInstance` verwendet, um anhand eines Durchschnitts von `70` für alle Instances dieser Variante die Skalierung anzupassen. Die Konfiguration sieht eine Ruhephase von 10 Minuten zum Abskalieren und eine Ruhephase von 5 Minuten zum Aufskalieren vor.
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
# Endpunkte mit mehreren Containern
SageMaker KI-Endpunkte mit mehreren Containern ermöglichen es Kunden, mehrere Container, die unterschiedliche Modelle oder Frameworks verwenden, auf einem einzigen KI-Endpunkt bereitzustellen. SageMaker Die Container können nacheinander als Inferenz-Pipeline ausgeführt werden, oder auf jeden Container kann mithilfe eines direkten Aufrufs einzeln zugegriffen werden, um die Endpunktauslastung zu verbessern und die Kosten zu optimieren.
Hinweise zum sequenziellen Aufrufen der Container in einem Endpunkt mit mehreren Containern finden Sie unter [Inferenz-Pipelines in Amazon AI SageMaker](inference-pipelines.md).
Hinweise zum Aufrufen eines bestimmten Containers in einem Endpunkt mit mehreren Containern finden Sie unter [Rufen Sie einen Endpunkt mit mehreren Containern mit direktem Aufruf auf](multi-container-direct.md)
**Topics**
+ [Erstellen eines Multicontainer-Endpunkts (Boto 3)](multi-container-create.md)
+ [Aktualisieren Sie einen Endpunkt mit mehreren Containern](multi-container-update.md)
+ [Rufen Sie einen Endpunkt mit mehreren Containern mit direktem Aufruf auf](multi-container-direct.md)
+ [Sicherheit bei Endpunkten mit mehreren Containern und direktem Aufruf](multi-container-security.md)
+ [Metriken für Endpunkte mit mehreren Containern und direktem Aufruf](multi-container-metrics.md)
+ [Automatische Skalierung von Endpunkten mit mehreren Containern](multi-container-auto-scaling.md)
+ [Problembehandlung bei Endpunkten mit mehreren Containern](multi-container-troubleshooting.md)
# Erstellen eines Multicontainer-Endpunkts (Boto 3)
Erstellen Sie einen Endpunkt mit mehreren Containern, indem Sie [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html),, aufrufen [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html), und [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) APIs zwar so, als würden Sie alle anderen Endpunkte erstellen. Sie können diese Container sequentiell als Inferenzpipeline ausführen oder jeden einzelnen Container mithilfe eines direkten Aufrufs ausführen. Multi-Container Endpunkte haben die folgenden Anforderungen, wenn Sie `create_model` aufrufen:
+ Verwenden Sie den `Containers` Parameter anstelle von `PrimaryContainer` und schließen Sie mehr als einen Container in den `Containers` Parameter ein.
+ Der `ContainerHostname` Parameter ist für jeden Container in einem Endpunkt mit mehreren Containern und direktem Aufruf erforderlich.
+ Setzen Sie den `Mode` Parameter des `InferenceExecutionConfig` Felds auf `Direct` für den direkten Aufruf jedes Containers oder `Serial` auf die Verwendung von Containern als Inferenz-Pipeline. Der Standardmodus ist `Serial`.
**Anmerkung**
Derzeit gibt es ein Limit von bis zu 15 Containern, die auf einem Endpunkt mit mehreren Containern unterstützt werden.
Im folgenden Beispiel wird ein Modell mit mehreren Containern für den direkten Aufruf erstellt.
1. Erstellen Sie Containerelemente und `InferenceExecutionConfig` mit direktem Aufruf.
```
container1 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage1:mytag',
'ContainerHostname': 'firstContainer'
}
container2 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage2:mytag',
'ContainerHostname': 'secondContainer'
}
inferenceExecutionConfig = {'Mode': 'Direct'}
```
1. Erstellen Sie das Modell mit den Containerelementen und legen Sie das `InferenceExecutionConfig` Feld fest.
```
import boto3
sm_client = boto3.Session().client('sagemaker')
response = sm_client.create_model(
ModelName = 'my-direct-mode-model-name',
InferenceExecutionConfig = inferenceExecutionConfig,
ExecutionRoleArn = role,
Containers = [container1, container2]
)
```
Um einen Endpunkt zu erstellen, würden Sie dann [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) aufrufen, als würden Sie jeden anderen Endpunkt erstellen.
# Aktualisieren Sie einen Endpunkt mit mehreren Containern
Gehen Sie wie folgt vor, um einen Amazon SageMaker AI-Endpunkt mit mehreren Containern zu aktualisieren.
1. Rufen Sie [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) auf, um ein neues Modell mit einem neuen Wert für den `Mode` Parameter im `InferenceExecutionConfig` Feld zu erstellen.
1. Rufen Sie [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) auf, um mithilfe des neuen Modells, das Sie im vorherigen Schritt erstellt haben, eine neue Endpunktkonfiguration mit einem anderen Namen zu erstellen.
1. Rufen Sie [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_endpoint) auf, um den Endpunkt mit der neuen Endpunktkonfiguration zu aktualisieren, die Sie im vorherigen Schritt erstellt haben.
# Rufen Sie einen Endpunkt mit mehreren Containern mit direktem Aufruf auf
SageMaker KI-Endpunkte mit mehreren Containern ermöglichen es Kunden, mehrere Container bereitzustellen, um verschiedene Modelle auf einem KI-Endpunkt bereitzustellen. SageMaker Sie können bis zu 15 verschiedene Inferenzcontainer auf einem einzigen Endpunkt hosten. Mithilfe des direkten Aufrufs können Sie eine Anfrage an einen bestimmten Inferenzcontainer senden, der auf einem Endpunkt mit mehreren Containern gehostet wird.
Um einen Multicontainer-Endpunkt mit direktem Aufruf aufzurufen, rufen Sie [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) wie jeden anderen Endpunkt auf und geben Sie mithilfe des `TargetContainerHostname`-Parameters an, welchen Container Sie aufrufen möchten.
Das folgende Beispiel ruft direkt die `secondContainer` eines Multi-Container-Endpunkts auf, um eine Vorhersage zu erhalten.
```
import boto3
runtime_sm_client = boto3.Session().client('sagemaker-runtime')
response = runtime_sm_client.invoke_endpoint(
EndpointName ='my-endpoint',
ContentType = 'text/csv',
TargetContainerHostname='secondContainer',
Body = body)
```
Bei jeder direkten Aufrufanforderung an einen Multi-Container-Endpunkt verarbeitet nur der Container mit den `TargetContainerHostname` die Aufrufanforderung. Sie erhalten Validierungsfehler, wenn Sie einen der folgenden Schritte ausführen:
+ Geben Sie eine `TargetContainerHostname` an, die im Endpunkt nicht vorhanden ist
+ Geben Sie keinen Wert für `TargetContainerHostname` in einer Anfrage an einen Endpunkt an, der für den direkten Aufruf konfiguriert ist
+ Geben Sie einen Wert für `TargetContainerHostname` in einer Anfrage an einen Endpunkt an, der nicht für den direkten Aufruf konfiguriert ist.
# Sicherheit bei Endpunkten mit mehreren Containern und direktem Aufruf
Bei Endpunkten mit mehreren Containern und direktem Aufruf werden mehrere Container in einer einzigen Instance gehostet, wobei Speicher und Speichervolume gemeinsam genutzt werden. Es liegt in Ihrer Verantwortung, sichere Container zu verwenden, die korrekte Zuordnung von Anfragen zu Zielcontainern aufrechtzuerhalten und Benutzern den richtigen Zugriff auf Zielcontainer zu gewähren. SageMaker KI verwendet IAM-Rollen, um identitätsbasierte IAM-Richtlinien bereitzustellen, mit denen Sie angeben, ob und unter welchen Bedingungen der Zugriff auf eine Ressource für diese Rolle erlaubt oder verweigert wird. Weitere Informationen zu IAM-Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) im *AWS Identity and Access Management Benutzerhandbuch*. Informationen über identitätsbasierte Richtlinien finden Sie unter [Identitätsbasierte Richtlinien und ressourcenbasierte Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
Standardmäßig kann ein IAM-Prinzipal mit `InvokeEndpoint` Berechtigungen auf einem Multi-Container-Endpunkt mit direktem Aufruf jeden Container innerhalb des Endpunktes mit dem Endpunktnamen aufrufen, den Sie beim Aufruf von `invoke_endpoint` angeben. Wenn Sie den `invoke_endpoint` Zugriff auf eine begrenzte Anzahl von Containern innerhalb eines Endpunkts mit mehreren Containern einschränken müssen, verwenden Sie den `sagemaker:TargetContainerHostname` IAM-Bedingungsschlüssel. Die folgenden Richtlinien zeigen, wie Aufrufe auf bestimmte Container innerhalb eines Endpunkts beschränkt werden können.
Die folgende Richtlinie lässt `invoke_endpoint`-Anfragen nur zu, wenn der Wert des Feldes `TargetContainerHostname` mit einem der angegebenen regulären Ausdrücke übereinstimmt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"customIps*",
"common*"
]
}
}
}
]
}
```
------
Die folgende Richtlinie lehnt `invoke_endpoint` Anfragen ab, wenn der Wert des `TargetContainerHostname` Felds mit einem der angegebenen regulären Ausdrücke in der `Deny` Anweisung übereinstimmt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"model_name*"
]
}
}
},
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Deny",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"special-model_name*"
]
}
}
}
]
}
```
------
*Informationen zu SageMaker KI-Bedingungsschlüsseln finden Sie unter [Bedingungsschlüssel für SageMaker KI im Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys).AWS Identity and Access Management *
# Metriken für Endpunkte mit mehreren Containern und direktem Aufruf
Zusätzlich zu den Endpunktmetriken, die unter aufgeführt sind[SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md), bietet SageMaker AI auch Metriken pro Container.
Containerspezifische Metriken für Endpunkte mit mehreren Containern und direktem Aufruf befinden sich in zwei Namespaces und sind in zwei Namespaces unterteilt: CloudWatch und. `AWS/SageMaker` `aws/sagemaker/Endpoints` Der `AWS/SageMaker` Namespace umfasst aufrufbezogene Metriken, und der `aws/sagemaker/Endpoints` Namespace umfasst Kennzahlen zur Speicher- und CPU-Auslastung.
In der folgenden Tabelle sind die containerspezifischen Metriken für Endpunkte mit mehreren Containern und direktem Aufruf aufgeführt. Alle Metriken verwenden die Dimension [`EndpointName, VariantName, ContainerName`], die Metriken an einem bestimmten Endpunkt für eine bestimmte Variante filtert und einem bestimmten Container entspricht. Diese Metriken haben dieselben Metriknamen wie die Metriken für Inferenz-Pipelines, jedoch auf Container-Ebene [`EndpointName, VariantName, ContainerName`].
| | | | |
| --- |--- |--- |--- |
| Metrikname | Description | Dimension | NameSpace |
| Invocations | Die Anzahl der InvokeEndpoint Anfragen, die an einen Container innerhalb eines Endpunkts gesendet wurden. Um die Gesamtzahl der an diesen Container gesendeten Anfragen zu ermitteln, verwenden Sie die Sum Statistik. Einheiten: Keine Gültige Statistik: Sum, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation4XX Errors | Die Anzahl der InvokeEndpoint-Anfragen, für die das Modell einen 4xx HTTP-Antwortcode für einen bestimmten Container zurückgegeben hat. Für jede Antwort sendet KI eine. 4xx SageMaker 1 Einheiten: Keine Gültige Statistik: Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation5XX Errors | Die Anzahl der InvokeEndpoint-Anfragen, für die das Modell einen 5xx HTTP-Antwortcode für einen bestimmten Container zurückgegeben hat. Für jede 5xx Antwort sendet SageMaker KI eine1. Einheiten: Keine Gültige Statistik: Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| ContainerLatency | Die Zeit, die der Zielcontainer benötigt hat, um zu antworten, wie von der SageMaker KI aus gesehen. ContainerLatencybeinhaltet die Zeit, die benötigt wurde, um die Anfrage zu senden, die Antwort aus dem Container des Modells abzurufen und die Inferenz im Container abzuschließen. Einheiten: Mikrosekunden Gültige Statistiken: Average, Sum, Min, Max, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| OverheadLatency | Die Zeit, die zu der Zeit hinzukommt, die SageMaker KI für die Beantwortung einer Kundenanfrage aufgrund von Overhead benötigt hat. OverheadLatencywird von der Zeit an gemessen, in der SageMaker KI die Anfrage empfängt, bis sie eine Antwort an den Client zurücksendet, abzüglich derModelLatency. Die Overhead-Latenz kann in Abhängigkeit von mehreren Faktoren variieren. Diese Faktoren sind beispielsweise die Größe der Nutzlast für Anfragen und Antworten, die Häufigkeit von Anfragen und die Authentifizierung oder Autorisierung der Anfrage. Einheiten: Mikrosekunden Gültige Statistiken: Average, Sum, Min, Max, `Anzahl der Stichproben ` | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| CPUUtilization | Der Prozentsatz der CPU-Einheiten, die von jedem auf einer Instance laufenden Container verwendet werden. Der Wert liegt zwischen 0% und 100% und wird mit der Anzahl von CPUs multipliziert. Wenn es beispielsweise vier gibt CPUs, CPUUtilization kann der Wert zwischen 0 und 400% liegen. Bei Endpunkten mit direktem Aufruf entspricht die Anzahl der CPUUtilization Metriken der Anzahl der Container in diesem Endpunkt. Einheiten: Prozent | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
| MemoryUtilizaton | Der Prozentsatz des Arbeitsspeichers, der von jedem auf einer Instance laufenden Container verwendet wird. Dieser Wert reicht von 0 bis 100 %. Ähnlich wie CPUUtilization bei Endpunkten mit direktem Aufruf entspricht die Anzahl der MemoryUtilization Metriken der Anzahl der Container in diesem Endpunkt. Einheiten: Prozent | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
Alle Metriken in der vorherigen Tabelle sind spezifisch für Endpunkte mit mehreren Containern und direktem Aufruf. Neben diesen speziellen Metriken pro Container gibt es auch Metriken auf Variantenebene mit einer Dimension `[EndpointName, VariantName]` für alle Metriken in der Tabelle, die `ContainerLatency` erwartet wird.
# Automatische Skalierung von Endpunkten mit mehreren Containern
Wenn Sie die automatische Skalierung für einen Endpunkt mit mehreren Containern mithilfe der `InvocationsPerInstance` Metrik konfigurieren möchten, empfehlen wir, dass das Modell in jedem Container bei jeder Inferenzanforderung eine ähnliche CPU-Auslastung und Latenz aufweist. Dies wird empfohlen, da, wenn der Datenverkehr zum Multi-Container-Endpunkt von einem Modell mit niedriger CPU-Auslastung zu einem Modell mit hoher CPU-Auslastung wechselt, das Gesamtaufrufvolumen jedoch gleich bleibt, der Endpunkt nicht skaliert wird und es möglicherweise nicht genügend Instances gibt, um alle Anfragen an das Modell mit hoher CPU-Auslastung zu verarbeiten. Informationen zur automatischen Skalierung von Endpunkten finden Sie unter[Automatische Skalierung von Amazon SageMaker AI-Modellen](endpoint-auto-scaling.md).
# Problembehandlung bei Endpunkten mit mehreren Containern
Die folgenden Abschnitte können zum Beheben von Fehlern bei Endpunkten mit mehreren Containern helfen.
## Fehler bei der Ping-Integritätsprüfung
Bei mehreren Containern stehen der Speicher und die CPU des Endpunkts bei der Endpunkterstellung unter höherem Druck. Insbesondere die Metriken `MemoryUtilization` und `CPUUtilization` sind höher als bei Einzelcontainer-Endpunkten, da der Nutzungsdruck proportional zur Anzahl der Container ist. Aus diesem Grund empfehlen wir, Instance-Typen mit ausreichend Arbeitsspeicher und CPU zu wählen, um sicherzustellen, dass auf der Instance genügend Arbeitsspeicher vorhanden ist, damit alle Modelle geladen werden können (die gleichen Richtlinien gelten für die Bereitstellung einer Inferenzpipeline). Andernfalls schlägt Ihre Endpunkterstellung möglicherweise fehl und es wird ein Fehler wie `XXX did not pass the ping health check` angezeigt.
## Das Docker-Label accept-bind-to-port =true fehlt
Die Container in einem Multi-Container-Endpunkt lauschen auf dem in der `SAGEMAKER_BIND_TO_PORT` Umgebungsvariablen angegebenen Port anstelle von Port 8080. Wenn ein Container in einem Endpunkt mit mehreren Containern ausgeführt wird, stellt SageMaker AI dem Container diese Umgebungsvariable automatisch zur Verfügung. Wenn diese Umgebungsvariable nicht vorhanden ist, verwenden Container standardmäßig Port 8080. Verwenden Sie den folgenden Befehl zum Hinzufügen einer Kennzeichnung zu Ihrem Dockerfile, um anzuzeigen, dass Ihr Container diese Anforderung erfüllt.
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
Andernfalls erhalten Sie eine Fehlermeldung wie `Your Ecr Image XXX does not contain required com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true Docker label(s).`
Wenn Ihr Container einen zweiten Port überwachen muss, wählen Sie einen Port im von der Umgebungsvariable `SAGEMAKER_SAFE_PORT_RANGE` angegebenen Bereich. Geben Sie den Wert als inklusiven Bereich im Format *XXXX* - an*YYYY*, wobei XXXX und YYYY mehrstellige Ganzzahlen sind. SageMaker AI stellt diesen Wert automatisch bereit, wenn Sie den Container in einem Endpunkt mit mehreren Containern ausführen.
# Inferenz-Pipelines in Amazon AI SageMaker
Eine *Inferenz-Pipeline* ist ein SageMaker Amazon-KI-Modell, das aus einer linearen Abfolge von zwei bis fünfzehn Containern besteht, die Anfragen für Rückschlüsse auf Daten verarbeiten. Sie verwenden eine Inferenz-Pipeline, um eine beliebige Kombination aus vortrainierten integrierten SageMaker KI-Algorithmen und Ihren eigenen benutzerdefinierten Algorithmen, die in Docker-Containern verpackt sind, zu definieren und bereitzustellen. Sie können eine Inferenz-Pipeline verwenden, um Vorverarbeitungs-, Prognose- und Post-Processing-Data Science-Aufgaben zu kombinieren. Inferenz-Pipelines sind vollständig verwaltet.
Sie können SageMaker AI Spark ML Serving- und Scikit-Learn-Container hinzufügen, die die für Trainingsmodelle entwickelten Datentransformatoren wiederverwenden. Die gesamte zusammengestellte Inferenz-Pipeline kann als SageMaker KI-Modell betrachtet werden, mit dem Sie entweder Vorhersagen in Echtzeit treffen oder Batch-Transformationen direkt ohne externe Vorverarbeitung verarbeiten können.
Innerhalb eines Inferenz-Pipeline-Modells behandelt SageMaker KI Aufrufe als eine Folge von HTTP-Anfragen. Der erste Container in der Pipeline verarbeitet die erste Anfrage, dann wird die Zwischenantwort als Anfrage an den zweiten Container gesendet usw. für jeden Container in der Pipeline. SageMaker KI gibt die endgültige Antwort an den Client zurück.
Wenn Sie das Pipeline-Modell bereitstellen, installiert SageMaker KI alle Container auf jeder Amazon Elastic Compute Cloud (Amazon EC2) -Instance im Endpunkt oder Transformationsjob und führt sie aus. Die Merkmalverarbeitung und Inferenzen geschehen mit geringer Latenz, da sich die Container auf denselben EC2-Instances befinden. Sie definieren die Container für ein Pipeline-Modell mithilfe der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)-Operation oder über die Konsole. Anstatt einen `PrimaryContainer` festzulegen, verwenden Sie den `Containers`-Parameter, um die Container einzurichten, aus denen die Pipeline besteht. Dazu geben Sie die Reihenfolge an, in der die Container ausgeführt werden.
Ein Pipeline-Modell ist unveränderbar, aber Sie können eine Inferenz-Pipeline aktualisieren, indem Sie mit der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)-Operation eine neue bereitstellen. Diese Modularität unterstützt eine größere Flexibilität beim Experimentieren.
Informationen zum Erstellen einer Inferenz-Pipeline mit der SageMaker Model Registry finden Sie unter. [Bereitstellung von Modellregistrierung mit Model Registry](model-registry.md)
Für diese Funktion fallen keine zusätzlichen Gebühren an. Sie zahlen nur für die Instances, die auf einem Endpunkt ausgeführt werden.
**Topics**
+ [Beispiel-Notebooks für Inferenz-Pipelines](#inference-pipeline-sample-notebooks)
+ [Feature-Verarbeitung mit SparkML und Scikit-learn](inference-pipeline-mleap-scikit-learn-containers.md)
+ [Erstellen eines Pipeline-Modells](inference-pipeline-create-console.md)
+ [Echtzeit-Prognosen mit einer Inferenz-Pipeline](inference-pipeline-real-time.md)
+ [Stapeltransformationen mit Inferenz-Pipelines](inference-pipeline-batch.md)
+ [Protokolle und Metriken der Inferenz-Pipeline](inference-pipeline-logs-metrics.md)
+ [Beheben von Problemen mit Inferenz-Pipelines](inference-pipeline-troubleshoot.md)
## Beispiel-Notebooks für Inferenz-Pipelines
Ein Beispiel, das zeigt, wie Inferenz-Pipelines erstellt und bereitgestellt werden, finden Sie im Beispiel-Notebook [Inference Pipeline with Scikit-Learn und Linear Learner](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/scikit_learn_inference_pipeline). Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in SageMaker KI ausführen können, finden Sie unter. [SageMaker Amazon-Notebook-Instanzen](nbi.md)
Um eine Liste aller SageMaker AI-Beispiele zu sehen, wählen Sie nach dem Erstellen und Öffnen einer Notebook-Instanz die Registerkarte **SageMaker KI-Beispiele**. Es gibt drei Inferenz Pipeline-Notebooks. Die ersten beiden Inferenz-Pipeline-Notebooks befinden sich im Ordner `advanced_functionality` und das dritte Notebook befindet sich im Ordner `sagemaker-python-sdk`. Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Use (Verwenden)** und dann **Create copy (Kopie erstellen)**.
# Feature-Verarbeitung mit SparkML und Scikit-learn
Bevor Sie ein Modell mit den in Amazon SageMaker AI integrierten Algorithmen oder benutzerdefinierten Algorithmen trainieren, können Sie Spark- und Scikit-Learn-Präprozessoren verwenden, um Ihre Daten- und Engineering-Funktionen zu transformieren.
## Feature-Verarbeitung mit Spark ML
Sie können Spark-ML-Jobs mit [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html), einem serverlosen ETL-Service (Extrahieren, Transformieren, Laden), von Ihrem SageMaker KI-Notebook aus ausführen. Sie können auch eine Verbindung mit vorhandenen EMR-Clustern zum Ausführen von Spark ML-Aufträgen mit [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html) herstellen. Dazu benötigen Sie eine AWS Identity and Access Management (IAM-) Rolle, die Ihnen die Erlaubnis erteilt, Anrufe von Ihrem SageMaker KI-Notizbuch aus an zu tätigen. AWS Glue
**Anmerkung**
Informationen darüber, welche Python- und Spark-Versionen AWS Glue unterstützt werden, finden Sie in den [Versionshinweisen von AWS Glue](/glue/latest/dg/release-notes.html).
Nach der Entwicklung der Funktionen packen und serialisieren Sie Spark-ML-Jobs MLeap in MLeap Containern, die Sie zu einer Inferenz-Pipeline hinzufügen können. Sie müssen keine extern verwalteten Spark-Cluster verwenden. Diese Vorgehensweise erlaubt das nahtlose Skalieren von einigen Zeilen bis zu Datenmengen im Terabytebereich. Die gleichen Transformationen funktionieren für Training und Inferenz, Sie müssen daher die Vorverarbeitungs- und Funktionsbearbeitungslogik nicht duplizieren oder eine einmalige Lösung entwickeln, um die Modelle dauerhaft zu machen. Mit Inferenz-Pipelines müssen Sie keine externe Infrastruktur verwalten, und Sie können Prognosen direkt aus Dateneingaben erstellen.
Wenn Sie einen Spark-ML-Job ausführen AWS Glue, wird eine Spark-ML-Pipeline in ein Format serialisiert. [MLeap](https://github.com/combust/mleap) Anschließend können Sie den Job mit dem [SparkML Model Serving Container](https://github.com/aws/sagemaker-sparkml-serving-container) in einer SageMaker AI-Inferenz-Pipeline verwenden. *MLeap*ist ein Serialisierungsformat und eine Ausführungs-Engine für Machine-Learning-Pipelines. Es unterstützt Spark, Scikit-Learn und TensorFlow zum Trainieren von Pipelines und deren Export in eine serialisierte Pipeline, ein sogenanntes Bundle. MLeap Sie können Bundles zurück in Spark deserialisieren, um sie im Batch-Modus zu bewerten, oder in die Runtime, um API-Dienste in Echtzeit bereitzustellen. MLeap
Ein Beispiel, das zeigt, wie Prozesse mit Spark ML dargestellt werden, finden Sie im Beispielnotizbuch [Train an ML Model using Apache Spark in Amazon EMR and Deployment in SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/sparkml_serving_emr_mleap_abalone).
## Feature-Verarbeitung mit Sci-kit Learn
Sie können Scikit-Learn-Jobs direkt in Amazon AI ausführen und in Container packen. SageMaker Ein Beispiel für Python-Code zum Erstellen eines scikit-learn-Funktionsengineering-Modells, das mit dem [Iris-Datensatz von Fischer](http://archive.ics.uci.edu/ml/datasets/Iris) trainiert wird und die Iris-Art basierend auf morphologischen Messungen voraussagt, finden Sie unter [IRIS-Training und -Voraussage mit SageMaker Scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris).
# Erstellen eines Pipeline-Modells
Verwenden Sie die Amazon SageMaker AI-Konsole oder den `CreateModel` Vorgang, um ein Pipeline-Modell zu erstellen, das auf einem Endpunkt bereitgestellt oder für einen Batch-Transformationsjob verwendet werden kann.
**So erstellen Sie eine Inferenz-Pipeline (Konsole):**
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 **Models (Modelle)** und dann **Create models (Modelle erstellen)** in der Gruppe **Inference (Inferenz)** aus.
1. Geben Sie auf der Seite **Modell erstellen** einen Modellnamen an, wählen Sie eine IAM-Rolle und, wenn Sie eine private VPC verwenden möchten, geben Sie VPC-Werte an.
![\[Die Seite für das Erstellen eines Modells für eine Inferenz-Pipeline.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/create-pipeline-model.png)
1. Wählen Sie zum Hinzufügen von Informationen zu den Containern in der Inferenz-Pipeline **Add Container (Container hinzufügen)** und dann **Next (Weiter)** aus.
1. Füllen Sie die Felder für jeden Container in der Reihenfolge aus, in der sie ausgeführt werden sollen, maximal fünfzehn. Machen Sie Angaben in den Feldern **Container input options (Container-Eingabeoptionen)**, **Location of inference code image (Speicherort des Inferenzcode-Abbilds)** und optional auch in **Location of model artifacts (Speicherort der Modellartefakte)**, **Container host name (Containerhostname)** und **Environmental variables (Umgebungsvariablen)**.
![\[Erstellen eines Pipeline-Modells mit Containern.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/create-pipeline-model-containers.png)
**MyInferencePipelineModel**Auf der Seite werden die Einstellungen für die Container zusammengefasst, die Eingaben für das Modell liefern. Wenn Sie die Umgebungsvariablen in einer entsprechenden Containerdefinition angegeben haben, zeigt SageMaker AI sie im Feld **Umgebungsvariablen** an.
![\[Die Zusammenfassung der Container-Einstellungen für das Pipeline-Modell.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipeline-MyInferencePipelinesModel-recap.png)
# Echtzeit-Prognosen mit einer Inferenz-Pipeline
Sie können trainierte Modelle in einer Inferenz-Pipeline verwenden, um Echtzeit-Prognosen direkt ohne externe Vorverarbeitung durchzuführen. Wenn Sie die Pipeline konfigurieren, können Sie wählen, ob Sie die integrierten Feature-Transformatoren verwenden möchten, die bereits in Amazon SageMaker AI verfügbar sind. Sie können auch Ihre eigene Transformationslogik mit nur wenigen Zeilen von Scikit-learn- oder Spark-Code implementieren.
[MLeap](https://combust.github.io/mleap-docs/), ein Serialisierungsformat und eine Ausführungs-Engine für Machine-Learning-Pipelines, unterstützt Spark, Scikit-Learn sowie TensorFlow für das Trainieren von Pipelines und deren Export in eine serialisierte Pipeline, das sogenannte Bundle. MLeap Sie können Bundles zurück in Spark deserialisieren, um sie im Batch-Modus zu bewerten, oder in die Runtime, um API-Dienste in Echtzeit bereitzustellen. MLeap
Die Container in einer Pipeline überwacht den in der Umgebungsvariable `SAGEMAKER_BIND_TO_PORT` angegebenen Port (anstelle von 8080). Bei der Ausführung in einer Inferenz-Pipeline stellt SageMaker KI diese Umgebungsvariable automatisch Containern zur Verfügung. Wenn diese Umgebungsvariable nicht vorhanden ist, verwenden Container standardmäßig Port 8080. Verwenden Sie den folgenden Befehl zum Hinzufügen einer Kennzeichnung zu Ihrem Dockerfile, um anzuzeigen, dass Ihr Container diese Anforderung erfüllt.
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
Wenn Ihr Container einen zweiten Port überwachen muss, wählen Sie einen Port im von der Umgebungsvariable `SAGEMAKER_SAFE_PORT_RANGE` angegebenen Bereich. Geben Sie den Wert als inklusiven Bereich im Format an**"XXXX-YYYY"**, wobei `XXXX` und mehrstellige Ganzzahlen `YYYY` sind. SageMaker AI stellt diesen Wert automatisch bereit, wenn Sie den Container in einer Multicontainer-Pipeline ausführen.
**Anmerkung**
Um benutzerdefinierte Docker-Images in einer Pipeline zu verwenden, die [integrierte SageMaker KI-Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) enthält, benötigen Sie eine [Amazon Elastic Container Registry (Amazon ECR) -Richtlinie](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html). Ihr Amazon ECR-Repository muss SageMaker KI die Erlaubnis erteilen, das Bild abzurufen. Weitere Informationen finden Sie unter [Beheben von Problemen mit Amazon ECR-Berechtigungen für Inferenz-Pipelines](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions).
## Erstellen und Bereitstellen eines Inferenz-Pipeline-Endpunkts
Der folgende Code erstellt und implementiert ein Echtzeit-Inferenz-Pipeline-Modell mit SparkML und XGBoost Serienmodellen unter Verwendung des AI SDK. SageMaker
```
from sagemaker.model import Model
from sagemaker.pipeline_model import PipelineModel
from sagemaker.sparkml.model import SparkMLModel
sparkml_data = 's3://{}/{}/{}'.format(s3_model_bucket, s3_model_key_prefix, 'model.tar.gz')
sparkml_model = SparkMLModel(model_data=sparkml_data)
xgb_model = Model(model_data=xgb_model.model_data, image=training_image)
model_name = 'serial-inference-' + timestamp_prefix
endpoint_name = 'serial-inference-ep-' + timestamp_prefix
sm_model = PipelineModel(name=model_name, role=role, models=[sparkml_model, xgb_model])
sm_model.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge', endpoint_name=endpoint_name)
```
## Aufruf von Echtzeit-Inferenz von einem Inferenz-Pipeline-Endpunkt
Das folgende Beispiel zeigt, wie Echtzeit-Prognosen erstellt werden, indem ein Inferenz-Endpunkt aufgerufen und eine Anfragenutzlast im JSON-Format übergeben wird:
```
import sagemaker
from sagemaker.predictor import json_serializer, json_deserializer, Predictor
payload = {
"input": [
{
"name": "Pclass",
"type": "float",
"val": "1.0"
},
{
"name": "Embarked",
"type": "string",
"val": "Q"
},
{
"name": "Age",
"type": "double",
"val": "48.0"
},
{
"name": "Fare",
"type": "double",
"val": "100.67"
},
{
"name": "SibSp",
"type": "double",
"val": "1.0"
},
{
"name": "Sex",
"type": "string",
"val": "male"
}
],
"output": {
"name": "features",
"type": "double",
"struct": "vector"
}
}
predictor = Predictor(endpoint=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=json_serializer,
content_type='text/csv', accept='application/json')
print(predictor.predict(payload))
```
Die Antwort, die Sie von `predictor.predict(payload)` erhalten, ist das Inferenzergebnis des Modells.
## Beispiel für eine Echtzeit-Inferenz-Pipeline
Sie können dieses [Beispiel-Notebook mit dem SKLearn Prädiktor ausführen, der](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-python-sdk/scikit_learn_randomforest/Sklearn_on_SageMaker_end2end.ipynb) zeigt, wie ein Endpunkt bereitgestellt, eine Inferenzanforderung ausgeführt und dann die Antwort deserialisiert wird. Dieses Notizbuch und weitere Beispiele finden Sie im [ SageMaker GitHub Amazon-Beispiel-Repository](https://github.com/awslabs/amazon-sagemaker-examples).
# Stapeltransformationen mit Inferenz-Pipelines
Um Inferenzen für einen gesamten Datensatz zu erhalten, führen Sie eine Batch-Transformation für ein trainiertes Modell aus. Zur Ausführung von Inferenzen für einen vollständigen Datensatz können Sie dasselbe Inferenz-Pipeline-Modell verwenden, das für einen Endpunkt zur Echtzeitverarbeitung in einem Stapelumwandlungsauftrag erstellt und bereitgestellt wurde. Für einen Stapeltransformationsauftrag in einer Pipeline werden die Eingaben von Amazon S3 heruntergeladen und in einer oder mehreren HTTP-Anfragen an ein Inferenz-Pipeline-Modell gesendet. Ein Beispiel, das zeigt, wie Daten für eine Batch-Transformation vorbereitet werden, finden Sie im Beispielnotizbuch [Amazon SageMaker Multi-Model Endpoints using Linear](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_linear_learner_home_value) Learner „Abschnitt 2 — Vorverarbeitung der Rohdaten von Housing mit Scikit Learn“. Informationen zu Amazon SageMaker AI-Batch-Transformationen finden Sie unter[Batch-Transformation für Inferenz mit Amazon AI SageMaker](batch-transform.md).
**Anmerkung**
Um benutzerdefinierte Docker-Images in einer Pipeline zu verwenden, die in [Amazon SageMaker AI integrierte Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) enthält, benötigen Sie eine [Amazon Elastic Container Registry (ECR) -Richtlinie](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html). Ihr Amazon ECR-Repository muss SageMaker KI die Erlaubnis erteilen, das Bild abzurufen. Weitere Informationen finden Sie unter [Beheben von Problemen mit Amazon ECR-Berechtigungen für Inferenz-Pipelines](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions).
Das folgende Beispiel zeigt, wie ein Transformationsjob mit dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) ausgeführt wird. In diesem Beispiel `model_name` handelt es sich um die Inferenzpipeline, die SparkML und XGBoost Modelle kombiniert (die in den vorherigen Beispielen erstellt wurden). Die von `input_data_path` angegebene Amazon-S3-Position enthält die Eingabedaten im CSV-Format zum Herunterladen und Senden an das Spark ML-Modell. Nach Abschluss des Transformationsauftrags `output_data_path` enthält der von angegebene Amazon S3 S3-Speicherort die vom XGBoost Modell zurückgegebenen Ausgabedaten im CSV-Format.
```
import sagemaker
input_data_path = 's3://{}/{}/{}'.format(default_bucket, 'key', 'file_name')
output_data_path = 's3://{}/{}'.format(default_bucket, 'key')
transform_job = sagemaker.transformer.Transformer(
model_name = model_name,
instance_count = 1,
instance_type = 'ml.m4.xlarge',
strategy = 'SingleRecord',
assemble_with = 'Line',
output_path = output_data_path,
base_transform_job_name='inference-pipelines-batch',
sagemaker_session=sagemaker.Session(),
accept = CONTENT_TYPE_CSV)
transform_job.transform(data = input_data_path,
content_type = CONTENT_TYPE_CSV,
split_type = 'Line')
```
# Protokolle und Metriken der Inferenz-Pipeline
Die Überwachung ist wichtig, um die Zuverlässigkeit, Verfügbarkeit und Leistung der Amazon SageMaker AI-Ressourcen aufrechtzuerhalten. Verwenden Sie CloudWatch Amazon-Protokolle und Fehlermeldungen, um die Leistung der Inferenz-Pipeline zu überwachen und Fehler zu beheben. Informationen zu den von SageMaker AI bereitgestellten Überwachungstools finden Sie unter[AWS Ressourcen in Amazon SageMaker AI überwachen](monitoring-overview.md).
## Verwenden von Metriken zum Überwachen von Multicontainer-Modellen
Verwenden Sie Amazon, um die Multi-Container-Modelle in Inference Pipelines zu überwachen. CloudWatch CloudWatchsammelt Rohdaten und verarbeitet sie zu lesbaren Metriken, die nahezu in Echtzeit verfügbar sind. SageMaker KI-Schulungsjobs und Endpunkte schreiben CloudWatch Metriken und Protokolle in den `AWS/SageMaker` Namespace.
Die folgenden Tabellen listen die Metriken und Dimensionen für Folgendes auf:
+ Endpunkt-Aufrufe
+ Trainingsaufträge, Stapeltransformationsaufträge und Endpunkt-Instances
Eine *Dimension* ist ein name/value Paar, das eine Metrik eindeutig identifiziert. Sie können einer Metrik bis zu 10 Dimensionen zuweisen. Weitere Informationen zur Überwachung mit CloudWatch finden Sie unter[SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md).
**Kennzahlen für Endpunktaufrufe**
Der `AWS/SageMaker`-Namespace enthält die folgenden Anforderungsmetriken von [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)-Aufrufen.
Metriken werden in Intervallen von einer Minute gemeldet.
| Metrik | Description |
| --- | --- |
| Invocation4XXErrors | Die Anzahl der `InvokeEndpoint`-Anforderungen, bei denen das Modell den HTTP-Antwortcode `4xx` zurückgegeben hat. Für jede `4xx` Antwort sendet SageMaker KI eine`1`. Einheiten: keine Gültige Statistiken: `Average`, `Sum` |
| Invocation5XXErrors | Die Anzahl der `InvokeEndpoint`-Anforderungen, bei denen das Modell den HTTP-Antwortcode `5xx` zurückgegeben hat. Für jede `5xx` Antwort sendet SageMaker KI eine`1`. Einheiten: keine Gültige Statistiken: `Average`, `Sum` |
| Invocations | Die an einen Modellendpunkt gesendeten `number of InvokeEndpoint`-Anforderungen. Mit der `Sum`-Statistik können Sie die Gesamtanzahl der an einen Modellendpunkt gesendeten Anforderungen abrufen. Einheiten: keine Gültige Statistiken: `Sum`, `Sample Count` |
| InvocationsPerInstance | Die Anzahl der Endpunktaufrufen, die an ein Modell gesendet wurden, normalisiert durch `InstanceCount` in jedem. `ProductionVariant` SageMaker AI sendet 1/ `numberOfInstances` als Wert für jede Anfrage, wobei `numberOfInstances` es sich um die Anzahl der aktiven Instanzen für den Endpunkt zum ProductionVariant Zeitpunkt der Anfrage handelt. Einheiten: keine Gültige Statistiken: `Sum` |
| ModelLatency | Die Zeit, die das/die Modell(e) für die Antwort gebraucht hat/haben. Dies umfasst die Zeit, die zum Senden der Anforderung, zum Abrufen der Antwort vom Modell-Container und zum Abschluss der Inferenz in dem Container benötigt wurde. ModelLatency ist die Gesamtzeit von allen Containern in einer Inferenz-Pipeline.Einheiten: MikrosekundenGültige Statistiken: `Average`, `Sum`, `Min`, `Max`, SampleCount |
| OverheadLatency | Die Zeit, die zu der Zeit hinzukommt, die SageMaker KI für die Beantwortung einer Kundenanfrage aufgrund von Overhead benötigt hat. `OverheadLatency`wird von der Zeit an gemessen, in der SageMaker KI die Anfrage empfängt, bis sie eine Antwort an den Client zurücksendet, abzüglich der`ModelLatency`. Die Overhead-Latenz kann in Abhängigkeit von mehreren Faktoren variieren. Diese Faktoren sind beispielsweise die Größe der Nutzlast für Anfragen und Antworten, die Häufigkeit von Anfragen und die Authentifizierung oder Autorisierung der Anfrage. Einheiten: Mikrosekunden Gültige Statistiken: `Average`, `Sum`, `Min`, `Max`, `Sample Count` |
| ContainerLatency | Die Zeit, die ein Inference-Pipeline-Container benötigt hat, um zu antworten, aus SageMaker Sicht der KI. ContainerLatencybeinhaltet die Zeit, die benötigt wurde, um die Anfrage zu senden, die Antwort aus dem Container des Modells abzurufen und die Inferenz im Container abzuschließen.Einheiten: MikrosekundenGültige Statistiken: `Average`, `Sum`, `Min`, `Max`, `Sample Count` |
**Dimensionen für Kennzahlen für den Aufruf von Endpunkten**
| Dimension | Description |
| --- | --- |
| EndpointName, VariantName, ContainerName | Filtert Endpunktaufrufmetriken für ein `ProductionVariant` am angegebenen Endpunkt und für die angegebene Variante. |
Für einen Inferenz-Pipeline-Endpunkt CloudWatch listet die Latenzmetriken pro Container in Ihrem Konto wie folgt als **Endpunkt-Container-Metriken** und **Endpunktvarianten-Metriken** im **SageMaker AI-Namespace** auf. Die `ContainerLatency`-Metrik wird nur für Inferenz-Pipelines angezeigt.
![\[Das CloudWatch Dashboard für eine Inferenz-Pipeline.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipeline-endpoint-metrics.png)
Für jeden Endpunkt und jeden Container zeigen die Latenzmetriken die Namen für den Container, den Endpunkt, die Variante und die Metrik an.
![\[Die Latenzmetriken für einen Endpunkt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipeline-endpoint-metrics-details.png)
**Trainingsauftrag-, Stapeltransformationsauftrag- und Endpunkt-Instance-Metriken**
Die Namespaces `/aws/sagemaker/TrainingJobs`, `/aws/sagemaker/TransformJobs` und `/aws/sagemaker/Endpoints` beinhalten die folgenden Metriken für die Trainingsaufträge und Endpunkt-Instances.
Metriken werden in Intervallen von einer Minute gemeldet.
| Metrik | Description |
| --- | --- |
| CPUUtilization | Der Prozentsatz der CPU-Einheiten, die von den Containern auf einer Instance verwendet werden. Der Wert liegt zwischen 0% und 100% und wird mit der Anzahl von multipliziert. CPUs Wenn es beispielsweise vier gibt CPUs, `CPUUtilization` kann der Wert zwischen 0 und 400% liegen. Bei Trainingsaufträgen ist `CPUUtilization` die CPU-Auslastung des Algorithmus-Containers auf der Instance. Bei Stapeltransformationsaufträgen ist `CPUUtilization` die CPU-Auslastung des Transformationscontainers auf der Instance. Bei Multi-Container-Modellen ist `CPUUtilization` die Summe der CPU-Auslastung für alle Container, die auf der Instance ausgeführt werden. Bei Endpunkt-Varianten ist `CPUUtilization` die Summe der CPU-Auslastung für alle Container, die auf der Instance ausgeführt werden. Einheiten: Prozent |
| MemoryUtilization | Der Prozentsatz des Speichers, der von den Containern auf einer Instance belegt wird. Dieser Wert reicht von 0 bis 100 %.Bei Trainingsaufträgen ist `MemoryUtilization` der vom Algorithmus-Container auf der Instance verwendete Speicher.Bei Stapeltransformationsaufträgen ist `MemoryUtilization` ist der vom Transformationscontainer auf der Instance verwendete Speicher.Bei Multi-Container-Modellen ist MemoryUtilization ist die Summe des Speichers für alle Container, die auf der Instance ausgeführt werden.Bei Endpunkt-Varianten ist `MemoryUtilization` die Summe des Speichers für alle Container, die auf der Instance ausgeführt werden.Einheiten: Prozent |
| GPUUtilization | Der Prozentsatz der GPU-Einheiten, die von den Containern verwendet werden, die auf einer Instance ausgeführt werden. `GPUUtilization`reicht von 0% bis 100% und wird mit der Anzahl von GPUs multipliziert. Wenn es beispielsweise vier gibt GPUs, `GPUUtilization` kann der Wert zwischen 0 und 400% liegen. Bei Trainingsaufträgen ist `GPUUtilization` der GPU-Anteil, den der Algorithmus-Container auf der Instance verwendet. Bei Stapeltransformationsaufträgen ist `GPUUtilization` der GPU-Anteil, den der Transformationscontainer auf der Instance verwendet. Bei Multi-Container-Modellen ist `GPUUtilization` die GPU-Summe für alle Container auf der Instance. Bei Endpunkt-Varianten ist `GPUUtilization` die GPU-Summe für alle Container auf der Instance. Einheiten: Prozent |
| GPUMemoryUtilization | Der Prozentsatz des GPU-Speichers, der von den Containern verwendet wird, die auf einer Instance ausgeführt werden. GPUMemoryDie Auslastung reicht von 0 bis 100% und wird mit der Anzahl von GPUs multipliziert. Wenn es beispielsweise vier gibt GPUs, `GPUMemoryUtilization` kann sie zwischen 0 und 400% liegen. Bei Trainingsaufträgen ist `GPUMemoryUtilization` der GPU-Speicher, den der Algorithmus-Container auf der Instance belegt. Bei Stapeltransformationsaufträgen ist `GPUMemoryUtilization` der GPU-Arbeitsspeicher, den der Transformationscontainer auf der Instance belegt. Bei Multi-Container-Modellen ist `GPUMemoryUtilization` die GPU-Summe, die von allen Containern auf der Instance verwendet wird. Bei Endpunkt-Varianten ist `GPUMemoryUtilization` die Summe des GPU-Speichers, die von allen Containern auf der Instance verwendet wird. Einheiten: Prozent |
| DiskUtilization | Der Prozentsatz des Festplattenspeichers, der von den Containern verwendet wird, die auf einer Instance ausgeführt werden. DiskUtilization reicht von 0 bis 100%. Diese Metrik wird für Stapeltransformationsaufträge nicht unterstützt. Bei Trainingsaufträgen ist `DiskUtilization` der Speicherplatz, den der Algorithmus-Container auf der Instance verwendet. Bei Endpunkt-Varianten ist `DiskUtilization` ist die Summe des Speicherplatzes für alle bereitgestellten Container auf der Instance. Einheiten: Prozent |
**Dimensions for Training Job, Batch Transform Job, and Endpoint Instance Metrics (Dimensionen für Instance-Metriken für Trainingsaufträge, Stapeltransformationsaufträge und Endpunkte)**
| Dimension | Description |
| --- | --- |
| Host | Bei Trainingsaufträgen hat `Host` das Format `[training-job-name]/algo-[instance-number-in-cluster]`. Mit dieser Dimension können Sie Instance-Metriken für den angegebenen Trainingsauftrag und die Instance filtern. Dieses Dimensionsformat ist nur im Namensraum `/aws/sagemaker/TrainingJobs` vorhanden. Bei Stapeltransformationsaufträgen hat `Host` das Format `[transform-job-name]/[instance-id]`. Mit dieser Dimension können Sie Instance-Kennzahlen für den angegebenen Stapeltransformationsauftrag und die Instance filtern. Dieses Dimensionsformat ist nur im Namensraum `/aws/sagemaker/TransformJobs` vorhanden. Bei Endpunkten hat `Host` das Format `[endpoint-name]/[ production-variant-name ]/[instance-id]`. Mit dieser Dimension können Sie Instance-Metriken für den angegebenen Endpunkt sowie die Variante und die Instance filtern. Dieses Dimensionsformat ist nur im Namensraum `/aws/sagemaker/Endpoints` vorhanden. |
Um Ihnen beim Debuggen Ihrer Trainingsjobs, Endpunkte und Lebenszykluskonfigurationen für Notebooks zu helfen, sendet SageMaker KI auch alles, was ein Algorithmuscontainer, ein Modellcontainer oder eine Notebook-Instance-Lebenszykluskonfiguration an `stdout` oder `stderr` an Amazon CloudWatch Logs sendet. Sie können diese Informationen zum Debugging und zur Fortschrittanalyse verwenden.
## Verwenden von Protokollen zum Überwachen einer Inferenz-Pipeline
In der folgenden Tabelle sind die Protokollgruppen und Protokollstreams aufgeführt, die SageMaker AI. an Amazon sendet CloudWatch
Ein *Protokollstream* ist eine Abfolge von Protokollereignissen, die dieselbe Quelle nutzen. Jede einzelne Logquelle CloudWatch bildet einen separaten Log-Stream. Eine *Protokollgruppe* ist eine Gruppe von Protokollstreams, die dieselben Einstellungen für die Aufbewahrung, Überwachung und Zugriffskontrolle besitzen.
**Protokolle**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
**Anmerkung**
SageMaker AI erstellt die `/aws/sagemaker/NotebookInstances` Protokollgruppe, wenn Sie eine Notebook-Instanz mit einer Lebenszykluskonfiguration erstellen. Weitere Informationen finden Sie unter [Anpassung einer SageMaker Notebook-Instanz mithilfe eines LCC-Skripts](notebook-lifecycle-config.md).
Weitere Informationen zur SageMaker KI-Protokollierung finden Sie unter[CloudWatch Protokolle für Amazon SageMaker AI](logging-cloudwatch.md).
# Beheben von Problemen mit Inferenz-Pipelines
Verwenden Sie CloudWatch Protokolle und Fehlermeldungen, um Probleme mit der Inferenzpipeline zu beheben. Wenn Sie benutzerdefinierte Docker-Images in einer Pipeline verwenden, die in Amazon SageMaker AI integrierte Algorithmen enthält, können auch Berechtigungsprobleme auftreten. Um die erforderlichen Berechtigungen zu erteilen, erstellen Sie eine Amazon Elastic Container Registry (Amazon ECR)-Richtlinie.
**Topics**
+ [Beheben von Problemen mit Amazon ECR-Berechtigungen für Inferenz-Pipelines](#inference-pipeline-troubleshoot-permissions)
+ [Verwenden Sie CloudWatch Protokolle zur Fehlerbehebung bei SageMaker KI-Inferenz-Pipelines](#inference-pipeline-troubleshoot-logs)
+ [Verwenden von Fehlermeldungen zum Beheben von Problemen mit Inferenz-Pipelines.](#inference-pipeline-troubleshoot-errors)
## Beheben von Problemen mit Amazon ECR-Berechtigungen für Inferenz-Pipelines
Wenn Sie benutzerdefinierte Docker-Images in einer Pipeline verwenden, die [integrierte SageMaker KI-Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) enthält, benötigen Sie eine [Amazon ECR-Richtlinie.](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) Die Richtlinie ermöglicht es Ihrem Amazon ECR-Repository, SageMaker KI die Erlaubnis zu erteilen, das Bild abzurufen. Die Richtlinie muss die folgenden Berechtigungen hinzufügen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "allowSageMakerToPull",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*"
}
]
}
```
------
## Verwenden Sie CloudWatch Protokolle zur Fehlerbehebung bei SageMaker KI-Inferenz-Pipelines
SageMaker KI veröffentlicht die Container-Logs für Endpunkte, die eine Inferenz-Pipeline für Amazon bereitstellen, CloudWatch unter dem folgenden Pfad für jeden Container.
```
/aws/sagemaker/Endpoints/{EndpointName}/{Variant}/{InstanceId}/{ContainerHostname}
```
Beispiel: Protokolle für diesen Endpunkt werden in den folgenden Protokollgruppen und Streams veröffentlicht:
```
EndpointName: MyInferencePipelinesEndpoint
Variant: MyInferencePipelinesVariant
InstanceId: i-0179208609ff7e488
ContainerHostname: MyContainerName1 and MyContainerName2
```
```
logGroup: /aws/sagemaker/Endpoints/MyInferencePipelinesEndpoint
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName1
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName2
```
Ein *Protokollstream* ist eine Abfolge von Protokollereignissen, die dieselbe Quelle nutzen. Jede einzelne Logquelle CloudWatch bildet einen separaten Log-Stream. Eine *Protokollgruppe* ist eine Gruppe von Protokollstreams, die dieselben Einstellungen für die Aufbewahrung, Überwachung und Zugriffskontrolle besitzen.
**Anzeigen der Protokollgruppen und -streams**
1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Wählen Sie auf der Navigationsseite **Logs (Protokolle)**.
1. Filtern Sie unter **Log Groups (Protokollgruppen)** nach **MyInferencePipelinesEndpoint**:
![\[Die CloudWatch Protokollgruppen wurden nach dem Endpunkt der Inferenzpipeline gefiltert.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipeline-log-group-filter.png)
1. Um die Protokollstreams anzuzeigen, wählen Sie **MyInferencePipelinesEndpoint** auf der Seite CloudWatch **Protokollgruppen** die Option **Protokollgruppe suchen** aus.
![\[Der CloudWatch Log-Stream für die Inferenz-Pipeline.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipeline-log-streams-2.png)
Eine Liste der Protokolle, die SageMaker AI veröffentlicht, finden Sie unter[Protokolle und Metriken der Inferenz-Pipeline](inference-pipeline-logs-metrics.md).
## Verwenden von Fehlermeldungen zum Beheben von Problemen mit Inferenz-Pipelines.
Die Inferenz-Pipeline-Fehlermeldungen geben an, welcher Container fehlgeschlagen ist.
Wenn beim Aufrufen eines Endpunkts durch SageMaker KI ein Fehler auftritt, gibt der Dienst einen Fehler zurück `ModelError` (Fehlercode 424), der angibt, welcher Container ausgefallen ist. Wenn die Nutzlast der Anfrage (die Antwort des vorherigen Containers) das Limit von 5 MB überschreitet, gibt SageMaker AI eine detaillierte Fehlermeldung aus, z. B.:
Antwort von MyContainerName 1 mit Statuscode 200 erhalten. Die Anforderungsnutzlast von MyContainerName 1 bis MyContainerName 2 beträgt jedoch 6000000 Byte, was die maximale Grenze von 5 MB überschritten hat.
``
Wenn ein Container die Ping-Zustandsprüfung nicht besteht, während SageMaker KI einen Endpunkt erstellt, gibt er a zurück `ClientError` und gibt alle Container an, die die Ping-Überprüfung bei der letzten Integritätsprüfung nicht bestanden haben.
# Endpunkte und Ressourcen löschen
Löschen Sie Endpunkte, damit keine Gebühren mehr anfallen.
## Endpunkt löschen
Löschen Sie Ihren Endpunkt programmgesteuert mithilfe AWS SDK für Python (Boto3), mit der AWS CLI oder interaktiv mithilfe der SageMaker KI-Konsole.
SageMaker KI gibt alle Ressourcen frei, die bei der Erstellung des Endpunkts bereitgestellt wurden. Durch das Löschen eines Endpunkts werden weder die Endpunktkonfiguration noch das SageMaker KI-Modell gelöscht. Informationen [Löschen eines Modells](#realtime-endpoints-delete-model) zum Löschen Ihrer Endpunktkonfiguration und Ihres SageMaker KI-Modells finden Sie unter [Löschen Sie die Endpunktkonfiguration](#realtime-endpoints-delete-endpoint-config) und.
------
#### [ AWS SDK für Python (Boto3) ]
Verwenden Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API, um Ihren Endpunkt zu löschen. Geben Sie den Namen Ihres Endpunkts für das `EndpointName` Feld an.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint
sagemaker_client.delete_endpoint(EndpointName=endpoint_name)
```
------
#### [ AWS CLI ]
Zum Löschen eines Endpunkts verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html). Geben Sie für die Flagge `endpoint-name` den Namen Ihres Endpunkts an.
```
aws sagemaker delete-endpoint --endpoint-name
```
------
#### [ SageMaker AI Console ]
Löschen Sie Ihren Endpunkt interaktiv mit der SageMaker KI-Konsole.
1. Wählen Sie in der SageMaker KI-Konsole im [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)Navigationsmenü **Inference** aus.
1. Wählen Sie **Endpunkt** im Dropdown-Menü aus. Eine Liste der in AWS Ihrem Konto erstellten Endpunkte wird mit Namen, Amazon-Ressourcennamen (ARN), Erstellungszeit, Status und einem Zeitstempel angezeigt, wann der Endpunkt zuletzt aktualisiert wurde.
1. Wählen Sie den Endpunkt aus, den Sie löschen möchten.
1. Wählen Sie oben rechts den Drop-down-Schalter für **Aktionen** aus.
1. Wählen Sie **Löschen** aus.
------
## Löschen Sie die Endpunktkonfiguration
Löschen Sie Ihre Endpunktkonfiguration programmgesteuert mithilfe AWS SDK für Python (Boto3), mit der AWS CLI oder interaktiv mithilfe der KI-Konsole. SageMaker Durch das Löschen einer Endpunktkonfiguration werden keine Endpunkte gelöscht, die mit dieser Konfiguration erstellt wurden. Informationen zum Löschen Ihres Endpunkts finden Sie unter [Endpunkt löschen](#realtime-endpoints-delete-endpoint).
Löschen Sie keine Endpunktkonfiguration, die von einem Endpunkt verwendet wird, der aktiv ist oder während der Endpunkt aktualisiert oder erstellt wird. Möglicherweise verlieren Sie den Überblick über den Instance-Typ, den der Endpunkt verwendet, wenn Sie die Endpunktkonfiguration eines Endpunkts löschen, der aktiv ist oder gerade erstellt oder aktualisiert wird.
------
#### [ AWS SDK für Python (Boto3) ]
Verwenden Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html) API, um Ihren Endpunkt zu löschen. Geben Sie den Namen Ihrer Endpunktkonfiguration für das `EndpointConfigName` Feld an.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
endpoint_config_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
Sie können optional die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) API verwenden, um Informationen über den Namen der von Ihnen bereitgestellten Modelle (Produktionsvarianten) zurückzugeben, z. B. den Namen Ihres Modells und den Namen der Endpunktkonfiguration, die diesem bereitgestellten Modell zugeordnet ist. Geben Sie den Namen Ihres Endpunkts für das `EndpointConfigName` Feld ein.
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
endpoint_config_name = response['ProductionVariants'][0]['EndpointConfigName']
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
Weitere Informationen zu anderen Antwortelementen, die von zurückgegeben wurden`DescribeEndpointConfig`, finden Sie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)im [SageMaker API-Referenzhandbuch](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ AWS CLI ]
Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html)Befehl, um Ihre Endpunktkonfiguration zu löschen. Geben Sie den Namen Ihrer Endpunktkonfiguration für die `endpoint-config-name` Flagge an.
```
aws sagemaker delete-endpoint-config \
--endpoint-config-name
```
Sie können den [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) Befehl optional verwenden, um Informationen über den Namen der von Ihnen bereitgestellten Modelle (Produktionsvarianten) zurückzugeben, z. B. den Namen Ihres Modells und den Namen der Endpunktkonfiguration, die diesem bereitgestellten Modell zugeordnet ist. Geben Sie den Namen Ihres Endpunkts für die `endpoint-config-name` Flagge ein.
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
Dadurch wird eine JSON-Antwort zurückgegeben. Sie können den Namen der Endpunktkonfiguration, der mit diesem Endpunkt verknüpft ist, kopieren und einfügen, einen JSON-Parser verwenden oder ein für die JSON-Analyse entwickeltes Tool verwenden.
------
#### [ SageMaker AI Console ]
Löschen Sie Ihre Endpunktkonfiguration interaktiv mit der SageMaker AI-Konsole.
1. Wählen Sie in der SageMaker AI-Konsole im [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)Navigationsmenü **Inference** aus.
1. Wählen Sie im Dropdown-Menü die Option **Endpunktkonfigurationen** aus. Eine Liste der in Ihrem AWS Konto erstellten Endpunktkonfigurationen wird nach Name, Amazon-Ressourcenname (ARN) und Erstellungszeit angezeigt.
1. Wählen Sie die Endpunktkonfiguration aus, die Sie löschen möchten.
1. Wählen Sie oben rechts den Drop-down-Schalter für **Aktionen** aus.
1. Wählen Sie **Löschen** aus.
------
## Löschen eines Modells
Löschen Sie Ihr SageMaker KI-Modell programmgesteuert mithilfe AWS SDK für Python (Boto3), mit der AWS CLI oder interaktiv mithilfe der KI-Konsole. SageMaker Durch das Löschen eines SageMaker KI-Modells wird nur der Modelleintrag gelöscht, der in AI erstellt wurde. SageMaker Beim Löschen eines Modells werden keine Modellartefakte, kein Inferenzcode und auch nicht die IAM-Rolle gelöscht, die Sie beim Erstellen des Modells angegeben haben.
------
#### [ AWS SDK für Python (Boto3) ]
Verwenden Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API, um Ihr SageMaker KI-Modell zu löschen. Geben Sie den Namen Ihres Modells für das `ModelName` Feld an.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
model_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete model
sagemaker_client.delete_model(ModelName=model_name)
```
Sie können optional die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) API verwenden, um Informationen über den Namen Ihrer bereitgestellten Modelle (Produktionsvarianten) zurückzugeben, z. B. den Namen Ihres Modells und den Namen der Endpunktkonfiguration, die diesem bereitgestellten Modell zugeordnet ist. Geben Sie den Namen Ihres Endpunkts für das `EndpointConfigName` Feld ein.
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
model_name = response['ProductionVariants'][0]['ModelName']
sagemaker_client.delete_model(ModelName=model_name)
```
Weitere Informationen zu anderen Antwortelementen, die von zurückgegeben wurden`DescribeEndpointConfig`, finden Sie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)im [SageMaker API-Referenzhandbuch](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ AWS CLI ]
Verwenden Sie den [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html)Befehl, um Ihr SageMaker KI-Modell zu löschen. Geben Sie den Namen für Ihr Model für die `model-name` Flagge an.
```
aws sagemaker delete-model \
--model-name
```
Sie können den [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) Befehl optional verwenden, um Informationen über den Namen der von Ihnen bereitgestellten Modelle (Produktionsvarianten) zurückzugeben, z. B. den Namen Ihres Modells und den Namen der Endpunktkonfiguration, die mit diesem bereitgestellten Modell verknüpft ist. Geben Sie den Namen Ihres Endpunkts für die `endpoint-config-name` Flagge ein.
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
Dadurch wird eine JSON-Antwort zurückgegeben. Sie können den Namen des Modells, das diesem Endpunkt zugeordnet ist, kopieren und einfügen, einen JSON-Parser verwenden oder ein für die JSON-Analyse entwickeltes Tool verwenden.
------
#### [ SageMaker AI Console ]
Löschen Sie Ihr SageMaker KI-Modell interaktiv mit der SageMaker KI-Konsole.
1. Wählen Sie in der SageMaker KI-Konsole im [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)Navigationsmenü **Inferenz** aus.
1. Wählen Sie im Dropdown-Menü **Modelle** aus. Eine Liste der in AWS Ihrem Konto erstellten Modelle wird mit Namen, Amazon-Ressourcennamen (ARN) und Erstellungszeit angezeigt.
1. Wählen Sie das Modell aus, das Sie löschen möchten.
1. Wählen Sie oben rechts den Drop-down-Schalter für **Aktionen** aus.
1. Wählen Sie **Löschen** aus.
------