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.
# Modelle für Inference einsetzen
Mit Amazon SageMaker AI können Sie beginnen, Vorhersagen oder *Schlussfolgerungen* aus Ihren trainierten Modellen für maschinelles Lernen zu ziehen. SageMaker KI bietet eine breite Auswahl an ML-Infrastruktur- und Modellbereitstellungsoptionen, um all Ihre Anforderungen an ML-Inferenz zu erfüllen. Mit SageMaker AI Inference können Sie Ihre Modellbereitstellung skalieren, Modelle in der Produktion effektiver verwalten und den betrieblichen Aufwand reduzieren. SageMaker KI bietet Ihnen verschiedene Inferenzoptionen, z. B. Echtzeit-Endpunkte für Inferenzen mit geringer Latenz, serverlose Endpunkte für vollständig verwaltete Infrastruktur und auto-scaling sowie asynchrone Endpunkte für Batches von Anfragen. Indem Sie die für Ihren Anwendungsfall geeignete Inferenzoption nutzen, können Sie eine effiziente Modellbereitstellung und Inferenz sicherstellen.
## Auswahl eines Feature
Es gibt mehrere Anwendungsfälle für die Bereitstellung von ML-Modellen mit KI. SageMaker In diesem Abschnitt werden diese Anwendungsfälle sowie die SageMaker KI-Funktion beschrieben, die wir für jeden Anwendungsfall empfehlen.
### Anwendungsfälle
Im Folgenden sind die wichtigsten Anwendungsfälle für den Einsatz von ML-Modellen mit SageMaker KI aufgeführt.
+ **Anwendungsfall 1: Bereitstellen eines Machine-Learning-Modells in einer Low-Code- oder No-Code-Umgebung.** Für Anfänger oder SageMaker KI-Neulinge können Sie vortrainierte Modelle mit Amazon SageMaker JumpStart über die Amazon SageMaker Studio-Oberfläche bereitstellen, ohne dass komplexe Konfigurationen erforderlich sind.
+ **Anwendungsfall 2: Verwenden von Code, um Machine-Learning-Modelle mit mehr Flexibilität und Kontrolle bereitzustellen.** Erfahrene ML-Praktiker können mithilfe der `ModelBuilder` Klasse im SageMaker KI-Python-SDK, die eine detaillierte Kontrolle über verschiedene Einstellungen wie Instanztypen, Netzwerkisolierung und Ressourcenzuweisung bietet, ihre eigenen Modelle mit benutzerdefinierten Einstellungen für ihre Anwendungsanforderungen bereitstellen.
+ **Anwendungsfall 3: Implementieren von Machine-Learning-Modellen in großem Maßstab.** Fortgeschrittene Benutzer und Unternehmen, die Modelle in der Produktion skalierbar verwalten möchten, können die AWS SDK für Python (Boto3) und CloudFormation zusammen mit der gewünschten Infrastructure as Code (IaC) und CI/CD Tools verwenden, um Ressourcen bereitzustellen und das Ressourcenmanagement zu automatisieren.
### Empfohlene Features
In der folgenden Tabelle werden die wichtigsten Überlegungen und Kompromisse für SageMaker KI-Funktionen für jeden Anwendungsfall beschrieben.
| | Anwendungsfall 1 | Anwendungsfall 2 | Anwendungsfall 3 |
| --- | --- | --- | --- |
| SageMaker KI-Funktion | Verwenden Sie es [ JumpStart in Studio](jumpstart-foundation-models-use-studio-updated.md), um die Bereitstellung Ihres grundlegenden Modells zu beschleunigen. | Stellen Sie [ModelBuilder Modelle mithilfe des SageMaker Python-SDK](how-it-works-modelbuilder-creation.md) bereit. | [Stellen Sie Modelle in großem Maßstab bereit und verwalten Sie sie mit CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_SageMaker.html). |
| Description | Verwenden Sie die Studio-Benutzeroberfläche, um vortrainierte Modelle aus einem Katalog für vorkonfigurierte Inferenzendpunkte bereitzustellen. Diese Option ist ideal für Citizen Data Scientists oder für alle, die ein Modell bereitstellen möchten, ohne komplexe Einstellungen konfigurieren zu müssen. | Verwenden Sie die ModelBuilder Klasse aus dem Amazon SageMaker AI Python SDK, um Ihr eigenes Modell bereitzustellen und Bereitstellungseinstellungen zu konfigurieren. Diese Option ist ideal für erfahrene Datenwissenschaftler oder für alle, die ihr eigenes Modell bereitstellen müssen und eine genaue Kontrolle benötigen. | Verwenden Sie CloudFormation und Infrastructure as Code (IaC) für die programmatische Steuerung und Automatisierung bei der Bereitstellung und Verwaltung von SageMaker KI-Modellen. Diese Option ist ideal für fortgeschrittene Benutzer, die konsistente und wiederholbare Bereitstellungen benötigen. |
| Optimiert für | schnelle und optimierte Bereitstellungen beliebter Open-Source-Modelle | die Bereitstellung Ihrer eigenen Modelle | die fortlaufende Verwaltung von Modellen in der Produktion |
| Überlegungen | Fehlende Anpassung an Container-Einstellungen und spezifische Anwendungsanforderungen | Keine Benutzeroberfläche; erfordert, dass Sie mit der Entwicklung und Wartung von Python-Code vertraut sind | Erfordert Infrastrukturmanagement und organisatorische Ressourcen sowie Vertrautheit mit den AWS SDK für Python (Boto3) oder mit Vorlagen. CloudFormation |
| Empfohlene Umgebung | Eine SageMaker KI-Domäne | Eine Python-Entwicklungsumgebung, die mit Ihren AWS Anmeldeinformationen konfiguriert ist und das SageMaker Python-SDK installiert ist, oder eine SageMaker AI-IDE wie [SageMaker JupyterLab](studio-updated-jl.md) | Die AWS CLI, eine lokale Entwicklungsumgebung sowie Infrastructure as Code (IaC) und Tools CI/CD |
### Zusätzliche Optionen
SageMaker KI bietet verschiedene Optionen für Ihre Inferenz-Anwendungsfälle, sodass Sie die technische Breite und Tiefe Ihrer Implementierungen selbst bestimmen können:
+ **Bereitstellen eines Modells auf einem Endpunkt** Ziehen Sie bei der Bereitstellung Ihres Modells die folgenden Optionen in Betracht:
+ [Echtzeit-Inferenz](realtime-endpoints.md). Inferenz in Echtzeit ist ideal für Inferenz-Workloads, bei denen interaktive Anforderungen mit geringer Latenz erfüllt werden müssen.
+ [Bereitstellen von Modellen mit Amazon SageMaker Serverless Inference](serverless-endpoints.md). Verwenden Sie Serverless Inference, um Modelle bereitzustellen, ohne die zugrunde liegende Infrastruktur konfigurieren oder verwalten zu müssen. Diese Option ist ideal für Workloads, bei denen es zwischen den einzelnen Datenverkehrsspitzen Leerlaufzeiten gibt und die Kaltstarts tolerieren können.
+ [Asynchrone Inferenz-Inferenz](async-inference.md). Stellt eingehende Anforderungen in eine Warteschlange und verarbeitet sie asynchron. Diese Option ist ideal für Anfragen mit großen Nutzlasten (bis zu 1 GB), langen Verarbeitungszeiten (bis zu einer Stunde) und Latenzanforderungen nahezu in Echtzeit.
+ **Kostenoptimierung** Ziehen Sie die folgenden Optionen in Betracht, um Ihre Inferenzkosten zu optimieren:
+ [Optimierung der Modellleistung mit SageMaker Neo](neo.md). Verwenden Sie SageMaker Neo, um Ihre Machine-Learning-Modelle mit besserer Leistung und Effizienz zu optimieren und auszuführen. So können Sie die Rechenkosten minimieren, indem Sie Modelle automatisch für die Ausführung in Umgebungen wie AWS Inferentia-Chips optimieren.
+ [Automatische Skalierung von Amazon SageMaker AI-Modellen](endpoint-auto-scaling.md). Verwenden Sie Auto Scaling, um die Rechenressourcen für Ihre Endpunkte dynamisch an die Muster des eingehenden Datenverkehrs anzupassen. So können Sie Ihre Kosten optimieren, indem Sie nur für die Ressourcen bezahlen, die Sie zu einem bestimmten Zeitpunkt nutzen.
# Optionen der Modellbereitstellung in Amazon SageMaker AI
Nachdem Sie Ihr Machine-Learning-Modell trainiert haben, können Sie es mit Amazon SageMaker AI bereitstellen, um Prognosen zu erhalten. Amazon SageMaker AI unterstützt je nach Anwendungsfall die folgenden Möglichkeiten, ein Modell bereitzustellen:
+ Verwenden Sie für persistente Echtzeit-Endpunkte, die jeweils eine Vorhersage treffen, die Echtzeit-Hosting-Dienste von SageMaker AI. Siehe [Echtzeit-Inferenz](realtime-endpoints.md).
+ Für Workloads, bei denen es zwischen den einzelnen Verkehrsspitzen Leerlaufzeiten gibt und die Kaltstarts tolerieren können, sollten Sie Serverless Inference verwenden. Siehe [Bereitstellen von Modellen mit Amazon SageMaker Serverless Inference](serverless-endpoints.md).
+ Anfragen mit großen Nutzlasten von bis zu 1 GB, langen Verarbeitungszeiten und Latenzanforderungen nahezu in Echtzeit verwenden Amazon SageMaker Asynchronous Inference. Siehe [Asynchrone Inferenz-Inferenz](async-inference.md).
+ Um Prognosen für einen ganzen Datensatz zu erhalten, verwenden Sie die SageMaker-AI-Stapeltransformation. Siehe [Batch-Transformation für Inferenz mit Amazon AI SageMaker](batch-transform.md).
SageMaker AI bietet Funktionen zum Verwalten von Ressourcen und Optimieren der Inferenzleistung bei der Bereitstellung von Machine Learning (ML)-Modellen.
+ Informationen zur Verwaltung von Modellen auf Edge-Geräten, sodass Sie Machine-Learning-Modelle auf Flotten von Edge-Geräten optimieren, sichern, überwachen und verwalten können, finden Sie unter [Modellieren Sie die Bereitstellung am Netzwerkrand mit Edge Manager SageMaker](edge.md). Dies gilt für Edge-Geräte wie Smart-Kameras, Roboter, PCs und Mobilgeräte.
+ Wie Neo Gluon-, Keras-, MXNet-, PyTorch-, TensorFlow-, TensorFlow-Lite- und ONNX-Modelle automatisch für die Inferenz auf Android-, Linux- und Windows-Computern optimiert , die mit Prozessoren von Ambarella, ARM, Intel, Nvidia, NXP, Qualcomm, Texas Instruments und Xilinx arbeiten, finden Sie unter [Optimierung der Modellleistung mit SageMaker Neo](neo.md).
Weitere Informationen zu allen Bereitstellungsoptionen finden Sie unter [Modelle für Inference einsetzen](deploy-model.md).
# Machen Sie sich mit den Optionen für die Bereitstellung von Modellen und das Ableiten von Schlussfolgerungen in Amazon AI vertraut SageMaker
Um Ihnen den Einstieg in SageMaker KI Inference zu erleichtern, lesen Sie die folgenden Abschnitte, in denen Ihre Optionen für die Implementierung Ihres Modells in SageMaker KI und das Abrufen von Schlussfolgerungen erläutert werden. Abschnitt [Inferenzoptionen in Amazon AI SageMaker](deploy-model-options.md) kann Ihnen dabei helfen, herauszufinden, welches Feature für die Inferenz in Ihrem Anwendungsfall am besten geeignet ist.
[Ressourcen](inference-resources.md)In diesem Abschnitt finden Sie weitere Informationen zur Problembehandlung und Referenzinformationen, Blogs und Beispiele, die Ihnen den Einstieg erleichtern, sowie allgemeine Informationen. FAQs
**Topics**
+ [Bevor Sie beginnen](#deploy-model-prereqs)
+ [Schritte beim Modelleinsatz](#deploy-model-steps)
+ [Inferenzoptionen in Amazon AI SageMaker](deploy-model-options.md)
+ [Erweiterte Endpunktoptionen für Inferenz mit Amazon AI SageMaker](deploy-model-advanced.md)
+ [Die nächsten Schritte zur Inferenz mit Amazon AI SageMaker](deploy-model-next-steps.md)
## Bevor Sie beginnen
In diesen Themen wird davon ausgegangen, dass Sie ein oder mehrere Machine-Learning-Modelle erstellt und trainiert haben und bereit sind, sie bereitzustellen. Sie müssen Ihr Modell nicht in SageMaker KI trainieren, um Ihr Modell in SageMaker KI einzusetzen und daraus Schlüsse zu ziehen. Wenn Sie kein eigenes Modell haben, können Sie auch die [integrierten Algorithmen der SageMaker KI oder vortrainierte](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) Modelle verwenden.
Wenn Sie mit SageMaker KI noch nicht vertraut sind und noch kein Modell für die Implementierung ausgewählt haben, gehen Sie die Schritte im Tutorial [Erste Schritte mit Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html) durch. Machen Sie sich anhand des Tutorials damit vertraut, wie SageMaker KI den datenwissenschaftlichen Prozess verwaltet und wie sie mit der Modellbereitstellung umgeht. Weitere Informationen zum Trainieren eines Modells finden Sie unter [Modelle trainieren](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html).
Weitere Informationen, Referenzen und Beispiele finden Sie in der [Ressourcen](inference-resources.md).
## Schritte beim Modelleinsatz
Der allgemeine Arbeitsablauf für Inference-Endpunkte besteht aus den folgenden Schritten:
+ Erstellen Sie ein Modell in SageMaker AI Inference, indem Sie auf in Amazon S3 gespeicherte Modellartefakte und ein Container-Image verweisen.
+ Wählen Sie eine Inference-Option aus. Weitere Informationen finden Sie unter [Inferenzoptionen in Amazon AI SageMaker](deploy-model-options.md).
+ Erstellen Sie eine SageMaker AI Inference-Endpunktkonfiguration, indem Sie den Instance-Typ und die Anzahl der Instances auswählen, die Sie hinter dem Endpunkt benötigen. Sie können [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html) verwenden, um Empfehlungen für Instance-Typen zu erhalten. Für Serverless Inference brauchen Sie nur die Speicherkonfiguration anzugeben, die Sie bei Ihrer Modellgröße brauchen.
+ Erstellen Sie einen SageMaker AI Inference-Endpunkt.
+ Rufen Sie Ihren Endpunkt auf, um als Antwort eine Inference zu erhalten.
Das folgende Diagramm zeigt den vorangehenden Arbeitsablauf.
![\[Der im vorherigen Absatz beschriebene Arbeitsablauf zeigt, wie man Rückschlüsse aus SageMaker KI zieht.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference-workflow-flowchart.png)
Sie können diese Aktionen mit der AWS Konsole, dem AWS SDKs, dem SageMaker Python-SDK CloudFormation oder dem ausführen AWS CLI.
Für Batch-Inference mit Stapel-Transformation verweisen Sie auf Ihre Modellartefakte und Eingabedaten und erstellen Sie einen Batch-Inference-Auftrag. Anstatt einen Endpunkt für Inferenzen zu hosten, gibt SageMaker KI Ihre Schlussfolgerungen an einen Amazon S3 S3-Standort Ihrer Wahl aus.
# Inferenzoptionen in Amazon AI SageMaker
SageMaker KI bietet mehrere Inferenzoptionen, sodass Sie die Option auswählen können, die am besten zu Ihrer Arbeitslast passt:
+ [Echtzeit-Inferenz](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html): *Echtzeit-Inferenz* eignet sich ideal für Online-Inferences, die eine geringe Latenz oder einen hohen Durchsatz erfordern. Verwenden Sie Echtzeit-Inferenz für einen persistenten und vollständig verwalteten Endpunkt (REST API), der anhaltenden Datenverkehr verarbeiten kann, unterstützt durch den Instance-Typ Ihrer Wahl. Echtzeit-Inferenz kann Nutzdaten von bis zu 25 MB und Verarbeitungszeiten von 60 Sekunden für reguläre Antworten und 8 Minuten für Streaming-Antworten unterstützen.
+ [Serverlose Inferenz: *Serverlose Inferenz*](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html) ist ideal, wenn Sie intermittierende oder unvorhersehbare Datenverkehrsmuster haben. SageMaker KI verwaltet die gesamte zugrunde liegende Infrastruktur, sodass es nicht erforderlich ist, Instanzen oder Skalierungsrichtlinien zu verwalten. Sie bezahlen nur für das, was Sie tatsächlich nutzen und nicht für Leerlaufzeit. Unterstützt werden Nutzlasten bis 4 MB und Verarbeitungszeiten von bis zu 60 Sekunden.
+ [Batch-Transformation](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html): Die *Batch-Transformation* eignet sich für die Offline-Verarbeitung, wenn große Datenmengen im Voraus verfügbar sind und Sie keinen persistenten Endpunkt brauchen. Sie können die Batch-Transformation auch zum Vorverarbeiten von Datensätzen verwenden. Es kann große Datensätze unterstützen, deren GBs Größe und Verarbeitungszeiten mehrere Tage betragen.
+ [Asynchrone Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference.html): Die *Asynchrone Inference *eignet sich ideal, wenn Sie Anfragen in eine Warteschlange stellen möchten und große Nutzlasten mit langen Verarbeitungszeiten haben. Die asynchrone Inference unterstützt Nutzlasten bis 1 GB und lange Verarbeitungszeiten von bis zu einer Stunde. Sie können Ihren Endpunkt auch auf 0 herunterskalieren, wenn keine Anfragen verarbeitet werden müssen.
# Erweiterte Endpunktoptionen für Inferenz mit Amazon AI SageMaker
Mit Echtzeit-Inferenz können Sie mit Hilfe der folgenden erweiterten Inference-Optionen Leistung und Kosten weiter optimieren:
+ [Multimodell-Endpunkte](multi-model-endpoints.md) – Verwenden Sie diese Option, wenn Sie mehrere Modelle haben, die dasselbe Framework verwenden und einen Container gemeinsam nutzen können. Mit dieser Option können Sie die Kosten optimieren, indem sie die Auslastung der Endpunkte verbessert und den Bereitstellungsaufwand reduziert.
+ [Endpunkte mit mehreren Containern](multi-container-endpoints.md) – Verwenden Sie diese Option, wenn Sie mehrere Modelle haben, die unterschiedliche Frameworks verwenden und eigene Container brauchen. Sie profitieren von vielen Vorteilen von Multimodell-Endpunkten und können eine Vielzahl von Frameworks und Modellen einsetzen.
+ [Serielle Inferenz-Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) – Verwenden Sie diese Option, wenn Sie Modelle mit Vor- und Nachverarbeitungslogik hinter einem Endpunkt hosten möchten. Inferenz-Pipelines werden vollständig von SageMaker KI verwaltet und bieten eine geringere Latenz, da alle Container auf denselben Amazon EC2 EC2-Instances gehostet werden.
# Die nächsten Schritte zur Inferenz mit Amazon AI SageMaker
Sobald Sie einen Endpunkt haben und den allgemeinen Inferenz-Workflow verstanden haben, können Sie die folgenden Funktionen in SageMaker KI verwenden, um Ihren Inferenz-Workflow zu verbessern.
## Überwachen
Mit dem Model Monitor können Sie Ihr Modell im Lauf der Zeit anhand von Kennzahlen wie Modellgenauigkeit und Modellabweichung verfolgen. Mit dem Model Monitor können Sie Warnmeldungen einrichten, die Sie benachrichtigen, wenn es in der Qualität Ihres Modells zu Abweichungen kommt. Weitere Informationen finden Sie in der [Dokumentation zum Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html).
Weitere Informationen zu Tools, mit denen Sie Modellbereitstellungen und Ereignisse, die Ihren Endpunkt ändern, überwachen können, finden Sie unter [Amazon SageMaker AI überwachen](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html). Sie können beispielsweise den Zustand Ihres Endpunkts anhand von Kennzahlen wie Aufruffehlern und Modelllatenz mithilfe von CloudWatch Amazon-Metriken überwachen. Die [Kennzahlen zum Aufrufen von SageMaker KI-Endpunkten](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation) können Ihnen wertvolle Informationen über die Leistung Ihres Endpunkts liefern.
## CI/CD für den Modelleinsatz
Um Lösungen für maschinelles Lernen in SageMaker KI zusammenzustellen, können Sie [SageMaker KI MLOps](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects.html) verwenden. Mit HIlfe dieser Funktion können Sie die Schritte in Ihrem Workflow für Machine Learning automatisieren und CI/CD üben. Sie können [MLOps Projektvorlagen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-templates.html) verwenden, um bei der Einrichtung und Implementierung von SageMaker MLOps KI-Projekten zu helfen. SageMaker AI unterstützt auch die Verwendung Ihres eigenen [Git-Repositorys eines Drittanbieters](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-walkthrough-3rdgit.html) zum Erstellen eines CI/CD Systems.
Mit [Model Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html) für Ihre ML-Pipelines können Sie Ihre Modellversionen sowie die Bereitstellung und Automatisierung Ihrer Modelle verwalten.
## Leitlinien für den Einsatz
Wenn Sie Ihr Modell bei laufender Produktion aktualisieren möchten, ohne die Produktion zu beeinträchtigen, können Sie Leitlinien für den Einsatz verwenden. Bei Deployment Guardrails handelt es sich um eine Reihe von Optionen zur Modellbereitstellung in SageMaker AI Inference, mit denen Sie Ihre Modelle für maschinelles Lernen in der Produktion aktualisieren können. Mithilfe der vollständig verwalteten Bereitstellungsoptionen können Sie die Umstellung vom aktuellen Modell in der Produktion auf ein neues steuern. Die Betriebsarten zur Verlagerung des Datenverkehrs geben Ihnen die detaillierte Kontrolle über Verlagerung des Datenverkehrs, und integrierte Sicherheitsvorkehrungen wie automatisches Rollback helfen Ihnen dabei, Probleme frühzeitig zu erkennen.
Weitere Informationen zu Leitlinien für den Einsatz finden Sie in der Dokumentation zu [Leitlinien für den Einsatz](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails.html).
## Inferentia
Wenn Sie umfangreiche Anwendungen für Machine Learning und Deep Learning ausführen müssen, können Sie eine `Inf1`-Instance mit einem Echtzeitendpunkt verwenden. Dieser Instance-Typ eignet sich für Anwendungsfälle wie Bild- oder Spracherkennung, natürliche Sprachverarbeitung (NLP), Personalisierung, Prognose oder Betrugserkennung.
`Inf1`Instances wurden zur Unterstützung von Inferenzanwendungen für maschinelles Lernen entwickelt und verfügen über die Inferentia-Chips. AWS `Inf1`Instances bieten einen höheren Durchsatz und niedrigere Kosten pro Inferenz als GPU-basierte Instances.
Um ein Modell auf `Inf1` Instances bereitzustellen, kompilieren Sie Ihr Modell mit SageMaker Neo und wählen Sie eine `Inf1` Instanz für Ihre Bereitstellungsoption. Weitere Informationen finden Sie unter [Optimieren der Modellleistung mit SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
## Optimierung der Modellleistung
SageMaker KI bietet Funktionen zur Verwaltung von Ressourcen und zur Optimierung der Inferenzleistung bei der Bereitstellung von Modellen für maschinelles Lernen. Sie können die [integrierten Algorithmen und vorgefertigten Modelle von SageMaker KI sowie vorgefertigte](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) [Docker-Images](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html) verwenden, die für maschinelles Lernen entwickelt wurden.
Informationen zum Trainieren von Modellen und deren Optimierung für den Einsatz finden Sie unter [Vordefinierte Docker-Images](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html) [Optimieren](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) Sie die Modellleistung mit Neo. SageMaker Mit SageMaker Neo können Sie Apache TensorFlow MXNet PyTorch, ONX und Modelle trainieren. XGBoost Anschließend können Sie sie optimieren und auf ARM-, Intel- und Nvidia-Prozessoren einsetzen.
## Auto Scaling
Wenn der Datenverkehr zu Ihren Endpunkten variiert, sollten Sie vielleicht Auto-Scaling ausprobieren. Beispielsweise benötigen Sie zu Spitzenzeiten eventuell mehr Instances, um Anfragen zu verarbeiten. In Zeiten mit geringem Datenverkehr möchten Sie jedoch vielleicht die Auslastung Ihrer Datenverarbeitungsressourcen reduzieren. Für Informationen zum dynamischen Anpassen der Anzahl der bereitgestellten Instances als Reaktion auf Änderungen der Workload siehe [Automatische Skalierung von Amazon SageMaker AI-Modellen](endpoint-auto-scaling.md).
Wenn Sie unvorhersehbare Datenverkehrsmuster haben oder keine Skalierungsrichtlinien einrichten möchten, können Sie Serverless Inference auch für einen Endpunkt verwenden. Anschließend verwaltet SageMaker KI die automatische Skalierung für Sie. In Zeiten mit geringem Datenverkehr skaliert SageMaker KI Ihren Endpunkt nach unten, und wenn der Verkehr zunimmt, skaliert SageMaker KI Ihren Endpunkt nach oben. Weitere Informationen finden Sie in der Dokumentation zu [Bereitstellen von Modellen mit Amazon SageMaker Serverless Inference](serverless-endpoints.md).
# Erstellen Sie ein Modell in Amazon SageMaker AI mit ModelBuilder
Die Vorbereitung Ihres Modells für die Bereitstellung auf einem SageMaker KI-Endpunkt erfordert mehrere Schritte, darunter die Auswahl eines Modell-Images, die Einrichtung der Endpunktkonfiguration, die Codierung Ihrer Serialisierungs- und Deserialisierungsfunktionen für die Übertragung von Daten zu und von Server und Client, die Identifizierung von Modellabhängigkeiten und deren Upload auf Amazon S3. `ModelBuilder`kann die Komplexität der Ersteinrichtung und Bereitstellung reduzieren, sodass Sie in einem einzigen Schritt ein einsatzfähiges Modell erstellen können.
`ModelBuilder` führt die folgenden Aufgaben für Sie aus:
+ Konvertiert Modelle für maschinelles Lernen, die mit verschiedenen Frameworks wie XGBoost oder trainiert wurden, PyTorch in einem Schritt in einsatzfähige Modelle.
+ Führt eine automatische Containerauswahl auf der Grundlage des Modell-Frameworks durch, sodass Sie Ihren Container nicht manuell angeben müssen. Sie können trotzdem Ihren eigenen Container verwenden, indem Sie Ihren eigenen URI an `ModelBuilder` übergeben.
+ Verwaltet die Serialisierung von Daten auf Clientseite, bevor sie zur Inferenz und Deserialisierung der vom Server zurückgegebenen Ergebnisse an den Server gesendet werden. Die Daten werden ohne manuelle Verarbeitung korrekt formatiert.
+ Ermöglicht die automatische Erfassung von Abhängigkeiten und verpackt das Modell entsprechend den Erwartungen des Modellservers. Die automatische Erfassung von Abhängigkeiten durch `ModelBuilder` ist ein Best-Effort-Ansatz, um Abhängigkeiten dynamisch zu laden. (Wir empfehlen, die automatische Erfassung lokal zu testen und die Abhängigkeiten an Ihre Bedürfnisse anzupassen.)
+ Führt für Anwendungsfälle mit großen Sprachmodellen (LLM) optional eine lokale Parameteroptimierung der Servereigenschaften durch, die für eine bessere Leistung beim Hosten auf einem SageMaker KI-Endpunkt bereitgestellt werden können.
+ Unterstützt die meisten gängigen Modellserver und Container wie TorchServe Triton DJLServing und TGI Container.
## Erstellen Sie Ihr Modell mit ModelBuilder
`ModelBuilder`ist eine Python-Klasse, die ein Framework-Modell wie XGBoost oder oder oder PyTorch eine benutzerdefinierte Inferenzspezifikation verwendet und es in ein bereitstellbares Modell konvertiert. `ModelBuilder`stellt eine Build-Funktion bereit, die die Artefakte für die Bereitstellung generiert. Das generierte Modellartefakt ist spezifisch für den Modellserver, den Sie auch als eine der Eingaben angeben können. Weitere Informationen zur `ModelBuilder` Klasse finden Sie unter [ModelBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.model_builder.ModelBuilder).
Das folgende Diagramm veranschaulicht den gesamten Workflow bei der Modellerstellung unter Verwendung von `ModelBuilder`. `ModelBuilder` akzeptiert eine Modell oder eine Inferenzspezifikation zusammen mit Ihrem Schema, um ein bereitstellbares Modell zu erstellen, das Sie vor der Bereitstellung lokal testen können.
![\[Ablauf der Modellerstellung und -bereitstellung unter Verwendung von ModelBuilder\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-builder-flow.png)
`ModelBuilder` kann jede Anpassung vornehmen, die Sie anwenden möchten. Um ein Framework-Modell bereitzustellen, erwartet der Model Builder jedoch mindestens ein Modell, eine Beispieleingabe und -ausgabe sowie die Rolle. Im folgenden Codebeispiel wird `ModelBuilder` mit einem Framework-Modell und einer Instance von `SchemaBuilder` mit minimalen Argumenten aufgerufen (um die entsprechenden Funktionen für die Serialisierung und Deserialisierung der Endpunkteingabe und -ausgabe abzuleiten). Es ist kein Container angegeben und es werden keine Paketabhängigkeiten übergeben — SageMaker KI leitet diese Ressourcen automatisch ab, wenn Sie Ihr Modell erstellen.
```
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
model_builder = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(input, output),
role_arn="execution-role",
)
```
Im folgenden Codebeispiel wird `ModelBuilder` mit einer Inferenzspezifikation (als `InferenceSpec`-Instance) statt mit einem Modell aufgerufen und bietet zusätzliche Anpassungen. In diesem Fall beinhaltet der Aufruf von Model Builder einen Pfad zum Speichern von Modellartefakten und aktiviert außerdem die automatische Erfassung aller verfügbaren Abhängigkeiten. Weitere Informationen zu `InferenceSpec` finden Sie unter [Anpassen des Ladens von Modellen und der Bearbeitung von Anforderungen](#how-it-works-modelbuilder-creation-is).
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": True}
)
```
## Definieren von Serialisierungs- und Deserialisierungsmethoden
Beim Aufrufen eines SageMaker KI-Endpunkts werden die Daten über HTTP-Payloads mit unterschiedlichen MIME-Typen gesendet. Beispielsweise muss ein Bild, das zur Inferenz an den Endpunkt gesendet wird, auf Clientseite in Byte konvertiert und über eine HTTP-Nutzlast an den Endpunkt gesendet werden. Wenn der Endpunkt die Nutzlast empfängt, muss er die Byte-Zeichenfolge wieder auf den Datentyp deserialisieren, der vom Modell erwartet wird (auch als serverseitige Deserialisierung bezeichnet). Nachdem das Modell die Vorhersage abgeschlossen hat, müssen die Ergebnisse auch in Byte serialisiert werden, die über die HTTP-Nutzlast an den Benutzer oder den Client zurückgesendet werden können. Sobald der Client die Antwort-Bytedaten erhalten hat, muss er eine clientseitige Deserialisierung durchführen, um die Bytedaten wieder in das erwartete Datenformat wie beispielsweise JSON zu konvertieren. Sie müssen die Daten mindestens für Folgendes konvertieren:
1. Serialisierung der Inferenzanforderung (durchgeführt vom Client)
1. Deserialisierung der Inferenzanforderung (durchgeführt vom Server oder Algorithmus)
1. Aufrufen des Modells für die Nutzlast und Zurücksenden der Antwort-Nutzlast
1. Serialisierung der Inferenzantwort (durchgeführt vom Server oder Algorithmus)
1. Deserialisierung der Inferenzantwort (durchgeführt vom Client)
Das folgende Diagramm zeigt die Serialisierungs- und Deserialisierungsprozesse, die beim Aufrufen des Endpunkts ablaufen.
![\[Diagramm der Serialisierung und Deserialisierung von Client-zu-Server-Daten\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-builder-serialization.png)
Wenn Sie eine Beispieleingabe und -ausgabe für `SchemaBuilder` bereitstellen, generiert der Schema Builder die entsprechenden Marshalling-Funktionen für die Serialisierung und Deserialisierung der Eingabe und Ausgabe. Sie können Ihre Serialisierungsfunktionen mit `CustomPayloadTranslator` weiter anpassen. In den meisten Fällen würde jedoch ein einfacher Serializer wie der folgende funktionieren:
```
input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)
```
Weitere Informationen dazu finden Sie unter`SchemaBuilder`. [SchemaBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.schema_builder.SchemaBuilder)
Der folgende Codeausschnitt veranschaulicht ein Beispiel, in dem Sie sowohl die Serialisierungs- als auch die Deserialisierungsfunktionen auf Client- und Serverseite anpassen möchten. Sie können Ihre eigenen Anforderung- und Antwortübersetzer mit `CustomPayloadTranslator` definieren und diese Übersetzer an `SchemaBuilder` übergeben.
Durch die Zusammenführung von Ein- und Ausgaben mit den Übersetzern kann der Model Builder das Datenformat extrahieren, das das Modell erwartet. Nehmen wir beispielsweise an, dass es sich bei der Beispieleingabe um ein Rohbild handelt und Ihre benutzerdefinierten Übersetzer das Bild zuschneiden und das zugeschnittene Bild als Tensor an den Server senden. `ModelBuilder` benötigt sowohl die Roheingabe als auch jeglichen benutzerdefinierten Vorverarbeitungs- oder Nachbearbeitungscode, um eine Methode zur Konvertierung von Daten sowohl auf Client- als auch auf Serverseite abzuleiten.
```
from sagemaker.serve import CustomPayloadTranslator
# request translator
class MyRequestTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on client side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the input payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on server side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
# response translator
class MyResponseTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on server side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the response payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on client side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
```
Sie übergeben die Beispieleingabe und -ausgabe zusammen mit den zuvor definierten benutzerdefinierten Übersetzern, wenn Sie das `SchemaBuilder`-Objekt erstellen, wie im folgenden Beispiel gezeigt:
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
Anschließend übergeben Sie die Beispieleingabe und -ausgabe zusammen mit den zuvor definierten benutzerdefinierten Übersetzern an das `SchemaBuilder`-Objekt.
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
In den folgenden Abschnitten wird detailliert erklärt, wie Sie Ihr Modell mit `ModelBuilder` erstellen und die unterstützenden Klassen verwenden, um das Erlebnis an Ihren Anwendungsfall anzupassen.
**Topics**
+ [Erstellen Sie Ihr Modell mit ModelBuilder](#how-it-works-modelbuilder-creation-mb)
+ [Definieren von Serialisierungs- und Deserialisierungsmethoden](#how-it-works-modelbuilder-creation-sb)
+ [Anpassen des Ladens von Modellen und der Bearbeitung von Anforderungen](#how-it-works-modelbuilder-creation-is)
+ [Erstellen und Bereitstellen Ihres Modells](#how-it-works-modelbuilder-creation-deploy)
+ [Verwendung Ihres eigenen Containers (BYOC)](#how-it-works-modelbuilder-creation-mb-byoc)
+ [Verwendung ModelBuilder im lokalen Modus](#how-it-works-modelbuilder-creation-local)
+ [ModelBuilder Beispiele](#how-it-works-modelbuilder-creation-example)
## Anpassen des Ladens von Modellen und der Bearbeitung von Anforderungen
Die Bereitstellung Ihres eigenen Inferenzcodes über `InferenceSpec` bietet eine zusätzliche Anpassungsebene. Mit `InferenceSpec` können Sie anpassen, wie das Modell geladen wird und wie es eingehende Inferenzanforderungen verarbeitet, wobei Sie die standardmäßigen Mechanismen zum Laden und Bearbeiten von Inferenzen umgehen. Diese Flexibilität ist besonders vorteilhaft, wenn Sie mit nicht standardmäßigen Modellen oder benutzerdefinierten Inferenz-Pipelines arbeiten. Sie können die `invoke`-Methode anpassen, um zu steuern, wie das Modell eingehende Anforderungen vor- und nachverarbeitet. Die `invoke`-Methode stellt sicher, dass das Modell Inferenzanforderungen korrekt verarbeitet. Das folgende Beispiel wird verwendet`InferenceSpec`, um ein Modell mit der HuggingFace Pipeline zu generieren. Weitere Informationen zu `InferenceSpec` finden Sie in der [InferenceSpec](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.spec.inference_spec.InferenceSpec).
```
from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline
class MyInferenceSpec(InferenceSpec):
def load(self, model_dir: str):
return pipeline("translation_en_to_fr", model="t5-small")
def invoke(self, input, model):
return model(input)
inf_spec = MyInferenceSpec()
model_builder = ModelBuilder(
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(X_test, y_pred)
)
```
Das folgende Beispiel zeigt eine angepasste Variante eines vorherigen Beispiels. Ein Modell wird mit einer Inferenzspezifikation definiert, die Abhängigkeiten aufweist. In diesem Fall ist der Code in der Inferenzspezifikation vom *lang-segment*-Paket abhängig. Das Argument for `dependencies` enthält eine Anweisung, die den Builder anweist, *lang-segment* mit Git zu installieren. Da der Model Builder vom Benutzer zur benutzerdefinierten Installation einer Abhängigkeit angewiesen wird, ist der `auto`-Schlüssel auf `False` festgelegt, um die automatische Erfassung von Abhängigkeiten zu deaktivieren.
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": False, "custom": ["-e git+https://github.com/luca-medeiros/lang-segment-anything.git#egg=lang-sam"],}
)
```
## Erstellen und Bereitstellen Ihres Modells
Rufen Sie die `build`-Funktion auf, um Ihr bereitstellbares Modell zu erstellen. Dieser Schritt erstellt den Inferenzcode (als `inference.py`) in Ihrem Arbeitsverzeichnis mit dem Code, der zum Erstellen Ihres Schemas, zum Ausführen der Serialisierung und Deserialisierung von Eingaben und Ausgaben sowie zum Ausführen anderer benutzerdefinierter Logik erforderlich ist.
Zur Integritätsprüfung packt SageMaker AI die für die Bereitstellung im Rahmen der `ModelBuilder` Build-Funktion erforderlichen Dateien und wählt sie aus. Während dieses Vorgangs erstellt SageMaker KI auch eine HMAC-Signatur für die Pickle-Datei und fügt den geheimen Schlüssel während `deploy` (oder) als Umgebungsvariable in die [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API ein. `create` Beim Starten des Endpunkts wird die Umgebungsvariable verwendet, um die Integrität der Pickle-Datei zu überprüfen.
```
# Build the model according to the model server specification and save it as files in the working directory
model = model_builder.build()
```
Stellen Sie Ihr Modell mit der vorhandenen `deploy`-Methode des Modells bereit. In diesem Schritt richtet SageMaker KI einen Endpunkt ein, auf dem Ihr Modell gehostet wird, während es anfängt, Vorhersagen über eingehende Anfragen zu treffen. `ModelBuilder` leitet zwar die Endpunktressourcen ab, die für die Bereitstellung Ihres Modells benötigt werden, Sie können diese Schätzungen jedoch mit Ihren eigenen Parameterwerten überschreiben. Das folgende Beispiel weist SageMaker KI an, das Modell auf einer einzigen `ml.c6i.xlarge` Instanz bereitzustellen. Ein Modell, das auf `ModelBuilder` basiert, ermöglicht als zusätzliche Funktion die Live-Protokollierung während der Bereitstellung.
```
predictor = model.deploy(
initial_instance_count=1,
instance_type="ml.c6i.xlarge"
)
```
Wenn Sie eine genauere Kontrolle über die Ihrem Modell zugewiesenen Endpunktressourcen wünschen, können Sie ein `ResourceRequirements`-Objekt verwenden. Mit dem `ResourceRequirements` Objekt können Sie eine Mindestanzahl von CPUs Beschleunigern und Kopien von Modellen anfordern, die Sie bereitstellen möchten. Sie können auch eine Mindest- und Höchstmenge an Arbeitsspeicher (in MB) anfordern. Um dieses Feature verwenden zu können, müssen Sie Ihren Endpunkttyp als`EndpointType.INFERENCE_COMPONENT_BASED` angeben. Im folgenden Beispiel müssen vier Beschleuniger, eine Mindestspeichergröße von 1024 MB und eine Kopie Ihres Modells auf einem Endpunkt des Typs `EndpointType.INFERENCE_COMPONENT_BASED` bereitgestellt werden.
```
resource_requirements = ResourceRequirements(
requests={
"num_accelerators": 4,
"memory": 1024,
"copies": 1,
},
limits={},
)
predictor = model.deploy(
mode=Mode.SAGEMAKER_ENDPOINT,
endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED,
resources=resource_requirements,
role="role"
)
```
## Verwendung Ihres eigenen Containers (BYOC)
Wenn Sie Ihren eigenen Container (erweitert von einem SageMaker AI-Container) mitbringen möchten, können Sie auch den Bild-URI angeben, wie im folgenden Beispiel gezeigt. Sie müssen auch den Modellserver identifizieren, der dem Image entspricht, damit `ModelBuilder` Artefakte generiert, die für den Modellserver spezifisch sind.
```
model_builder = ModelBuilder(
model=model,
model_server=ModelServer.TORCHSERVE,
schema_builder=SchemaBuilder(X_test, y_pred),
image_uri="123123123123.dkr.ecr.ap-southeast-2.amazonaws.com/byoc-image:xgb-1.7-1")
)
```
## Verwendung ModelBuilder im lokalen Modus
Sie können Ihr Modell lokal bereitstellen, indem Sie das `mode`-Argument verwenden, um zwischen lokalen Tests und der Bereitstellung auf einem Endpunkt zu wechseln. Sie müssen die Modellartefakte im Arbeitsverzeichnis speichern, wie im folgenden Codeausschnitt dargestellt:
```
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")
```
Übergeben Sie das Modellobjekt, eine `SchemaBuilder`-Instance, und setzen Sie den Modus auf `Mode.LOCAL_CONTAINER`. Wenn Sie die `build`-Funktion aufrufen, identifiziert `ModelBuilder` automatisch den unterstützten Framework-Container und sucht nach Abhängigkeiten. Das folgende Beispiel zeigt die Modellerstellung mit einem XGBoost Modell im lokalen Modus.
```
model_builder_local = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(X_test, y_pred),
role_arn=execution-role,
mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()
```
Rufen Sie die `deploy`-Funktion für die lokale Bereitstellung auf, wie im folgenden Codeausschnitt dargestellt. Wenn Sie Parameter für Instance-Typ oder -Anzahl Parameter angeben, werden diese Argumente ignoriert.
```
predictor_local = xgb_local_builder.deploy()
```
### Fehlerbehebung für den lokalen Modus
Abhängig von Ihrer individuellen lokalen Konfiguration können Probleme beim Betrieb von `ModelBuilder` in Ihrer Umgebung auftreten. In der folgenden Liste finden Sie einige Probleme, mit denen Sie möglicherweise konfrontiert werden, und Informationen zu deren Behebung.
+ **Wird bereits verwendet**: Möglicherweise ist ein `Address already in use`-Fehler aufgetreten. In diesem Fall ist es möglich, dass ein Docker-Container auf diesem Port läuft oder ein anderer Prozess ihn verwendet. Sie können dem in der [Linux-Dokumentation](https://www.cyberciti.biz/faq/what-process-has-open-linux-port/) beschriebenen Ansatz folgen, um den Prozess zu identifizieren und Ihren lokalen Prozess ordnungsgemäß von Port 8080 auf einen anderen Port umzuleiten oder die Docker-Instance zu bereinigen.
+ **IAM-Berechtigungsproblem**: Möglicherweise tritt ein Berechtigungsproblem auf, wenn Sie versuchen, ein Amazon-ECR-Image abzurufen oder auf Amazon S3 zuzugreifen. Navigieren Sie in diesem Fall zur Ausführungsrolle der Notebook- oder Studio-Classic-Instance, um die Richtlinie für `SageMakerFullAccess` oder die entsprechenden API-Berechtigungen zu überprüfen.
+ **Problem mit der EBS-Volumenkapazität**: Wenn Sie ein großes Sprachmodell (LLM) bereitstellen, geht Ihnen möglicherweise der Speicherplatz aus, während Sie Docker im lokalen Modus ausführen, oder es kommt zu Speicherbeschränkungen für den Docker-Cache. In diesem Fall können Sie versuchen, Ihr Docker-Volume in ein Dateisystem zu verschieben, das über ausreichend Speicherplatz verfügt. Führen Sie die folgenden Schritte aus, um Ihr Docker-Volume zu verschieben:
1. Öffnen Sie ein Terminal und führen Sie `df` aus, um die Festplattennutzung anzuzeigen, wie in der folgenden Ausgabe gezeigt:
```
(python3) sh-4.2$ df
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 195928700 0 195928700 0% /dev
tmpfs 195939296 0 195939296 0% /dev/shm
tmpfs 195939296 1048 195938248 1% /run
tmpfs 195939296 0 195939296 0% /sys/fs/cgroup
/dev/nvme0n1p1 141545452 135242112 6303340 96% /
tmpfs 39187860 0 39187860 0% /run/user/0
/dev/nvme2n1 264055236 76594068 176644712 31% /home/ec2-user/SageMaker
tmpfs 39187860 0 39187860 0% /run/user/1002
tmpfs 39187860 0 39187860 0% /run/user/1001
tmpfs 39187860 0 39187860 0% /run/user/1000
```
1. Verschieben Sie das Docker-Standardverzeichnis von `/dev/nvme0n1p1` nach, `/dev/nvme2n1` damit Sie das 256 GB SageMaker AI-Volume voll ausnutzen können. Weitere Informationen finden Sie in der Dokumentation zum [Verschieben Ihres Docker-Verzeichnisses](https://www.guguweb.com/2019/02/07/how-to-move-docker-data-directory-to-another-location-on-ubuntu/).
1. Stoppen Sie Docker mit dem folgenden Befehl:
```
sudo service docker stop
```
1. Fügen Sie `daemon.json` zu `/etc/docker` hinzu oder hängen Sie den folgenden JSON-Blob an den vorhandenen an.
```
{
"data-root": "/home/ec2-user/SageMaker/{created_docker_folder}"
}
```
1. Verschieben Sie das Docker-Verzeichnis `/var/lib/docker` mit dem folgenden Befehl nach `/home/ec2-user/SageMaker AI`:
```
sudo rsync -aP /var/lib/docker/ /home/ec2-user/SageMaker/{created_docker_folder}
```
1. Starten Sie den Docker mit dem folgenden Befehl:
```
sudo service docker start
```
1. Reinigen Sie den Papierkorb mit dem folgenden Befehl:
```
cd /home/ec2-user/SageMaker/.Trash-1000/files/*
sudo rm -r *
```
1. Wenn Sie eine SageMaker Notebook-Instanz verwenden, können Sie die Schritte in der [Docker-Vorbereitungsdatei befolgen, um Docker](https://github.com/melanie531/amazon-sagemaker-pytorch-lightning-distributed-training/blob/main/prepare-docker.sh) für den lokalen Modus vorzubereiten.
## ModelBuilder Beispiele
Weitere Beispiele für die Verwendung `ModelBuilder` beim Erstellen Ihrer Modelle finden Sie unter [ModelBuilderBeispielnotizbücher](https://github.com/aws-samples/sagemaker-hosting/blob/main/SageMaker-Model-Builder).
# Inferenzoptimierung für Modelle von Amazon SageMaker AI
Mit Amazon SageMaker AI können Sie die Leistung Ihrer Modelle mit generativer KI verbessern, indem Sie Techniken zur Inferenzoptimierung anwenden. Durch die Optimierung Ihrer Modelle können Sie ein besseres Preis-Leistungs-Verhältnis für Ihren Anwendungsfall erzielen. Wenn Sie ein Modell optimieren, wählen Sie aus, welche der unterstützten Optimierungstechniken angewendet werden sollen, einschließlich Quantisierung, spekulativer Dekodierung und Kompilierung. Nachdem Ihr Modell optimiert wurde, können Sie eine Bewertung durchführen, um Leistungsmetriken für Latenz, Durchsatz und Preis einzusehen.
Für viele Modelle bietet SageMaker AI auch mehrere voroptimierte Versionen, die auf unterschiedliche Anwendungsanforderungen in Bezug auf Latenz und Durchsatz zugeschnitten sind. Bei diesen Modellen können Sie eine der optimierten Versionen bereitstellen, ohne das Modell zuerst selbst zu optimieren.
## Optimierungsmethoden
Amazon SageMaker AI unterstützt die folgenden Optimierungsmethoden.
### Kompilierung
Durch die *Kompilierung* wird das Modell für die beste verfügbare Leistung auf dem ausgewählten Hardwaretyp optimiert, ohne dass die Genauigkeit darunter leidet. Sie können die Modellkompilierung anwenden, um LLMs für beschleunigte Hardware wie GPU-Instances, AWS-Trainium-Instances oder AWS-Inferentia-Instances zu optimieren.
Wenn Sie ein Modell anhand von Kompilierung optimieren, profitieren Sie von einer frühzeitigen Kompilierung. Sie reduzieren die Bereitstellungszeit des Modells und die Auto-Scaling-Latenz, da die Modellgewichtungen keine Just-in-Time-Kompilierung erfordern, wenn das Modell auf einer neuen Instance bereitgestellt wird.
Wenn Sie Ihr Modell für eine GPU-Instance kompilieren möchten, verwendet SageMaker AI die TensorRT-LLM-Bibliothek, um die Kompilierung auszuführen. Wenn Sie Ihr Modell für eine AWS-Trainium- oder AWS-Inferentia-Instance kompilieren möchten, verwendet SageMaker AI das AWS Neuron SDK, um die Kompilierung auszuführen.
### Quantisierung
Die *Quantisierung* ist eine Methode zur Reduzierung der Hardwareanforderungen eines Modells, indem ein weniger genauer Datentyp für Gewichtungen und Aktivierungen verwendet wird. Nachdem Sie ein Modell anhand der Quantisierung optimiert haben, können Sie es auf kostengünstigeren und besser verfügbaren GPUs hosten. Das quantisierte Modell ist jedoch möglicherweise weniger genau als das ursprüngliche Modell, das Sie optimiert haben.
Die Datenformate, die SageMaker AI für die Quantisierung unterstützt, variieren von Modell zu Modell. Folgende Formate werden unterstützt:
+ INT4-AWQ – Ein 4-Bit-Datenformat. Activation-aware Weight Quantization (AWQ) ist eine effiziente, genaue und auf die Gewichtung beschränkte Quantisierungsmethode für LLMs mit geringer Bitzahl.
+ FP8 – Das 8-Bit-Gleitkommaformat (FP8) ist ein Format mit niedriger Genauigkeit für Gleitkommazahlen. Es sorgt für ein ausgewogenes Verhältnis zwischen Speichereffizienz und Modellgenauigkeit, indem es Werte mit weniger Bits als das Standard-FP16-Gleitkommaformat darstellt.
+ int8-SmoothQuant – Ein 8-Bit-Datenformat. SmoothQuant ist eine Quantisierungsmethode mit gemischter Präzision, die Aktivierungen und Gewichtungen gemeinsam skaliert, indem ihre Dynamikbereiche ausgeglichen werden.
### Spekulative Dekodierung
Die *spekulative Dekodierung* ist eine Methode, um den Dekodierungsprozess großer LLMs zu beschleunigen. Sie optimiert Modelle im Hinblick auf die Latenz, ohne die Qualität des generierten Textes zu beeinträchtigen.
Bei dieser Methode wird ein kleineres, aber schnelleres Modell verwendet, das als *Entwurfsmodell* bezeichnet wird. Das Entwurfsmodell generiert Kandidaten-Token, die dann durch das größere, aber langsamere *Zielmodell* validiert werden. Bei jeder Iteration generiert das Entwurfsmodell mehrere Kandidaten-Token. Das Zielmodell überprüft die Token und wenn es feststellt, dass ein bestimmtes Token nicht akzeptabel ist, lehnt es das Token ab und generiert es neu. Das Zielmodell verifiziert also Token und generiert eine kleine Anzahl von Token.
Das Entwurfsmodell ist deutlich schneller als das Zielmodell. Es generiert alle Token schnell und sendet sie stapelweise zur Überprüfung an das Zielmodell. Das Zielmodell wertet sie alle parallel aus, was die endgültige Antwort beschleunigt.
SageMaker AI bietet einen vorgefertigten Modellentwurf, den Sie verwenden können, um kein eigenes Modell erstellen zu müssen. Wenn Sie lieber Ihr eigenes benutzerdefiniertes Entwurfsmodell verwenden möchten, unterstützt SageMaker AI jedoch auch diese Option.
### Schnelles Laden von Modellen
Die Methode zum *schnellen Laden von Modellen* bereitet ein LLM so vor, dass SageMaker AI es schneller auf eine ML-Instance laden kann.
Um das Modell vorzubereiten, fragmentiert SageMaker AI es im Voraus, indem es das Modell in Teile unterteilt, die sich jeweils auf einer separaten GPU befinden können, um verteilte Inferenzen zu ermöglichen. Außerdem speichert SageMaker AI die Modellgewichte in gleich großen Blöcken, die SageMaker AI gleichzeitig auf die Instance laden kann.
Wenn SageMaker AI das optimierte Modell auf die Instance lädt, streamt es die Modellgewichte direkt von Amazon S3 auf die GPUs der Instance. Durch das Streamen der Gewichte entfallen bei SageMaker AI mehrere zeitaufwändige Schritte, die normalerweise notwendig sind. Zu diesen Schritten gehören das Herunterladen der Modellartefakte von Amazon S3 auf die Festplatte, das Laden der Modellartefakte in den Host-Speicher und das Fragmentieren des Modells auf dem Host, bevor die Shards schließlich auf die GPUs geladen werden.
Nachdem Sie Ihr Modell für das schnellere Laden optimiert haben, können Sie es schneller auf einem SageMaker-AI-Endpunkt bereitstellen. Wenn Sie den Endpunkt für die Verwendung von Auto Scaling konfigurieren, wird er außerdem schneller aufskaliert, um dem Anstieg des Datenverkehrs Rechnung zu tragen.
# Bereitstellen eines voroptimierten Modells
Einige Modelle in JumpStart sind von SageMaker AI voroptimiert, was bedeutet, dass Sie optimierte Versionen dieser Modelle bereitstellen können, ohne zuvor einen Inferenzoptimierungsjob zu erstellen.
Eine Liste der Modelle mit voroptimierten Optionen finden Sie unter [Voroptimierte JumpStart-Modelle](#pre-optimized-js).
## Wählen Sie Amazon SageMaker Studio
Gehen Sie wie folgt vor, um ein voroptimiertes JumpStart-Modell mit Amazon SageMaker Studio bereitzustellen.
**So stellen Sie ein voroptimiertes Modell bereit**
1. Wählen Sie in Studio im Navigationsmenü links **JumpStart** aus.
1. Wählen Sie auf der Seite **Alle öffentlichen Modelle** eines der voroptimierten Modelle aus.
1. Wählen Sie auf der Modelldetailseite die Option **Bereitstellen** aus.
1. Auf der Bereitstellungsseite müssen Sie bei einigen JumpStart-Modellen eine Endbenutzer-Lizenzvereinbarung (EULA) unterzeichnen, bevor Sie fortfahren können. Falls Sie dazu aufgefordert werden, lesen Sie die Lizenzbedingungen im Abschnitt **Lizenzvereinbarung**. Wenn die Bedingungen für Ihren Anwendungsfall akzeptabel sind, aktivieren Sie das Kontrollkästchen **Ich akzeptiere die EULA und habe die allgemeinen Geschäftsbedingungen gelesen**.
Weitere Informationen finden Sie unter [Endbenutzer-Lizenzvereinbarungen](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. Unter **Endpunktname** und **Anfängliche Instance-Anzahl** können sie entweder die Standardwerte übernehmen oder benutzerdefinierte Werte festlegen.
1. Behalten Sie als **Instance-Typ** den Standardwert bei. Andernfalls können Sie keine voroptimierte Konfiguration bereitstellen.
1. Erweitern Sie unter **Modelle** die Modellkonfiguration. Studio zeigt eine Tabelle mit den voroptimierten Konfigurationen an, aus denen Sie wählen können. Jede Option verfügt über Metriken für Latenz und Durchsatz. Wählen Sie die Option, die Ihren Anwendungsanforderungen am besten entspricht.
1. Wählen Sie **Bereitstellen**.
## SageMaker AI Python SDK
Sie können ein voroptimiertes Modell bereitstellen, indem Sie das SageMaker AI Python SDK in Ihrem Projekt verwenden. Zunächst definieren Sie eine `Model`-Instance mithilfe der `ModelBuilder`-Klasse. Anschließend verwenden Sie die `set_deployment_config()`-Methode, um die voroptimierte Konfiguration festzulegen, die Sie bereitstellen möchten. Daraufhin erstellen Sie anhand der `build()`-Methode das Modell. Abschließend verwenden Sie die `deploy()`-Methode, um das Modell auf einem Inferenzendpunkt bereitzustellen.
Weitere Informationen zu den in den folgenden Beispielen verwendeten Klassen und Methoden finden Sie unter [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html) in der Dokumentation zum SageMaker AI Python SDK.
**So richten Sie Ihr Projekt ein**
1. Importieren Sie in Ihren Anwendungscode die erforderlichen Bibliotheken. Im folgenden Beispiel wird das SDK für Python (Boto3) importiert. Es werden außerdem die Module aus dem SageMaker AI Python SDK importiert, die Sie zum Definieren und Arbeiten mit Modellen verwenden:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Initialisieren Sie eine SageMaker-AI-Sitzung. Im folgenden Beispiel wird die `Session()`-Klasse verwendet:
```
sagemaker_session = Session()
```
**So definieren Sie Ihr Modell**
1. Erstellen Sie eine `SchemaBuilder`-Instance und stellen Sie Eingabe- und Ausgabebeispiele bereit. Sie stellen diese Instance der `ModelBuilder`-Klasse zur Verfügung, wenn Sie ein Modell definieren. Damit generiert SageMaker AI automatisch die Marshalling-Funktionen für die Serialisierung und Deserialisierung von Ein- und Ausgabe.
Weitere Informationen zur Verwendung der `SchemaBuilder`- und `ModelBuilder`-Klassen finden Sie unter [Erstellen Sie ein Modell in Amazon SageMaker AI mit ModelBuilder](how-it-works-modelbuilder-creation.md).
Im Folgenden finden Sie Beispiele für Eingabe- und Ausgabezeichenfolgen für die `SchemaBuilder`-Klasse.
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Definieren Sie Ihr Modell für SageMaker AI. Das folgende Beispiel legt die Parameter zum Initialisieren einer `ModelBuilder`-Instance fest:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
In diesem Beispiel wird ein JumpStart-Modell verwendet. Ersetzen Sie `jumpstart-model-id` durch die ID eines JumpStart-Modells, z. B. `meta-textgeneration-llama-3-70b`.
**So rufen Sie Benchmark-Metriken ab**
1. Um zu bestimmen, welche voroptimierte Konfiguration Sie bereitstellen möchten, schauen Sie sich die Optionen an, die SageMaker AI bietet. Das folgende Beispiel zeigt sie an:
```
model_builder.display_benchmark_metrics()
```
Diese `display_benchmark_metrics()`-Methode druckt eine Tabelle wie die folgende aus:
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
In der ersten Spalte sind in der Tabelle potenzielle Instance-Typen aufgeführt, die Sie zum Hosten des von Ihnen ausgewählten JumpStart-Modells verwenden können. Für jeden Instance-Typ werden unter `Config Name` die Namen der voroptimierten Konfigurationen aufgeführt. Die Konfigurationen, die SageMaker AI bereitstellt, heißen `lmi-optimized`. Für jeden Instance-Typ und jede Konfiguration enthält die Tabelle Benchmark-Metriken. Diese Metriken geben den Durchsatz und die Latenz an, die Ihr Modell für eine unterschiedliche Anzahl gleichzeitiger Benutzer unterstützt.
1. Wählen Sie auf der Grundlage der Benchmark-Metriken den Instance-Typ und die Konfiguration aus, die Ihren Leistungsanforderungen am besten entsprechen. Sie werden diese Werte verwenden, wenn Sie eine Bereitstellungskonfiguration erstellen.
**So stellen Sie ein voroptimiertes Modell bereit**
1. Erstellen Sie eine Bereitstellungskonfiguration. Im folgenden Beispiel wird eine `ModelBuilder`-Instance verwendet. Sie übergibt einen Instance-Typ und einen Konfigurationsnamen an die `set_deployment_config()`-Methode:
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Ersetzen Sie *`config-name`* durch einen Konfigurationsnamen aus der Tabelle, z. B. `lmi-optimized`. Ersetzen Sie `instance-type` durch einen Instance-Typ aus der Tabelle, z. B. `ml.p4d.24xlarge`.
1. Erstellen Sie Ihr Modell. Im folgenden Beispiel wird die `.build()`-Methode der `ModelBuilder`-Instance verwendet:
```
optimized_model = model_builder.build()
```
Die `.build()`-Methode gibt eine bereitstellbare `Model`-Instance zurück.
1. Stellen Sie Ihr Modell auf einem Inference-Endpunkt bereit. Im folgenden Beispiel wird die `.deploy()`-Methode der `Model`-Instance verwendet:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Die `deploy()`-Methode gibt eine `Predictor`-Instance zurück, mit der Sie Inferenzanforderungen an das Modell senden können.
**So testen Sie Ihr Modell mit einer Inferenzanforderung**
+ Nachdem Sie Ihr Modell auf einem Inferenzendpunkt bereitgestellt haben, testen Sie die Prognosen des Modells. Im folgenden Beispiel wird mithilfe der `Predictor`-Instance eine Inferenzanforderung gesendet:
```
predictor.predict(sample_input)
```
Das Modell gibt den generierten Text mit einer Antwort wie der folgenden zurück:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## Voroptimierte JumpStart-Modelle
Im Folgenden sind die JumpStart-Modelle mit voroptimierten Konfigurationen aufgeführt.
**Meta**
+ Llama 3.1 70B Instruct
+ Llama 3.1 70B
+ Llama 3.1 405B Instruct FP8
+ Llama 3.1 405B FP8
+ Llama 3 8B Instruct
+ Llama 3 8B
+ Llama 3 70B Instruct
+ Llama 3 70B
+ Llama 2 70B Chat
+ Llama 2 7B Chat
+ Llama 2 13B Chat
**HuggingFace**
+ Mixtral 8x7B Instruct
+ Mixtral 8x7B
+ Mistral 7B Instruct
+ Mistral 7B
### Vorkompilierte JumpStart-Modelle
Für einige Modelle und Konfigurationen bietet SageMaker AI Modelle, die für bestimmte AWS-Inferentia- und AWS-Trainium-Instances vorkompiliert sind. Für diese Modelle ruft SageMaker AI die kompilierten Artefakte ab, wenn Sie einen Job zur Kompilierungsoptimierung erstellen und ml.inf2.48xlarge oder ml.trn1.32xlarge als Bereitstellungs-Instance-Typ wählen. Da der Job ein bereits kompiliertes Modell verwendet, wird er schnell abgeschlossen, ohne die Kompilierung von Grund auf neu ausführen zu müssen.
Im Folgenden sind die JumpStart-Modelle aufgeführt, für die SageMaker AI vorkompilierte Modelle bereitstellt:
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B
# Erstellen eines Jobs zur Inferenzoptimierung
Sie können einen Job zur Inferenzoptimierung mithilfe von Studio oder dem SageMaker AI Python SDK erstellen. Der Job optimiert Ihr Modell, indem er die von Ihnen ausgewählten Methoden anwendet. Weitere Informationen finden Sie unter [Optimierungsmethoden](model-optimize.md#optimization-techniques).
**Instance-Gebühren für Jobs zur Inferenzoptimierung**
Wenn Sie einen Job zur Inferenzoptimierung erstellen, der Quantisierung oder Kompilierung anwendet, wählt SageMaker AI aus, welcher Instanztyp für die Ausführung des Jobs verwendet werden soll. Die Gebühren werden auf Grundlage der verwendeten Instance berechnet.
Die möglichen Instance-Typen und ihre Preisdetails finden Sie in den Preisinformationen zur Inferenzoptimierung auf der [ SageMaker Amazon-Preisseite](https://aws.amazon.com/sagemaker/pricing/).
Für Jobs, bei denen spekulative Dekodierung angewendet wird, fallen keine zusätzlichen Kosten an.
Informationen zu den unterstützten Modellen, die Sie optimieren können, finden Sie unter [Referenz zu unterstützten Modellen](optimization-supported-models.md).
## Amazon SageMaker Studio
Führen Sie die folgenden Schritte aus, um einen Job zur Inferenzoptimierung in Studio zu erstellen.
**So beginnen Sie mit der Erstellung eines Optimierungsjobs**
1. Erstellen Sie in SageMaker AI Studio einen Optimierungsjob über einen der folgenden Pfade:
+ Gehen Sie wie folgt vor, um einen Job für ein JumpStart Modell zu erstellen:
1. Wählen Sie im Navigationsmenü **JumpStart**.
1. Wählen Sie auf der Seite **Alle öffentlichen Modelle** einen Modellanbieter und dann eines der Modelle aus, die die Optimierung unterstützen.
1. Wählen Sie auf der Seite mit den Modelldetails die Option **Optimieren** aus. Diese Schaltfläche ist nur für Modelle aktiviert, die die Optimierung unterstützen.
1. Auf der **Jobseite „Inferenzoptimierung erstellen**“ müssen Sie bei einigen JumpStart Modellen eine Endbenutzer-Lizenzvereinbarung (EULA) unterzeichnen, bevor Sie fortfahren können. Falls Sie dazu aufgefordert werden, lesen Sie die Lizenzbedingungen im Abschnitt **Lizenzvereinbarung**. Wenn die Bedingungen für Ihren Anwendungsfall akzeptabel sind, aktivieren Sie das Kontrollkästchen **Ich akzeptiere die EULA und habe die allgemeinen Geschäftsbedingungen gelesen**.
+ Gehen Sie wie folgt vor, um einen Job für ein fein abgestimmtes JumpStart Modell zu erstellen:
1. Wählen Sie im Navigationsbereich unter **Jobs** die Option **Training** aus.
1. Wählen Sie auf der Seite **Trainingsjobs** den Namen eines Jobs aus, den Sie zur Feinabstimmung eines JumpStart Modells verwendet haben. Diese Jobs haben in der Spalte **Jobtyp den Typ JumpStart** **Ausbildung**.
1. Wählen Sie auf der Detailseite für den Trainingsjob die Option **Optimieren** aus.
+ Gehen Sie wie folgt vor, um einen Job für ein benutzerdefiniertes Modell zu erstellen:
1. Wählen Sie im Navigationsmenü unter **Jobs** die Option **Inferenzoptimierung** aus.
1. Wählen Sie **Create new job** (Neuen Auftrag anlegen) aus.
1. Wählen Sie auf der Seite **Job für Inferenzoptimierung erstellen** die Option **Modell hinzufügen** aus.
1. Wählen Sie im Fenster **Modell hinzufügen** die Option **Benutzerdefiniertes Modell** aus.
1. Wählen Sie eine der folgenden Optionen:
**Verwenden Sie Ihr vorhandenes Modell** — Wählen Sie diese Option, um ein Modell zu optimieren, das Sie bereits in SageMaker KI erstellt haben.
**Bestehender Modellname** — geben Sie den Namen Ihres SageMaker KI-Modells ein.
**Von S3** — Wählen Sie diese Option, um Modellartefakte aus Amazon S3 bereitzustellen. Geben Sie unter **S3-URI** den URI für den Speicherort in Amazon S3 ein, an dem Sie Ihre Modellartefakte gespeichert haben.
1. (Optional) Für den ****Namen des Ausgabemodells**** können Sie einen benutzerdefinierten Namen für das optimierte Modell eingeben, das der Job erstellt. Wenn Sie keinen Namen angeben, generiert Studio automatisch einen auf der Grundlage Ihrer Auswahl.
1. Auf der **Jobseite Inferenzoptimierung erstellen** können Sie für **Jobname** den von SageMaker AI zugewiesenen Standardnamen akzeptieren. Wenn Sie jedoch einen benutzerdefinierten Jobnamen eingeben möchten, wählen Sie das Feld **Jobname** und anschließend **Jobname eingeben** aus.
**So legen Sie die Optimierungskonfigurationen fest**
1. Wählen Sie unter **Bereitstellungs-Instance-Typ** den Instance-Typ aus, für den Sie das Modell optimieren möchten.
Der Instance-Typ wirkt sich darauf aus, welche Optimierungsmethoden Sie auswählen können. Für die meisten Typen, die GPU-Hardware verwenden, werden **Quantisierung** und **Spekulative Dekodierung** unterstützt. Wenn Sie eine Instance wählen, die benutzerdefiniertes Silizium verwendet, wie die AWS Inferentia-Instanz ml.inf2.8xlarge, wird die Methode Compilation unterstützt, mit der Sie das Modell für diesen bestimmten Hardwaretyp **kompilieren** können.
1. Wählen Sie eine oder mehrere der Optimierungsmethoden aus, die Studio bietet:
+ Wenn Sie **Quantisierung** auswählen, wählen Sie unter **Präzisionsdatentyp** einen Datentyp aus.
+ Wenn Sie **Spekulative Dekodierung** auswählen, wählen Sie eine der folgenden Optionen aus:
+ ** SageMaker KI-Entwurfsmodell verwenden** — Wählen Sie aus, ob Sie das von AI bereitgestellte Entwurfsmodell verwenden möchten. SageMaker
**Anmerkung**
Wenn Sie das SageMaker KI-Entwurfsmodell verwenden möchten, müssen Sie auch die Netzwerkisolierung aktivieren. Studio bietet diese Option unter **Sicherheit**.
+ ** JumpStart Entwurfsmodell** wählen — Wählen Sie ein Modell aus dem JumpStart Katalog aus, das Sie als Entwurfsmodell verwenden möchten.
+ **Eigenes Entwurfsmodell wählen** – Wählen Sie diese Option aus, um Ihr eigenes Entwurfsmodell zu verwenden, und geben Sie den S3-URI an, mit dem das Modell gefunden werden kann.
+ Wenn Sie **Schnelles Laden des Modells** wählen, zeigt Studio die Umgebungsvariable `OPTION_TENSOR_PARALLEL_DEGREE` an. Legen Sie im Feld **Wert** den Grad der Tensorparallelität fest. Der Wert muss die Anzahl der Instanzen, die Sie für GPUs den **Instanztyp Deployment** ausgewählt haben, gleichmäßig teilen. Um beispielsweise Ihr Modell zu teilen, während Sie eine Instanz mit 8 verwenden GPUs, verwenden Sie die Werte 2, 4 oder 8.
+ Wenn Sie den **Instanztyp Deployment** auf eine AWS Inferentia- oder AWS Trainium-Instanz festlegen, zeigt Studio möglicherweise an, dass **Compilation die einzige unterstützte Option** ist. In diesem Fall wählt Studio diese Option für Sie aus.
1. Geben Sie unter **Ausgabe** den URI eines Speicherorts in Amazon S3 ein. Dort speichert SageMaker KI die Artefakte des optimierten Modells, das Ihr Job erstellt.
1. (Optional) Erweitern Sie **Erweiterte Optionen**, um detaillierte Einstellungen wie IAM-Rolle, VPC und Umgebungsvariablen zu steuern. Weitere Informationen finden Sie nachstehend unter *Erweiterte Optionen*.
1. Wenn Sie mit der Konfiguration des Jobs fertig sind, wählen Sie **Job erstellen** aus.
In Studio wird die Seite mit den Jobdetails einschließlich des Status und aller zugehörigen Einstellungen angezeigt.
### Erweiterte Optionen
Sie können die folgenden erweiterten Optionen festlegen, wenn Sie einen Job zur Inferenzoptimierung erstellen.
Unter **Konfigurationen** können Sie die folgenden Optionen festlegen:
**Tensor-Parallelgrad **
Ein Wert für den Grad der *Tensorparallelität*. Tensor-Parallelität ist eine Art von Modellparallelität, bei der bestimmte Modellgewichtungen, Steigungen und Optimierer-Zustände auf verschiedene Geräte aufgeteilt werden. Der Wert muss die Anzahl der GPUs in Ihrem Cluster gleichmäßig teilen.
**Maximale Token-Länge**
Die Höchstanzahl der Token, die vom Modell generiert werden sollen. Beachten Sie, dass das Modell möglicherweise nicht immer die maximale Anzahl von Token generiert.
**Nebenläufigkeit**
Die Fähigkeit, mehrere Instances eines Modells auf derselben zugrunde liegenden Hardware auszuführen. Verwenden Sie die Gleichzeitigkeit, um Prognosen für mehrere Benutzer bereitzustellen und die Hardwarenutzung zu maximieren.
**Batch-Größe**
Wenn Ihr Modell *Batch-Inferencing* durchführt, legen Sie anhand dieser Option die Größe der Batches fest, die Ihr Modell verarbeitet.
Beim Batch-Inferencing werden Modellprognosen anhand einer Reihe von Beobachtungen erstellt. Es ist eine gute Option für große Datensätze oder wenn Sie keine sofortige Antwort auf eine Inferenzanforderung benötigen.
Unter **Sicherheit** können Sie die folgenden Optionen festlegen:
**IAM Role (IAM-Rolle)**
Eine IAM-Rolle, die es SageMaker KI ermöglicht, Aufgaben in Ihrem Namen auszuführen. Während der Modelloptimierung benötigt SageMaker KI Ihre Erlaubnis, um:
+ Eingabedaten aus einem S3-Bucket lesen
+ Modellartefakte in einen S3-Bucket schreiben
+ Logs in Amazon CloudWatch Logs schreiben
+ Metriken auf Amazon veröffentlichen CloudWatch
Sie gewähren einer IAM-Rolle Berechtigungen für all diese Aufgaben.
Weitere Informationen finden Sie unter [Wie verwendet man SageMaker AI-Ausführungsrollen](sagemaker-roles.md).
**KMS-Verschlüsselungsschlüssel**
Ein Schlüssel in AWS Key Management Service (AWS KMS). SageMaker KI verwendet ihren Schlüssel, um die Artefakte des optimierten Modells zu verschlüsseln, wenn SageMaker KI das Modell auf Amazon S3 hochlädt.
**VPC**
SageMaker KI verwendet diese Informationen, um Netzwerkschnittstellen zu erstellen und sie an Ihre Modellcontainer anzuhängen. Die Netzwerkschnittstellen stellen Ihren Modellcontainern eine Netzwerkverbindung innerhalb Ihrer VPC zur Verfügung, die nicht mit dem Internet verbunden ist. Außerdem kann Ihr Modell auf diese Weise eine Verbindung zu Ressourcen in Ihrer privaten VPC herstellen.
Weitere Informationen finden Sie unter [Geben Sie SageMaker KI-gehosteten Endpunkten Zugriff auf Ressourcen in Ihrer Amazon VPC](host-vpc.md).
**Aktivieren der Netzwerkisolierung**
Aktivieren Sie diese Option, wenn Sie den Internetzugang Ihres Containers einschränken möchten. Container, die mit Netzwerkisolierung ausgeführt werden, können keine ausgehenden Netzwerkaufrufe tätigen.
Sie müssen diese Option aktivieren, wenn Sie mit spekulativer Dekodierung optimieren und das SageMaker KI-Entwurfsmodell verwenden.
Weitere Informationen zur Netzwerkisolierung finden Sie unter [Netzwerkisolierung](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
Unter **Erweiterte Containerdefinition** können Sie die folgenden Optionen festlegen:
**Stoppen**
Gibt an, wie lange ein Job ausgeführt werden kann. Wenn der Job das Zeitlimit erreicht, beendet SageMaker KI den Job. Verwenden Sie diese Option, um die Kosten zu begrenzen.
**Tags (Markierungen)**
Mit dem Optimierungsjob verknüpfte Schlüssel-Wert-Paare.
Weitere Informationen zu Tags finden Sie unter [Markieren Ihrer AWS -Ressourcen](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) im *Allgemeine AWS-Referenz*.
**Umgebungsvariablen**
Schlüssel-Wert-Paare, die die Umgebungsvariablen definieren, die im Modellcontainer festgelegt werden sollen.
## SageMaker KI-Python-SDK
Sie können einen Job zur Inferenzoptimierung erstellen, indem Sie das SageMaker AI Python SDK in Ihrem Projekt verwenden. Zunächst definieren Sie eine `Model`-Instance mithilfe der `ModelBuilder`-Klasse. Anschließend verwenden Sie die `optimize()`-Methode, um einen Job auszuführen, der Ihr Modell durch Quantisierung, spekulative Dekodierung oder Kompilierung optimiert. Wenn der Job abgeschlossen ist, stellen Sie das Modell mithilfe der `deploy()`-Methode auf einem Inferenzendpunkt bereit.
Weitere Informationen zu den in den folgenden Beispielen verwendeten Klassen und Methoden finden Sie [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)in der SageMaker AI Python SDK-Dokumentation.
**So richten Sie Ihr Projekt ein**
1. Importieren Sie in Ihren Anwendungscode die erforderlichen Bibliotheken. Im folgenden Beispiel wird das SDK für Python (Boto3) importiert. Es importiert auch die Klassen aus dem SageMaker AI Python SDK, die Sie verwenden, um Modelle zu definieren und mit ihnen zu arbeiten:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. Initialisieren Sie eine SageMaker AI-Sitzung. Im folgenden Beispiel wird die `Session()`-Klasse verwendet:
```
sagemaker_session = Session()
```
**So definieren Sie Ihr Modell**
1. Erstellen Sie eine `SchemaBuilder`-Instance und stellen Sie Eingabe- und Ausgabebeispiele bereit. Sie stellen diese Instance der `ModelBuilder`-Klasse zur Verfügung, wenn Sie ein Modell definieren. Damit generiert SageMaker KI automatisch die Marshalling-Funktionen für die Serialisierung und Deserialisierung der Eingabe und Ausgabe.
Weitere Informationen zur Verwendung der `SchemaBuilder`- und `ModelBuilder`-Klassen finden Sie unter [Erstellen Sie ein Modell in Amazon SageMaker AI mit ModelBuilder](how-it-works-modelbuilder-creation.md).
Im Folgenden finden Sie Beispiele für Eingabe- und Ausgabezeichenfolgen für die `SchemaBuilder`-Klasse.
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Definieren Sie Ihr Modell für KI. SageMaker Das folgende Beispiel legt die Parameter zum Initialisieren einer `ModelBuilder`-Instance fest:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
In diesem Beispiel wird ein JumpStart Modell verwendet. `jumpstart-model-id`Ersetzen Sie es durch die ID eines JumpStart Modells, z. `meta-textgeneration-llama-3-70b` B.
**Anmerkung**
Wenn Sie mit spekulativer Dekodierung optimieren und den SageMaker KI-Entwurf verwenden möchten, müssen Sie die Netzwerkisolierung aktivieren. Geben Sie hierfür bei der Initialisierung einer `ModelBuilder`-Instance das folgende Argument an:
```
enable_network_isolation=True,
```
Weitere Informationen zur Netzwerkisolierung finden Sie unter [Netzwerkisolierung](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**So optimieren Sie Ihr Modell anhand von Quantisierung**
1. Um einen Quantisierungsjob auszuführen, verwenden Sie die `optimize()`-Methode und legen Sie das `quantization_config`-Argument fest. Im folgenden Beispiel wird `OPTION_QUANTIZE` als Umgebungsvariable im Optimierungscontainer festgelegt:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
Ersetzen Sie in diesem Beispiel *`instance-type`* durch eine ML-Instance, wie `ml.p4d.24xlarge`. Ersetzen Sie *`s3://output-path`* durch den Pfad zum S3-Speicherort, an dem Sie das optimierte Modell speichern, das der Job erstellt.
Die `optimize()`-Methode gibt ein `Model`-Objekt zurück, mit dem Sie Ihr Modell auf einem Endpunkt bereitstellen können.
1. Wenn der Job abgeschlossen ist, stellen Sie das Modell bereit. Im folgenden Beispiel wird die `deploy()`-Methode angewendet:
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
Ersetzen Sie in diesem Beispiel *`instance-type`* durch eine ML-Instance, wie `ml.p4d.24xlarge`.
Die `deploy()`-Methode gibt ein Prognoseobjekt zurück, mit dem Sie Inferenzanforderungen an den Endpunkt senden können, der das Modell hostet.
**Um mit spekulativer Dekodierung unter Verwendung des KI-Entwurfsmodells zu optimieren SageMaker**
Wenn Sie Ihr Modell mit spekulativer Dekodierung optimieren, können Sie wählen, ob Sie einen von SageMaker KI bereitgestellten Modellentwurf oder Ihr eigenes Modell verwenden möchten. In den folgenden Beispielen wird das SageMaker KI-Entwurfsmodell verwendet.
**Voraussetzung**
Um mit spekulativer Dekodierung und dem SageMaker KI-Entwurfsmodell zu optimieren, müssen Sie bei der Definition Ihres Modells die Netzwerkisolierung aktivieren.
1. Um einen Job zur spekulativen Dekodierung auszuführen, verwenden Sie die `optimize()`-Methode und legen Sie das Argument `speculative_decoding_config` fest. Im folgenden Beispiel wird der `ModelProvider` Schlüssel `SAGEMAKER` zur Verwendung des von SageMaker KI bereitgestellten Entwurfsmodells festgelegt.
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
Ersetzen Sie in diesem Beispiel *`instance-type`* durch eine ML-Instance, wie `ml.p4d.24xlarge`.
Die `optimize()`-Methode gibt ein `Model`-Objekt zurück, mit dem Sie Ihr Modell auf einem Endpunkt bereitstellen können.
1. Wenn der Job abgeschlossen ist, stellen Sie das Modell bereit. Im folgenden Beispiel wird die `deploy()`-Methode angewendet:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Die `deploy()`-Methode gibt ein Prognoseobjekt zurück, mit dem Sie Inferenzanforderungen an den Endpunkt senden können, der das Modell hostet.
**So optimieren Sie Ihr Modell anhand von spekulativer Dekodierung mithilfe eines benutzerdefinierten Entwurfsmodells**
Bevor Sie Ihr benutzerdefiniertes Entwurfsmodell für SageMaker AI bereitstellen können, müssen Sie zunächst die Modellartefakte auf Amazon S3 hochladen.
Die folgenden Beispiele zeigen eine Möglichkeit, ein benutzerdefiniertes Entwurfsmodell bereitzustellen. Sie veranschaulichen, wie der Modellentwurf vom Hugging-Face-Hub heruntergeladen und in Amazon S3 hochgeladen wird und wie der S3-URI für das Argument `speculative_decoding_config` bereitgestellt wird.
1. Wenn Sie ein Modell vom Hugging-Face-Hub herunterladen möchten, fügen Sie die `huggingface_hub`-Bibliothek zu Ihrem Projekt hinzu und laden Sie ein Modell mit der `snapshot_download()`-Methode herunter. Im folgenden Beispiel wird ein Modell in ein lokales Verzeichnis heruntergeladen:
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
Ersetzen Sie in diesem Beispiel *`model-id`* durch die ID eines Modells im Hugging-Face-Hub, wie z. B. `meta-llama/Meta-Llama-3-8B`. Ersetzen Sie *`download-dir`* durch ein lokales Verzeichnis. Ersetzen Sie *`hf-access-token`* durch Ihr Benutzerzugriffstoken. Informationen dazu, wie Sie Ihr Zugriffstoken erhalten, finden Sie unter [Benutzerzugriffstoken](https://huggingface.co/docs/hub/en/security-tokens) in der Hugging-Face-Dokumentation.
Weitere Informationen zur `huggingface_hub`-Bibliothek finden Sie unter [Hub-Client-Bibliothek](https://huggingface.co/docs/huggingface_hub/en/index) in der Hugging-Face-Dokumentation.
1. Um Ihr heruntergeladenes Modell für SageMaker KI verfügbar zu machen, laden Sie es auf Amazon S3 hoch. Im folgenden Beispiel wird das Modell mit dem `sagemaker_session`-Objekt hochgeladen:
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
Ersetzen Sie in diesem Beispiel *`prefix`* durch einen Qualifizierer, der Ihnen hilft, das Entwurfsmodell in S3 von anderen Modellen zu unterscheiden, z. B. `spec-dec-custom-draft-model`.
Die `upload_data()`-Methode gibt den S3-URI für die Modellartefakte zurück.
1. Um einen Job zur spekulativen Dekodierung auszuführen, verwenden Sie die `optimize()`-Methode und legen Sie das Argument `speculative_decoding_config` fest. Im folgenden Beispiel wird der `ModelSource`-Schlüssel auf den S3-URI des benutzerdefinierten Entwurfsmodells gesetzt:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
Ersetzen Sie in diesem Beispiel *`instance-type`* durch eine ML-Instance, wie `ml.p4d.24xlarge`.
Die `optimize()`-Methode gibt ein `Model`-Objekt zurück, mit dem Sie Ihr Modell auf einem Endpunkt bereitstellen können.
1. Wenn der Job abgeschlossen ist, stellen Sie das Modell bereit. Im folgenden Beispiel wird die `deploy()`-Methode angewendet:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Die `deploy()`-Methode gibt ein Prognoseobjekt zurück, mit dem Sie Inferenzanforderungen an den Endpunkt senden können, der das Modell hostet.
**So optimieren Sie Ihr Modell anhand von Kompilierung**
1. Um einen Kompilierungsjob auszuführen, verwenden Sie die `optimize()`-Methode und legen Sie das `compilation_config`-Argument fest. Im folgenden Beispiel wird der `OverrideEnvironment`-Schlüssel verwendet, um die erforderlichen Umgebungsvariablen im Optimierungscontainer festzulegen:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
In diesem Beispiel wird *`instance-type`* auf einen ML-Instance-Typ mit beschleunigter Hardware gesetzt. Für eine beschleunigte Inferenz mit AWS Inferentia könnten Sie den Typ beispielsweise auf eine Inf2-Instance festlegen, wie z. `ml.inf2.48xlarge` Ersetzen Sie *`s3://output-path`* durch den Pfad zum S3-Speicherort, an dem Sie das optimierte Modell speichern, das der Job erstellt.
1. Wenn der Job abgeschlossen ist, stellen Sie das Modell bereit. Im folgenden Beispiel wird die `deploy()`-Methode angewendet:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Die `deploy()`-Methode gibt ein Prognoseobjekt zurück, mit dem Sie Inferenzanforderungen an den Endpunkt senden können, der das Modell hostet.
**So testen Sie Ihr Modell mit einer Inferenzanforderung**
+ Verwenden Sie die `predict()`-Methode eines Prognoseobjekts, um eine Test-Inferenzanforderung an Ihr bereitgestelltes Modell zu senden. Im folgenden Beispiel wird die `sample_input`-Variable übergeben, die auch an die `SchemaBuilder`-Klasse in den Beispielen übergeben wurde, um Ihr Modell zu definieren:
```
predictor.predict(sample_input)
```
Die Beispieleingabe enthält den Prompt: `"What is the largest planet in the solar system?"`. Die `predict()`-Methode gibt die vom Modell generierte Antwort zurück, wie das folgende Beispiel zeigt:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK for Python (Boto3)
Sie können das AWS SDK for Python (Boto3) verwenden, um Aufträge zur Inferenzoptimierung programmgesteuert zu erstellen und zu verwalten. Dieser Abschnitt enthält Beispiele für verschiedene Optimierungstechniken.
**Voraussetzungen**
Bevor Sie einen Optimierungsjob mit Boto3 erstellen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Konfigurierte AWS Anmeldeinformationen — Richten Sie Ihre AWS Anmeldeinformationen mit den entsprechenden Berechtigungen ein
+ Es wurde ein SageMaker KI-Modell erstellt (falls ein vorhandenes Modell verwendet wurde)
+ Aufbereitete Trainingsdaten in S3 (für spekulative Dekodierungsoptimierung, unterstützte Kontextlänge bis zu 4096)
+ IAM-Rolle mit den erforderlichen Berechtigungen — Ihre Ausführungsrolle muss über Berechtigungen verfügen, um auf S3 zuzugreifen und Ressourcen zu erstellen SageMaker
**Beispiel: Erstellen Sie einen Optimierungsjob mit EAGLE Speculative Decoding (Llama 3.3 70B)**
Dieses Beispiel zeigt die Erstellung eines Optimierungsjobs für ein umfangreiches Sprachmodell mithilfe der spekulativen Dekodierungstechnik von EAGLE:
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Beispiel: Einen Optimierungsjob aus S3-Modellartefakten erstellen (Qwen3 32B)**
Dieses Beispiel zeigt, wie ein Optimierungsjob mit Modellartefakten direkt aus S3 erstellt wird:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Beispiel: Optimierungsjobs überwachen und verwalten**
Nachdem Sie einen Optimierungsjob erstellt haben, können Sie seinen Fortschritt überwachen und ihn mit den folgenden Befehlen verwalten:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
Bei der spekulativen Dekodierung mit Eagle Heads werden vier aufeinanderfolgende Trainingsjobs ausgeführt. Jeder Job erzeugt eine Ausgabe, die als Eingabe für den nächsten dient. Nur die Ausgabe des endgültigen Jobs wird an Ihren S3-Bucket übermittelt. Die Zwischenausgaben werden verschlüsselt und bis zu 20 Tage in einem internen SageMaker KI-Service-Bucket gespeichert. SageMaker KI ist nicht berechtigt, sie zu entschlüsseln. Wenn Sie möchten, dass die Zwischendaten vor diesem Zeitraum entfernt werden, stellen Sie sicher, dass Ihr Job abgeschlossen oder gestoppt wurde, und öffnen Sie dann eine Support-Anfrage [[https://docs.aws.amazon.com/awssupport/latest/user/case-management.html\$1 creating-a-support-case](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)], damit diese Daten gelöscht werden. Geben Sie in der Anfrage Ihre AWS Konto-ID und den ARN für den Optimierungsjob an.
## Einschränkungen des SageMaker KI-Entwurfsmodells
Beachten Sie bei jedem Modell, das Sie mit dem SageMaker KI-Entwurfsmodell optimieren, die Anforderungen, Einschränkungen und unterstützten Umgebungsvariablen.
**Voraussetzungen**
Sie müssen die folgenden Schritte ausführen:
+ Verwenden Sie ein Modell, das von bereitgestellt wird SageMaker JumpStart.
+ Aktivieren Sie die Netzwerkisolierung für die Modellbereitstellung.
+ Wenn Sie das Modell in einem LMI-Container (Large Model Inference) bereitstellen, verwenden Sie einen DJLServing Container der Version 0.28.0 oder höher.
Informationen zu den verfügbaren Containern finden Sie unter [Large Model Inference Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) im Deep Learning Containers GitHub Container-Repository.
+ Verwenden Sie bei der Feinabstimmung des JumpStart Modells das Safetensors-Format für die Modellgewichte.
Weitere Informationen zu diesem Format finden Sie unter [Safetensors](https://huggingface.co/docs/safetensors/en/index) in der Hugging-Face-Dokumentation.
**Einschränkungen**
Sie haben nicht die folgenden Möglichkeiten:
+ Das Modell in lokalen Testumgebungen verwenden, die Sie im lokalen Modus erstellen.
Weitere Informationen zum lokalen Modus finden Sie unter [Lokaler Modus](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) in der SageMaker AI Python SDK-Dokumentation.
+ Greifen Sie über den AWS Systems Manager Agenten (SSM-Agent) auf den Modellcontainer zu. Der SSM-Agent bietet Zugriff auf Shell-Ebene auf Ihren Modellcontainer, sodass Sie Prozesse debuggen und Befehle mit Amazon protokollieren können. CloudWatch
Weitere Informationen über dieses Feature finden Sie unter [Greifen Sie über SSM auf Container zu](ssm-access.md).
+ Den Modellcontainer für einen Core-Dump konfigurieren, der auftritt, wenn der Prozess abstürzt.
Weitere Informationen zu Core-Dumps aus Modellcontainern finden Sie unter. [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html)
+ Das Modell auf Multimodell-Endpunkten, Endpunkten mit mehreren Containern oder Endpunkten bereitstellen, die Inferenzkomponenten hosten.
Weitere Informationen zu diesen Endpunkttypen finden Sie unter [Multimodell-Endpunkte](multi-model-endpoints.md), [Endpunkte mit mehreren Containern](multi-container-endpoints.md) und [Inferenzkomponenten](realtime-endpoints-deploy-models.md#inference-components).
+ Ein Modellpaket für das Modell erstellen. Sie verwenden Modellpakete, um bereitstellbare Modelle zu erstellen, auf denen Sie veröffentlichen. AWS Marketplace
Weitere Informationen über dieses Feature finden Sie unter [Erstellen einer Modellpaketressource](sagemaker-mkt-create-model-package.md).
+ Ihren eigenen Inferenzcode im Modellcontainer verwenden.
+ Verwenden Sie eine `requirements.txt`-Datei im Modellcontainer. Dieser Dateityp listet Paketabhängigkeiten auf.
+ Den Hugging-Face-Parameter `trust_remote_code` aktivieren.
**Unterstützte Umgebungsvariablen**
Sie können den Container nur mit den folgenden Umgebungsvariablen konfigurieren:
+ allgemeine Umgebungsvariablen für Large Model Inference (LMI)-Container.
Weitere Informationen zu diesen Variablen finden Sie unter [Konfigurationen von Umgebungsvariablen](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) in der LMI-Container-Dokumentation.
+ allgemeine Umgebungsvariablen für Pakete, die der Hugging Face Hub in seinen Git-Repositorys bereitstellt.
Informationen zu den Repositorien finden Sie unter [Hugging](https://github.com/huggingface) Face on. GitHub
+ Allgemeine PyTorch und CUDA-Umgebungsvariablen.
Weitere Informationen zu diesen Variablen finden Sie in der PyTorch Dokumentation unter [Torch-Umgebungsvariablen](https://pytorch.org/docs/stable/torch_environment_variables.html).
# Anzeigen der Ergebnisse von Optimierungsjobs
Nachdem Sie einen oder mehrere Optimierungsjobs erstellt haben, können Sie Studio verwenden, um eine Übersichtstabelle all Ihrer Jobs sowie die Details für jeden einzelnen Job anzuzeigen.
## Wählen Sie Amazon SageMaker Studio
**So zeigen Sie die Übersichtstabelle für Optimierungsjobs an**
+ Wählen Sie im Studio-Navigationsmenü unter **Jobs** die Option **Inferenzoptimierung** aus.
Auf der Seite **Inferenzoptimierung** wird eine Tabelle mit den Jobs angezeigt, die Sie erstellt haben. Für jeden Job werden die Optimierungskonfigurationen, die Sie angewendet haben, und der Jobstatus angezeigt.
**So zeigen Sie die Details eines Jobs an**
+ Wählen Sie auf der Seite **Inferenzoptimierung** in der Übersichtstabelle den Namen des Jobs aus.
In Studio wird die Seite mit den Jobdetails einschließlich des Status und aller zugehörigen Einstellungen angezeigt, die Sie bei der Erstellung des Jobs angewendet haben. Wenn der Job erfolgreich abgeschlossen wurde, hat SageMaker AI die optimierten Modellartefakte am Amazon-S3-Speicherort unter dem **S3-URI des optimierten Modells** gespeichert.
# Bewerten der Leistung optimierter Modelle
Nachdem Sie einen Optimierungsjob ausgeführt haben, um ein optimiertes Modell zu erstellen, können Sie eine Bewertung der Modellleistung durchführen. Diese Bewertung liefert Metriken für Latenz, Durchsatz und Preis. Ermitteln Sie anhand dieser Metriken, ob das optimierte Modell die Anforderungen Ihres Anwendungsfalls erfüllt oder ob weitere Optimierungen erforderlich sind.
Sie können Leistungsbewertungen nur mit Studio durchführen. Diese Funktion wird nicht über die Amazon SageMaker AI-API oder das Python-SDK bereitgestellt.
## Bevor Sie beginnen
Bevor Sie eine Leistungsbewertung erstellen können, müssen Sie zunächst ein Modell optimieren, indem Sie einen Job zur Inferenzoptimierung erstellen. In Studio können Sie nur die Modelle bewerten, die Sie mit diesen Jobs erstellen.
## Erstellen der Leistungsbewertung
Führen Sie die folgenden Schritte in Studio aus, um eine Leistungsbewertung für ein optimiertes Modell zu erstellen.
1. Wählen Sie im Studio-Navigationsmenü unter **Jobs** die Option **Inferenzoptimierung** aus.
1. Wählen Sie den Namen des Jobs aus, der das optimierte Modell erstellt hat, das Sie bewerten möchten.
1. Wählen Sie auf der Seite mit den Jobdetails die Option **Leistung bewerten** aus.
1. Auf der Seite „**Leistung bewerten**“ müssen Sie bei einigen JumpStart Modellen eine Endbenutzer-Lizenzvereinbarung (EULA) unterzeichnen, bevor Sie fortfahren können. Falls Sie dazu aufgefordert werden, lesen Sie die Lizenzbedingungen im Abschnitt **Lizenzvereinbarung**. Wenn die Bedingungen für Ihren Anwendungsfall akzeptabel sind, aktivieren Sie das Kontrollkästchen **Ich akzeptiere die EULA und habe die allgemeinen Geschäftsbedingungen gelesen**.
1. Unter **Modell als Tokenizer auswählen** können Sie entweder die Standardeinstellung übernehmen oder ein bestimmtes Modell als Tokenizer für Ihre Bewertung auswählen.
1. Wählen Sie unter **Eingabedatensätze** aus, ob Sie:
+ Verwenden Sie die Standard-Beispieldatensätze von AI. SageMaker
+ einen S3-URI angeben, die auf Ihre eigenen Beispieldatensätze verweist.
1. Geben Sie unter **S3-URI für Leistungsergebnisse** einen URI an, der auf den Speicherort in Amazon S3 verweist, an dem Sie die Bewertungsergebnisse speichern möchten.
1. Wählen Sie **Bewerten** aus.
Studio zeigt die Seite mit den **Leistungsbewertungen** an, auf der Ihr Bewertungsjob in der Tabelle aufgeführt ist. In der Spalte **Status** wird der Status Ihrer Bewertung angezeigt.
1. Wenn der Status **Abgeschlossen** lautet, wählen Sie den Namen des Jobs aus, um die Bewertungsergebnisse anzuzeigen.
Auf der Seite mit den Bewertungsdetails werden Tabellen mit Leistungsmetriken für Latenz, Durchsatz und Preis angezeigt. Weitere Informationen zu den jeweiligen Metriken finden Sie in der [Referenz zu den Bewertungsmetriken der Inferenzleistung](#performance-eval-metrics-reference).
## Referenz zu den Bewertungsmetriken der Inferenzleistung
Nachdem Sie die Leistung eines optimierten Modells erfolgreich bewertet haben, werden auf der Seite mit den Bewertungsdetails in Studio die folgenden Metriken angezeigt.
### Latenzmetriken
Der Abschnitt **Latenz** zeigt die folgenden Metriken an.
**Nebenläufigkeit**
Die Anzahl der gleichzeitigen Benutzer, die bei der Bewertung simuliert wurden, um den Endpunkt gleichzeitig aufzurufen.
**Zeit bis zum ersten Token (ms)**
Die Zeit, die zwischen dem Senden der Anfrage und dem Empfang des ersten Tokens einer Streaming-Antwort vergangen ist.
**Latenz zwischen den Token (ms)**
Die Zeit bis zur Generierung eines Ausgabetokens für jede Anforderung.
**Client-Latenz (ms)**
Die Latenz vom Senden der Anforderung bis zum Erhalt der gesamten Antwort.
**Eingabe tokens/sec (Anzahl)**
Die Gesamtzahl der generierten Eingabetoken für alle Anforderungen geteilt durch die Gesamtdauer in Sekunden für die Gleichzeitigkeit.
**Ausgabe tokens/sec (Anzahl)**
Die Gesamtzahl der generierten Ausgabetoken für alle Anforderungen geteilt durch die Gesamtdauer in Sekunden für die Gleichzeitigkeit.
**Client-Aufrufe (Anzahl)**
Die Gesamtzahl der Inferenzanforderungen, die von allen Benutzern gleichzeitig an den Endpunkt gesendet wurden.
**Client-Aufruffehler (Anzahl)**
Die Gesamtzahl der Inferenzanforderungen, die von allen Benutzern gleichzeitig an den Endpunkt gesendet wurden und zu einem Aufruffehler geführt haben.
**Tokenizer fehlgeschlagen (Anzahl)**
Die Gesamtzahl der Inferenzanforderungen, bei denen der Tokenizer die Anforderung oder die Antwort nicht analysieren konnte.
**Leere Inferenzantwort (Anzahl)**
Die Gesamtzahl der Inferenzanfragen, die dazu geführt haben, dass keine Ausgabetoken ausgegeben wurden oder der Tokenizer die Antwort nicht analysieren konnte.
### Durchsatzmetriken
Im Abschnitt **Durchsatz** werden die folgenden Metriken angezeigt.
**Nebenläufigkeit**
Die Anzahl der gleichzeitigen Benutzer, die bei der Bewertung simuliert wurden, um den Endpunkt gleichzeitig aufzurufen.
**Eingabe tokens/sec/req (Anzahl)**
Die Gesamtzahl der generierten Eingabetoken pro Sekunde und Anforderung.
**Ausgabe tokens/sec/req (Anzahl)**
Die Gesamtzahl der generierten Ausgabetoken pro Sekunde und Anforderung.
**Eingabetoken (Anzahl)**
Die Gesamtzahl der generierten Eingabetoken pro Anforderung.
**Ausgabetoken (Anzahl)**
Die Gesamtzahl der generierten Ausgabetoken pro Anforderung.
### Preismetriken
Im Abschnitt **Preis** werden die folgenden Metriken angezeigt.
**Nebenläufigkeit**
Die Anzahl der gleichzeitigen Benutzer, die bei der Bewertung simuliert wurden, um den Endpunkt gleichzeitig aufzurufen.
**Preis pro Million Eingabetoken**
Kosten für die Verarbeitung von 1 Mio. Eingabetoken.
**Preis pro Million Ausgabetoken**
Kosten für die Generierung von 1 Mio. Ausgabetoken.
# Referenz zu unterstützten Modellen
Die folgenden Tabellen zeigen die Modelle, für die SageMaker KI die Inferenzoptimierung unterstützt, und sie zeigen die unterstützten Optimierungstechniken.
**Unterstützte Llama-Modelle**
| Modellname | Unterstützte Datenformate für die Quantisierung | Unterstützt spekulative Dekodierung | Unterstützt schnelles Laden von Modellen | Für die Kompilierung verwendete Bibliotheken |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Llama 2 13B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Llama 2 70B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Lama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Llama 2 7B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Lama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Llama 3 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Lama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Llama 3 8B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Meta Code Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 13B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 34B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Code Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Meta Llama 2 13B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 2 13B Chat Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 2 70B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 2 70B Chat Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 2 7B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 2 7B Chat Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3 70B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3 70B Instruct Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3 8B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3 8B Instruct Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Code Llama 70B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Code Llama 7B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Code Llama 7B Python Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Lama 3.1 405B FP8 | Keine | Ja | Ja | Keine |
| Meta Llama 3.1 405B Einweisen FP8 | Keine | Ja | Ja | Keine |
| Meta Lama 3.1 70B | INT4-AWQ FP8 | Ja | Ja | Keine |
| Meta Llama 3.1 70B Instruct | INT4-AWQ FP8 | Ja | Ja | Keine |
| Meta Lama 3.1 8B | INT4-AWQ FP8 | Ja | Ja | Keine |
| Meta Llama 3.1 8B Instruct | INT4-AWQ FP8 | Ja | Ja | Keine |
| Meta Llama 3.1 70B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3.1 70B Instruct Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3 1 8B Neuron | Keine | Nein | Nein | AWSNeuron |
| Meta Llama 3.1 8B Instruct Neuron | Keine | Nein | Nein | AWSNeuron |
**Unterstützte Mistral-Modelle**
| Modellname | Unterstützte Datenformate für die Quantisierung | Unterstützt spekulative Dekodierung | Unterstützt schnelles Laden von Modellen | Für die Kompilierung verwendete Bibliotheken |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | AWSNeuron TensorRT-LLM |
| Mistral 7B Neuron | Keine | Nein | Nein | AWSNeuron |
| Mistral 7B Instruct Neuron | Keine | Nein | Nein | AWSNeuron |
**Unterstützte Mixtral-Modelle**
| Modellname | Unterstützte Datenformate für die Quantisierung | Unterstützt spekulative Dekodierung | Unterstützt schnelles Laden von Modellen | Für die Kompilierung verwendete Bibliotheken |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Ja | Ja | TensorRT-LLM |
**Unterstützte Modellarchitekturen und EAGLE-Typ**
| Name der Modellarchitektur | Typ EAGLE |
| --- | --- |
| LlamaForCausalLM | ADLER 3 |
| Frau 3 LM ForCausal | ADLER 3 |
| Frau 3 LM NextForCausal | ADLER 2 |
| Frau 3 LM MoeForCausal | ADLER 3 |
| Frau 2 LM ForCausal | ADLER 3 |
| GptOssForCausalLM | ADLER 3 |
# Optionen für die Bewertung Ihres Modells für maschinelles Lernen in Amazon SageMaker AI
Nach dem Training eines Modells werten Sie dieses aus, um zu ermitteln, ob dessen Leistung und Genauigkeit es Ihnen ermöglichen, Ihre Geschäftsziele zu erreichen. Sie können mehrere Modelle mit verschiedenen Methoden generieren und jeweils auswerten. Beispielsweise können Sie unterschiedliche Geschäftsregeln für die einzelnen Modelle nutzen und dann verschiedene Maßnahmen einsetzen, um die Eignung jedes Modells zu bestimmen. Sie können prüfen, ob Ihr Modell eher empfindlich als spezifisch sein muss (oder umgekehrt).
Sie können Ihr Modell anhand von historischen Daten (offline) oder Live-Daten auswerten:
+ **Offline-Tests** – Verwenden Sie historische Daten, keine Live-Daten, um Inferenzanforderungen an das Modell zu senden.
Stellen Sie das trainierte Modell auf einem Alpha-Endpunkt bereit und nutzen Sie historische Daten, um Inferenzanforderungen an dieses zu senden. Um die Anfragen zu senden, verwenden Sie ein Jupyter-Notebook in Ihrer Amazon SageMaker AI-Notebook-Instance und entweder die von AI bereitgestellte Python-Bibliothek AWS SDK für Python (Boto) oder die High-Level-Python-Bibliothek. SageMaker
+ **Online-Tests mit Live-Daten** — SageMaker KI unterstützt das A/B Testen von Modellen in der Produktion mithilfe von Produktionsvarianten. Produktionsvarianten sind Modelle, die denselben Inferenzcode verwenden und auf demselben SageMaker KI-Endpunkt eingesetzt werden. Konfigurieren Sie die Produktionsvarianten so, dass ein geringer Teil des Live-Datenverkehr an das zu validierende Modell geleitet wird. Beispielsweise können Sie festlegen, dass 10 % des Datenverkehrs zur Auswertung an eine Modellvariante gesendet werden. Wenn Sie mit der Leistung des Modells zufrieden sind, können Sie den Datenverkehr zu 100 % an das aktualisierte Modell weiterleiten. Ein Beispiel für das Testen von Modellen in der Produktion finden Sie unter [Testen von Modellen mit Produktionsvarianten](model-ab-testing.md).
Weitere Informationen finden Sie in Artikeln und Büchern zur Auswertung von Modellen, z. B. [Evaluating Machine Learning Models (Auswerten von Machine-Learning-Modellen)](http://www.oreilly.com/data/free/evaluating-machine-learning-models.csp).
Die Offline-Modellauswertung bietet folgende Optionen:
+ **Validieren mithilfe eines Holdout-Satzes** – Machine-Learning-Experten halten häufig einen Teil der Daten als "Holdout-Satz" zurück. Das heißt, diese Daten werden nicht für das Modelltraining verwendet.
Bei dieser Methode wird ausgewertet, wie gut das Modell Inferenzen zum Holdout-Satz generiert. Anschließend wird ermittelt, wie effektiv das im Initialtraining Gelernte vom Modell generalisiert werden kann, im Gegensatz zur Gedächtnisnutzung des Modells. Anhand dieses Validierungsansatzes lässt sich erkennen, wie oft das Modell die richtige Antwort ableiten kann.
In gewisser Weise ist dieser Ansatz mit dem Unterrichten von Grundschulschülern vergleichbar. Zunächst geben Sie den Schülern einige Beispiele zum Lernen an die Hand und anschließend testen Sie deren Fähigkeit, das Gelernte zu verallgemeinern. Mit Hausaufgaben und Tests stellen Sie Probleme dar, die in den initialen Lerninhalten nicht vorkamen, und bestimmen, ob die Schüler effektiv generalisieren können. Schüler mit perfektem Gedächtnis können sich die Probleme einprägen, anstatt die Regeln zu lernen.
In der Regel umfasst ein Holdout-Datensatz 20 bis 30 % der Trainingsdaten.
+ **k-fold Validierung** – Bei dieser Validierungsmethode wird der Beispieldatensatz in *k* Teile gesplittet. Sie behandeln jeden Teil als Holdout-Satz für* k* Trainingsläufe und verwenden die anderen *k*-1 Teile als Trainingssatz für diesen Durchlauf. Sie erstellen* k*-Modelle mit einem ähnlichen Verfahren und aggregieren die Modelle, um das finale Modell zu generieren. Der Wert von *k* liegt in der Regel zwischen 5 und 10.
# Amazon SageMaker Inference Recommender
Amazon SageMaker Inference Recommender ist eine Funktion von Amazon SageMaker AI. Es reduziert die Zeit, die benötigt wird, um Modelle für maschinelles Lernen (ML) in Produktion zu bringen, indem Lasttests und Modelloptimierung für SageMaker KI-ML-Instances automatisiert werden. Sie können Inference Recommender verwenden, um Ihr Modell auf einem Endpoint- oder serverlosen Inferenzendpunkt bereitzustellen, der die beste Leistung zu den niedrigsten Kosten bietet. Inference Recommender hilft Ihnen bei der Auswahl des besten Instance-Typs und der besten Konfiguration für Ihre ML-Modelle und Workloads. Dabei werden Faktoren wie die Anzahl der Instances, Containerparameter, Modelloptimierungen, maximale Parallelität und Speichergröße berücksichtigt.
Amazon SageMaker Inference Recommender berechnet Ihnen nur die Instances, die Sie während der Ausführung Ihrer Jobs verwenden.
## Funktionsweise
Um Amazon SageMaker Inference Recommender zu verwenden, können Sie entweder [ein SageMaker KI-Modell erstellen oder ein Modell](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) mit Ihren Modellartefakten in der SageMaker Model Registry registrieren. Verwenden Sie die AWS SDK für Python (Boto3) oder die SageMaker AI-Konsole, um Benchmarking-Jobs für verschiedene SageMaker KI-Endpunktkonfigurationen auszuführen. Inference Recommender-Jobs helfen Ihnen dabei, Kennzahlen zu Leistung und Ressourcennutzung zu sammeln und zu visualisieren, damit Sie entscheiden können, welchen Endpunkttyp und welche Konfiguration Sie wählen sollten.
## Erste Schritte
Wenn Sie Amazon SageMaker Inference Recommender zum ersten Mal verwenden, empfehlen wir Ihnen, wie folgt vorzugehen:
1. Lesen Sie den [Voraussetzungen für die Verwendung von Amazon SageMaker Inference Recommender](inference-recommender-prerequisites.md) Abschnitt durch, um sicherzustellen, dass Sie die Anforderungen für die Verwendung von Amazon SageMaker Inference Recommender erfüllt haben.
1. Lesen Sie sich den [Empfehlungsjobs mit Amazon SageMaker Inference Recommender](inference-recommender-recommendation-jobs.md) Abschnitt durch, um Ihre ersten Inference Recommender-Empfehlungsjobs zu starten.
1. Sehen Sie sich das einführende Beispiel für das Amazon SageMaker Inference Recommender [Jupyter-Notizbuch](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-inference-recommender/inference-recommender.ipynb) an, oder sehen Sie sich die Beispiel-Notebooks im folgenden Abschnitt an.
## Beispiel-Notebooks
Die folgenden Beispiel-Jupyter-Notebooks können Ihnen bei den Workflows für mehrere Anwendungsfälle in Inference Recommender helfen:
+ [Wenn Sie ein Einführungs-Notebook suchen, das Benchmarks für ein TensorFlow Modell vornimmt, schauen Sie sich das Inference Recommender-Notebook an. SageMaker TensorFlow](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb)
+ Informationen zum Benchmarking eines HuggingFace Modells finden Sie im [SageMaker Inference Recommender](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/huggingface-inference-recommender/huggingface-inference-recommender.ipynb) für Notebooks. HuggingFace
+ Wenn Sie ein XGBoost Modell vergleichen möchten, schauen Sie sich das [SageMaker Inference Recommender-Notebook](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb) an. XGBoost
+ [Wenn Sie die CloudWatch Kennzahlen für Ihre Inference Recommender-Jobs überprüfen möchten, schauen Sie sich das Notizbuch für Inference Recommender-Metriken anSageMaker . CloudWatch ](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb)
# Voraussetzungen für die Verwendung von Amazon SageMaker Inference Recommender
Bevor Sie Amazon SageMaker Inference Recommender verwenden können, müssen Sie die erforderlichen Schritte ausführen. Als Beispiel zeigen wir, wie Sie ein vortrainiertes Modell PyTorch (v1.7.1) ResNet -18 für beide Arten von Amazon SageMaker Inference Recommender-Empfehlungsjobs verwenden können. Die gezeigten Beispiele verwenden das AWS SDK für Python (Boto3).
**Anmerkung**
Die folgenden Codebeispiele verwenden Python. Entfernen Sie das `!` Präfixzeichen, wenn Sie eines der folgenden Codebeispiele in Ihrem Terminal ausführen oder AWS CLI.
Sie können die folgenden Beispiele mit dem Python 3-Kernel (TensorFlow 2.6 Python 3.8 CPU-optimiert) in einem Amazon SageMaker Studio-Notebook ausführen. Weitere Informationen über Studio finden Sie unter [Amazon SageMaker Studio](studio-updated.md).
1. **Erstellen Sie eine IAM-Rolle für Amazon SageMaker AI.**
Erstellen Sie eine IAM-Rolle für Amazon SageMaker AI, der die `AmazonSageMakerFullAccess` IAM-verwaltete Richtlinie angehängt ist.
1. **Einrichten Ihrer Umgebung**
Importieren Sie Abhängigkeiten und erstellen Sie Variablen für Ihre AWS-Region, Ihre SageMaker KI-IAM-Rolle (aus Schritt 1) und den SageMaker AI-Client.
```
!pip install --upgrade pip awscli botocore boto3 --quiet
from sagemaker import get_execution_role, Session, image_uris
import boto3
region = boto3.Session().region_name
role = get_execution_role()
sagemaker_client = boto3.client("sagemaker", region_name=region)
sagemaker_session = Session()
```
1. **(Optional) Überprüfen Sie bestehende Modelle, die von Inference Recommender bewertet wurden.**
Inference Recommender vergleicht Modelle beliebter Modellzoos. Inference Recommender unterstützt Ihr Modell, auch wenn es noch nicht einem Benchmarking unterzogen wurde.
`ListModelMetaData` wird verwendet, um ein Antwortobjekt abzurufen, das die Domain-, Framework-, Aufgaben- und Modellnamen von Modellen für Machine Learning auflistet, die in gängigen Modellzoos zu finden sind.
In späteren Schritten verwenden Sie die Domain, das Framework, die Framework-Version, die Aufgabe und den Modellnamen, um sowohl ein Inferenz-Docker-Image auszuwählen als auch Ihr Modell bei SageMaker Model Registry zu registrieren. Im Folgenden wird veranschaulicht, wie Modellmetadaten mit SDK for Python (Boto3) aufgelistet werden:
```
list_model_metadata_response=sagemaker_client.list_model_metadata()
```
Die Ausgabe umfasst Modellzusammenfassungen (`ModelMetadataSummaries`) und Antwortmetadaten (`ResponseMetadata`), die dem folgenden Beispiel ähneln:
```
{
'ModelMetadataSummaries': [{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-cased',
'Task': 'FILL_MASK'
},
{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-uncased',
'Task': 'FILL_MASK'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'MXNET:1.8.0',
'Model': 'resnet18v2-gluon',
'Task': 'IMAGE_CLASSIFICATION'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'PYTORCH:1.6.0',
'Model': 'resnet152',
'Task': 'IMAGE_CLASSIFICATION'
}],
'ResponseMetadata': {
'HTTPHeaders': {
'content-length': '2345',
'content-type': 'application/x-amz-json-1.1',
'date': 'Tue, 19 Oct 2021 20:52:03 GMT',
'x-amzn-requestid': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
},
'HTTPStatusCode': 200,
'RequestId': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
'RetryAttempts': 0
}
}
```
Für diese Demo verwenden wir ein PyTorch (v1.7.1) ResNet -18-Modell, um die Bildklassifizierung durchzuführen. Im folgenden Python-Codebeispiel werden das Framework, die Framework-Version, die Domain und die Aufgabe zur späteren Verwendung in Variablen gespeichert:
```
# ML framework details
framework = 'pytorch'
framework_version = '1.7.1'
# ML model details
ml_domain = 'COMPUTER_VISION'
ml_task = 'IMAGE_CLASSIFICATION'
```
1. **Laden Sie Ihr Modell für Machine Learning auf Amazon S3 hoch.**
Verwenden Sie dieses PyTorch (v1.7.1) ResNet -18-Modell, wenn Sie kein vortrainiertes Modell für maschinelles Lernen haben:
```
# Optional: Download a sample PyTorch model
import torch
from torchvision import models, transforms, datasets
# Create an example input for tracing
image = torch.zeros([1, 3, 256, 256], dtype=torch.float32)
# Load a pretrained resnet18 model from TorchHub
model = models.resnet18(pretrained=True)
# Tell the model we are using it for evaluation (not training). Note this is required for Inferentia compilation.
model.eval()
model_trace = torch.jit.trace(model, image)
# Save your traced model
model_trace.save('model.pth')
```
Laden Sie ein Beispiel für ein Inferenzskript `inference.py` herunter. Erstellen Sie ein `code` Verzeichnis und verschieben Sie das Inferenzskript in das `code` Verzeichnis.
```
# Download the inference script
!wget https://aws-ml-blog-artifacts.s3.us-east-2.amazonaws.com/inference.py
# move it into a code/ directory
!mkdir code
!mv inference.py code/
```
Amazon SageMaker AI erfordert, dass vortrainierte Modelle für maschinelles Lernen als komprimierte TAR-Datei (`*.tar.gz`) verpackt werden. Komprimieren Sie Ihr Modell und Ihr Inferenzskript, um diese Anforderung zu erfüllen:
```
!tar -czf test.tar.gz model.pth code/inference.py
```
Wenn Ihr Endpunkt bereitgestellt wird, werden die Dateien im Archiv `/opt/ml/model/` auf den Endpunkt extrahiert.
Nachdem Sie Ihr Modell und die Modellartefakte als `.tar.gz` Datei komprimiert haben, laden Sie sie in Ihren Amazon S3-Bucket hoch. Das folgende Beispiel veranschaulicht, wie Sie Ihr Modell mit der AWS CLI auf Amazon S3 hochladen können:
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
1. **Wählen Sie ein vorgefertigtes Docker-Inferenz-Image aus oder erstellen Sie Ihr eigenes Inference-Docker-Image.**
SageMaker AI stellt Container für seine integrierten Algorithmen und vorgefertigte Docker-Images für einige der gängigsten Frameworks für maschinelles Lernen wie Apache,, und MXNet TensorFlow Chainer bereit. PyTorch Eine vollständige Liste der verfügbaren SageMaker KI-Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Wenn keiner der vorhandenen SageMaker KI-Container Ihren Anforderungen entspricht und Sie keinen eigenen Container haben, erstellen Sie ein neues Docker-Image. Weitere Informationen zum Erstellen eines Docker-Image finden Sie unter [Container mit benutzerdefiniertem Inferenzcode](your-algorithms-inference-main.md).
Im Folgenden wird gezeigt, wie Sie mit dem SageMaker Python-SDK ein Inferenzbild der PyTorch Version 1.7.1 abrufen:
```
from sagemaker import image_uris
## Uncomment and replace with your own values if you did not define
## these variables a previous step.
#framework = 'pytorch'
#framework_version = '1.7.1'
# Note: you can use any CPU-based instance here,
# this is just to set the arch as CPU for the Docker image
instance_type = 'ml.m5.2xlarge'
image_uri = image_uris.retrieve(framework,
region,
version=framework_version,
py_version='py3',
instance_type=instance_type,
image_scope='inference')
```
Eine Liste der verfügbaren SageMaker AI-Instances finden Sie unter [Amazon SageMaker AI-Preise](https://aws.amazon.com/sagemaker/pricing/).
1. **Erstellen Sie ein Beispiel-Payload-Archiv.**
Erstellen Sie ein Archiv, das einzelne Dateien enthält, die das Lasttest-Tool an Ihre SageMaker KI-Endpunkte senden kann. Ihr Inferenzcode muss in der Lage sein, die Dateiformate aus der Beispiel-Payload zu lesen.
Im Folgenden wird ein JPG-Bild heruntergeladen, das in diesem Beispiel in einem späteren Schritt für das Modell ResNet -18 verwendet wird.
```
!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg
```
Komprimieren Sie die Beispiel-Payload als Tarball:
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Laden Sie die Beispielnutzlast auf Amazon S3 hoch und notieren Sie sich die Amazon-S3-URI:
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Sie benötigen den Amazon-S3-URI in einem späteren Schritt. Speichern Sie ihn daher in einer Variablen:
```
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
payload_s3_key = f"{bucket_prefix}/payload.tar.gz"
sample_payload_url= f"s3://{bucket}/{payload_s3_key}"
```
1. **Bereiten Sie Ihre Modelleingaben für den Job mit den Empfehlungen vor**
Für die letzte Voraussetzung haben Sie zwei Möglichkeiten, Ihre Modelleingabe vorzubereiten. Sie können Ihr Modell entweder bei SageMaker Model Registry registrieren, das Sie zum Katalogisieren von Modellen für die Produktion verwenden können, oder Sie können ein SageMaker KI-Modell erstellen und es vor `ContainerConfig` Ort angeben, wenn Sie einen Empfehlungsauftrag erstellen. Die erste Option eignet sich am besten, wenn Sie die Funktionen von [Model Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html) nutzen möchten, z. B. die Verwaltung von Modellversionen und die Automatisierung der Modellbereitstellung. Die zweite Option ist ideal, wenn Sie schnell loslegen möchten. Für die erste Option fahren Sie mit Schritt 7 fort. Für die zweite Option überspringen Sie Schritt 7 und fahren Sie mit Schritt 8 fort.
1. **Option 1: Registrieren Sie Ihr Modell in der Modellregistrierung**
Mit SageMaker Model Registry können Sie Modelle für die Produktion katalogisieren, Modellversionen verwalten, Metadaten (wie Trainingsmetriken) mit einem Modell verknüpfen, den Genehmigungsstatus eines Modells verwalten, Modelle für die Produktion bereitstellen und die Modellbereitstellung mit CI/CD automatisieren.
Wenn Sie SageMaker Model Registry verwenden, um Ihre Modelle nachzuverfolgen und zu verwalten, werden sie als versioniertes Modellpaket innerhalb von Modellpaketgruppen dargestellt. Modellpakete ohne Version sind nicht Teil einer Modellgruppe. Modellpaketgruppen enthalten mehrere Versionen oder Iterationen eines Modells. Sie müssen zwar nicht für jedes Modell in der Registrierung erstellt werden, sie helfen jedoch dabei, verschiedene Modelle zu organisieren, die alle demselben Zweck dienen, und ermöglichen eine automatische Versionsverwaltung.
Um Amazon SageMaker Inference Recommender verwenden zu können, benötigen Sie ein versioniertes Modellpaket. Sie können ein versioniertes Modellpaket programmgesteuert mit AWS SDK für Python (Boto3) oder mit Amazon SageMaker Studio Classic erstellen. Um ein versioniertes Modellpaket programmgesteuert zu erstellen, erstellen Sie zunächst eine Modellpaketgruppe mit der `CreateModelPackageGroup` API. Erstellen Sie als Nächstes mithilfe der `CreateModelPackage` API ein Modellpaket. Durch den Aufruf dieser Methode wird ein versioniertes Modellpaket erstellt.
Unter [Erstellen einer Modellgruppe](model-registry-model-group.md) und [Registrieren Sie eine Modellversion](model-registry-version.md) finden Sie detaillierte Anweisungen zum programmgesteuerten und interaktiven Erstellen einer Modellpaketgruppe bzw. zum Erstellen eines versionierten Modellpakets mit dem AWS SDK für Python (Boto3) und Amazon Studio Classic. SageMaker
Das folgende Codebeispiel zeigt, wie Sie ein versioniertes Modellpaket mit dem AWS SDK für Python (Boto3) erstellen.
**Anmerkung**
Sie müssen das Modellpaket nicht genehmigen, um einen Inference Recommender-Job zu erstellen.
1. **Erstellen einer Modellpaketgruppe**
Erstellen Sie eine Modellpaketgruppe mit der `CreateModelPackageGroup` API. Geben Sie einen Namen für die Modellpaketgruppe für `ModelPackageGroupName` und optional eine Beschreibung des Modellpakets in das `ModelPackageGroupDescription` Feld ein.
```
model_package_group_name = ''
model_package_group_description = ''
model_package_group_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageGroupDescription" : model_package_group_description,
}
model_package_group_response = sagemaker_client.create_model_package_group(**model_package_group_input_dict)
```
Eine vollständige Liste der optionalen und erforderlichen Argumente, an die Sie übergeben können, finden Sie im [Amazon SageMaker API-Referenzhandbuch [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html).
Erstellen Sie ein Modellpaket, indem Sie ein Docker-Image angeben, das Ihren Inferenzcode und den Amazon S3-Speicherort Ihrer Modellartefakte ausführt und Werte für `InferenceSpecification` bereitstellt. `InferenceSpecification` sollte Informationen zu Inferenzaufträgen enthalten, die mit Modellen ausgeführt werden können, die auf diesem Modellpaket basieren, einschließlich der folgenden Informationen:
+ Die Amazon ECR-Pfade der Bilder, auf denen Ihr Inferenzcode ausgeführt wird.
+ (Optional) Die Instance-Typen, die das Modellpaket für Transformationsjobs unterstützt, und Echtzeit-Endpunkte, die für Inferenzen verwendet werden.
+ Die Eingabe- und Ausgabeinhaltsformate, die das Modellpaket für Inferenzen unterstützt.
Darüber hinaus müssen Sie beim Erstellen eines Modellpakets die folgenden Parameter angeben:
+ [Domain](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Domain): Der Bereich des Machine Learning für Ihr Modellpaket und seine Komponenten. Zu den gängigen Bereichen des Machine Learnings gehören Computer Vision und die natürliche Sprachverarbeitung.
+ [Aufgabe](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task): Die Aufgabe des maschinellen Lernens, die Ihr Modellpaket erfüllt. Zu den gängigen Machine-Learning-Aufgaben gehören die Objekterkennung und die Image-Klassifizierung. Geben Sie „OTHER“ an, wenn keine der im [API-Referenzhandbuch](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) aufgeführten Aufgaben Ihrem Anwendungsfall entspricht. Eine Liste der unterstützten [Aufgaben](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task) für Machine Learning finden Sie in den Feldbeschreibungen der Task-API.
+ [SamplePayloadUrl](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-SamplePayloadUrl): Der Amazon Simple Storage Service (Amazon S3) -Pfad, in dem die Beispielnutzdaten gespeichert werden. Dieser Pfad muss auf ein einzelnes, mit GZIP komprimiertes TAR-Archiv zeigen (.tar.gz-Suffix).
+ [Framework](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-Framework): Das Framework für Machine Learning des Modellpakets Container Image.
+ [FrameworkVersion](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-FrameworkVersion): Die Framework-Version des Container-Images des Modellpakets.
Wenn Sie eine Zulassungsliste mit Instance-Typen angeben, anhand derer in Echtzeit Inferenzen für die generiert werden können [SupportedRealtimeInferenceInstanceTypes](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InferenceSpecification.html#sagemaker-Type-InferenceSpecification-SupportedRealtimeInferenceInstanceTypes), schränkt Inference Recommender den Suchraum für Instance-Typen während eines Jobs ein. `Default` Verwenden Sie diesen Parameter, wenn Sie Budgetbeschränkungen haben oder wissen, dass es bestimmte Instance-Typen gibt, die Ihr Modell und Ihr Container-Image unterstützen können.
In einem vorherigen Schritt haben wir ein vortrainiertes ResNet 18-Modell heruntergeladen und es in einem Amazon S3 S3-Bucket in einem Verzeichnis namens `models` gespeichert. Wir haben ein Deep-Learning-Container-Inferenzbild PyTorch (v1.7.1) abgerufen und den URI in einer Variablen namens gespeichert. `image_uri` Verwenden Sie diese Variablen im folgenden Codebeispiel, um ein Wörterbuch zu definieren, das als Eingabe für die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html)-API verwendet wird.
```
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
# Similar open source model to the packaged model
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input.
input_content_type='image/jpeg'
# Optional - provide a description of your model.
model_package_description = ''
## Uncomment if you did not store the domain and task in an earlier
## step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version
## in a previous step.
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating a model pacakge group
model_package_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageDescription" : model_package_description,
"Domain": ml_domain,
"Task": ml_task,
"SamplePayloadUrl": sample_payload_url,
"InferenceSpecification": {
"Containers": [
{
"Image": image_uri,
"ModelDataUrl": model_url,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"ModelInput": {"DataInputConfig": data_input_configuration}
}
],
"SupportedContentTypes": [input_content_type]
}
}
```
1. **Erstellen eines Modellpakets**
Verwenden Sie die `CreateModelPackage`-API, um ein Modellpaket zu erstellen. Übergeben Sie das im vorherigen Schritt definierte Eingabewörterbuch:
```
model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)
```
Sie benötigen das Modellpaket ARN, um Amazon SageMaker Inference Recommender verwenden zu können. Notieren Sie sich den ARN des Modellpakets oder speichern Sie ihn in einer Variablen:
```
model_package_arn = model_package_response["ModelPackageArn"]
print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
1. **Option 2: Erstellen Sie ein Modell und konfigurieren Sie das `ContainerConfig` Feld**
Verwenden Sie diese Option, wenn Sie einen Job mit Inferenzempfehlungen starten möchten und Ihr Modell nicht in der Modellregistrierung registrieren müssen. In den folgenden Schritten erstellen Sie ein Modell in SageMaker AI und konfigurieren das `ContainerConfig` Feld als Eingabe für den Empfehlungsjob.
1. **Erstellen eines Modells**
Erstellen eines Modells mit der `CreateModel`-API Ein Beispiel, das diese Methode aufruft, wenn ein Modell für SageMaker AI Hosting bereitgestellt wird, finden Sie unter [Create a Model (AWS SDK für Python (Boto3))](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html#realtime-endpoints-deployment-create-model).
In einem vorherigen Schritt haben wir ein vortrainiertes ResNet 18-Modell heruntergeladen und es in einem Amazon S3 S3-Bucket in einem Verzeichnis namens `models` gespeichert. Wir haben ein Deep-Learning-Container-Inferenzbild PyTorch (v1.7.1) abgerufen und den URI in einer Variablen namens gespeichert. `image_uri` Wir verwenden diese Variablen im folgenden Codebeispiel, in dem wir ein Wörterbuch definieren, das als Eingabe für die `[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html#sagemaker-CreateModel-request-ModelName)` API verwendet wird.
```
model_name = ''
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam::::role/*"
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': image_uri,
'ModelDataUrl': model_url,
})
```
1. **Konfigurieren Sie das `ContainerConfig` Feld**
Als Nächstes müssen Sie das [ContainerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobInputConfig.html#sagemaker-Type-RecommendationJobInputConfig-ContainerConfig)Feld mit dem Modell konfigurieren, das Sie gerade erstellt haben, und darin die folgenden Parameter angeben:
+ `Domain`: Die Domain des Modells für Machine Learning und seine Komponenten, z. B. Computer Vision oder Verarbeitung natürlicher Sprache.
+ `Task`: Die Aufgabe des maschinellen Lernens, die das Modell erfüllt, z. B. Bildklassifizierung oder Objekterkennung.
+ `PayloadConfig`: Die Konfiguration für die Nutzlast für einen Empfehlungsjob. Weitere Informationen zu den Teilbereichen finden Sie unter `[RecommendationJobPayloadConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobPayloadConfig.html#sagemaker-Type-RecommendationJobPayloadConfig-SamplePayloadUrl)`.
+ `Framework`: Das Framework für maschinelles Lernen des Container-Images, z. PyTorch B.
+ `FrameworkVersion`: Die Framework-Version des Container-Images.
+ (Optional) `SupportedInstanceTypes`: Eine Liste der Instance-Typen, die zur Erzeugung von Schlussfolgerungen in Echtzeit verwendet werden.
Wenn Sie den `SupportedInstanceTypes` Parameter verwenden, schränkt Inference Recommender den Suchraum für Instance-Typen während eines Jobs `Default` ein. Verwenden Sie diesen Parameter, wenn Sie Budgetbeschränkungen haben oder wissen, dass es bestimmte Instance-Typen gibt, die Ihr Modell und Ihr Container-Image unterstützen können.
Im folgenden Codebeispiel verwenden wir die zuvor definierten Parameter zusammen mit `NearestModelName`, um ein Wörterbuch zu definieren, das als Eingabe für die `[CreateInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)` API verwendet wird.
```
## Uncomment if you did not store the domain and task in a previous step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version in a previous step
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input
input_content_type='image/jpeg'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating an inference recommendation job
container_config = {
"Domain": ml_domain,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"PayloadConfig": {
"SamplePayloadUrl": sample_payload_url,
"SupportedContentTypes": [ input_content_type ]
},
"DataInputConfig": data_input_configuration
"Task": ml_task,
}
```
# Empfehlungsjobs mit Amazon SageMaker Inference Recommender
Amazon SageMaker Inference Recommender kann zwei Arten von Empfehlungen aussprechen:
1. Mit Inferenzempfehlungen (`Default` Auftragstyp) wird eine Reihe von Belastungstests für die empfohlenen Instances-Typen ausgeführt. Sie können auch einen Lasttest für einen serverlosen Endpunkt durchführen. Sie müssen nur ein Modellpaket mit dem Amazon-Ressourcenname (ARN) angeben, um diese Art von Empfehlungsjob zu starten. Aufträge für Inferenzempfehlungen werden innerhalb von 45 Minuten abgeschlossen.
1. Endpunktempfehlungen (`Advanced` Auftragstyp) basieren auf einem benutzerdefinierten Lasttest, bei dem Sie Ihre gewünschten ML-Instances oder einen serverlosen Endpunkt auswählen, ein benutzerdefiniertes Datenverkehrsmuster angeben und Anforderungen für Latenz und Durchsatz auf der Grundlage Ihrer Produktionsanforderungen angeben. Die Ausführung dieses Jobs dauert je nach eingestellter Auftragsdauer und Gesamtzahl der getesteten Inferenzkonfigurationen durchschnittlich 2 Stunden.
Beide Arten von Empfehlungen verwenden dasselbe, APIs um Jobs zu erstellen, zu beschreiben und zu beenden. Die Ausgabe ist eine Liste von Empfehlungen zur Instance-Konfiguration mit zugehörigen Umgebungsvariablen, Kosten-, Durchsatz- und Latenzmetriken. Empfehlungsaufträge bieten auch eine anfängliche Anzahl von Instances, die Sie verwenden können, um eine Autoscaling-Richtlinie zu konfigurieren. Um zwischen den beiden Auftragstypen zu unterscheiden, geben Sie bei der Erstellung eines Jobs entweder über die SageMaker KI-Konsole oder über an APIs`Default`, dass vorläufige Endpunktempfehlungen und benutzerdefinierte Belastungstests und `Advanced` Endpunktempfehlungen erstellt werden sollen.
**Anmerkung**
Sie müssen nicht beide Arten von Empfehlungsaufträgen in Ihrem eigenen Workflow ausführen. Sie können beide unabhängig voneinander ausführen.
Inference Recommender kann Ihnen auch eine Liste potenzieller Instances oder die fünf wichtigsten Instance-Typen, die im Hinblick auf Kosten, Durchsatz und Latenz für die Modellbereitstellung optimiert sind, zusammen mit einem Konfidenzwert zur Verfügung stellen. Sie können diese Instances bei der Bereitstellung Ihres Modells auswählen. Inference Recommender führt automatisch ein Benchmarking mit Ihrem Modell durch, damit Sie die potenziellen Instances bereitstellen können. Da es sich dabei um vorläufige Empfehlungen handelt, empfehlen wir Ihnen, weitere Instance-Empfehlungsaufträge auszuführen, um genauere Ergebnisse zu erhalten. Rufen Sie die Detailseite Ihres SageMaker KI-Modells auf, um sich die potenziellen Instanzen anzusehen. Weitere Informationen finden Sie unter [Erhalten Sie sofort potenzielle Instances](inference-recommender-prospective.md).
**Topics**
+ [Erhalten Sie sofort potenzielle Instances](inference-recommender-prospective.md)
+ [Inferenzempfehlungen](inference-recommender-instance-recommendation.md)
+ [Holen Sie sich eine Inferenzempfehlung für einen vorhandenen Endpunkt](inference-recommender-existing-endpoint.md)
+ [Stoppen Sie Ihre Inferenzempfehlung](instance-recommendation-stop.md)
+ [Mit Neo zusammengestellte Empfehlungen](inference-recommender-neo-compilation.md)
+ [Empfehlungsergebnisse](inference-recommender-interpret-results.md)
+ [Holen Sie sich politische Empfehlungen zur automatischen Skalierung](inference-recommender-autoscaling.md)
+ [Führen Sie einen benutzerdefinierten Belastungstest aus](inference-recommender-load-test.md)
+ [Stoppen Sie Ihren Belastungstest](load-test-stop.md)
+ [Beheben Sie Inference Recommender-Fehler](inference-recommender-troubleshooting.md)
# Erhalten Sie sofort potenzielle Instances
Inference Recommender kann Ihnen auf der Detailseite Ihres SageMaker KI-Modells auch eine Liste *potenzieller Instances* oder Instance-Typen, die für Ihr Modell geeignet sein könnten, zur Verfügung stellen. Inference Recommender führt automatisch ein vorläufiges Benchmarking mit Ihrem Modell durch, sodass Sie die fünf potenziellen Instances mit den besten Ergebnissen ermitteln können. Da es sich dabei um vorläufige Empfehlungen handelt, empfehlen wir Ihnen, weitere Instance-Empfehlungsaufträge auszuführen, um genauere Ergebnisse zu erhalten.
Sie können eine Liste potenzieller Instanzen für Ihr Modell entweder programmgesteuert mithilfe der [DescribeModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModel.html)API, des SageMaker Python-SDK oder der SageMaker AI-Konsole anzeigen.
**Anmerkung**
Sie erhalten keine potenziellen Instanzen für Modelle, die Sie in SageMaker KI erstellt haben, bevor diese Funktion verfügbar wurde.
Führen Sie die folgenden Schritte aus, um die potenziellen Instances für Ihr Modell über die Konsole anzuzeigen:
1. Gehen Sie zur SageMaker Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im linken Navigationsbereich die Option **Inferenz** und anschließend die Option **Modelle**.
1. Wählen Sie Ihr Modell aus der Modellliste aus.
Gehen Sie auf der Detailseite für Ihr Modell zum Abschnitt **Voraussichtliche Instances für das Einsatzmodell**. Der folgende Screenshot zeigt diesen Abschnitt.
![\[Screenshot der Liste potenzieller Instances auf der Seite mit den Modelldetails.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inf-rec-prospective.png)
In diesem Abschnitt können Sie sich die potenziellen Instances ansehen, die im Hinblick auf Kosten, Durchsatz und Latenz für die Modellbereitstellung optimiert sind, sowie zusätzliche Informationen für jeden Instance-Typ wie Speichergröße, CPU- und GPU-Anzahl und Kosten pro Stunde.
Wenn Sie sich entscheiden, eine Beispiel-Payload zu vergleichen und einen vollständigen Job für Inferenzempfehlungen für Ihr Modell auszuführen, können Sie auf dieser Seite einen Standard-Job für Inferenzempfehlungen starten. So starten Sie einen Standardauftrag über die Konsole:
1. Wählen Sie auf der Seite mit den Modelldetails im **Abschnitt Voraussichtliche Instances für das Einsatzmodell** die Option **Inferenz-Empfehlungsauftrag ausführen** aus.
1. Geben Sie in dem daraufhin angezeigten Dialogfeld für **S3-Bucket für Benchmarking-Nutzdaten**, den Amazon S3-Speicherort ein, an dem Sie eine Beispiel-Payload für Ihr Modell gespeichert haben.
1. Geben Sie als **Payload-Inhaltstyp** die MIME-Typen für Ihre Payload-Daten ein.
1. (Optional) Geben Sie im Abschnitt **Modellkompilierung mit SageMaker Neo** für die **Dateneingabekonfiguration** eine Datenform im Wörterbuchformat ein.
1. Wählen Sie **Auftrag ausführen** aus.
Inference Recommender startet den Job, und Sie können den Job und seine Ergebnisse auf der Seite mit **der Liste der Inference-Empfehlungen in der AI-Konsole** anzeigen. SageMaker
Wenn Sie einen erweiterten Job ausführen und benutzerdefinierte Lasttests durchführen oder zusätzliche Einstellungen und Parameter für Ihren Job konfigurieren möchten, finden Sie weitere Informationen unter. [Führen Sie einen benutzerdefinierten Belastungstest aus](inference-recommender-load-test.md)
# Inferenzempfehlungen
Jobs mit Inferenzempfehlungen führen eine Reihe von Lasttests für empfohlene Instance-Typen oder einen serverlosen Endpunkt aus. Inferenzempfehlungsjobs verwenden Leistungsmetriken, die auf Lasttests mit den Beispieldaten basieren, die Sie bei der Registrierung der Modellversion angegeben haben.
**Anmerkung**
Bevor Sie einen Inference Recommender-Empfehlungsauftrag erstellen, stellen Sie sicher, dass Sie die Anforderungen [Voraussetzungen für die Verwendung von Amazon SageMaker Inference Recommender](inference-recommender-prerequisites.md) erfüllt haben.
Im Folgenden wird gezeigt, wie Sie Amazon SageMaker Inference Recommender verwenden, um mithilfe von,, und Amazon SageMaker Studio Classic sowie der AWS SDK für Python (Boto3) KI-Konsole eine auf Ihrem Modelltyp basierende Inferenzempfehlung zu erstellen. AWS CLI SageMaker
**Topics**
+ [Erstellen Sie eine Inferenzempfehlung](instance-recommendation-create.md)
+ [Rufen Sie die Ergebnisse Ihrer Inferenzempfehlung ab.](instance-recommendation-results.md)
# Erstellen Sie eine Inferenzempfehlung
Erstellen Sie eine Inferenzempfehlung programmgesteuert mit AWS SDK für Python (Boto3) oder dem oder interaktiv mit Studio AWS CLI Classic oder der AI-Konsole. SageMaker Geben Sie im Abschnitt **Voraussetzungen** einen Jobnamen für Ihre Inferenzempfehlung, einen AWS IAM-Rollen-ARN, eine Eingabekonfiguration und entweder einen Modellpaket-ARN an, als Sie Ihr Modell bei der Modellregistrierung registriert haben, oder Ihren Modellnamen und ein `ContainerConfig` Wörterbuch von der Erstellung Ihres Modells.
------
#### [ AWS SDK für Python (Boto3) ]
Verwenden Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)-API, um einen Job mit Inferenzempfehlungen zu starten. Stellen Sie das `JobType` Feld auf `'Default'` ehlungen ein. Darüber hinaus sind folgende Angaben zu machen:
+ Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die es Inference Recommender ermöglicht, Aufgaben in Ihrem Namen durchzuführen. Definieren Sie dies für das `RoleArn` Feld.
+ Ein Modellpaket-ARN oder ein Modellname. Inference Recommender unterstützt entweder einen Modellpaket-ARN oder einen Modellnamen als Eingabe. Geben Sie eines der folgenden Elemente an:
+ Der ARN des versionierten Modellpakets, das Sie erstellt haben, als Sie Ihr Modell bei der SageMaker AI-Modellregistrierung registriert haben. Definieren Sie dies für `ModelPackageVersionArn` in dem `InputConfig` Feld.
+ Den Namen des Modells, welches Sie erstellt haben. Definieren Sie dies für `ModelName` im `InputConfig` Feld. Geben Sie außerdem das `ContainerConfig` Wörterbuch an, das die erforderlichen Felder enthält, die mit dem Modellnamen versehen werden müssen. Definieren Sie dies für `ContainerConfig` in dem `InputConfig` Feld. In dem `ContainerConfig` können Sie das `SupportedEndpointType` Feld auch optional als entweder `RealTime` oder `Serverless` angeben. Wenn Sie dieses Feld angeben, gibt Inference Recommender nur Empfehlungen für diesen Endpunkttyp zurück. Wenn Sie dieses Feld nicht angeben, gibt Inference Recommender Empfehlungen für beide Endpunkttypen zurück.
+ Ein Name für Ihren Inference Recommender-Empfehlungsjob für das `JobName` Feld. Der Inference Recommender-Jobname muss innerhalb der AWS Region und in Ihrem Konto eindeutig sein. AWS
Importieren Sie das AWS SDK für Python (Boto3) Paket und erstellen Sie mithilfe der Client-Klasse ein SageMaker AI-Client-Objekt. Wenn Sie die Schritte im Abschnitt **Voraussetzungen** befolgt haben, geben Sie nur eine der folgenden Optionen an:
+ Option 1: Wenn Sie einen Job mit Inferenzempfehlungen mit einem Modellpaket-ARN erstellen möchten, speichern Sie den ARN der Modellpaketgruppe in einer Variablen namens `model_package_arn`.
+ Option 2: Wenn Sie einen Job mit Inferenzempfehlungen mit einem Modellnamen und `ContainerConfig` erstellen möchten, speichern Sie den Modellnamen in einer Variablen mit dem Namen `model_name` und das `ContainerConfig` Wörterbuch in einer Variablen mit dem Namen `container_config`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide only one of model package ARN or model name, not both.
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
## Uncomment if you would like to create an inference recommendations job with a
## model name instead of a model package ARN, and comment out model_package_arn above
## Provide your model name
# model_name = ''
## Provide your container config
# container_config = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = 'arn:aws:iam:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
# Provide only one of model package ARN or model name, not both.
# If you would like to create an inference recommendations job with a model name,
# uncomment ModelName and ContainerConfig, and comment out ModelPackageVersionArn.
InputConfig = {
'ModelPackageVersionArn': model_package_arn
# 'ModelName': model_name,
# 'ContainerConfig': container_config
}
)
```
Eine vollständige Liste der optionalen und erforderlichen Argumente, an die Sie übergeben können, finden Sie im [Amazon SageMaker API-Referenzhandbuch [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html).
------
#### [ AWS CLI ]
Verwenden Sie die `create-inference-recommendations-job`-API, um einen Job mit Inferenzempfehlungen zu starten. Stellen Sie das `job-type` Feld auf `'Default'` ehlungen ein. Darüber hinaus sind folgende Angaben zu machen:
+ Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die es Amazon SageMaker Inference Recommender ermöglicht, Aufgaben in Ihrem Namen auszuführen. Definieren Sie dies für das `role-arn` Feld.
+ Ein Modellpaket-ARN oder ein Modellname. Inference Recommender unterstützt entweder einen Modellpaket-ARN oder einen Modellnamen als Eingabe. Geben Sie eine der folgenden Möglichkeiten an
+ Der ARN des versionierten Modellpakets, das Sie bei der Registrierung Ihres Modells bei Model Registry erstellt haben. Definieren Sie dies für `ModelPackageVersionArn` in dem `input-config` Feld.
+ Den Namen des Modells, welches Sie erstellt haben. Definieren Sie dies für `ModelName` im `input-config` Feld. Geben Sie außerdem das `ContainerConfig` Wörterbuch an, das die erforderlichen Felder enthält, die mit dem Modellnamen versehen werden müssen. Definieren Sie dies für `ContainerConfig` in dem `input-config` Feld. In dem `ContainerConfig` können Sie das `SupportedEndpointType` Feld auch optional als entweder `RealTime` oder `Serverless` angeben. Wenn Sie dieses Feld angeben, gibt Inference Recommender nur Empfehlungen für diesen Endpunkttyp zurück. Wenn Sie dieses Feld nicht angeben, gibt Inference Recommender Empfehlungen für beide Endpunkttypen zurück.
+ Ein Name für Ihren Inference Recommender-Empfehlungsjob für das `job-name` Feld. Der Inference Recommender-Jobname muss innerhalb der AWS Region und innerhalb Ihres Kontos eindeutig sein. AWS
Verwenden Sie das folgende Beispiel, um Jobs für Inferenzempfehlungen mit einem Modellpaket-ARN zu erstellen:
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
}"
```
Verwenden Sie das folgende Beispiel, um Jobs mit einem Modellnamen und `ContainerConfig` einer Inferenzempfehlung zu erstellen. Das Beispiel verwendet das `SupportedEndpointType` Feld, um anzugeben, dass wir nur Inferenzempfehlungen in Echtzeit zurückgeben möchten:
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelName\": \"model-name\",
\"ContainerConfig\" : {
\"Domain\": \"COMPUTER_VISION\",
\"Framework\": \"PYTORCH\",
\"FrameworkVersion\": \"1.7.1\",
\"NearestModelName\": \"resnet18\",
\"PayloadConfig\":
{
\"SamplePayloadUrl\": \"s3://{bucket}/{payload_s3_key}\",
\"SupportedContentTypes\": [\"image/jpeg\"]
},
\"SupportedEndpointType\": \"RealTime\",
\"DataInputConfig\": \"[[1,3,256,256]]\",
\"Task\": \"IMAGE_CLASSIFICATION\",
},
}"
```
------
#### [ Amazon SageMaker Studio Classic ]
Erstellen Sie einen Inferenzempfehlungsauftrag in Studio Classic.
1. Wählen Sie in Ihrer Studio-Classic-Anwendung das Startsymbol (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/studio/icons/house.png)) aus.
1. Wählen Sie in der linken Seitenleiste von Studio Classic die Option **Modelle** aus.
1. Wählen Sie in der Dropdown-Liste die Option **Modellregistrierung** aus, um die Modelle anzuzeigen, die Sie in der Modellregistrierung registriert haben.
Im linken Bereich wird eine Liste von Modellgruppen angezeigt. Die Liste enthält alle Modellgruppen, die bei der Model Registry in Ihrem Konto registriert sind, einschließlich Modelle, die außerhalb von Studio Classic registriert sind.
1. Wählen Sie den Namen der Modellgruppe aus. Wenn Sie Ihre Modellgruppe auswählen, werden im rechten Bereich von Studio Classic Spaltenüberschriften wie **Versionen** und **Einstellungen** angezeigt.
Wenn Sie ein oder mehrere Modellpakete in Ihrer Modellgruppe haben, wird in der Spalte **Versionen** eine Liste dieser Modellpakete angezeigt.
1. Wählen Sie die Spalte **Inference Recommender** aus.
1. Wählen Sie eine IAM-Rolle, die Inference Recommender die Erlaubnis erteilt, auf Dienste zuzugreifen. AWS Sie können dafür eine Rolle erstellen und die von `AmazonSageMakerFullAccess` IAM verwaltete Richtlinie anfügen. Oder Sie können Studio Classic eine Rolle für Sie erstellen lassen.
1. Wählen Sie **Get recommendations (Empfehlungen erhalten)**.
Die Inferenzempfehlung kann bis zu 45 Minuten dauern.
**Warnung**
Schließen Sie diese Registerkarte nicht. Wenn Sie diese Registerkarte schließen, brechen Sie den Job mit der Instance-Empfehlung ab.
------
#### [ SageMaker AI console ]
Erstellen Sie einen Instanzempfehlungsjob über die SageMaker AI-Konsole, indem Sie wie folgt vorgehen:
1. Gehen Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie in der linken Navigationsleiste **Inferenz** und wählen Sie dann **Inferenzempfehlung**.
1. Wählen Sie auf der Seite **Inferenz Empfehlungsgeber Aufträge** die Option **Job erstellen** aus.
1. Für **Schritt 1: Modellkonfiguration** gehen Sie wie folgt vor:
1. Wählen Sie als **Jobtyp** die Option **Standard-Empfehlungsjob aus**.
1. Wenn Sie ein Modell verwenden, das in der SageMaker AI-Modellregistrierung registriert ist, aktivieren Sie die **Option Modell aus der Modellregistrierung auswählen** und gehen Sie wie folgt vor:
1. Wählen Sie aus der Dropdownliste **Modellgruppe** die Modellgruppe in der SageMaker AI-Modellregistrierung aus, in der sich Ihr Modell befindet.
1. Wählen Sie aus der Dropdown-Liste **Modellversion** die gewünschte Version Ihres Modells aus.
1. Wenn Sie ein Modell verwenden, das Sie in SageMaker AI erstellt haben, deaktivieren Sie die Option **Modell aus der Modellregistrierung auswählen** und gehen Sie wie folgt vor:
1. Geben Sie in das Feld **Modellname** den Namen Ihres SageMaker KI-Modells ein.
1. Aus der Dropdownliste für die **IAM-Rolle** können Sie eine bestehende AWS IAM-Rolle auswählen, die über die erforderlichen Berechtigungen verfügt, um einen Instanzempfehlungsjob zu erstellen. Wenn Sie noch keine Rolle haben, können Sie alternativ **Neue Rolle erstellen** wählen, um das Pop-up zur Rollenerstellung zu öffnen. SageMaker AI fügt dann der neuen Rolle, die Sie erstellen, die erforderlichen Berechtigungen hinzu.
1. Geben Sie für **S3-Bucket for Benchmarking Payload** den Amazon S3-Pfad zu Ihrem Beispiel-Payload-Archiv ein, das Beispiel-Payload-Dateien enthalten sollte, die Inference Recommender verwendet, um Ihr Modell auf verschiedenen Instance-Typen zu vergleichen.
1. Geben Sie als **Payload-Inhaltstyp** die MIME-Typen Ihrer Beispiel-Payload-Daten ein.
1. (Optional) Wenn Sie die Option **Modell aus der Modellregistrierung auswählen** deaktiviert und ein SageMaker KI-Modell angegeben haben, gehen Sie für die **Container-Konfiguration** wie folgt vor:
1. Wählen Sie in der Dropdown-Liste **Domain** die Domain für Machine Learning des Modells aus, z. B. Computer Vision, Verarbeitung natürlicher Sprache oder Machine Learning.
1. **Wählen Sie in der Dropdownliste Framework das Framework Ihres Containers aus, z. B. TensorFlow oder.** XGBoost
1. Geben Sie als **Framework-Version** die Framework-Version Ihres Container-Images ein.
1. Wählen Sie in der Dropdown-Liste **Nächster Modellname** das vortrainierte Modell aus, das Ihrem Modell am ehesten entspricht.
1. Wählen Sie in der Dropdown-Liste **Aufgabe** die maschinelle Lernaufgabe aus, die das Modell erfüllt, z. B. Bildklassifizierung oder Regression.
1. (Optional) Für die **Modellkompilierung mit SageMaker Neo** können Sie den Empfehlungsjob für ein Modell konfigurieren, das Sie mit SageMaker Neo kompiliert haben. Geben Sie für die **Konfiguration der Dateneingabe** die richtige Form der Eingabedaten für Ihr Modell in einem Format ein, das dem `{'input':[1,1024,1024,3]}` ähnelt.
1. Wählen Sie **Weiter** aus.
1. Bei **Schritt 2: Instances und Umgebungsparameter** gehen Sie wie folgt vor:
1. (Optional) Für **Select Instances for Benchmarking** können Sie bis zu 8 Instance-Typen auswählen, die Sie benchmarken möchten. Wenn Sie keine Instances auswählen, berücksichtigt Inference Recommender alle Instance-Typen.
1. Wählen Sie **Weiter** aus.
1. Für **Schritt 3: Auftragsparameter** gehen Sie wie folgt vor:
1. (Optional) Geben Sie für das Feld **Jobname** einen Namen für Ihren Instance-Empfehlungsjob ein. Wenn Sie den Job erstellen, hängt SageMaker KI einen Zeitstempel an das Ende dieses Namens an.
1. (Optional) Geben Sie in das Feld **Auftragsbeschreibung** eine Beschreibung für den Auftrag ein.
1. (Optional) Wählen Sie in der Dropdownliste **Verschlüsselungsschlüssel** einen AWS KMS Schlüssel nach Namen aus oder geben Sie seinen ARN ein, um Ihre Daten zu verschlüsseln.
1. (Optional) Geben Sie unter **Max. Testdauer (s)** die maximale Anzahl von Sekunden ein, für die jeder Test ausgeführt werden soll.
1. (Optional) Geben Sie für **Max. Aufrufe pro Minute** die maximale Anzahl von Anfragen pro Minute ein, die der Endpunkt erreichen kann, bevor der Empfehlungsjob beendet wird. Nach Erreichen dieses Grenzwerts beendet SageMaker KI den Job.
1. (Optional) Geben Sie für den **Latenzschwellenwert (ms) des Modells P99** den Latenzwert des Modells in Millisekunden ein.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie für Schritt 4: **Job überprüfen** Ihre Konfigurationen und wählen Sie dann **Senden** aus.
------
# Rufen Sie die Ergebnisse Ihrer Inferenzempfehlung ab.
Erfassen Sie die Ergebnisse Ihres Jobs mit Inferenzempfehlungen programmgesteuert mit AWS SDK für Python (Boto3) der AWS CLI Studio Classic- oder der SageMaker AI-Konsole.
------
#### [ AWS SDK für Python (Boto3) ]
Sobald eine Inferenzempfehlung abgeschlossen ist, können Sie sie verwenden, `DescribeInferenceRecommendationsJob` um die Auftragsdetails und Empfehlungen abzurufen. Geben Sie den Jobnamen ein, den Sie bei der Erstellung des Jobs für Inferenzempfehlungen verwendet haben.
```
job_name=''
response = sagemaker_client.describe_inference_recommendations_job(
JobName=job_name)
```
Drucken Sie das Antwortobjekt aus. Im vorherigen Codebeispiel wurde die Antwort in einer Variable namens `response` gespeichert.
```
print(response['Status'])
```
Dies gibt eine JSON-Antwort ähnlich dem folgenden Beispiel zurück. Beachten Sie, dass dieses Beispiel die empfohlenen Instance-Typen für Echtzeit-Inferenzen zeigt (ein Beispiel mit Empfehlungen für serverlose Inferenzen finden Sie im nachfolgenden Beispiel).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
Die ersten Zeilen enthalten Informationen über den Job mit Inferenzempfehlungen selbst. Dazu gehören der Jobname, der Rollen-ARN sowie die Erstellungs- und Löschzeiten.
Das `InferenceRecommendations` Wörterbuch enthält eine Liste von Inference Recommender-Inferenzempfehlungen.
Das `EndpointConfiguration` verschachtelte Wörterbuch enthält die Empfehlung für den Instanztyp (`InstanceType`) sowie den Endpunkt- und Variantennamen (ein bereitgestelltes Modell für AWS maschinelles Lernen), die während des Empfehlungsjobs verwendet wurden. Sie können den Endpunkt und den Variantennamen für die Überwachung in Amazon CloudWatch Events verwenden. Weitere Informationen finden Sie unter [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md).
Das `Metrics` verschachtelte Wörterbuch enthält Informationen über die geschätzten Kosten pro Stunde (`CostPerHour`) für Ihren Echtzeit-Endpunkt in US-Dollar, die geschätzten Kosten pro Inferenz (`CostPerInference`) in US-Dollar für Ihren Echtzeit-Endpunkt, die erwartete maximale Anzahl von `InvokeEndpoint` Anfragen pro Minute, die an den Endpunkt gesendet wurden (`MaxInvocations`) und die Modelllatenz (`ModelLatency`), also das Zeitintervall (in Mikrosekunden), das Ihr Modell benötigt hat, um auf KI zu reagieren. SageMaker Dieses Intervall enthält die lokale Kommunikationszeitspanne für das Senden der Anforderung und Abrufen der Antwort vom Container eines Modells sowie die Zeitspanne für das Abschließen der Inferenz im Container.
Das folgende Beispiel zeigt den `InferenceRecommendations` Teil der Antwort für einen Job mit Inferenzempfehlungen, der so konfiguriert ist, dass er serverlose Inferenzempfehlungen zurückgibt:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Sie können die Empfehlungen für die serverlose Inferenz ähnlich wie die Ergebnisse für die Echtzeit-Inferenz interpretieren, mit Ausnahme von `ServerlessConfig`, das Ihnen die Metriken angibt, die für einen serverlosen Endpunkt mit dem angegebenen `MemorySizeInMB` und wann `MaxConcurrency = 1` zurückgegeben werden. Um den auf dem Endpunkt möglichen Durchsatz zu erhöhen, erhöhen Sie den Wert `MaxConcurrency` linear. Wenn zum Beispiel die Schlussfolgerungsempfehlung `MaxInvocations` als `1000` ausweist, dann würde die Erhöhung von `MaxConcurrency` auf `2` 2000 `MaxInvocations` unterstützen. Beachten Sie, dass dies nur bis zu einem bestimmten Punkt gilt, der je nach Modell und Code variieren kann. Serverlose Empfehlungen messen auch die Metrik `ModelSetupTime`, die (in Mikrosekunden) die Zeit misst, die benötigt wird, um Computerressourcen auf einem serverlosen Endpunkt zu starten. Weitere Informationen zum Festlegen serverloser Endpunkte finden Sie in der [Serverless Inferenz-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ AWS CLI ]
Sobald eine Inferenzempfehlung abgeschlossen ist, können Sie `describe-inference-recommendations-job` verwenden, um die Auftragsdetails und die empfohlenen Instance-Typen abzurufen. Geben Sie den Jobnamen an, den Sie bei der Erstellung des Jobs für die Inferenzempfehlung verwendet haben.
```
aws sagemaker describe-inference-recommendations-job\
--job-name \
--region
```
Die JSON-Antwort sollte dem folgenden Beispiel ähneln. Beachten Sie, dass dieses Beispiel die empfohlenen Instance-Typen für Echtzeit-Inferenzen zeigt (ein Beispiel mit Empfehlungen für serverlose Inferenzen finden Sie im nachfolgenden Beispiel).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
Die ersten Zeilen enthalten Informationen über den Job mit Inferenzempfehlungen selbst. Dazu gehören der Jobname, der Rollen-ARN, die Erstellungs- und Löschzeit.
Das `InferenceRecommendations` Wörterbuch enthält eine Liste von Inference Recommender-Inferenzempfehlungen.
Das `EndpointConfiguration` verschachtelte Wörterbuch enthält die Empfehlung für den Instanztyp (`InstanceType`) zusammen mit dem Endpunkt und dem Variantennamen (ein bereitgestelltes Modell für AWS maschinelles Lernen), die während des Empfehlungsjobs verwendet wurden. Sie können den Endpunkt und den Variantennamen für die Überwachung in Amazon CloudWatch Events verwenden. Weitere Informationen finden Sie unter [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md).
Das `Metrics` verschachtelte Wörterbuch enthält Informationen zu den geschätzten Kosten pro Stunde (`CostPerHour`) für Ihren Echtzeit-Endpunkt in US-Dollar, zu den geschätzten Kosten pro Inferenz (`CostPerInference`) in US-Dollar für Ihren Echtzeit-Endpunkt, zur erwarteten maximalen Anzahl von `InvokeEndpoint` Anfragen pro Minute, die an den Endpunkt gesendet werden (`MaxInvocations`), und zur Modelllatenz (`ModelLatency`), d. h. das Zeitintervall (in Millisekunden), das Ihr Modell benötigt hat, um auf SageMaker KI zu reagieren. Dieses Intervall enthält die lokale Kommunikationszeitspanne für das Senden der Anforderung und Abrufen der Antwort vom Container eines Modells sowie die Zeitspanne für das Abschließen der Inferenz im Container.
Das folgende Beispiel zeigt den `InferenceRecommendations` Teil der Antwort für einen Job mit Inferenzempfehlungen, der so konfiguriert ist, dass er serverlose Inferenzempfehlungen zurückgibt:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Sie können die Empfehlungen für die serverlose Inferenz ähnlich wie die Ergebnisse für die Echtzeit-Inferenz interpretieren, mit Ausnahme von `ServerlessConfig`, das Ihnen die Metriken angibt, die für einen serverlosen Endpunkt mit dem angegebenen `MemorySizeInMB` und wann `MaxConcurrency = 1` zurückgegeben werden. Um den auf dem Endpunkt möglichen Durchsatz zu erhöhen, erhöhen Sie den Wert `MaxConcurrency` linear. Wenn zum Beispiel die Schlussfolgerungsempfehlung `MaxInvocations` als `1000` ausweist, dann würde die Erhöhung von `MaxConcurrency` auf `2` 2000 `MaxInvocations` unterstützen. Beachten Sie, dass dies nur bis zu einem bestimmten Punkt gilt, der je nach Modell und Code variieren kann. Serverlose Empfehlungen messen auch die Metrik `ModelSetupTime`, die (in Mikrosekunden) die Zeit misst, die benötigt wird, um Computerressourcen auf einem serverlosen Endpunkt zu starten. Weitere Informationen zum Festlegen serverloser Endpunkte finden Sie in der [Serverless Inferenz-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ Amazon SageMaker Studio Classic ]
Die Inferenzempfehlungen werden in Studio Classic auf einer neuen Registerkarte namens **Inferenzempfehlungen** angezeigt. Es kann bis zu 45 Minuten dauern, bis die Ergebnisse angezeigt werden. Diese Registerkarte enthält die Spaltenüberschriften **Ergebnisse** und **Details**.
Die Spalte **Details** enthält Informationen über den Job für die Inferenzempfehlung, z. B. den Namen der Inferenzempfehlung, den Zeitpunkt der Erstellung des Jobs (**Erstellungszeit**) und mehr. Sie enthält auch **Einstellungsinformationen**, wie z. B. die maximale Anzahl von Aufrufen pro Minute und Informationen zu den verwendeten Amazon-Ressourcennamen.
Die Spalte **Ergebnisse** enthält ein Fenster mit **Bereitstellungszielen** und **SageMaker KI-Empfehlungen**, in dem Sie die Reihenfolge, in der die Ergebnisse angezeigt werden, je nach Wichtigkeit der Bereitstellung anpassen können. Es gibt drei Dropdown-Menüs, mit denen Sie angeben können, wie wichtig **Kosten**, **Latenz** und **Durchsatz** für Ihren Anwendungsfall sind. Für jedes Ziel (Kosten, Latenz und Durchsatz) können Sie die Prioritätsstufe festlegen: **Niedrigste Wichtigkeit**, **Niedrige Wichtigkeit**, **Mittlere Wichtigkeit**, **Hohe Wichtigkeit** oder **Höchste Wichtigkeit**.
**Basierend auf Ihrer Auswahl der Wichtigkeit für jedes Ziel zeigt Inference Recommender die wichtigste Empfehlung im Empfehlungsfeld auf der SageMaker rechten Seite des Fensters an, zusammen mit den geschätzten Kosten pro Stunde und der Inferenzanfrage.** Es bietet auch Informationen über die erwartete Modelllatenz, die maximale Anzahl von Aufrufen und die Anzahl der Instances. Bei Empfehlungen für serverlose Server können Sie sich die idealen Werte für die maximale Parallelität und die Speichergröße des Endpunkts anzeigen lassen.
Zusätzlich zur Anzeige der wichtigsten Empfehlung werden im Abschnitt **Alle Ausführungen** dieselben Informationen für alle Instances angezeigt, die Inference Recommender getestet hat.
------
#### [ SageMaker AI console ]
Sie können Ihre Instanzempfehlungsaufträge in der SageMaker AI-Konsole wie folgt anzeigen:
1. Gehen Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie in der linken Navigationsleiste **Inferenz** und wählen Sie dann **Inferenzempfehlung**.
1. Wählen Sie auf der Seite **Inferenzempfehlungsaufträge** den Namen Ihres Jobs für Inference Recommender aus.
Auf der Detailseite für Ihren Job können Sie sich die **Inferenzempfehlungen** ansehen. Dabei handelt es sich um die Instanztypen, die SageMaker KI für Ihr Modell empfiehlt, wie im folgenden Screenshot dargestellt.
![\[Screenshot der Liste der Inferenzempfehlungen auf der Seite mit den Jobdetails in der SageMaker AI-Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
In diesem Abschnitt können Sie die Instance-Typen anhand verschiedener Faktoren wie **Modelllatenz**, **Kosten pro Stunde**, **Kosten pro Inferenz** und **Aufrufe pro Minute vergleichen**.
Auf dieser Seite können Sie auch die Konfigurationen anzeigen, die Sie für Ihren Job angegeben haben. Im Bereich **Monitor** können Sie die CloudWatch Amazon-Metriken einsehen, die für jeden Instance-Typ protokolliert wurden. Weitere Informationen zur Interpretation dieser Metriken finden Sie unter [Interpretieren von Ergebnissen](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html).
------
Weitere Informationen zum Interpretieren der Ergebnisse aus Ihrem Empfehlungsjob finden Sie unter [Empfehlungsergebnisse](inference-recommender-interpret-results.md).
# Holen Sie sich eine Inferenzempfehlung für einen vorhandenen Endpunkt
Jobs mit Inferenzempfehlungen führen eine Reihe von Lasttests für empfohlene Instance-Typen und einen vorhandenen Endpunkt durch. Inferenzempfehlungsjobs verwenden Leistungsmetriken, die auf Lasttests mit den Beispieldaten basieren, die Sie bei der Registrierung der Modellversion angegeben haben.
Sie können einen vorhandenen SageMaker KI-Inferenz-Endpunkt vergleichen und Inferenzempfehlungen für ihn abrufen, um die Leistung Ihres Endpunkts zu verbessern. Das Verfahren zum Abrufen von Empfehlungen für einen vorhandenen SageMaker KI-Inferenzendpunkt ähnelt dem Verfahren zum [Abrufen von Inferenzempfehlungen](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html) ohne Endpunkt. Beim Benchmarking eines vorhandenen Endpunkts sind mehrere Funktionsausschlüsse zu beachten:
+ Sie können nur einen vorhandenen Endpunkt pro Inference Recommender-Job verwenden.
+ Sie können nur eine Variante auf Ihrem Endpunkt haben.
+ Sie können keinen Endpunkt verwenden, der Autoscaling aktiviert.
+ Diese Funktionalität wird nur für [Real-Time-Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) unterstützt.
+ Diese Funktion unterstützt keine [Echtzeit-Endpunkte mit mehreren Modellen](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html).
**Warnung**
Es wird dringend davon abgeraten, Inference Recommender-Jobs auf einem Produktionsendpunkt auszuführen, der Live-Traffic verarbeitet. Die synthetische Belastung beim Benchmarking kann sich auf Ihren Produktionsendpunkt auswirken und zu Drosselungen führen oder zu ungenauen Benchmark-Ergebnissen führen. Wir empfehlen Ihnen, zu Vergleichszwecken einen Endpunkt zu verwenden, der nicht für die Produktion oder für Entwickler bestimmt ist.
In den folgenden Abschnitten wird gezeigt, wie Sie Amazon SageMaker Inference Recommender verwenden, um mithilfe des AWS SDK for Python (Boto3) und des eine Inferenzempfehlung für einen vorhandenen Endpunkt zu erstellen, die auf Ihrem Modelltyp basiert. AWS CLI
**Anmerkung**
Bevor Sie einen Inference Recommender-Empfehlungsauftrag erstellen, stellen Sie sicher, dass Sie die [Voraussetzungen für die Verwendung von Amazon SageMaker Inference Recommender](inference-recommender-prerequisites.md) Anforderungen erfüllt haben.
## Voraussetzungen
[Wenn Sie noch keinen SageMaker KI-Inferenz-Endpunkt haben, können Sie entweder eine [Inferenzempfehlung ohne Endpunkt erhalten oder Sie können einen Echtzeit-Inferenz-Endpunkt](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html) erstellen, indem Sie den Anweisungen unter Erstellen Sie Ihren Endpunkt und Bereitstellen Ihres Modells folgen.](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html)
## Erstellen Sie einen Job mit Inferenzempfehlungen für einen vorhandenen Endpunkt
Erstellen Sie programmgesteuert eine Inferenzempfehlung mit, oder. AWS SDK für Python (Boto3) AWS CLI Geben Sie einen Jobnamen für Ihre Inferenzempfehlung, den Namen eines vorhandenen SageMaker KI-Inferenz-Endpunkts, einen AWS IAM-Rollen-ARN, eine Eingabekonfiguration und Ihren Modellpaket-ARN an, seit Sie Ihr Modell bei der Modellregistrierung registriert haben.
------
#### [ AWS SDK für Python (Boto3) ]
Verwenden Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)API, um eine Inferenzempfehlung zu erhalten. Stellen Sie das `JobType` Feld auf `'Default'` ehlungen ein. Darüber hinaus sind folgende Angaben zu machen:
+ Geben Sie einen Namen für Ihren Inference Recommender-Empfehlungsjob für das `JobName` Feld ein. Der Inference Recommender-Jobname muss innerhalb der AWS Region und in Ihrem Konto eindeutig sein. AWS
+ Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die es Inference Recommender ermöglicht, Aufgaben in Ihrem Namen durchzuführen. Definieren Sie dies für das `RoleArn` Feld.
+ Der ARN des versionierten Modellpakets, das Sie erstellt haben, als Sie Ihr Modell in der Modellregistrierung registriert haben. Definieren Sie dies für `ModelPackageVersionArn` in dem `InputConfig` Feld.
+ Geben Sie vor Ort den Namen eines vorhandenen SageMaker KI-Inferenz-Endpunkts ein, für den Sie in Inference Recommender einen Benchmark durchführen möchten. `Endpoints` `InputConfig`
Importieren Sie das AWS SDK für Python (Boto3) Paket und erstellen Sie mithilfe der SageMaker Client-Klasse ein AI-Client-Objekt. Wenn Sie die Schritte im Abschnitt **Voraussetzungen** befolgt haben, wurde die Modellpaketgruppe ARN in einer Variablen mit dem Namen `model_package_arn` gespeichert.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = ':role/*>'
# Provide endpoint name for your endpoint that want to benchmark in Inference Recommender
endpoint_name = ''
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
InputConfig = {
'ModelPackageVersionArn': model_package_arn,
'Endpoints': [{'EndpointName': endpoint_name}]
}
)
```
Eine vollständige Liste der optionalen und erforderlichen Argumente, an die Sie übergeben können, finden Sie im [Amazon SageMaker API-Referenzhandbuch [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html).
------
#### [ AWS CLI ]
Verwenden Sie die `create-inference-recommendations-job` API, um eine Empfehlung für einen Instance-Endpunkt zu erhalten. Setzen Sie das Feld `job-type` für Instance-Endpunkt-Empfehlungsaufträge auf `'Default'`. Darüber hinaus sind folgende Angaben zu machen:
+ Geben Sie einen Namen für Ihren Inference Recommender-Empfehlungsjob für das `job-name` Feld ein. Der Jobname von Inference Recommender muss innerhalb der AWS Region und innerhalb Ihres AWS Kontos eindeutig sein.
+ Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die es Amazon SageMaker Inference Recommender ermöglicht, Aufgaben in Ihrem Namen auszuführen. Definieren Sie dies für das `role-arn` Feld.
+ Der ARN des versionierten Modellpakets, das Sie bei der Registrierung Ihres Modells bei Model Registry erstellt haben. Definieren Sie dies für `ModelPackageVersionArn` in dem `input-config` Feld.
+ Geben Sie den Namen eines vorhandenen SageMaker KI-Inferenz-Endpunkts an, für den Sie im Inference Recommender einen Benchmark vor Ort durchführen möchten. `Endpoints` `input-config`
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
\"Endpoints\": [{\"EndpointName\": }]
}"
```
------
## Holen Sie sich die Job-Ergebnisse Ihrer Inferenzempfehlung
Sie können die Ergebnisse Ihres Jobs mit Inferenzempfehlungen programmgesteuert sammeln. Gehen Sie dabei genauso vor wie bei Standardjobs mit Inferenzempfehlungen. Weitere Informationen finden Sie unter [Rufen Sie die Ergebnisse Ihrer Inferenzempfehlung ab.](instance-recommendation-results.md).
Wenn Sie Ergebnisse des Jobs mit Inferenzempfehlungen für einen vorhandenen Endpunkt erhalten, sollten Sie eine JSON-Antwort erhalten, die der folgenden ähnelt:
```
{
"JobName": "job-name",
"JobType": "Default",
"JobArn": "arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id",
"RoleArn": "iam-role-arn",
"Status": "COMPLETED",
"CreationTime": 1664922919.2,
"LastModifiedTime": 1664924208.291,
"InputConfig": {
"ModelPackageVersionArn": "arn:aws:sagemaker:region:account-id:model-package/resource-id",
"Endpoints": [
{
"EndpointName": "endpoint-name"
}
]
},
"InferenceRecommendations": [
{
"Metrics": {
"CostPerHour": 0.7360000014305115,
"CostPerInference": 7.456940238625975e-06,
"MaxInvocations": 1645,
"ModelLatency": 171
},
"EndpointConfiguration": {
"EndpointName": "sm-endpoint-name",
"VariantName": "variant-name",
"InstanceType": "ml.g4dn.xlarge",
"InitialInstanceCount": 1
},
"ModelConfiguration": {
"EnvironmentParameters": [
{
"Key": "TS_DEFAULT_WORKERS_PER_MODEL",
"ValueType": "string",
"Value": "4"
}
]
}
}
],
"EndpointPerformances": [
{
"Metrics": {
"MaxInvocations": 184,
"ModelLatency": 1312
},
"EndpointConfiguration": {
"EndpointName": "endpoint-name"
}
}
]
}
```
Die ersten Zeilen enthalten Informationen über den Job mit Inferenzempfehlungen selbst. Dazu gehören der Jobname, der Rollen-ARN sowie die Erstellungs- und letzten Änderungszeiten.
Das `InferenceRecommendations` Wörterbuch enthält eine Liste von Inference Recommender-Inferenzempfehlungen.
Das `EndpointConfiguration` verschachtelte Wörterbuch enthält die Empfehlung für den Instanztyp (`InstanceType`) sowie den Endpunkt- und Variantennamen (ein bereitgestelltes Modell für AWS maschinelles Lernen), die während des Empfehlungsjobs verwendet wurden.
Das `Metrics` verschachtelte Wörterbuch enthält Informationen zu den geschätzten Kosten pro Stunde (`CostPerHour`) für Ihren Echtzeit-Endpunkt in US-Dollar, zu den geschätzten Kosten pro Inferenz (`CostPerInference`) in US-Dollar für Ihren Echtzeit-Endpunkt, zur erwarteten maximalen Anzahl von `InvokeEndpoint` Anfragen pro Minute, die an den Endpunkt gesendet werden (`MaxInvocations`), und zur Modelllatenz (`ModelLatency`), d. h. das Zeitintervall (in Millisekunden), das Ihr Modell benötigt hat, um auf SageMaker KI zu reagieren. Die Modelllatenz umfasst die lokalen Kommunikationszeiten für das Senden der Anfrage und das Abrufen der Antwort aus dem Container eines Modells sowie die Zeit, die für den Abschluss der Inferenz im Container benötigt wird.
Das `EndpointPerformances` verschachtelte Wörterbuch enthält den Namen Ihres vorhandenen Endpunkts, auf dem der Empfehlungsjob ausgeführt wurde (`EndpointName`), und die Leistungskennzahlen für Ihren Endpunkt (`MaxInvocations`und`ModelLatency`).
# Stoppen Sie Ihre Inferenzempfehlung
Möglicherweise möchten Sie einen Auftrag beenden, der gerade ausgeführt wird, weil Sie ihn versehentlich gestartet haben oder ihn nicht mehr benötigen. Beenden Sie Ihre Inference Recommender-Jobs mit Inference Recommender programmgesteuert mit der `StopInferenceRecommendationsJob` API oder mit Studio Classic.
------
#### [ AWS SDK für Python (Boto3) ]
Geben Sie den Namen des Jobs für die Inferenzempfehlung für das `JobName` Feld an:
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
Geben Sie den Jobnamen des Jobs für die Inferenzempfehlung für das Kennzeichen `job-name` an:
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
Schließen Sie die Registerkarte, in der Sie die Inferenzempfehlung initiiert haben, um Ihre Inference Recommender-Inferenzempfehlung zu beenden.
------
#### [ SageMaker AI console ]
Gehen Sie wie folgt vor, um Ihren Instance-Empfehlungsjob über die SageMaker AI-Konsole zu beenden:
1. Gehen Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im linken Navigationsbereich **Inferenz** und dann **Inferenzempfehlung** aus.
1. Wählen Sie auf der Seite **Inference Recommender Jobs Ihren Instance-Empfehlungsjob** aus.
1. Wählen Sie **Stop job (Testauftrag stoppen)**.
1. Wählen Sie im daraufhin angezeigten Dialogfeld die Option **Confirm** (Bestätigen) aus.
Nachdem Sie Ihren Job beendet haben, sollte sich der **Status** des Jobs auf **Stoppt** ändern.
------
# Mit Neo zusammengestellte Empfehlungen
In Inference Recommender können Sie Ihr Modell mit Neo kompilieren und Endpunktempfehlungen für Ihr kompiliertes Modell abrufen. [SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) ist ein Service, der Ihr Modell für eine Zielhardwareplattform (d. h. einen bestimmten Instanztyp oder eine bestimmte Umgebung) optimieren kann. Die Optimierung eines Modells mit Neo kann die Leistung Ihres gehosteten Modells verbessern.
Für von NEO unterstützte Frameworks und Container schlägt Inference Recommender automatisch NEO-optimierte Empfehlungen vor. Um für die Neo-Kompilierung in Frage zu kommen, muss Ihr Input die folgenden Voraussetzungen erfüllen:
+ Sie verwenden einen SageMaker KI-eigenen [DLC](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) oder XGBoost Container.
+ Sie verwenden eine Framework-Version, die von Neo unterstützt wird. Die von Neo unterstützten Framework-Versionen finden Sie [Cloud-Instances](neo-supported-cloud.md#neo-supported-cloud-instances) in der SageMaker Neo-Dokumentation.
+ Neo erfordert, dass Sie eine korrekte Eingabedatenform für Ihr Modell angeben. Sie können diese Datenform als `[DataInputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelInput.html#sagemaker-Type-ModelInput-DataInputConfig)` im `[InferenceSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-InferenceSpecification)` angeben, wenn Sie ein Modellpaket erstellen. Informationen zu den richtigen Datenformen für jedes Framework finden Sie in der SageMaker Neo-Dokumentation unter [Modell für die Kompilierung vorbereiten](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html).
Das folgende Beispiel zeigt, wie das `DataInputConfig` Feld in der `InferenceSpecification` angegeben wird. Dabei handelt es sich um eine Variable `data_input_configuration`, die die Datenform im Wörterbuchformat enthält (z. B. `{'input':[1,1024,1024,3]}`).
```
"InferenceSpecification": {
"Containers": [
{
"Image": dlc_uri,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": model_name,
"ModelInput": {"DataInputConfig": data_input_configuration},
}
],
"SupportedContentTypes": input_mime_types, # required, must be non-null
"SupportedResponseMIMETypes": [],
"SupportedRealtimeInferenceInstanceTypes": supported_realtime_inference_types, # optional
}
```
Wenn diese Bedingungen in Ihrer Anfrage erfüllt sind, führt Inference Recommender Szenarien sowohl für kompilierte als auch für unkompilierte Versionen Ihres Modells aus, sodass Sie aus mehreren Empfehlungskombinationen wählen können. Sie können die Konfigurationen für kompilierte und unkompilierte Versionen derselben Inferenzempfehlung vergleichen und herausfinden, welche am besten zu Ihrem Anwendungsfall passt. Die Empfehlungen sind nach den Kosten pro Inferenz geordnet.
Um die Empfehlungen zur Neo-Kompilierung zu erhalten, müssen Sie keine zusätzliche Konfiguration vornehmen, außer sicherzustellen, dass Ihre Eingabe die zuvor genannten Anforderungen erfüllt. Inference Recommender führt automatisch die Neo-Kompilierung auf Ihrem Modell durch, wenn Ihre Eingabe die Anforderungen erfüllt, und Sie erhalten eine Antwort, die Neo-Empfehlungen enthält.
Falls bei der Neo-Kompilierung Fehler auftreten, finden Sie weitere Informationen unter [Beheben von NEO-Kompilierungsfehlern](neo-troubleshooting-compilation.md).
Die folgende Tabelle ist ein Beispiel für eine Antwort, die Sie möglicherweise von einem Inference Recommender-Job erhalten, der Empfehlungen für kompilierte Modelle enthält. Wenn das `InferenceSpecificationName` Feld den Wert hat `None`, handelt es sich bei der Empfehlung um ein unkompiliertes Modell. Die letzte Zeile, in der sich der Wert für das **InferenceSpecificationName**Feld befindet`neo-00011122-2333-4445-5566-677788899900`, bezieht sich auf ein mit Neo kompiliertes Modell. Der Wert im Feld ist der Name des Neo-Jobs, der zur Kompilierung und Optimierung Ihres Modells verwendet wird.
| EndpointName | InstanceType | InitialInstanceCount | EnvironmentParameters | CostPerHour | CostPerInference | MaxInvocations | ModelLatency | InferenceSpecificationName |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| sm-epc-example-000111222 | ml.c5.9xlarge | 1 | [] | 1,836 | 9,15E-07 | 33456 | 7 | Keine |
| sm-epc-example-111222333 | ml.c5.2xlarge | 1 | [] | 0,408 | 2,11E-07 | 32211 | 21 | Keine |
| sm-epc-example-222333444 | ml.c5.xlarge | 1 | [] | 0,204 | 1,86E-07 | 18276 | 92 | Keine |
| sm-epc-example-333444555 | ml.c5.xlarge | 1 | [] | 0,204 | 1,60E-07 | 21286 | 42 | neo-00011122-2333-4445-5566-677788899900 |
## Erste Schritte
Die allgemeinen Schritte zur Erstellung eines Inference Recommender-Jobs, der NEO-optimierte Empfehlungen enthält, lauten wie folgt:
+ Bereiten Sie Ihr ML-Modell für die Kompilierung vor. Weitere Informationen finden Sie unter [Modell für die Kompilierung vorbereiten](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html) in der Neo-Dokumentation.
+ Package Sie Ihr Modell in einem Modellarchiv (`.tar.gz` Datei).
+ Erstellen Sie ein Beispiel-Payload-Archiv.
+ Registrieren Sie Ihr Modell in der SageMaker Modellregistrierung.
+ Erstellen Sie einen Inference Recommender-Job.
+ Sehen Sie sich die Ergebnisse des Inference Recommender-Jobs an und wählen Sie eine Konfiguration aus.
+ Debuggen Sie Kompilierungsfehler, falls vorhanden. Weitere Informationen finden Sie unter [Fehlerbehebung bei Neo-Kompilierungsfehlern](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html).
Ein Beispiel, das den vorherigen Arbeitsablauf und die Verwendung von NEO-optimierten Empfehlungen demonstriert XGBoost, finden Sie im folgenden [Beispiel-Notizbuch](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb). Ein Beispiel, das zeigt, wie Sie mithilfe von NEO-optimierte Empfehlungen erhalten TensorFlow, finden Sie im folgenden [Beispielnotizbuch](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb).
# Empfehlungsergebnisse
Jedes Ergebnis eines Inference Recommender-Jobs enthält `InstanceType`, `InitialInstanceCount` und `EnvironmentParameters`, bei denen es sich um optimierte Umgebungsvariablenparameter für Ihren Container handelt, um dessen Latenz und Durchsatz zu verbessern. Die Ergebnisse beinhalten auch Leistungs- und Kostenkennzahlen wie`MaxInvocations`, `ModelLatency`, `CostPerHour`, `CostPerInference`, `CpuUtilization`, und `MemoryUtilization`.
In der folgenden Tabelle finden Sie eine Beschreibung dieser Kennzahlen. Diese Metriken können Ihnen helfen, Ihre Suche nach der besten Endpunktkonfiguration für Ihren Anwendungsfall einzugrenzen. Wenn Ihre Motivation beispielsweise das allgemeine Preis-Leistungs-Verhältnis mit Schwerpunkt auf dem Durchsatz ist, sollten Sie sich auf Folgendes konzentrieren `CostPerInference`.
| Metrik | Description | Anwendungsfall |
| --- | --- | --- |
| `ModelLatency` | Das Zeitintervall, das ein Modell benötigt, um aus der Sicht der SageMaker KI zu reagieren. Dieses Intervall enthält die lokale Kommunikationszeitspanne für das Senden der Anforderung und Abrufen der Antwort vom Container eines Modells sowie die Zeitspanne für das Abschließen der Inferenz im Container. Einheiten: Millisekunden | Latenzempfindliche Workloads wie Anzeigenschaltung und medizinische Diagnose |
| `MaximumInvocations` | Die maximale Anzahl von `InvokeEndpoint` Anfragen, die in einer Minute an einen Modellendpunkt gesendet werden. Einheiten: keine | Auf den Durchsatz ausgerichtete Workloads wie Videoverarbeitung oder Batch-Inferenz |
| `CostPerHour` | Die geschätzten Kosten pro Stunde für Ihren Echtzeit-Endpunkt. Einheiten: US-Dollar | Kostensensible Workloads ohne Latenzfristen |
| `CostPerInference` | Die geschätzten Kosten pro Inferenzgespräch für Ihren Echtzeit-Endpunkt. Einheiten: US-Dollar | Maximieren Sie das allgemeine Preis-/Leistungsverhältnis und konzentrieren Sie sich dabei auf den Durchsatz |
| `CpuUtilization` | Die erwartete CPU-Auslastung bei maximalen Aufrufen pro Minute für die Endpunkt-Instance. Einheiten: Prozent | Verschaffen Sie sich einen Überblick über den Zustand der Instance beim Benchmarking, indem Sie Einblick in die Kern-CPU-Auslastung der Instance haben |
| `MemoryUtilization` | Die erwartete Speicherauslastung bei maximalen Aufrufen pro Minute für die Endpunkt-Instance. Einheiten: Prozent | Verschaffen Sie sich einen Überblick über den Zustand der Instance beim Benchmarking, indem Sie Einblick in die Kernspeichernutzung der Instance haben |
In einigen Fällen möchten Sie vielleicht andere [SageMaker KI Endpoint Invocation-Metriken](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation) untersuchen, wie `CPUUtilization` z. Jedes Inference Recommender-Job-Ergebnis enthält die Namen der Endpunkte, die während des Auslastungstests gestartet wurden. Sie können CloudWatch damit die Protokolle für diese Endpunkte überprüfen, auch nachdem sie gelöscht wurden.
Die folgende Abbildung zeigt ein Beispiel für CloudWatch Kennzahlen und Diagramme, die Sie anhand Ihres Empfehlungsergebnisses für einen einzelnen Endpunkt überprüfen können. Dieses Empfehlungsergebnis stammt aus einem Standardjob. Die Skalarwerte aus den Empfehlungsergebnissen lassen sich so interpretieren, dass sie auf dem Zeitpunkt basieren, zu dem sich das Aufruf-Diagramm zum ersten Mal zu nivellieren beginnt. Der gemeldete `ModelLatency` Wert befindet sich beispielsweise am Anfang des Plateaus um `03:00:31`.
![\[Diagramme für CloudWatch Metriken.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference-recommender-cw-metrics.png)
Vollständige Beschreibungen der in den vorherigen Diagrammen verwendeten CloudWatch Metriken finden Sie unter [SageMaker KI Endpoint Invocation-Metriken](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation).
Im `/aws/sagemaker/InferenceRecommendationsJobs` namespace finden Sie auch Leistungskennzahlen wie `ClientInvocations` und `NumberOfUsers` von Inference Recommender veröffentlicht. Eine vollständige Liste der Metriken und Beschreibungen, die von Inference Recommender veröffentlicht wurden, finden Sie unter [SageMaker Kennzahlen zu Stellenangeboten von Inference Recommender](monitoring-cloudwatch.md#cloudwatch-metrics-inference-recommender).
Im Notizbuch [Amazon SageMaker Inference Recommender — CloudWatch Metrics](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb) Jupyter im [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples)Github-Repository finden Sie ein Beispiel dafür, wie Sie das AWS SDK for Python (Boto3) verwenden können, um Metriken für Ihre Endgeräte zu untersuchen. CloudWatch
# Holen Sie sich politische Empfehlungen zur automatischen Skalierung
Mit Amazon SageMaker Inference Recommender können Sie Empfehlungen für Autoscaling-Richtlinien für Ihren SageMaker KI-Endpunkt erhalten, die auf Ihrem erwarteten Datenverkehrsmuster basieren. Wenn Sie bereits einen Job mit Inferenzempfehlungen abgeschlossen haben, können Sie die Details des Jobs angeben, um eine Empfehlung für eine Autoscaling-Richtlinie zu erhalten, die Sie auf Ihren Endpunkt anwenden können.
Inference Recommender vergleicht verschiedene Werte für jede Metrik, um die ideale Autoscaling-Konfiguration für Ihren Endpunkt zu ermitteln. Die Autoscaling-Empfehlung gibt eine empfohlene Autoscaling-Richtlinie für jede Metrik zurück, die in Ihrem Inferenzempfehlungsjob definiert wurde. Sie können die Richtlinien speichern und sie mit der API auf Ihren Endpunkt anwenden. [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)
Lesen Sie die folgenden Seiten, um zu beginnen.
## Voraussetzungen
Bevor Sie beginnen, müssen Sie eine Inferenzempfehlung erfolgreich abgeschlossen haben. Im folgenden Abschnitt können Sie entweder eine Inferenzempfehlungs-ID oder den Namen eines SageMaker KI-Endpunkts angeben, der während eines Inferenzempfehlungsjobs einem Benchmarking unterzogen wurde.
Um Ihre Empfehlungs-Job-ID oder den Namen Ihres Endpunkts abzurufen, können Sie entweder die Details Ihres Jobs mit Inferenzempfehlungen in der SageMaker AI-Konsole anzeigen oder die von der API zurückgegebenen `EndpointName` Felder `RecommendationId` oder verwenden. [DescribeInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeInferenceRecommendationsJob.html)
## Erstellen Sie eine Konfigurationsempfehlung für Autoscaling
Um eine Empfehlungsrichtlinie für die automatische Skalierung zu erstellen, können Sie die AWS SDK für Python (Boto3) verwenden.
Das folgende Beispiel zeigt die Felder für die [ GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html)API. Verwenden Sie die folgenden Felder, wenn Sie die API aufrufen:
+ `InferenceRecommendationsJobName`– Geben Sie den Namen Ihres Jobs für Inferenzempfehlungen ein.
+ `RecommendationId`– Geben Sie die ID einer Inferenzempfehlung aus einem Empfehlungsjob ein. Dies ist optional, wenn Sie das `EndpointName` Feld angegeben haben.
+ `EndpointName`– Geben Sie den Namen eines Endpunkts ein, für den während eines Jobs mit Inferenzempfehlungen ein Benchmarking durchgeführt wurde. Dies ist optional, wenn Sie das `RecommendationId` Feld angegeben haben.
+ `TargetCpuUtilizationPerCore`– (Optional) Geben Sie einen Prozentwert ein, der angibt, wie viel Auslastung eine Instance auf Ihrem Endpunkt vor der automatischen Skalierung nutzen soll. Wenn Sie dieses Feld nicht angeben, beträgt der Standardwert 50%.
+ `ScalingPolicyObjective`– (Optional) Ein Objekt, in dem Sie Ihr erwartetes Verkehrsmuster angeben.
+ `MinInvocationsPerMinute`– (Optional) Die Mindestanzahl erwarteter Anfragen an Ihren Endpunkt pro Minute.
+ `MaxInvocationsPerMinute`– (Optional) Die maximale Anzahl erwarteter Anfragen an Ihren Endpunkt pro Minute.
```
{
"InferenceRecommendationsJobName": "string", // Required
"RecommendationId": "string", // Optional, provide one of RecommendationId or EndpointName
"EndpointName": "string", // Optional, provide one of RecommendationId or EndpointName
"TargetCpuUtilizationPerCore": number, // Optional
"ScalingPolicyObjective": { // Optional
"MinInvocationsPerMinute": number,
"MaxInvocationsPerMinute": number
}
}
```
Nachdem Sie Ihre Anfrage eingereicht haben, erhalten Sie eine Antwort mit Richtlinien zur automatischen Skalierung, die für jede Metrik definiert sind. Im folgenden Abschnitt finden Sie Informationen zur Interpretation der Antwort.
## Überprüfen Sie die Ergebnisse Ihrer Autoscaling-Konfigurationsempfehlungen
Das folgende Beispiel zeigt die Antwort der [ GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html)API:
```
{
"InferenceRecommendationsJobName": "string",
"RecommendationId": "string", // One of RecommendationId or EndpointName is shown
"EndpointName": "string",
"TargetUtilizationPercentage": Integer,
"ScalingPolicyObjective": {
"MinInvocationsPerMinute": Integer,
"MaxInvocationsPerMinute": Integer
},
"Metric": {
"ModelLatency": Integer,
"InvocationsPerInstance": Integer
},
"DynamicScalingConfiguration": {
"MinCapacity": number,
"MaxCapacity": number,
"ScaleInCooldown": number,
"ScaleOutCooldown": number,
"ScalingPolicies": [
{
"TargetTracking": {
"MetricSpecification": {
"Predefined" {
"PredefinedMetricType": "string"
},
"Customized": {
"MetricName": "string",
"Namespace": "string",
"Statistic": "string"
}
},
"TargetValue": Double
}
}
]
}
}
```
Die Felder `InferenceRecommendationsJobName`, `RecommendationID` oder `EndpointName`, `TargetCpuUtilizationPerCore`, und die `ScalingPolicyObjective` Objektfelder werden aus Ihrer ersten Anfrage kopiert.
Das `Metric` Objekt listet die Metriken auf, die in Ihrem Job mit Inferenzempfehlungen verglichen wurden, sowie eine Berechnung der Werte für jede Metrik, wenn die Instance-Auslastung dem Wert `TargetCpuUtilizationPerCore` entsprechen würde. Dies ist nützlich, um die Leistungskennzahlen auf Ihrem Endpunkt zu antizipieren, wenn dieser mit der empfohlenen Autoscaling-Richtlinie nach oben oder unten skaliert wird. Stellen Sie sich zum Beispiel vor, dass Ihre Instance-Auslastung bei Ihrer Inferenzempfehlung bei 50% lag und Ihr `InvocationsPerInstance` Wert ursprünglich bei `4` lag. Wenn Sie in Ihrer Autoscaling-Empfehlungsanfrage `TargetCpuUtilizationPerCore` einen Wert von 100% angeben, ist der in der Antwort zurückgegebene `InvocationsPerInstance` Metrikwert darauf zurückzuführen, `2` dass Sie damit gerechnet haben, doppelt so viel Instance-Auslastung zuzuweisen.
Das `DynamicScalingConfiguration` Objekt gibt die Werte zurück, die Sie angeben sollten [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html#autoscaling-PutScalingPolicy-request-TargetTrackingScalingPolicyConfiguration), wenn Sie die [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API aufrufen. Dazu gehören die empfohlenen Mindest- und Höchstwerte für die Kapazität, die empfohlenen Abklingzeiten beim Ein- und Ausskalieren sowie das `ScalingPolicies` Objekt, das die empfohlenen `TargetValue` Werte enthält, die Sie für jede Metrik angeben sollten.
# Führen Sie einen benutzerdefinierten Belastungstest aus
Amazon SageMaker Inference Recommender-Lasttests führen umfangreiche Benchmarks durch, die auf den Produktionsanforderungen für Latenz und Durchsatz, benutzerdefinierten Datenverkehrsmustern und entweder serverlosen Endpunkten oder Echtzeit-Instances (bis zu 10) basieren, die Sie auswählen.
In den folgenden Abschnitten wird gezeigt, wie Sie einen Auslastungstest programmgesteuert mit AWS SDK für Python (Boto3) und dem oder interaktiv mit Amazon SageMaker Studio Classic oder der SageMaker AI-Konsole erstellen AWS CLI, beschreiben und beenden.
## Erstellen eines Lasttestauftrags
Erstellen Sie einen Auslastungstest programmgesteuert mit der AWS SDK für Python (Boto3), mit der AWS CLI oder interaktiv mithilfe von Studio Classic oder der AI-Konsole. SageMaker Geben Sie wie bei den Inferenzempfehlungen von Inference Recommender einen Jobnamen für Ihren Belastungstest, einen AWS IAM-Rollen-ARN, eine Eingabekonfiguration und Ihren Modellpaket-ARN an, seit Sie Ihr Modell bei der Modellregistrierung in der Modellregistrierung registriert haben. Für Lasttests müssen Sie auch ein Verkehrsmuster und die Stoppbedingungen angeben.
------
#### [ AWS SDK für Python (Boto3) ]
Verwenden Sie die `CreateInferenceRecommendationsJob` API, um einen Inference Recommender-Lasttest zu erstellen. Geben Sie `Advanced` für das `JobType` Feld an und geben Sie Folgendes an:
+ Ein Jobname für Ihren Auslastungstest (`JobName`). Der Jobname muss in Ihrer AWS Region und in Ihrem Konto eindeutig sein. AWS
+ Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die es Inference Recommender ermöglicht, Aufgaben in Ihrem Namen durchzuführen. Definieren Sie dies für das `RoleArn` Feld.
+ Ein Endpunkt-Konfigurationswörterbuch (`InputConfig`), in dem Sie Folgendes angeben:
+ Geben Sie für `TrafficPattern` entweder das Phasen- oder das Treppenverkehrsmuster an. Beim Phasen-Verkehrsmuster erscheinen jede Minute neue Benutzer mit der von Ihnen angegebenen Geschwindigkeit. Beim Treppen-Verkehrsmuster erscheinen neue Benutzer in bestimmten Intervallen (oder *Schritten*) mit einer von Ihnen festgelegten Geschwindigkeit. Wählen Sie eine der folgenden Optionen:
+ Legen Sie für `TrafficType` die Option `PHASES` fest. Geben Sie dann für das `Phases` Array die `InitialNumberOfUsers` (mit wie vielen gleichzeitigen Benutzern, mit mindestens 1 und maximal 3), `SpawnRate` (die Anzahl der Benutzer, die in einer Minute für eine bestimmte Phase des Lasttests gestartet werden sollen, mit mindestens 0 und maximal 3) und `DurationInSeconds` (wie lang die Datenverkehrsphase sein soll, mit mindestens 120 und maximal 3600) an.
+ Legen Sie für `TrafficType` die Option `STAIRS` fest. Geben Sie dann für das `Stairs` Array an `DurationInSeconds` (wie lang die Verkehrsphase sein soll, mit mindestens 120 und maximal 3600), `NumberOfSteps` (wie viele Intervalle während der Phase verwendet werden) und `UsersPerStep` (wie viele Benutzer in jedem Intervall hinzugefügt werden). Beachten Sie, dass die Länge jedes Schritts dem Wert von `DurationInSeconds / NumberOfSteps` entspricht. Wenn Ihr `DurationInSeconds` z.B `600` ist, und Sie `5` Schritte angeben, so ist jeder Schritt 120 Sekunden lang.
**Anmerkung**
Ein Benutzer ist als ein vom System generierter Akteur definiert, der in einer Schleife läuft und im Rahmen von Inference Recommender Anfragen an einen Endpunkt aufruft. Bei einem typischen XGBoost Container, der auf einer `ml.c5.large` Instance ausgeführt wird, können Endpunkte 30.000 Aufrufe pro Minute (500 tps) mit nur 15 bis 20 Benutzern erreichen.
+ Geben Sie für `ResourceLimit` `MaxNumberOfTests` (die maximale Anzahl von Benchmarking-Lasttests für einen Inference Recommender-Job, mit mindestens 1 und maximal 10) und `MaxParallelOfTests` (die maximale Anzahl parallel Benchmarking-Lasttests für einen Inference Recommender-Job, mit mindestens 1 und maximal 10) an.
+ Für `EndpointConfigurations` können Sie eine der folgenden Möglichkeiten angeben:
+ Das `InstanceType` Feld, in dem Sie den Instance-Typ angeben, auf dem Sie Ihre Lasttests ausführen möchten.
+ Das `ServerlessConfig`, in dem Sie Ihre idealen Werte für `MaxConcurrency` und `MemorySizeInMB` für einen serverlosen Endpunkt angeben. Weitere Informationen finden Sie in der [Dokumentation zu Serverloser Inferenz](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
+ Ein Wörterbuch mit Stoppbedingungen (`StoppingConditions`), in dem der Inference Recommender-Job beendet wird, wenn eine der Bedingungen erfüllt ist. Geben Sie für dieses Beispiel die folgenden Felder im Wörterbuch an:
+ Geben Sie für `MaxInvocations` die maximale Anzahl von Anfragen pro Minute an, die für den Endpunkt erwartet werden, mit einem Minimum von 1 und einem Maximum von 30.000.
+ Geben Sie für `ModelLatencyThresholds` `Percentile` (den Perzentilschwellenwert für die Modelllatenz) und `ValueInMilliseconds` (den Perzentilwert für die Modelllatenz in Millisekunden) an.
+ (Optional) Für `FlatInvocations` können Sie angeben, ob der Lasttest fortgesetzt werden soll, wenn die TPS-Rate (Aufrufe pro Minute) abflacht. Eine verringerte TPS-Rate bedeutet normalerweise, dass der Endpunkt seine Kapazität erreicht hat. Möglicherweise möchten Sie den Endpunkt jedoch weiterhin unter vollen Kapazitätsbedingungen überwachen. Um den Lasttest in diesem Fall fortzusetzen, geben Sie diesen Wert als an `Continue`. Andernfalls ist der Standardwert `Stop`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region=
sagemaker_client=boto3.client('sagemaker', region=aws_region)
# Provide a name to your recommendation based on load testing
load_test_job_name=""
# Provide the name of the sagemaker instance type
instance_type=""
# Provide the IAM Role that gives SageMaker permission to access AWS services
role_arn='arn:aws:iam:::role/*'
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn='arn:aws:sagemaker:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName=load_test_job_name,
JobType="Advanced",
RoleArn=role_arn,
InputConfig={
'ModelPackageVersionArn': model_package_arn,
"JobDurationInSeconds": 7200,
'TrafficPattern' : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
'TrafficType': 'PHASES',
'Phases': [
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
},
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
'ResourceLimit': {
'MaxNumberOfTests': 10,
'MaxParallelOfTests': 3
},
"EndpointConfigurations" : [{
'InstanceType': 'ml.c5.xlarge'
},
{
'InstanceType': 'ml.m5.xlarge'
},
{
'InstanceType': 'ml.r5.xlarge'
}]
# Uncomment the ServerlessConfig and comment out the InstanceType field if you want recommendations for a serverless endpoint
# "ServerlessConfig": {
# "MaxConcurrency": value,
# "MemorySizeInMB": value
# }
},
StoppingConditions={
'MaxInvocations': 1000,
'ModelLatencyThresholds':[{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
'FlatInvocations': 'Stop'
}
)
```
Eine vollständige Liste der optionalen und erforderlichen Argumente, an die Sie übergeben können, finden Sie im [Amazon SageMaker API-Referenzhandbuch](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html)`CreateInferenceRecommendationsJob`.
------
#### [ AWS CLI ]
Verwenden Sie die `create-inference-recommendations-job` API, um einen Inference Recommender-Lasttest zu erstellen. Geben Sie `Advanced` für das `JobType` Feld an und geben Sie Folgendes an:
+ Ein Jobname für Ihren Auslastungstest (`job-name`). Der Jobname muss in Ihrer AWS Region und in Ihrem AWS Konto eindeutig sein.
+ Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die es Inference Recommender ermöglicht, Aufgaben in Ihrem Namen durchzuführen. Definieren Sie dies für das `role-arn` Feld.
+ Ein Endpunkt-Konfigurationswörterbuch (`input-config`), in dem Sie Folgendes angeben:
+ Geben Sie für `TrafficPattern` entweder das Phasen- oder das Treppenverkehrsmuster an. Beim Phasen-Verkehrsmuster erscheinen jede Minute neue Benutzer mit der von Ihnen angegebenen Geschwindigkeit. Beim Treppen-Verkehrsmuster erscheinen neue Benutzer in bestimmten Intervallen (oder *Schritten*) mit einer von Ihnen festgelegten Geschwindigkeit. Wählen Sie eine der folgenden Optionen:
+ Legen Sie für `TrafficType` die Option `PHASES` fest. Geben Sie dann für das `Phases` Array die `InitialNumberOfUsers` (mit wie vielen gleichzeitigen Benutzern, mit mindestens 1 und maximal 3), `SpawnRate` (die Anzahl der Benutzer, die in einer Minute für eine bestimmte Phase des Lasttests gestartet werden sollen, mit mindestens 0 und maximal 3) und `DurationInSeconds` (wie lang die Datenverkehrsphase sein soll, mit mindestens 120 und maximal 3600) an.
+ Legen Sie für `TrafficType` die Option `STAIRS` fest. Geben Sie dann für das `Stairs` Array an `DurationInSeconds` (wie lang die Verkehrsphase sein soll, mit mindestens 120 und maximal 3600), `NumberOfSteps` (wie viele Intervalle während der Phase verwendet werden) und `UsersPerStep` (wie viele Benutzer in jedem Intervall hinzugefügt werden). Beachten Sie, dass die Länge jedes Schritts dem Wert von `DurationInSeconds / NumberOfSteps` entspricht. Wenn Ihr `DurationInSeconds` z.B `600` ist, und Sie `5` Schritte angeben, so ist jeder Schritt 120 Sekunden lang.
**Anmerkung**
Ein Benutzer ist als ein vom System generierter Akteur definiert, der in einer Schleife läuft und im Rahmen von Inference Recommender Anfragen an einen Endpunkt aufruft. Bei einem typischen XGBoost Container, der auf einer `ml.c5.large` Instance ausgeführt wird, können Endpunkte 30.000 Aufrufe pro Minute (500 tps) mit nur 15 bis 20 Benutzern erreichen.
+ Geben Sie für `ResourceLimit` `MaxNumberOfTests` (die maximale Anzahl von Benchmarking-Lasttests für einen Inference Recommender-Job, mit mindestens 1 und maximal 10) und `MaxParallelOfTests` (die maximale Anzahl parallel Benchmarking-Lasttests für einen Inference Recommender-Job, mit mindestens 1 und maximal 10) an.
+ Für `EndpointConfigurations` können Sie eine der folgenden Möglichkeiten angeben:
+ Das `InstanceType` Feld, in dem Sie den Instance-Typ angeben, auf dem Sie Ihre Lasttests ausführen möchten.
+ Das `ServerlessConfig`, in dem Sie Ihre idealen Werte für `MaxConcurrency` und `MemorySizeInMB` für einen serverlosen Endpunkt angeben.
+ Ein Wörterbuch mit Stoppbedingungen (`stopping-conditions`), in dem der Inference Recommender-Job beendet wird, wenn eine der Bedingungen erfüllt ist. Geben Sie für dieses Beispiel die folgenden Felder im Wörterbuch an:
+ Geben Sie für `MaxInvocations` die maximale Anzahl von Anfragen pro Minute an, die für den Endpunkt erwartet werden, mit einem Minimum von 1 und einem Maximum von 30.000.
+ Geben Sie für `ModelLatencyThresholds` `Percentile` (den Perzentilschwellenwert für die Modelllatenz) und `ValueInMilliseconds` (den Perzentilwert für die Modelllatenz in Millisekunden) an.
+ (Optional) Für `FlatInvocations` können Sie angeben, ob der Lasttest fortgesetzt werden soll, wenn die TPS-Rate (Aufrufe pro Minute) abflacht. Eine verringerte TPS-Rate bedeutet normalerweise, dass der Endpunkt seine Kapazität erreicht hat. Möglicherweise möchten Sie den Endpunkt jedoch weiterhin unter vollen Kapazitätsbedingungen überwachen. Um den Lasttest in diesem Fall fortzusetzen, geben Sie diesen Wert als an `Continue`. Andernfalls ist der Standardwert `Stop`.
```
aws sagemaker create-inference-recommendations-job\
--region \
--job-name \
--job-type ADVANCED\
--role-arn arn:aws:iam:::role/*\
--input-config \"{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:::role/*\",
\"JobDurationInSeconds\": 7200,
\"TrafficPattern\" : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
\"TrafficType\": \"PHASES\",
\"Phases\": [
{
\"InitialNumberOfUsers\": 1,
\"SpawnRate\": 60,
\"DurationInSeconds\": 300
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
\"ResourceLimit\": {
\"MaxNumberOfTests\": 10,
\"MaxParallelOfTests\": 3
},
\"EndpointConfigurations\" : [
{
\"InstanceType\": \"ml.c5.xlarge\"
},
{
\"InstanceType\": \"ml.m5.xlarge\"
},
{
\"InstanceType\": \"ml.r5.xlarge\"
}
# Use the ServerlessConfig and leave out the InstanceType fields if you want recommendations for a serverless endpoint
# \"ServerlessConfig\": {
# \"MaxConcurrency\": value,
# \"MemorySizeInMB\": value
# }
]
}\"
--stopping-conditions \"{
\"MaxInvocations\": 1000,
\"ModelLatencyThresholds\":[
{
\"Percentile\": \"P95\",
\"ValueInMilliseconds\": 100
}
],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
\"FlatInvocations\": \"Stop\"
}\"
```
------
#### [ Amazon SageMaker Studio Classic ]
Erstellen Sie einen Auslastungstest mit Studio Classic.
1. Wählen Sie in Ihrer Studio-Classic-Anwendung das Startsymbol (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/studio/icons/house.png)) aus.
1. Wählen Sie in der linken Seitenleiste von Studio Classic die Option **Bereitstellungen** aus.
1. Wählen Sie **Inferenzempfehlung** aus der Dropdown-Liste.
1. Wählen Sie **Create Inference Recommender** Job aus. Eine neue Registerkarte mit dem Titel Job für **Inferenzempfehlungen erstellen** wird geöffnet.
1. Wählen Sie den Namen Ihrer Modellgruppe aus dem Dropdown-Feld **Modellgruppe** aus. Die Liste enthält alle Modellgruppen, die bei der Model Registry in Ihrem Konto registriert sind, einschließlich Modelle, die außerhalb von Studio Classic registriert sind.
1. Wählen Sie eine Modellversion aus dem Dropdown-Feld **Modellversion** aus.
1. Klicken Sie auf **Weiter**.
1. Geben Sie im Feld Name einen **Namen** für den Job ein.
1. (Optional) Geben Sie im Feld Beschreibung eine **Beschreibung** Ihres Jobs ein.
1. Wählen Sie eine IAM-Rolle, die Inference Recommender die Berechtigung zum Zugriff auf Dienste gewährt. AWS Sie können zu diesem Zweck eine Rolle erstellen und die von `AmazonSageMakerFullAccess` IAM verwaltete Richtlinie anhängen, oder Sie können Studio Classic eine Rolle für Sie erstellen lassen.
1. Wählen Sie **Stoppbedingungen**, um die verfügbaren Eingabefelder zu erweitern. Geben Sie eine Reihe von Bedingungen für das Stoppen einer Bereitstellungsempfehlung an.
1. Geben Sie im Feld **Max. Aufrufe pro Minute** die maximale Anzahl von Anfragen pro Minute an, die für den Endpunkt erwartet werden.
1. Geben Sie den Schwellenwert für die Modelllatenz in Mikrosekunden im Feld **Schwellenwert für Modelllatenz** an. Der **Schwellenwert für die Modelllatenz** gibt das Zeitintervall an, das ein Modell benötigt, um zu reagieren, wie es im Inference Recommender angezeigt wird. Das Intervall umfasst die lokale Kommunikationszeit, die benötigt wird, um die Anfrage zu senden und die Antwort aus dem Modellcontainer zu holen, sowie die Zeit, die benötigt wird, um die Inferenz im Container abzuschließen.
1. Wählen Sie **Traffic Pattern**, um die verfügbaren Eingabefelder zu erweitern.
1. Legen Sie die anfängliche Anzahl virtueller Benutzer fest, indem Sie im Feld **Anfängliche Anzahl von Benutzern** eine Ganzzahl angeben.
1. Geben Sie eine Ganzzahl für das Feld **Spawnrate** ein. Die Spawn-Rate legt die Anzahl der pro Sekunde erstellten Benutzer fest.
1. Legen Sie die Dauer der Phase in Sekunden fest, indem Sie im Feld **Dauer** eine Ganzzahl angeben.
1. (Optional) Fügen Sie zusätzliche Verkehrsmuster hinzu. Wählen Sie dafür **Hinzufügen**.
1. Wählen Sie die Einstellung **Erweitert**, um das Feld **Max. Testdauer** einzublenden. Geben Sie in Sekunden die maximale Zeit an, die ein Test während eines Jobs dauern kann. Neue Jobs werden nicht nach der definierten Dauer geplant. Auf diese Weise wird sichergestellt, dass laufende Jobs nicht gestoppt werden und dass Sie nur abgeschlossene Jobs sehen.
1. Klicken Sie auf **Weiter**.
1. Wählen Sie **Ausgewählte Instances**.
1. Wählen Sie im Feld **Instances für Benchmarking** die Option **Zu testende Instances hinzufügen** aus. Wählen Sie bis zu 10 Instances aus, die Inference Recommender für Lasttests verwenden soll.
1. Wählen Sie **Zusätzliche Einstellungen**
1. Geben Sie eine Ganzzahl ein, die eine Obergrenze für die Anzahl der Tests festlegt, die ein Job für das Feld **Maximale Anzahl von Tests** durchführen kann. Beachten Sie, dass jede Endpunktkonfiguration zu einem neuen Belastungstest führt.
1. Geben Sie eine Ganzzahl für das Testfeld **Max Parallel** an. Diese Einstellung definiert eine Obergrenze für die Anzahl der Lasttests, die parallel ausgeführt werden können.
1. Wählen Sie **Absenden** aus.
Der Belastungstest kann bis zu 2 Stunden dauern.
**Warnung**
Schließen Sie diese Registerkarte nicht. Wenn Sie diese Registerkarte schließen, brechen Sie den Inference Recommender-Lasttestjob ab.
------
#### [ SageMaker AI console ]
Erstellen Sie einen benutzerdefinierten Belastungstest über die SageMaker AI-Konsole, indem Sie wie folgt vorgehen:
1. Gehen Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie in der linken Navigationsleiste **Inferenz** und wählen Sie dann **Inferenzempfehlung**.
1. Wählen Sie auf der Seite **Inferenz Empfehlungsgeber Aufträge** die Option **Job erstellen** aus.
1. Führen Sie für **Schritt 1: Modellkonfiguration** die folgenden Schritte aus:
1. Wählen Sie als **Jobtyp** die Option **Erweiterter Empfehlungsjob** aus.
1. Wenn Sie ein Modell verwenden, das in der SageMaker AI-Modellregistrierung registriert ist, aktivieren Sie die **Option Modell aus der Modellregistrierung auswählen** und gehen Sie wie folgt vor:
1. Wählen Sie in der Dropdownliste **Modellgruppe** die Modellgruppe in der SageMaker AI-Modellregistrierung aus, in der sich Ihr Modell befindet.
1. Wählen Sie in der Dropdown-Liste **Modellversion** die gewünschte Version Ihres Modells aus.
1. Wenn Sie ein Modell verwenden, das Sie in SageMaker AI erstellt haben, deaktivieren Sie die Option **Modell aus der Modellregistrierung auswählen** und gehen Sie wie folgt vor:
1. Geben Sie in das Feld **Modellname** den Namen Ihres SageMaker KI-Modells ein.
1. Für die **IAM-Rolle** können Sie eine vorhandene AWS IAM-Rolle auswählen, die über die erforderlichen Berechtigungen verfügt, um einen Instanzempfehlungsjob zu erstellen. Wenn Sie noch keine Rolle haben, können Sie alternativ **Neue Rolle erstellen** wählen, um das Pop-up zur Rollenerstellung zu öffnen. SageMaker AI fügt dann der neuen Rolle, die Sie erstellen, die erforderlichen Berechtigungen hinzu.
1. Geben Sie für **S3-Bucket for Benchmarking Payload** den Amazon S3-Pfad zu Ihrem Beispiel-Payload-Archiv ein, das Beispiel-Payload-Dateien enthalten sollte, die Inference Recommender verwendet, um Ihr Modell auf verschiedenen Instance-Typen zu vergleichen.
1. Geben Sie als **Payload-Inhaltstyp** die MIME-Typen Ihrer Beispiel-Payload-Daten ein.
1. Konfigurieren Sie unter **Verkehrsmuster** die Phasen für den Auslastungstest, indem Sie wie folgt vorgehen:
1. Geben Sie **unter Anfängliche Benutzeranzahl** an, mit wie vielen gleichzeitigen Benutzern Sie beginnen möchten (mit mindestens 1 und maximal 3).
1. Geben Sie unter **Spawnrate** die Anzahl der Benutzer an, die in einer Minute für die Phase erzeugt werden sollen (mit einem Minimum von 0 und einem Maximum von 3).
1. Geben Sie unter **Dauer (Sekunden)** an, wie tief die Verkehrsphase in Sekunden sein soll (mit einem Minimum von 120 und einem Maximum von 3600).
1. (Optional) Wenn Sie die Option **Modell aus der Modellregistrierung auswählen** deaktiviert und ein SageMaker KI-Modell angegeben haben, gehen Sie für die **Container-Konfiguration** wie folgt vor:
1. Wählen Sie in der Dropdown-Liste **Domain** die Domain für Machine Learning des Modells aus, z. B. Computer Vision, Verarbeitung natürlicher Sprache oder Machine Learning.
1. **Wählen Sie in der Dropdownliste Framework das Framework Ihres Containers aus, z. B. TensorFlow oder.** XGBoost
1. Geben Sie als **Framework-Version** die Framework-Version Ihres Container-Images ein.
1. Wählen Sie in der Dropdown-Liste **Nächster Modellname** das vortrainierte Modell aus, das Ihrem Modell am ehesten entspricht.
1. Wählen Sie in der Dropdown-Liste **Aufgabe** die maschinelle Lernaufgabe aus, die das Modell erfüllt, z. B. Bildklassifizierung oder Regression.
1. (Optional) Für die **Modellkompilierung mit SageMaker Neo** können Sie den Empfehlungsjob für ein Modell konfigurieren, das Sie mit SageMaker Neo kompiliert haben. Geben Sie für die **Konfiguration der Dateneingabe** die richtige Form der Eingabedaten für Ihr Modell in einem Format ein, das dem `{'input':[1,1024,1024,3]}` ähnelt.
1. Wählen Sie **Weiter** aus.
1. Bei **Schritt 2: Instances und Umgebungsparameter** gehen Sie wie folgt vor:
1. Wählen Sie für **Select Instances for Benchmarking** bis zu 8 Instance-Typen aus, mit denen Sie einen Benchmark durchführen möchten.
1. (Optional) Für **Umgebungsparameterbereiche** können Sie Umgebungsparameter angeben, die zur Optimierung Ihres Modells beitragen. Geben Sie die Parameter als **Schlüssel-** und **Werte** -paare an.
1. Wählen Sie **Weiter** aus.
1. Für **Schritt 3: Auftragsparameter** gehen Sie wie folgt vor:
1. (Optional) Geben Sie für das Feld **Jobname** einen Namen für Ihren Instance-Empfehlungsjob ein. Wenn Sie den Job erstellen, hängt SageMaker KI einen Zeitstempel an das Ende dieses Namens an.
1. (Optional) Geben Sie in das Feld **Auftragsbeschreibung** eine Beschreibung für den Auftrag ein.
1. (Optional) Wählen Sie in der Dropdownliste **Verschlüsselungsschlüssel** einen AWS KMS Schlüssel nach Namen aus oder geben Sie seinen ARN ein, um Ihre Daten zu verschlüsseln.
1. (Optional) Geben Sie unter **Maximale Anzahl an Tests** die Anzahl der Tests ein, die Sie während des Empfehlungsjobs ausführen möchten.
1. (Optional) Geben Sie für **Max parallel Tests** die maximale Anzahl parallel Tests ein, die Sie während des Empfehlungsjobs ausführen möchten.
1. Geben Sie für **Max. Testdauer (s)** die maximale Anzahl von Sekunden ein, für die jeder Test ausgeführt werden soll.
1. Geben Sie für **Max. Aufrufe pro Minute** die maximale Anzahl von Anfragen pro Minute ein, die der Endpunkt erreichen kann, bevor der Empfehlungsjob beendet wird. Nach Erreichen dieses Grenzwerts beendet SageMaker KI den Job.
1. Geben Sie für den **Latenzschwellenwert des Modells P99 (ms)** das Perzentil der Modelllatenz in Millisekunden ein.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie für **Schritt 4: Job überprüfen** Ihre Konfigurationen und wählen Sie dann **Submit** aus.
------
## Holen Sie sich Ihre Belastungstestergebnisse
Sie können programmgesteuert Metriken für alle Auslastungstests sammeln AWS SDK für Python (Boto3), sobald die Auslastungstests mit der AWS CLI Studio Classic- oder der SageMaker AI-Konsole durchgeführt wurden.
------
#### [ AWS SDK für Python (Boto3) ]
Erfassen Sie Metriken mit der `DescribeInferenceRecommendationsJob` API. Geben Sie den Jobnamen des Belastungstests für das `JobName` Feld an:
```
load_test_response = sagemaker_client.describe_inference_recommendations_job(
JobName=load_test_job_name
)
```
Drucken Sie das Antwortobjekt aus.
```
load_test_response['Status']
```
Dies gibt eine JSON-Antwort ähnlich dem folgenden Beispiel zurück. Beachten Sie, dass dieses Beispiel die empfohlenen Instance-Typen für Echtzeit-Inferenzen zeigt (ein Beispiel mit Empfehlungen für serverlose Inferenzen finden Sie im nachfolgenden Beispiel).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100}
]},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0}
}
```
Die ersten Zeilen enthalten Informationen über den Lasttestjob selbst. Dazu gehören der Jobname, der Rollen-ARN, die Erstellungs- und Löschzeit.
Das `InferenceRecommendations` Wörterbuch enthält eine Liste von Inference Recommender-Inferenzempfehlungen.
Das `EndpointConfiguration` verschachtelte Wörterbuch enthält die Empfehlung für den Instanztyp (`InstanceType`) sowie den Endpunkt- und Variantennamen (ein bereitgestelltes Modell für AWS maschinelles Lernen), die während des Empfehlungsjobs verwendet wurden. Sie können den Endpunkt und den Variantennamen für die Überwachung in Amazon CloudWatch Events verwenden. Weitere Informationen finden Sie unter [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md).
Das `EndpointConfiguration` verschachtelte Wörterbuch enthält auch die Empfehlung für die Anzahl der Instances (`InitialInstanceCount`). Dies ist die Anzahl der Instances, die Sie auf dem Endpunkt bereitstellen sollten, um die im `StoppingConditions` angegebenen Wert `MaxInvocations` angegebene Anzahl zu erreichen. Wenn `InstanceType` beispielsweise `ml.m5.large` und `InitialInstanceCount` `2` ist, sollten Sie 2 `ml.m5.large`-Instances für Ihren Endpunkt bereitstellen, damit er den in der `MaxInvocations` Anhaltebedingung angegebenen TPS verarbeiten kann.
Das `Metrics` verschachtelte Wörterbuch enthält Informationen über die geschätzten Kosten pro Stunde (`CostPerHour`) für Ihren Echtzeit-Endpunkt in US-Dollar, die geschätzten Kosten pro Inferenz (`CostPerInference`) für Ihren Echtzeit-Endpunkt, die maximale Anzahl von `InvokeEndpoint` Anfragen, die an den Endpunkt gesendet wurden, und die Modelllatenz (`ModelLatency`), d. h. das Zeitintervall (in Mikrosekunden), das Ihr Modell benötigt hat, um auf KI zu reagieren. SageMaker Die Modelllatenz umfasst die lokalen Kommunikationszeiten für das Senden der Anfrage und das Abrufen der Antwort aus dem Modellcontainer sowie die Zeit, die für den Abschluss der Inferenz im Container benötigt wird.
Das folgende Beispiel zeigt den `InferenceRecommendations` Teil der Antwort für einen Lasttestjob, der so konfiguriert wurde, dass er serverlose Inferenzempfehlungen zurückgibt:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Sie können die Empfehlungen für serverlose Inferenz ähnlich wie die Ergebnisse für Echtzeit-Inferenzen interpretieren, mit Ausnahme von `ServerlessConfig`, die Ihnen die Werte anzeigt, die Sie für `MaxConcurrency` und `MemorySizeInMB` bei der Einrichtung des Lasttests angegeben haben. Serverlose Empfehlungen messen auch die Metrik `ModelSetupTime`, die (in Mikrosekunden) die Zeit misst, die benötigt wird, um Rechenressourcen auf einem serverlosen Endpunkt zu starten. Weitere Informationen zum Festlegen serverloser Endpunkte finden Sie in der [Serverless Inferenz-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ AWS CLI ]
Erfassen Sie Metriken mit der `describe-inference-recommendations-job` API. Geben Sie den Jobnamen des Lasttests für das `job-name` Flag an:
```
aws sagemaker describe-inference-recommendations-job --job-name
```
Dies gibt eine Antwort ähnlich dem folgenden Beispiel zurück. Beachten Sie, dass dieses Beispiel die empfohlenen Instance-Typen für Echtzeit-Inferenz zeigt (ein Beispiel mit Empfehlungen für Serverless-Inferenzen finden Sie im nachfolgenden Beispiel).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}]
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0
}
}
```
Die ersten Zeilen enthalten Informationen über den Lasttestjob selbst. Dazu gehören der Jobname, der Rollen-ARN, die Erstellungs- und Löschzeit.
Das `InferenceRecommendations` Wörterbuch enthält eine Liste von Inference Recommender-Inferenzempfehlungen.
Das `EndpointConfiguration` verschachtelte Wörterbuch enthält die Empfehlung für den Instanztyp (`InstanceType`) zusammen mit dem Endpunkt und dem Variantennamen (ein bereitgestelltes Modell für AWS maschinelles Lernen), die während des Empfehlungsjobs verwendet wurden. Sie können den Endpunkt und den Variantennamen für die Überwachung in Amazon CloudWatch Events verwenden. Weitere Informationen finden Sie unter [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md).
Das `Metrics` verschachtelte Wörterbuch enthält Informationen über die geschätzten Kosten pro Stunde (`CostPerHour`) für Ihren Echtzeit-Endpunkt in US-Dollar, die geschätzten Kosten pro Inferenz (`CostPerInference`) für Ihren Echtzeit-Endpunkt, die maximale Anzahl von `InvokeEndpoint` Anfragen, die an den Endpunkt gesendet wurden, und die Modelllatenz (`ModelLatency`), d. h. das Zeitintervall (in Mikrosekunden), das Ihr Modell benötigt hat, um auf KI zu reagieren. SageMaker Die Modelllatenz umfasst die lokalen Kommunikationszeiten für das Senden der Anfrage und das Abrufen der Antwort aus dem Modellcontainer sowie die Zeit, die für den Abschluss der Inferenz im Container benötigt wird.
Das folgende Beispiel zeigt den `InferenceRecommendations` Teil der Antwort für einen Lasttestjob, der so konfiguriert wurde, dass er serverlose Inferenzempfehlungen zurückgibt:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Sie können die Empfehlungen für serverlose Inferenz ähnlich wie die Ergebnisse für Echtzeit-Inferenzen interpretieren, mit Ausnahme von, das Ihnen die Werte anzeigt`ServerlessConfig`, die Sie für `MaxConcurrency` und `MemorySizeInMB` bei der Einrichtung des Lasttests angegeben haben. Serverlose Empfehlungen messen auch die Metrik `ModelSetupTime`, die (in Mikrosekunden) die Zeit misst, die benötigt wird, um Computerressourcen auf einem serverlosen Endpunkt zu starten. Weitere Informationen zum Festlegen serverloser Endpunkte finden Sie in der [Serverless Inferenz-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ Amazon SageMaker Studio Classic ]
Die Empfehlungen werden in Studio Classic auf einer neuen Registerkarte mit dem Namen **Inferenzempfehlungen** angezeigt. Es kann bis zu 2 Stunden dauern, bis die Ergebnisse angezeigt werden. Diese Registerkarte enthält die Spalten **Ergebnisse** und **Details**.
Die Spalte **Details** enthält Informationen über den Lasttestauftrag, z. B. den Namen, den der Lasttestauftrag erhalten hat, wann der Job erstellt wurde (**Erstellungszeit**) und mehr. Sie enthält auch **Einstellungsinformationen**, wie z. B. die maximale Anzahl von Aufrufen pro Minute und Informationen zu den verwendeten Amazon-Ressourcennamen.
Die Spalte **Ergebnisse** enthält Fenster mit **Bereitstellungszielen** und **SageMaker KI-Empfehlungen**, in denen Sie die Reihenfolge, in der die Ergebnisse angezeigt werden, je nach Wichtigkeit der Bereitstellung anpassen können. Es gibt drei Dropdown-Menüs, in denen Sie angeben können, wie wichtig **Kosten**, **Latenz** und **Durchsatz** für Ihren Anwendungsfall sind. Für jedes Ziel (Kosten, Latenz und Durchsatz) können Sie die Prioritätsstufe festlegen: **Niedrigste Wichtigkeit**, **Niedrige Wichtigkeit**, **Mittlere Wichtigkeit**, **Hohe Wichtigkeit** oder **Höchste Wichtigkeit**.
**Basierend auf Ihrer Auswahl der Wichtigkeit für jedes Ziel zeigt Inference Recommender die wichtigste Empfehlung im Empfehlungsfeld auf der SageMaker rechten Seite des Fensters an, zusammen mit den geschätzten Kosten pro Stunde und der Inferenzanfrage.** Es bietet auch Informationen über die erwartete Modelllatenz, die maximale Anzahl von Aufrufen und die Anzahl der Instances.
Zusätzlich zur angezeigten Top-Empfehlung können Sie im Abschnitt **Alle Läufe** dieselben Informationen für alle Instances sehen, die Inference Recommender getestet hat.
------
#### [ SageMaker AI console ]
Sie können die Ergebnisse Ihrer benutzerdefinierten Lasttest-Jobs in der SageMaker AI-Konsole anzeigen, indem Sie wie folgt vorgehen:
1. Gehen Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie in der linken Navigationsleiste **Inferenz** und wählen Sie dann **Inferenzempfehlung**.
1. Wählen Sie auf der Seite **Inferenzempfehlungsaufträge** den Namen Ihres Jobs für Inference Recommender aus.
Auf der Detailseite für Ihren Job können Sie sich die **Inferenzempfehlungen** ansehen. Dabei handelt es sich um die Instanztypen, die SageMaker KI für Ihr Modell empfiehlt, wie im folgenden Screenshot dargestellt.
![\[Screenshot der Liste der Inferenzempfehlungen auf der Seite mit den Jobdetails in der SageMaker AI-Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
In diesem Abschnitt können Sie die Instance-Typen anhand verschiedener Faktoren wie **Modelllatenz**, **Kosten pro Stunde**, **Kosten pro Inferenz** und **Aufrufe pro Minute vergleichen**.
Auf dieser Seite können Sie auch die Konfigurationen anzeigen, die Sie für Ihren Job angegeben haben. Im Bereich **Monitor** können Sie die CloudWatch Amazon-Metriken einsehen, die für jeden Instance-Typ protokolliert wurden. Weitere Informationen zur Interpretation dieser Metriken finden Sie unter [Interpretieren von Ergebnissen](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html).
------
# Stoppen Sie Ihren Belastungstest
Möglicherweise möchten Sie einen Auftrag beenden, der gerade ausgeführt wird, weil Sie ihn versehentlich gestartet haben oder ihn nicht mehr benötigen. Stoppen Sie Ihre Lasttestjobs programmgesteuert mit der `StopInferenceRecommendationsJob` API oder über Studio Classic oder die SageMaker AI-Konsole.
------
#### [ AWS SDK für Python (Boto3) ]
Geben Sie den Jobnamen des Lasttests für das `JobName` Feld an:
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
Geben Sie den Jobnamen des Lasttests für das `job-name` Flag an:
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
Schließen Sie die Registerkarte, auf der Sie Ihren benutzerdefinierten Ladejob initiiert haben, um Ihren Inference Recommender-Lasttest zu beenden.
------
#### [ SageMaker AI console ]
Gehen Sie wie folgt vor, um Ihren Lasttestjob über die SageMaker AI-Konsole zu beenden:
1. Gehen Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie in der linken Navigationsleiste **Inferenz** und wählen Sie dann **Inferenzempfehlung**.
1. Wählen Sie auf der Seite **Inference Recommender Jobs Ihren Loadtest-Job** aus.
1. Wählen Sie **Stop run (Testlauf stoppen)**.
1. Wählen Sie im daraufhin angezeigten Dialogfeld die Option **Confirm** (Bestätigen) aus.
Nachdem Sie Ihren Job beendet haben, sollte sich der **Status** des Jobs auf **Stoppt** ändern.
------
# Beheben Sie Inference Recommender-Fehler
Dieser Abschnitt enthält Informationen dazu, wie Sie häufige Fehler verstehen und verhindern können, welche Fehlermeldungen sie generieren und wie Sie diese Fehler beheben können.
## Fehlerbehebung
Sie können versuchen, Ihren Fehler zu beheben, indem Sie die folgenden Schritte ausführen:
+ Prüfen Sie, ob Sie alle Voraussetzungen für die Verwendung von Inference Recommender erfüllt haben. Weitere Informationen finden Sie unter [Voraussetzungen für Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-prerequisites.html).
+ Vergewissern Sie sich, dass Sie Ihr Modell von Model Registry aus auf einem Endpunkt bereitstellen können und ob es Ihre Payloads fehlerfrei verarbeiten kann. Weitere Informationen finden Sie unter [Bereitstellen eines Modells aus dem Verzeichnis](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry-deploy.html).
+ Wenn Sie einen Inference Recommender-Job starten, sollten Sie sehen, dass in der Konsole Endpoints erstellt wurden, und Sie können die Protokolle überprüfen. CloudWatch
## Häufige Fehler
In der folgenden Tabelle finden Sie häufig auftretende Inference Recommender-Fehler und deren Lösungen.
| Fehler | Lösung |
| --- | --- |
| Geben Sie `Domain` im Modellpaket Version 1 an. `Domain` ist ein obligatorischer Parameter für den Job. | Stellen Sie sicher, dass Sie die ML-Domain oder `OTHER`, falls unbekannt, angeben. |
| Der angegebene Rollen-ARN kann nicht übernommen werden und es ist ein `AWSSecurityTokenServiceException` Fehler aufgetreten. | Stellen Sie sicher, dass die angegebene Ausführungsrolle über die erforderlichen Berechtigungen verfügt, die in den Voraussetzungen angegeben sind. |
| Geben Sie `Framework` im Modellpaket Version 1 an.`Framework` ist ein obligatorischer Parameter für den Job. | Stellen Sie sicher, dass Sie das ML-Framework angeben oder, `OTHER` falls es unbekannt ist. |
| Benutzer am Ende der vorherigen Phase sind 0, während die ersten Benutzer der aktuellen Phase 1 sind. | Benutzer beziehen sich hier auf virtuelle Benutzer oder Threads, die zum Senden von Anfragen verwendet werden. Jede Phase beginnt mit A-Benutzern und endet mit B-Benutzern, also B > A. Zwischen den aufeinanderfolgenden Phasen, x\$11 und x\$12, benötigen wir abs (x\$12.A – x\$11.B) <= 3 und >= 0. |
| Die Gesamtdauer des Datenverkehrs (über) sollte nicht länger als die Auftragsdauer sein. | Die Gesamtdauer all Ihrer Phasen darf die Jobdauer nicht überschreiten. |
| Der Burstable-Instance-Typ ml.t2.medium ist nicht zulässig. | Inference Recommender unterstützt keine Lasttests für die T2-Instance-Familie, da Burstable-Instances keine konsistente Leistung bieten. |
| ResourceLimitExceeded beim Aufrufen von Operation CreateEndpoint | Sie haben ein SageMaker KI-Ressourcenlimit überschritten. Beispielsweise kann Inference Recommender möglicherweise keine Endpunkte für das Benchmarking bereitstellen, wenn das Konto das Endpunktkontingent erreicht hat. Weitere Informationen zu SageMaker KI-Limits und -Kontingenten finden Sie unter [Amazon SageMaker AI-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html). |
| ModelError beim Aufrufen InvokeEndpoint des Betriebs | Ein Modellfehler kann aus folgenden Gründen auftreten: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
| PayloadError beim Aufrufen von InvokeEndpoint Operation | Ein Payload-Fehler kann aus folgenden Gründen auftreten: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
## Prüfen CloudWatch
Wenn Sie einen Inference Recommender-Job starten, sollten Sie sehen, dass in der Konsole Endpoints erstellt werden. Wählen Sie einen der Endpunkte aus und sehen Sie sich die CloudWatch Protokolle an, um nach 4xx/5xx-Fehlern zu suchen. Wenn Sie einen erfolgreichen Inference Recommender-Job ausgeführt haben, können Sie die Endpunktnamen als Teil der Ergebnisse sehen. Selbst wenn Ihr Inference Recommender-Job nicht erfolgreich ist, können Sie die CloudWatch Protokolle der gelöschten Endpunkte trotzdem überprüfen, indem Sie die folgenden Schritte ausführen:
1. Öffnen Sie die CloudWatch Amazon-Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Wählen Sie aus der Dropdown-Liste Region oben rechts die **Region** aus, in der Sie den Inference Recommender-Job erstellt haben.
1. Wählen Sie im Navigationsbereich von CloudWatch **Logs** und anschließend **Log-Gruppen** aus.
1. Suchen Sie nach der Protokollgruppe namens`/aws/sagemaker/Endpoints/sm-epc-*`. Wählen Sie die Protokollgruppe auf der Grundlage Ihres letzten Inference Recommender-Jobs aus.
Sie können Ihren Job auch beheben, indem Sie die Inference Recommender-Protokolle CloudWatch überprüfen. Die Inference Recommender-Protokolle, die in der `/aws/sagemaker/InferenceRecommendationsJobs` CloudWatch Protokollgruppe veröffentlicht werden, bieten einen umfassenden Überblick über den Fortschritt des Jobs im Protokollstream. `/execution` Detaillierte Informationen zu jeder der getesteten Endpunktkonfigurationen finden Sie im `/Endpoint/` Protokollstream.
**Überblick über die Inference Recommender-Logstreams**
+ `/execution` enthält allgemeine Jobinformationen wie Endpunktkonfigurationen, die für das Benchmarking geplant sind, den Grund für das Überspringen von Kompilierungsaufträgen und den Grund für die fehlgeschlagene Validierung.
+ `/Endpoint/` enthält Informationen wie den Fortschritt der Ressourcenerstellung, die Testkonfiguration, den Grund für den Stopp des Ladetests und den Status der Ressourcenbereinigung.
+ `/CompilationJob/` enthält Informationen zu Kompilierungsaufträgen, die von Inference Recommender erstellt wurden, wie z. B. die Konfiguration des Kompilierungsauftrags und den Status des Kompilierungsauftrags.
**Erstellen Sie einen Alarm für Inference Recommender-Fehlermeldungen**
Inference Recommender gibt Protokollanweisungen für Fehler aus, die bei der Fehlerbehebung hilfreich sein können. Mit einer CloudWatch Protokollgruppe und einem Metrikfilter können Sie beim Senden der Daten in diesen Protokolldaten nach Begriffen und Mustern suchen. CloudWatch Anschließend können Sie einen CloudWatch Alarm erstellen, der auf dem Metrikfilter für Protokollgruppen basiert. Weitere Informationen finden Sie unter [Erstellen eines CloudWatch Alarms auf der Grundlage eines Metrikfilters für Protokollgruppen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_alarm_log_group_metric_filter.html).
## Überprüfen Sie die Benchmarks
Wenn Sie einen Inference Recommender-Job starten, erstellt Inference Recommender mehrere Benchmarks, um die Leistung Ihres Modells auf verschiedenen Instance-Typen zu bewerten. Sie können die [ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API verwenden, um die Details für alle Benchmarks anzuzeigen. Wenn Sie einen fehlgeschlagenen Benchmark haben, können Sie die Gründe für das Scheitern als Teil der Ergebnisse sehen.
Um die [ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API zu verwenden, geben Sie die folgenden Werte an:
+ Geben Sie für den Namen des `JobName` Inference Recommender-Jobs an.
+ Für `StepType`, wird verwendet, `BENCHMARK` um Details zu den Benchmarks des Jobs zurückzugeben.
+ Für `Status`, wird verwendet, `FAILED` um nur Details zu den fehlgeschlagenen Benchmarks zurückzugeben. Eine Liste der anderen Statustypen finden Sie in dem `Status` Feld in der [ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide the job name for the SageMaker Inference Recommender job
job_name = ''
# Filter for benchmarks
step_type = 'BENCHMARK'
# Filter for benchmarks that have a FAILED status
status = 'FAILED'
response = sagemaker_client.list_inference_recommendations_job_steps(
JobName = job_name,
StepType = step_type,
Status = status
)
```
Sie können das Antwortobjekt drucken, um die Ergebnisse anzuzeigen. Im vorherigen Codebeispiel wurde die Antwort in einer Variablen mit dem Namen gespeichert`response`:
```
print(response)
```
# Echtzeit-Inferenz
Echtzeit-Inferenz ist ideal für Inferenz-Workloads, bei denen interaktive Echtzeitanforderungen mit niedriger Latenz gestellt werden. Sie können Ihr Modell für SageMaker KI-Hosting-Dienste bereitstellen und einen Endpunkt erhalten, der für Inferenzen verwendet werden kann. Diese Endgeräte werden vollständig verwaltet und unterstützen Autoscaling (siehe [Automatische Skalierung von Amazon SageMaker AI-Modellen](endpoint-auto-scaling.md)).
**Topics**
+ [Modelle für Echtzeit-Inferenzen bereitstellen](realtime-endpoints-deploy-models.md)
+ [Aufrufen von Modellen für Echtzeit-Inferenz](realtime-endpoints-test-endpoints.md)
+ [Endpunkte](realtime-endpoints-manage.md)
+ [Hosting-Optionen](realtime-endpoints-options.md)
+ [Automatische Skalierung von Amazon SageMaker AI-Modellen](endpoint-auto-scaling.md)
+ [Instance-Speicher-Volumes](host-instance-storage.md)
+ [Validieren von Modellen in der Produktion](model-validation.md)
+ [Online-Erklärbarkeit mit Clarify SageMaker](clarify-online-explainability.md)
+ [Optimierung von Modellen mit Adapter-Inferenzkomponenten](realtime-endpoints-adapt.md)
# Modelle für Echtzeit-Inferenzen bereitstellen
**Wichtig**
Benutzerdefinierte IAM-Richtlinien, die es Amazon SageMaker Studio oder Amazon SageMaker Studio Classic ermöglichen, SageMaker Amazon-Ressourcen zu erstellen, müssen auch Berechtigungen zum Hinzufügen von Tags zu diesen Ressourcen gewähren. Die Berechtigung zum Hinzufügen von Tags zu Ressourcen ist erforderlich, da Studio und Studio Classic automatisch alle von ihnen erstellten Ressourcen taggen. Wenn eine IAM-Richtlinie Studio und Studio Classic das Erstellen von Ressourcen, aber kein Tagging erlaubt, können "AccessDenied" Fehler beim Versuch, Ressourcen zu erstellen, auftreten. Weitere Informationen finden Sie unter [Erteilen Sie Berechtigungen für das Taggen von SageMaker KI-Ressourcen](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS verwaltete Richtlinien für Amazon SageMaker AI](security-iam-awsmanpol.md)die Berechtigungen zum Erstellen von SageMaker Ressourcen gewähren, beinhalten bereits Berechtigungen zum Hinzufügen von Tags beim Erstellen dieser Ressourcen.
Es gibt mehrere Möglichkeiten, ein Modell mithilfe von SageMaker KI-Hosting-Diensten bereitzustellen. Sie können ein Modell interaktiv mit SageMaker Studio bereitstellen. Oder Sie können ein Modell mithilfe eines AWS SDK programmgesteuert bereitstellen, z. B. mit dem Python-SDK oder dem SDK für SageMaker Python (Boto3). Sie können die Bereitstellung auch mit dem durchführen. AWS CLI
## Bevor Sie beginnen
Bevor Sie ein SageMaker KI-Modell bereitstellen, sollten Sie Folgendes ausfindig machen und sich Folgendes notieren:
+ AWS-Region Wo sich Ihr Amazon S3 S3-Bucket befindet
+ Pfad des Amazon S3 URI, in dem die Modellartefakte gespeichert sind
+ Die IAM-Rolle für KI SageMaker
+ Der Docker Amazon ECR URI-Registrierungspfad für das benutzerdefinierte Image, das den Inferenzcode enthält, oder das Framework und die Version eines integrierten Docker-Images, das unterstützt wird und von AWS
Eine Liste der jeweils AWS-Services verfügbaren Netzwerke finden Sie unter [Regionskarten AWS-Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) und Edge-Netzwerke. Weitere Informationen zum Erstellen von IAM-Rollen finden Sie unter [Erstellen von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
**Wichtig**
Der Amazon-S3-Bucket, in dem die Modellartefakte gespeichert sind, muss sich in derselben AWS-Region wie das Modell, das Sie erstellen, befinden.
## Gemeinsame Ressourcennutzung mit mehreren Modellen
Mit Amazon SageMaker AI können Sie ein oder mehrere Modelle auf einem Endpunkt bereitstellen. Wenn sich mehrere Modelle einen Endpunkt teilen, nutzen sie gemeinsam die Ressourcen, die dort gehostet werden, wie z. B. die ML-Recheninstanzen und Beschleuniger. CPUs Die flexibelste Methode, mehrere Modelle auf einem Endpunkt bereitzustellen, besteht darin, jedes Modell als *Inferenzkomponente* zu definieren.
### Inferenzkomponenten
Eine Inferenzkomponente ist ein SageMaker KI-Hosting-Objekt, mit dem Sie ein Modell auf einem Endpunkt bereitstellen können. In den Einstellungen für die Inferenzkomponente geben Sie das Modell, den Endpunkt und die Art und Weise an, wie das Modell die vom Endpunkt gehosteten Ressourcen nutzt. Um das Modell zu spezifizieren, können Sie ein SageMaker AI-Model-Objekt angeben, oder Sie können die Modellartefakte und das Bild direkt angeben.
In den Einstellungen können Sie die Ressourcennutzung optimieren, indem Sie anpassen, wie die erforderlichen CPU-Kerne, Accelerators und Speicher dem Modell zugewiesen werden. Sie können mehrere Inferenzkomponenten für einen Endpunkt bereitstellen, wobei jede Inferenzkomponente ein Modell und die für dieses Modell erforderliche Ressourcennutzung enthält.
Nachdem Sie eine Inferenzkomponente bereitgestellt haben, können Sie das zugehörige Modell direkt aufrufen, wenn Sie die InvokeEndpoint Aktion in der SageMaker API verwenden.
Inferenzkomponenten bieten die folgenden Vorteile:
**Flexibilität**
Die Inferenzkomponente entkoppelt die Einzelheiten zum Hosting des Modells vom Endpunkt selbst. Dies bietet mehr Flexibilität und Kontrolle darüber, wie Modelle über einen Endpunkt gehostet und bereitgestellt werden. Sie können mehrere Modelle auf derselben Infrastruktur hosten und je nach Bedarf Modelle zu einem Endpunkt hinzufügen oder daraus entfernen. Sie können jedes Modell unabhängig aktualisieren.
**Skalierbarkeit**
Sie können angeben, wie viele Kopien jedes Modells gehostet werden sollen, und Sie können eine Mindestanzahl von Kopien festlegen, um sicherzustellen, dass das Modell in der Menge geladen wird, die Sie für die Bearbeitung von Anforderungen benötigen. Sie können jede Kopie einer Inferenzkomponente auf Null herunterskalieren, sodass Platz für eine weitere Kopie zum Hochskalieren geschaffen wird.
SageMaker KI verpackt Ihre Modelle als Inferenzkomponenten, wenn Sie sie bereitstellen, indem Sie Folgendes verwenden:
+ SageMaker Studio-Klassiker.
+ Das SageMaker Python-SDK zur Bereitstellung eines Model-Objekts (wobei Sie den Endpunkttyp auf festlegen`EndpointType.INFERENCE_COMPONENT_BASED`).
+ Das AWS SDK für Python (Boto3) zur Definition von `InferenceComponent` Objekten, die Sie auf einem Endpunkt bereitstellen.
## Stellen Sie Modelle mit SageMaker Studio bereit
Führen Sie die folgenden Schritte aus, um Ihr Modell interaktiv über SageMaker Studio zu erstellen und bereitzustellen. Weitere Informationen über Studio finden Sie in der [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html)-Dokumentation. Weitere Anleitungen zu verschiedenen Bereitstellungsszenarien finden Sie im Blog [Verpacken und implementieren Sie klassische ML-Modelle LLMs ganz einfach mit Amazon SageMaker AI — Teil 2.](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-2-interactive-user-experiences-in-sagemaker-studio/)
### Vorbereiten Ihrer Artefakte und Berechtigungen
Füllen Sie diesen Abschnitt aus, bevor Sie ein Modell in SageMaker Studio erstellen.
Sie haben zwei Möglichkeiten, Ihre eigenen Artefakte zu verwenden und ein Modell in Studio zu erstellen:
1. Sie können ein vorgefertigtes `tar.gz`-Archiv verwenden, das Ihre Modellartefakte, benutzerdefinierten Inferenzcode und alle in einer `requirements.txt`-Datei aufgelisteten Abhängigkeiten enthalten sollte.
1. SageMaker KI kann Ihre Artefakte für Sie verpacken. Sie müssen nur Ihre Rohmodellartefakte und alle Abhängigkeiten in einer `requirements.txt` Datei zusammenführen, und SageMaker AI kann Ihnen den Standard-Inferenzcode zur Verfügung stellen (oder Sie können den Standardcode mit Ihrem eigenen benutzerdefinierten Inferenzcode überschreiben). SageMaker AI unterstützt diese Option für die folgenden Frameworks: PyTorch,. XGBoost
Sie müssen nicht nur Ihr Modell, Ihre AWS Identity and Access Management (IAM-) Rolle und einen Docker-Container (oder das gewünschte Framework und die gewünschte Version, für die SageMaker AI einen vorgefertigten Container hat) mitbringen, sondern auch Berechtigungen zum Erstellen und Bereitstellen von Modellen über SageMaker AI Studio gewähren.
Sie sollten die [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html)Richtlinie an Ihre IAM-Rolle angehängt haben, damit Sie auf SageMaker KI und andere relevante Dienste zugreifen können. Um die Preise der Instance-Typen in Studio zu sehen, müssen Sie auch die [AWS PriceListServiceFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPriceListServiceFullAccess.html)Richtlinie anhängen (oder, wenn Sie nicht die gesamte Richtlinie anhängen möchten, genauer gesagt die `pricing:GetProducts` Aktion).
Wenn Sie beim Erstellen eines Modells Ihre Modellartefakte hochladen möchten (oder eine Beispiel-Nutzlastdatei für Inferenzempfehlungen hochladen), müssen Sie einen Amazon-S3-Bucket erstellen. Dem Bucket-Namen muss das Wort `SageMaker AI` vorangestellt werden. Alternative Groß-/Kleinschreibung von SageMaker KI ist ebenfalls zulässig: `Sagemaker` oder`sagemaker`.
Es wird empfohlen, die Benennungskonvention für Buckets zu verwenden: `sagemaker-{Region}-{accountID}`. Dieser Bucket wird verwendet, um die Artefakte zu speichern, die Sie hochladen.
Nachdem Sie den Bucket erstellt haben, fügen Sie ihm die folgende CORS-Richtlinie (Cross-Origin Resource Sharing) hinzu:
```
[
{
"AllowedHeaders": ["*"],
"ExposeHeaders": ["Etag"],
"AllowedMethods": ["PUT", "POST"],
"AllowedOrigins": ['https://*.sagemaker.aws'],
}
]
```
Sie können eine CORS-Richtlinie mit einer der folgenden Methoden an einen Amazon-S3-Bucket anfügen:
+ über die Seite [Bearbeiten von Cross-Origin Resource Sharing (CORS)](https://s3.console.aws.amazon.com/s3/bucket/bucket-name/property/cors/edit) in der Amazon-S3-Konsole
+ Verwenden der Amazon S3 S3-API [PutBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketCors.html)
+ Mit dem put-bucket-cors AWS CLI Befehl:
```
aws s3api put-bucket-cors --bucket="..." --cors-configuration="..."
```
### Erstellen eines bereitstellbaren Modells
In diesem Schritt erstellen Sie eine bereitstellbare Version Ihres Modells in SageMaker KI, indem Sie Ihre Artefakte zusammen mit zusätzlichen Spezifikationen wie Ihrem gewünschten Container und Framework, beliebigen benutzerdefinierten Inferenzcode und Netzwerkeinstellungen bereitstellen.
Erstellen Sie ein bereitstellbares Modell in SageMaker Studio, indem Sie wie folgt vorgehen:
1. Öffnen Sie die SageMaker Studio-Anwendung.
1. Wählen Sie im linken Navigationsbereich **Models (Modelle)** aus.
1. Wählen Sie die Registerkarte **Bereitstellbare Modelle** aus.
1. Wählen Sie auf der Seite **Bereitstellbare Modelle** die Option **Erstellen** aus.
1. Geben Sie auf der Seite **Bereitstellbares Modell erstellen** in das Feld **Modellname** einen Namen für das Modell ein.
Auf der Seite **Bereitstellbares Modell erstellen**gibt es mehrere weitere Abschnitte, die Sie ausfüllen müssen.
Der Abschnitt **Container-Definition** sieht wie der folgende Screenshot aus:
![\[Screenshot des Abschnitts Container-Definition zum Erstellen eines Modells in Studio\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-container-definition.png)
**Führen Sie im Abschnitt **Containerdefinition** Folgendes aus:**
1. Wählen Sie als **Containertyp** die Option **Vorgefertigter Container** aus, wenn Sie einen SageMaker KI-verwalteten Container verwenden möchten, oder wählen Sie **Bring your own container** aus, wenn Sie Ihren eigenen Container haben.
1. Wenn Sie **Vorgefertigter Container** ausgewählt haben, wählen Sie das gewünschte **Container-Framework**, die **Framework-Version** und den **Hardwaretyp** aus.
1. Wenn Sie **Eigenen Container verwenden** ausgewählt haben, geben Sie einen Amazon-ECR-Pfad für den **ECR-Pfad zum Container-Image** ein.
Füllen Sie dann den Abschnitt **Artefakte** aus, der wie der folgende Screenshot aussieht:
![\[Screenshot des Abschnitts Artefakte zum Erstellen eines Modells in Studio\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-artifacts-section.png)
**Gehen Sie im Abschnitt **Artefakte** wie folgt vor:**
1. Wenn Sie eines der Frameworks verwenden, die SageMaker KI für das Verpacken von Modellartefakten (PyTorch oder XGBoost) unterstützt, können Sie für **Artefakte** die Option **Artefakte hochladen** auswählen. Mit dieser Option können Sie einfach Ihre Rohmodellartefakte, jeden benutzerdefinierten Inferenzcode, den Sie haben, und Ihre Datei requirements.txt angeben, und SageMaker AI übernimmt das Packen des Archivs für Sie. Gehen Sie wie folgt vor:
1. Wählen Sie für **Artefakte** die Option **Artefakte hochladen** aus, um Ihre Dateien weiterhin bereitzustellen. Andernfalls, wenn Sie bereits über ein `tar.gz`-Archiv verfügen, das Ihre Modelldateien, Ihren Inferenzcode und Ihre `requirements.txt`-Datei enthält, wählen Sie **S3-URI für vorgefertigte Artefakte eingeben** aus.
1. Wenn Sie Ihre Artefakte hochladen möchten, geben Sie für den **S3-Bucket** den Amazon S3 S3-Pfad zu einem Bucket ein, in dem SageMaker KI Ihre Artefakte speichern soll, nachdem sie für Sie verpackt wurden. Führen Sie anschließend die folgenden Schritte aus.
1. Laden Sie unter **Modellartefakte hochladen** Ihre Modelldateien hoch.
1. Wählen Sie **unter Inferenzcode** die Option **Standard-Inferenzcode verwenden** aus, wenn Sie den Standardcode verwenden möchten, den SageMaker KI für die Bereitstellung von Inferenzen bereitstellt. Wenn Sie stattdessen Ihren eigenen Inferenzcode verwenden möchten, wählen Sie **Benutzerdefinierten Inferenzcode hochladen** aus.
1. Laden Sie über **requirements.txt hochladen** eine Textdatei hoch, in der alle Abhängigkeiten aufgeführt sind, die Sie zur Laufzeit installieren möchten.
1. Wenn Sie kein Framework verwenden, das SageMaker KI für das Verpacken von Modellartefakten unterstützt, zeigt Ihnen Studio die Option **Vorgefertigte Artefakte** an, und Sie müssen alle Ihre Artefakte, die bereits verpackt sind, als Archiv bereitstellen. `tar.gz` Gehen Sie wie folgt vor:
1. Wählen Sie unter **Vorgefertigte Artefakte** die Option **S3-URI für vorgefertigte Modellartefakte eingeben** aus, wenn Sie Ihr `tar.gz`-Archiv bereits auf Amazon S3 hochgeladen haben. Wählen Sie **Vorverpackte Modellartefakte hochladen** aus, wenn Sie Ihr Archiv direkt in AI hochladen möchten. SageMaker
1. Wenn Sie **S3-URI für vorgefertigte Modellartefakte eingeben** ausgewählt haben, geben Sie unter **S3-URI** den Amazon-S3-Pfad zu Ihrem Archiv ein. Andernfalls wählen Sie das Archiv aus und laden es von Ihrem lokalen Rechner hoch.
Der nächste Abschnitt ist **Sicherheit** und sieht wie der folgende Screenshot aus:
![\[Screenshot des Abschnitts Sicherheit zum Erstellen eines Modells in Studio\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-security-section.png)
**Gehen Sie im Abschnitt **Sicherheit** wie folgt vor:**
1. Geben Sie unter **IAM-Rolle** den ARN für eine IAM-Rolle ein.
1. (Optional) Unter **Virtual Private Cloud (VPC)** können Sie eine Amazon-VPC zum Speichern Ihrer Modellkonfiguration und Ihrer Artefakte auswählen.
1. (Optional) Aktivieren Sie die Option **Netzwerkisolierung**, wenn Sie den Internetzugang Ihres Containers einschränken möchten.
Abschließend können Sie bei Bedarf den Abschnitt **Erweiterte Optionen** ausfüllen, der wie der folgende Screenshot aussieht:
![\[Screenshot des Abschnitts Erweiterte Optionen zum Erstellen eines Modells in Studio\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-advanced-options.png)
**(Optional) Führen Sie im Abschnitt **Erweiterte Optionen** Folgendes aus:**
1. Aktivieren Sie die Option **Benutzerdefinierte Instanzempfehlungen**, wenn Sie nach der Erstellung einen Amazon SageMaker Inference Recommender-Job für Ihr Modell ausführen möchten. Inference Recommender ist ein Feature, das Ihnen empfohlene Instance-Typen zur Optimierung der Leistung und der Kosten von Inferenzen bietet. Sie können sich diese Instance-Empfehlungen ansehen, wenn Sie sich auf die Bereitstellung Ihres Modells vorbereiten.
1. Geben Sie unter **Umgebungsvariablen hinzufügen** die Umgebungsvariablen für Ihren Container als Schlüssel-Wert-Paare ein.
1. Geben Sie unter **Tags** beliebige Tags als Schlüssel-Wert-Paare ein.
1. Wählen Sie nach Abschluss der Modell- und Container-Konfiguration die Option **Bereitstellbares Modell erstellen** aus.
Sie sollten jetzt über ein Modell in SageMaker Studio verfügen, das für die Bereitstellung bereit ist.
### Bereitstellen Ihres Modells
Schließlich stellen Sie das Modell, das Sie im vorherigen Schritt konfiguriert haben, auf einem HTTPS-Endpunkt bereit. Sie können entweder ein einzelnes oder mehrere Modelle für den Endpunkt bereitstellen.
**Modell- und Endpunktkompatibilität**
Bevor Sie ein Modell auf einem Endpunkt bereitstellen können, müssen Modell und Endpunkt kompatibel sein und dieselben Werte für die folgenden Einstellungen aufweisen:
die IAM-Rolle
die Amazon VPC, einschließlich ihrer Subnetze und Sicherheitsgruppen
die Netzwerkisolierung (aktiviert oder deaktiviert)
Studio verhindert auf folgende Weise, dass Sie Modelle auf inkompatiblen Endpunkten bereitstellen:
Wenn Sie versuchen, ein Modell auf einem neuen Endpunkt bereitzustellen, konfiguriert SageMaker AI den Endpunkt mit kompatiblen Anfangseinstellungen. Wenn Sie die Kompatibilität durch eine Änderung dieser Einstellungen beeinträchtigen, zeigt Studio eine Warnung an und verhindert die Bereitstellung.
Wenn Sie versuchen, eine Bereitstellung auf einem vorhandenen Endpunkt durchzuführen und dieser Endpunkt nicht kompatibel ist, zeigt Studio eine Warnung an und verhindert die Bereitstellung.
Wenn Sie versuchen, einer Bereitstellung mehrere Modelle hinzuzufügen, die nicht miteinander kompatibel sind, verhindert Studio die Bereitstellung dieser Modelle.
Wenn Studio die Warnung zur Modell- und Endpunktinkompatibilität anzeigt, können Sie über die Schaltfläche **Details anzeigen** prüfen, welche Einstellungen nicht kompatibel sind.
Eine Möglichkeit, ein Modell bereitzustellen, besteht darin, in Studio wie folgt vorzugehen:
1. Öffnen Sie die SageMaker Studio-Anwendung.
1. Wählen Sie im linken Navigationsbereich **Models (Modelle)** aus.
1. Wählen Sie auf der Seite **Modelle** ein oder mehrere Modelle aus der Liste der SageMaker KI-Modelle aus.
1. Wählen Sie **Bereitstellen**.
1. Öffnen Sie das Dropdown-Menü unter **Endpunktname**. Sie können entweder einen vorhandenen Endpunkt auswählen oder einen neuen Endpunkt erstellen, auf dem Sie das Modell bereitstellen.
1. Wählen Sie unter **Instance-Typ** den Instance-Typ aus, den Sie für den Endpunkt verwenden möchten. Wenn Sie zuvor einen Inference-Recommender-Job für das Modell ausgeführt haben, werden Ihre empfohlenen Instance-Typen in der Liste unter dem Titel **Empfohlen** angezeigt. Andernfalls werden Ihnen einige **voraussichtliche Instances** angezeigt, die möglicherweise für Ihr Modell geeignet sind.
**Kompatibilität mit dem Instanztyp für JumpStart**
Wenn Sie ein JumpStart Modell bereitstellen, zeigt Studio nur Instanztypen an, die das Modell unterstützt.
1. Geben Sie unter **Anfängliche Instance-Anzahl** die anfängliche Anzahl der Instances ein, die Sie für Ihren Endpunkt bereitstellen möchten.
1. Geben Sie unter **Maximale Instance-Anzahl** die maximale Anzahl von Instances an, die der Endpunkt bereitstellen kann, wenn er entsprechend einem Anstieg des Datenverkehrs skaliert wird.
1. Wenn das Modell, das Sie bereitstellen, eines der am häufigsten JumpStart LLMs vom Model Hub verwendeten ist, wird die Option **Alternative Konfigurationen** hinter den Feldern Instanztyp und Instanzanzahl angezeigt.
Für die beliebtesten Instance-Typen AWS wurden vorab Benchmarks durchgeführt JumpStart LLMs, um entweder Kosten oder Leistung zu optimieren. Diese Daten können Ihnen bei der Entscheidung helfen, welchen Instance-Typ Sie für die Bereitstellung Ihres LLM verwenden möchten. Wählen Sie **Alternative Konfigurationen** aus, um ein Dialogfeld zu öffnen, das die vorab geprüften Daten enthält. Das Panel sieht wie im folgenden Screenshot aus:
![\[Screenshot des Felds Alternative Konfigurationen\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-jumpstart-alternate-configurations.png)
Gehen Sie im Feld **Alternative Konfigurationen** wie folgt vor:
1. Auswahl von Instance-Typen Sie können **Kosten pro Stunde** oder **Beste Leistung** wählen, um Instance-Typen anzuzeigen, die entweder die Kosten oder die Leistung für das angegebene Modell optimieren. Sie können auch **Andere unterstützte Instances** wählen, um eine Liste anderer Instance-Typen zu sehen, die mit dem JumpStart Modell kompatibel sind. Beachten Sie, dass die Auswahl eines Instance-Typs hier alle zuvor in Schritt 6 ausgewählten Instances überschreibt.
1. (Optional) Aktivieren Sie die Option **Ausgewählte Konfiguration anpassen**, um **Max. Token-Gesamtzahl** (die maximale Anzahl von Tokens, die Sie zulassen möchten, d. h. die Summe Ihrer Eingabe-Token und der generierten Ausgabe des Modells), **Max. Länge des Eingabe-Tokens** (die maximale Anzahl von Tokens, die Sie für die Eingabe jeder Anforderung zulassen möchten) und **Max. Anzahl gleichzeitiger Anfragen** (die maximale Anzahl von Anfragen, die das Modell gleichzeitig verarbeiten kann) anzugeben.
1. Wählen Sie **Auswählen**, um Ihren Instance-Typ und Ihre Konfigurationseinstellungen zu bestätigen.
1. Das Feld **Modell** sollte bereits mit dem Namen des Modells oder der Modelle ausgefüllt sein, das bzw. die Sie bereitstellen. Sie können **Modell hinzufügen** auswählen, um der Bereitstellung weitere Modelle hinzuzufügen. Füllen Sie für jedes Modell, das Sie hinzufügen, die folgenden Felder aus:
1. Geben Sie unter **Anzahl der CPU-Kerne** die CPU-Kerne ein, die Sie für die Nutzung des Modells reservieren möchten.
1. Geben Sie unter **Mindestanzahl an Kopien** die Mindestanzahl von Modellkopien ein, die zu einem bestimmten Zeitpunkt auf dem Endpunkt gehostet werden sollen.
1. Geben Sie unter **Min. CPU-Speicher (MB)** die Mindestmenge an Arbeitsspeicher (in MB) ein, die das Modell benötigt.
1. Geben Sie für **Max. CPU-Speicher (MB)** die maximale Speichermenge (in MB) ein, die das Modell verwenden darf.
1. (Optional) Führen Sie unter **Erweiterte Optionen** Folgendes aus:
1. Verwenden Sie für die **IAM-Rolle** entweder die standardmäßige SageMaker AI IAM-Ausführungsrolle oder geben Sie Ihre eigene Rolle an, die über die erforderlichen Berechtigungen verfügt. Beachten Sie, dass diese IAM-Rolle mit der Rolle identisch sein muss, die Sie beim Erstellen des bereitstellbaren Modells angegeben haben.
1. Unter **Virtual Private Cloud (VPC)** können Sie eine VPC angeben, in der Sie Ihren Endpunkt hosten möchten.
1. Wählen Sie für **Encryption KMS Key** einen AWS KMS Schlüssel aus, um Daten auf dem Speichervolume zu verschlüsseln, das an die ML-Compute-Instanz angehängt ist, die den Endpunkt hostet.
1. Aktivieren Sie die Option **Netzwerkisolierung aktivieren**, um den Internetzugang Ihres Containers einzuschränken.
1. Füllen Sie unter **Timeout-Konfiguration** die Felder **Timeout beim Herunterladen von Modelldaten (Sekunden)** und **Timeout für die Zustandsprüfung beim Container-Start (Sekunden)** aus. Diese Werte bestimmen die maximale Zeit, die SageMaker KI für das Herunterladen des Modells in den Container bzw. das Starten des Containers einräumt.
1. Geben Sie unter **Tags** beliebige Tags als Schlüssel-Wert-Paare ein.
**Anmerkung**
SageMaker AI konfiguriert die IAM-Rollen-, VPC- und Netzwerkisolationseinstellungen mit Anfangswerten, die mit dem Modell kompatibel sind, das Sie bereitstellen. Wenn Sie die Kompatibilität durch eine Änderung dieser Einstellungen beeinträchtigen, zeigt Studio eine Warnung an und verhindert die Bereitstellung.
Nachdem Sie die Optionen konfiguriert haben, sollte die Seite wie im folgenden Screenshot aussehen.
![\[Screenshot der Seite Modell bereitstellen in Studio.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-deploy-realtime-model-2.png)
Nachdem Sie die Bereitstellung konfiguriert haben, wählen Sie **Bereitstellen** aus, um den Endpunkt zu erstellen und Ihr Modell bereitzustellen.
## Modelle mit Python bereitstellen SDKs
Mit dem SageMaker Python-SDK können Sie Ihr Modell auf zwei Arten erstellen. Die erste Möglichkeit besteht darin, ein Modellobjekt aus der Klasse `Model` oder `ModelBuilder` zu erstellen. Wenn Sie die `Model`-Klasse verwenden, um Ihr `Model`-Objekt zu erstellen, müssen Sie das Modellpaket oder den Inferenzcode (abhängig von Ihrem Modellserver), Skripte für die Serialisierung und Deserialisierung von Daten zwischen dem Client und dem Server sowie alle Abhängigkeiten angeben, die zur Nutzung auf Amazon S3 hochgeladen werden sollen. Alternativ können Sie Ihr Modell mit `ModelBuilder` erstellen, wofür Sie Modellartefakte oder Inferenzcode bereitstellen. `ModelBuilder` erfasst automatisch Ihre Abhängigkeiten, leitet die benötigten Serialisierungs- und Deserialisierungsfunktionen ab und verpackt Ihre Abhängigkeiten, um Ihr `Model`-Objekt zu erstellen. Mehr über `ModelBuilder` erfahren Sie unter [Erstellen Sie ein Modell in Amazon SageMaker AI mit ModelBuilder](how-it-works-modelbuilder-creation.md).
Im folgenden Abschnitt werden beide Methoden beschrieben, mit denen Sie Ihr Modell erstellen und Ihr Modellobjekt bereitstellen können.
### Einrichten
Die folgenden Beispiele bereiten den Prozess der Modellbereitstellung vor. Sie importieren die erforderlichen Bibliotheken und definieren die S3-URL, die die Modellartefakte lokalisiert.
------
#### [ SageMaker Python SDK ]
**Example Importanweisungen**
Im folgenden Beispiel werden Module aus dem SageMaker Python-SDK, dem SDK für Python (Boto3) und der Python-Standardbibliothek importiert. Diese Module bieten nützliche Methoden, die Ihnen bei der Bereitstellung von Modellen helfen, und werden in den übrigen folgenden Beispielen verwendet.
```
import boto3
from datetime import datetime
from sagemaker.compute_resource_requirements.resource_requirements import ResourceRequirements
from sagemaker.predictor import Predictor
from sagemaker.enums import EndpointType
from sagemaker.model import Model
from sagemaker.session import Session
```
------
#### [ boto3 inference components ]
**Example Importanweisungen**
Das folgende Beispiel importiert Module aus dem SDK für Python (Boto3) und der Python Standard Library. Diese Module bieten nützliche Methoden, die Ihnen bei der Bereitstellung von Modellen helfen, und werden in den übrigen folgenden Beispielen verwendet.
```
import boto3
import botocore
import sys
import time
```
------
#### [ boto3 models (without inference components) ]
**Example Importanweisungen**
Das folgende Beispiel importiert Module aus dem SDK für Python (Boto3) und der Python Standard Library. Diese Module bieten nützliche Methoden, die Ihnen bei der Bereitstellung von Modellen helfen, und werden in den übrigen folgenden Beispielen verwendet.
```
import boto3
import botocore
import datetime
from time import gmtime, strftime
```
------
**Example Modellartefakt-URL**
Der folgende Code erstellt eine beispielhafte Amazon-S3-URL. Die URL sucht nach Modellartefakten für ein vortrainiertes Modell in einem Amazon-S3-Bucket.
```
# Create a variable w/ the model S3 URL
# The name of your S3 bucket:
s3_bucket = "amzn-s3-demo-bucket"
# The directory within your S3 bucket your model is stored in:
bucket_prefix = "sagemaker/model/path"
# The file name of your model artifact:
model_filename = "my-model-artifact.tar.gz"
# Relative S3 path:
model_s3_key = f"{bucket_prefix}/"+model_filename
# Combine bucket name, model file name, and relate S3 path to create S3 model URL:
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
Die vollständige Amazon-S3-URL wird in der Variablen `model_url` gespeichert, die in den folgenden Beispielen verwendet wird.
### -Übersicht
Es gibt mehrere Möglichkeiten, Modelle mit dem SageMaker Python-SDK oder dem SDK für Python (Boto3) bereitzustellen. In den folgenden Abschnitten werden die Schritte zusammengefasst, die Sie für verschiedene mögliche Ansätze ausführen. Diese Schritte werden anhand der folgenden Beispiele veranschaulicht.
------
#### [ SageMaker Python SDK ]
Mit dem SageMaker Python-SDK können Sie Ihr Modell auf eine der folgenden Arten erstellen:
+ **Erstellen eines Modellobjekts anhand der `Model`-Klasse** – Sie müssen das Modellpaket oder den Inferenzcode (abhängig von Ihrem Modellserver), Skripten für die Serialisierung und Deserialisierung von Daten zwischen dem Client und dem Server sowie alle Abhängigkeiten angeben, die zur Nutzung auf Amazon S3 hochgeladen werden sollen.
+ **Erstellen eines Modellobjekt anhand der `ModelBuilder`-Klasse** – Sie stellen Modellartefakte oder Inferenzcode bereit und `ModelBuilder` erfasst automatisch Ihre Abhängigkeiten, leitet die benötigten Serialisierungs- und Deserialisierungsfunktionen ab und verpackt Ihre Abhängigkeiten, um Ihr `Model`-Objekt zu erstellen.
Mehr über `ModelBuilder` erfahren Sie unter [Erstellen Sie ein Modell in Amazon SageMaker AI mit ModelBuilder](how-it-works-modelbuilder-creation.md). Weitere Informationen finden Sie auch im Blog [Klassische ML-Modelle verpacken und bereitstellen — LLMs ganz einfach mit SageMaker KI — Teil 1.](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/)
In den folgenden Beispielen werden beide Methoden beschrieben, mit denen Sie Ihr Modell erstellen und Ihr Modellobjekt bereitstellen können. Führen Sie die folgenden Schritte aus, um auf diese Weise ein Modell bereitzustellen:
1. Definieren Sie die Endpunktressourcen, die dem Modell mit einem `ResourceRequirements`-Objekt zugewiesen werden sollen.
1. Erstellen Sie ein Modellobjekt aus der Klasse `ModelBuilder` oder `Model`. Das `ResourceRequirements`-Objekt ist in den Modelleinstellungen angegeben.
1. Stellen Sie das Modell mithilfe der `deploy`-Methode des `Model`-Objekts auf einem Endpunkt bereit.
------
#### [ boto3 inference components ]
Die folgenden Beispiele zeigen, wie Sie ein Modell einer Inferenzkomponente zuweisen und diese dann auf einem Endpunkt bereitstellen. Führen Sie die folgenden Schritte aus, um ein Modell auf diese Weise bereitzustellen:
1. (Optional) Erstellen Sie mithilfe der [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)Methode ein SageMaker KI-Modellobjekt.
1. Geben Sie die Einstellungen für Ihren Endpunkt an, indem Sie ein Endpunktkonfigurationsobjekt erstellen. Verwenden Sie hierfür die [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config)-Methode.
1. Erstellen Sie Ihren Endpunkt mithilfe der [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html)-Methode und geben Sie in Ihrer Anforderung die Endpunktkonfiguration an, die Sie erstellt haben.
1. Erstellen Sie mithilfe der `create_inference_component`-Methode eine Inferenzkomponente. In den Einstellungen geben Sie ein Modell an, indem Sie entweder
+ Spezifizieren eines SageMaker AI-Modellobjekts
+ den Modell-Image-URI und die S3-URL angeben.
Sie weisen dem Modell auch Endpunktressourcen zu. Durch die Erstellung der Inferenzkomponente stellen Sie das Modell auf dem Endpunkt bereit. Sie können mehrere Modelle auf einem Endpunkt bereitstellen, indem Sie mehrere Inferenzkomponenten erstellen – eine für jedes Modell.
------
#### [ boto3 models (without inference components) ]
Die folgenden Beispiele zeigen, wie Sie ein Modellobjekt erstellen und das Modell anschließend auf einem Endpunkt bereitstellen. Führen Sie die folgenden Schritte aus, um ein Modell auf diese Weise bereitzustellen:
1. Erstellen Sie mithilfe der [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)Methode ein SageMaker KI-Modell.
1. Geben Sie die Einstellungen für Ihren Endpunkt an, indem Sie ein Endpunktkonfigurationsobjekt erstellen. Verwenden Sie hierfür die [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config)-Methode. In der Endpunktkonfiguration weisen Sie das Modellobjekt einer Produktionsvariante zu.
1. Erstellen Sie Ihren Endpunkt mithilfe der [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html)-Methode. Geben Sie in Ihrer Anforderung die Endpunktkonfiguration an, die Sie erstellt haben.
Wenn Sie den Endpunkt erstellen, stellt SageMaker KI die Endpunktressourcen bereit und stellt das Modell auf dem Endpunkt bereit.
------
### Konfiguration
In den folgenden Beispielen werden die Ressourcen konfiguriert, die Sie für die Bereitstellung eines Modells auf einem Endpunkt benötigen.
------
#### [ SageMaker Python SDK ]
Im folgenden Beispiel werden einem Modell mit einem `ResourceRequirements`-Objekt Endpunktressourcen zugewiesen. Zu diesen Ressourcen gehören CPU-Kerne, Accelerators und Speicher. Anschließend erstellt das Beispiel ein Modellobjekt aus der `Model`-Klasse. Alternativ können Sie ein Modellobjekt erstellen, indem Sie die [ModelBuilder](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-modelbuilder-creation.html)Klasse instanziieren und ausführen `build` — diese Methode wird auch im Beispiel gezeigt. `ModelBuilder`bietet eine einheitliche Schnittstelle für das Paketieren von Modellen und bereitet in diesem Fall ein Modell für eine umfangreiche Modellbereitstellung vor. Das Beispiel verwendet `ModelBuilder`, um ein Hugging-Face-Modell zu konstruieren. (Sie können auch ein JumpStart Modell übergeben). Sobald Sie das Modell erstellt haben, können Sie die Ressourcenanforderungen im Modellobjekt angeben. Im nächsten Schritt verwenden Sie dieses Objekt, um das Modell auf einem Endpunkt bereitzustellen.
```
resources = ResourceRequirements(
requests = {
"num_cpus": 2, # Number of CPU cores required:
"num_accelerators": 1, # Number of accelerators required
"memory": 8192, # Minimum memory required in Mb (required)
"copies": 1,
},
limits = {},
)
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y-%H-%M-%S")
model_name = "my-sm-model"+dt_string
# build your model with Model class
model = Model(
name = "model-name",
image_uri = "image-uri",
model_data = model_url,
role = "arn:aws:iam::111122223333:role/service-role/role-name",
resources = resources,
predictor_cls = Predictor,
)
# Alternate mechanism using ModelBuilder
# uncomment the following section to use ModelBuilder
/*
model_builder = ModelBuilder(
model="", # like "meta-llama/Llama-2-7b-hf"
schema_builder=SchemaBuilder(sample_input,sample_output),
env_vars={ "HUGGING_FACE_HUB_TOKEN": "}" }
)
# build your Model object
model = model_builder.build()
# create a unique name from string 'mb-inference-component'
model.model_name = unique_name_from_base("mb-inference-component")
# assign resources to your model
model.resources = resources
*/
```
------
#### [ boto3 inference components ]
Im folgenden Beispiel wird ein Endpunkt mit der `create_endpoint_config`-Methode konfiguriert. Sie weisen diese Konfiguration einem Endpunkt zu, wenn Sie ihn erstellen. In der Konfiguration definieren Sie eine oder mehrere Produktionsvarianten. Für jede Variante können Sie den Instance-Typ auswählen, den Amazon SageMaker AI bereitstellen soll, und Sie können die verwaltete Instance-Skalierung aktivieren.
```
endpoint_config_name = "endpoint-config-name"
endpoint_name = "endpoint-name"
inference_component_name = "inference-component-name"
variant_name = "variant-name"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
ProductionVariants = [
{
"VariantName": variant_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1,
"ManagedInstanceScaling": {
"Status": "ENABLED",
"MinInstanceCount": 1,
"MaxInstanceCount": 2,
},
}
],
)
```
------
#### [ boto3 models (without inference components) ]
**Example Modelldefinition**
Das folgende Beispiel definiert ein SageMaker KI-Modell mit der `create_model` Methode in AWS SDK für Python (Boto3).
```
model_name = "model-name"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
PrimaryContainer = {
"Image": "image-uri",
"ModelDataUrl": model_url,
}
)
```
In diesem Beispiel wird Folgendes festgelegt:
+ `ModelName`: Ein Name für Ihr Modell (in diesem Beispiel wird es als String-variable namens `model_name` gespeichert).
+ `ExecutionRoleArn`: Der Amazon-Ressourcenname (ARN) der IAM-Rolle, die Amazon SageMaker AI übernehmen kann, um auf Modellartefakte und Docker-Images für die Bereitstellung auf ML-Compute-Instances oder für Batch-Transformationsjobs zuzugreifen.
+ `PrimaryContainer`: Der Speicherort des primären Docker-Image mit Inferenzcode, zugehörigen Artefakten und benutzerdefinierter Umgebungs-Map, die der Inferenz-Code verwendet, wenn das Modell für die Voraussagen bereitgestellt wird.
**Example Endpunktkonfiguration**
Im folgenden Beispiel wird ein Endpunkt mit der `create_endpoint_config`-Methode konfiguriert. Amazon SageMaker AI verwendet diese Konfiguration, um Modelle bereitzustellen. In der Konfiguration identifizieren Sie ein oder mehrere Modelle, die mit der `create_model` Methode erstellt wurden, um die Ressourcen bereitzustellen, die Amazon SageMaker AI bereitstellen soll.
```
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName = "endpoint-config-name",
# List of ProductionVariant objects, one for each model that you want to host at this endpoint:
ProductionVariants = [
{
"VariantName": "variant-name", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
]
)
```
In diesem Beispiel werden die folgenden Schlüssel für das `ProductionVariants`-Feld angegeben:
+ `VariantName`: Der Name der Produktionsvariante
+ `ModelName`: Der Name des Modells, das Sie hosten möchten. Dies ist der Name, den Sie beim Erstellen des Modells angegeben haben.
+ `InstanceType`: DerCompute-Instances-Typ. Eine Liste der unterstützten Compute-Instance-Typen [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) und [Preise für jeden Instance-Typ finden Sie im `InstanceType` Feld und SageMaker KI-Preise](https://aws.amazon.com/sagemaker/pricing/).
------
### Bereitstellen
In den folgenden Beispielen wird ein Modell für einen Endpunkt bereitgestellt.
------
#### [ SageMaker Python SDK ]
Im folgenden Beispiel wird das Modell mit der `deploy`-Methode des Modellobjekts auf einem HTTPS-Echtzeitendpunkt bereitgestellt. Wenn Sie sowohl für die Erstellung als auch für die Bereitstellung des Modells einen Wert für das `resources`-Argument angeben, haben die Ressourcen, die Sie für die Bereitstellung angeben, Vorrang.
```
predictor = model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
resources = resources,
)
```
Als `instance_type` ist im Beispiel der Name des Amazon-EC2-Instance-Typs für das Modell angegeben. Im Feld `initial_instance_count` ist die anfängliche Anzahl von Instances angegeben, auf denen der Endpunkt ausgeführt werden soll.
Das folgende Codebeispiel zeigt einen weiteren Fall, in dem Sie ein Modell auf einem Endpunkt und dann ein anderes Modell auf demselben Endpunkt bereitstellen. In diesem Fall müssen Sie denselben Endpunktnamen für die `deploy`-Methoden beider Modelle angeben.
```
# Deploy the model to inference-component-based endpoint
falcon_predictor = falcon_model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = ""
resources = resources,
)
# Deploy another model to the same inference-component-based endpoint
llama2_predictor = llama2_model.deploy( # resources already set inside llama2_model
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = "" # same endpoint name as for falcon model
)
```
------
#### [ boto3 inference components ]
Sobald Sie eine Endpunktkonfiguration haben, verwenden Sie die Methode [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html), um Ihren Endpunkt zu erstellen. Der Endpunktname muss innerhalb eines AWS-Region AWS Kontos eindeutig sein.
Im folgenden Beispiel wird ein Endpunkt unter Verwendung der in der Anfrage angegebenen Endpunktkonfiguration erstellt. Amazon SageMaker AI verwendet den Endpunkt zur Bereitstellung von Ressourcen.
```
sagemaker_client.create_endpoint(
EndpointName = endpoint_name,
EndpointConfigName = endpoint_config_name,
)
```
Nachdem Sie einen Endpunkt erstellt haben, können Sie einen oder mehrere Modelle darauf bereitstellen, indem Sie Inferenzkomponenten erstellen. Im folgenden Beispiel wird eine Inferenzkomponente mit der `create_inference_component`-Methode erstellt.
```
sagemaker_client.create_inference_component(
InferenceComponentName = inference_component_name,
EndpointName = endpoint_name,
VariantName = variant_name,
Specification = {
"Container": {
"Image": "image-uri",
"ArtifactUrl": model_url,
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
},
RuntimeConfig = {"CopyCount": 2}
)
```
------
#### [ boto3 models (without inference components) ]
**Example Einsatz**
Stellen Sie SageMaker AI die Endpunktkonfiguration zur Verfügung. Der Service startet die ML-Compute-Instances und stellt die Modelle gemäß der Konfiguration bereit.
Sobald Sie Ihr Modell und Ihre Endpunktkonfiguration haben, verwenden Sie die [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html)-Methode, um Ihren Endpunkt zu erstellen. Der Endpunktname muss innerhalb und AWS-Region in Ihrem AWS Konto eindeutig sein.
Im folgenden Beispiel wird ein Endpunkt unter Verwendung der in der Anfrage angegebenen Endpunktkonfiguration erstellt. Amazon SageMaker AI verwendet den Endpunkt, um Ressourcen bereitzustellen und Modelle bereitzustellen.
```
create_endpoint_response = sagemaker_client.create_endpoint(
# The endpoint name must be unique within an AWS Region in your AWS account:
EndpointName = "endpoint-name"
# The name of the endpoint configuration associated with this endpoint:
EndpointConfigName = "endpoint-config-name")
```
------
## Stellen Sie Modelle bereit mit dem AWS CLI
Sie können ein Modell auf einem Endpunkt bereitstellen, indem Sie den verwenden AWS CLI.
### -Übersicht
Wenn Sie ein Modell mit dem bereitstellen AWS CLI, können Sie es mit oder ohne Verwendung einer Inferenzkomponente bereitstellen. In den folgenden Abschnitten werden die Befehle zusammengefasst, die Sie für beide Ansätze ausführen. Diese Befehle werden anhand der folgenden Beispiele veranschaulicht.
------
#### [ With inference components ]
Um ein Modell mit einer Inferenzkomponente bereitzustellen, führen Sie die folgenden Schritte aus:
1. (Optional) Erstellen Sie ein Modell mit dem [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html)-Befehl.
1. Geben Sie die Einstellungen für Ihren Endpunkt an, indem Sie eine Endpunktkonfiguration erstellen. Führen Sie hierfür den [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)-Befehl aus.
1. Erstellen Sie Ihren Endpunkt mithilfe des [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html)-Befehls. Geben Sie im Befehlstext die Endpunktkonfiguration an, die Sie erstellt haben.
1. Erstellen Sie mit dem `create-inference-component`-Befehl eine Inferenzkomponente. In den Einstellungen geben Sie ein Modell an, indem Sie entweder
+ Spezifizieren eines SageMaker AI-Modellobjekts
+ den Modell-Image-URI und die S3-URL angeben.
Sie weisen dem Modell auch Endpunktressourcen zu. Durch die Erstellung der Inferenzkomponente stellen Sie das Modell auf dem Endpunkt bereit. Sie können mehrere Modelle auf einem Endpunkt bereitstellen, indem Sie mehrere Inferenzkomponenten erstellen – eine für jedes Modell.
------
#### [ Without inference components ]
Um ein Modell ohne Verwendung einer Inferenzkomponente bereitzustellen, führen Sie die folgenden Schritte aus:
1. Erstellen Sie mit dem [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html)Befehl ein SageMaker KI-Modell.
1. Geben Sie die Einstellungen für Ihren Endpunkt an, indem Sie ein Endpunktkonfigurationsobjekt erstellen. Verwenden Sie hierfür den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html). In der Endpunktkonfiguration weisen Sie das Modellobjekt einer Produktionsvariante zu.
1. Erstellen Sie Ihren Endpunkt mithilfe des [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html)-Befehls. Geben Sie im Befehlstext die Endpunktkonfiguration an, die Sie erstellt haben.
Wenn Sie den Endpunkt erstellen, stellt SageMaker KI die Endpunktressourcen bereit und stellt das Modell auf dem Endpunkt bereit.
------
### Konfiguration
In den folgenden Beispielen werden die Ressourcen konfiguriert, die Sie für die Bereitstellung eines Modells auf einem Endpunkt benötigen.
------
#### [ With inference components ]
**Example create-endpoint-config Befehl**
Im folgenden Beispiel wird mit dem [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)Befehl eine Endpunktkonfiguration erstellt.
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name\
--production-variants file://production-variants.json
```
In diesem Beispiel definiert die Datei `production-variants.json` eine Produktionsvariante mit dem folgenden JSON:
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
Wenn der Befehl erfolgreich ist, AWS CLI antwortet der mit dem ARN für die von Ihnen erstellte Ressource.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
#### [ Without inference components ]
**Example create-model-Befehl**
Im folgenden Beispiel wird ein Modell mit dem Befehl [create-model](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html) erstellt.
```
aws sagemaker create-model \
--model-name model-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name \
--primary-container "{ \"Image\": \"image-uri\", \"ModelDataUrl\": \"model-s3-url\"}"
```
Wenn der Befehl erfolgreich ist, AWS CLI antwortet der mit dem ARN für die von Ihnen erstellte Ressource.
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:111122223333:model/model-name"
}
```
**Example create-endpoint-config Befehl**
Im folgenden Beispiel wird mit dem [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)Befehl eine Endpunktkonfiguration erstellt.
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--production-variants file://production-variants.json
```
In diesem Beispiel definiert die Datei `production-variants.json` eine Produktionsvariante mit dem folgenden JSON:
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
Wenn der Befehl erfolgreich ist, AWS CLI antwortet der mit dem ARN für die von Ihnen erstellte Ressource.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
### Bereitstellen
In den folgenden Beispielen wird ein Modell für einen Endpunkt bereitgestellt.
------
#### [ With inference components ]
**Example create-endpoint-Befehl**
Das folgende Beispiel erstellt einen Endpunkt mit dem Befehl [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
Wenn der Befehl erfolgreich ist, AWS CLI antwortet der mit dem ARN für die von Ihnen erstellte Ressource.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
**Example create-inference-component Befehl**
Im folgenden Beispiel wird mit dem create-inference-component Befehl eine Inferenzkomponente erstellt.
```
aws sagemaker create-inference-component \
--inference-component-name inference-component-name \
--endpoint-name endpoint-name \
--variant-name variant-name \
--specification file://specification.json \
--runtime-config "{\"CopyCount\": 2}"
```
In diesem Beispiel definiert die Datei `specification.json` den Container und die Rechenressourcen mit dem folgenden JSON-Code:
```
{
"Container": {
"Image": "image-uri",
"ArtifactUrl": "model-s3-url"
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
}
```
Wenn der Befehl erfolgreich ist, AWS CLI antwortet der mit dem ARN für die von Ihnen erstellte Ressource.
```
{
"InferenceComponentArn": "arn:aws:sagemaker:us-west-2:111122223333:inference-component/inference-component-name"
}
```
------
#### [ Without inference components ]
**Example create-endpoint-Befehl**
Das folgende Beispiel erstellt einen Endpunkt mit dem Befehl [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
Wenn der Befehl erfolgreich ist, AWS CLI antwortet der mit dem ARN für die von Ihnen erstellte Ressource.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
------
# Aufrufen von Modellen für Echtzeit-Inferenz
Nachdem Sie Amazon SageMaker AI verwendet haben, um ein Modell auf einem Endpunkt bereitzustellen, können Sie mit dem Modell interagieren, indem Sie Inferenzanfragen an das Modell senden. Um eine Inferenzanforderung an ein Modell zu senden, rufen Sie den Endpunkt auf, der es hostet. Sie können Ihre Endgeräte mit Amazon SageMaker Studio AWS SDKs, dem oder dem aufrufen. AWS CLI
## Rufen Sie Ihr Modell mit Amazon SageMaker Studio auf
Nachdem Sie Ihr Modell auf einem Endpunkt bereitgestellt haben, können Sie den Endpunkt über Amazon SageMaker Studio anzeigen und Ihren Endpunkt testen, indem Sie einzelne Inferenzanfragen senden.
**Anmerkung**
SageMaker KI unterstützt nur Endpunkttests in Studio für Echtzeit-Endpunkte.
**Um eine Test-Inferenzanfrage an Ihren Endpunkt zu senden**
1. Starten Sie Amazon SageMaker Studio.
1. Wählen Sie im Navigationsbereich auf der linken Seite **Bereitstellungen** aus.
1. Wählen Sie in der Dropdown-Liste die Option **Endpunkte** aus.
1. Suchen Sie anhand des Namens nach Ihrem Endpunkt und wählen Sie den Namen in der Tabelle aus. Die im Bereich **Endpunkte** aufgeführten Endpunktnamen werden bei der Bereitstellung eines Modells definiert. Der Studio-Arbeitsbereich öffnet die Seite **Endpunkt** in einer neuen Registerkarte.
1. Wählen Sie die Registerkarte **Inferenz testen** aus.
1. Wählen Sie für **Testoptionen** eine der folgenden Optionen aus:
1. Wählen Sie **Beispielanforderung testen** aus, um sofort eine Anforderung an Ihren Endpunkt zu senden. Verwenden Sie den **JSON-Editor**, um Beispieldaten im JSON-Format bereitzustellen, und wählen Sie **Anforderung senden** aus, um die Anforderung an Ihren Endpunkt zu senden. Nach dem Senden Ihrer Anforderung zeigt Studio die Inferenzausgabe auf einer Karte rechts neben dem JSON-Editor an.
1. Wählen Sie **Python-SDK-Beispielcode verwenden** aus, um den Code für das Senden einer Anforderung an den Endpunkt anzuzeigen. Kopieren Sie dann das Codebeispiel aus dem Abschnitt **Beispiel-Inferenzanforderung** und führen Sie den Code in Ihrer Testumgebung aus.
Oben auf der Karte wird die Art der Anfrage angezeigt, die an den Endpunkt gesendet wurde (nur JSON wird akzeptiert). Die Karte enthält die folgenden Felder:
+ **Status** – zeigt einen der folgenden Statustypen an:
+ `Success` – Die Anforderung war erfolgreich.
+ `Failed` – Die Anforderung hat fehlgeschlagen. Unter **Fehlerursache** wird eine Antwort angezeigt.
+ `Pending` – Solange die Inferenzanforderung noch aussteht, zeigt der Status ein rotierendes, kreisförmiges Symbol an.
+ **Ausführungsdauer** – Wie lange der Aufruf gedauert hat (Endzeit minus Startzeit) in Millisekunden.
+ **Anforderungszeit** – Wie viele Minuten sind vergangen, seit die Anfrage gesendet wurde.
+ **Ergebniszeit** – Wie viele Minuten sind vergangen, seit das Ergebnis zurückgegeben wurde.
## Rufen Sie Ihr Modell auf, indem Sie den AWS SDK für Python (Boto3)
Wenn Sie einen Modellendpunkt in Ihrem Anwendungscode aufrufen möchten, können Sie einen der verwenden AWS SDKs, einschließlich der. AWS SDK für Python (Boto3) Um Ihren Endpunkt mit diesem SDK aufzurufen, verwenden Sie eine der folgenden Python-Methoden:
+ `invoke_endpoint` – Sendet eine Inferenzanforderung an einen Modellendpunkt und gibt die Antwort zurück, die das Modell generiert.
Diese Methode gibt die Inferenz-Payload als eine Antwort zurück, nachdem das Modell die Generierung abgeschlossen hat. Weitere Informationen finden Sie in [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) in der *AWS SDK für Python (Boto3) API-Referenz*.
+ `invoke_endpoint_with_response_stream` – Sendet eine Inferenzanforderung an einen Modellendpunkt und streamt die Antwort in inkrementellen Teilen, während das Modell die Inferenz generiert.
Bei dieser Methode empfängt Ihre Anwendung Teile der Antwort, sobald sie verfügbar sind. Weitere Informationen finden Sie in [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) in der *AWS SDK für Python (Boto3) API-Referenz*.
Verwenden Sie diese Methode nur, um Modelle aufzurufen, die Inferenzstreaming unterstützen.
Bevor Sie diese Methoden in Ihrem Anwendungscode verwenden können, müssen Sie einen SageMaker AI Runtime-Client initialisieren und den Namen Ihres Endpunkts angeben. Im folgenden Beispiel werden der Client und der Endpunkt für die restlichen folgenden Beispiele eingerichtet:
```
import boto3
sagemaker_runtime = boto3.client(
"sagemaker-runtime", region_name='aws_region')
endpoint_name='endpoint-name'
```
### Aufrufen, um eine Inferenzantwort zu erhalten
Im folgenden Beispiel wird die `invoke_endpoint` Methode verwendet, um einen Endpunkt aufzurufen mit AWS SDK für Python (Boto3):
```
# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
EndpointName=endpoint_name,
Body=bytes('{"features": ["This is great!"]}', 'utf-8')
)
# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))
```
In diesem Beispiel werden Eingabedaten in dem `Body` Feld bereitgestellt, die SageMaker KI an das Modell weitergibt. Diese Daten müssen dasselbe Format haben, das für das Training verwendet wurde. In dem Beispiel wird die Antwort in der `response`-Variable gespeichert.
Die `response` Variable bietet Zugriff auf den HTTP-Status, den Namen des bereitgestellten Modells und andere Felder. Der folgende Codeausschnitt gibt den HTTP-Statuscode aus:
```
print(response["HTTPStatusCode"])
```
### Aufrufen, um eine Inferenzantwort zu streamen
Wenn Sie ein Modell bereitgestellt haben, das Inferenzstreaming unterstützt, können Sie das Modell aufrufen, um seine Inferenz-Payload als Stream von Teilen zu empfangen. Das Modell liefert diese Teile inkrementell, während das Modell sie generiert. Wenn eine Anwendung einen Inferenzstream empfängt, muss die Anwendung nicht darauf warten, dass das Modell die gesamte Antwortnutzlast generiert. Stattdessen empfängt die Anwendung sofort Teile der Antwort, sobald sie verfügbar sind.
Indem Sie einen Inferenzstream in Ihrer Anwendung verwenden, können Sie Interaktionen erzeugen, bei denen Ihre Benutzer die Inferenz als schnell wahrnehmen, weil sie den ersten Teil sofort erhalten. Sie können Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, virtuelle Assistenten und Musikgeneratoren zu unterstützen. Sie könnten beispielsweise einen Chatbot erstellen, der den von einem großem Sprachmodel (LLM) generierten Text inkrementell anzeigt.
Um einen Inferenzstream abzurufen, können Sie die Methode `invoke_endpoint_with_response_stream` verwenden. Im Antworttext stellt das SDK ein `EventStream` Objekt bereit, das die Inferenz als eine Reihe von `PayloadPart` Objekten wiedergibt.
**Example Inferenzstream**
Das folgende Beispiel ist ein Stream von `PayloadPart` Objekten:
```
{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .
```
In jedem Nutzdatenteil stellt das `Bytes` Feld einen Teil der Inferenzantwort des Modells bereit. Bei diesem Teil kann es sich um einen beliebigen Inhaltstyp handeln, den ein Modell generiert, z. B. Text-, Bild- oder Audiodaten. In diesem Beispiel handelt es sich bei den Teilen um JSON-Objekte, die generierten Text aus einem LLM enthalten.
Normalerweise enthält der Payload-Teil einen diskreten Datenblock aus dem Modell. In diesem Beispiel sind die diskreten Blocks ganze JSON-Objekte. Gelegentlich teilt die Streaming-Antwort die BLocks auf mehrere Payload-Teile auf oder kombiniert mehrere Blocks zu einem Payload-Teil. Das folgende Beispiel zeigt einen Datenblock im JSON-Format, der auf zwei Nutzlastteile aufgeteilt ist:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
Wenn Sie Anwendungscode schreiben, der einen Inferenzstream verarbeitet, sollten Sie Logik einbeziehen, die diese gelegentlichen Aufteilungen und Kombinationen von Daten verarbeitet. Als eine Strategie könnten Sie Code schreiben, der den Inhalt von `Bytes` verkettet, während Ihre Anwendung die Nutzdaten empfängt. Wenn Sie die JSON-Beispieldaten hier verketten, würden Sie die Daten zu einem durch Zeilenumbruch getrennten JSON-Hauptteil kombinieren. Dann könnte Ihr Code den Stream verarbeiten, indem er das gesamte JSON-Objekt in jeder Zeile analysiert.
Das folgende Beispiel zeigt das durch Zeilenumbrüche getrennte JSON, das Sie erstellen würden, wenn Sie den Beispielinhalt von `Bytes` verketten würden:
```
{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .
```
**Example Code zur Verarbeitung eines Inferenz-Streams**
Die folgende Python-Beispielklasse, `SmrInferenceStream`, zeigt, wie Sie einen Inferenzstream verarbeiten können, der Textdaten im JSON-Format sendet:
```
import io
import json
# Example class that processes an inference stream:
class SmrInferenceStream:
def __init__(self, sagemaker_runtime, endpoint_name):
self.sagemaker_runtime = sagemaker_runtime
self.endpoint_name = endpoint_name
# A buffered I/O stream to combine the payload parts:
self.buff = io.BytesIO()
self.read_pos = 0
def stream_inference(self, request_body):
# Gets a streaming inference response
# from the specified model endpoint:
response = self.sagemaker_runtime\
.invoke_endpoint_with_response_stream(
EndpointName=self.endpoint_name,
Body=json.dumps(request_body),
ContentType="application/json"
)
# Gets the EventStream object returned by the SDK:
event_stream = response['Body']
for event in event_stream:
# Passes the contents of each payload part
# to be concatenated:
self._write(event['PayloadPart']['Bytes'])
# Iterates over lines to parse whole JSON objects:
for line in self._readlines():
resp = json.loads(line)
part = resp.get("outputs")[0]
# Returns parts incrementally:
yield part
# Writes to the buffer to concatenate the contents of the parts:
def _write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
# The JSON objects in buffer end with '\n'.
# This method reads lines to yield a series of JSON objects:
def _readlines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
self.read_pos += len(line)
yield line[:-1]
```
In diesem Beispiel wird der Inferenzstream wie folgt verarbeitet:
+ Initialisiert einen SageMaker AI Runtime-Client und legt den Namen eines Modellendpunkts fest. Bevor Sie einen Inferenzstream abrufen können, muss das Modell, das der Endpunkt hostet, Inferenzstreaming unterstützen.
+ In der `stream_inference` Beispielmethode empfängt es einen Anforderungstext und übergibt ihn an die `invoke_endpoint_with_response_stream` Methode des SDK.
+ Iteriert jedes Ereignis im `EventStream` Objekt, das das SDK zurückgibt.
+ Ruft aus jedem Ereignis den Inhalt des `Bytes` Objekts im `PayloadPart` Objekt ab.
+ In der `_write` Beispielmethode wird in einen Puffer geschrieben, um den Inhalt der `Bytes` Objekte zu verketten. Die kombinierten Inhalte bilden einen durch Zeilenumbrüche getrennten JSON-Hauptteil.
+ Verwendet die `_readlines` Beispielmethode, um eine iterierbare Reihe von JSON-Objekten abzurufen.
+ Ruft in jedem JSON-Objekt einen Teil der Inferenz ab.
+ Gibt zusammen mit dem `yield` Ausdruck die Teile inkrementell zurück.
Im folgenden Beispiel wird ein `SmrInferenceStream` Objekt erstellt und verwendet:
```
request_body = {"inputs": ["Large model inference is"],
"parameters": {"max_new_tokens": 100,
"enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
print(part, end='')
```
In diesem Beispiel wird ein Anforderungstext an die `stream_inference` Methode übergeben. Es iteriert über die Antwort, um jedes Stück zu drucken, das der Inferenzstream zurückgibt.
Das Beispiel geht davon aus, dass es sich bei dem Modell am angegebenen Endpunkt um ein LLM handelt, das Text generiert. Die Ausgabe dieses Beispiels ist ein generierter Textkörper, der inkrementell gedruckt wird:
```
a challenging problem in machine learning. The goal is to . . .
```
## Rufen Sie Ihr Modell auf, indem Sie den AWS CLI
Sie können Ihren Modellendpunkt aufrufen, indem Sie Befehle mit der AWS Command Line Interface ()AWS CLI ausführen. Der AWS CLI unterstützt standardmäßige Inferenzanfragen mit dem `invoke-endpoint` Befehl und asynchrone Inferenzanfragen mit dem `invoke-endpoint-async` Befehl.
**Anmerkung**
Das unterstützt AWS CLI keine Streaming-Inferenzanfragen.
Im folgenden Beispiel wird der `invoke-endpoint` Befehl verwendet, um eine Inferenzanforderung an einen Modellendpunkt zu senden:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name endpoint_name \
--body fileb://$file_name \
output_file.txt
```
Geben Sie für den `--endpoint-name`-Parameter den Endpunktnamen an, den Sie bei der Erstellung Ihres Endpunkts angegeben haben. Geben Sie für den `--body` Parameter Eingabedaten an, die SageMaker KI an das Modell weitergibt. Die Daten müssen dasselbe Format haben, das für das Training verwendet wurde. Dieses Beispiel zeigt, wie Sie Binärdaten an Ihren Endpunkt senden.
Weitere Informationen darüber, wann `file://` Over verwendet werden sollte, `fileb://` wenn der Inhalt einer Datei an einen Parameter von übergeben wird AWS CLI, finden Sie unter [Bewährte Methoden für lokale Dateiparameter](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/).
Weitere Informationen und zusätzliche Parameter, die Sie übergeben können, finden Sie in [https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html) in der *AWS CLI -Befehlsreferenz*.
Wenn der `invoke-endpoint` Befehl erfolgreich ist, wird eine Antwort wie die folgende zurückgegeben:
```
{
"ContentType": "; charset=utf-8",
"InvokedProductionVariant": ""
}
```
Wenn der Befehl nicht erfolgreich ist, überprüfen Sie, ob die Eingabe-Payload das richtige Format hat.
Sehen Sie sich die Ausgabe des Aufrufs an, indem Sie die Dateiausgabedatei überprüfen (`output_file.txt` in diesem Beispiel).
```
more output_file.txt
```
## Rufen Sie Ihr Modell mithilfe des AWS SDK für Python auf
### Rufen Sie auf, um eine Inferenzanforderung und -antwort bidirektional zu streamen
Wenn Sie in Ihrem Anwendungscode einen Modellendpunkt aufrufen möchten, der bidirektionales Streaming unterstützt, können Sie das [neue experimentelle SDK für Python](https://github.com/awslabs/aws-sdk-python) verwenden, das bidirektionale Streaming-Funktionen mit HTTP/2-Unterstützung unterstützt. Dieses SDK ermöglicht eine bidirektionale Kommunikation in Echtzeit zwischen Ihrer Client-Anwendung und dem SageMaker Endpunkt, sodass Sie Inferenzanfragen inkrementell senden und gleichzeitig Streaming-Antworten empfangen können, während das Modell sie generiert. Dies ist besonders nützlich für interaktive Anwendungen, bei denen sowohl der Client als auch der Server kontinuierlich Daten über eine persistente Verbindung austauschen müssen.
**Anmerkung**
Das neue experimentelle SDK unterscheidet sich vom standardmäßigen Boto3-SDK und unterstützt persistente bidirektionale Verbindungen für den Datenaustausch. Bei der Verwendung des experimentellen Python-SDK empfehlen wir dringend, sich für alle nicht experimentellen Anwendungsfälle strikt an eine Version des SDK zu binden.
Verwenden Sie die Methode, um Ihren Endpunkt mit bidirektionalem Streaming aufzurufen. `invoke_endpoint_with_bidirectional_stream` Diese Methode stellt eine persistente Verbindung her, die es Ihnen ermöglicht, mehrere Nutzdatenblöcke in Ihr Modell zu streamen und gleichzeitig Antworten in Echtzeit zu erhalten, während das Modell Daten verarbeitet. Die Verbindung bleibt geöffnet, bis Sie den Eingabestream explizit schließen oder der Endpunkt die Verbindung schließt, was eine Verbindungszeit von bis zu 30 Minuten unterstützt.
### Voraussetzungen
Bevor Sie bidirektionales Streaming in Ihrem Anwendungscode verwenden können, müssen Sie:
1. Installieren Sie das experimentelle SageMaker Runtime HTTP/2-SDK
1. Richten Sie AWS Anmeldeinformationen für Ihren SageMaker Runtime-Client ein
1. Stellen Sie ein Modell bereit, das bidirektionales Streaming zu einem SageMaker Endpunkt unterstützt
### Richten Sie den bidirektionalen Streaming-Client ein
Das folgende Beispiel zeigt, wie die erforderlichen Komponenten für bidirektionales Streaming initialisiert werden:
```
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
# Configuration
AWS_REGION = "us-west-2"
BIDI_ENDPOINT = f"https://runtime.sagemaker.{AWS_REGION}.amazonaws.com:8443"
ENDPOINT_NAME = "your-endpoint-name"
# Initialize the client configuration
config = Config(
endpoint_uri=BIDI_ENDPOINT,
region=AWS_REGION,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
# Create the SageMaker Runtime HTTP/2 client
client = SageMakerRuntimeHTTP2Client(config=config)
```
### Vollständiger bidirektionaler Streaming-Client
Das folgende Beispiel zeigt, wie Sie einen bidirektionalen Streaming-Client erstellen, der mehrere Textnutzlasten an einen SageMaker Endpunkt sendet und Antworten in Echtzeit verarbeitet:
```
import asyncio
import logging
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from sagemaker_runtime_http2.models import (
InvokeEndpointWithBidirectionalStreamInput,
RequestStreamEventPayloadPart,
RequestPayloadPart
)
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class SageMakerBidirectionalClient:
def __init__(self, endpoint_name, region="us-west-2"):
self.endpoint_name = endpoint_name
self.region = region
self.client = None
self.stream = None
self.response_task = None
self.is_active = False
def _initialize_client(self):
bidi_endpoint = f"runtime.sagemaker.{self.region}.amazonaws.com:8443"
config = Config(
endpoint_uri=bidi_endpoint,
region=self.region,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
self.client = SageMakerRuntimeHTTP2Client(config=config)
async def start_session(self):
"""Establish a bidirectional streaming connection with the endpoint."""
if not self.client:
self._initialize_client()
logger.info(f"Starting session with endpoint: {self.endpoint_name}")
self.stream = await self.client.invoke_endpoint_with_bidirectional_stream(
InvokeEndpointWithBidirectionalStreamInput(endpoint_name=self.endpoint_name)
)
self.is_active = True
# Start processing responses concurrently
self.response_task = asyncio.create_task(self._process_responses())
async def send_message(self, message):
"""Send a single message to the endpoint."""
if not self.is_active:
raise RuntimeError("Session not active. Call start_session() first.")
logger.info(f"Sending message: {message}")
payload = RequestPayloadPart(bytes_=message.encode('utf-8'))
event = RequestStreamEventPayloadPart(value=payload)
await self.stream.input_stream.send(event)
async def send_multiple_messages(self, messages, delay=1.0):
"""Send multiple messages with a delay between each."""
for message in messages:
await self.send_message(message)
await asyncio.sleep(delay)
async def end_session(self):
"""Close the bidirectional streaming connection."""
if not self.is_active:
return
await self.stream.input_stream.close()
self.is_active = False
logger.info("Stream closed")
# Cancel the response processing task
if self.response_task and not self.response_task.done():
self.response_task.cancel()
async def _process_responses(self):
"""Process incoming responses from the endpoint."""
try:
output = await self.stream.await_output()
output_stream = output[1]
while self.is_active:
result = await output_stream.receive()
if result is None:
logger.info("No more responses")
break
if result.value and result.value.bytes_:
response_data = result.value.bytes_.decode('utf-8')
logger.info(f"Received: {response_data}")
except Exception as e:
logger.error(f"Error processing responses: {e}")
# Example usage
async def run_bidirectional_client():
client = SageMakerBidirectionalClient(endpoint_name="your-endpoint-name")
try:
# Start the session
await client.start_session()
# Send multiple messages
messages = [
"I need help with",
"my account balance",
"I can help with that",
"and recent charges"
]
await client.send_multiple_messages(messages)
# Wait for responses to be processed
await asyncio.sleep(2)
# End the session
await client.end_session()
logger.info("Session ended successfully")
except Exception as e:
logger.error(f"Client error: {e}")
await client.end_session()
if __name__ == "__main__":
asyncio.run(run_bidirectional_client())
```
Der Client initialisiert den SageMaker Runtime-HTTP/2-Client mit dem regionalen Endpunkt-URI auf Port 8443, der für bidirektionale Streaming-Verbindungen erforderlich ist. Die `session()` Methode start\$1 ruft `invoke_endpoint_with_bidirectional_stream()` auf, um die persistente Verbindung herzustellen, und erstellt eine asynchrone Aufgabe, um eingehende Antworten gleichzeitig zu verarbeiten.
Die `send_event()` Methode verpackt Nutzdaten in die entsprechenden Anforderungsobjekte und sendet sie über den Eingabestream, während die `_process_responses()` Methode kontinuierlich auf Antworten vom Endpunkt wartet und diese verarbeitet, sobald sie eintreffen. Dieser bidirektionale Ansatz ermöglicht eine Interaktion in Echtzeit, bei der sowohl das Senden von Anfragen als auch das Empfangen von Antworten gleichzeitig über dieselbe Verbindung erfolgen.
# Endpunkte
Nachdem Sie Ihr Modell auf einem Endpunkt bereitgestellt haben, möchten Sie möglicherweise den Endpunkt anzeigen und verwalten. Mit SageMaker AI können Sie den Status und die Details Ihres Endpunkts einsehen, Metriken und Protokolle überprüfen, um die Leistung Ihres Endpunkts zu überwachen, die auf Ihrem Endpunkt bereitgestellten Modelle aktualisieren und vieles mehr.
In den folgenden Abschnitten wird gezeigt, wie Sie Endpunkte innerhalb von Amazon SageMaker Studio oder innerhalb der AWS-Managementkonsole verwalten können.
Auf der folgenden Seite wird beschrieben, wie Sie Ihre Endpunkte mithilfe der Konsole von Amazon SageMaker AI oder mit SageMaker Studio interaktiv anzeigen und ändern können.
**Topics**
+ [Anzeigen von Endpunktdetails in SageMaker Studio](manage-endpoints-studio.md)
+ [Sehen Sie sich die Endpunktdetails in der SageMaker-AI-Konsole an.](manage-endpoints-console.md)
# Anzeigen von Endpunktdetails in SageMaker Studio
In Amazon SageMaker Studio können Sie Ihre Hosting-Endpunkte von SageMaker AI anzeigen und verwalten. Weitere Informationen zu Studio finden Sie unter [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html).
Gehen Sie wie folgt vor, um die Liste Ihrer Endpunkte in SageMaker Studio zu finden:
1. Öffnen Sie die Studio-Anwendung.
1. Klicken Sie im linken Navigationsbereich auf **Bereitstellungen**.
1. Wählen Sie **Endpunkte** im Dropdown-Menü aus.
Die Seite **Endpunkte** wird geöffnet, auf der alle Ihre Hosting-Endpunkte von SageMaker AI aufgelistet sind. Auf dieser Seite können Sie die Endpunkte und ihren **Status** sehen. Sie können auch einen neuen Endpunkt erstellen oder einen vorhandenen Endpunkt bearbeiten oder löschen.
Um die Details für einen bestimmten Endpunkt anzuzeigen, wählen Sie einen Endpunkt aus der Liste aus. Auf der Detailseite des Endpunkts erhalten Sie eine Übersicht wie im folgenden Screenshot.
![\[Screenshot der Hauptseite eines Endpunkts mit einer Zusammenfassung der Endpunktdetails in Studio.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-endpoint-details-page.png)
Jede Endpunktdetailseite enthält die folgenden Registerkarten mit Informationen:
# Varianten (oder Modelle) anzeigen
Auf der Registerkarte **Varianten** (oder **Modelle**, wenn auf Ihrem Endpunkt mehrere Modelle bereitgestellt wurden) wird die Liste der [Modellvarianten](https://docs.aws.amazon.com/sagemaker/latest/dg/model-ab-testing.html) oder Modelle angezeigt, die derzeit auf Ihrem Endpunkt bereitgestellt werden. Der folgende Screenshot zeigt Ihnen, wie die Abschnitte „Übersicht“ und **Modelle** für einen Endpunkt mit mehreren bereitgestellten Modellen aussehen.
![\[Screenshot der Hauptseite eines Endpunkts, auf der mehrere bereitgestellte Modelle angezeigt werden\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-goldfinch-multi-model-endpoint.png)
Sie können Einstellungen für jede Variante oder jedes Modell hinzufügen oder ändern. Sie können auch eine Variante auswählen und eine Standardrichtlinie zum Auto Scaling aktivieren, die Sie später auf der Registerkarte **Auto Scaling** bearbeiten können.
# Anzeigen der Einstellungen
Auf der Registerkarte **Einstellungen** können Sie die dem Endpunkt zugeordnete AWS-IAM-Rolle, den für die Verschlüsselung verwendeten AWS KMS-Schlüssel (falls zutreffend), den Namen Ihrer VPC und die Netzwerkisolationseinstellungen einsehen.
# Testinferenz
Auf der Registerkarte **Testinferenz** können Sie eine Testinferenzanforderung an ein bereitgestelltes Modell senden. Dies ist nützlich, wenn Sie überprüfen möchten, ob Ihr Endpunkt wie erwartet auf Anfragen reagiert.
Führen Sie für die Testinferenz folgende Schritte aus:
1. Wählen Sie auf der Registerkarte **Testinferenz** des Modells eine der folgenden Optionen aus:
1. Wählen Sie **Anforderungstext eingeben** aus, wenn Sie den Endpunkt testen und eine Antwort über die Studio-Oberfläche erhalten möchten.
1. Wählen Sie **Beispielcode kopieren (Python)** aus, wenn Sie ein AWS SDK für Python (Boto3)-Beispiel kopieren möchten, mit dem Sie Ihren Endpunkt aus einer lokalen Umgebung aufrufen und programmgesteuert eine Antwort erhalten können.
1. Wählen Sie unter **Modell** das Modell aus, das Sie auf dem Endpunkt testen möchten.
1. Wenn Sie sich für die Testmethode der Studio-Benutzeroberfläche entschieden haben, können Sie auch den gewünschten **Inhaltstyp** für die Antwort aus dem Dropdown-Menü auswählen.
Nachdem Sie Ihre Anforderung konfiguriert haben, können Sie entweder **Anfrage senden** (um eine Antwort über die Studio-Oberfläche zu erhalten) oder **Kopieren** wählen, um das Python-Beispiel zu kopieren.
Wenn Sie eine Antwort über die Studio-Oberfläche erhalten, sieht sie wie im folgenden Screenshot aus.
![\[Screenshot einer erfolgreichen Inferenztestanforderung auf einem Endpunkt in Studio\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/endpoint-test-inference.png)
# Auto Scaling
Auf der Registerkarte **Auto Scaling** können Sie alle Richtlinien für die automatische Skalierung anzeigen, die für die auf Ihrem Endpunkt gehosteten Modelle konfiguriert sind. Der folgende Screenshot zeigt die Registerkarte **Auto Scaling**.
![\[Screenshot der Registerkarte Auto Scaling, die eine aktive Richtlinie zeigt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/inference/studio-endpoint-autoscaling.png)
Sie können **Auto Scaling bearbeiten** auswählen, um eine der Richtlinien zu ändern und die standardmäßige Auto-Scaling-Richtlinie zu aktivieren oder zu deaktivieren.
Weitere Informationen zum Auto Scaling für Echtzeit-Endpunkte finden Sie unter [Automatisches Skalieren der Modelle von Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html). Wenn Sie sich nicht sicher sind, wie Sie eine Auto-Scaling-Richtlinie für Ihren Endpunkt konfigurieren sollen, können Sie einen [Inference-Recommender-Job mit Auto-Scaling-Empfehlungen](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-autoscaling.html) verwenden, um Empfehlungen zur Auto-Scaling-Richtlinie zu erhalten.
# Sehen Sie sich die Endpunktdetails in der SageMaker-AI-Konsole an.
Führen Sie die folgenden Schritte aus, um Ihre Endpunkte in der SageMaker AI-Konsole anzuzeigen:
1. Rufen Sie die SageMaker-AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) auf.
1. Wählen Sie im linken Navigationsbereich ** services** aus.
1. Wählen Sie in der Dropdown-Liste **Endpunkte**.
1. Wählen Sie auf der Seite **Endpunkte** Ihren Endpunkt aus.
Die Seite mit den Endpunktdetails sollte sich öffnen und Ihnen eine Zusammenfassung Ihres Endpunkts und der für Ihren Endpunkt gesammelten Metriken anzeigen.
In den folgenden Abschnitten werden die Registerkarten auf der Seite „Endpunktdetails“ beschrieben.
# Überwachen von Endpunkten
Nachdem Sie einen Hosting-Endpunkt SageMaker AI erstellt haben, können Sie Ihren Endpunkt mit Amazon CloudWatch überwachen, das Rohdaten sammelt und sie in lesbare Metriken in nahezu Echtzeit verarbeitet. Mithilfe dieser Metriken können Sie auf historische Informationen zugreifen und sich einen besseren Überblick über die Leistung Ihres Endpunkts verschaffen. Weitere Informationen finden Sie im *[Amazon CloudWatch-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
Auf der Seite mit den Endpunktdetails auf der Registerkarte **Überwachung** können Sie CloudWatch-Metrikdaten einsehen, die von Ihrem Endpunkt erfasst wurden.
Die Registerkarte **Überwachen** enthält die folgenden Abschnitte:
+ **Betriebsmetriken**: Sehen Sie sich Metriken an, die die Auslastung der Ressourcen Ihres Endpunkts verfolgen, z. B. CPU-Auslastung und Speicherauslastung.
+ **Aufrufmetriken**: Sehen Sie sich Metriken an, die die Anzahl, den Zustand und den Status von `InvokeEndpoint` Anfragen verfolgen, die an Ihren Endpunkt eingehen, z. B. Aufrufmodellfehler und Modelllatenz.
+ **Integritätskennzahlen**: Sehen Sie sich Metriken an, die den allgemeinen Zustand Ihres Endpunkts verfolgen, z. B. Aufruffehler und Benachrichtigungsfehler.
Eine ausführliche Beschreibung der einzelnen Metriken finden Sie unter [Überwachen von SageMaker AI mit CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
Der folgende Screenshot zeigt den Abschnitt **Betriebsmetriken** für einen serverlosen Endpunkt.
![\[Screenshot der Metrikdiagramme im Abschnitt mit den Betriebsmetriken auf der Seite mit den Endpunktdetails.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hosting-operational-metrics.png)
Sie können den **Zeitraum** und die **Statistik**, die Sie für die Kennzahlen in einem bestimmten Abschnitt verfolgen möchten, sowie den Zeitraum, für den Sie die Metrikdaten anzeigen möchten, anpassen. Sie können der Ansicht auch Metrik-Widgets für jeden Abschnitt hinzufügen und daraus entfernen, indem Sie **Widget hinzufügen** wählen. Im Dialogfeld **Widget hinzufügen** können Sie die Metriken, die Sie sehen möchten, auswählen und deren Auswahl aufheben.
Welche Metriken verfügbar sind, hängt möglicherweise von Ihrem Endpunkttyp ab. Beispielsweise verfügen serverlose Endgeräte über einige Messwerte, die für Echtzeit-Endpunkte nicht verfügbar sind. Spezifischere Überwachen von -Metriken nach Endpunkttyp finden Sie auf den folgenden Seiten:
+ [Überwachen Sie einen serverlosen Endpunkt](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints-monitoring.html)
+ [Überwachen Sie einen asynchronen Endpunkt](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-monitor.html)
+ [CW-Metriken für die Bereitstellung von Endpunkten nach mehreren Modellen](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoint-cloudwatch-metrics.html)
+ [Protokolle und Metriken der Inferenz-Pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
# Einstellungen
Sie können die Registerkarte **Einstellungen** wählen, um zusätzliche Informationen zu Ihrem Endpunkt anzuzeigen, z. B. die Datenerfassungseinstellungen, die Endpunktkonfiguration und Tags.
# Erstellen und Anzeigen von Alarmen
Unter der Registerkarte **Alarme** auf der Seite mit den Endpunktdetails können Sie einfache statische Alarme für Metriken mit Schwellenwerten anzeigen und erstellen, in denen Sie einen Schwellenwert für eine Metrik angeben. Wenn die Metrik den Schwellenwert überschreitet, geht der Alarm in den `ALARM` Status über. Weitere Informationen zu CloudWatch-Alarmen erhalten Sie unter [Verwendung von Amazon-CloudWatch-Alarmen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html).
Im Abschnitt **Endpunktzusammenfassung** können Sie das Feld **Alarme aufrufen**, in dem Sie erfahren, wie viele Alarme derzeit auf Ihrem Endpunkt aktiv sind.
Um zu sehen, welche Alarme sich im `ALARM` Status befinden, wählen Sie die Registerkarte **Alarme**. Auf der Registerkarte **Alarme** finden Sie eine vollständige Liste Ihrer Endpunktalarme sowie Einzelheiten zu deren Status und Bedingungen. Der folgende Screenshot zeigt eine Liste der Alarme in diesem Abschnitt, die für einen Endpunkt konfiguriert wurden.
![\[Screenshot der Registerkarte Alarme auf der Seite mit den Endpunktdetails, auf der eine Liste der CloudWatch-Alarme angezeigt wird.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hosting-alarms-tab.png)
Der Status eines Alarms kann `In alarm`, `OK` oder `Insufficient data` sein, wenn nicht genügend Metrikdaten gesammelt werden.
Gehen Sie wie folgt vor, um einen neuen Alarm für Ihren Endpunkt zu erstellen:
1. Wählen Sie auf der Registerkarte **Alarme** die Option **Alarm erstellen**.
1. Die Seite **Alarm erstellen** wird geöffnet. Geben Sie für **Alarmname** einen Namen für den Alarm ein.
1. (Optional) Geben Sie eine Beschreibung für den Alarm ein.
1. Wählen Sie für **Metric** die CloudWatch-Metriken, die der Alarm verfolgen soll.
1. Wählen Sie als **Variantenname** die Endpunktmodellvariante aus, die Sie überwachen möchten.
1. Wählen Sie unter **Statistik** eine der verfügbaren Statistiken für die von Ihnen ausgewählte Metrik aus.
1. Wählen Sie unter **Zeitraum** den Zeitraum aus, der für die Berechnung der einzelnen statistischen Werte verwendet werden soll. Wenn Sie beispielsweise die Statistik Durchschnitt und einen Zeitraum von 5 Minuten wählen, entspricht jeder vom Alarm überwachte Datenpunkt dem Durchschnitt der Datenpunkte der Metrik in 5-Minuten-Intervallen.
1. Geben Sie für **Bewertungszeiträume** die Anzahl der Datenpunkte ein, die der Alarm bei der Bewertung, ob der Alarmstatus aktiviert werden soll oder nicht, berücksichtigen soll.
1. Wählen Sie unter **Bedingung** die Bedingung aus, die Sie für Ihren Alarmschwellenwert verwenden möchten.
1. Geben Sie unter **Schwellenwert** den gewünschten Wert für Ihren Schwellenwert ein.
1. (Optional) Für **Benachrichtigung** können Sie **Benachrichtigung hinzufügen** wählen, um ein Amazon SNS-Thema zu erstellen oder anzugeben, das eine Benachrichtigung erhält, wenn sich Ihr Alarmstatus ändert.
1. Wählen Sie **Alarm erstellen** aus.
Nachdem Sie Ihren Alarm erstellt haben, können Sie jederzeit zur Registerkarte **Alarme** zurückkehren, um seinen Status einzusehen. In diesem Bereich können Sie auch den Alarm auswählen und ihn entweder **bearbeiten** oder **löschen**.
# 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.
------
# Automatische Skalierung von Amazon SageMaker AI-Modellen
Amazon SageMaker AI unterstützt die automatische Skalierung (Auto Scaling) für Ihre gehosteten Modelle. *Auto Scaling* passt dynamisch die Anzahl der Instances an, die für ein Modell als Reaktion auf Workload-Änderungen zur Verfügung gestellt werden. Wenn die Arbeitslast steigt, bringt die automatische Skalierung mehr Instances online. Wenn die Arbeitslast sinkt, werden durch die automatische Skalierung unnötige Instances entfernt, so dass Sie nicht für bereitgestellte Instances zahlen, die Sie nicht nutzen.
**Topics**
+ [Überblick über Auto-Scaling-Richtlinien](endpoint-auto-scaling-policy.md)
+ [Voraussetzungen für Auto Scaling](endpoint-auto-scaling-prerequisites.md)
+ [Konfigurieren Sie Auto Scaling für Modelle über die Konsole](endpoint-auto-scaling-add-console.md)
+ [Registrieren eines Modells](endpoint-auto-scaling-add-policy.md)
+ [Definieren einer Skalierungsrichtlinie](endpoint-auto-scaling-add-code-define.md)
+ [Anwenden einer Skalierungsrichtlinie](endpoint-auto-scaling-add-code-apply.md)
+ [Anweisungen zum Bearbeiten einer Skalierungsrichtlinie](endpoint-auto-scaling-edit.md)
+ [Vorübergehendes Deaktivieren von Skalierungsrichtlinien](endpoint-auto-scaling-suspend-scaling-activities.md)
+ [Löschen einer Skalierungsrichtlinie](endpoint-auto-scaling-delete.md)
+ [Überprüfen des Status einer Skalierungsaktivität durch Beschreibung der Skalierungsaktivitäten](endpoint-scaling-query-history.md)
+ [Skalieren eines Endpunkts auf null Instances](endpoint-auto-scaling-zero-instances.md)
+ [Lasttest Ihrer Auto -Scaling-Konfiguration](endpoint-scaling-loadtest.md)
+ [Wird verwendet CloudFormation , um eine Skalierungsrichtlinie zu erstellen](endpoint-scaling-cloudformation.md)
+ [Aktualisieren von Endpunkten, für die das Auto Scaling verwendet wird](endpoint-scaling-update.md)
+ [Löschen von Endpunkten, die für das Auto Scaling konfiguriert wurden](endpoint-delete-with-scaling.md)
# Überblick über Auto-Scaling-Richtlinien
Um Auto Scaling zu verwenden, definieren Sie eine Skalierungsrichtlinie, die die Anzahl der Instances für Ihre Produktionsvariante als Reaktion auf die tatsächlichen Workloads erhöht oder verringert.
Für die automatische Skalierung bei Veränderungen der Workload haben Sie zwei Optionen: Zielverfolgungs-Skalierungsrichtlinien oder Richtlinien zur schrittweisen Skalierung.
In den meisten Fällen empfehlen wir die Verwendung von Zielverfolgungs-Skalierungsrichtlinien. Bei der Zielverfolgung wählen Sie eine CloudWatch Amazon-Metrik und einen Zielwert aus. Auto Scaling erstellt und verwaltet die CloudWatch Alarme für die Skalierungsrichtlinie und berechnet die Skalierungsanpassung auf der Grundlage der Metrik und des Zielwerts. Durch die Richtlinie werden so viele Instances wie erforderlich hinzugefügt und entfernt, damit die Metrik auf oder nahe am Zielwert gehalten wird. Hierbei kann z. B. eine Skalierungsrichtlinie, die die vorab definierte `InvocationsPerInstance`-Kennzahl mit einem Zielwert von 70 verwendet, `InvocationsPerInstance` auf oder fast auf 70 halten. Weitere Informationen finden Sie in den [Skalierungsrichtlinien für die Ziel-Nachverfolgung](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) im *Benutzerhandbuch für Application Auto Scaling*.
Sie können die schrittweise Skalierung verwenden, wenn Sie eine erweiterte Konfiguration benötigen, z. B. angeben, wie viele Instances unter welchen Bedingungen bereitgestellt werden sollen. Die schrittweise Skalierung ist beispielsweise dann erforderlich, wenn ein Endpunkt in der Lage sein soll, von null aktiven Instances aus aufzuskalieren. Einen Überblick über die Richtlinien zur schrittweisen Skalierung und ihre Funktionsweise finden Sie unter [Richtlinien zur schrittweisen Skalierung](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) im *Benutzerhandbuch zum Auto Scaling von Anwendungen*.
Zum Erstellen einer Skalierungsrichtlinie für die Ziel-Nachverfolgung geben Sie Folgendes an:
+ **Metrik** — Die zu verfolgende CloudWatch Metrik, z. B. die durchschnittliche Anzahl von Aufrufen pro Instance.
+ **Zielwert** – der Zielwert für die Metrik, z. B. 70 Aufrufe pro Instance pro Minute
Sie können Skalierungsrichtlinien zur Zielverfolgung mit vordefinierten oder benutzerdefinierten Metriken erstellen. Eine vordefinierte Metrik ist in einer Aufzählung definiert, sodass Sie sie im Code namentlich angeben oder in der SageMaker AI-Konsole verwenden können. Alternativ können Sie entweder die AWS CLI oder die API zum Auto Scaling von Anwendungen verwenden, um eine Skalierungsrichtlinie für die Zielnachverfolgung anzuwenden, die auf einer vor- oder benutzerdefinierten Metrik basiert.
Beachten Sie, dass den Skalierungsaktivitäten Ruhephasen liegen, um schnelle Kapazitätsschwankungen zu vermeiden. Sie können die Ruhephasen für Ihre Richtlinie optional konfigurieren.
Weitere Informationen zu den Schlüsselkonzepten des Auto Scaling finden Sie im folgenden Abschnitt.
## Zeitplanbasierte Skalierung
Sie können auch geplante Aktionen erstellen, um Skalierungsaktivitäten zu bestimmten Zeitpunkten durchzuführen. Sie können geplante Aktionen erstellen, die nur einmal oder nach einem wiederkehrenden Zeitplan skaliert werden. Nachdem eine geplante Aktion ausgeführt wurde, kann Ihre Skalierungsrichtlinie weiterhin Entscheidungen darüber treffen, ob eine dynamische Skalierung erfolgen soll, wenn sich die Workload ändert. Die geplante Skalierung kann nur über die AWS CLI oder die Application Auto Scaling API verwaltet werden. Weitere Informationen finden Sie unter [Geplante Skalierung](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) im *Benutzerhandbuch für Application Auto Scaling*.
## Mindest- und Höchstwerte für die Skalierung
Bei der Konfiguration von Auto Scaling müssen Sie Ihre Skalierungsgrenzen angeben, bevor Sie eine Skalierungsrichtlinie erstellen. Sie legen Grenzwerte für die Mindest- und die Höchstwerte separat fest.
Der Mindestwert muss mindestens 1 betragen und gleich oder kleiner sein als der Wert, der als Höchstwert angegeben ist.
Der Höchstwert muss gleich oder größer als der für den Minimalwert angegebene Wert sein. SageMaker AI Auto Scaling erzwingt kein Limit für diesen Wert.
Um die Skalierungsgrenzen zu bestimmen, die Sie für einen typischen Datenverkehr benötigen, testen Sie Ihre Auto-Scaling-Konfiguration mit der zu erwartenden Rate des Datenverkehrs für Ihr Modell.
Wenn der Traffic einer Variante Null wird, skaliert SageMaker KI automatisch auf die angegebene Mindestanzahl von Instanzen. In diesem Fall gibt SageMaker KI Metriken mit einem Wert von Null aus.
Es gibt drei Optionen für die Angabe der minimalen und maximalen Kapazität:
1. Verwenden Sie die Konsole, um die Einstellungen für **Minimale Instance-Anzahl** und **Maximale Instance-Anzahl** zu aktualisieren.
1. Verwenden Sie die `--max-capacity` Optionen AWS CLI und include the `--min-capacity` und, wenn Sie den [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)Befehl ausführen.
1. Rufen Sie die [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API auf und geben Sie die `MaxCapacity` Parameter `MinCapacity` und an.
**Tipp**
Sie können manuell aufskalieren, indem Sie den Mindestwert erhöhen, oder manuell abskalieren, indem Sie den Höchstwert verringern.
## Ruhephase
Eine *Ruhephase* wird verwendet, um vor einer Überskalierung zu schützen, wenn Ihr Modell abskaliert (die Kapazität reduziert) oder aufskaliert (die Kapazität erhöht). Dabei werden nachfolgende Skalierungsaktivitäten bis zum Ablauf der Phase verlangsamt. Auf diese Weise wird die Löschung von Instances für Abskalieranfragen blockiert und die Erstellung von Instances für Aufskalieranfragen wird begrenzt. Weitere Informationen finden Sie unter [Definieren von Ruhephasen](https://docs.aws.amazon.com/autoscaling/application/userguide/target-tracking-scaling-policy-overview.html#target-tracking-cooldown) im *Benutzerhandbuch zum Auto Scaling von Anwendungen*.
Sie können die Ruhephase in Ihrer Skalierungsrichtlinie konfigurieren.
Wenn Sie keine Ruhephase zum Abskalieren bzw. Aufskalieren festlegen, verwendet die Skalierungsrichtlinie für jede Aktivität den Standardwert von 300 Sekunden.
Werden Instances zu schnell hinzugefügt oder entfernt, während Sie Ihre Skalierungskonfiguration testen, dann denken Sie daran, diesen Wert zu erhöhen. Sie können dieses Verhalten beobachten, wenn der Datenverkehr in Ihrem Modell zu viele Spitzen aufweist, oder wenn Sie mehrere Skalierungsrichtlinien für eine Variante festgelegt haben.
Wenn Instances nicht schnell genug hinzugefügt werden, um auf den erhöhten Datenverkehr zu antworten, dann sollten Sie diesen Wert verringern.
## Zugehörige Ressourcen
Weitere Informationen zum Konfigurieren des Auto Scaling finden Sie in den folgenden Ressourcen:
+ Abschnitt [application-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) in der *AWS CLI -Befehlsreferenz*
+ [API-Referenz zu Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/APIReference/)
+ [Benutzerhandbuch zum Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/)
**Anmerkung**
SageMaker KI hat kürzlich neue Inferenzfunktionen eingeführt, die auf Echtzeit-Inferenzendpunkten basieren. Sie erstellen einen SageMaker KI-Endpunkt mit einer Endpunktkonfiguration, die den Instanztyp und die anfängliche Anzahl der Instanzen für den Endpunkt definiert. Erstellen Sie anschließend eine Inferenzkomponente, bei der es sich um ein SageMaker KI-Hosting-Objekt handelt, mit dem Sie ein Modell auf einem Endpunkt bereitstellen können. Informationen zur Skalierung von Inferenzkomponenten finden Sie im Blog unter [SageMaker KI fügt neue Inferenzfunktionen hinzu, um die Kosten und die Latenz](https://aws.amazon.com/blogs/aws/amazon-sagemaker-adds-new-inference-capabilities-to-help-reduce-foundation-model-deployment-costs-and-latency/) [von Basismodellen zu reduzieren und die Kosten für die Modellbereitstellung mithilfe der neuesten SageMaker KI-Funktionen um durchschnittlich 50%](https://aws.amazon.com/blogs/machine-learning/reduce-model-deployment-costs-by-50-on-average-using-sagemakers-latest-features/) zu senken. AWS
# Voraussetzungen für Auto Scaling
Bevor Sie Auto Scaling verwenden können, müssen Sie bereits einen Amazon SageMaker AI-Modellendpunkt erstellt haben. Sie können mehrere Modellversionen für denselben Endpunkt haben. Jedes Modell wird als [Produktionsvariante (Modellvariante)](model-ab-testing.md) bezeichnet. Weitere Informationen zur Bereitstellung eines Modellendpunkts finden Sie unter [Stellen Sie das Modell für SageMaker AI Hosting Services bereit](ex1-model-deployment.md#ex1-deploy-model).
Um Auto Scaling für ein Modell zu aktivieren, können Sie die SageMaker AI-Konsole, das AWS Command Line Interface (AWS CLI) oder ein AWS SDK über die Application Auto Scaling API verwenden.
+ Wenn Sie zum ersten Mal die Skalierung für ein Modell konfigurieren, empfehlen wir Ihnen [Konfigurieren Sie Auto Scaling für Modelle über die Konsole](endpoint-auto-scaling-add-console.md).
+ Wenn Sie die AWS CLI oder die Application Auto Scaling Scaling-API verwenden, besteht der Ablauf darin, das Modell als skalierbares Ziel zu registrieren, die Skalierungsrichtlinie zu definieren und sie dann anzuwenden. Wählen Sie auf der SageMaker AI-Konsole im Navigationsbereich unter **Inferenz** die Option **Endpoints** aus. Suchen Sie den Endpunktnamen Ihres Modells und wählen Sie ihn aus, um den Variantennamen zu finden. Sie müssen sowohl den Endpunktnamen als auch den Variantennamen angeben, um Auto Scaling für ein Modell zu aktivieren.
Auto Scaling wird durch eine Kombination aus Amazon SageMaker AI CloudWatch, Amazon und Application Auto Scaling ermöglicht APIs. Informationen zu den erforderlichen Mindestberechtigungen finden Sie unter [Beispiele für identitätsbasierte Richtlinien für Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/security_iam_id-based-policy-examples.html) im *Benutzerhandbuch zu Application Auto Scaling*.
Die `SagemakerFullAccessPolicy` IAM-Richtlinie beinhaltet alle zur Durchführung von Auto Scaling erforderlichen IAM-Berechtigungen. Weitere Informationen zu SageMaker KI-IAM-Berechtigungen finden Sie unter[Wie verwendet man SageMaker AI-Ausführungsrollen](sagemaker-roles.md).
Wenn Sie Ihre eigene Berechtigungsrichtlinie verwenden, müssen Sie die folgenden Berechtigungen hinzufügen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/sagemaker.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint",
"Condition": {
"StringLike": { "iam:AWSServiceName": "sagemaker.application-autoscaling.amazonaws.com" }
}
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricAlarm",
"cloudwatch:DescribeAlarms",
"cloudwatch:DeleteAlarms"
],
"Resource": "*"
}
]
}
```
------
## Servicegebundene Rolle
Auto Scaling verwendet die serviceverknüpfte Rolle `AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint`. Diese Service-verknüpfte Rolle gewährt Application Auto Scaling die Berechtigung zum Beschreiben der Alarme für die Richtlinien, zum Überwachen der aktuellen Kapazitätsstufen und zum Skalieren der Zielressource. Diese Rolle wird automatisch für Sie erstellt. Damit die automatische Rollenerstellung erfolgreich ist, müssen Sie über die Berechtigung für die Aktion `iam:CreateServiceLinkedRole` verfügen. Weitere Informationen finden Sie unter [Serviceverknüpfte Rollen](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) im *Application Auto Scaling-Benutzerhandbuch*.
# Konfigurieren Sie Auto Scaling für Modelle über die Konsole
**So konfigurieren Sie Auto Scaling für ein Modell (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 im Navigationsbereich **Inferenz** und anschließend **Endpunkte** aus.
1. Wählen Sie Ihren Endpunkt und dann für **Endpunktlaufzeiteinstellungen** die Variante aus.
1. Wählen Sie **Configure auto scaling (Auto Scaling konfigurieren)** aus.
1. Gehen Sie auf der Seite **Auto Scaling von Varianten konfigurieren** unter **Varianten-Auto Scaling** wie folgt vor:
1. Geben Sie für **Minimale Instance-Anzahl** die Mindestzahl an Instances ein, die die Skalierungsrichtlinie beibehalten soll. Es ist mindestens eine Instance erforderlich.
1. Geben Sie für **Maximale Instance-Anzahl** die Höchstzahl an Instances ein, die die Skalierungsrichtlinie beibehalten soll.
1. Gehen Sie unter **Integrierte Skalierungsrichtlinie** wie folgt vor:
1. Für die **Zielmetrik** ist `SageMakerVariantInvocationsPerInstance` automatisch ausgewählt und kann nicht geändert werden.
1. Geben Sie für den **Zielwert** die durchschnittliche Anzahl der Aufrufe pro Instance pro Minute für das Modell ein. Um diesen Wert festzulegen, befolgen Sie die Richtlinien auf [Lasttest](endpoint-scaling-loadtest.md).
1. (Optional) Geben Sie für **Cooldown für Herunterskalieren (Sekunden)** und **Cooldown für Hochskalieren (Sekunden)** die Zeit für jede Ruhephase in Sekunden ein.
1. (Optional) Wählen Sie **Skalierung deaktivieren** aus, wenn Sie nicht möchten, dass Auto Scaling die Instances beendet, wenn der Traffic abnimmt.
1. Wählen Sie **Speichern**.
Dieses Verfahren registriert ein Modell als skalierbares Ziel mit Application Auto Scaling. Wenn Sie ein Modell registrieren, nimmt Application Auto Scaling Überprüfungen vor, um sicherzustellen, dass:
+ Das Modell existiert
+ die Berechtigungen ausreichen
+ Sie keine Variante mit einer Instance registrieren, die eine Burstable Performance Instance wie T2 ist
**Anmerkung**
SageMaker KI unterstützt Auto Scaling für Burstable-Instances wie T2 nicht, da sie bereits eine höhere Kapazität bei erhöhten Workloads ermöglichen. Informationen zu Instances mit Spitzenlastleistung finden Sie unter [Instance-Typen von Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
# Registrieren eines Modells
Bevor Sie Ihrem Modell eine Skalierungsrichtlinie hinzufügen, müssen Sie Ihr Modell zunächst für Auto Scaling registrieren und die Skalierungsgrenzen für das Modell definieren.
Die folgenden Verfahren beschreiben, wie Sie ein Modell (Produktionsvariante) für Auto Scaling mithilfe der API AWS Command Line Interface (AWS CLI) oder Application Auto Scaling registrieren.
**Topics**
+ [Registrieren eines Modells (AWS CLI)](#endpoint-auto-scaling-add-cli)
+ [Ein Modell registrieren (Application Auto Scaling Anwendungen-API)](#endpoint-auto-scaling-add-api)
## Registrieren eines Modells (AWS CLI)
Verwenden Sie den [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)Befehl mit den folgenden Parametern, um Ihre Produktionsvariante zu registrieren:
+ `--service-namespace` – Stellen Sie diesen Wert auf `sagemaker` ein.
+ `--resource-id`-Die Ressourcenkennung für das Modell (insbesondere die Produktionsvariante). Für diesen Parameter lautet der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Produktionsvariante. Beispiel, `endpoint/my-endpoint/variant/my-variant`.
+ `--scalable-dimension` – Stellen Sie diesen Wert auf `sagemaker:variant:DesiredInstanceCount` ein.
+ `--min-capacity` – Mindestanzahl von Instances Dieser Wert muss auf mindestens 1 gesetzt werden und muss gleich oder kleiner sein als der für `max-capacity` angegebene Wert.
+ `--max-capacity` – Höchstzahl von Instances Dieser Wert muss auf mindestens 1 gesetzt werden und muss gleich oder größer sein als der für `min-capacity` angegebene Wert.
**Example**
Das folgende Beispiel zeigt, wie Sie eine Variante mit dem Namen `my-variant` registrieren, die auf dem Endpunkt `my-endpoint` ausgeführt wird und dynamisch skaliert werden kann, um eine bis acht Instances zu erhalten.
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--min-capacity 1 \
--max-capacity 8
```
## Ein Modell registrieren (Application Auto Scaling Anwendungen-API)
Um Ihr Modell bei Application Auto Scaling zu registrieren, verwenden Sie die API-Aktion [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) Application Auto Scaling mit den folgenden Parametern:
+ `ServiceNamespace` – Stellen Sie diesen Wert auf `sagemaker` ein.
+ `ResourceID`-Die Ressourcenkennung für die Produktionsvariante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension` – Stellen Sie diesen Wert auf `sagemaker:variant:DesiredInstanceCount` ein.
+ `MinCapacity` – Mindestanzahl von Instances Dieser Wert muss auf mindestens 1 gesetzt werden und muss gleich oder kleiner sein als der für `MaxCapacity` angegebene Wert.
+ `MaxCapacity` – Höchstzahl von Instances Dieser Wert muss auf mindestens 1 gesetzt werden und muss gleich oder größer sein als der für `MinCapacity` angegebene Wert.
**Example**
Das folgende Beispiel zeigt, wie Sie eine Variante mit dem Namen `my-variant` registrieren, die auf dem Endpunkt `my-endpoint` ausgeführt wird und dynamisch skaliert werden kann, um eine bis acht Instances zu erhalten.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"MinCapacity": 1,
"MaxCapacity": 8
}
```
# Definieren einer Skalierungsrichtlinie
Bevor Sie eine Skalierungsrichtlinie zu Ihrem Modell hinzufügen, speichern Sie Ihre Richtlinienkonfiguration als JSON-Block in einer Textdatei. Sie verwenden diese Textdatei, wenn Sie die AWS Command Line Interface (AWS CLI) oder die Application Auto Scaling Scaling-API aufrufen. Sie können die Skalierung optimieren, indem Sie eine geeignete CloudWatch Metrik auswählen. Bevor Sie jedoch eine benutzerdefinierte Metrik in einer Produktionsumgebung verwenden, müssen Sie Auto Scaling mit Ihrer benutzerdefinierten Metrik testen.
**Topics**
+ [Geben Sie eine vordefinierte Metrik an (CloudWatch Metrik: InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined)
+ [Geben Sie eine vordefinierte Metrik mit hoher Auflösung an (CloudWatch Metriken: ConcurrentRequestsPerModel und ConcurrentRequestsPerCopy)](#endpoint-auto-scaling-add-code-high-res)
+ [Definieren Sie eine benutzerdefinierte Metrik (CloudWatch Metrik: CPUUtilization)](#endpoint-auto-scaling-add-code-custom)
+ [Definieren Sie eine benutzerdefinierte Metrik (CloudWatch Metrik: ExplanationsPerInstance)](#endpoint-auto-scaling-online-explainability)
+ [Angabe von Ruhephasen](#endpoint-auto-scaling-add-code-cooldown)
In diesem Abschnitt finden Sie beispielhafte Richtlinienkonfigurationen für Skalierungsrichtlinien zur Zielverfolgung.
## Geben Sie eine vordefinierte Metrik an (CloudWatch Metrik: InvocationsPerInstance)
**Example**
Nachfolgend finden Sie ein Beispiel für eine Richtlinienkonfiguration zur Zielverfolgung für eine Variante, welche die durchschnittlichen Aufrufe pro Instance bei 70 hält. Speichern Sie diese Konfiguration in einer Datei mit dem Namen `config.json`.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
```
Weitere Informationen finden Sie [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)in der *API-Referenz für Application Auto Scaling*.
## Geben Sie eine vordefinierte Metrik mit hoher Auflösung an (CloudWatch Metriken: ConcurrentRequestsPerModel und ConcurrentRequestsPerCopy)
Mit den folgenden hochauflösenden CloudWatch Metriken können Sie Skalierungsrichtlinien für das Volumen der gleichzeitigen Anfragen festlegen, die Ihre Modelle erhalten:
**ConcurrentRequestsPerModel**
Legt die Anzahl der gleichzeitigen Anforderungen fest, die von einem Modellcontainer empfangen werden.
**ConcurrentRequestsPerCopy**
Legt die Anzahl der gleichzeitigen Anforderungen fest, die von einer Inferenzkomponente empfangen werden.
Diese Metriken verfolgen die Anzahl der gleichzeitigen Anforderungen, die Ihre Modellcontainer verarbeiten, einschließlich der Anforderungen, die sich in den Containern in der Warteschlange befinden. Bei Modellen, die ihre Inferenzantwort als Token-Stream senden, verfolgen diese Metriken jede Anforderung, bis das Modell das letzte Token für die Anforderung sendet.
Als hochauflösende Metriken geben sie Daten häufiger aus als Standardmetriken. CloudWatch Standardmetriken, wie die `InvocationsPerInstance`-Metrik, geben einmal pro Minute Daten aus. Diese hochauflösenden Metriken geben hingegen alle 10 Sekunden Daten aus. Bei einer Zunahme des gleichzeitigen Datenverkehrs zu Ihren Modellen reagiert Ihre Richtlinie mit einer deutlich schnelleren Aufskalierung als es bei Standardmetriken der Fall wäre. Wenn der Datenverkehr zu Ihren Modellen jedoch abnimmt, erfolgt die Abskalierung durch die Richtlinie genauso schnell wie bei Standardmetriken.
Im Folgenden finden Sie ein Beispiel für eine Richtlinienkonfiguration zur Zielverfolgung, die Instances hinzufügt, wenn die Anzahl gleichzeitiger Anforderungen pro Modell auf über 5 steigt. Speichern Sie diese Konfiguration in einer Datei mit dem Namen `config.json`.
```
{
"TargetValue": 5.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantConcurrentRequestsPerModelHighResolution"
}
}
```
Wenn Sie Inferenzkomponenten verwenden, um mehrere Modelle auf demselben Endpunkt bereitzustellen, können Sie eine entsprechende Richtlinie erstellen. Stellen Sie in diesem Fall `PredefinedMetricType` auf `SageMakerInferenceComponentConcurrentRequestsPerCopyHighResolution` ein.
Weitere Informationen finden Sie [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)in der *API-Referenz für Application Auto Scaling*.
## Definieren Sie eine benutzerdefinierte Metrik (CloudWatch Metrik: CPUUtilization)
Um eine Skalierungsrichtlinie zur Zielverfolgung mit einer benutzerdefinierten Metrik zu erstellen, geben Sie den Namen, den Namespace, die Einheit, die Statistik und null oder mehr Dimensionen für die Metrik an. Dimensionen bestehen aus einem Dimensionsnamen und einem Dimensionswert. Sie können eine beliebige Variantenmetrik verwenden, die sich proportional zur Kapazität ändert.
**Example**
Die folgende Beispielkonfiguration zeigt eine Skalierungsrichtlinie für die Zielnachverfolgung mit einer benutzerdefinierten Metrik. Die Richtlinie skaliert die Variante basierend auf einer durchschnittlichen CPU-Auslastung von 50 % über alle Instances hinweg. Speichern Sie diese Konfiguration in einer Datei mit dem Namen `config.json`.
```
{
"TargetValue": 50.0,
"CustomizedMetricSpecification":
{
"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
Weitere Informationen finden Sie [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)in der *API-Referenz für Application Auto Scaling*.
## Definieren Sie eine benutzerdefinierte Metrik (CloudWatch Metrik: ExplanationsPerInstance)
Wenn für den Endpunkt die Online-Erklärbarkeit aktiviert ist, wird eine `ExplanationsPerInstance`-Metrik ausgegeben, die die durchschnittliche Anzahl erklärter Datensätze pro Minute und Instance für eine Variante ausgibt. Die Ressourcennutzung bei der Erklärung von Datensätzen kann sich stärker von der der Vorhersage von Datensätzen unterscheiden. Wir empfehlen dringend, diese Metrik für die Skalierung der Zielnachverfolgung von Endpunkten zu verwenden, wenn die Online-Erklärbarkeit aktiviert ist.
Sie können mehrere Zielverfolgungsrichtlinien für ein skalierbares Ziel erstellen. Erwägen Sie, die `InvocationsPerInstance`-Richtlinie aus dem Abschnitt [Geben Sie eine vordefinierte Metrik an (CloudWatch Metrik: InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined) hinzuzufügen (zusätzlich zur `ExplanationsPerInstance`-Richtlinie). Wenn die meisten Aufrufe aufgrund des im `EnableExplanations`-Parameter festgelegten Schwellenwerts keine Erklärung zurückgeben, kann der Endpunkt die Richtlinie `InvocationsPerInstance` auswählen. Wenn eine große Anzahl von Erklärungen vorliegt, kann der Endpunkt die Richtlinie `ExplanationsPerInstance` verwenden.
**Example**
Die folgende Beispielkonfiguration zeigt eine Skalierungsrichtlinie für die Zielnachverfolgung mit einer benutzerdefinierten Metrik. Die Richtlinienskala dient zur Einstellung der Anzahl der Varianten-Instances, damit für jede Instance `ExplanationsPerInstance`-Metrik auf 20 festgelegt ist. Speichern Sie diese Konfiguration in einer Datei mit dem Namen `config.json`.
```
{
"TargetValue": 20.0,
"CustomizedMetricSpecification":
{
"MetricName": "ExplanationsPerInstance",
"Namespace": "AWS/SageMaker",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Sum"
}
}
```
Weitere Informationen finden Sie [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)in der *API-Referenz für Application Auto Scaling*.
## Angabe von Ruhephasen
In Ihrer Skalierungsrichtlinie für die Zielverfolgung können Sie optional Ruhephasen definieren, indem Sie die Parameter `ScaleOutCooldown` und `ScaleInCooldown` festlegen.
**Example**
Nachfolgend finden Sie ein Beispiel für eine Richtlinienkonfiguration zur Zielverfolgung für eine Variante, welche die durchschnittlichen Aufrufe pro Instance bei 70 hält. Die Richtlinienkonfiguration sieht eine Ruhephase von 10 Minuten (600 Sekunden) zum Abskalieren und eine Ruhephase von 5 Minuten (300 Sekunden) zum Aufskalieren vor. Speichern Sie diese Konfiguration in einer Datei mit dem Namen `config.json`.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
Weitere Informationen finden Sie [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)in der *API-Referenz für Application Auto Scaling*.
# Anwenden einer Skalierungsrichtlinie
Nachdem Sie Ihr Modell registriert und eine Skalierungsrichtlinie definiert haben, wenden Sie die Skalierungsrichtlinie auf das registrierte Modell an. In diesem Abschnitt wird gezeigt, wie eine Skalierungsrichtlinie über die AWS Command Line Interface (AWS CLI) oder die Application Auto Scaling API angewendet wird.
**Topics**
+ [Anwenden einer Skalierungsrichtlinie zur Zielnachverfolgung (AWS CLI)](#endpoint-auto-scaling-add-code-apply-cli)
+ [Wenden Sie eine Skalierungsrichtlinie an (Application Auto Scaling API)](#endpoint-auto-scaling-add-code-apply-api)
## Anwenden einer Skalierungsrichtlinie zur Zielnachverfolgung (AWS CLI)
Verwenden Sie den [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) AWS CLI Befehl mit den folgenden Parametern, um eine Skalierungsrichtlinie auf Ihr Modell anzuwenden:
+ `--policy-name` – Der Name der Skalierungsrichtlinie.
+ `--policy-type`-Stellen Sie diesen Wert auf `TargetTrackingScaling` ein.
+ `--resource-id`- Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Beispiel, `endpoint/my-endpoint/variant/my-variant`.
+ `--service-namespace`-Stellen Sie diesen Wert auf `sagemaker` ein.
+ `--scalable-dimension`-Stellen Sie diesen Wert auf `sagemaker:variant:DesiredInstanceCount` ein.
+ `--target-tracking-scaling-policy-configuration` – Die Konfiguration der Skalierungsrichtlinie für die Zielnachverfolgung, die für das Modell verwendet werden soll.
**Example**
Im folgenden Beispiel wird eine Skalierungsrichtlinie zur Zielnachverfolgung namens `my-scaling-policy` auf eine Variante namens `my-endpoint` angewendet, die auf dem Endpunkt `my-variant` ausgeführt wird. Geben Sie unter der Option `--target-tracking-scaling-policy-configuration` die `config.json`-Datei an, die Sie zuvor erstellt haben.
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--target-tracking-scaling-policy-configuration file://config.json
```
## Wenden Sie eine Skalierungsrichtlinie an (Application Auto Scaling API)
Um auf eine Variante mit der Application Auto Scaling API eine Skalierungsrichtlinie anzuwenden, verwenden Sie die Aktion Application Auto Scaling API [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) mit den folgenden Parametern:
+ `PolicyName` – Der Name der Skalierungsrichtlinie.
+ `ServiceNamespace`-Stellen Sie diesen Wert auf `sagemaker` ein.
+ `ResourceID`- Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Beispiel, `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension`-Stellen Sie diesen Wert auf `sagemaker:variant:DesiredInstanceCount` ein.
+ `PolicyType`-Stellen Sie diesen Wert auf `TargetTrackingScaling` ein.
+ `TargetTrackingScalingPolicyConfiguration`-Die für die Variante zu verwendende Konfiguration der Skalierungsrichtlinie für die Zielverfolgung.
**Example**
Im folgenden Beispiel wird eine Skalierungsrichtlinie zur Zielnachverfolgung namens `my-scaling-policy` auf eine Variante namens `my-endpoint` angewendet, die auf dem Endpunkt `my-variant` ausgeführt wird. Die Richtlinienkonfiguration hält die durchschnittlichen Aufrufe pro Instance bei 70.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
}
```
# Anweisungen zum Bearbeiten einer Skalierungsrichtlinie
Nachdem Sie eine Skalierungsrichtlinie erstellt haben, können Sie alle Einstellungen mit Ausnahme des Namens bearbeiten.
Verwenden Sie dasselbe Verfahren wie früher AWS-Managementkonsole, um eine Skalierungsrichtlinie für die Zielverfolgung mit der zu bearbeiten[Konfigurieren Sie Auto Scaling für Modelle über die Konsole](endpoint-auto-scaling-add-console.md).
Sie können die AWS CLI oder die Application Auto Scaling Scaling-API verwenden, um eine Skalierungsrichtlinie auf die gleiche Weise zu bearbeiten, wie Sie eine neue Skalierungsrichtlinie erstellen. Weitere Informationen finden Sie unter [Anwenden einer Skalierungsrichtlinie](endpoint-auto-scaling-add-code-apply.md).
# Vorübergehendes Deaktivieren von Skalierungsrichtlinien
Nachdem Sie Auto Scaling konfiguriert haben, haben Sie die folgenden Optionen, wenn Sie ein Problem untersuchen müssen, ohne von Skalierungsrichtlinien beeinträchtigt zu werden (dynamische Skalierung):
+ Unterbrechen Sie die Skalierungsaktivitäten vorübergehend und setzen Sie sie dann fort, indem Sie den [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)CLI-Befehl oder die [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API-Aktion aufrufen und einen booleschen Wert für sowohl als auch `DynamicScalingInSuspended` angeben. `DynamicScalingOutSuspended`
**Example**
Das folgende Beispiel zeigt, wie Skalierungsrichtlinien für eine Variante namens `my-variant`, die auf dem Endpunkt `my-endpoint` ausgeführt wird, ausgesetzt werden.
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--suspended-state '{"DynamicScalingInSuspended":true,"DynamicScalingOutSuspended":true}'
```
+ Verhindern Sie, dass bestimmte Zielverfolgungs-Skalierungsrichtlinien eine Abskalierung in Ihrer Variante durchführen, indem Sie den Abskalierungsteil der Richtlinie deaktivieren. Diese Methode verhindert das Löschen von Instances durch die Skalierungsrichtlinie und erlaubt ihr dennoch, Instances nach Bedarf zu erstellen.
Deaktivieren Sie vorübergehend Scale-In-Aktivitäten und aktivieren Sie sie dann, indem Sie die Richtlinie mit dem [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)CLI-Befehl oder der [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API-Aktion bearbeiten und einen booleschen Wert für angeben. `DisableScaleIn`
**Example**
Im Folgenden finden Sie eine Beispielkonfiguration für die Zielnachverfolgung für eine Skalierungsrichtlinie, die das Aufskalieren, aber kein Abskalieren ermöglicht.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"DisableScaleIn": true
}
```
# Löschen einer Skalierungsrichtlinie
Wenn Sie keine Skalierungsrichtlinie mehr benötigen, können Sie diese jederzeit löschen.
**Topics**
+ [Löschen aller Skalierungsrichtlinien und Aufheben der Registrierung des Modells (Konsole)](#endpoint-auto-scaling-delete-console)
+ [Löschen Sie eine Skalierungsrichtlinie (AWS CLI oder eine Application Auto Scaling Scaling-API)](#endpoint-auto-scaling-delete-code)
## Löschen aller Skalierungsrichtlinien und Aufheben der Registrierung des Modells (Konsole)
**So löschen Sie alle Skalierungsrichtlinien und heben die Registrierung der Variante als skalierbares Ziel auf**
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im Navigationsbereich **Endpunkte** aus.
1. Wählen Sie Ihren Endpunkt und dann für **Endpunktlaufzeiteinstellungen** die Variante aus.
1. Wählen Sie **Configure auto scaling (Auto Scaling konfigurieren)** aus.
1. Wählen Sie **Deregister auto scaling (Auto Scaling abmelden)** aus.
## Löschen Sie eine Skalierungsrichtlinie (AWS CLI oder eine Application Auto Scaling Scaling-API)
Sie können die AWS CLI oder die Application Auto Scaling API verwenden, um eine Skalierungsrichtlinie aus einer Variante zu löschen.
### Löschen einer Skalierungsrichtlinie (AWS CLI)
Um eine Skalierungsrichtlinie aus einer Variante zu löschen, verwenden Sie den [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html)Befehl mit den folgenden Parametern:
+ `--policy-name` – Der Name der Skalierungsrichtlinie.
+ `--resource-id`- Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Beispiel, `endpoint/my-endpoint/variant/my-variant`.
+ `--service-namespace`-Stellen Sie diesen Wert auf `sagemaker` ein.
+ `--scalable-dimension`-Stellen Sie diesen Wert auf `sagemaker:variant:DesiredInstanceCount` ein.
**Example**
Im folgenden Beispiel wird eine Skalierungsrichtlinie zur Zielnachverfolgung namens `my-scaling-policy` aus einer Variante namens `my-endpoint` gelöscht, die auf dem Endpunkt `my-variant` ausgeführt wird.
```
aws application-autoscaling delete-scaling-policy \
--policy-name my-scaling-policy \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount
```
### Eine Skalierungsrichtlinie löschen (Application Auto Scaling API)
Um eine Skalierungsrichtlinie für Ihre Variante zu löschen, verwenden Sie die API-Maßnahme [DeleteScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeleteScalingPolicy.html) Application Auto Scaling mit den folgenden Parametern:
+ `PolicyName` – Der Name der Skalierungsrichtlinie.
+ `ServiceNamespace`-Stellen Sie diesen Wert auf `sagemaker` ein.
+ `ResourceID`- Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Beispiel, `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension`-Stellen Sie diesen Wert auf `sagemaker:variant:DesiredInstanceCount` ein.
**Example**
Im folgenden Beispiel wird eine Skalierungsrichtlinie zur Zielnachverfolgung namens `my-scaling-policy` aus einer Variante namens `my-endpoint` gelöscht, die auf dem Endpunkt `my-variant` ausgeführt wird.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount"
}
```
# Überprüfen des Status einer Skalierungsaktivität durch Beschreibung der Skalierungsaktivitäten
Sie können den Status einer Skalierungsaktivität für Ihren automatisch skalierten Endpunkt überprüfen, indem Sie die Skalierungsaktivitäten beschreiben. Application Auto Scaling liefert beschreibende Informationen zu den Skalierungsaktivitäten im angegebenen Namespace aus den letzten sechs Wochen. Weitere Informationen finden Sie unter [Skalierungsaktivitäten für Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scaling-activities.html) im *Benutzerhandbuch zum Application Auto Scaling*.
Verwenden Sie den [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)Befehl, um den Status einer Skalierungsaktivität zu überprüfen. Sie können den Status einer Skalierungsaktivität nicht mit der Konsole überprüfen.
**Topics**
+ [Beschreiben von Skalierungsaktivitäten (AWS CLI)](#endpoint-how-to)
+ [Erkennen von blockierten Skalierungsaktivitäten anhand von Instance-Kontingenten (AWS CLI)](#endpoint-identify-blocked-autoscaling)
## Beschreiben von Skalierungsaktivitäten (AWS CLI)
Um die Skalierungsaktivitäten für alle SageMaker KI-Ressourcen zu beschreiben, die bei Application Auto Scaling registriert sind, verwenden Sie den [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)Befehl und geben Sie `sagemaker` die `--service-namespace` Option an.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker
```
Um Skalierungsaktivitäten für eine bestimmte Ressource zu beschreiben, fügen Sie die Option `--resource-id` hinzu.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
Das folgende Beispiel zeigt die Ausgabe, die beim Ausführen dieses Befehls erzeugt wird.
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "string",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "string",
"StatusMessage": "string"
}
```
## Erkennen von blockierten Skalierungsaktivitäten anhand von Instance-Kontingenten (AWS CLI)
Wenn Sie aufskalieren (weitere Instances hinzufügen), erreichen Sie ggf. Ihr Instance-Kontingent auf Kontoebene. Sie können den [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)Befehl verwenden, um zu überprüfen, ob Sie Ihr Instance-Kontingent erreicht haben. Wenn Sie Ihr Kontingent überschreiten, wird das Auto Scaling blockiert.
Um zu überprüfen, ob Sie Ihr Instanzkontingent erreicht haben, verwenden Sie den [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)Befehl und geben Sie die Ressourcen-ID für die `--resource-id` Option an.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
Überprüfen Sie in der Syntax der Antwort die Tasten [StatusCode](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusCode) und [StatusMessage](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusMessage)und die zugehörigen Werte. `StatusCode` gibt `Failed` zurück. `StatusMessage` enthält die Meldung, dass das Service Quota auf Kontoebene erreicht wurde. Es folgt ein Beispiel dafür, wie diese Mitteilung aussehen könnte:
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "minimum capacity was set to 110",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "Failed",
"StatusMessage": "Failed to set desired instance count to 110. Reason: The
account-level service limit 'ml.xx.xxxxxx for endpoint usage' is 1000
Instances, with current utilization of 997 Instances and a request delta
of 20 Instances. Please contact AWS support to request an increase for this
limit. (Service: AmazonSageMaker; Status Code: 400;
Error Code: ResourceLimitExceeded; Request ID: request-id)."
}
```
# Skalieren eines Endpunkts auf null Instances
Wenn Sie Auto Scaling für einen Endpunkt einrichten, können Sie zulassen, dass beim Abskalierungsprozess die Anzahl der betriebsbereiten Instances auf Null reduziert wird. Auf diese Weise sparen Sie Kosten in Zeiten, in denen Ihr Endpunkt keine Inferenzanforderungen bedient und daher keine aktiven Instances benötigt.
Nach der Skalierung auf null Instances kann Ihr Endpunkt jedoch erst dann auf eingehende Inferenzanforderungen antworten, wenn er mindestens eine Instance bereitstellt. Um den Bereitstellungsprozess zu automatisieren, erstellen Sie eine Richtlinie zur schrittweisen Skalierung mit Application Auto Scaling. Anschließend weisen Sie die Richtlinie einem CloudWatch Amazon-Alarm zu.
Nachdem Sie die Richtlinie zur schrittweisen Skalierung und den Alarm eingerichtet haben, stellt Ihr Endpunkt automatisch eine Instance bereit, sobald er eine Inferenzanforderung erhält, auf die er nicht antworten kann. Beachten Sie, dass der Bereitstellungsprozess mehrere Minuten dauert. Während dieser Zeit führen alle Versuche, den Endpunkt aufzurufen, zu einem Fehler.
In den folgenden Verfahren wird erklärt, wie Sie beim Auto Scaling für einen Endpunkt die Abskalierung auf null Instances und die Aufskalierung von null Instances konfigurieren. Bei diesen Verfahren werden AWS CLI-Befehle verwendet.
**Bevor Sie beginnen**
Ihr Endpunkt muss die folgenden Voraussetzungen erfüllen, bevor er auf null Instances abskaliert bzw. von null Instances aufskaliert werden kann.
+ Er ist betriebsbereit.
+ Es hostet eine oder mehrere Inferenzkomponenten. Ein Endpunkt kann nur dann auf null Instances abskaliert und von null Instances aufskaliert werden, wenn er Inferenzkomponenten hostet.
Informationen zum Hosten von Inferenzkomponenten auf SageMaker KI-Endpunkten finden Sie unter. [Modelle für Echtzeit-Inferenzen bereitstellen](realtime-endpoints-deploy-models.md)
+ In der Endpunktkonfiguration haben Sie für das `ManagedInstanceScaling`-Objekt der Produktionsvariante den Parameter `MinInstanceCount` auf `0` gesetzt.
Referenzinformationen zu diesem Parameter finden Sie unter. [ProductionVariantManagedInstanceScaling](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantManagedInstanceScaling.html)
**So aktivieren Sie die Abskalierung eines Endpunkts auf null Instances (AWS CLI)**
Gehen Sie für jede Inferenzkomponente, die der Endpunkt hostet, wie folgt vor:
1. Registrieren Sie die Inferenzkomponente als skalierbares Ziel. Legen Sie bei der Registrierung die Mindestkapazität auf `0` fest, wie im folgenden Befehl dargestellt:
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id inference-component/inference-component-name \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--min-capacity 0 \
--max-capacity n
```
Ersetzen Sie ihn in diesem Beispiel *inference-component-name* durch den Namen Ihrer Inferenzkomponente. *n*Ersetzen Sie durch die maximale Anzahl von Kopien der Inferenzkomponenten, die beim Skalieren bereitgestellt werden sollen.
Weitere Informationen zu diesem Befehl und seinen einzelnen Parametern finden Sie [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)in der *AWS CLI Befehlsreferenz.*
1. Wenden Sie eine Zielverfolgungsrichtlinie auf die Inferenzkomponente an, wie im folgenden Befehl dargestellt:
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--target-tracking-scaling-policy-configuration file://config.json
```
Ersetzen Sie in diesem Beispiel *inference-component-name* durch den Namen Ihrer Inferenzkomponente.
In dem Beispiel enthält die `config.json`-Datei eine Richtlinienkonfiguration für die Zielverfolgung wie die folgende:
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerInferenceComponentInvocationsPerCopy"
},
"TargetValue": 1,
"ScaleInCooldown": 300,
"ScaleOutCooldown": 300
}
```
Weitere Beispiele für Richtlinienkonfigurationen zur Nachverfolgung finden Sie unter [Definieren einer Skalierungsrichtlinie](endpoint-auto-scaling-add-code-define.md).
Weitere Informationen zu diesem Befehl und seinen einzelnen Parametern finden Sie [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)in der *AWS CLI Befehlsreferenz.*
**So aktivieren Sie die Aufskalierung eines Endpunkts von null Instances (AWS CLI)**
Gehen Sie für jede Inferenzkomponente, die der Endpunkt hostet, wie folgt vor:
1. Wenden Sie eine Richtlinie zur schrittweisen Skalierung auf die Inferenzkomponente an, wie im folgenden Befehl dargestellt:
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type StepScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--step-scaling-policy-configuration file://config.json
```
Ersetzen Sie es in diesem Beispiel *my-scaling-policy* durch einen eindeutigen Namen für Ihre Richtlinie. *inference-component-name*Ersetzen Sie ihn durch den Namen Ihrer Inferenzkomponente.
In dem Beispiel enthält die `config.json`-Datei eine Richtlinienkonfiguration für die schrittweise Skalierung wie die folgende:
```
{
"AdjustmentType": "ChangeInCapacity",
"MetricAggregationType": "Maximum",
"Cooldown": 60,
"StepAdjustments":
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
}
```
Wenn diese Richtlinie zur schrittweisen Skalierung ausgelöst wird, stellt SageMaker KI die erforderlichen Instanzen bereit, um die Kopien der Inferenzkomponenten zu unterstützen.
Notieren Sie nach dem Erstellen der Richtlinie zur schrittweisen Skalierung den Amazon-Ressourcennamen (ARN). Im nächsten Schritt benötigen Sie den ARN für den CloudWatch Alarm.
Weitere Informationen über Richtlinien zur schrittweisen Skalierung finden Sie unter [Richtlinien zur schrittweisen Skalierung](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) im *Benutzerhandbuch zum Auto Scaling von Anwendungen*.
1. Erstellen Sie einen CloudWatch Alarm und weisen Sie ihm die Step Scaling-Richtlinie zu, wie das folgende Beispiel zeigt:
```
aws cloudwatch put-metric-alarm \
--alarm-actions step-scaling-policy-arn \
--alarm-description "Alarm when SM IC endpoint invoked that has 0 instances." \
--alarm-name ic-step-scaling-alarm \
--comparison-operator GreaterThanThreshold \
--datapoints-to-alarm 1 \
--dimensions "Name=InferenceComponentName,Value=inference-component-name" \
--evaluation-periods 1 \
--metric-name NoCapacityInvocationFailures \
--namespace AWS/SageMaker \
--period 60 \
--statistic Sum \
--threshold 1
```
In diesem Beispiel *step-scaling-policy-arn* ersetzen Sie es durch den ARN Ihrer Step Scaling-Richtlinie. *ic-step-scaling-alarm*Ersetzen Sie es durch einen Namen Ihrer Wahl. *inference-component-name*Ersetzen Sie durch den Namen Ihrer Inferenzkomponente.
In diesem Beispiel wird der `--metric-name` Parameter auf gesetzt`NoCapacityInvocationFailures`. SageMaker AI gibt diese Metrik aus, wenn ein Endpunkt eine Inferenzanforderung empfängt, der Endpunkt aber keine aktiven Instanzen hat, um die Anfrage zu bearbeiten. Wenn dieses Ereignis eintritt, initiiert der Alarm die Richtlinie zur schrittweisen Skalierung aus dem vorherigen Schritt.
Weitere Informationen zu diesem Befehl und seinen einzelnen Parametern finden Sie [put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html)in der *AWS CLI Befehlsreferenz*.
# Lasttest Ihrer Auto -Scaling-Konfiguration
Führen Sie Lasttests durch, um eine Skalierungskonfiguration auszuwählen, die so funktioniert, wie Sie es möchten.
Die folgenden Richtlinien zur Durchführung von Lasttests gehen davon aus, dass Sie eine Skalierungsrichtlinie verwenden, die die vorab definierte `SageMakerVariantInvocationsPerInstance`-Kennzahl nutzt.
**Topics**
+ [Bestimmen der Leistungseigenschaften](#endpoint-scaling-loadtest-variant)
+ [Berechnen der Ziellast](#endpoint-scaling-loadtest-calc)
## Bestimmen der Leistungseigenschaften
Führen Sie Lasttests durch, um die höchste Auslastung `InvocationsPerInstance`, die Ihre Produktionsvariante Ihres Modells verarbeiten kann, und die Latenz der Anfragen, während die Nebenläufigkeit zunimmt, zu finden.
Dieser Wert hängt vom ausgewählten Instance-Typ, von den Nutzlasten, die Kunden in der Regel an Ihr Modell senden sowie von der Performance der externen Abhängigkeiten Ihres Modells ab.
**Um den Spitzenwert requests-per-second (RPS) zu ermitteln, den die Produktionsvariante Ihres Modells bewältigen kann, und die Latenz von Anfragen**
1. Richten Sie mithilfe einer einzigen Instance einen Endpunkt für Ihr Modell ein. Informationen zum Einrichten eines Endpunkts finden Sie unter [Stellen Sie das Modell für SageMaker AI Hosting Services bereit](ex1-model-deployment.md#ex1-deploy-model).
1. Verwenden Sie ein Tool für Lasttests, um eine steigende Anzahl von Parallelanforderungen zu generieren und die Anfragen pro Sekunde (RPS) sowie das Latenzmodell im Ausgang des Tools für Lasttests zu überwachen.
**Anmerkung**
Sie können requests-per-minute anstelle von RPS auch überwachen. In diesem Fall multiplizieren Sie in der Gleichung nicht mit 60, um `SageMakerVariantInvocationsPerInstance`, wie unten veranschaulicht, zu berechnen.
Steigt die Modelllatenz oder verringert sich der Anteil erfolgreicher Transaktionen, dann ist das die Höchstzahl der Anfragen pro Sekunde (RPS), die Ihr Modell verarbeiten kann.
## Berechnen der Ziellast
Nachdem Sie die Leistungsmerkmale der Variante gefunden haben, können Sie die Höchstzahl der Anfragen pro Sekunde (RPS) bestimmen, die wir an eine Instance senden sollen. Die Schwellenwert, der für die Skalierung verwendet wurde, muss kleiner sein als dieser Maximalwert. Verwenden Sie die folgende Gleichung in Kombination mit einem Lasttest, um den passenden Wert für die Zielkennzahl `SageMakerVariantInvocationsPerInstance` in Ihrer Skalierungskonfiguration festzulegen.
```
SageMakerVariantInvocationsPerInstance = (MAX_RPS * SAFETY_FACTOR) * 60
```
Wo `MAX_RPS` die maximale, durch Sie zuvor festgelegte Anzahl der Anfragen pro Sekunde (RPS) darstellt, und `SAFETY_FACTOR` der Sicherheitsfaktor ist, den Sie gewählt haben, um sicherzustellen, dass Ihre Kunden die Höchstzahl der Anfragen (RPS) nicht überschreiten. Multiplizieren Sie mit 60, um von RPS so umzurechnen, dass es der CloudWatch Minutenmetrik entspricht, die SageMaker KI zur Implementierung von Auto Scaling verwendet (Sie müssen dies nicht tun, wenn Sie requests-per-minute stattdessen messen). invocations-per-minute requests-per-second
**Anmerkung**
SageMaker AI empfiehlt, dass Sie mit dem Testen mit einem Wert `SAFETY_FACTOR` von 0,5 beginnen. Testen Sie Ihre Skalierungskonfiguration, um sicherzustellen, dass sie wunschgemäß entsprechend Ihres Modells funktioniert, um den Kundendatenverkehr an Ihrem Endpunkt zu erhöhen oder zu senken.
# Wird verwendet CloudFormation , um eine Skalierungsrichtlinie zu erstellen
Das folgende Beispiel zeigt, wie Sie Auto Scaling für Modelle auf einem Endpunkt mit CloudFormation konfigurieren.
```
Endpoint:
Type: "AWS::SageMaker::Endpoint"
Properties:
EndpointName: yourEndpointName
EndpointConfigName: yourEndpointConfigName
ScalingTarget:
Type: "AWS::ApplicationAutoScaling::ScalableTarget"
Properties:
MaxCapacity: 10
MinCapacity: 2
ResourceId: endpoint/my-endpoint/variant/my-variant
RoleARN: arn
ScalableDimension: sagemaker:variant:DesiredInstanceCount
ServiceNamespace: sagemaker
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
PolicyName: my-scaling-policy
PolicyType: TargetTrackingScaling
ScalingTargetId:
Ref: ScalingTarget
TargetTrackingScalingPolicyConfiguration:
TargetValue: 70.0
ScaleInCooldown: 600
ScaleOutCooldown: 30
PredefinedMetricSpecification:
PredefinedMetricType: SageMakerVariantInvocationsPerInstance
```
Weitere Informationen finden Sie unter [Erstellen von Ressourcen für Application Auto Scaling mit AWS CloudFormation](https://docs.aws.amazon.com/autoscaling/application/userguide/creating-resources-with-cloudformation.html) im *Benutzerhandbuch zum Application Auto Scaling*.
# Aktualisieren von Endpunkten, für die das Auto Scaling verwendet wird
Wenn Sie einen Endpunkt aktualisieren, prüft Application Auto Scaling, ob irgendeines der Modelle auf diesem Endpunkt Ziel für das Auto Scaling ist. Ändert die Aktualisierung den Instance-Typ für ein Modell, das ein Ziel für das Auto Scaling darstellt, so schlägt die Aktualisierung fehl.
In der wird eine Warnung angezeigt AWS-Managementkonsole, dass Sie das Modell von Auto Scaling abmelden müssen, bevor Sie es aktualisieren können. Wenn Sie versuchen, den Endpunkt zu aktualisieren, indem Sie die [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)-API aufrufen, schlägt der Aufruf fehl. Bevor Sie den Endpunkt aktualisieren, löschen Sie alle für ihn konfigurierten Skalierungsrichtlinien und heben Sie die Registrierung der Variante als skalierbares Ziel auf, indem Sie die API-Aktion [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)Application Auto Scaling aufrufen. Nachdem Sie den Endpunkt aktualisiert haben, können Sie die aktualisierte Variante als skalierbares Ziel registrieren und eine Skalierungsrichtlinie hinzufügen.
Es gibt eine Ausnahme. Wenn Sie das Modell für eine Variante ändern, die für Auto Scaling konfiguriert ist, ermöglicht Amazon SageMaker AI Auto Scaling das Update. Das liegt daran, dass sich die Änderung des Modells normalerweise nicht stark genug auf die Leistung auswirkt, um die Skalierung zu verändern. Wenn Sie ein Modell für eine Variante aktualisieren, die für das Auto Scaling konfiguriert wurde, stellen Sie sicher, dass die Änderung des Modells keine signifikanten Auswirkungen auf die Leistung und Skalierung hat.
Wenn Sie SageMaker KI-Endpunkte aktualisieren, auf die Auto Scaling angewendet wurde, führen Sie die folgenden Schritte aus:
**So aktualisieren Sie einen Endpunkt, bei dem das Auto Scaling angewendet wird**
1. Melden Sie den Endpunkt per Anruf als skalierbares Ziel ab. [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)
1. Da Auto Scaling während des Aktualisierungsvorgangs blockiert wird (oder wenn Sie Auto Scaling im vorangegangenen Schritt deaktiviert haben), sollten Sie als zusätzliche Vorsichtsmaßnahme die Anzahl der Instances für Ihren Endpunkt während der Aktualisierung erhöhen. Aktualisieren Sie dazu die Anzahl der Instances für die am Endpunkt gehosteten Produktionsvarianten, indem Sie [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) aufrufen.
1. Rufen Sie [ DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) wiederholt auf, bis der Wert des Feldes `EndpointStatus` der Antwort `InService` lautet.
1. Rufen Sie [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) auf, um die Werte der aktuellen Endpunktkonfiguration abzurufen.
1. Erstellen Sie eine neue Endpunktkonfiguration, indem Sie [ CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) aufrufen. Verwenden Sie für die Produktionsvarianten, für die Sie die vorhandene Instance-Zahl oder -Gewichtung beibehalten möchten, denselben Variantennamen aus der Antwort aus dem Aufruf von [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) im vorherigen Schritt. Verwenden Sie für alle anderen Werte die Werte, die Sie im vorherigen Schritt beim Aufruf von [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) erhalten haben.
1. Aktualisieren Sie den Endpunkt, indem Sie [ UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) aufrufen. Geben Sie die Endpunktkonfiguration an, die Sie im vorangegangenen Schritt als `EndpointConfig`-Feld erstellt haben. Wenn Sie Varianteneigenschaften wie Instance-Zahl oder -Gewichtung beibehalten möchten, legen Sie den Wert des Parameters `RetainAllVariantProperties` auf `True` fest. Dies gibt an, dass Produktionsvarianten mit demselben Namen mit der jeweils aktuellen `DesiredInstanceCount` aus der Antwort auf den Aufruf von `DescribeEndpoint` aktualisiert werden, unabhängig von den Werten für das Feld `InitialInstanceCount` in der neuen `EndpointConfig`.
1. (Optional) Reaktivieren Sie Auto Scaling, indem Sie [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)und [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)aufrufen.
**Anmerkung**
Die Schritte 1 und 7 sind nur erforderlich, wenn Sie einen Endpunkt mit den folgenden Änderungen aktualisieren:
Ändern des Instance-Typs für eine Produktionsvariante, für die Auto Scaling konfiguriert ist
Entfernen einer Produktionsvariante, für die Auto Scaling konfiguriert ist
# Löschen von Endpunkten, die für das Auto Scaling konfiguriert wurden
Wenn Sie einen Endpunkt löschen, prüft Application Auto Scaling, ob eines der Modelle auf diesem Endpunkt Ziele für das Auto Scaling sind. Wenn dies der Fall ist und Sie die Erlaubnis haben, das Modell abzumelden, meldet Application Auto Scaling diese Modelle als skalierbare Ziele ab, ohne Sie zu benachrichtigen. Wenn Sie eine benutzerdefinierte Berechtigungsrichtlinie verwenden, die keine Genehmigung für die [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)Aktion gewährt, müssen Sie Zugriff auf diese Aktion anfordern, bevor Sie den Endpunkt löschen.
**Anmerkung**
Als IAM-Benutzer verfügen Sie ggf. nicht über ausreichende Berechtigungen zum Löschen eines Endpunktes, wenn ein anderer Benutzer das Auto Scaling für eine Variante auf diesem Endpunkt konfiguriert hat.
# Instance-Speicher-Volumes
Wenn Sie einen Endpunkt erstellen, fügt Amazon SageMaker AI ein Volume von Amazon Elastic Block Store (Amazon EBS)-Volumes von Amazon-EC2-Instances hinzu, die den Endpunkt hosten. Die Größe des Speichervolumens ist skalierbar, und die Speicheroptionen sind in zwei Kategorien unterteilt: SSD-gestützter Speicher und HDD-gestützter Speicher.
Weitere Informationen zu Amazon EBS-Speichern und Funktionen finden Sie auf den folgenden Seiten.
+ [Funktionen von Amazon EBS](https://aws.amazon.com/ebs/features/)
+ [Amazon EBS Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
Die vollständige Liste der Host-Instance-Speicher-Volumes finden Sie unter [Host-Instance-Speicher-Volumes-Tabelle](https://aws.amazon.com/releasenotes/host-instance-storage-volumes-table/).
**Anmerkung**
Amazon SageMaker AI fügt Amazon-EC2-Instances ein Volume von Amazon Elastic Block Store (Amazon EBS) nur hinzu, wenn Sie [Asynchrone Inferenz-Inferenz](async-inference.md) und [Echtzeit-Inferenz](realtime-endpoints.md) Endpunkttypen erstellen. Weitere Informationen zum Anpassen des Amazon EBS-Speichervolumes finden Sie unter [SageMaker-AI-Endpunktparameter zur Inferenz großer Modelle](large-model-inference-hosting.md).
# Validieren von Modellen in der Produktion
Mit SageMaker AI können Sie mehrere Modelle oder Modellversionen hinter demselben Endpunkt mithilfe von Produktionsvarianten testen. Eine Variante besteht aus einer ML Instance und den in einem SageMaker-AI-Modell angegebenen Serving-Komponenten. Sie können mehrere Varianten hinter einem Endpunkt haben. Jede Variante kann einen anderen Instance-Typ oder ein SageMaker-AI-Modell haben, das unabhängig von den anderen automatisch skaliert werden kann. Die Modelle innerhalb der Varianten können mithilfe verschiedener Datensätze, verschiedener Algorithmen, verschiedener ML-Frameworks oder einer beliebigen Kombination aus all diesen trainiert werden. Alle Varianten hinter einem Endpunkt haben denselben Inferenzcode. SageMaker AI unterstützt zwei Arten von Varianten: Produktionsvarianten und Schattenvarianten.
Wenn Sie mehrere Produktionsvarianten hinter einem Endpunkt haben, können Sie jeder Variante einen Teil Ihrer Inferenzanfragen zuordnen. Jede Anfrage wird nur an eine der Produktionsvarianten weitergeleitet. Die Produktionsvariante, an die die Anfrage weitergeleitet wurde, liefert dem Anrufer die Antwort. Sie können vergleichen, wie sich die Produktionsvarianten im Vergleich zueinander verhalten.
Sie können auch eine Schattenvariante haben, die einer Produktionsvariante hinter einem Endpunkt entspricht. Ein Teil der Inferenzanfragen, die an die Produktionsvariante gehen, wird in die Schattenvariante repliziert. Die Antworten der Schattenvariante werden zum Vergleich protokolliert und nicht an den Aufrufer zurückgegeben. Auf diese Weise können Sie die Leistung der Schattenvariante testen, ohne den Aufrufer der Antwort der Schattenvariante auszusetzen.
**Topics**
+ [Testen von Modellen mit Produktionsvarianten](model-ab-testing.md)
+ [Testen von Modellen mit Schattenvarianten](model-shadow-deployment.md)
# Testen von Modellen mit Produktionsvarianten
In produktiven ML-Workflows versuchen Datenwissenschaftler und -ingenieure häufig, die Leistung mit verschiedenen Methoden zu verbessern, z. B. durch [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md), Training auf zusätzlichen oder aktuelleren Daten, Verbesserung der Merkmalsauswahl, Verwendung besser aktualisierter Instances und Bereitstellung von Containern. Sie können Produktionsvarianten verwenden, um Ihre Modelle, Instances und Container zu vergleichen und den Kandidaten mit der besten Leistung für die Beantwortung von Inferenzanfragen auszuwählen.
Mit variantenreichen SageMaker KI-Endpunkten können Sie Anfragen zum Endpunktaufruf auf mehrere Produktionsvarianten verteilen, indem Sie die Verkehrsverteilung für jede Variante angeben, oder Sie können für jede Anfrage direkt eine bestimmte Variante aufrufen. In diesem Thema betrachten wir beide Methoden zum Testen von ML-Modellen.
**Topics**
+ [Testen von Modellen durch Angabe der Verteilung des Datenverkehrs](#model-testing-traffic-distribution)
+ [Testen von Modellen durch Aufrufen bestimmter Varianten](#model-testing-target-variant)
+ [Beispiel für einen A/B Modelltest](#model-ab-test-example)
## Testen von Modellen durch Angabe der Verteilung des Datenverkehrs
Um mehrere Modelle zu testen, indem der Datenverkehr zwischen ihnen verteilt wird, geben Sie den Prozentsatz des Datenverkehrs an, der an jedes Modell weitergeleitet wird, indem Sie die Gewichtung für jede Produktionsvariante in der Endpunktkonfiguration angeben. Weitere Informationen finden Sie unter [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Das folgende Diagramm zeigt, wie dies im Detail funktioniert.
![\[Beispiel, das zeigt, wie die Verteilung des Datenverkehrs zwischen Modellen mithilfe von KI funktioniertInvokeEndpoint. SageMaker\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-traffic-distribution.png)
## Testen von Modellen durch Aufrufen bestimmter Varianten
Um mehrere Modelle zu testen, indem Sie für jede Anfrage spezifische Modelle aufrufen, geben Sie die spezifische Version des Modells an, das Sie aufrufen möchten, indem Sie beim Aufruf einen Wert für den `TargetVariant` Parameter angeben. [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) SageMaker KI stellt sicher, dass die Anfrage von der von Ihnen angegebenen Produktionsvariante verarbeitet wird. Wenn Sie die Verteilung des Datenverkehrs bereits angegeben und einen Wert für den Parameter `TargetVariant` angegeben haben, überschreibt das Ziel-Routing die zufällige Verteilung des Datenverkehrs. Das folgende Diagramm zeigt, wie dies im Detail funktioniert.
![\[Beispiel, das zeigt, wie das Aufrufen bestimmter Modelle für jede Anfrage mithilfe von SageMaker KI InvokeEndpoint funktioniert.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-target-variant.png)
## Beispiel für einen A/B Modelltest
Die Durchführung von A/B Tests zwischen einem neuen Modell und einem alten Modell mit Produktionsverkehr kann ein effektiver letzter Schritt im Validierungsprozess für ein neues Modell sein. Beim A/B Testen testen Sie verschiedene Varianten Ihrer Modelle und vergleichen die Leistung der einzelnen Varianten. Wenn die neuere Version des Modells eine bessere Leistung erbringt als die bisherige Version, ersetzen Sie die alte Version des Modells durch die neue Version in der Produktion.
Das folgende Beispiel zeigt, wie Sie A/B Modelltests durchführen. Ein Beispiel-Notebook, das dieses Beispiel implementiert, finden Sie unter [A/B-Testen von ML-Modellen in der Produktion](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_endpoints/a_b_testing/a_b_testing.html).
### Schritt 1: Erstellen und Bereitstellen von Modellen
Zunächst legen wir fest, wo sich unsere Modelle in Amazon S3 befinden. Diese Standorte werden verwendet, wenn wir unsere Modelle in folgenden Schritten bereitstellen:
```
model_url = f"s3://{path_to_model_1}"
model_url2 = f"s3://{path_to_model_2}"
```
Als Nächstes erstellen wir die Modellobjekte mit den Bild- und Modelldaten. Diese Modellobjekte werden verwendet, um Produktionsvarianten auf einem Endpunkt bereitzustellen. Die Modelle werden durch Training von ML-Modellen auf verschiedenen Datensätzen, verschiedenen Algorithmen oder ML-Frameworks und verschiedenen Hyperparametern entwickelt:
```
from sagemaker.amazon.amazon_estimator import get_image_uri
model_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
model_name2 = f"DEMO-xgb-churn-pred2-{datetime.now():%Y-%m-%d-%H-%M-%S}"
image_uri = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-1')
image_uri2 = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-2')
sm_session.create_model(
name=model_name,
role=role,
container_defs={
'Image': image_uri,
'ModelDataUrl': model_url
}
)
sm_session.create_model(
name=model_name2,
role=role,
container_defs={
'Image': image_uri2,
'ModelDataUrl': model_url2
}
)
```
Wir erstellen nun zwei Produktionsvarianten mit jeweils eigenem Modell und Ressourcenanforderungen (Instance-Typ und -Anzahl). Auf diese Weise können Sie auch Modelle mit verschiedenen Instance-Typen testen.
Wir legen ein initial\$1weight von 1 für beide Varianten fest. Dies bedeutet, dass 50 % der Anfragen an `Variant1` und die restlichen 50 % der Anfragen an `Variant2` gehen. Die Summe der Gewichtungen in beiden Varianten ist 2 und jede Variante hat eine Gewichtungszuweisung von 1. Dies bedeutet, dass jede Variante 1/2 oder 50 % des gesamten Datenverkehrs erhält.
```
from sagemaker.session import production_variant
variant1 = production_variant(
model_name=model_name,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant1',
initial_weight=1,
)
variant2 = production_variant(
model_name=model_name2,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant2',
initial_weight=1,
)
```
Endlich sind wir bereit, diese Produktionsvarianten auf einem SageMaker KI-Endpunkt bereitzustellen.
```
endpoint_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
print(f"EndpointName={endpoint_name}")
sm_session.endpoint_from_production_variants(
name=endpoint_name,
production_variants=[variant1, variant2]
)
```
### Schritt 2: Aufrufen der bereitgestellten Modelle
Jetzt senden wir Anfragen an diesen Endpunkt, um Inferenzen in Echtzeit zu erhalten. Wir verwenden sowohl die Verteilung des Datenverkehrs als auch das direkte Targeting.
Zuerst verwenden wir die Verteilung des Datenverkehrs, die wir im vorherigen Schritt konfiguriert haben. Jede Inferenzantwort enthält den Namen der Produktionsvariante, die die Anforderung verarbeitet, sodass wir sehen können, dass der Datenverkehr zu den beiden Produktionsvarianten ungefähr gleich ist.
```
# get a subset of test data for a quick test
!tail -120 test_data/test-dataset-input-cols.csv > test_data/test_sample_tail_input_cols.csv
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload
)
time.sleep(0.5)
print("Done!")
```
SageMaker KI gibt Metriken wie `Latency` und `Invocations` für jede Variante in Amazon CloudWatch aus. Eine vollständige Liste der von SageMaker KI ausgegebenen Metriken finden Sie unter. [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md) Lassen Sie uns die Anzahl der Aufrufe pro Variante abfragen CloudWatch , um zu zeigen, wie Aufrufe standardmäßig auf die Varianten aufgeteilt werden:
![\[Beispiel für die CloudWatch Anzahl der Aufrufe pro Variante.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-variant-invocations.png)
Lassen Sie uns nun eine bestimmte Version des Modells aufrufen, indem Sie `Variant1` als `TargetVariant` im Aufruf von `invoke_endpoint` angeben.
```
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload,
TargetVariant="Variant1"
)
time.sleep(0.5)
```
Um zu bestätigen, dass alle neuen Aufrufe von verarbeitet wurden`Variant1`, können wir die Anzahl der Aufrufe pro Variante abfragen CloudWatch . Wir sehen, dass für die letzten Aufrufe (aktueller Zeitstempel) alle Anfragen von `Variant1` verarbeitet wurden, wie wir angegeben hatten. Es wurden keine Aufrufe für `Variant2` gemacht.
![\[Beispiel für CloudWatch die Anzahl der Aufrufe für jede Variante.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-invocations-target1.png)
### Schritt 3: Beurteilen der Leistung des Modells
Um herauszufinden, welche Modellversion besser abschneidet, bewerten wir für jede Variante die Genauigkeit, die Präzision, den Erinnerungswert, den F1-Wert und die Leistung von Receiver charactersistic/Area unter der Kurve. Betrachten wir zunächst diese Metriken für `Variant1`:
![\[Beispiel für eine Betriebskennlinie des Empfängers für Variant1\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-curve.png)
Betrachten wir nun die Metriken für `Variant2`:
![\[Beispiel für eine Betriebskennlinie des Empfängers für Variant2.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model2-curve.png)
Für die meisten unserer definierten Metriken, ist die Leistung von `Variant2` besser, also ist dies diejenige, die wir in der Produktion verwenden möchten.
### Schritt 4: Erhöhen des Datenverkehrs auf das beste Modell
Nun, da wir festgestellt haben, dass `Variant2` eine bessere Leistung erzielt als `Variant1`, verlagern wir mehr Verkehr darauf. Wir können weiterhin verwenden`TargetVariant`, um eine bestimmte Modellvariante aufzurufen, aber ein einfacherer Ansatz besteht darin, die jeder Variante zugewiesenen Gewichtungen durch einen Aufruf [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)zu aktualisieren. Dadurch wird die Verteilung des Datenverkehrs in Ihre Produktionsvarianten geändert, ohne dass Aktualisierungen des Endpunkts erforderlich sind. Wiedererkennung aus dem Setup-Abschnitt, dass wir Variantengewichtungen festgelegt haben, um den Datenverkehr 50/50 aufzuteilen. Die folgenden CloudWatch Metriken für die Gesamtzahl der Aufrufe für jede Variante zeigen uns die Aufrufmuster für jede Variante:
![\[CloudWatch Beispielmetriken für die Gesamtzahl der Aufrufe für jede Variante.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-invocations-even-dist.png)
Jetzt verlagern wir 75% des Traffics auf, `Variant2` indem wir jeder Variante neue Gewichtungen zuweisen. `UpdateEndpointWeightsAndCapacities` SageMaker KI sendet jetzt 75% der Inferenzanfragen an `Variant2` und die restlichen 25% der Anfragen an. `Variant1`
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 25,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 75,
"VariantName": variant2["VariantName"]
}
]
)
```
Die CloudWatch Kennzahlen für die Gesamtzahl der Aufrufe für jede Variante zeigen uns höhere Aufrufe für als für: `Variant2` `Variant1`
![\[CloudWatch Beispielmetriken für die Gesamtzahl der Aufrufe für jede Variante.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-invocations-75-25.png)
Wir können unsere Metriken weiterhin überwachen, und wenn wir mit der Leistung einer Variante zufrieden sind, können wir 100 % des Datenverkehrs an diese Variante weiterleiten. Wir verwenden [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html), um die Zuweisungen des Datenverkehrs für die Varianten zu aktualisieren. Die Gewichtung für `Variant1` ist auf 0 und die Gewichtung für `Variant2` auf 1 gesetzt. SageMaker KI sendet jetzt 100% aller Inferenzanfragen an`Variant2`.
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 0,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 1,
"VariantName": variant2["VariantName"]
}
]
)
```
Die CloudWatch Metriken für die Gesamtzahl der Aufrufe für jede Variante zeigen, dass alle Inferenzanfragen von verarbeitet werden `Variant2` und dass es keine Inferenzanfragen gibt. `Variant1`
![\[CloudWatch Beispielmetriken für die Gesamtzahl der Aufrufe für jede Variante.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/model-invocations-best-model.png)
Sie können Ihren Endpunkt jetzt sicher aktualisieren und `Variant1` aus Ihrem Endpunkt löschen. Sie können auch mit dem Testen neuer Modelle in der Produktion fortfahren, indem Sie dem Endpunkt neue Varianten hinzufügen und die Schritte 2 – 4 ausführen.
# Testen von Modellen mit Schattenvarianten
Sie können SageMaker AI Model Shadow Deployments verwenden, um Schattenvarianten mit langer Laufzeit zu erstellen, um jede neue Kandidatenkomponente Ihres Model Serving-Stacks zu validieren, bevor Sie sie zur Produktion hochstufen. Das folgende Diagramm zeigt, wie dies im Detail funktioniert.
![\[Details einer Schattenvariante.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/juxtaposer/shadow-variant.png)
## Stellen Sie Schattenvarianten bereit
Das folgende Codebeispiel veranschaulicht, wie Sie eine Schattenvariante programmgesteuert bereitstellen können. Um diese Richtlinie zu verwenden, ersetzen Sie den *kursiv gedruckten Platzhaltertext* in der Beispielrichtlinie durch Ihre eigenen Informationen.
1. Erstellen Sie zwei SageMaker-AI-Modelle: eines für Ihre Produktionsvariante und eines für Ihre Schattenvariante.
```
import boto3
from sagemaker import get_execution_role, Session
aws_region = "aws-region"
boto_session = boto3.Session(region_name=aws_region)
sagemaker_client = boto_session.client("sagemaker")
role = get_execution_role()
bucket = Session(boto_session).default_bucket()
model_name1 = "name-of-your-first-model"
model_name2 = "name-of-your-second-model"
sagemaker_client.create_model(
ModelName = model_name1,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-first-model",
"ModelDataUrl": "s3-location-of-trained-first-model"
}
]
)
sagemaker_client.create_model(
ModelName = model_name2,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-second-model",
"ModelDataUrl": "s3-location-of-trained-second-model"
}
]
)
```
1. Eine Endpunktkonfiguration erstellen. Geben Sie in der Konfiguration sowohl Ihre Produktions- als auch Ihre Schattenvarianten an.
```
endpoint_config_name = name-of-your-endpoint-config
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": name-of-your-production-variant,
"ModelName": model_name1,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
],
ShadowProductionVariants=[
{
"VariantName": name-of-your-shadow-variant,
"ModelName": model_name2,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
]
)
```
1. Endpunkt herstellen.
```
create_endpoint_response = sm.create_endpoint(
EndpointName=name-of-your-endpoint,
EndpointConfigName=endpoint_config_name,
)
```
# Online-Erklärbarkeit mit Clarify SageMaker
Diese Anleitung zeigt, wie Sie die Online-Erklärbarkeit mit Clarify konfigurieren. SageMaker Mit SageMaker [KI-Echtzeit-Inferenzendpunkten](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) können Sie die Erklärbarkeit kontinuierlich in Echtzeit analysieren. Die Online-Erklärbarkeitsfunktion passt in den Teil „Für die **Produktion bereitstellen**“ des [Amazon SageMaker AI Machine Learning Learning-Workflows](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-mlconcepts.html).
## So funktioniert die Verdeutlichung der Online-Erklärbarkeit
Die folgende Grafik zeigt die SageMaker KI-Architektur für das Hosten eines Endpunkts, der Erklärungsanfragen bedient. Sie zeigt Interaktionen zwischen einem Endpunkt, dem Modellcontainer und dem Clarify-Erklärer. SageMaker
![\[SageMaker KI-Architektur, die das Hosten eines Endpunkts zeigt, der Anfragen zur Erläuterung auf Abruf bedient.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/DeveloperGuideArchitecture.png)
So funktioniert die Verdeutlichung der Online-Erklärbarkeit: Die Anwendung sendet eine `InvokeEndpoint` Anfrage im REST-Stil an den SageMaker AI Runtime Service. Der Dienst leitet diese Anfrage an einen SageMaker KI-Endpunkt weiter, um Vorhersagen und Erklärungen zu erhalten. Anschließend erhält der Service die Antwort vom Endpunkt. Schließlich sendet der Service die Antwort an die Anwendung zurück.
Um die Verfügbarkeit der Endgeräte zu erhöhen, versucht SageMaker KI automatisch, Endpunktinstanzen entsprechend der Anzahl der Instanzen in der Endpunktkonfiguration in mehreren Availability Zones zu verteilen. Auf einer Endpunktinstanz ruft der SageMaker Clarify-Erklärer bei einer neuen Anfrage zur Erläuterung den Modellcontainer für Vorhersagen auf. Anschließend werden die Funktionszuordnungen berechnet und zurückgegeben.
Hier sind die vier Schritte, um einen Endpunkt zu erstellen, der die Online-Erklärbarkeit von Clarify verwendet SageMaker :
1. [Prüfen Sie anhand der Schritte zur Vorabprüfung, ob Ihr vorab trainiertes SageMaker KI-Modell mit der Online-Erklärbarkeit kompatibel ist.](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)
1. [Erstellen Sie mithilfe der API eine Endpunktkonfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) mit der SageMaker Clarify-Erklärkonfiguration. `CreateEndpointConfig`
1. [Erstellen Sie einen Endpunkt](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) und stellen Sie SageMaker KI mithilfe der API die Endpunktkonfiguration zur Verfügung. `CreateEndpoint` Der Service startet die ML-Compute-Instance und stellt die Modelle gemäß der Konfiguration bereit.
1. [Rufen Sie den Endpunkt](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) auf: Nachdem der Endpunkt in Betrieb ist, rufen Sie die SageMaker AI Runtime API `InvokeEndpoint` auf, um Anfragen an den Endpunkt zu senden. Der Endpunkt gibt dann Erklärungen und Prognosen zurück.
# Überprüfen Sie den Modellcontainer
In diesem Abschnitt erfahren Sie, wie Sie die Ein- und Ausgaben des Modellcontainers vorab auf Kompatibilität prüfen, bevor Sie einen Endpunkt konfigurieren. Der SageMaker Clarify-Erklärer ist **modellunabhängig**, hat jedoch Anforderungen an die Eingabe und Ausgabe von Modellcontainern.
**Anmerkung**
Sie können die Effizienz steigern, indem Sie Ihren Container so konfigurieren, dass er Batch-Anfragen unterstützt, die zwei oder mehr Datensätze in einer einzigen Anfrage unterstützen. Ein einzelner Datensatz ist beispielsweise eine einzelne Zeile mit CSV-Daten oder eine einzelne Zeile mit JSON-Lines-Daten. SageMaker Clarify versucht zunächst, einen Mini-Batch von Datensätzen an den Modellcontainer zu senden, bevor auf einzelne Datensatzanfragen zurückgegriffen wird.
## Eingabe des Modellcontainers
------
#### [ CSV ]
Der Modellcontainer unterstützt die Eingabe in CSV mit dem MIME-Typ: `text/csv`. Die folgende Tabelle zeigt Beispieleingaben, die SageMaker Clarify unterstützt.
| Eingabe des Modellcontainers (Zeichenkettendarstellung) | Kommentare |
| --- | --- |
| '1,2,3,4' | Einzelner Datensatz, der vier numerische Merkmale verwendet. |
| '1,2,3,4\$1n5,6,7,8' | Zwei Datensätze, getrennt durch einen Zeilenumbruch '\$1n'. |
| '"This is a good product",5' | Einzelner Datensatz, der ein Textmerkmal und ein numerisches Merkmal enthält. |
| ‘"This is a good product",5\$1n"Bad shopping experience",1' | Zwei Datensätze. |
------
#### [ JSON Lines ]
SageMaker AI unterstützt auch Eingaben im [dichten Format JSON Lines](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines) mit dem MIME-Typ:`application/jsonlines`, wie in der folgenden Tabelle dargestellt.
| Eingabe des Modellcontainers | Kommentare |
| --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | Einzelner Datensatz; eine Liste von Merkmalen kann per JMESPath Ausdruck extrahiert werden`data.features`. |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1' | Zwei Datensätze. |
| '\$1"features":["This is a good product",5]\$1' | Einzelner Datensatz; eine Liste von Merkmalen kann durch einen JMESPath Ausdruck extrahiert werden`features`. |
| '\$1"features":["This is a good product",5]\$1\$1n\$1"features":["Bad shopping experience",1]\$1' | Zwei Datensätze. |
------
## Ausgabe des Modellcontainers
Die Ausgabe Ihres Modellcontainers sollte ebenfalls entweder im CSV-Format oder im dichten JSON Lines-Format vorliegen. Darüber hinaus sollte der Modellcontainer die Wahrscheinlichkeiten der Eingabedatensätze enthalten, die SageMaker Clarify zur Berechnung von Feature-Attributionen verwendet.
Die folgenden Datenbeispiele beziehen sich auf Modellcontainer-Ausgaben im **CSV-Format.**
------
#### [ Probability only ]
Bei Regressions- und binären Klassifikationsproblemen gibt der Modellcontainer einen einzelnen Wahrscheinlichkeitswert (Bewertung) für das vorhergesagte Label aus. Diese Wahrscheinlichkeiten können mit dem Spaltenindex 0 extrahiert werden. Bei Problemen mit mehreren Klassen gibt der Modellcontainer eine Liste von Wahrscheinlichkeiten (Bewertungen) aus. Bei Problemen mit mehreren Klassen werden alle Werte extrahiert, wenn kein Index angegeben wird.
| Eingabe des Modellcontainers | Ausgabe des Modellcontainers (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '0.6' |
| Zwei Datensätze (Ergebnisse in einer Zeile) | '0.6,0.3' |
| Zwei Datensätze (Ergebnisse in einer Zeile) | '0.6\$1n0.3' |
| Einzelner Datensatz eines Modells mit mehreren Klassen (drei Klassen) | '0.1,0.6,0.3' |
| Zwei Datensätze eines Modells mit mehreren Klassen (drei Klassen) | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
------
#### [ Predicted label and probabilities ]
Der Modellcontainer gibt das vorhergesagte Label gefolgt von seiner Wahrscheinlichkeit im **CSV**-Format aus. Die Wahrscheinlichkeiten können mit dem Index `1` extrahiert werden.
| Eingabe des Modellcontainers | Ausgabe des Modellcontainers |
| --- | --- |
| Einzelner Datensatz | '1,0.6' |
| Zwei Datensätze | '1,0.6\$1n0,0.3' |
------
#### [ Predicted labels header and probabilities ]
Ein von Autopilot trainierter Modellcontainer mit mehreren Klassen kann so konfiguriert werden, dass er **die Zeichenkettendarstellung** der Liste der vorhergesagten Labels und Wahrscheinlichkeiten im **CSV**-Format ausgibt. Im folgenden Beispiel können die Wahrscheinlichkeiten per Index `1` extrahiert werden. Die Label-Header können per Index `1` extrahiert werden, und sie können mithilfe des Index `0` extrahiert werden.
| Eingabe des Modellcontainers | Ausgabe des Modellcontainers |
| --- | --- |
| Einzelner Datensatz | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"' |
| Zwei Datensätze | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"\$1n"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.2,0.5,0.3]"' |
------
Die folgenden Datenbeispiele beziehen sich auf Modellcontainer-Ausgaben im **JSON Lines-Format.**
------
#### [ Probability only ]
In diesem Beispiel gibt der Modellcontainer die Wahrscheinlichkeit aus, die durch einen [https://jmespath.org/](https://jmespath.org/)-Ausdruck `score` im **JSON Lines-Format** extrahiert werden kann.
| Eingabe des Modellcontainers | Ausgabe des Modellcontainers |
| --- | --- |
| Einzelner Datensatz | '\$1"score":0.6\$1' |
| Zwei Datensätze | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
------
#### [ Predicted label and probabilities ]
In diesem Beispiel gibt ein Modellcontainer mit mehreren Klassen eine Liste von Label-Headern zusammen mit einer Liste von Wahrscheinlichkeiten im **JSON Lines**-Format aus. Die Wahrscheinlichkeiten können durch einen `JMESPath`-Ausdruck `probability` extrahiert werden, und die Label-Header können durch einen `JMESPath`-Ausdruck extrahiert werden `predicted labels`.
| Eingabe des Modellcontainers | Ausgabe des Modellcontainers |
| --- | --- |
| Einzelner Datensatz | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| Zwei Datensätze | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
#### [ Predicted labels header and probabilities ]
In diesem Beispiel gibt ein Modellcontainer mit mehreren Klassen eine Liste von Label-Headern und eine Liste von Wahrscheinlichkeiten im **JSON Lines**-Format aus. Die Wahrscheinlichkeiten können durch einen `JMESPath`-Ausdruck `probability` extrahiert werden, und die Label-Header können durch einen `JMESPath`-Ausdruck extrahiert werden `predicted labels`.
| Eingabe des Modellcontainers | Ausgabe des Modellcontainers |
| --- | --- |
| Einzelner Datensatz | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| Zwei Datensätze | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
## Validierung von Modellcontainern
Wir empfehlen, dass Sie Ihr Modell auf einem SageMaker KI-Echtzeit-Inferenzendpunkt bereitstellen und Anfragen an den Endpunkt senden. Untersuchen Sie die Anfragen (Modellcontainer-Eingaben) und Antworten (Modellcontainer-Ausgaben) manuell, um sicherzustellen, dass beide den Anforderungen in den Abschnitten **Modellcontainer-Eingabe** und **Modellcontainer-Ausgabe** entsprechen. Wenn Ihr Modellcontainer Batch-Anfragen unterstützt, können Sie mit einer einzelnen Datensatzanforderung beginnen und dann zwei oder mehr Datensätze ausprobieren.
Die folgenden Befehle veranschaulichen das Anfordern einer Antwort mit AWS CLI. Das AWS CLI ist in SageMaker Studio Classic- und SageMaker Notebook-Instanzen vorinstalliert. Wenn Sie das installieren müssen AWS CLI, folgen Sie dieser [Installationsanleitung](https://aws.amazon.com/cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Die Parameter sind wie folgt definiert:
+ `$ENDPOINT NAME`: Der Name des Endpunkts.
+ `$CONTENT_TYPE`: Der MIME-Typ der Anfrage (Eingabe des Modellcontainers).
+ `$ACCEPT_TYPE`: Der MIME-Typ der Antwort (Ausgabe des Modellcontainers).
+ `$REQUEST_DATA`: Die angeforderte Payload-Zeichenfolge.
+ `$CLI_BINARY_FORMAT`: Das Format des Parameters der Befehlszeilenschnittstelle (CLI). Für AWS CLI Version 1 sollte dieser Parameter leer bleiben. Für v2 sollte dieser Parameter auf `--cli-binary-format raw-in-base64-out` gesetzt werden.
**Anmerkung**
AWS CLI [v2 übergibt standardmäßig binäre Parameter als Base64-kodierte Zeichenketten.](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
In den folgenden Beispielen wird v1 verwendet: AWS CLI
------
#### [ Request and response in CSV format ]
+ Die Anfrage besteht aus einem einzigen Datensatz und die Antwort ist deren Wahrscheinlichkeitswert.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`0.6`
+ Die Anfrage besteht aus zwei Datensätzen, die Antwort beinhaltet deren Wahrscheinlichkeiten, und das Modell trennt die Wahrscheinlichkeiten durch ein Komma. Der `$'content'`-Ausdruck im `--body` weist den Befehl an, `\n` im Inhalt als Zeilenumbruch zu interpretieren.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`0.6,0.3`
+ Die Anfrage besteht aus zwei Datensätzen, die Antwort beinhaltet deren Wahrscheinlichkeiten, und das Modell trennt die Wahrscheinlichkeiten durch einen Zeilenumbruch.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`0.6`
`0.3`
+ Die Anfrage besteht aus einem einzigen Datensatz, und die Antwort besteht aus Wahrscheinlichkeitswerten (Mehrklassenmodell, drei Klassen).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`0.1,0.6,0.3`
+ Die Anfrage besteht aus zwei Datensätzen, und die Antwort besteht aus Wahrscheinlichkeitswerten (Mehrklassenmodell, drei Klassen).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`0.1,0.6,0.3`
`0.2,0.5,0.3`
+ Die Anfrage besteht aus zwei Datensätzen, und die Antwort umfasst das vorhergesagte Label und die Wahrscheinlichkeit.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`1,0.6`
`0,0.3`
+ Die Anfrage besteht aus zwei Datensätzen, und die Antwort umfasst Label-Header und Wahrscheinlichkeiten.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`"['cat','dog','fish']","[0.1,0.6,0.3]"`
`"['cat','dog','fish']","[0.2,0.5,0.3]"`
------
#### [ Request and response in JSON Lines format ]
+ Die Anfrage besteht aus einem einzigen Datensatz und die Antwort ist deren Wahrscheinlichkeitswert.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`{"score":0.6}`
+ Die Anfrage enthält zwei Datensätze, und die Antwort umfasst das vorhergesagte Label und die Wahrscheinlichkeit.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`{"predicted_label":1,"probability":0.6}`
`{"predicted_label":0,"probability":0.3}`
+ Die Anfrage enthält zwei Datensätze, und die Antwort umfasst Label-Header und Wahrscheinlichkeiten.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}`
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}`
------
#### [ Request and response in different formats ]
+ Die Anfrage ist im CSV-Format und die Antwort ist im JSON Lines-Format:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`{"probability":0.6}`
`{"probability":0.3}`
+ Die Anfrage ist im JSON Lines-Format und die Antwort ist im CSV-Format:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Ausgabe:
`0.6`
`0.3`
------
Nachdem die Validierungen abgeschlossen sind, [löschen](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html) Sie den Testendpunkt.
# Einen Endpunkt konfigurieren und erstellen
Erstellen Sie eine neue Endpunktkonfiguration, die zu Ihrem Modell passt, und verwenden Sie diese Konfiguration, um den Endpunkt zu erstellen. Sie können den im [Schritt der Vorabprüfung](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html) validierten Modellcontainer verwenden, um einen Endpunkt zu erstellen und die Online-Erklärbarkeitsfunktion SageMaker Clarify zu aktivieren.
Verwenden Sie das `sagemaker_client` Objekt, um mithilfe der API einen Endpunkt zu erstellen. [CreateEndpointConfig](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateEndpointConfig.html) Stellen Sie das Mitglied `ClarifyExplainerConfig` innerhalb des `ExplainerConfig`-Parameters wie folgt ein:
```
sagemaker_client.create_endpoint_config(
EndpointConfigName='name-of-your-endpoint-config',
ExplainerConfig={
'ClarifyExplainerConfig': {
'EnableExplanations': '`true`',
'InferenceConfig': {
...
},
'ShapConfig': {
...
}
},
},
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': 'name-of-your-model',
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}]
...
)
sagemaker_client.create_endpoint(
EndpointName='name-of-your-endpoint',
EndpointConfigName='name-of-your-endpoint-config'
)
```
Beim ersten Aufruf des `sagemaker_client`-Objekts wird eine neue Endpunktkonfiguration mit aktivierter Erklärbarkeitsfunktion erstellt. Der zweite Aufruf verwendet die Endpunktkonfiguration, um den Endpunkt zu starten.
**Anmerkung**
Sie können auch mehrere Modelle in einem Container hinter einem [SageMaker KI-Echtzeit-Inferenz-Endpunkt mit mehreren Modellen](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) hosten und die Online-Erklärbarkeit mit Clarify konfigurieren. SageMaker
# Der Ausdruck `EnableExplanations`
Der `EnableExplanations`-Parameter ist eine [https://jmespath.org/](https://jmespath.org/) boolesche Ausdruckszeichenfolge. Sie wird für **jeden Datensatz** in der Erklärbarkeitsanfrage ausgewertet. Wenn dieser Parameter als **wahr** bewertet wird, wird der Datensatz erklärt. Wenn dieser Parameter als **falsch** bewertet wird, werden keine Erklärungen generiert.
SageMaker Clarify deserialisiert die Ausgabe des Modellcontainers für jeden Datensatz in eine JSON-kompatible Datenstruktur und verwendet dann den Parameter, um die Daten auszuwerten. `EnableExplanations`
**Hinweise**
Je nach Format der Modellcontainer-Ausgabe gibt es zwei Optionen für Datensätze.
Wenn die Ausgabe des Modellcontainers im CSV-Format vorliegt, wird ein Datensatz als JSON-Array geladen.
Wenn die Ausgabe des Modellcontainers im JSON Lines-Format vorliegt, wird ein Datensatz als JSON-Objekt geladen.
Der `EnableExplanations` Parameter ist ein JMESPath Ausdruck, der entweder während der Oder-Operationen übergeben werden kann. `InvokeEndpoint` `CreateEndpointConfig` Wenn der von Ihnen angegebene JMESPath Ausdruck nicht gültig ist, schlägt die Endpunkterstellung fehl. Wenn der Ausdruck gültig ist, das Ergebnis der Ausdrucksauswertung jedoch unerwartet ist, wird der Endpunkt erfolgreich erstellt, aber beim Aufrufen des Endpunkts wird ein Fehler generiert. Testen Sie Ihren `EnableExplanations`-Ausdruck mithilfe der `InvokeEndpoint`-API und wenden Sie ihn dann auf die Endpunktkonfiguration an.
Im Folgenden finden Sie einige Beispiele für gültige `EnableExplanations`-Ausdrücke. In den Beispielen umschließt ein JMESPath Ausdruck ein Literal mit Backtick-Zeichen. Zum Beispiel bedeutet ``true`` „wahr“.
| Ausdruck (Zeichenkettendarstellung) | Ausgabe des Modellcontainers (Zeichenkettendarstellung) | Ergebnis der Auswertung (Boolean) | Bedeutung |
| --- | --- | --- | --- |
| '`true`' | – | Wahr | Aktivieren Sie die Online-Erklärbarkeit bedingungslos. |
| '`false`' | – | Falsch | Deaktivieren Sie die Online-Erklärbarkeit bedingungslos. |
| '[1]>`0.5`' | '1,0.6' | Wahr | Für jeden Datensatz gibt der Modellcontainer das vorhergesagte Label und die Wahrscheinlichkeit aus. Erklärt einen Datensatz, wenn seine Wahrscheinlichkeit (bei Index 1) größer als 0,5 ist. |
| 'probability>`0.5`' | '\$1"predicted\$1label":1,"probability":0.6\$1' | Wahr | Für jeden Datensatz gibt der Modellcontainer JSON-Daten aus. Erklären Sie einen Datensatz, wenn seine Wahrscheinlichkeit größer als 0,5 ist. |
| '\$1contains(probabilities[:-1], max(probabilities))' | '\$1"probabilities": [0.4, 0.1, 0.4], "labels":["cat","dog","fish"]\$1' | Falsch | Für ein Modell mit mehreren Klassen: Erklärt einen Datensatz, ob sein vorhergesagtes Label (die Klasse mit dem höchsten Wahrscheinlichkeitswert) die letzte Klasse ist. Wörtlich bedeutet der Ausdruck, dass der Wert für die maximale Wahrscheinlichkeit nicht in der Liste der Wahrscheinlichkeiten mit Ausnahme der letzten steht. |
# Synthetischer Datensatz
SageMaker Clarify verwendet den Kernel-SHAP-Algorithmus. Anhand eines Datensatzes (auch als Beispiel oder Instanz bezeichnet) und der SHAP-Konfiguration generiert der Explainer zunächst einen synthetischen Datensatz. SageMaker Clarify fragt dann den Modellcontainer nach den Vorhersagen des Datensatzes ab und berechnet dann die Feature-Attributionen und gibt sie zurück. Die Größe des synthetischen Datensatzes wirkt sich auf die Laufzeit des Clarify-Erklärers aus. Größere synthetische Datensätze benötigen mehr Zeit, um Modellvorhersagen zu erhalten als kleinere.
Die Größe des synthetischen Datensatzes wird durch die folgende Formel bestimmt:
```
Synthetic dataset size = SHAP baseline size * n_samples
```
Die SHAP-Basisgröße ist die Anzahl der Datensätze in den SHAP-Basisdaten. Diese Informationen stammen aus dem `ShapBaselineConfig`.
Die Größe von `n_samples` wird durch den Parameter `NumberOfSamples` in der Erklärkonfiguration und die Anzahl der Funktionen festgelegt. Wenn die Anzahl der Features `n_features` ist, dann ist `n_samples` wie folgt:
```
n_samples = MIN(NumberOfSamples, 2^n_features - 2)
```
Im Folgenden wird `n_samples` gezeigt, wenn `NumberOfSamples` nicht vorhanden ist.
```
n_samples = MIN(2*n_features + 2^11, 2^n_features - 2)
```
Beispielsweise hat ein tabellarischer Datensatz mit 10 Features eine SHAP-Basisliniengröße von 1. Wenn `NumberOfSamples` nicht angegeben ist, enthält der synthetische Datensatz 1022 Datensätze. Wenn der Datensatz 20 Features enthält, hat der synthetische Datensatz 2088 Datensätze.
Bei NLP-Problemen entspricht `n_features` der Anzahl der Nicht-Text-Features plus der Anzahl der Texteinheiten.
**Anmerkung**
Die `InvokeEndpoint`-API hat ein Zeitlimit für Anfragen. Wenn der synthetische Datensatz zu groß ist, kann der Erklärer die Berechnung möglicherweise nicht innerhalb dieser Grenze abschließen. Verwenden Sie gegebenenfalls die vorherigen Informationen, um die Größe der SHAP-Basislinie und `NumberOfSamples` zu verstehen und diese zu reduzieren. Wenn Ihr Modellcontainer für die Verarbeitung von Batch-Anfragen eingerichtet ist, können Sie auch den Wert von `MaxRecordCount` anpassen.
# Rufen Sie den Endpunkt auf
Nachdem der Endpunkt ausgeführt wurde, verwenden Sie die SageMaker AI [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)Runtime-API im SageMaker AI Runtime-Dienst, um Anfragen an den Endpunkt zu senden oder ihn aufzurufen. Als Antwort darauf werden die Anfragen vom Clarify-Erklärer als Erklärungsanfragen behandelt. SageMaker
**Anmerkung**
Wählen Sie eine der folgenden Optionen aus, um einen Endpunkt aufzurufen:
Anweisungen zur Verwendung von Boto3 oder zum Aufrufen eines Endpunkts finden AWS CLI Sie unter. [Aufrufen von Modellen für Echtzeit-Inferenz](realtime-endpoints-test-endpoints.md)
Informationen zum Aufrufen eines Endpunkts mit dem SageMaker SDK für Python finden Sie in der [Predictor-API](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html).
## Anforderung
Die `InvokeEndpoint`-API hat einen optionalen Parameter `EnableExplanations`, der dem HTTP-Header zugeordnet `X-Amzn-SageMaker-Enable-Explanations` ist. Wenn dieser Parameter angegeben wird, überschreibt er den `EnableExplanations`-Parameter von `ClarifyExplainerConfig`.
**Anmerkung**
Die Parameter `ContentType` und `Accept` der `InvokeEndpoint`-API sind erforderlich. Zu den unterstützten Formaten gehören MIME-Typ `text/csv` und `application/jsonlines`.
Verwenden Sie den `sagemaker_runtime_client`, um wie folgt eine Anfrage an den Endpunkt zu senden:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName='name-of-your-endpoint',
EnableExplanations='`true`',
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4', # single record (of four numerical features)
)
```
Bei Endpunkten mit mehreren Modellen übergeben Sie in der vorherigen Beispielanforderung einen zusätzlichen `TargetModel` Parameter, der angibt, auf welches Modell der Endpunkt ausgerichtet werden soll. Der Multimodell-Endpunkt lädt Zielmodelle nach Bedarf dynamisch. Weitere Informationen Multimodell-Endpunkten finden Sie unter [Multimodell-Endpunkte](multi-model-endpoints.md). Im [Beispielnotizbuch SageMaker Clarify Online Explainability on Multi-Model Endpoint](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular_multi_model_endpoint/multi_model_xgboost_with_online_explainability.ipynb) finden Sie ein Beispiel dafür, wie Sie mehrere Zielmodelle von einem einzigen Endpunkt aus einrichten und aufrufen können.
## Antwort
Wenn der Endpunkt mit `ExplainerConfig` erstellt wird, wird ein neues Antwortschema verwendet. Dieses neue Schema unterscheidet sich von einem Endpunkt, für den der angegebene `ExplainerConfig`-Parameter fehlt und nicht mit diesem kompatibel ist.
Der MIME-Typ der Antwort ist `application/json`, und die Antwortnutzlast kann von UTF-8-Bytes in ein JSON-Objekt dekodiert werden. Im Folgenden werden die Mitglieder dieses JSON-Objekts wie folgt dargestellt:
+ `version`: Die Version des Antwortschemas im Zeichenfolgeformat. Beispiel, `1.0`.
+ `predictions`: Die Vorhersagen, die die Anfrage macht, haben folgende Eigenschaften:
+ `content_type`: Der MIME-Typ der Vorhersagen, der sich auf die Antwort `ContentType` des Modellcontainers bezieht.
+ `data`: Die Datenzeichenfolge mit den Vorhersagen, die als Nutzlast der Antwort des Modellcontainers für die Anfrage geliefert wurde.
+ `label_headers`: Die Label-Header des `LabelHeaders`-Parameters. Dies wird entweder in der Erklärkonfiguration oder in der Ausgabe des Modellcontainers bereitgestellt.
+ `explanations`: Die Erläuterungen finden Sie in der Anforderungsnutzlast. Wenn keine Datensätze erklärt werden, gibt dieses Mitglied das leere Objekt `{}` zurück.
+
+ `kernel_shap`: Ein Schlüssel, der sich auf ein Array von Kernel-SHAP-Erklärungen für jeden Datensatz in der Anfrage bezieht. Wenn ein Datensatz nicht erklärt wird, ist die entsprechende Erklärung `null`.
Das `kernel_shap`-Element hat die folgenden Mitglieder:
+ `feature_header`: Der Header-Name der Funktionen, die durch den `FeatureHeaders`-Parameter in der Erklärkonfiguration `ExplainerConfig` bereitgestellt werden.
+ `feature_type`: Der Feature-Typ, der vom Erklärer abgeleitet oder im `FeatureTypes`-Parameter in der `ExplainerConfig` angegeben wurde. Dieses Element ist nur für NLP-Erklärbarkeitsprobleme verfügbar.
+ `attributions`: Eine Reihe von Zuordnungsobjekten. Textmerkmale können mehrere Zuordnungsobjekte haben, jedes für eine Einheit. Das Zuordnungsobjekt hat die folgenden Mitglieder:
+ `attribution`: Eine Liste von Wahrscheinlichkeitswerten, die für jede Klasse angegeben ist.
+ `description`: Die Beschreibung der Texteinheiten, nur für NLP-Erklärbarkeitsprobleme verfügbar.
+ `partial_text`: Der Teil des Textes, der vom Erklärer erklärt wurde.
+ `start_idx`: Ein auf Null basierender Index zur Identifizierung der Array-Position am Anfang des partiellen Textfragments.
# Codebeispiele: SDK für Python
Dieser Abschnitt enthält Beispielcode zum Erstellen und Aufrufen eines Endpunkts, der die Online-Erklärbarkeit von Clarify verwendet. SageMaker Diese Codebeispiele verwenden das [AWS SDK für Python.](https://aws.amazon.com/sdk-for-python/)
## Tabellendaten
Das folgende Beispiel verwendet tabellarische Daten und ein SageMaker KI-Modell namens. `model_name` In diesem Beispiel akzeptiert der Modellcontainer Daten im CSV-Format, und jeder Datensatz hat vier numerische Merkmale. In dieser Minimalkonfiguration sind die SHAP-Basisdaten **nur zu Demonstrationszwecken** auf Null gesetzt. Weitere Informationen zur Auswahl geeigneterer Werte für `ShapBaseline` finden Sie unter [SHAP-Baselines zur Erläuterbarkeit](clarify-feature-attribute-shap-baselines.md).
Konfigurieren Sie den Endpunkt wie folgt:
```
endpoint_config_name = 'tabular_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '0,0,0,0',
},
},
},
},
)
```
Verwenden Sie die Endpunktkonfiguration, um einen Endpunkt wie folgt zu erstellen:
```
endpoint_name = 'tabular_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
Verwenden Sie die `DescribeEndpoint`-API, um den Fortschritt bei der Erstellung eines Endpunkts wie folgt zu überprüfen:
```
response = sagemaker_client.describe_endpoint(
EndpointName=endpoint_name,
)
response['EndpointStatus']
```
Wenn der Endpunktstatus "InService" lautet, rufen Sie den Endpunkt mit einem Testdatensatz wie folgt auf:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
)
```
**Anmerkung**
Im vorherigen Codebeispiel übergeben Sie bei Multimodell-Endpunkten einen zusätzlichen `TargetModel`-Parameter in der Anfrage, um anzugeben, auf welches Modell der Endpunkt ausgerichtet werden soll.
Gehen Sie davon aus, dass die Antwort den Statuscode 200 (kein Fehler) hat, und laden Sie den Antworttext wie folgt:
```
import codecs
import json
json.load(codecs.getreader('utf-8')(response['Body']))
```
Die Standardaktion für den Endpunkt besteht darin, den Datensatz zu erklären. Im Folgenden wird die Beispielausgabe im zurückgegebenen JSON-Objekt gezeigt.
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.0006380207487381"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [-0.00433456]
}
]
},
{
"attributions": [
{
"attribution": [-0.005369821]
}
]
},
{
"attributions": [
{
"attribution": [0.007917749]
}
]
},
{
"attributions": [
{
"attribution": [-0.00261214]
}
]
}
]
]
}
}
```
Verwenden Sie den `EnableExplanations`-Parameter, um Erklärungen auf Abruf wie folgt zu aktivieren:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
EnableExplanations='[0]>`0.8`',
)
```
**Anmerkung**
Im vorherigen Codebeispiel übergeben Sie bei Multimodell-Endpunkten einen zusätzlichen `TargetModel`-Parameter in der Anfrage, um anzugeben, auf welches Modell der Endpunkt ausgerichtet werden soll.
In diesem Beispiel ist der Prognosewert kleiner als der Schwellenwert von `0.8`, sodass der Datensatz nicht erklärt wird:
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.6380207487381995"
},
"explanations": {}
}
```
Verwenden Sie Visualisierungstools, um die zurückgegebenen Erklärungen zu interpretieren. Die folgende Abbildung zeigt, wie SHAP-Diagramme verwendet werden können, um zu verstehen, wie jedes Merkmal zur Vorhersage beiträgt. Der Basiswert im Diagramm, auch Erwartungswert genannt, ist der Mittelwert der Vorhersagen des Trainingsdatensatzes. Features, die den Erwartungswert nach oben treiben, sind rot und Features, die den Erwartungswert nach unten drücken, sind blau. Weitere Informationen finden Sie unter [SHAP-Layout für additive Kräfte](https://shap.readthedocs.io/en/latest/generated/shap.plots.force.html).
![\[Beispiel-SHAP-Diagramm, das verwendet werden kann, um zu verstehen, wie jedes Merkmal zur Vorhersage beiträgt\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/force-plot.png)
Siehe [Vollständiges Beispiel-Notebook für Tabellendaten](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular/tabular_online_explainability_with_sagemaker_clarify.ipynb).
## Textdaten
Dieser Abschnitt enthält ein Codebeispiel zum Erstellen und Aufrufen eines Online-Erklärbarkeitsendpunkts für Textdaten. Das Codebeispiel verwendet SDK für Python.
Das folgende Beispiel verwendet Textdaten und ein SageMaker KI-Modell namens`model_name`. In diesem Beispiel akzeptiert der Modellcontainer Daten im CSV-Format, und jeder Datensatz ist eine einfache Zeichenfolge.
```
endpoint_config_name = 'text_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'InferenceConfig': {
'FeatureTypes': ['text'],
'MaxRecordCount': 100,
},
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '""',
},
'TextConfig': {
'Granularity': 'token',
'Language': 'en',
},
'NumberOfSamples': 100,
},
},
},
)
```
+ `ShapBaseline`: Ein spezielles Token, das für die natürliche Sprachverarbeitung (NLP) reserviert ist.
+ `FeatureTypes`: Identifiziert das Feature als Text. Wenn dieser Parameter nicht angegeben wird, versucht der Erklärer, den Feature-Typ abzuleiten.
+ `TextConfig`: Gibt die Granularitätseinheit und die Sprache für die Analyse von Textmerkmalen an. In diesem Beispiel ist die Sprache Englisch, und Granularität `token` bedeutet ein Wort im englischen Text.
+ `NumberOfSamples`: Ein Limit für die Festlegung der Obergrenzen der Größe des synthetischen Datensatzes.
+ `MaxRecordCount`: Die maximale Anzahl von Datensätzen in einer Anfrage, die der Modellcontainer verarbeiten kann. Dieser Parameter dient der Leistungsstabilisierung.
Verwenden Sie die Endpunktkonfiguration, um den Endpunkt wie folgt zu erstellen:
```
endpoint_name = 'text_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
Nachdem der Status des Endpunkts auf `InService` gesetzt wurde, rufen Sie den Endpunkt auf. Im folgenden Codebeispiel wird ein Testdatensatz wie folgt verwendet:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='"This is a good product"',
)
```
Wenn die Anfrage erfolgreich abgeschlossen wurde, gibt der Antworttext ein gültiges JSON-Objekt zurück, das dem Folgenden ähnelt:
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv",
"data": "0.9766594\n"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [
-0.007270948666666712
],
"description": {
"partial_text": "This",
"start_idx": 0
}
},
{
"attribution": [
-0.018199033666666628
],
"description": {
"partial_text": "is",
"start_idx": 5
}
},
{
"attribution": [
0.01970993241666666
],
"description": {
"partial_text": "a",
"start_idx": 8
}
},
{
"attribution": [
0.1253469515833334
],
"description": {
"partial_text": "good",
"start_idx": 10
}
},
{
"attribution": [
0.03291143366666657
],
"description": {
"partial_text": "product",
"start_idx": 15
}
}
],
"feature_type": "text"
}
]
]
}
}
```
Verwenden Sie Visualisierungstools, um die zurückgegebenen Textzuordnungen zu interpretieren. Die folgende Abbildung zeigt, wie das captum Visualisierungsdienstprogramm verwendet werden kann, um zu verstehen, wie jedes Wort zur Vorhersage beiträgt. Je höher die Farbsättigung, desto höher die Bedeutung, die dem Wort beigemessen wird. In diesem Beispiel deutet eine stark gesättigte hellrote Farbe auf einen starken negativen Beitrag hin. Eine stark gesättigte grüne Farbe weist auf einen starken positiven Beitrag hin. Die Farbe Weiß zeigt an, dass das Wort einen neutralen Beitrag leistet. Weitere Informationen zum Parsen und Rendern der Zuordnungen finden Sie in der [Captum](https://github.com/pytorch/captum)-Bibliothek.
![\[Das captum Visualisierungsdienstprogramm wird verwendet, um zu verstehen, wie jedes Wort zur Vorhersage beiträgt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/word-importance.png)
Siehe [Vollständiges Beispiel-Notebook für Textdaten](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/natural_language_processing/nlp_online_explainability_with_sagemaker_clarify.ipynb).
# Anleitung zur Fehlerbehebung
Wenn Sie bei der Verwendung von SageMaker Clarify online Explainability auf Fehler stoßen, lesen Sie die Themen in diesem Abschnitt.
**`InvokeEndpoint`Die API schlägt mit dem Fehler „:Read ReadTimeoutError timeout on endpoint...“ fehl**
Dieser Fehler bedeutet, dass die Anfrage nicht innerhalb der durch das [Zeitbeschränkung für die Anforderung](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) festgelegten Frist von 60 Sekunden abgeschlossen werden konnte.
Um die Anforderungslatenz zu verringern, führen Sie die folgenden Schritte aus:
+ Passen Sie die Leistung des Modells während der Inferenz an. SageMaker AI [Neo](https://aws.amazon.com/sagemaker/neo/) kann beispielsweise Modelle für Inferenz optimieren.
+ Erlauben Sie dem Modellcontainer, Batch-Anfragen zu verarbeiten.
+ Verwenden Sie einen größeren `MaxRecordCount`-Wert, um die Anzahl der Aufrufe vom Erklärer zum Modellcontainer zu reduzieren. Dadurch werden die Netzwerklatenz und der Overhead reduziert.
+ Verwenden Sie einen Instance-Typ, dem mehr Ressourcen zugewiesen sind. Weisen Sie dem Endpunkt alternativ mehr Instances zu, um die Last besser verteilen zu können.
+ Reduzieren Sie die Anzahl der Datensätze in einer einzelnen `InvokeEndpoint`-Anfrage.
+ Reduzieren Sie die Anzahl der Datensätze in den Basisdaten.
+ Verwenden Sie einen kleineren `NumberOfSamples`-Wert, um die Größe des synthetischen Datensatzes zu reduzieren. Weitere Informationen dazu, wie sich die Anzahl der Proben auf Ihren synthetischen Datensatz auswirkt, finden Sie unter [Synthetischer Datensatz](clarify-online-explainability-create-endpoint-synthetic.md).
# Optimierung von Modellen mit Adapter-Inferenzkomponenten
Mit Amazon SageMaker AI können Sie vortrainierte Basismodelle hosten, ohne Ihre eigenen Modelle von Grund auf neu erstellen zu müssen. Um jedoch ein universelles Basismodell auf die individuellen Bedürfnisse Ihres Unternehmens zuzuschneiden, müssen Sie eine optimierte Version davon erstellen. Eine kosteneffiziente Optimierungstechnik ist die Low-Rank Adaptation (LoRA). Das Prinzip hinter LoRA ist, dass nur ein kleiner Teil eines großen Basismodells aktualisiert werden muss, um es an neue Aufgaben oder Domains anzupassen. Ein LoRA-Adapter erweitert die Inferenz aus einem Basismodell mit nur wenigen zusätzlichen Adapterschichten.
*Wenn Sie Ihr Basismodell mithilfe einer SageMaker KI-Inferenzkomponente hosten, können Sie dieses Basismodell mit LoRa-Adaptern verfeinern, indem Sie Adapter-Inferenzkomponenten erstellen.* Beim Erstellen einer Adapter-Inferenzkomponente geben Sie Folgendes an:
+ Die *Basis-Inferenzkomponente*, die die Adapter-Inferenzkomponente enthalten soll. Die Basis-Inferenzkomponente enthält das Basismodell, das Sie anpassen möchten. Die Adapter-Inferenzkomponente verwendet die Rechenressourcen, die Sie der Basis-Inferenzkomponente zugewiesen haben.
+ Der Speicherort, an dem Sie den LoRA-Adapter in Amazon S3 gespeichert haben.
Nachdem Sie die Adapter-Inferenzkomponente erstellt haben, können Sie sie direkt aufrufen. Wenn Sie dies tun, kombiniert SageMaker AI den Adapter mit dem Basismodell, um die generierte Antwort zu verbessern.
**Bevor Sie beginnen**
Bevor Sie eine Adapter-Inferenzkomponente erstellen können, müssen Sie die folgenden Voraussetzungen erfüllen:
+ Sie haben eine Basis-Inferenzkomponente, die das anzupassende Basismodell enthält. Sie haben diese Inferenzkomponente auf einem SageMaker KI-Endpunkt bereitgestellt.
Weitere Informationen zum Bereitstellen von Inferenzkomponenten auf Endpunkten finden Sie unter [Modelle für Echtzeit-Inferenzen bereitstellen](realtime-endpoints-deploy-models.md).
+ Sie haben ein LoRA-Adaptermodell und Sie haben die Modellartefakte als `tar.gz`-Datei in Amazon S3 gespeichert. Sie geben den S3-URI der Artefakte an, wenn Sie die Adapter-Inferenzkomponente erstellen.
Die folgenden Beispiele verwenden den SDK for Python (Boto3), um eine Adapter-Inferenzkomponente zu erstellen und aufzurufen.
**Example Aufruf von `create_inference_component` zum Erstellen einer Adapter-Inferenzkomponente**
Im folgenden Beispiel wird eine Adapter-Inferenzkomponente erstellt und einer Basis-Inferenzkomponente zugewiesen:
```
sm_client.create_inference_component(
InferenceComponentName = adapter_ic_name,
EndpointName = endpoint_name,
Specification={
"BaseInferenceComponentName": base_inference_component_name,
"Container": {
"ArtifactUrl": adapter_s3_uri
},
},
)
```
Wenn Sie dieses Beispiel in Ihrem eigenen Code verwenden, ersetzen Sie die Platzhalterwerte wie folgt:
+ *adapter\$1ic\$1name*— Ein eindeutiger Name für Ihre Adapter-Inferenzkomponente.
+ *endpoint\$1name*— Der Name des Endpunkts, der die Basis-Inferenzkomponente hostet.
+ *base\$1inference\$1component\$1name*— Der Name der Basisinferenzkomponente, die das zu adaptierende Basismodell enthält.
+ *adapter\$1s3\$1uri*— Der S3-URI, der die `tar.gz` Datei mit Ihren LoRa-Adapter-Artefakten findet.
Sie erstellen eine Adapter-Inferenzkomponente mit Code, der dem Code für eine normale Inferenzkomponente ähnelt. Ein Unterschied besteht darin, dass Sie für den `Specification`-Parameter den Schlüssel `ComputeResourceRequirements` weglassen. Wenn Sie eine Adapter-Inferenzkomponente aufrufen, wird sie von der Basis-Inferenzkomponente geladen. Die Adapter-Inferenzkomponente verwendet die Rechenressourcen der Basis-Inferenzkomponente.
Weitere Informationen zum Erstellen und Bereitstellen von Inferenzkomponenten mit dem SDK für Python (Boto3) finden Sie unter [Modelle mit Python bereitstellen SDKs](realtime-endpoints-deploy-models.md#deploy-models-python).
Nachdem Sie eine Adapter-Inferenzkomponente erstellt haben, rufen Sie sie auf, indem Sie ihren Namen in einer `invoke_endpoint`-Anfrage angeben.
**Example Aufruf von `invoke_endpoint` zum Aufrufen einer Adapter-Inferenzkomponente**
Im folgenden Beispiel wird eine Adapter-Inferenzkomponente aufgerufen:
```
response = sm_rt_client.invoke_endpoint(
EndpointName = endpoint_name,
InferenceComponentName = adapter_ic_name,
Body = json.dumps(
{
"inputs": prompt,
"parameters": {"max_new_tokens": 100, "temperature":0.9}
}
),
ContentType = "application/json",
)
adapter_reponse = response["Body"].read().decode("utf8")["generated_text"]
```
Wenn Sie dieses Beispiel in Ihrem eigenen Code verwenden, ersetzen Sie die Platzhalterwerte wie folgt:
+ *endpoint\$1name*— Der Name des Endpunkts, der die Basis- und Adapter-Inferenzkomponenten hostet.
+ *adapter\$1ic\$1name*— Der Name der Adapter-Inferenzkomponente.
+ *prompt*— Die Aufforderung zur Eingabe der Inferenzanforderung.
Weitere Informationen zum Aufrufen von Inferenzkomponenten mit dem SDK für Python (Boto3) finden Sie unter [Aufrufen von Modellen für Echtzeit-Inferenz](realtime-endpoints-test-endpoints.md).
# Bereitstellen von Modellen mit Amazon SageMaker Serverless Inference
Amazon SageMaker Serverless Inference ist eine speziell entwickelte Inferenzoption, mit der Sie ML-Modelle bereitstellen und skalieren können, ohne die zugrunde liegende Infrastruktur konfigurieren oder verwalten zu müssen. Serverless Inference auf Abruf ist ideal für Workloads, bei denen es zwischen den einzelnen Datenverkehrsspitzen Leerlaufzeiten gibt und die Kaltstarts tolerieren können. Serverless Endpunkte starten automatisch Rechenressourcen und skalieren sie je nach Datenverkehr ein- und auswärts, sodass Sie keine Instance-Typen auswählen oder Skalierungsrichtlinien verwalten müssen. Dadurch entfällt die undifferenzierte Schwerstarbeit bei der Auswahl und Verwaltung von Servern. Serverless Inference lässt sich mit AWS Lambda integrieren und bietet Ihnen Hochverfügbarkeit, integrierte Fehlertoleranz und automatische Skalierung. Mit einem pay-per-use Modell ist Serverless Inference eine kostengünstige Option, wenn Sie ein seltenes oder unvorhersehbares Datenverkehrsmuster haben. In Zeiten, in denen keine Anfragen vorliegen, skaliert Serverless Inference Ihren Endpunkt auf 0 herunter und hilft Ihnen so, Ihre Kosten zu minimieren. Weitere Informationen zu den Preisen für serverlose On-Demand-Inferenz finden Sie unter [ SageMaker Amazon-Preise](https://aws.amazon.com/sagemaker/pricing/).
Optional können Sie auch Provisioned Concurrency mit Serverless Inference verwenden. Serverlose Inferenz mit bereitgestellter Parallelität ist eine kostengünstige Option, wenn Sie vorhersehbare Datenverkehrsspitzen haben. Mit Provisioned Concurrency können Sie Modelle auf serverlosen Endpunkten mit vorhersehbarer Leistung und hoher Skalierbarkeit bereitstellen, indem Ihre Endgeräte warm gehalten werden. SageMaker KI stellt sicher, dass für die Anzahl von Provisioned Concurrency, die Sie zuweisen, die Rechenressourcen initialisiert werden und innerhalb von Millisekunden bereit sind, zu reagieren. Bei Serverless Inference with Provisioned Concurrency zahlen Sie für die Rechenkapazität, die zur Verarbeitung von Inferenzanfragen verwendet wird, die pro Millisekunde abgerechnet wird, und für die Menge der verarbeiteten Daten. Sie zahlen auch für die Nutzung von Provisioned Concurrency auf der Grundlage des konfigurierten Speichers, der Bereitstellungsdauer und der Anzahl der aktivierten Parallelität. [Weitere Informationen zu den Preisen für Serverless Inference with Provisioned Concurrency finden Sie unter Amazon-Preise. SageMaker ](https://aws.amazon.com/sagemaker/pricing/)
[Sie können Serverless Inference in Ihre MLOps Pipelines integrieren, um Ihren ML-Workflow zu optimieren, und Sie können einen serverlosen Endpunkt verwenden, um ein bei Model Registry registriertes Modell zu hosten.](model-registry.md)
Serverless Inference ist generell in 21 AWS Regionen verfügbar: USA Ost (Nord-Virginia), USA Ost (Ohio), USA West (Nordkalifornien), USA West (Oregon), Afrika (Kapstadt), Asien-Pazifik (Hongkong), Asien-Pazifik (Mumbai), Asien-Pazifik (Tokio), Asien-Pazifik (Seoul), Asien-Pazifik (Osaka), Asien-Pazifik (Singapur), Asien-Pazifik (Sydney), Kanada (Zentral), Europa (Frankfurt), Europa (Irland), Europa (London), Europa (Paris), Europa (Stockholm), Europa (Mailand), Naher Osten (Bahrain), Südamerika (São Paulo). Weitere Informationen zur regionalen Verfügbarkeit von Amazon SageMaker AI finden Sie in der [Liste der AWS regionalen Dienste](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Funktionsweise
Das folgende Diagramm zeigt den Arbeitsablauf von serverloser On-Demand-Inferenz und die Vorteile der Verwendung eines Serverless Endpunkts.
![\[Diagramm, das den Workflow der Serverless Inference zeigt\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/serverless-endpoints-how-it-works.png)
Wenn Sie einen serverlosen On-Demand-Endpunkt einrichten, SageMaker stellt KI die Rechenressourcen für Sie bereit und verwaltet sie. Anschließend können Sie Inferenzanfragen an den Endpunkt stellen und als Antwort Modellvorhersagen erhalten. SageMaker KI skaliert die Rechenressourcen je nach Bedarf hoch und runter, um Ihren Anforderungsverkehr zu bewältigen, und Sie zahlen nur für das, was Sie tatsächlich nutzen.
Für Provisioned Concurrency ist Serverless Inference auch in Application Auto Scaling integriert, sodass Sie Provisioned Concurrency auf der Grundlage einer Zielmetrik oder eines Zeitplans verwalten können. Weitere Informationen finden Sie unter [Automatische Skalierung der bereitgestellten Gleichzeitigkeit für einen Serverless Endpunkt](serverless-endpoints-autoscale.md).
In den folgenden Abschnitten finden Sie zusätzliche Informationen zu Serverless Inference und seiner Funktionsweise.
**Topics**
+ [Container-Support](#serverless-endpoints-how-it-works-containers)
+ [Arbeitsspeichergröße](#serverless-endpoints-how-it-works-memory)
+ [Gleichzeitige Aufrufe](#serverless-endpoints-how-it-works-concurrency)
+ [Minimierung von Cold-Starts](#serverless-endpoints-how-it-works-cold-starts)
+ [Exklusive Features](#serverless-endpoints-how-it-works-exclusions)
### Container-Support
Für Ihren Endpunkt-Container können Sie entweder einen von SageMaker KI bereitgestellten Container wählen oder Ihren eigenen mitbringen. SageMaker AI stellt Container für seine integrierten Algorithmen und vorgefertigte Docker-Images für einige der gängigsten Frameworks für maschinelles Lernen wie Apache,, und MXNet TensorFlow Chainer bereit. PyTorch Eine Liste der verfügbaren SageMaker Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Wenn Sie Ihren eigenen Container mitbringen, müssen Sie ihn so modifizieren, dass er mit SageMaker KI funktioniert. Weitere Informationen zum Laden integrieren eigener Container finden Sie unter [Passen Sie Ihren eigenen Inferenzcontainer für Amazon SageMaker AI an](adapt-inference-container.md).
Die maximale Größe des Container-Images, das Sie verwenden können, ist 10 GB. Für serverlose Endpunkte empfehlen wir, nur einen Worker im Container zu erstellen und nur eine Kopie des Modells zu laden. Beachten Sie, dass dies anders ist als bei Echtzeit-Endpunkten, bei denen einige SageMaker KI-Container möglicherweise einen Worker für jede vCPU erstellen, um Inferenzanfragen zu verarbeiten und das Modell in jeden Worker zu laden.
Wenn Sie bereits über einen Container für einen Echtzeit-Endpunkt verfügen, können Sie denselben Container für Ihren Serverless Endpunkt verwenden, obwohl einige Funktionen ausgeschlossen sind. Weitere Informationen zu den Container-Funktionen, die in Serverless Inference nicht unterstützt werden, finden Sie unter [Exklusive Features](#serverless-endpoints-how-it-works-exclusions). Wenn Sie sich dafür entscheiden, denselben Container zu verwenden, SageMaker hinterlegt KI eine Kopie Ihres Container-Images, bis Sie alle Endpunkte löschen, die das Image verwenden. SageMaker KI verschlüsselt das kopierte Image im Ruhezustand mit einem KI-eigenen Schlüssel. SageMaker AWS KMS
### Arbeitsspeichergröße
Ihr serverloser Endpunkt hat eine minimale RAM-Größe von 1024 MB (1 GB), und die maximale RAM-Größe, die Sie wählen können, beträgt 6144 MB (6 GB). Die Speichergrößen, die Sie wählen können, sind: 048 MB, 3 072 MB, 4 096 MB, 5 120 MB oder 6 144 MB. Serverlose Inferenz weist Rechenressourcen automatisch proportional zum ausgewählten Speicher zu. Wenn Sie eine größere Speichergröße wählen, hat Ihr Container Zugriff auf mehr V. CPUs Wählen Sie die Speichergröße Ihres Endpunkts entsprechend Ihrer Modellgröße. Im Allgemeinen sollte die Speichergröße mindestens so groß sein wie Ihre Modellgröße. Möglicherweise müssen Sie einen Benchmark durchführen, um anhand Ihrer Latenz die richtige Speicherauswahl für Ihr Modell auszuwählen SLAs. Eine schrittweise Anleitung zum Benchmarking finden Sie unter [Einführung in das Amazon SageMaker Serverless Inference Benchmarking](https://aws.amazon.com/blogs/machine-learning/introducing-the-amazon-sagemaker-serverless-inference-benchmarking-toolkit/) Toolkit. Die Speichergrößenstufen haben unterschiedliche Preise. Weitere Informationen finden Sie auf der [Amazon SageMaker AI-Preisseite](https://aws.amazon.com/sagemaker/pricing/).
Unabhängig von der ausgewählten Speichergröße stehen Ihrem Serverless Endpunkt 5 GB flüchtiger Festplattenspeicher zur Verfügung. Hilfe zu Problemen mit Containerberechtigungen bei der Arbeit mit Speicher finden Sie unter [Fehlerbehebung](serverless-endpoints-troubleshooting.md).
### Gleichzeitige Aufrufe
Serverless Inference auf Abruf verwaltet vordefinierte Skalierungsrichtlinien und Kontingente für die Kapazität Ihres Endpunkts. Serverlose Endgeräte haben ein Kontingent dafür, wie viele gleichzeitige Aufrufe gleichzeitig verarbeitet werden können. Wenn der Endpunkt aufgerufen wird, bevor er die Verarbeitung der ersten Anfrage abgeschlossen hat, verarbeitet er die zweite Anfrage gleichzeitig.
Die gesamte Parallelität, die Sie zwischen allen Serverless Endpunkten in Ihrem Konto teilen können, hängt von Ihrer Region ab:
+ Für die Regionen USA Ost (Ohio), USA Ost (N. Virginia), USA West (Oregon), Asien-Pazifik (Singapur), Asien-Pazifik (Sydney), Asien-Pazifik (Tokio), Europa (Frankfurt) und Europa (Irland) beträgt die Gesamtzahl der Gleichzeitigkeit, die Sie zwischen allen Serverless Endpunkten pro Region in Ihrem Konto teilen können, 1000.
+ Für die Regionen USA-West (Nordkalifornien), Afrika (Kapstadt), Asien-Pazifik (Hongkong), Asien-Pazifik (Mumbai), Asien-Pazifik (Osaka), Asien-Pazifik (Seoul), Kanada (Zentral), Europa (London), Europa (Mailand), Europa (Paris), Europa (Stockholm), Naher Osten (Bahrain) und Südamerika (São Paulo) beträgt die Gesamtzahl der Gleichzeitigkeiten pro Region auf Ihrem Konto 500.
Sie können die maximale Parallelität für einen einzelnen Endpunkt auf bis zu 200 festlegen, und die Gesamtzahl der Serverless Endpunkte, die Sie in einer Region hosten können, beträgt 50. Die maximale Parallelität für einen einzelnen Endpunkt verhindert, dass dieser Endpunkt alle für Ihr Konto zulässigen Aufrufe annimmt, und alle Endpunktaufrufen, die über das Maximum hinausgehen, werden gedrosselt.
**Anmerkung**
Die bereitgestellte Parallelität, die Sie einem Serverless Endpunkt zuweisen, sollte immer kleiner oder gleich der maximalen Parallelität sein, die Sie diesem Endpunkt zugewiesen haben.
Informationen zum Festlegen der maximalen Parallelität für Ihren Endpunkt finden Sie unter[Eine Endpunktkonfiguration erstellen](serverless-endpoints-create-config.md). Weitere Informationen zu Kontingenten und Limits finden Sie unter [Amazon SageMaker AI-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html) in der *Allgemeine AWS-Referenz*. Wenn Sie ein höheren Service-Limit anfordern möchten, kontaktieren Sie [AWS -Support](https://console.aws.amazon.com/support). Weitere Informationen zum Anfordern einer Erhöhung des Servicelimits finden Sie unter [Unterstützte Regionen und Kontingente](regions-quotas.md).
### Minimierung von Cold-Starts
Wenn Ihr On-Demand-Endpunkt für serverlose Inferenz eine Zeit lang keinen Datenverkehr empfängt und Ihr Endpunkt dann plötzlich neue Anfragen erhält, kann es einige Zeit dauern, bis Ihr Endpunkt die Rechenressourcen für die Verarbeitung der Anfragen aktiviert hat. Dies wird als *Kaltstart* bezeichnet. Da serverlose Endgeräte Rechenressourcen bei Bedarf bereitstellen, kann es bei Ihrem Endpunkt zu Kaltstarts kommen. Ein Kaltstart kann auch auftreten, wenn Ihre gleichzeitigen Anfragen die aktuelle Auslastung der gleichzeitigen Anfragen überschreiten. Die Kaltstartzeit hängt von Ihrer Modellgröße, der Dauer des Herunterladens Ihres Modells und der Startzeit Ihres Containers ab.
Um zu überwachen, wie lang Ihre Kaltstartzeit ist, können Sie die CloudWatch Amazon-Metrik verwenden, `OverheadLatency` um Ihren serverlosen Endpunkt zu überwachen. Diese Metrik verfolgt die Zeit, die benötigt wird, um neue Rechenressourcen für Ihren Endpunkt zu starten. Weitere Informationen zur Verwendung von CloudWatch Metriken mit serverlosen Endpunkten finden Sie unter. [Alarme und Protokolle zur Verfolgung von Metriken von Serverless-Endpunkten](serverless-endpoints-monitoring.md)
Sie können Kaltstarts minimieren, indem Sie Provisioned Concurrency verwenden. SageMaker KI hält den Endpunkt warm und bereit, innerhalb von Millisekunden zu reagieren, und zwar für die Anzahl von Provisioned Concurrency, die Sie zugewiesen haben.
### Exklusive Features
Einige der derzeit für SageMaker AI Real-time Inference verfügbaren Funktionen werden für Serverless Inference nicht unterstützt, darunter AWS Marketplace-Modellpakete GPUs, private Docker-Registries, Multi-Model-Endpunkte, VPC-Konfiguration, Netzwerkisolierung, Datenerfassung, mehrere Produktionsvarianten, Model Monitor und Inferenz-Pipelines.
Sie können Ihren instance-basierten Echtzeit-Endpunkt nicht in einen Serverless Endpunkt umwandeln. Wenn Sie versuchen, Ihren Echtzeit-Endpunkt auf Serverless Endpunkt umzustellen, erhalten Sie eine `ValidationError` Meldung. Sie können einen Serverless Endpunkt in einen Echtzeit-Endpunkt umwandeln, aber sobald Sie das Update vorgenommen haben, können Sie es nicht mehr auf serverlos zurücksetzen.
## Erste Schritte
Sie können einen serverlosen Endpunkt mit der SageMaker AI-Konsole, dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) und dem erstellen AWS SDKs, aktualisieren, beschreiben und löschen. AWS CLI Sie können Ihren Endpunkt mit dem AWS SDKs, dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) und dem AWS CLI aufrufen. Für serverlose Endpoints mit Provisioned Concurrency können Sie Application Auto Scaling verwenden, um Provisioned Concurrency auf der Grundlage einer Zielmetrik oder eines Zeitplans automatisch zu skalieren. Weitere Informationen zum Einrichten und Verwenden eines serverless Endpunkts finden Sie im Leitfaden [Serverless-Endpoint-Operationen](serverless-endpoints-create-invoke-update-delete.md). Weitere Informationen zum Auto Scaling serverloser Endpunkte mit Provisioned Concurrency finden Sie unter [Automatische Skalierung der bereitgestellten Gleichzeitigkeit für einen Serverless Endpunkt](serverless-endpoints-autoscale.md).
**Anmerkung**
Application Auto Scaling for Serverless Inference with Provisioned Concurrency wird derzeit auf AWS CloudFormation nicht unterstützt.
### Beispiele für Notebooks und Blogs
[Beispiele für Jupyter-Notebooks, die Workflows für end-to-end serverlose Endgeräte zeigen, finden Sie in den Beispiel-Notebooks für Serverless Inference.](https://github.com/aws/amazon-sagemaker-examples/tree/master/serverless-inference)
# Serverless-Endpoint-Operationen
Im Gegensatz zu anderen SageMaker KI-Echtzeit-Endpunkten verwaltet Serverless Inference Rechenressourcen für Sie und reduziert so die Komplexität, sodass Sie sich auf Ihr ML-Modell statt auf die Verwaltung der Infrastruktur konzentrieren können. In der folgenden Anleitung werden die wichtigsten Funktionen von Serverless-Endpunkten beschrieben: wie Endpunkte erstellt, aufgerufen, aktualisiert, beschrieben oder gelöscht werden. Sie können die SageMaker KI-Konsole AWS SDKs, das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) oder das verwenden, AWS CLI um Ihre serverlosen Endpunkte zu verwalten.
**Topics**
+ [Erfüllen der Voraussetzungen](serverless-endpoints-prerequisites.md)
+ [Erstellen eines Serverless-Endpunkts](serverless-endpoints-create.md)
+ [Aufrufen eines Serverless-Endpunktes](serverless-endpoints-invoke.md)
+ [Serverless-Endpunkt aktualisieren](serverless-endpoints-update.md)
+ [Serverless-Endpunkt beschreiben](serverless-endpoints-describe.md)
+ [So löschen Sie einen Serverless-Endpunkt](serverless-endpoints-delete.md)
# Erfüllen der Voraussetzungen
Das folgende Thema beschreibt die Voraussetzungen, die Sie erfüllen müssen, bevor Sie einen Serverless-Endpunkt erstellen. Zu diesen Voraussetzungen gehören das ordnungsgemäße Speichern Ihrer Modellartefakte, die Konfiguration eines AWS IAM mit den richtigen Berechtigungen und die Auswahl eines Container-Images.
**So erfüllen Sie die Voraussetzungen**
1. **Richten Sie ein AWS Konto ein.** Sie benötigen zunächst ein AWS Konto und einen AWS Identity and Access Management Administratorbenutzer. Anweisungen zur Einrichtung eines AWS Kontos finden Sie unter [Wie erstelle und aktiviere ich ein neues AWS Konto?](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) . Anweisungen dazu, wie Sie Ihr Konto mit einem IAM-Benutzer als Administrator sichern, finden Sie unter [Erstellen Ihres ersten IAM-Benutzers als Administrator und einer Benutzergruppe](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) im *IAM-Benutzerhandbuch*.
1. **Erstellen Sie einen Amazon-S3-Bucket**. Sie verwenden einen Amazon-S3-Bucket, um Ihre Modellartefakte zu speichern. Wie Sie einen Bucket erstellen, erfahren Sie unter [So erstellen Sie Ihren ersten S3-Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) im *Amazon S3-Benutzerhandbuch*.
1. **Laden Sie Ihre Modellartefakte in Ihren S3-Bucket hoch.** Wie Sie Ihr Modell in Ihren Bucket hochladen, erfahren Sie unter [So laden Sie ein Objekt in Ihren Bucket hoch](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) im *Amazon S3-Benutzerhandbuch*.
1. **Erstellen Sie eine IAM-Rolle für Amazon SageMaker AI.** Amazon SageMaker AI benötigt Zugriff auf den S3-Bucket, in dem Ihr Modell gespeichert ist. Erstellen Sie eine IAM-Rolle mit einer Richtlinie, die SageMaker KI Lesezugriff auf Ihren Bucket gewährt. Das folgende Verfahren zeigt, wie Sie eine Rolle in der Konsole erstellen. Sie können jedoch auch die [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)API aus dem *IAM-Benutzerhandbuch* verwenden. Wie Sie Ihrer Rolle je nach Anwendungsfall detailliertere Berechtigungen zuweisen können, erfahren Sie unter [Wie verwendet man SageMaker AI-Ausführungsrollen](sagemaker-roles.md#sagemaker-roles-createmodel-perms).
1. Melden Sie sich bei der [IAM-Konsole](https://console.aws.amazon.com/iam/) an.
1. Wählen Sie auf der Registerkarte Navigation **Rollen** aus.
1. Wählen Sie **Rolle erstellen** aus.
1. **Wählen Sie unter Typ der vertrauenswürdigen Entität** auswählen die Option **AWS Service** und dann **SageMaker AI** aus.
1. Wählen Sie **Weiter: Berechtigungen** und dann **Weiter: Tags** aus.
1. (Optional) Sie können Tags als Schlüssel-Wert-Paare hinzufügen, wenn Sie Metadaten für die Rolle haben möchten.
1. Wählen Sie **Weiter: Prüfen** aus.
1. Geben Sie unter **Rollenname** einen Namen für die neue Rolle ein, der innerhalb Ihres AWS Kontos eindeutig ist. Nachdem Sie die Rolle erstellt haben, können Sie den Rollennamen nicht mehr bearbeiten.
1. (Optional) Geben Sie im Feld **Role description (Rollenbeschreibung)** eine Beschreibung für die neue Rolle ein.
1. Wählen Sie **Rolle erstellen** aus.
1. **Ordnen Sie Ihrer SageMaker KI-Rolle S3-Bucket-Berechtigungen zu.** Nachdem Sie eine IAM-Rolle erstellt haben, fügen Sie eine Richtlinie hinzu, die SageMaker KI die Erlaubnis erteilt, auf den S3-Bucket zuzugreifen, der Ihre Modellartefakte enthält.
1. Wählen Sie auf der Registerkarte IAM-Konsolennavigation **Rollen** aus.
1. Suchen Sie auf der Liste der Rollen anhand des Namens nach der Rolle, die Sie im vorherigen Schritt erstellt haben.
1. Wählen Sie Ihre Rolle aus und anschließend **Richtlinien anhängen**.
1. Wählen Sie unter **Berechtigungen anfügen)** **Richtlinie erstellen** aus.
1. Wählen Sie in der Ansicht **Richtlinie erstellen** die Registerkarte **JSON** aus.
1. Fügen Sie im JSON-Editor die folgende Richtlinienanweisung hinzu. Vergewissern Sie sich, dass Sie `` durch den Namen des S3-Buckets ersetzen, in dem Ihre Modellartefakte gespeichert sind. Wenn Sie den Zugriff auf einen bestimmten Ordner oder eine bestimmte Datei in Ihrem Bucket einschränken möchten, können Sie auch den Amazon S3-Ordnerpfad angeben, z. B. `/`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
}
```
------
1. Wählen Sie **Weiter: Tags** aus.
1. (Optional) Fügen Sie Metadaten in Form von Schlüssel-Wert-Paare zur Richtlinie hinzu.
1. Wählen Sie **Weiter: Prüfen** aus.
1. Geben Sie unter **Name** einen Namen für die Richtlinie ein.
1. (Optional) Geben Sie eine **Beschreibung** für die Richtlinie ein.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Kehren Sie nach der Erstellung der Richtlinie in der [IAM-Konsole](https://console.aws.amazon.com/iam/) zu **Rollen** zurück und wählen Sie Ihre SageMaker KI-Rolle aus.
1. Wählen Sie **Richtlinien anfügen**.
1. Suchen Sie unter **Berechtigungen anhängen** nach der Richtlinie, die Sie erstellt haben, nach dem Namen. Wählen Sie diese aus und wählen Sie dann **Richtlinie anhängen**.
1. **Wählen Sie ein vorgefertigtes Docker-Container-Image aus oder bringen Sie Ihr eigenes mit.** Der von Ihnen gewählte Container dient der Inferenz auf Ihrem Endpunkt. SageMaker KI bietet Container für integrierte Algorithmen und vorgefertigte Docker-Images für einige der gängigsten Frameworks für maschinelles Lernen wie Apache, MXNet TensorFlow PyTorch, und Chainer. Eine vollständige Liste der verfügbaren SageMaker Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Wenn keiner der vorhandenen SageMaker KI-Container Ihren Anforderungen entspricht, müssen Sie möglicherweise Ihren eigenen Docker-Container erstellen. Informationen dazu, wie Sie Ihr Docker-Image erstellen und es mit SageMaker KI kompatibel machen, finden Sie unter. [Container mit benutzerdefiniertem Inferenzcode](your-algorithms-inference-main.md) Um Ihren Container mit einem serverlosen Endpunkt zu verwenden, muss sich das Container-Image in einem Amazon ECR-Repository innerhalb desselben AWS Kontos befinden, das den Endpunkt erstellt.
1. **(Optional) Registrieren Sie Ihr Modell bei der Model Registry.** [SageMaker Model Registry](model-registry.md) hilft Ihnen dabei, Versionen Ihrer Modelle für die Verwendung in ML-Pipelines zu katalogisieren und zu verwalten. Wie Sie eine Version Ihres Modells registrieren können, erfahren Sie unter [Erstellen einer Modellgruppe](model-registry-model-group.md) und [Registrieren Sie eine Modellversion](model-registry-version.md). Ein Beispiel für einen Workflow mit Model Registry und Serverless Inference finden Sie im folgenden [Beispiel-Notebook](https://github.com/aws/amazon-sagemaker-examples/blob/main/serverless-inference/serverless-model-registry.ipynb).
1. **(Optional) Bringen Sie einen AWS KMS Schlüssel mit.** Bei der Einrichtung eines serverlosen Endpunkts haben Sie die Möglichkeit, einen KMS-Schlüssel anzugeben, den SageMaker KI zur Verschlüsselung Ihres Amazon ECR-Images verwendet. Beachten Sie, dass die Schlüsselrichtlinie für den KMS-Schlüssel Zugriff auf die IAM-Rolle gewähren muss, die Sie bei der Einrichtung Ihres Endpunktes angeben. Weitere Informationen zu KMS-Schlüsseln finden Sie im [AWS Key Management Service Entwicklerhandbuch](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
# Erstellen eines Serverless-Endpunkts
**Wichtig**
Benutzerdefinierte IAM-Richtlinien, die es Amazon SageMaker Studio oder Amazon SageMaker Studio Classic ermöglichen, SageMaker Amazon-Ressourcen zu erstellen, müssen auch Berechtigungen zum Hinzufügen von Tags zu diesen Ressourcen gewähren. Die Berechtigung zum Hinzufügen von Tags zu Ressourcen ist erforderlich, da Studio und Studio Classic automatisch alle von ihnen erstellten Ressourcen taggen. Wenn eine IAM-Richtlinie Studio und Studio Classic das Erstellen von Ressourcen, aber kein Tagging erlaubt, können "AccessDenied" Fehler beim Versuch, Ressourcen zu erstellen, auftreten. Weitere Informationen finden Sie unter [Erteilen Sie Berechtigungen für das Taggen von SageMaker KI-Ressourcen](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS verwaltete Richtlinien für Amazon SageMaker AI](security-iam-awsmanpol.md)die Berechtigungen zum Erstellen von SageMaker Ressourcen gewähren, beinhalten bereits Berechtigungen zum Hinzufügen von Tags beim Erstellen dieser Ressourcen.
Um einen serverlosen Endpunkt zu erstellen, können Sie die Amazon SageMaker AI-Konsole APIs, die oder die AWS CLI verwenden. Einen Serverless-Endpunkt können Sie nach einem ähnlichen Verfahren erstellen wie einen [Echtzeitendpunkt](realtime-endpoints.md).
**Topics**
+ [Ein Modell erstellen](serverless-endpoints-create-model.md)
+ [Eine Endpunktkonfiguration erstellen](serverless-endpoints-create-config.md)
+ [Endpunkt herstellen](serverless-endpoints-create-endpoint.md)
# Ein Modell erstellen
Um Ihr Modell zu erstellen, müssen Sie den Speicherort Ihrer Modellartefakte und Ihres Container-Images angeben. Sie können auch eine Modellversion aus [SageMaker Model Registry](model-registry.md) verwenden. Die Beispiele in den folgenden Abschnitten zeigen Ihnen, wie Sie mithilfe der [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, der Model Registry und der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home) ein Modell erstellen.
## Zum Erstellen eines Modells (mit Hilfe von Model Registry)
[Model Registry](model-registry.md) ist eine Funktion von SageMaker KI, mit der Sie Versionen Ihres Modells für die Verwendung in ML-Pipelines katalogisieren und verwalten können. Um Model Registry mit Serverless Inference verwenden zu können, müssen Sie zunächst eine Modellversion in einer Model Registry Modellgruppe registrieren. Wie Sie ein Modell in Model Registry registrieren, erfahren Sie in den Anweisungen unter [Erstellen einer Modellgruppe](model-registry-model-group.md) und [Registrieren Sie eine Modellversion](model-registry-version.md).
Für das folgende Beispiel benötigen Sie den ARN einer registrierten Modellversion und verwendet das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html), um die [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API aufzurufen. Für Serverless Inference wird Model Registry derzeit nur vom AWS SDK for Python (Boto3) unterstützt. Geben Sie für das Beispiel die folgenden Werte an:
+ Geben Sie für `model_name` einen Name für das Modell ein.
+ Für `sagemaker_role` können Sie die von SageMaker KI erstellte Standardrolle oder eine benutzerdefinierte SageMaker KI-IAM-Rolle aus Schritt 4 des Abschnitts verwenden. [Erfüllen der Voraussetzungen](serverless-endpoints-prerequisites.md)
+ Geben Sie für `ModelPackageName` den ARN für Ihre Modellversion an, die in der Model Registry für eine Modellgruppe registriert sein muss.
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Specify a name for the model
model_name = ""
#Specify a Model Registry model version
container_list = [
{
"ModelPackageName":
}
]
#Create the model
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
container_list
)
```
## So erstellen Sie ein Modell (mit Hilfe der API)
Im folgenden Beispiel wird das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) verwendet, um die [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API aufzurufen. Geben Sie die folgenden Werte an:
+ Denn `sagemaker_role,` Sie können die von SageMaker KI erstellte Standardrolle oder eine benutzerdefinierte SageMaker KI-IAM-Rolle aus Schritt 4 des Abschnitts verwenden. [Erfüllen der Voraussetzungen](serverless-endpoints-prerequisites.md)
+ Geben Sie für `model_url` den Amazon-S3-URI für Ihr Modell an.
+ Rufen Sie für `container` über seinen Amazon ECR-Pfad den Container ab, den Sie verwenden möchten. In diesem Beispiel wird ein von SageMaker KI bereitgestellter XGBoost Container verwendet. Wenn Sie keinen SageMaker KI-Container ausgewählt oder Ihren eigenen mitgebracht haben, finden Sie weitere Informationen in Schritt 6 des [Erfüllen der Voraussetzungen](serverless-endpoints-prerequisites.md) Abschnitts.
+ Geben Sie für `model_name` einen Name für das Modell ein.
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Get model from S3
model_url = "s3://amzn-s3-demo-bucket/models/model.tar.gz"
#Get container image (prebuilt example)
from sagemaker import image_uris
container = image_uris.retrieve("xgboost", region, "0.90-1")
#Create model
model_name = ""
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
Containers = [{
"Image": container,
"Mode": "SingleModel",
"ModelDataUrl": model_url,
}]
)
```
## So erstellen Sie ein Modell (mithilfe der Konsole)
1. Melden Sie sich bei der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home) an.
1. Wählen Sie auf der Registerkarte Navigation die Option **Inferenz** aus.
1. Wählen Sie als Nächstes **Modelle** aus.
1. Wählen Sie **Modell erstellen** aus.
1. Geben Sie unter **Modellname** einen Namen für das Modell ein, der für Ihr Konto eindeutig ist, und AWS-Region.
1. Wählen Sie für die **IAM-Rolle** entweder eine IAM-Rolle aus, die Sie bereits erstellt haben (siehe[Erfüllen der Voraussetzungen](serverless-endpoints-prerequisites.md)), oder lassen Sie SageMaker KI eine für Sie erstellen.
1. Wählen Sie in **Container-Definition 1** für **Container-Eingabeoptionen** die Option **Modellartefakte bereitstellen und Ort eingeben** aus.
1. Wählen Sie unter **Modellartefakte und Inferenz-Image-Optionen bereitstellen** die Option **Ein einzelnes Modell verwenden** aus.
1. Geben Sie unter **Standort des Inferenzcode-Abbildes** einen Amazon ECR-Pfad zu einem Container ein. Das Image muss entweder ein von SageMaker KI bereitgestelltes First-Party-Image sein (z. B. TensorFlow XGBoost) oder ein Image, das sich in einem Amazon ECR-Repository innerhalb desselben Kontos befindet, in dem Sie den Endpunkt erstellen. Wenn Sie keinen Container haben, gehen Sie zurück zu Schritt 6 im Abschnitt [Erfüllen der Voraussetzungen](serverless-endpoints-prerequisites.md). Dort finden Sie weitere Informationen.
1. Geben Sie als **Standort der Modellartefakte** den Amazon-S3-URI zu Ihrem ML-Modell ein. Beispiel, `s3://amzn-s3-demo-bucket/models/model.tar.gz`.
1. (Optional) Fügen Sie für **Tags** Schlüssel-Wert-Paare hinzu, um Metadaten für Ihr Modell zu erstellen.
1. Wählen Sie **Modell erstellen** aus.
# Eine Endpunktkonfiguration erstellen
Wenn Sie ein Modell erstellt haben, erstellen Sie als nächstes eine Endpunktkonfiguration. Anschließend können Sie Ihr Modell mithilfe der Spezifikationen in Ihrer Endpunktkonfiguration bereitstellen. In der Konfiguration geben Sie an, ob Sie einen Echtzeit- oder einen Serverless-Endpunkt haben wollen. Um eine serverlose Endpunktkonfiguration zu erstellen, können Sie die [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home), die [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API oder die AWS CLI verwenden. Die API- und Konsolenansätze werden in den folgenden Abschnitten beschrieben.
## So erstellen Sie eine Endpunktkonfiguration (mit Hilfe der API)
Im folgenden Beispiel wird das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) verwendet, um die [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API aufzurufen. Geben Sie die folgenden Werte an:
+ Wählen Sie für `EndpointConfigName` einen Namen für die Endpunktkonfiguration. Der Name sollte innerhalb einer Region in Ihrem Konto eindeutig sein.
+ (Optional) Verwenden Sie für `KmsKeyId` die Schlüssel-ID, den Schlüssel-ARN, den Aliasnamen oder den Alias-ARN für einen AWS KMS Schlüssel, den Sie verwenden möchten. SageMaker KI verwendet diesen Schlüssel, um Ihr Amazon ECR-Bild zu verschlüsseln.
+ Verwenden Sie für `ModelName` den Namen des Modells, das Sie bereitstellen möchten. Dieses Modell sollte dasselbe sein, das Sie im [Ein Modell erstellen](serverless-endpoints-create-model.md) Schritt verwendet haben.
+ Für `ServerlessConfig`:
+ Setzen Sie `MemorySizeInMB` auf `2048`. In diesem Beispiel legen wir die Speichergröße auf 2048 MB fest. Sie können für Ihre Speichergröße jedoch einen der folgenden Werte wählen: 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB oder 6144 MB.
+ Setzen Sie `MaxConcurrency` auf `20`. In diesem Beispiel haben wir die maximale Parallelität auf 20 festgelegt. Die maximale Anzahl gleichzeitiger Aufrufe, die Sie für einen Serverless-Endpunkt festlegen können, ist 200. Der Mindestwert, den Sie auswählen können, ist 1.
+ (Optional) Um bereitgestellte Gleichzeitigkeit zu verwenden, legen Sie `ProvisionedConcurrency` auf 10 fest. In diesem Beispiel haben wir die bereitgestellte Gleichzeitigkeit auf 10 gesetzt. Die `ProvisionedConcurrency` Zahl für einen Serverless-Endpunkt muss kleiner oder gleich der `MaxConcurrency` Zahl sein. Sie können das Feld leer lassen, wenn Sie einen Endpunkt für Serverless Inferenz auf Abruf verwenden möchten. Sie können Gleichzeitigkeit bereitstellen dynamisch skalieren. Weitere Informationen finden Sie unter [Automatische Skalierung der bereitgestellten Gleichzeitigkeit für einen Serverless Endpunkt](serverless-endpoints-autoscale.md).
```
response = client.create_endpoint_config(
EndpointConfigName="",
KmsKeyId="arn:aws:kms:us-east-1:123456789012:key/143ef68f-76fd-45e3-abba-ed28fc8d3d5e",
ProductionVariants=[
{
"ModelName": "",
"VariantName": "AllTraffic",
"ServerlessConfig": {
"MemorySizeInMB": 2048,
"MaxConcurrency": 20,
"ProvisionedConcurrency": 10,
}
}
]
)
```
## So erstellen Sie eine Endpunktkonfiguration (mit Hilfe der Konsole)
1. Melden Sie sich bei der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home) an.
1. Wählen Sie auf der Registerkarte Navigation **Inferenz** aus.
1. Wählen Sie als Nächstes **Endpunktkonfigurationen** aus.
1. Wählen Sie **Endpunktkonfiguration erstellen** aus.
1. Geben Sie unter **Name der Endpunktkonfiguration** einen Namen ein, der innerhalb Ihres Kontos in einer Region eindeutig ist.
1. Wählen Sie als **Typ des Endpunkts** die Option **Serverless** aus.
![\[Screenshot der Option Endpunkttyp in der Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config.png)
1. Wählen Sie für **Produktionsvarianten** die Option **Modell hinzufügen** aus.
1. Wählen Sie unter **Modell hinzufügen** das Modell, das Sie verwenden möchten, von der Liste der Modelle aus und klicken Sie dann auf **Speichern**.
1. Wenn Sie Ihr Modell hinzugefügt haben, wählen Sie unter **Aktionen** die Option **Bearbeiten** aus.
1. Wählen Sie unter **Speichergröße** die gewünschte Speichergröße in GB aus.
![\[Screenshot der Option „Speichergröße“ in der Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config-2.png)
1. Geben Sie für **Max. Gleichzeitigkeit** die gewünschte maximale Anzahl gleichzeitiger Aufrufe für den Endpunkt ein. Der Höchstwert, den Sie eingeben können, ist 200 und der Mindestwert ist 1.
1. (Optional) Um die bereitgestellte Gleichzeitigkeit zu verwenden, geben Sie die gewünschte Anzahl gleichzeitiger Aufrufe in das Feld **Einstellung für bereitgestellte Gleichzeitigkeit** ein. Die Anzahl der gleichzeitig bereitgestellten Aufrufe muss kleiner oder gleich der maximalen Anzahl gleichzeitiger Aufrufe sein.
1. Wählen Sie **Speichern**.
1. (Optional) Geben Sie unter **Tags** Schlüssel-Wert-Paare ein, wenn Sie Metadaten für Ihre Endpunktkonfiguration erstellen möchten.
1. Wählen Sie **Endpunktkonfiguration erstellen** aus.
# Endpunkt herstellen
Um einen serverlosen Endpunkt zu erstellen, können Sie die [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home), die [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API oder die AWS CLI verwenden. Die API- und Konsolenansätze werden in den folgenden Abschnitten beschrieben. Wenn Sie Ihren Endpunkt erstellt haben, kann es einige Minuten dauern, bis der Endpunkt verfügbar ist.
## So erstellen Sie einen Endpunkt (mithilfe der API)
Im folgenden Beispiel wird das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) verwendet, um die [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API aufzurufen. Geben Sie die folgenden Werte an:
+ Geben Sie für `EndpointName` einen Namen für den Endpunkt ein, der innerhalb einer Region in Ihrem Konto eindeutig ist.
+ Verwenden Sie für `EndpointConfigName` den Namen der Endpunktkonfiguration, die Sie im letzten Abschnitt erstellt haben.
```
response = client.create_endpoint(
EndpointName="",
EndpointConfigName=""
)
```
## So erstellen Sie einen Endpunkt (mit Hilfe der Konsole)
1. Melden Sie sich bei der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home) an.
1. Wählen Sie auf der Registerkarte Navigation **Inferenz** aus.
1. Wählen Sie als Nächstes **Endpunkte** aus.
1. Wählen Sie **Endpunkt erstellen** aus.
1. Geben Sie als **Endpunktname** einen Namen ein, der innerhalb einer Region in Ihrem Konto eindeutig ist.
1. Wählen **Sie unter Endpunktkonfiguration anhängen** die Option **Vorhandene Endpunktkonfiguration verwenden** aus.
1. Wählen Sie für **Endpunktkonfiguration** den Namen der Endpunktkonfiguration aus, die Sie im letzten Abschnitt erstellt haben, und wählen Sie dann **Endpunktkonfiguration auswählen** aus.
1. (Optional) Geben Sie unter **Tags** Schlüssel-Wert-Paare ein, wenn Sie Metadaten für Ihren Endpunkt erstellen möchten.
1. Wählen Sie **Endpunkt erstellen** aus.
![\[Screenshot der Seite „Endpunkt erstellen und konfigurieren“ in der Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/serverless-endpoints-create.png)
# Aufrufen eines Serverless-Endpunktes
Um mit einem serverlosen Endpunkt eine Inferenz vorzunehmen, müssen Sie eine HTTP-Anfrage an den Endpunkt senden. Sie können die [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API oder die verwenden AWS CLI, die eine `POST` Anfrage zum Aufrufen Ihres Endpunkts stellen. Die maximale Größe der Nutzdaten für Anfragen und Antworten für Serverless-Aufrufe beträgt 4 MB. Für Serverlesse Endpunkte:
+ Das Modell muss heruntergeladen werden und der Server muss innerhalb von 3 Minuten erfolgreich auf `/ping` antworten.
+ Das Timeout, bis zu dem der Container Inferenzanfragen an `/invocations` beantworten muss, beträgt 1 Minute.
## Zum Aufrufen eines Endpunktes
Im folgenden Beispiel wird das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) verwendet, um die [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API aufzurufen. Beachten Sie, dass Sie im Gegensatz zu den anderen API-Aufrufen in diesem Handbuch für `InvokeEndpoint` SageMaker Runtime Runtime als Client verwenden müssen. Geben Sie die folgenden Werte an:
+ Verwenden Sie für `endpoint_name` den Namen des betriebsbereiten Serverless-Endpunkts, den Sie aufrufen möchten.
+ Geben Sie für `content_type` den MIME-Typ Ihrer Eingabedaten im Anforderungstext ein (z. B. `application/json`).
+ Verwenden Sie für`payload` Ihre „Nutzlast anfordern“ als Inferenz. Ihre Nutzlast sollte in Byte oder als dateiähnliches Objekt angegeben werden.
```
runtime = boto3.client("sagemaker-runtime")
endpoint_name = ""
content_type = ""
payload =
response = runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload
)
```
# Serverless-Endpunkt aktualisieren
Bevor Sie Ihren Endpunkt aktualisieren, erstellen Sie eine neue Endpunktkonfiguration oder verwenden Sie eine vorhandene Endpunktkonfiguration. In der Endpunktkonfiguration geben Sie die Änderungen für Ihr Update an. Anschließend können Sie Ihren Endpunkt mit der [SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home), der [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API oder dem AWS CLI aktualisieren. Der Vorgang zur Aktualisierung eines Serverless-Endpunktes ist derselbe wie für die Aktualisierung eines [Echtzeitendpunktes](realtime-endpoints.md). Beachten Sie, dass es bei der Aktualisierung Ihres Endpunkts zu Kaltstarts kommen kann, wenn Sie Anfragen an den Endpunkt stellen, da SageMaker KI Ihren Container und Ihr Modell neu initialisieren muss.
Sie möchten ggf. einen Serverless-Endpunkt auf Abruf auf einen Serverless-Endpunkt mit bereitgestellter Gleichzeitigkeit aktualisieren oder den Wert für bereitgestellte Gleichzeitigkeit für einen vorhandenen Serverless-Endpunkt mit bereitgestellter Gleichzeitigkeit anpassen. In beiden Fällen müssen Sie eine neue Serverless-Endpunktkonfiguration mit dem gewünschten Wert für bereitgestellte Gleichzeitigkeit erstellen und `UpdateEndpoint` auf den vorhandenen Serverless-Endpunkt anwenden. Wie Sie eine neue Serverless-Endpunktkonfiguration mit bereitgestellter Gleichzeitigkeit erstellen, erfahren Sie unter [Eine Endpunktkonfiguration erstellen](serverless-endpoints-create-config.md).
Wenn Sie von einem Serverless-Endpunkt die bereitgestellte Gleichzeitigkeit entfernen möchten, müssen Sie eine neue Endpunktkonfiguration erstellen, ohne einen Wert für die bereitgestellte Gleichzeitigkeit anzugeben, und dann `UpdateEndpoint` auf den Endpunkt anwenden.
**Anmerkung**
Die Aktualisierung eines Echtzeit-Inferenzendpunktes auf einen Serverless-Endpunkt auf Abruf oder einen Serverless-Endpunkt mit bereitgestellter Gleichzeitigkeit wird derzeit nicht unterstützt.
## Den Endpunkt löschen
Nachdem Sie eine neue serverlose Endpunktkonfiguration erstellt haben, können Sie die [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)oder die [SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/) verwenden, um einen vorhandenen serverlosen Endpunkt zu aktualisieren. In den folgenden Abschnitten werden Beispiele dafür beschrieben, wie Sie Ihren Endpunkt mithilfe der AWS SDK für Python (Boto3) und der SageMaker AI-Konsole aktualisieren können.
### So aktualisieren Sie den Endpunkt (mit Boto3)
Im folgenden Beispiel wird das [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) verwendet, um die Methode [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html) aufzurufen. Geben Sie beim Aufrufen der Methode mindestens die folgenden Parameter an:
+ Verwenden Sie für `EndpointName` den Namen des Endpunktes, den Sie aktualisieren wollen.
+ Verwenden Sie für `EndpointConfigName` den Namen der Endpunktkonfiguration, die Sie für das Update verwenden möchten.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
)
```
### So aktualisieren Sie den Endpunkt (mit Hilfe der Konsole)
1. Melden Sie sich bei der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/) an.
1. Wählen Sie auf der Registerkarte Navigation **Inferenz** aus.
1. Wählen Sie als Nächstes **Endpunkte** aus.
1. Wählen Sie von der Liste der Endpunkte den Endpunkt aus, den Sie aktualisieren möchten.
1. Wählen Sie im Abschnitt **Einstellungen für Endpunktkonfiguration** die Option **Ändern** aus.
1. Wählen Sie unter **Endpunktkonfiguration ändern** die Option **Vorhandene Endpunktkonfiguration verwenden** aus.
1. Wählen Sie von der Liste der Endpunktkonfigurationen diejenige aus, die Sie für Ihr Update verwenden möchten.
1. Wählen Sie **Endpunktkonfiguration auswählen**.
1. Wählen Sie **Endpunkt aktualisieren** aus.
# Serverless-Endpunkt beschreiben
Sie möchten ggf. Informationen über Ihren Endpunkt abrufen, einschließlich Details wie den ARN-Endpunkt, den aktuellen Status, die Bereitstellungskonfiguration und die Gründe für das Fehlschlagen. Informationen zu Ihrem Endpunkt finden Sie in der [SageMaker KI-Konsole](https://console.aws.amazon.com/sagemaker/home), der [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API oder der AWS CLI.
## So beschreiben Sie einen Endpunkt (mithilfe der API)
Im folgenden Beispiel wird das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#id309) verwendet, um die [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API aufzurufen. Verwenden Sie für `EndpointName` den Namen des Endpunktes, den Sie überprüfen möchten.
```
response = client.describe_endpoint(
EndpointName="",
)
```
## So beschreiben Sie einen Endpunkt (mithilfe der Konsole)
1. Melden Sie sich bei der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home) an.
1. Wählen Sie auf der Registerkarte Navigation **Inferenz** aus.
1. Wählen Sie als Nächstes **Endpunkte** aus.
1. Wählen Sie von der Liste der Endpunkte den Endpunkt aus, den Sie überprüfen möchten.
Die Seite mit den Endpunkten enthält die Informationen zu Ihrem Endpunkt.
# So löschen Sie einen Serverless-Endpunkt
Sie können Ihren serverlosen Endpunkt mithilfe der [SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home), der [DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)API oder der löschen. AWS CLI Die folgenden Beispiele zeigen Ihnen, wie Sie Ihren Endpunkt über die API und die SageMaker AI-Konsole löschen.
## So löschen Sie einen Endpunkt (mithilfe der API)
Im folgenden Beispiel wird das [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) verwendet, um die [DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)API aufzurufen. Verwenden Sie für `EndpointName` den Namen des Serverless-Endpunktes, den Sie löschen möchten.
```
response = client.delete_endpoint(
EndpointName="",
)
```
## So löschen Sie einen Endpunkt (mit Hilfe der Konsole)
1. Melden Sie sich bei der [Amazon SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/home) an.
1. Wählen Sie auf der Registerkarte Navigation **Inferenz** aus.
1. Wählen Sie als Nächstes **Endpunkte** aus.
1. Wählen Sie von der Liste der Endpunkte den Endpunkt aus, den Sie löschen möchten.
1. Wählen Sie die Dropdown-Liste **Aktionen** aus und danach **Löschen**.
1. Wenn Sie erneut dazu aufgefordert werden, wählen Sie **Löschen** aus.
Der Löschvorgang für Ihren Endpunkt sollte jetzt beginnen.
# Alarme und Protokolle zur Verfolgung von Metriken von Serverless-Endpunkten
Um Ihren serverlosen Endpunkt zu überwachen, können Sie Amazon CloudWatch-Alarme verwenden. CloudWatch ist ein Dienst, der Metriken in Echtzeit aus Ihren AWS Anwendungen und Ressourcen sammelt. Ein Alarm überwacht die erfassten Messwerte und gibt Ihnen die Möglichkeit, vorab einen Schwellenwert und die Maßnahmen festzulegen, die bei einer Überschreitung dieses Schwellenwerts zu ergreifen sind. Ihr CloudWatch-Alarm kann Ihnen beispielsweise eine Benachrichtigung senden, wenn Ihr Endpunkt einen Fehlerschwellenwert überschreitet. Durch die Einrichtung von CloudWatch-Alarmen erhalten Sie Einblick in die Leistung und Funktionalität Ihres Endpunkts. Mehr Informationen über CloudWatch-Alarme finden Sie unter [Vewenden von Amazon-CloudWatch-Alarmen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) im *Amazon-CloudWatch-Benutzerhandbuch*.
## Überwachung mit CloudWatch
Die folgenden Metriken sind eine vollständige Liste von Metriken für serverlose Endgeräte. Alle unten nicht aufgeführten Metriken werden nicht für serverlose Endgeräte veröffentlicht. Informationen zu den folgenden Metriken finden Sie unter [Überwachen von Amazon SageMaker AI mit Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
### Allgemeine Endpunktmetriken
Diese CloudWatch-Metriken entsprechen den für Echtzeit-Endpunkte veröffentlichten Metriken.
Die `OverheadLatency`-Metrik verfolgt alle zusätzlichen Latenzen, die SageMaker AI hinzugefügt hat, einschließlich der Kaltstartzeit für den Start neuer Rechenressourcen für Ihren Serverless-Endpunkt. Im Vergleich zu serverlosen On-Demand-Endpunkten ist die `OverheadLatency` bei serverlosen Endpunkten mit paralleler Bereitstellung im Allgemeinen deutlich geringer.
Serverlose Endgeräte können auch die `Invocations4XXErrors`, `Invocations5XXErrors`, `Invocations`, `ModelLatency`, `ModelSetupTime` und `MemoryUtilization` Metriken verwenden. Weitere Informationen zu diesen Metriken finden Sie unter [SageMaker Metriken zum Aufrufen von KI-Endpunkten](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation).
### Metriken für serverlose Endgeräte
Diese CloudWatch-Metriken werden sowohl für serverlose On-Demand-Endpunkte als auch für serverlose Endpunkte mit Provisioned Concurrency veröffentlicht.
| Metrikname | Beschreibung | Einheit/Statistik |
| --- | --- | --- |
| ServerlessConcurrentExecutionsUtilization | Die Anzahl der gleichzeitigen Ausführungen geteilt durch die maximale Gleichzeitigkeit. | Einheiten: keineGültige Statistiken: Durchschnitt, Maximum und Minimum |
### Serverloser Endpunkt mit Metriken für Provisioned Concurrency
Diese CloudWatch-Metriken werden für serverlose Endpunkte mit Provisioned Concurrency veröffentlicht.
| Metrikname | Beschreibung | Einheit/Statistik |
| --- | --- | --- |
| ServerlessProvisionedConcurrencyExecutions | Die Anzahl der gleichzeitigen Ausführungen, die vom Endpunkt verarbeitet werden. | Einheiten: AnzahlGültige Statistiken: Durchschnitt, Maximum und Minimum |
| ServerlessProvisionedConcurrencyUtilization | Die Anzahl der gleichzeitigen Ausführungen geteilt durch die zugewiesene Provisioned Concurrency. | Einheiten: keineGültige Statistiken: Durchschnitt, Maximum und Minimum |
| ServerlessProvisionedConcurrencyInvocations | Die Anzahl der InvokeEndpoint Anfragen, die von Provisioned Concurrency bearbeitet wurden. | Einheiten: AnzahlGültige Statistiken: Durchschnitt, Maximum und Minimum |
| ServerlessProvisionedConcurrencySpilloverInvocations | Die Anzahl der InvokeEndpoint Anfragen, die nicht von Provisioned Concurrency, sondern von On-Demand-serverlose Inferenz bearbeitet werden. | Einheiten: AnzahlGültige Statistiken: Durchschnitt, Maximum und Minimum |
## Logs (Protokolle)
Wenn Sie die Protokolle von Ihrem Endpunkt aus zum Debuggen oder zur Fortschrittsanalyse überwachen möchten, können Sie Amazon CloudWatch Protokolle verwenden. Die von SageMaker AI bereitgestellte Protokollgruppe, die Sie für Serverless-Endpunkte verwenden können, ist `/aws/sagemaker/Endpoints/[EndpointName]`. Weitere Informationen zur Verwendung von CloudWatch-Protokollen in SageMaker AI finden Sie unter [CloudWatch Protokolle für Amazon SageMaker AI](logging-cloudwatch.md). Weitere Informationen zu CloudWatch Logs finden Sie unter [Was ist Amazon CloudWatch Protokolle](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) im *Benutzerhandbuch zu Amazon CloudWatch Protokolle*.
# Automatische Skalierung der bereitgestellten Gleichzeitigkeit für einen Serverless Endpunkt
Amazon SageMaker AI skaliert bei Bedarf automatisch Serverless Endpunkte ein oder aus. Für Serverless Endpunkte mit Provisioned Concurrency können Sie Application Auto Scaling verwenden, um die bereitgestellte Parallelität basierend auf Ihrem Verkehrsprofil nach oben oder unten zu skalieren und so die Kosten zu optimieren.
Im Folgenden sind die Voraussetzungen für die automatische Skalierung von Provisioned Concurrency auf Serverless Endpunkten aufgeführt:
+ [Registrieren eines Modells](#serverless-endpoints-autoscale-register)
+ [Definieren einer Skalierungsrichtlinie](#serverless-endpoints-autoscale-define)
+ [Anwenden einer Skalierungsrichtlinie](#serverless-endpoints-autoscale-apply)
Bevor Sie Autoscaling verwenden können, müssen Sie bereits ein Modell auf einem Serverless Endpunkt mit Provisioned Concurrency bereitgestellt haben. Eingesetzte Modelle werden als [Produktionsvarianten](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) bezeichnet. Weitere Informationen zur Bereitstellung eines Modells auf einem Serverless Endpunkt mit Provisioned Concurrency finden Sie unter [Eine Endpunktkonfiguration erstellen](serverless-endpoints-create-config.md) und [Endpunkt herstellen](serverless-endpoints-create-endpoint.md). Um die Metriken und Zielwerte für eine Skalierungsrichtlinie festzulegen, müssen Sie eine Skalierungsrichtlinie konfigurieren. Weitere Informationen zum Definieren einer Skalierungsrichtlinie finden Sie unter [Definieren einer Skalierungsrichtlinie](#serverless-endpoints-autoscale-define). Registrieren Sie Ihr Modell und legen Sie eine Skalierungsrichtlinie fest, um die Skalierungsrichtlinie auf das registrierte Modell anzuwenden. Informationen zur Anwendung der Skalierungsrichtlinie finden Sie unter [Anwenden einer Skalierungsrichtlinie](#serverless-endpoints-autoscale-apply).
Einzelheiten zu anderen Voraussetzungen und Komponenten, die für Autoscaling verwendet werden, finden Sie im Abschnitt [Voraussetzungen für Auto Scaling](endpoint-auto-scaling-prerequisites.md) der [Dokumentation zu SageMaker AI Auto Scaling](endpoint-auto-scaling.md).
## Registrieren eines Modells
Um Autoscaling zu einem Serverless Endpunkt mit Provisioned Concurrency hinzuzufügen, müssen Sie zunächst Ihr Modell (Produktionsvariante) mithilfe AWS CLI unserer Application Auto Scaling API registrieren.
### Registrieren eines Modells (AWS CLI)
Um Ihr Modell zu registrieren, verwenden Sie den Befehl `register-scalable-target` AWS CLI mit den folgenden Parametern:
+ `--service-namespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `--resource-id`– Die Ressourcen-ID für das Modell (insbesondere die Produktionsvariante). Für diesen Parameter lautet der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Produktionsvariante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `--scalable-dimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
+ `--min-capacity`– Die Mindestanzahl von Provisioned Concurrency für das Modell. Setzen Sie `--min-capacity` auf mindestens 1. Der Wert muss gleich oder kleiner sein als der für `--max-capacity` angegebene Wert.
+ `--max-capacity`– Die maximale Anzahl an Provisioned Concurrency, die über Application Auto Scaling aktiviert werden soll. Auf mindestens 1 festgelegt`--max-capacity`. Er muss größer oder gleich dem für `--min-capacity` angegebenen Wert sein.
Das folgende Beispiel zeigt, wie man ein Modell mit dem Namen `MyVariant` registriert, das dynamisch skaliert wird und einen Wert von 1 bis 10 für die bereitgestellte Gleichzeitigkeit hat:
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--min-capacity 1 \
--max-capacity 10
```
### Ein Modell registrieren (Application Auto Scaling Anwendungen-API)
Um Ihr Modell zu registrieren, verwenden Sie die `RegisterScalableTarget` Application Auto Scaling Anwendungen-API-Aktion mit den folgenden Parametern:
+ `ServiceNamespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `ResourceId`– Die Ressourcen-ID für das Modell (insbesondere die Produktionsvariante). Für diesen Parameter lautet der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Produktionsvariante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `ScalableDimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
+ `MinCapacity`– Die Mindestanzahl von Provisioned Concurrency für das Modell. Setzen Sie `MinCapacity` auf mindestens 1. Der Wert muss gleich oder kleiner sein als der für `MaxCapacity` angegebene Wert.
+ `MaxCapacity`– Die maximale Anzahl an Provisioned Concurrency, die über Application Auto Scaling aktiviert werden soll. Auf mindestens 1 festgelegt`MaxCapacity`. Er muss größer oder gleich dem für `MinCapacity` angegebenen Wert sein.
Das folgende Beispiel zeigt, wie man ein Modell mit dem Namen `MyVariant` registriert, das dynamisch skaliert wird und einen Wert von 1 bis 10 für die bereitgestellte Gleichzeitigkeit hat:
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndPoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"MinCapacity": 1,
"MaxCapacity": 10
}
```
## Definieren einer Skalierungsrichtlinie
Um die Metriken und Zielwerte für eine Skalierungsrichtlinie festzulegen, können Sie eine Skalierungsrichtlinie mit Zielverfolgung konfigurieren. Definieren Sie die Skalierungsrichtlinie als JSON-Block in einer Textdatei. Sie können diese Textdatei dann verwenden, wenn Sie die AWS CLI oder die Applikation Auto Scaling API aufrufen. Um schnell eine Zielverfolgungs-Skalierungsrichtlinie für einen Serverless Endpunkt zu definieren, verwenden Sie die `SageMakerVariantProvisionedConcurrencyUtilization` vordefinierte Metrik.
```
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
},
"ScaleOutCooldown": 1,
"ScaleInCooldown": 1
}
```
## Anwenden einer Skalierungsrichtlinie
Nachdem Sie Ihr Modell registriert haben, können Sie mit Provisioned Concurrency eine Skalierungsrichtlinie auf Ihren Serverless Endpunkt anwenden. Sehen Sie [Anwendung einer Skalierungsrichtlinie zur Zielverfolgung](#serverless-endpoints-autoscale-apply-target), um eine von Ihnen definierte Zielverfolgungs-Skalierungsrichtlinie anzuwenden. Wenn der Datenverkehrsfluss zu Ihrem Serverless Endpunkt eine vorhersehbare Routine hat, sollten Sie Skalierungsaktionen zu bestimmten Zeiten planen, anstatt eine Skalierungsrichtlinie für die Zielverfolgung anzuwenden. Weitere Informationen zum Planen von Skalierungsaktionen finden Sie unter [Geplante Skalierung](#serverless-endpoints-autoscale-apply-scheduled).
### Anwendung einer Skalierungsrichtlinie zur Zielverfolgung
Sie können die AWS-Managementkonsole, AWS CLI oder die Applikation Auto Scaling API verwenden, um eine Skalierungsrichtlinie für die Zielverfolgung auf Ihren Serverless-Endpunkt anzuwenden.
#### Anwendung einer Zielverfolgungs-Skalierungsrichtlinie (AWS CLI)
Um eine Skalierungsrichtlinie auf Ihr Modell anzuwenden, verwenden Sie den AWS CLI-Befehl `put-scaling-policy` mit den folgenden Parametern:
+ `--policy-name` – Der Name der Skalierungsrichtlinie.
+ `--policy-type` – Legen Sie diesen Wert auf fest `TargetTrackingScaling`.
+ `--resource-id` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `--scalable-dimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
+ `--target-tracking-scaling-policy-configuration` – Die für das Modell zu verwendende Konfiguration der Skalierungsrichtlinie für die Zielverfolgung.
Das folgende Beispiel zeigt, wie eine Zielverfolgungs-Skalierungsrichtlinie namens `MyScalingPolicy` auf ein Modell namens `MyVariant`. Die Richtlinienkonfiguration wird in einer Datei mit dem Namen `scaling-policy.json` gespeichert.
```
aws application-autoscaling put-scaling-policy \
--policy-name MyScalingPolicy \
--policy-type TargetTrackingScaling \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--target-tracking-scaling-policy-configuration file://[file-localtion]/scaling-policy.json
```
#### Wenden Sie eine Skalierungsrichtlinie zur Zielverfolgung an (Application Auto Scaling API)
Um eine Skalierungsrichtlinie auf Ihr Modell anzuwenden, verwenden Sie die `PutScalingPolicy` Application Auto Scaling Anwendungen-API-Aktion mit den folgenden Parametern:
+ `PolicyName` – Der Name der Skalierungsrichtlinie.
+ `PolicyType` – Legen Sie diesen Wert auf fest `TargetTrackingScaling`.
+ `ResourceId` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `ScalableDimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
+ `TargetTrackingScalingPolicyConfiguration` – Die für das Modell zu verwendende Konfiguration der Skalierungsrichtlinie für die Zielverfolgung.
Das folgende Beispiel zeigt, wie eine Zielverfolgungs-Skalierungsrichtlinie namens `MyScalingPolicy` auf ein Modell namens `MyVariant`. Die Richtlinienkonfiguration wird in einer Datei mit dem Namen `scaling-policy.json` gespeichert.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration":
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
}
}
}
```
#### Anwendung einer Zielverfolgungs-Skalierungsrichtlinie (AWS-Managementkonsole)
Zur Anwendung einer Zielverfolgungs-Skalierungsrichtlinie mit dem AWS-Managementkonsole:
1. Melden Sie sich bei der [Konsole von Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/) an.
1. Wählen Sie im Navigationsbereich **Inferenz** aus.
1. Wählen Sie **Endpunkte** aus, um eine Liste all Ihrer Endpoints anzuzeigen.
1. Wählen Sie den Endpunkt aus, auf den Sie die Skalierungsrichtlinie anwenden möchten. Es wird eine Seite mit den Einstellungen des Endpunkts angezeigt, auf der die Modelle (Produktionsvariante) im **Abschnitt Endpunkt-Laufzeiteinstellungen** aufgeführt sind.
1. Wählen Sie die Produktionsvariante aus, auf die Sie die Skalierungsrichtlinie anwenden möchten, und wählen Sie **Auto Scaling konfigurieren**. Das Dialogfenster **Automatische Skalierung der Variante konfigurieren** wird angezeigt.
![\[Screenshot des Dialogfelds Automatische Skalierung der Variante konfigurieren in der Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/serverless-endpoints-variant-autoscaling.png)
1. Geben Sie die minimalen und maximalen Werte für die bereitgestellte Parallelität in die Felder **Minimale bereitgestellte Parallelität** bzw. **Maximale bereitgestellte Parallelität** im Abschnitt **Automatische Skalierung der Variante** ein. Die minimale bereitgestellte Parallelität muss kleiner oder gleich der maximalen bereitgestellten Parallelität sein.
1. Geben Sie den Zielwert in das Feld **Zielwert** für die Zielmetrik, `SageMakerVariantProvisionedConcurrencyUtilization` ein.
1. (Optional) Geben Sie in den Feldern **Verkleinern bei Abkühlung** und **Vergrößern bei Abkühlung** Werte für die Abkühlung (in Sekunden) ein.
1. (Optional) Wählen Sie **Skalierung deaktivieren** aus, wenn Sie nicht möchten, dass Auto Scaling die Instance löscht, wenn der Traffic abnimmt.
1. Wählen Sie **Save (Speichern)**.
### Geplante Skalierung
Wenn der Datenverkehr zu Ihrem Serverless Endpunkt mit Provisioned Concurrency einem Routinemuster folgt, sollten Sie Skalierungsaktionen zu bestimmten Zeiten planen, um Provisioned Concurrency ab- oder aufskalieren. Sie können das AWS CLI oder das Application Auto Scaling verwenden, um Skalierungsaktionen zu planen.
#### Geplante Skalierung (AWS CLI)
Um eine Skalierungsrichtlinie auf Ihr Modell anzuwenden, verwenden Sie den AWS CLI-Befehl `put-scheduled-action` mit den folgenden Parametern:
+ `--schedule-action-name` – Der Name der Skalierungsrichtlinie.
+ `--schedule`– Ein Cron-Ausdruck, der die Start- und Endzeiten der Skalierungsaktion mit einem wiederkehrenden Zeitplan angibt.
+ `--resource-id` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `--scalable-dimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
+ `--scalable-target-action`– Das Ziel der Skalierungsaktion.
Das folgende Beispiel zeigt, wie eine Skalierungsaktion namens `MyScalingAction` zu einem Modell namens `MyVariant` in einem wiederkehrenden Zeitplan hinzugefügt wird. Nach dem angegebenen Zeitplan (täglich um 12:15 Uhr UTC), wenn die aktuelle Provisioned Concurrency unter dem für angegebenen `MinCapacity` Wert liegt. Application Auto Scaling skaliert die bereitgestellte Parallelität auf den von `MinCapacity` angegebenen Wert.
```
aws application-autoscaling put-scheduled-action \
--scheduled-action-name 'MyScalingAction' \
--schedule 'cron(15 12 * * ? *)' \
--service-namespace sagemaker \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--scalable-target-action 'MinCapacity=10'
```
#### Geplante Skalierung (Application Auto Scaling API)
Um eine Skalierungsrichtlinie auf Ihr Modell anzuwenden, verwenden Sie die `PutScheduledAction` Application Auto Scaling Anwendungen-API-Aktion mit den folgenden Parametern:
+ `ScheduleActionName` – Der Name der Skalierungsaktion.
+ `Schedule`– Ein Cron-Ausdruck, der die Start- und Endzeiten der Skalierungsaktion mit einem wiederkehrenden Zeitplan angibt.
+ `ResourceId` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `ScalableDimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
+ `ScalableTargetAction`– Das Ziel der Skalierungsaktion.
Das folgende Beispiel zeigt, wie eine Skalierungsaktion namens `MyScalingAction` zu einem Modell namens `MyVariant` in einem wiederkehrenden Zeitplan hinzugefügt wird. Nach dem angegebenen Zeitplan (täglich um 12:15 Uhr UTC), wenn die aktuelle Provisioned Concurrency unter dem für angegebenen `MinCapacity` Wert liegt. Application Auto Scaling skaliert die bereitgestellte Parallelität auf den von `MinCapacity` angegebenen Wert.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScheduledAction
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ScheduledActionName": "MyScalingAction",
"Schedule": "cron(15 12 * * ? *)",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"ScalableTargetAction": "MinCapacity=10"
}
}
}
```
# Bereinigen
Nachdem Sie die Verwendung von Auto Scaling für Ihren Serverless-Endpunkt mit Provisioned Concurrency abgeschlossen haben, sollten Sie die von Ihnen erstellten Ressourcen bereinigen. Dies beinhaltet das Löschen der Skalierungsrichtlinie und das Abmelden des Modells von Application Auto Scaling. Durch die Bereinigung wird sichergestellt, dass Ihnen keine unnötigen Kosten für Ressourcen entstehen, die Sie nicht mehr verwenden.
## Löschen einer Skalierungsrichtlinie
Sie können eine Skalierungsrichtlinie über die AWS-Managementkonsole, die AWS CLI oder die Application-Auto-Scaling-API löschen. Weitere Informationen dazu, wie Sie mit dem AWS-Managementkonsole eine Skalierungsrichtlinie löschen können, finden Sie [Löschen einer Skalierungsrichtlinie](endpoint-auto-scaling-delete.md) in der [Dokumentation zur automatischen Skalierung von SageMaker AI](endpoint-auto-scaling.md).
### Löschen einer Skalierungsrichtlinie (AWS CLI)
Um eine Skalierungsrichtlinie auf Ihr Modell anzuwenden, verwenden Sie den AWS CLI-Befehl `delete-scaling-policy` mit den folgenden Parametern:
+ `--policy-name` – Der Name der Skalierungsrichtlinie.
+ `--resource-id` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `--scalable-dimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
Das folgende Beispiel löscht die Skalierungsrichtlinie namens `MyScalingPolicy` aus einem Modell namens `MyVariant`.
```
aws application-autoscaling delete-scaling-policy \
--policy-name MyScalingPolicy \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### Löschen Sie eine Skalierungsrichtlinie (Application Auto Scaling API)
Um eine Skalierungsrichtlinie für Ihr Modell zu löschen, verwenden Sie die `DeleteScalingPolicy` API-Aktion Application Auto Scaling mit den folgenden Parametern:
+ `PolicyName` – Der Name der Skalierungsrichtlinie.
+ `ResourceId` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `ScalableDimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
Im folgenden Beispiel wird die Application Auto Scaling-API verwendet, um eine Skalierungsrichtlinie namens `MyScalingPolicy` aus einem Modell namens `MyVariant` zu löschen.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
## Ein Modell abmelden
Sie können die Registrierung eines Modells über die AWS-Managementkonsole, die AWS CLI oder die Application Auto Scaling Anwendungen-API abmelden.
### Ein Modell deregistrieren (AWS CLI)
Um ein Modell von Application Auto Scaling abzumelden, verwenden Sie den `deregister-scalable-target`AWS CLI; -Befehl mit den folgenden Parametern:
+ `--resource-id` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `--scalable-dimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
Das folgende Beispiel deregistriert ein Modell namens dasda von `MyVariant` Application Auto Scaling.
```
aws application-autoscaling deregister-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### Einen Model abmelden (Application Auto Scaling Anwendungen-API)
Um ein Modell von Application Auto Scaling abmelden zu lassen, verwenden Sie die `DeregisterScalableTarget` Application Auto Scaling Anwendungen-API-Aktion mit den folgenden Parametern:
+ `ResourceId` – Die Ressourcenkennung für die Variante. Für diesen Parameter ist der Ressourcentyp `endpoint` und die eindeutige Kennung ist der Name der Variante. Zum Beispiel `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` – Legen Sie diesen Wert auf `sagemaker` fest.
+ `ScalableDimension` – Legen Sie diesen Wert auf `sagemaker:variant:DesiredProvisionedConcurrency` fest.
Das folgende Beispiel verwendet die Application Auto Scaling-API, um ein Modell namens `MyVariant` von Application Auto Scaling abzumelden.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeregisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
### Ein Modell deregistrieren (AWS-Managementkonsole)
Um ein Modell (Produktionsvariante) abzumelden mit AWS-Managementkonsole:
1. Öffnen Sie die [Konsole von Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im Navigationsbereich **Inferenz** aus.
1. Wählen Sie **Endpunkte** aus, um eine Liste Ihrer Endpunkte anzuzeigen.
1. Wählen Sie den Serverless-Endpunkt aus, der die Produktionsvariante hostet. Eine Seite mit den Einstellungen des Endpunkts wird angezeigt. Die Produktionsvarianten sind im Abschnitt **Endpunkt-Laufzeiteinstellungen** aufgeführt.
1. Wählen Sie die Produktionsvariante aus, die Sie abmelden möchten, und wählen Sie **Auto Scaling konfigurieren**. Die Seite **Configure variant automatic scaling (Auto Scaling von Varianten konfigurieren)** wird angezeigt.
1. Wählen Sie **Deregister auto scaling (Auto Scaling abmelden)** aus.
# Fehlerbehebung
**Wichtig**
Benutzerdefinierte IAM-Richtlinien, die es Amazon SageMaker Studio oder Amazon SageMaker Studio Classic ermöglichen, Amazon-SageMaker-Ressourcen zu erstellen, müssen auch Berechtigungen zum Hinzufügen von Tags zu diesen Ressourcen gewähren. Die Berechtigung zum Hinzufügen von Tags zu Ressourcen ist erforderlich, da Studio und Studio Classic automatisch alle von ihnen erstellten Ressourcen taggen. Wenn eine IAM-Richtlinie Studio und Studio Classic das Erstellen von Ressourcen, aber kein Tagging erlaubt, können bei dem Versuch, Ressourcen zu erstellen, „AccessDenied“-Fehler auftreten. Weitere Informationen finden Sie unter [Erteilen Sie Berechtigungen für das Taggen von SageMaker KI-Ressourcen](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS verwaltete Richtlinien für Amazon SageMaker AI](security-iam-awsmanpol.md), die Berechtigungen zum Erstellen von SageMaker-Ressourcen gewähren, enthalten bereits Berechtigungen zum Hinzufügen von Tags während der Erstellung dieser Ressourcen.
Wenn Sie Probleme mit Serverless Inference haben, lesen Sie die folgenden Tipps zur Fehlerbehebung.
## Probleme mit Containern
Wenn der Container, den Sie für einen serverlosen Endpunkt verwenden, derselbe ist, den Sie auf einem instance-basierten Endpunkt verwendet haben, ist Ihr Container möglicherweise nicht berechtigt, Dateien zu schreiben. Dies kann aus einem der folgenden Gründe geschehen:
+ Ihr serverloser Endpunkt kann aufgrund eines Fehlers bei der Ping-Integritätsprüfung nicht erstellt oder aktualisiert werden.
+ Die Amazon CloudWatch-Protokolle für den Endpunkt zeigen, dass der Container aufgrund eines Berechtigungsfehlers nicht in eine Datei oder ein Verzeichnis schreiben kann.
Um dieses Problem zu beheben, können Sie versuchen, Lese-, Schreib- und Ausführungsberechtigungen für `other` die Datei oder das Verzeichnis hinzuzufügen und dann den Container neu zu erstellen. Gehen Sie für dieses Tutorial wie folgt vor:
1. Fügen Sie in der Dockerfile, mit der Sie Ihren Container erstellt haben, den folgenden Befehl hinzu: `RUN chmod o+rwX `
1. Bauen Sie den Container neu auf.
1. Laden Sie das Image in Ihre Amazon-ECR-Container-Registry hoch.
1. Versuchen Sie erneut, den serverlosen Endpunkt zu erstellen oder zu aktualisieren.
# Asynchrone Inferenz-Inferenz
Amazon SageMaker Asynchronous Inference ist eine SageMaker KI-Funktion, die eingehende Anfragen in die Warteschlange stellt und sie asynchron verarbeitet. Diese Option ist ideal für Anfragen mit großen Nutzlasten (bis zu 1 GB), langen Verarbeitungszeiten (bis zu einer Stunde) und Latenzanforderungen nahezu in Echtzeit. Asynchrone Inferenz ermöglicht es Ihnen, Kosten zu sparen, indem Sie die Anzahl der Instances automatisch auf Null skalieren, wenn keine Anfragen zu verarbeiten sind. Sie zahlen also nur, wenn Ihr Endpunkt Anfragen verarbeitet.
## So funktioniert’s
Die Erstellung eines asynchronen Inferenzendpunkts ähnelt der Erstellung von Echtzeit-Inferenzendpunkten. Sie können Ihre vorhandenen SageMaker KI-Modelle verwenden und müssen nur das `AsyncInferenceConfig` Objekt angeben, während Sie Ihre Endpunktkonfiguration mit dem `EndpointConfig` Feld in der API erstellen. `CreateEndpointConfig` Das folgende Diagramm zeigt die Architektur und den Arbeitsablauf von Asynchronous Inference.
![\[Architekturdiagramm von Asynchronous Inference, das zeigt, wie ein Benutzer einen Endpunkt aufruft.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/async-architecture.png)
Um den Endpunkt aufzurufen, müssen Sie die Nutzdaten der Anfrage in Amazon S3 platzieren. Sie müssen als Teil der `InvokeEndpointAsync`-Anfrage auch einen Verweis auf diese Nutzdaten angeben. Beim Aufruf stellt SageMaker AI die Anfrage zur Verarbeitung in eine Warteschlange und gibt als Antwort eine Kennung und einen Ausgabeort zurück. Nach der Verarbeitung platziert SageMaker KI das Ergebnis am Amazon S3 S3-Standort. Sie können optional wählen, ob Sie Erfolgs- oder Fehlerbenachrichtigungen mit Amazon SNS erhalten möchten. Weitere Informationen zum Einrichten asynchroner Benachrichtigungen finden Sie unter [Überprüfen Sie die Ergebnisse der Prognose](async-inference-check-predictions.md).
**Anmerkung**
Das Vorhandensein eines asynchronen Inferenz-Configuration (`AsyncInferenceConfig`) Objekts in der Endpunktkonfiguration bedeutet, dass der Endpunkt nur asynchrone Aufrufe empfangen kann.
## Was sind die ersten Schritte?
Wenn Sie Amazon SageMaker Asynchronous Inference zum ersten Mal verwenden, empfehlen wir Ihnen, wie folgt vorzugehen:
+ Weitere Informationen zum Erstellen, Aufrufen, Aktualisieren und Löschen eines asynchronen Endpunkts finden Sie unter [Asynchrone Endpunktoperationen](async-inference-create-invoke-update-delete.md).
+ [Erkunden Sie das [Beispiel-Notizbuch für Asynchronous Inference im aws/-Repository](https://github.com/aws/amazon-sagemaker-examples/blob/main/async-inference/Async-Inference-Walkthrough.ipynb). amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub
Beachten Sie, dass Sie Asynchronous Inference nicht verwenden können, wenn Ihr Endpunkt eine der auf dieser [Ausschlüsse](deployment-guardrails-exclusions.md) Seite aufgeführten Funktionen verwendet.
# Asynchrone Endpunktoperationen
In diesem Handbuch werden die Voraussetzungen beschrieben, die Sie erfüllen müssen, um einen asynchronen Endpunkt zu erstellen, sowie wie Sie Ihre asynchronen Endpunkte erstellen, aufrufen und löschen. Sie können asynchrone Endpoints mit dem [Amazon SageMaker ](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-asynchronous-inference) Python SDK erstellen, aktualisieren, löschen AWS SDKs und aufrufen.
**Topics**
+ [Erfüllen der Voraussetzungen](async-inference-create-endpoint-prerequisites.md)
+ [So erstellen Sie einen asynchronen Inferenzendpunkt](async-inference-create-endpoint.md)
+ [Rufen Sie einen asynchronen Endpunkt auf](async-inference-invoke-endpoint.md)
+ [Aktualisieren Sie einen asynchronen Endpunkt](async-inference-update-endpoint.md)
+ [Löschen eines asynchronen Endpunktes](async-inference-delete-endpoint.md)
# Erfüllen der Voraussetzungen
Im folgenden Thema werden die Voraussetzungen beschrieben, die erfüllt werden müssen, bevor Sie einen asynchronen Endpunkt erstellen können. Zu diesen Voraussetzungen gehören das ordnungsgemäße Speichern Ihrer Modellartefakte, die Konfiguration eines AWS IAM mit den richtigen Berechtigungen und die Auswahl eines Container-Images.
**So erfüllen Sie die Voraussetzungen**
1. **Erstellen Sie eine IAM-Rolle für Amazon SageMaker AI.**
Asynchrone Inferenz benötigt Zugriff auf Ihren Amazon-S3-Bucket-URI. Um dies zu erleichtern, erstellen Sie eine IAM-Rolle, die SageMaker KI ausführen kann und über Zugriffsberechtigungen für Amazon S3 und Amazon SNS verfügt. Mit dieser Rolle kann SageMaker KI unter Ihrem Konto ausgeführt werden und auf Ihren Amazon S3-Bucket und Ihre Amazon SNS SNS-Themen zugreifen.
Sie können eine IAM-Rolle mithilfe der IAM-Konsole,, AWS SDK für Python (Boto3) oder erstellen. AWS CLI Im Folgenden finden Sie ein Beispiel, wie Sie eine IAM-Rolle erstellen und die erforderlichen Richtlinien an die IAM-Konsole anfügen.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Klicken Sie im Navigationsbereich der IAM-Konsole auf **Roles** und wählen Sie dann **Create role**.
1. Wählen Sie unter **Select type of trusted entity (Typ der vertrauenswürdigen Entität wählen)** die Option **AWS service (Service)**.
1. Wählen Sie den Service aus, dem Sie das Übernehmen dieser Rolle erlauben wollen. Wählen Sie in diesem Fall **SageMaker AI**. Wählen Sie dann **Next: Permissions**.
+ Dadurch wird automatisch eine IAM-Richtlinie erstellt, die Zugriff auf verwandte Dienste wie Amazon S3, Amazon ECR und CloudWatch Logs gewährt.
1. Wählen Sie **Weiter: Tags** aus.
1. (Optional) Fügen Sie der Rolle Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen dazu, wie Sie verwenden können von Tags mit IAM finden Sie unter [Tagging von Amazon RDSIAM-Ressourcen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Wählen Sie **Weiter: Prüfen** aus.
1. Geben Sie einen **Namen für die Rolle** ein.
1. Geben Sie möglichst einen Rollennamen oder ein Rollennamen-Suffix ein. Rollennamen müssen innerhalb Ihres AWS Kontos eindeutig sein. Sie werden nicht nach Groß- und Kleinschreibung unterschieden. z. B. können Sie keine Rollen erstellen, die `PRODROLE` bzw. `prodrole` heißen. Da andere AWS Ressourcen möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nicht bearbeiten, nachdem sie erstellt wurde.
1. (Optional) Geben Sie im Feld **Role description** eine Beschreibung für die neue Rolle ein.
1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.
Beachten Sie den ARN der SageMaker AI-Rolle. Um den Rollen-ARN mithilfe der Konsole zu finden, führen Sie die folgenden Schritte aus:
1. Gehen Sie zur IAM-Konsole: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie **Rollen** aus.
1. Suchen Sie nach der Rolle, die Sie gerade erstellt haben, indem Sie den Namen der Rolle in das Suchfeld eintippen.
1. Wählen Sie die Rolle aus.
1. Der Rollen-ARN befindet sich oben auf der **Übersichtsseite**.
1. **Fügen Sie Amazon SageMaker AI-, Amazon S3- und Amazon SNS SNS-Berechtigungen zu Ihrer IAM-Rolle hinzu.**
Sobald die Rolle erstellt wurde, gewähren Sie Ihrer IAM-Rolle SageMaker AI-, Amazon S3- und optional Amazon SNS-Berechtigungen.
Wählen Sie in der IAM-Konsole **Rollen** aus. Suchen Sie nach der von Ihnen erstellten Rolle, indem Sie Ihren Rollennamen in das **Suchfeld** eingeben.
1. Wählen Sie Ihre Rolle.
1. Wählen Sie **Attach Policies**.
1. Amazon SageMaker Asynchronous Inference benötigt die Genehmigung, um die folgenden Aktionen auszuführen:`"sagemaker:CreateModel"`, `"sagemaker:CreateEndpointConfig"``"sagemaker:CreateEndpoint"`, und. `"sagemaker:InvokeEndpointAsync"`
Diese Aktionen sind in der `AmazonSageMakerFullAccess` Richtlinie enthalten. Fügen Sie diese Richtlinie zu Ihrer IAM-Rolle hinzu. Suchen Sie `AmazonSageMakerFullAccess` im **Suchfeld** nach . Wählen Sie `AmazonSageMakerFullAccess` aus.
1. Wählen Sie **Richtlinie anfügen** aus.
1. Wählen Sie anschließend **Attach Policies** aus, um Amazon S3-Berechtigungen hinzuzufügen.
1. Wählen Sie **Create Policy**.
1. Wählen Sie die Registerkarte `JSON` aus.
1. Fügen Sie die folgende Richtlinien Erklärung hinzu:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::bucket_name/*"
}
]
}
```
------
1. Wählen Sie **Weiter: Tags** aus.
1. Geben Sie einen **Namen für die Richtlinie** ein.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wiederholen Sie dieselben Schritte, die Sie zum Hinzufügen von Amazon S3-Berechtigungen ausgeführt haben, um Amazon SNS SNS-Berechtigungen hinzuzufügen. Fügen Sie der Grundsatzerklärung Folgendes bei:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sns:Publish"
],
"Effect": "Allow",
"Resource": "arn:aws:sns:us-east-1:111122223333:SNS_Topic"
}
]
}
```
------
1. **Laden Sie Ihre Inferenzdaten (z. B. Modell für Machine Learning, Beispieldaten) auf **Amazon S3** hoch.**
1. **Wählen Sie ein vorgefertigtes Docker-Inferenz-Image aus oder erstellen Sie Ihr eigenes Inference-Docker-Image.**
SageMaker AI stellt Container für seine integrierten Algorithmen und vorgefertigte Docker-Images für einige der gängigsten Frameworks für maschinelles Lernen wie Apache MXNet,, und Chainer bereit. TensorFlow PyTorch Eine vollständige Liste der verfügbaren SageMaker KI-Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Wenn Sie sich dafür entscheiden, einen von SageMaker KI bereitgestellten Container zu verwenden, können Sie das Endpunkt-Timeout und die Payload-Größe gegenüber den Standardeinstellungen erhöhen, indem Sie die Umgebungsvariablen im Container festlegen. Informationen zum Einstellen der verschiedenen Umgebungsvariablen für jedes Framework finden Sie im Schritt Modell erstellen unter Erstellen eines asynchronen Endpunkts.
Wenn keiner der vorhandenen SageMaker KI-Container Ihren Anforderungen entspricht und Sie keinen eigenen Container haben, müssen Sie möglicherweise einen neuen Docker-Container erstellen. Informationen [Container mit benutzerdefiniertem Inferenzcode](your-algorithms-inference-main.md) zum Erstellen eines Docker-Images
1. **Erstellen Sie ein Amazon-SNS-Thema (optional)**
Erstellen Sie ein Amazon-Simple-Notification-Service Simple Notification Service (Amazon SNS) -Thema, das Benachrichtigungen über Anfragen sendet, deren Bearbeitung abgeschlossen ist. Amazon SNS ist ein Benachrichtigungsservice für messaging-orientierte Anwendungen, bei dem mehrere Abonnenten „Push“ -Benachrichtigungen über zeitkritische Nachrichten über verschiedene Transportprotokolle, darunter HTTP, Amazon SQS und E-Mail, anfordern und empfangen. Sie können Amazon SNS-Themen angeben, wenn Sie ein `EndpointConfig` Objekt erstellen, wenn Sie es `AsyncInferenceConfig` mithilfe der `EndpointConfig` API angeben.
Gehen Sie wie folgt vor, um ein Amazon SNS-Thema zu erstellen und zu abonnieren.
1. Erstellen Sie mit der Amazon SNS-Konsole ein Thema. Eine Anleitung finden Sie unter [Amazon SNS-Thema anlegen](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) im *Amazon Simple Notification Service* *Entwicklerhandbuch*.
1. Abonnieren Sie das Thema. Eine Anleitung finden Sie unter [Abonnieren eines Amazon SNS-Themas](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) im *Amazon Simple Notification Service* *Entwicklerhandbuch*.
1. Wenn Sie eine E-Mail erhalten, in der Sie aufgefordert werden, das Abonnement des Themas zu bestätigen, bestätigen Sie das Abonnement.
1. Notieren Sie den ARN (Amazon-Ressourcenname). Das von Ihnen erstellte Amazon SNS SNS-Thema ist eine weitere Ressource in Ihrem AWS Konto und hat einen eindeutigen ARN. Der ARN muss das folgende Format aufweisen:
```
arn:aws:sns:aws-region:account-id:topic-name
```
Weitere Informationen zu Amazon SNS-Themen finden Sie im [Amazon SNS-Entwicklerhandbuch](https://docs.aws.amazon.com/sns/latest/dg/welcome.html).
# So erstellen Sie einen asynchronen Inferenzendpunkt
Erstellen Sie einen asynchronen Endpunkt auf die gleiche Weise, wie Sie einen Endpunkt mithilfe von SageMaker KI-Hosting-Diensten erstellen würden:
+ Erstellen Sie ein Modell in SageMaker KI mit`CreateModel`.
+ Erstellen Sie eine Endpunktkonfiguration mit `CreateEndpointConfig`.
+ Erstellen Sie einen HTTPS-Endpunkt mit `CreateEndpoint`.
Um einen Endpunkt zu erstellen, erstellen Sie zunächst ein Modell mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), wobei Sie auf das Modellartefakt und einen Docker-Registry-Pfad (Image) verweisen. Anschließend erstellen Sie eine Konfiguration, [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)in der Sie ein oder mehrere Modelle angeben, die mithilfe der `CreateModel` API zur Bereitstellung erstellt wurden, sowie die Ressourcen, die SageMaker KI bereitstellen soll. Erstellen Sie einen Endpunkt mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) unter Verwendung der in der Anforderung angegebenen Endpunktkonfiguration Sie können einen asynchronen Endpunkt mit der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API aktualisieren. Senden und Empfangen von Inferenzanfragen von dem auf dem Endpunkt gehosteten Modell mit `InvokeEndpointAsync`. Sie können Ihre Endpunkte mit der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API löschen.
Eine vollständige Liste der verfügbaren SageMaker Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Informationen [Container mit benutzerdefiniertem Inferenzcode](your-algorithms-inference-main.md) zum Erstellen eines Docker-Images
**Topics**
+ [Erstellen eines Modells](async-inference-create-endpoint-create-model.md)
+ [Erstellen einer Endpunktkonfiguration](async-inference-create-endpoint-create-endpoint-config.md)
+ [Erstellen eines Endpunkts](async-inference-create-endpoint-create-endpoint.md)
# Erstellen eines Modells
Das folgende Beispiel zeigt, wie man ein Modell mit Hilfe des AWS SDK für Python (Boto3). Die ersten paar Zeilen definieren:
+ `sagemaker_client`: Ein SageMaker KI-Client-Objekt auf niedriger Ebene, das das Senden und Empfangen von Anfragen an AWS Dienste vereinfacht.
+ `sagemaker_role`: Eine Zeichenkettenvariable mit der SageMaker AI IAM-Rolle Amazon Resource Name (ARN).
+ `aws_region`: Eine Zeichenkettenvariable mit dem Namen Ihrer AWS Region.
```
import boto3
# Specify your AWS Region
aws_region=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam:::role/*"
```
Geben Sie als Nächstes den Speicherort des vortrainierten Modells an, das in Amazon S3 gespeichert ist. In diesem Beispiel verwenden wir ein vortrainiertes XGBoost Modell mit dem Namen`demo-xgboost-model.tar.gz`. Die vollständige Amazon-S3-URI wird in einer Zeichenkettenvariablen gespeichert `model_url`:
```
#Create a variable w/ the model S3 URI
s3_bucket = '' # Provide the name of your S3 bucket
bucket_prefix='saved_models'
model_s3_key = f"{bucket_prefix}/demo-xgboost-model.tar.gz"
#Specify S3 bucket w/ model
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
Geben Sie einen primären Container an. Für den primären Container geben Sie das Docker-Image an, das den Inferenzcode, Artefakte (aus früheren Trainings) und eine benutzerdefinierte Umgebungszuordnung enthält, die der Inferenzcode verwendet, wenn Sie das Modell für Vorhersagen einsetzen.
In diesem Beispiel spezifizieren wir ein XGBoost integriertes Algorithmus-Container-Image:
```
from sagemaker import image_uris
# Specify an AWS container image.
container = image_uris.retrieve(region=aws_region, framework='xgboost', version='0.90-1')
```
Erstellen Sie ein Modell in Amazon SageMaker AI mit`CreateModel`. Machen Sie folgende Angaben:
+ `ModelName`: Ein Name für Ihr Modell (in diesem Beispiel wird es als String-variable namens `model_name` gespeichert).
+ `ExecutionRoleArn`: Der Amazon-Ressourcenname (ARN) der IAM-Rolle, die Amazon SageMaker AI übernehmen kann, um auf Modellartefakte und Docker-Images für die Bereitstellung auf ML-Compute-Instances oder für Batch-Transformationsjobs zuzugreifen.
+ `PrimaryContainer`: Der Speicherort des primären Docker-Image mit Inferenzcode, zugehörigen Artefakten und benutzerdefinierter Umgebungs-Map, die der Inferenz-Code verwendet, wenn das Modell für die Voraussagen bereitgestellt wird.
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
})
```
Eine vollständige Liste der SageMaker API-Parameter finden Sie in der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)Beschreibung im API-Referenzhandbuch.
Wenn Sie einen von SageMaker KI bereitgestellten Container verwenden, können Sie das Timeout für den Modellserver und die Nutzlastgrößen von den Standardwerten auf die vom Framework unterstützten Höchstwerte erhöhen, indem Sie in diesem Schritt Umgebungsvariablen festlegen. Wenn Sie diese Variablen nicht explizit festlegen, können Sie die maximalen Timeout- und Payload-Größen, die Asynchronous Inference unterstützt, möglicherweise nicht nutzen. Das folgende Beispiel zeigt, wie Sie die Umgebungsvariablen für einen Inferenzcontainer auf der Grundlage von festlegen können. PyTorch TorchServe
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
'Environment': {
'TS_MAX_REQUEST_SIZE': '100000000',
'TS_MAX_RESPONSE_SIZE': '100000000',
'TS_DEFAULT_RESPONSE_TIMEOUT': '1000'
},
})
```
Nachdem Sie Ihren Endpunkt erstellt haben, sollten Sie testen, ob Sie die Umgebungsvariablen korrekt gesetzt haben, indem Sie sie aus Ihrem Skript `inference.py` ausdrucken. In der folgenden Tabelle sind die Umgebungsvariablen für verschiedene Frameworks aufgeführt, die Sie festlegen können, um die Standardwerte zu ändern.
| Framework | Umgebungsvariablen |
| --- | --- |
| PyTorch 1.8 (basierend auf TorchServe) | 'TS\$1MAX\$1REQUEST\$1SIZE': '100000000' 'TS\$1MAX\$1RESPONSE\$1SIZE': '100000000' 'TS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '1000' |
| PyTorch 1.4 (basierend auf MMS) | 'MMS\$1MAX\$1REQUEST\$1SIZE': '1000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE': '1000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '900' |
| HuggingFace Inference Container (basierend auf MMS) | 'MMS\$1MAX\$1REQUEST\$1SIZE': '2000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE': '2000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '900' |
# Erstellen einer Endpunktkonfiguration
Sobald Sie ein Modell haben, erstellen Sie eine Endpunktkonfiguration mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Amazon SageMaker AI Hosting Services verwendet diese Konfiguration zur Bereitstellung von Modellen. In der Konfiguration identifizieren Sie ein oder mehrere Modelle, die mit with erstellt wurden [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), um die Ressourcen bereitzustellen, die Amazon SageMaker AI bereitstellen soll. Geben Sie das `AsyncInferenceConfig` Objekt an und geben Sie einen Amazon S3-Ausgabespeicherort für `OutputConfig`. Sie können optional [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) Themen angeben, zu denen Benachrichtigungen über Prognoseergebnisse gesendet werden sollen. Weitere Informationen zu Amazon SNS-Themen finden Sie unter [Konfigurieren von Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html).
Das folgende Beispiel zeigt, wie Sie eine Endpunktkonfiguration mit AWS SDK für Python (Boto3) erstellen:
```
import datetime
from time import gmtime, strftime
# Create an endpoint config name. Here we create one based on the date
# so it we can search endpoints based on creation time.
endpoint_config_name = f"XGBoostEndpointConfig-{strftime('%Y-%m-%d-%H-%M-%S', gmtime())}"
# The name of the model that you want to host. This is the name that you specified when creating the model.
model_name=''
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name, # You will specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": f"s3://{s3_bucket}/{bucket_prefix}/output"
# (Optional) specify Amazon SNS topics
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
},
"ClientConfig": {
# (Optional) Specify the max number of inflight invocations per instance
# If no value is provided, Amazon SageMaker will choose an optimal value for you
"MaxConcurrentInvocationsPerInstance": 4
}
}
)
print(f"Created EndpointConfig: {create_endpoint_config_response['EndpointConfigArn']}")
```
Im oben genannten Beispiel geben Sie die folgenden Schlüssel für `OutputConfig` für `AsyncInferenceConfig` Feld an:
+ `S3OutputPath`: Ort zum Hochladen von Antwortausgaben, wenn in der Anfrage kein Standort angegeben ist.
+ `NotificationConfig`: (Optional) SNS-Themen, die Benachrichtigungen an Sie senden, wenn eine Inferenzanfrage erfolgreich (`SuccessTopic`) ist oder fehlschlägt (`ErrorTopic`).
Sie können in dem Feld auch das folgende optionale Argument für `ClientConfig` in `AsyncInferenceConfig` angeben:
+ `MaxConcurrentInvocationsPerInstance`: (Optional) Die maximale Anzahl gleichzeitiger Anfragen, die vom SageMaker AI-Client an den Modellcontainer gesendet werden.
# Erstellen eines Endpunkts
Sobald Sie Ihr Modell und Ihre Endpunktkonfiguration haben, verwenden Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API, um Ihren Endpunkt zu erstellen. Der Endpunktname muss innerhalb einer AWS Region in Ihrem AWS Konto eindeutig sein.
Im Folgenden wird ein Endpunkt unter Verwendung der in der Anfrage angegebenen Endpunktkonfiguration erstellt. Amazon SageMaker AI verwendet den Endpunkt, um Ressourcen bereitzustellen und Modelle bereitzustellen.
```
# The name of the endpoint.The name must be unique within an AWS Region in your AWS account.
endpoint_name = ''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
```
Wenn Sie die `CreateEndpoint` API aufrufen, sendet Amazon SageMaker Asynchronous Inference eine Testbenachrichtigung, um zu überprüfen, ob Sie ein Amazon SNS SNS-Thema konfiguriert haben. Amazon SageMaker Asynchronous Inference sendet auch Testbenachrichtigungen nach `UpdateEndpoint` Aufrufen von und. `UpdateEndpointWeightsAndCapacities` Auf diese Weise kann SageMaker KI überprüfen, ob Sie über die erforderlichen Berechtigungen verfügen. Die Benachrichtigung kann einfach ignoriert werden. Die Test-Benachrichtigung verfügt über das folgende Format:
```
{
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"TestNotification"
}
```
# Rufen Sie einen asynchronen Endpunkt auf
Rufen Sie Rückschlüsse aus dem Modell ab, das auf Ihrem asynchronen Endpunkt mit `InvokeEndpointAsync` gehostet wird.
**Anmerkung**
Falls Sie dies noch nicht getan haben, laden Sie Ihre Inferenzdaten (z. B. Modell für Machine Learning, Beispieldaten) auf Amazon S3 hoch.
Geben Sie in Ihrer Anfrage die folgenden Felder an:
+ Geben Sie für `InputLocation` den Speicherort Ihrer Inferenzdaten an.
+ Geben Sie für `EndpointName` den Namen Ihres Endpunktes an.
+ (Optional) Für `InvocationTimeoutSeconds` können Sie das maximale Timeout für die Anfragen festlegen. Sie können diesen Wert pro Anfrage auf ein Maximum von 3600 Sekunden (eine Stunde) festlegen. Wenn Sie dieses Feld in Ihrer Anfrage nicht angeben, wird das Zeitlimit für die Anfrage standardmäßig nach 15 Minuten überschritten.
```
# Create a low-level client representing Amazon SageMaker Runtime
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the location of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# After you deploy a model into production using SageMaker AI hosting
# services, your client applications use this API to get inferences
# from the model hosted at the specified endpoint.
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName=endpoint_name,
InputLocation=input_location,
InvocationTimeoutSeconds=3600)
```
Sie erhalten eine Antwort als JSON-Strings mit Ihrer Anforderungs-ID und dem Namen des Amazon S3-Buckets, der nach der Verarbeitung die Antwort auf den API-Aufruf erhalten wird.
# Aktualisieren Sie einen asynchronen Endpunkt
Aktualisieren Sie einen asynchronen Endpunkt mit der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API. Wenn Sie einen Endpunkt aktualisieren, stellt SageMaker KI zunächst die von Ihnen angegebene neue Endpunktkonfiguration bereit und wechselt zu dieser, bevor die Ressourcen gelöscht werden, die in der vorherigen Endpunktkonfiguration bereitgestellt wurden. Löschen Sie keine `EndpointConfig`, deren Endpunkt aktiv ist oder während die `UpdateEndpoint` oder `CreateEndpoint` Operationen auf dem Endpunkt ausgeführt werden.
```
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
sagemaker_client.update_endpoint(
EndpointConfigName=endpoint_config_name,
EndpointName=endpoint_name
)
```
Wenn Amazon SageMaker AI die Anfrage erhält, setzt es den Endpunktstatus auf **Aktualisierung**. Nach der Aktualisierung des asynchronen Endpunkts wird der Status auf **InService**gesetzt. Den Status eines Endpunkts können Sie mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API einsehen. Eine vollständige Liste der Parameter, die Sie bei der Aktualisierung eines Endpunkts angeben können, finden Sie in der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API.
# Löschen eines asynchronen Endpunktes
Löschen Sie einen asynchronen Endpunkt auf ähnliche Weise, wie Sie einen SageMaker KI-gehosteten Endpunkt mit der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)API löschen würden. Geben Sie den Namen des asynchronen Endpunktes an, den Sie löschen möchten. Wenn Sie einen Endpunkt löschen, SageMaker gibt KI alle Ressourcen frei, die bei der Erstellung des Endpunkts bereitgestellt wurden. 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.
Löschen Sie Ihr SageMaker KI-Modell mit der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API oder mit der SageMaker KI-Konsole.
------
#### [ Boto3 ]
```
import boto3
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.delete_endpoint(EndpointName='')
```
------
#### [ SageMaker AI console ]
1. Navigieren Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Erweitern Sie die Dropdown-Liste **Inference**.
1. Wählen Sie **Endpoints** aus.
1. Suchen Sie nach einem Endpunkt in der Suchleiste **Endpunkte suchen**.
1. Wählen Sie Ihren Endpunkt aus.
1. Wählen Sie **Löschen** aus.
------
Zusätzlich zum Löschen des asynchronen Endpunkts möchten Sie möglicherweise auch andere Ressourcen löschen, die zur Erstellung des Endpunkts verwendet wurden, z. B. das Amazon ECR-Repository (wenn Sie ein benutzerdefiniertes Inferenzbild erstellt haben), das SageMaker KI-Modell und die asynchrone Endpunktkonfiguration selbst.
# Alarme und Protokolle zur Verfolgung von Metriken von asynchronen Endpunkten
Sie können SageMaker AI mit Amazon CloudWatch überwachen, wobei Rohdaten erfasst und in lesbare, nahezu Echtzeit-Metriken verarbeitet werden. Mit Amazon CloudWatch können Sie auf historische Informationen zugreifen und sich einen besseren Überblick über die Leistung Ihrer Webanwendung oder Ihres Services verschaffen. Weitere Informationen zu Amazon CloudWatch finden Sie unter [Was ist Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html)
## Überwachung mit CloudWatch
Die folgenden Metriken sind eine vollständige Liste von Metriken für asynchrone Endpunkte und befinden sich im `AWS/SageMaker` Namespace. Jede Metrik, die unten nicht aufgeführt ist, wird nicht veröffentlicht, wenn der Endpunkt für asynchrone Inferenz aktiviert ist. Zu diesen Metriken gehören u. a.:
+ Overhead/Latenz
+ Aufrufe
+ InvocationsPerInstance
### Allgemeine Endpunktmetriken
Diese Metriken entsprechen den Metriken, die heute für Echtzeit-Endpunkte veröffentlicht wurden. Für weitere Informationen zu anderen Metriken in Amazon CloudWatch siehe [Überwachen von SageMaker AI mit Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
| Metrikname | Beschreibung | Einheit/Statistik |
| --- | --- | --- |
| `Invocation4XXErrors` | Die Anzahl der -Anforderungen, bei denen das Modell den HTTP-Antwortcode 4xx zurückgegeben hat. Für jede 4xx-Antwort wird der Wert 1 gesendet, andernfalls 0. | Einheiten: keineGültige Statistiken: Durchschnitt, Summe |
| `Invocation5XXErrors` | Die Anzahl der InvokeEndpoint-Anforderungen, bei denen das Modell den HTTP-Antwortcode 5xx zurückgegeben hat. Für jede 5xx-Antwort wird der Wert 1 gesendet, andernfalls 0. | Einheiten: keineGültige Statistiken: Durchschnitt, Summe |
| `ModelLatency` | Das Zeitintervall bis zur Reaktion eines Modells, von SageMaker AI aus gesehen. Dieses Intervall enthält die lokale Kommunikationszeitspanne für das Senden der Anforderung und Abrufen der Antwort vom Container eines Modells sowie die Zeitspanne für das Abschließen der Inferenz im Container. | Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
### Asynchrone Inferenz-Endpunkt-Metriken
Diese Metriken werden für Endpunkte veröffentlicht, für die asynchrone Inferenz aktiviert ist. Die folgenden Metriken werden mit einer `EndpointName`-Dimension veröffentlicht:
| Metrikname | Beschreibung | Einheit/Statistik |
| --- | --- | --- |
| `ApproximateBacklogSize` | Die Anzahl der Elemente in der Warteschlange für einen Endpunkt, die gerade verarbeitet werden oder noch verarbeitet werden müssen. | Einheiten: Anzahl Gültige Statistiken: Durchschnitt, Maximum und Minimum |
| `ApproximateBacklogSizePerInstance` | Anzahl der Elemente in der Warteschlange geteilt durch die Anzahl der Instances hinter einem Endpunkt. Diese Metrik wird hauptsächlich für die Einrichtung der automatischen Anwendungsskalierung für einen asynchronen Endpunkt verwendet. | Einheiten: AnzahlGültige Statistiken: Durchschnitt, Maximum und Minimum |
| `ApproximateAgeOfOldestRequest` | Alter der ältesten Anfrage in der Warteschlange. | Einheiten: SekundenGültige Statistiken: Durchschnitt, Maximum und Minimum |
| `HasBacklogWithoutCapacity` | Der Wert dieser Metrik ist `1`, wenn sich Anfragen in der Warteschlange befinden, aber keine Instances hinter dem Endpunkt liegen. Der Wert ist `0` zu allen anderen Zeiten. Sie können diese Metrik für die automatische Skalierung Ihres Endpunkts verwenden, wenn Sie eine neue Anfrage in der Warteschlange erhalten. | Einheiten: AnzahlGültige Statistiken: Durchschnitt |
Die folgenden Metriken werden mit einer `EndpointName` und `VariantName`-Dimension veröffentlicht.
| Metrikname | Beschreibung | Einheit/Statistik |
| --- | --- | --- |
| `RequestDownloadFailures` | Wenn aufgrund eines Problems beim Herunterladen der Anfrage von Amazon S3 ein Inferenzfehler auftritt. | Einheiten: AnzahlGültige Statistiken: Summe |
| `ResponseUploadFailures` | Wenn aufgrund eines Problems beim Hochladen der Antwort auf Amazon S3 ein Inferenzfehler auftritt. | Einheiten: AnzahlGültige Statistiken: Summe |
| `NotificationFailures` | Wenn ein Problem beim Veröffentlichen von Benachrichtigungen auftritt. | Einheiten: AnzahlGültige Statistiken: Summe |
| `RequestDownloadLatency` | Gesamtzeit für das Herunterladen der Anforderungsnutzlast. | Einheiten: MikrosekundenGültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| `ResponseUploadLatency` | Gesamtzeit für das Hochladen der Antwortnutzlast. | Einheiten: Mikrosekunden Gültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| `ExpiredRequests` | Anzahl der Anfragen in der Warteschlange, die aufgrund des Erreichens der angegebenen Anfrage-TTL fehlschlagen. | Einheiten: AnzahlGültige Statistiken: Summe |
| `InvocationFailures` | Wenn ein Aufruf aus irgendeinem Grund fehlschlägt. | Einheiten: AnzahlGültige Statistiken: Summe |
| `InvocationsProcesssed` | Anzahl der vom Endpunkt verarbeiteten asynchronen Aufrufe. | Einheiten: AnzahlGültige Statistiken: Summe |
| `TimeInBacklog` | Gesamtzeit, in der die Anfrage vor der Verarbeitung in die Warteschlange gestellt wurde. Dies beinhaltet nicht die tatsächliche Verarbeitungszeit (d. h. Downloadzeit, Uploadzeit, Modelllatenz). | Einheiten: MillisekundenGültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
| `TotalProcessingTime` | Uhrzeit, zu der die Inferenzanforderung von SageMaker AI empfangen wurde, bis zu dem Zeitpunkt, zu dem die Verarbeitung der Anfrage abgeschlossen wurde. Dies beinhaltet die Zeit im Backlog und die Zeit zum Hochladen und Senden von Antwortbenachrichtigungen, falls vorhanden. | Einheiten: MillisekundenGültige Statistiken: Durchschnitt, Minimum, Maximum, Stichprobenanzahl |
Amazon SageMaker Asynchronous Inference umfasst auch Metriken auf Host-Ebene. Informationen zu Metriken auf Host-Ebene finden Sie unter [SageMaker-AI-Jobs und Endpunktmetriken](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs).
## Logs (Protokolle)
Zusätzlich zu den [Model-Container-Protokollen](https://docs.aws.amazon.com/sagemaker/latest/dg/logging-cloudwatch.html), die in Ihrem Konto in Amazon CloudWatch veröffentlicht werden, erhalten Sie auch ein neues Plattformprotokoll für die Verfolgung und das Debuggen von Inferenzanfragen.
Die neuen Protokolle werden unter der Endpoint Log Group veröffentlicht:
```
/aws/sagemaker/Endpoints/[EndpointName]
```
Der Name des Protokollstreams besteht aus:
```
[production-variant-name]/[instance-id]/data-log.
```
Protokollzeilen enthalten die Inferenz-ID der Anfrage, sodass Fehler leicht einer bestimmten Anfrage zugeordnet werden können.
# Überprüfen Sie die Ergebnisse der Prognose
Es gibt mehrere Möglichkeiten, die Ergebnisse der Prognose von Ihrem asynchronen Endpunkt aus zu überprüfen. Die Optionen sind:
1. Amazon SNS-Themen.
1. Suchen Sie in Ihrem Amazon-S3-Bucket nach Ausgaben.
## Amazon SNS-Themen
Amazon SNS ist ein Benachrichtigungsservice für messaging-orientierte Anwendungen, bei dem mehrere Abonnenten „Push“ -Benachrichtigungen über zeitkritische Nachrichten über verschiedene Transportprotokolle, darunter HTTP, Amazon SQS und E-Mail, anfordern und empfangen. Amazon SageMaker Asynchronous Inference sendet Benachrichtigungen, wenn Sie einen Endpunkt mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) und ein Amazon SNS-Thema angeben.
**Anmerkung**
Um Amazon SNS-Benachrichtigungen zu erhalten, muss Ihre IAM-Rolle über `sns:Publish` Berechtigungen verfügen. Informationen zu den Voraussetzungen, die Sie für die Verwendung der Asynchronen Inferenz erfüllen müssen, finden Sie im Abschnitt [Erfüllen der Voraussetzungen](async-inference-create-endpoint-prerequisites.md).
Um Amazon SNS zur Überprüfung der Prognoseergebnisse von Ihrem asynchronen Endpunkt zu verwenden, müssen Sie zunächst ein Thema erstellen, das Thema abonnieren, Ihr Abonnement für das Thema bestätigen und den Amazon-Ressourcennamen (ARN) dieses Themas notieren. Ausführliche Informationen zum Erstellen, Abonnieren und Auffinden des Amazon-ARN eines Amazon SNS-Themas finden Sie unter [Amazon SNS konfigurieren](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html).
Geben Sie das Amazon SNS-Thema ARN (s) in das `AsyncInferenceConfig` Feld ein, wenn Sie eine Endpunktkonfiguration mit `CreateEndpointConfig` erstellen. Sie können sowohl ein Amazon SNS `ErrorTopic` als auch ein `SuccessTopic` angeben.
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.create_endpoint_config(
EndpointConfigName=, # You specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": "model_name",
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": "s3:///"
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
}
}
)
```
Nachdem Sie Ihren Endpunkt erstellt und aufgerufen haben, erhalten Sie eine Benachrichtigung von Ihrem Amazon SNS-Thema. Wenn Sie beispielsweise E-Mail-Benachrichtigungen zu Ihrem Thema abonniert haben, erhalten Sie jedes Mal, wenn Sie Ihren Endpunkt aufrufen, eine E-Mail-Benachrichtigung. Im folgenden Beispiel wird der JSON-Code einer E-Mail-Benachrichtigung über einen erfolgreichen Aufruf gezeigt.
```
{
"awsRegion":"us-east-1",
"eventTime":"2022-01-25T22:46:00.608Z",
"receivedTime":"2022-01-25T22:46:00.455Z",
"invocationStatus":"Completed",
"requestParameters":{
"contentType":"text/csv",
"endpointName":"",
"inputLocation":"s3:////input-data.csv"
},
"responseParameters":{
"contentType":"text/csv; charset=utf-8",
"outputLocation":"s3:////prediction.out"
},
"inferenceId":"11111111-2222-3333-4444-555555555555",
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"InferenceResult"
}
```
## Überprüfen Sie Ihren S3-Bucket
Wenn Sie einen Endpunkt mit `InvokeEndpointAsync` aufrufen, wird ein Antwortobjekt zurückgegeben. Sie können das Antwortobjekt verwenden, um die Amazon-S3-URI abzurufen, in der Ihre Ausgabe gespeichert ist. Mit dem Ausgabespeicherort können Sie eine SageMaker-AI-Sitzungsklasse des SageMaker AI Python SDK verwenden, um programmgesteuert nach einer Ausgabe zu suchen.
Im Folgenden wird das Ausgabewörterbuch von `InvokeEndpointAsync` als Variable mit dem Namen response gespeichert. Mit der Antwortvariablen erhalten Sie dann den Amazon S3-Ausgabe-URI und speichern ihn als Zeichenkettenvariable namens `output_location`.
```
import uuid
import boto3
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the S3 URI of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName='',
InputLocation=input_location,
InferenceId=str(uuid.uuid4()),
ContentType="text/libsvm" #Specify the content type of your data
)
output_location = response['OutputLocation']
print(f"OutputLocation: {output_location}")
```
Weitere Informationen zu unterstützten Instance-Typen finden Sie unter [Gängige Datenformate für die Inferenz](cdf-inference.md).
Mit dem Amazon-S3-Ausgabespeicherort können Sie dann eine [SageMaker-AI-Sitzungsklasse des SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/api/utility/session.html?highlight=session) verwenden, um Amazon-S3-Dateien einzulesen. Das folgende Codebeispiel zeigt, wie eine Funktion (`get_ouput`) erstellt wird, die wiederholt versucht, eine Datei vom Amazon S3-Ausgabespeicherort zu lesen:
```
import sagemaker
import urllib, time
from botocore.exceptions import ClientError
sagemaker_session = sagemaker.session.Session()
def get_output(output_location):
output_url = urllib.parse.urlparse(output_location)
bucket = output_url.netloc
key = output_url.path[1:]
while True:
try:
return sagemaker_session.read_s3_file(
bucket=output_url.netloc,
key_prefix=output_url.path[1:])
except ClientError as e:
if e.response['Error']['Code'] == 'NoSuchKey':
print("waiting for output...")
time.sleep(2)
continue
raise
output = get_output(output_location)
print(f"Output: {output}")
```
# Automatisches Skalieren eines asynchronen Endpunkts
Amazon SageMaker AI unterstützt die automatische Skalierung (Autoscaling) Ihres asynchronen Endpunkts. Autoscaling passt die Anzahl der Instances, die für ein Modell als Reaktion auf Änderungen Ihres Workloads bereitgestellt wurden, dynamisch an. Im Gegensatz zu anderen gehosteten Modellen, die Amazon SageMaker AI unterstützt, können Sie mit Asynchronous Inference auch Ihre asynchronen Endpunkt-Instances auf Null herunterskalieren. Anfragen, die eingehen, wenn keine Instances vorhanden sind, werden zur Verarbeitung in die Warteschlange gestellt, sobald der Endpunkt hochskaliert wird.
Um Ihren asynchronen Endpunkt automatisch zu skalieren, müssen Sie mindestens:
+ Registrieren Sie ein bereitgestelltes Modell (Produktionsvariante).
+ Definieren einer Skalierungsrichtlinie.
+ Wenden Sie die Autoscaling-Richtlinie an.
Bevor Sie Autoscaling verwenden können, müssen Sie bereits ein Modell auf einem SageMaker-AI-Endpunkt bereitgestellt haben. Bereitgestellte Modelle werden als [Produktionsvariante](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) bezeichnet. Weitere Informationen zur Bereitstellung eines Modells auf einem Endpunkt finden Sie unter [Bereitstellen des Modells für SageMaker Hosting Services](https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-model-deployment.html#ex1-deploy-model). Um die Metriken und Zielwerte für eine Skalierungsrichtlinie festzulegen, konfigurieren Sie eine Skalierungsrichtlinie. Informationen zur Definition einer Skalierungsrichtlinie finden Sie unter [Definieren einer Skalierungsrichtlinie](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-define.html). Registrieren Sie Ihr Modell und legen Sie eine Skalierungsrichtlinie fest, um die Skalierungsrichtlinie auf das registrierte Modell anzuwenden. Informationen zur Anwendung der Skalierungsrichtlinie finden Sie unter [Anwenden einer Skalierungsrichtlinie](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-apply.html).
Weitere Informationen zur Definition einer optionalen zusätzlichen Skalierungsrichtlinie, die Ihren Endpunkt hochskaliert, sobald Sie eine Anfrage erhalten, nachdem Ihr Endpunkt auf Null herunterskaliert wurde, finden Sie unter[Optional: Definieren Sie eine -Skalierungsrichtline, die für neue Anfragen von Null skaliert](#async-inference-autoscale-scale-up). Wenn Sie diese optionale Richtlinie nicht angeben, leitet Ihr Endpunkt die Skalierung von Null aus erst ein, wenn die Anzahl der Backlog-Anfragen den Zielwert für die Nachverfolgung überschreitet.
Einzelheiten zu anderen Voraussetzungen und Komponenten, die für Autoscaling verwendet werden, finden Sie im Abschnitt [Voraussetzungen](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-prerequisites.html) in der Autoscaling-Dokumentation von SageMaker AI.
**Anmerkung**
Wenn Sie derselben Autoscaling-Gruppe mehrere Skalierungsrichtlinien zuordnen, kann es zu Skalierungskonflikten kommen. Wenn ein Konflikt auftritt, wählt Amazon EC2 Auto Scaling die Richtlinie aus, die die größte Kapazität sowohl für Scale-out als auch Scale-in bereitstellt. Weitere Informationen zu diesem Verhalten finden Sie unter [Multiple Dynamic Scaling Policies](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scale-based-on-demand.html#multiple-scaling-policy-resolution) in der *Amazon EC2 Auto Scaling-Dokumentation*.
## Definieren einer Skalierungsrichtlinie
Um die Kennzahlen und Zielwerte für eine Skalierungsrichtlinie festzulegen, konfigurieren Sie eine Skalierungsrichtlinie für die Ziel-Nachverfolgung. Definieren Sie die -Skalierungsrichtline als JSON-Block in einer Textdatei. Sie verwenden diese Textdatei, wenn Sie die AWS CLI oder die Application-Auto-Scaling-API aufrufen. Weitere Informationen zur Syntax der Richtlinienkonfiguration finden Sie unter [https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) in der Application Auto Scaling API Reference.
Für asynchrone Endpunkte empfiehlt SageMaker AI dringend, eine Policy-Konfiguration für die Zielverfolgungsskalierung für eine Variante zu erstellen. In diesem Konfigurationsbeispiel verwenden wir eine benutzerdefinierte Metrik, `CustomizedMetricSpecification`, genannt `ApproximateBacklogSizePerInstance`.
```
TargetTrackingScalingPolicyConfiguration={
'TargetValue': 5.0, # The target value for the metric. Here the metric is: ApproximateBacklogSizePerInstance
'CustomizedMetricSpecification': {
'MetricName': 'ApproximateBacklogSizePerInstance',
'Namespace': 'AWS/SageMaker',
'Dimensions': [
{'Name': 'EndpointName', 'Value': }
],
'Statistic': 'Average',
}
}
```
## Definieren Sie eine Skalierungsrichtlinie, die auf Null skaliert
Im Folgenden wird gezeigt, wie Sie Ihre Endpunktvariante mit der automatischen Anwendungsskalierung unter Verwendung von AWS SDK für Python (Boto3) definieren und registrieren können. Nach der Definition eines Low-Level-Client-Objekts, das die automatische Skalierung der Anwendung mit Boto3 darstellt, verwenden wir die [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target)-Methode, um die Produktionsvariante zu registrieren. Wir setzen `MinCapacity` auf 0, weil Asynchrone Inferenz es Ihnen ermöglicht, automatisch auf 0 zu skalieren, wenn keine Anfragen zur Verarbeitung vorliegen.
```
# Common class representing application autoscaling for SageMaker
client = boto3.client('application-autoscaling')
# This is the format in which application autoscaling references the endpoint
resource_id='endpoint/' + + '/variant/' + <'variant1'>
# Define and register your endpoint variant
response = client.register_scalable_target(
ServiceNamespace='sagemaker',
ResourceId=resource_id,
ScalableDimension='sagemaker:variant:DesiredInstanceCount', # The number of EC2 instances for your Amazon SageMaker model endpoint variant.
MinCapacity=0,
MaxCapacity=5
)
```
Eine ausführliche Beschreibung der Application Autoscaling API finden Sie in der [Application Scaling Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target)-Dokumentation.
## Optional: Definieren Sie eine -Skalierungsrichtline, die für neue Anfragen von Null skaliert
Möglicherweise haben Sie einen Anwendungsfall, in dem Sie sporadische Anfragen oder Zeiträume mit einer geringen Anzahl von Anfragen haben. Wenn Ihr Endpunkt in diesen Zeiträumen auf null Instances herunterskaliert wurde, wird Ihr Endpunkt erst wieder hochskaliert, wenn die Anzahl der Anfragen in der Warteschlange das in Ihrer Skalierungsrichtlinie angegebene Ziel überschreitet. Dies kann zu langen Wartezeiten für Anfragen in der Warteschlange führen. Im folgenden Abschnitt erfahren Sie, wie Sie eine zusätzliche Skalierungsrichtlinie erstellen, die Ihren Endpunkt nach Erhalt einer neuen Anfrage in der Warteschlange von Null auf Instances hochskaliert. Ihr Endpunkt wird in der Lage sein, schneller auf neue Anfragen zu antworten, anstatt darauf zu warten, dass die Warteschlangengröße das Ziel überschreitet.
Gehen Sie wie folgt vor, um eine Skalierungsrichtlinie für Ihren Endpunkt zu erstellen, die von null Instances aus hochskaliert werden kann:
1. Erstellen Sie eine Skalierungsrichtlinie, die das gewünschte Verhalten definiert, d. h. Ihren Endpunkt hochskalieren, wenn er keine Instances mehr hat, aber Anfragen in der Warteschlange hat. Im Folgenden wird gezeigt, wie Sie eine Skalierungsrichtlinie namens `HasBacklogWithoutCapacity-ScalingPolicy` mit Hilfe von AWS SDK für Python (Boto3) definieren. Wenn die Warteschlange größer als Null ist und die aktuelle Anzahl der Instances für Ihren Endpunkt ebenfalls Null ist, skaliert die Richtlinie Ihren Endpunkt nach oben. In allen anderen Fällen wirkt sich die Richtlinie nicht auf die Skalierung für Ihren Endpunkt aus.
```
response = client.put_scaling_policy(
PolicyName="HasBacklogWithoutCapacity-ScalingPolicy",
ServiceNamespace="sagemaker", # The namespace of the service that provides the resource.
ResourceId=resource_id, # Endpoint name
ScalableDimension="sagemaker:variant:DesiredInstanceCount", # SageMaker supports only Instance Count
PolicyType="StepScaling", # 'StepScaling' or 'TargetTrackingScaling'
StepScalingPolicyConfiguration={
"AdjustmentType": "ChangeInCapacity", # Specifies whether the ScalingAdjustment value in the StepAdjustment property is an absolute number or a percentage of the current capacity.
"MetricAggregationType": "Average", # The aggregation type for the CloudWatch metrics.
"Cooldown": 300, # The amount of time, in seconds, to wait for a previous scaling activity to take effect.
"StepAdjustments": # A set of adjustments that enable you to scale based on the size of the alarm breach.
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
},
)
```
1. Erstellen Sie einen CloudWatch-Alarm mit der benutzerdefinierten Metrik `HasBacklogWithoutCapacity`. Wenn der Alarm ausgelöst wird, initiiert er die zuvor definierte Skalierungsrichtlinie. Für weitere Informationen über die `HasBacklogWithoutCapacity`-Metrik siehe [Asynchrone Inferenz-Endpunkt-Metriken](async-inference-monitor.md#async-inference-monitor-cloudwatch-async).
```
response = cw_client.put_metric_alarm(
AlarmName=step_scaling_policy_alarm_name,
MetricName='HasBacklogWithoutCapacity',
Namespace='AWS/SageMaker',
Statistic='Average',
EvaluationPeriods= 2,
DatapointsToAlarm= 2,
Threshold= 1,
ComparisonOperator='GreaterThanOrEqualToThreshold',
TreatMissingData='missing',
Dimensions=[
{ 'Name':'EndpointName', 'Value':endpoint_name },
],
Period= 60,
AlarmActions=[step_scaling_policy_arn]
)
```
Sie sollten jetzt über eine Skalierungsrichtlinie und einen CloudWatch-Alarm verfügen, die Ihren Endpunkt von Null auf Instances hochskalieren, wenn Ihre Warteschlange ausstehende Anfragen hat.
# Fehlerbehebung
Die folgenden häufig gestellten Fragen können Ihnen helfen, Probleme mit Ihren Amazon SageMaker Asynchronous Inference-Endpoints zu beheben.
## F: Ich habe Autoscaling aktiviert. Wie kann ich die Anzahl der Instances hinter dem Endpunkt zu einem bestimmten Zeitpunkt ermitteln?
Sie können die folgenden Methoden verwenden, um die Anzahl der Instances hinter Ihrem Endpunkt zu ermitteln:
+ Sie können die [DescribeEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) von SageMaker AI verwenden, um die Anzahl der Instances hinter dem Endpunkt zu einem bestimmten Zeitpunkt zu beschreiben.
+ Sie können die Anzahl der Instances abrufen, indem Sie sich Ihre Amazon CloudWatch-Metriken ansehen. Sehen Sie sich die [metrics for your endpoint instances](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs) an, z. B. `CPUUtilization` oder, `MemoryUtilization` und überprüfen Sie die Statistik zur Anzahl der Stichproben für einen Zeitraum von 1 Minute. Die Anzahl sollte der Anzahl der aktiven Instances entsprechen. Der folgende Screenshot zeigt die in der CloudWatch-Konsole grafisch dargestellte `CPUUtilization` Metrik, wobei die **Statistik** auf `Sample count` eingestellt ist, der **Zeitraum** auf `1 minute` eingestellt ist und die resultierende Anzahl 5 ist.
![\[CloudWatch-Konsole mit grafischer Darstellung der Anzahl der aktiven Instances für einen Endpunkt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/cloudwatch-sample-count.png)
## F: Was sind die allgemeinen einstellbaren Umgebungsvariablen für SageMaker-AI-Container?
In den folgenden Tabellen sind die allgemeinen einstellbaren Umgebungsvariablen für SageMaker-AI-Container nach Framework-Typ aufgeführt.
**TensorFlow**
| Umgebungsvariable | Beschreibung |
| --- | --- |
| `SAGEMAKER_TFS_INSTANCE_COUNT` | Bei TensorFlow-basierten Modellen ist die `tensorflow_model_server` Binärdatei die operative Komponente, die dafür verantwortlich ist, ein Modell in den Speicher zu laden, Eingaben gegen einen Modellgraphen auszuführen und Ausgaben abzuleiten. In der Regel wird eine einzelne Instance dieser Binärdatei gestartet, um Modelle auf einem Endpunkt bereitzustellen. Diese Binärdatei hat intern mehrere Threads und erzeugt mehrere Threads, um auf eine Inferenzanforderung zu antworten. In bestimmten Fällen kann es hilfreich sein, diesen Parameter zu erhöhen, wenn Sie feststellen, dass die CPU angemessen ausgelastet ist (über 30% ausgelastet), der Speicher jedoch nicht ausgelastet ist (weniger als 10% Auslastung). Eine Erhöhung der Anzahl der `tensorflow_model_servers` zur Verfügung stehenden Server erhöht in der Regel den Durchsatz eines Endpunkts. |
| `SAGEMAKER_TFS_FRACTIONAL_GPU_MEM_MARGIN` | Dieser Parameter bestimmt den Anteil des verfügbaren GPU-Speichers für die Initialisierung von Cuda/cuDNN und anderen GPU-Bibliotheken. `0.2` bedeutet, dass 20% des verfügbaren GPU-Speichers für die Initialisierung von Cuda/cuDNN und anderen GPU-Bibliotheken reserviert sind und 80% des verfügbaren GPU-Speichers gleichmäßig auf die TF-Prozesse verteilt sind. Der GPU-Speicher ist vorab zugewiesen, sofern die `allow_growth` Option nicht aktiviert ist. |
| `SAGEMAKER_TFS_INTER_OP_PARALLELISM` | Dies ist auf die `inter_op_parallelism_threads` Variable zurückzuführen. Diese Variable bestimmt die Anzahl der Threads, die von unabhängigen, nicht blockierenden Vorgängen verwendet werden. `0` bedeutet, dass das System eine passende Zahl auswählt. |
| `SAGEMAKER_TFS_INTRA_OP_PARALLELISM` | Dies ist auf die `intra_op_parallelism_threads` Variable zurückzuführen. Dies bestimmt die Anzahl der Threads, die für bestimmte Operationen wie Matrixmultiplikation und Reduktionen zur Beschleunigung verwendet werden können. Ein Wert von `0` bedeutet, dass das System eine geeignete Zahl auswählt. |
| `SAGEMAKER_GUNICORN_WORKERS` | Dies bestimmt die Anzahl der Auftragnehmer-Prozesse, die Gunicorn zur Bearbeitung von Anfragen starten soll. Dieser Wert wird in Kombination mit anderen Parametern verwendet, um einen Satz abzuleiten, der den Inferenzdurchsatz maximiert. Darüber hinaus `SAGEMAKER_GUNICORN_WORKER_CLASS` bestimmt der, welche Art von Arbeitskräften hervorgebracht wurden, typischerweise `async` oder `gevent`. |
| `SAGEMAKER_GUNICORN_WORKER_CLASS` | Dies bestimmt die Anzahl der Auftragnehmer-Prozesse, die Gunicorn zur Bearbeitung von Anfragen starten soll. Dieser Wert wird in Kombination mit anderen Parametern verwendet, um einen Satz abzuleiten, der den Inferenzdurchsatz maximiert. Darüber hinaus `SAGEMAKER_GUNICORN_WORKER_CLASS` bestimmt der, welche Art von Arbeitskräften hervorgebracht wurden, typischerweise `async` oder `gevent`. |
| `OMP_NUM_THREADS` | Python verwendet intern OpenMP für die Implementierung von Multithreading innerhalb von Prozessen. In der Regel werden Threads erzeugt, die der Anzahl der CPU-Kerne entsprechen. Wenn ein bestimmter Prozess jedoch zusätzlich zu Simultaneous Multi Threading (SMT) implementiert wird, wie z. B. Intels HyperThreading, kann es sein, dass ein bestimmter Prozess einen bestimmten Kern überlastet, indem er doppelt so viele Threads erzeugt wie die Anzahl der tatsächlichen CPU-Kerne. In bestimmten Fällen kann eine Python-Binärdatei bis zu viermal so viele Threads wie verfügbare Prozessorkerne erzeugen. Daher ist eine ideale Einstellung für diesen Parameter, wenn Sie die verfügbaren Kerne mit Auftragnehmer-Threads überbelegt haben, `1` oder die Hälfte der Anzahl der CPU-Kerne auf einer CPU mit aktiviertem SMT. |
| `TF_DISABLE_MKL` `TF_DISABLE_POOL_ALLOCATOR` | In einigen Fällen kann das Ausschalten von MKL die Inferenz beschleunigen, wenn `TF_DISABLE_MKL` und `TF_DISABLE_POOL_ALLOCATOR` auf `1` eingestellt sind. |
**PyTorch**
| Umgebungsvariable | Beschreibung |
| --- | --- |
| `SAGEMAKER_TS_MAX_BATCH_DELAY` | Dies ist die maximale Batch-Verzögerungszeit, auf deren Empfang TorchServe wartet. |
| `SAGEMAKER_TS_BATCH_SIZE` | Wenn TorchServe vor Ablauf des Timers nicht die in `batch_size` angegebene Anzahl von Anfragen empfängt, sendet es die empfangenen Anfragen an den Model-Handler. |
| `SAGEMAKER_TS_MIN_WORKERS` | Die Mindestanzahl von Workern, auf die TorchServe herunterskalieren darf. |
| `SAGEMAKER_TS_MAX_WORKERS` | Die maximale Anzahl von Workern, auf die TorchServe skaliert werden darf. |
| `SAGEMAKER_TS_RESPONSE_TIMEOUT` | Die Zeitverzögerung, nach deren Ablauf die Inferenz abläuft, wenn keine Antwort erfolgt. |
| `SAGEMAKER_TS_MAX_REQUEST_SIZE` | Die maximale Nutzlastgröße für TorchServe. |
| `SAGEMAKER_TS_MAX_RESPONSE_SIZE` | Die maximale Antwortgröße für TorchServe. |
**Multi Model Server (MMS)**
| Umgebungsvariable | Beschreibung |
| --- | --- |
| `job_queue_size` | Dieser Parameter ist nützlich, wenn Sie ein Szenario haben, in dem der Typ der Nutzlast der Inferenzanforderung groß ist und aufgrund der größeren Nutzlast möglicherweise ein höherer Heap-Speicherverbrauch der JVM, in der diese Warteschlange verwaltet wird, auftreten kann. Im Idealfall sollten Sie die Heap-Speicheranforderungen von JVM niedriger halten und Python-Workern ermöglichen, mehr Speicher für die eigentliche Modellbereitstellung zuzuweisen. JVM dient nur dazu, die HTTP-Anfragen zu empfangen, sie in die Warteschlange zu stellen und sie zur Inferenz an die Python-basierten Worker weiterzuleiten. Wenn Sie den `job_queue_size` erhöhen, erhöhen Sie möglicherweise den Heap-Speicherverbrauch der JVM und nehmen dem Host letztendlich Speicher weg, der von Python-Workern hätte verwendet werden können. Lassen Sie daher auch bei der Optimierung dieses Parameters Vorsicht walten. |
| `default_workers_per_model` | Dieser Parameter ist für die Backend-Modellbereitstellung vorgesehen und kann für die Optimierung nützlich sein, da dies die kritische Komponente der gesamten Modellbereitstellung ist, auf deren Grundlage die Python-Prozesse Threads für jedes Modell erzeugen. Wenn diese Komponente langsamer (oder nicht richtig abgestimmt) ist, ist das Frontend-Tuning möglicherweise nicht effektiv. |
## F: Wie stelle ich sicher, dass mein Container asynchrone Inferenz unterstützt?
Sie können denselben Container für asynchrone Inferenz verwenden wie für Real-Time Inference oder Batch Transform. Sie sollten sicherstellen, dass die Timeouts und die Payload-Größenbeschränkungen für Ihren Container so eingestellt sind, dass größere Payloads und längere Timeouts verarbeitet werden können.
## F: Was sind die spezifischen Grenzwerte für asynchrone Inferenz, und können sie angepasst werden?
Beachten Sie die folgenden Grenzwerte für asynchrone Inferenz:
+ Größenbeschränkung für die Nutzlast: 1 GB
+ Timeout-Limit: Eine Anfrage kann bis zu 60 Minuten dauern.
+ Warteschlangennachricht TimeToLive (TTL): 6 Stunden
+ Anzahl der Nachrichten, die in Amazon SQS gespeichert werden können: Unbegrenzt. Es gibt jedoch ein Kontingent von 120.000 für die Anzahl der laufenden Nachrichten für eine Standardwarteschlange und 20.000 für eine FIFO-Warteschlange.
## F: Welche Metriken eignen sich am besten für die automatische Skalierung bei asynchroner Inferenz? Kann ich mehrere Skalierungsrichtlinien haben?
Im Allgemeinen können Sie mit Asynchronous Inference die Skalierung auf der Grundlage von Aufrufen oder Instances vornehmen. Bei Aufrufmetriken empfiehlt es sich, sich Ihre `ApproximateBacklogSize` anzusehen. Dabei handelt es sich um eine Metrik, die die Anzahl der Elemente in Ihrer Warteschlange definiert, die noch verarbeitet wurden. Sie können diese Metrik oder Ihre `InvocationsPerInstance` Metrik verwenden, um zu verstehen, bei welchem TPS Sie möglicherweise gedrosselt werden. Überprüfen Sie auf Instance-Ebene Ihren Instance-Typ und dessen CPU/GPU-Auslastung, um zu definieren, wann eine Skalierung erforderlich ist. Wenn eine einzelne Instance eine Kapazität von über 60-70% aufweist, ist dies oft ein gutes Zeichen dafür, dass Sie Ihre Hardware ausgelastet haben.
Es wird nicht empfohlen, mehrere Skalierungsrichtlinien zu verwenden, da diese zu Konflikten führen und zu Verwirrung auf Hardwareebene führen können, was zu Verzögerungen bei der Skalierung führen kann.
## F: Warum beendet mein asynchroner Endpunkt eine Instance `Unhealthy` und die Aktualisierungsanforderungen von Autoscaling schlagen fehl?
Prüfen Sie, ob Ihr Container in der Lage ist, Ping- und Aufruf-Anfragen gleichzeitig zu verarbeiten. SageMaker-AI-Aufrufanfragen dauern ungefähr 3 Minuten. In dieser Zeit schlagen in der Regel mehrere Ping-Anfragen fehl, da das Timeout dazu führt, dass SageMaker AI Ihren Container als `Unhealthy` erkennt.
## F: Kann `MaxConcurrentInvocationsPerInstance` mit den Ningx/Gunicorn/Flask-Einstellungen für meinen BYOC-Modellcontainer arbeiten?
Ja. `MaxConcurrentInvocationsPerInstance` ist eine Funktion von asynchronen Endpunkten. Dies hängt nicht von der Implementierung des benutzerdefinierten Containers ab. `MaxConcurrentInvocationsPerInstance` steuert die Geschwindigkeit, mit der Aufrufanforderungen an den Kundencontainer gesendet werden. Wenn dieser Wert auf `1` festgelegt ist, wird immer nur eine Anfrage an den Container gesendet, unabhängig davon, wie viele Auftragnehmer sich im Kundencontainer befinden.
## F: Wie kann ich Modellserverfehler (500) auf meinem asynchronen Endpunkt debuggen?
Der Fehler bedeutet, dass der Kundencontainer einen Fehler zurückgegeben hat. SageMaker AI kontrolliert nicht das Verhalten von Kundencontainern. SageMaker AI gibt einfach die Antwort von `ModelContainer` zurück und versucht es nicht erneut. Wenn Sie möchten, können Sie den Aufruf so konfigurieren, dass er es bei einem Fehler erneut versucht. Wir empfehlen Ihnen, die Container-Protokollierung zu aktivieren und Ihre Container-Logs zu überprüfen, um die Ursache für den 500-Fehler in Ihrem Modell zu finden. Überprüfen Sie auch die entsprechenden `CPUUtilization` und `MemoryUtilization` Metriken zum Zeitpunkt des Fehlers. Sie können auch den [S3FailurePath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AsyncInferenceOutputConfig.html#sagemaker-Type-AsyncInferenceOutputConfig-S3FailurePath) zur Modellantwort in Amazon SNS als Teil der asynchronen Fehlerbenachrichtigungen konfigurieren, um Fehler zu untersuchen.
## F: Wie kann ich wissen, ob `MaxConcurrentInvocationsPerInstance=1` wirksam wird? Gibt es irgendwelche Kennzahlen, die ich überprüfen kann?
Sie können die Metrik `InvocationsProcesssed`, überprüfen, die mit der Anzahl der Aufrufe übereinstimmen sollte, die Sie erwarten, dass sie in einer Minute verarbeitet werden, basierend auf einer einzigen Parallelität.
## F: Wie kann ich den Erfolg und Misserfolg meiner Aufrufanfragen verfolgen? Was sind die besten Methoden?
Die bewährte Methode besteht darin, Amazon SNS zu aktivieren, einen Benachrichtigungsdienst für messaging-orientierte Anwendungen, bei dem mehrere Abonnenten „Push“ -Benachrichtigungen über zeitkritische Nachrichten über verschiedene Transportprotokolle wie HTTP, Amazon SQS und E-Mail anfordern und empfangen. Asynchronous Inference sendet Benachrichtigungen, wenn Sie einen Endpunkt mit `CreateEndpointConfig` und einen Amazon SNS-Thema angeben.
Um Amazon SNS zur Überprüfung der Prognoseergebnisse von Ihrem asynchronen Endpunkt zu verwenden, müssen Sie zunächst ein Thema erstellen, das Thema abonnieren, Ihr Abonnement für das Thema bestätigen und den Amazon-Ressourcennamen (ARN) dieses Themas notieren. Ausführliche Informationen zum Erstellen, Abonnieren und Auffinden des Amazon-ARN eines Amazon SNS-Themas finden Sie unter [Configuring Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html) im *Amazon SNS SNS-Entwicklerhandbuch*. Weitere Informationen zur Verwendung von Amazon SNS mit asynchroner Inferenz finden Sie unter [Überprüfen der Prognoseergebnisse](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-check-predictions.html).
## F: Kann ich eine Skalierungsrichtlinie definieren, die bei Erhalt einer neuen Anfrage von Null auf Instances hochskaliert?
Ja. Asynchrone Inferenz bietet einen Mechanismus zum Herunterskalieren auf null Instances, wenn keine Anfragen vorliegen. Wenn Ihr Endpunkt in diesen Zeiträumen auf null Instances herunterskaliert wurde, wird Ihr Endpunkt erst wieder hochskaliert, wenn die Anzahl der Anfragen in der Warteschlange das in Ihrer Skalierungsrichtlinie angegebene Ziel überschreitet. Dies kann zu langen Wartezeiten für Anfragen in der Warteschlange führen. Wenn Sie in solchen Fällen für neue Anfragen, die unter dem angegebenen Warteschlangenziel liegen, von Null auf Instances hochskalieren möchten, können Sie eine zusätzliche Skalierungsrichtlinie namens `HasBacklogWithoutCapacity` verwenden. Weitere Informationen zur Definition dieser Skalierungsrichtlinie finden Sie unter [Autoscale an asynchronous endpoint](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-autoscale.html#async-inference-autoscale-scale-up).
## F: Ich erhalte die Fehlermeldung, dass der Instance-Typ für asynchrone Inferenz nicht unterstützt wird. Welche Instance-Typen unterstützt Asynchronous Inference?
Eine vollständige Liste der von Asynchronous Inference pro Region unterstützten Instances finden Sie unter [SageMaker-Preise.](https://aws.amazon.com/sagemaker/pricing/) Prüfen Sie, ob die erforderliche Instance in Ihrer Region verfügbar ist, bevor Sie fortfahren.
# Batch-Transformation für Inferenz mit Amazon AI SageMaker
Verwenden Sie die Stapeltransformation, wenn Sie folgende Aufgaben ausführen möchten:
+ Vorverarbeitung von Datensätzen, um Rauschen oder Bias, das das Training oder Inferenz beeinträchtigt, aus Ihrem Datensatz zu entfernen.
+ Abrufen von Inferenzen aus großen Datensätzen.
+ Ausführen der Inferenz, wenn Sie keinen persistenten Endpunkt benötigen.
+ Verknüpfen von Eingabedatensätzen mit Inferenzen, um die Interpretation der Ergebnisse zu unterstützen
Informationen zum Filtern von Eingabedaten vor dem Ausführen von Inferenzen oder zum Zuweisen von Eingabedatensätzen zu Inferenzen über diese Datensätze finden Sie unter [Zuordnen von Voraussageergebnissen zu Eingabedatensätzen](batch-transform-data-processing.md). Sie können beispielsweise Eingabedaten filtern, um Kontext für das Erstellen und Interpretieren von Berichten zu den Ausgabedaten bereitzustellen.
**Topics**
+ [Verwenden der Batch-Transformation zum Abrufen von Inferenzen aus großen Datensätzen](#batch-transform-large-datasets)
+ [Beschleunigen eines Stapeltransformationsauftrags](#batch-transform-reduce-time)
+ [Verwenden der Stapeltransformation zum Testen von Produktionsvarianten](#batch-transform-test-variants)
+ [Beispiel-Notebooks für Stapeltransformationen](#batch-transform-notebooks)
+ [Zuordnen von Voraussageergebnissen zu Eingabedatensätzen](batch-transform-data-processing.md)
+ [Speichern in Stapeltransformation](batch-transform-storage.md)
+ [Fehlerbehebung](batch-transform-errors.md)
## Verwenden der Batch-Transformation zum Abrufen von Inferenzen aus großen Datensätzen
Die Stapeltransformation verwaltet automatisch die Verarbeitung von großen Datensätzen innerhalb der angegebenen Parameter. Nehmen wir beispielsweise an, Sie haben eine Datensatz-Datei `input1.csv`, die in einem S3-Bucket gespeichert ist. Der Inhalt der Eingabedatei könnte wie das nachfolgende Beispiel aussehen:
```
Record1-Attribute1, Record1-Attribute2, Record1-Attribute3, ..., Record1-AttributeM
Record2-Attribute1, Record2-Attribute2, Record2-Attribute3, ..., Record2-AttributeM
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
...
RecordN-Attribute1, RecordN-Attribute2, RecordN-Attribute3, ..., RecordN-AttributeM
```
Wenn ein Batch-Transformationsjob gestartet wird, startet SageMaker KI Recheninstanzen und verteilt die Inferenz- oder Vorverarbeitungs-Workload zwischen ihnen. Die Stapeltransformation partitioniert Amazon S3-Objekte in der Eingabe nach Schlüssel und ordnet Amazon S3-Objekte den Instances zu. Wenn Sie mehrere Dateien haben, verarbeitet eine Instance z. B. `input1.csv` und eine andere Instance möglicherweise die Datei mit dem Namen `input2.csv`. Wenn Sie über eine Eingabedatei verfügen, aber mehrere Rechen-Instances initialisieren, verarbeitet nur eine Instance die Eingabedatei. Die übrigen Instances befinden sich im Leerlauf.
Sie können Eingabedateien auch in Mini-Batches aufteilen. Sie können z. B. einen Ministapel aus `input1.csv` erstellen, indem Sie nur zwei der Dateien einschließen.
```
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
Record4-Attribute1, Record4-Attribute2, Record4-Attribute3, ..., Record4-AttributeM
```
**Anmerkung**
SageMaker AI verarbeitet jede Eingabedatei separat. Ministapel aus verschiedenen Eingabedateien werden nicht kombiniert, um das [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB )-Limit einzuhalten.
Um Eingabedateien bei der Erstellung eines Batch-Transformationsauftrags in Mini-Batches aufzuteilen, setzen Sie den [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType )Parameterwert auf. `Line` SageMaker AI verwendet die gesamte Eingabedatei in einer einzigen Anforderung, wenn:
+ `SplitType` auf `None` gesetzt wird.
+ Eine Eingabedatei kann nicht in Mini-Batches aufgeteilt werden.
Beachten Sie, dass Stapeltransformation keine CSV-formatierte Eingabe unterstützt, die eingebettete Zeilenumbruchzeichen enthält. Sie können die Größe der Mini-Batches mithilfe der Parameter `[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)` und `[MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)` steuern. `MaxPayloadInMB` darf nicht größer als 100 MB sein. Wenn Sie den optionalen `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)` Parameter angeben, darf der Wert von `(MaxConcurrentTransforms * MaxPayloadInMB)` ebenfalls 100 MB nicht überschreiten.
Wenn der Stapeltransformationsauftrag alle Datensätze in einer Eingabedatei erfolgreich verarbeitet, wird eine Ausgabedatei erstellt. Die Ausgabedatei hat denselben Namen und die Dateierweiterung `.out`. Bei mehreren Eingabedateien, wie z. B. `input1.csv` und `input2.csv`, erhalten die Ausgabedateien die Namen `input1.csv.out` und `input2.csv.out`. Der Stapeltransformationsauftrag speichert die Ausgabedateien am angegebenen Speicherort in Amazon S3, z. B. unter `s3://amzn-s3-demo-bucket/output/`.
Die Prognosen in einer Ausgabedatei werden in der gleichen Reihenfolge aufgelistet wie die entsprechenden Datensätze in der Eingabedatei. Die Ausgabedatei `input1.csv.out` würde basierend auf der zuvor gezeigten Eingabedatei wie folgt aussehen.
```
Inference1-Attribute1, Inference1-Attribute2, Inference1-Attribute3, ..., Inference1-AttributeM
Inference2-Attribute1, Inference2-Attribute2, Inference2-Attribute3, ..., Inference2-AttributeM
Inference3-Attribute1, Inference3-Attribute2, Inference3-Attribute3, ..., Inference3-AttributeM
...
InferenceN-Attribute1, InferenceN-Attribute2, InferenceN-Attribute3, ..., InferenceN-AttributeM
```
Wenn Sie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ) auf `Line` festlegen, können Sie den Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) auf `Line` setzen, um die Ausgabedatensätze mit einem Zeilentrennzeichen zu verketten. Dies ändert nichts an der Anzahl der Ausgabedateien. Die Anzahl der Ausgabedateien entspricht der Anzahl der Eingabedateien, und bei der Verwendung von `AssembleWith` werden keine Dateien zusammengeführt. Wenn Sie den Parameter `AssembleWith` nicht angeben, werden die Ausgabedatensätze standardmäßig in einem Binärformat verkettet.
Wenn die Eingabedaten sehr groß sind und mit HTTP-Abschnittscodierung übertragen werden, um die Daten an den Algorithmus zu streamen, legen Sie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB) auf `0` fest. Die integrierten Algorithmen von Amazon SageMaker AI unterstützen diese Funktion nicht.
Weitere Informationen über das Erstellen eines Stapeltransformationsauftrags mithilfe der API finden Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)-API. Weitere Informationen zur Beziehung zwischen Eingabe- und Ausgabeobjekten bei der Stapeltransformation erhalten Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html). Ein Beispiel zur Verwendung der Stapeltransformation finden Sie unter [(Optional) Vorhersagen mit Batch-Transformation treffen](ex1-model-deployment.md#ex1-batch-transform).
## Beschleunigen eines Stapeltransformationsauftrags
Wenn Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)-API verwenden, können Sie die Stapeltransformationsaufträge schneller abschließen, indem Sie optimale Werte für Parameter verwenden. Dazu gehören Parameter wie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB), [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms) oder [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy). Der ideale Wert für `MaxConcurrentTransforms` entspricht der Anzahl der Compute Worker im Stapeltransformationsauftrag.
Wenn Sie die SageMaker AI-Konsole verwenden, geben Sie diese optimalen Parameterwerte im Abschnitt **Zusätzliche Konfiguration der Konfigurationsseite** **für Batch-Transformationsjobs** an. SageMaker KI findet automatisch die optimalen Parametereinstellungen für integrierte Algorithmen. Für benutzerdefinierte Algorithmen müssen Sie diese Werte über einen [execution-parameters](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests)-Endpunkt angeben.
## Verwenden der Stapeltransformation zum Testen von Produktionsvarianten
Zum Testen verschiedener Modelle oder Hyperparametereinstellungen erstellen Sie eine separate Transformationsaufgabe für jede neue Modellvariante und verwenden einen Validierungsdatensatz. Geben Sie für jeden Transformationsauftrag einen eindeutigen Namen und einen Speicherort in Amazon S3 für die Ausgabedatei an. Beachten Sie bei der Analyse der Ergebnisse das Thema [Protokolle und Metriken der Inferenz-Pipeline](inference-pipeline-logs-metrics.md).
## Beispiel-Notebooks für Stapeltransformationen
Ein Beispiel-Notebook, das die Batch-Transformation verwendet, finden Sie unter [Batch-Transformation mit PCA- und DBSCAN-Movie-Clustern](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_batch_transform/introduction_to_batch_transform/batch_transform_pca_dbscan_movie_clusters.html). In diesem Notebook wird eine Batch-Transformation mit einem Modell der Hauptkomponentenanalyse (PCA, Principal Component Analysis) verwendet, um die Daten in einer Bewertungsmatrix für Benutzerelemente zu reduzieren. Anschließend wird die Anwendung eines Algorithmus zum dichtebasierten räumlichen Clustering von Anwendungen mit Rauschen (DBSCAN) zum Clustering von Filmen gezeigt.
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) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMakerBeispiele**, um eine Liste aller KI-Beispiele zu sehen. SageMaker Die Beispiel-Notebooks zum Thema Modellierung, die die NTM-Algorithmen verwenden, befinden sich im Abschnitt **Erweiterte Funktionen**. Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Use (Verwenden)** und dann **Create copy (Kopie erstellen)**.
# Zuordnen von Voraussageergebnissen zu Eingabedatensätzen
Wenn Sie Voraussagen für einen großen Datensatz erstellen, können Sie nicht für die Prognose benötigte Attribute ausschließen. Nachdem die Prognosen vorgenommen wurden, können Sie einige der ausgeschlossenen Attribute diesen Prognosen oder anderen Eingabedaten in Ihrem Bericht zuordnen. Wenn diese Datenverarbeitungsschritte mithilfe der Stapeltransformation ausgeführt werden, entfällt häufig eine zusätzliche Vor- oder Nachverarbeitung. Sie können Eingabedateien nur im JSON- und CSV-Format verwenden.
**Topics**
+ [Workflow für die Zuordnung von Inferenzen zu Eingabedatensätzen](#batch-transform-data-processing-workflow)
+ [Verwenden der Datenverarbeitung in Stapelumwandlungsaufträgen](#batch-transform-data-processing-steps)
+ [Unterstützte Operatoren JSONPath](#data-processing-operators)
+ [Beispiele für die Stapeltransformation](#batch-transform-data-processing-examples)
## Workflow für die Zuordnung von Inferenzen zu Eingabedatensätzen
Das folgende Diagramm zeigt den Workflow für die Zuordnung von Inferenzen zu Eingabedatensätzen.
![\[Workflow für die Zuordnung von Inferenzen zu Eingabedatensätzen\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/batch-transform-data-processing.png)
Inferenzen werden in drei Hauptschritten mit Eingabedaten verknüpft:
1. Filtern Sie die Eingabedaten, die für die Inferenz nicht erforderlich sind, bevor sie an den Stapeltransformationsauftrag übergeben werden. Verwenden Sie den Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ), um zu bestimmen, welche Attribute als Eingabe für das Modell verwendet werden.
1. Ordnen Sie die Eingabedaten den Inferenzergebnissen zu. Verwenden Sie den Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ), um die Eingabedaten mit der Inferenz zu kombinieren.
1. Filtern Sie die verknüpften Daten, um die Eingaben beizubehalten, die erforderlich sind, um Kontext für die Interpretation der Prognosen in den Berichten bereitzustellen. Verwenden Sie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ) zum Speichern des angegebenen Teils des verknüpften Datensatzes in der Ausgabedatei.
## Verwenden der Datenverarbeitung in Stapelumwandlungsaufträgen
Beim Erstellen eines Stapeltransformationsauftrags mit [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) zum Verarbeiten von Daten:
1. Geben Sie den Teil der Eingabe an, die dem Modell mit dem `InputFilter`-Parameter in der `DataProcessing`-Datenstruktur übergeben werden soll.
1. Verknüpfen Sie die unformatierten Eingabedaten mithilfe des `JoinSource`-Parameters mit den transformierten Daten.
1. Geben Sie mit dem `OutputFilter`-Parameter an, welcher Teil der verknüpften Eingabedaten und transformierten Daten aus dem Stapeltransformationauftrag in die Ausgabedatei eingeschlossen werden soll.
1. Wählen Sie entweder JSON- oder CSV-formatierte Dateien für die Eingabe aus:
+ Bei Eingabedateien im JSON- oder JSON Lines-Format fügt SageMaker AI entweder das `SageMakerOutput` Attribut zur Eingabedatei hinzu oder erstellt eine neue JSON-Ausgabedatei mit den `SageMakerInput` Attributen und. `SageMakerOutput` Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html).
+ Für CSV-formatierte Eingabedateien folgen den verknüpften Eingabedaten die transformierten Daten und die Ausgabe ist eine CSV-Datei.
Wenn Sie einen Algorithmus mit der `DataProcessing`-Struktur verwenden, muss diese das ausgewählte Format sowohl für Eingabe- *als auch* Ausgabedateien unterstützen. Mit dem Feld [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html) der `CreateTransformJob`-API müssen Sie z. B. die Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) und [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept) auf einen der folgenden Werte festlegen: `text/csv`, `application/json` oder `application/jsonlines`. Die Syntax für die Angabe von Spalten in einer CSV-Datei und von Attributen in einer JSON-Datei ist unterschiedlich. Durch Verwenden der falschen Syntax wird ein Fehler verursacht. Weitere Informationen finden Sie unter [Beispiele für die Stapeltransformation](#batch-transform-data-processing-examples). Weitere Informationen zu Eingabe- und Ausgabedateiformaten für integrierte Algorithmen finden Sie unter [Integrierte Algorithmen und vortrainierte Modelle in Amazon SageMaker](algos.md).
Die Datensatztrennzeichen für die Ein- und Ausgabe müssen außerdem mit der von Ihnen ausgewählten Dateieingabe konsistent sein. Der Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType) gibt an, wie die Datensätze im Eingabedatensatz aufgeteilt werden sollen. Der Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) gibt an, wie die Wiederherstellung der Datensätze für die Ausgabe erfolgen soll. Wenn Sie Ein- und Ausgabeformate auf `text/csv` festlegen, müssen Sie auch die Parameter `SplitType` und `AssembleWith` auf `line` einstellen. Wenn Sie die Ein- und Ausgabeformate auf `application/jsonlines` festlegen, können Sie die sowohl `SplitType` als auch `AssembleWith` auf `line` einstellen.
Für CSV-Dateien können Sie keine eingebetteten Zeilenumbruchzeichen verwenden. Für JSON-Dateien ist der Attributname `SageMakerOutput` für die Ausgabe reserviert. Die JSON-Eingabedatei darf kein Attribut mit diesem Namen enthalten. Wenn dies der Fall ist, werden die Daten in der Eingabedatei möglicherweise überschrieben.
## Unterstützte Operatoren JSONPath
Verwenden Sie einen JSONPath Unterausdruck, um die Eingabedaten und die Inferenz zu filtern und zu verknüpfen. SageMaker AI unterstützt nur eine Teilmenge der definierten Operatoren. JSONPath In der folgenden Tabelle sind die unterstützten JSONPath Operatoren aufgeführt. Bei CSV-Daten wird jede Zeile als JSON-Array verwendet, sodass nur indexbasierte Daten angewendet werden JSONPaths können`$[0]`, `$[1:]` z. B. CSV-Daten sollten auch dem [RFC-Format](https://tools.ietf.org/html/rfc4180)folgen.
| JSONPath Operator | Beschreibung | Beispiel |
| --- | --- | --- |
| \$1 | Das Root-Element für eine Abfrage. Dieser Operator ist am Anfang alle Pfadausdrücke erforderlich. | \$1 |
| . | Ein untergeordnetes Element in Punkt-Notation. | `$.id` |
| \$1 | Platzhalter Verwenden Sie diesen anstelle eines Attributnamens oder numerischen Werts. | `$.id.*` |
| ['' (,'')] | Ein Element oder mehrere untergeordnete Elemente in Klammer-Notation. | `$['id','SageMakerOutput']` |
| [ (,)] | Ein Index oder Array von Indizes. Negative Indexwerte werden ebenfalls unterstützt. Der Index `-1` bezieht sich auf das letzte Element in einem Array. | `$[1]` , `$[1,3,5]` |
| [:] | Ein Array-Slice-Operator. Die Array-Slice()-Methode extrahiert einen Abschnitt eines Arrays und gibt ein neues Array zurück. Wenn Sie es weglassen**, verwendet SageMaker AI das erste Element des Arrays. Wenn Sie es weglassen**, verwendet SageMaker AI das letzte Element des Arrays. | `$[2:5]`, `$[:5]`, `$[2:]` |
Wenn Sie die Klammern verwenden, um mehrere untergeordnete Elemente eines bestimmten Felds anzugeben, wird eine zusätzliche Verschachtelung von untergeordneten Elementen in Klammern nicht unterstützt. Beispielsweise `$.field1.['child1','child2']` wird unterstützt, während `$.field1.['child1','child2.grandchild']` es nicht ist.
Weitere Informationen zu JSONPath Operatoren finden Sie [JsonPath](https://github.com/json-path/JsonPath)unter GitHub
## Beispiele für die Stapeltransformation
Die folgenden Beispiele zeigen einige gängige Möglichkeiten zur Verknüpfung von Eingabedaten mit Prognoseergebnissen.
**Topics**
+ [Beispiel: Ausgeben nur von Inferenzen](#batch-transform-data-processing-example-default)
+ [Beispiel: Ausgabe von Inferenzen in Verbindung mit Eingabedaten](#batch-transform-data-processing-example-all)
+ [Beispiel: Mit Eingabedaten verknüpfte Inferenzen ausgeben und die ID-Spalte von der Eingabe ausschließen (CSV)](#batch-transform-data-processing-example-select-csv)
+ [Beispiel: Ausgabe von Inferenzen in Verbindung mit einer ID-Spalte und Ausschließen der ID-Spalte aus der Eingabe (CSV)](#batch-transform-data-processing-example-select-json)
### Beispiel: Ausgeben nur von Inferenzen
Standardmäßig verbindet der Parameter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing) keine Inferenzergebnisse mit der Eingabe. Sie gibt nur die Inferenzergebnisse aus.
Wenn Sie explizit angeben möchten, dass Ergebnisse nicht mit Eingaben verknüpft werden sollen, verwenden Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) und geben Sie die folgenden Einstellungen in einem Transformer-Aufruf an.
```
sm_transformer = sagemaker.transformer.Transformer(…)
sm_transformer.transform(…, input_filter="$", join_source= "None", output_filter="$")
```
Um Inferenzen mit dem AWS SDK für Python auszugeben, fügen Sie Ihrer CreateTransformJob Anfrage den folgenden Code hinzu. Mit dem folgenden Code wird das Standardverhalten nachgeahmt.
```
{
"DataProcessing": {
"InputFilter": "$",
"JoinSource": "None",
"OutputFilter": "$"
}
}
```
### Beispiel: Ausgabe von Inferenzen in Verbindung mit Eingabedaten
Wenn Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) verwenden, um die Eingabedaten mit den Inferenzen in der Ausgabedatei zu kombinieren, geben Sie die `accept` Parameter `assemble_with` und an, wenn Sie das Transformer-Objekt initialisieren. Wenn Sie den Transform-Aufruf verwenden, geben Sie `Input` für den Parameter `join_source` an und geben Sie auch die Parameter `split_type` und `content_type` an. Der Parameter `split_type` muss denselben Wert wie `assemble_with` haben, und der Parameter `content_type` muss denselben Wert wie haben `accept`. Weitere Informationen zu den Parametern und ihren akzeptierten Werten finden Sie auf der [Transformer-Seite](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) im *Amazon SageMaker AI Python SDK*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, join_source="Input", split_type="Line", content_type="text/csv")
```
Wenn Sie das AWS SDK für Python (Boto 3) verwenden, verknüpfen Sie alle Eingabedaten mit der Inferenz, indem Sie Ihrer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)Anfrage den folgenden Code hinzufügen. Die Werte für `Accept` und `ContentType` müssen übereinstimmen, und die Werte für `AssembleWith` und `SplitType` müssen ebenfalls übereinstimmen.
```
{
"DataProcessing": {
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
Für JSON- oder JSON Lines-Eingabedateien sind die Ergebnisse im `SageMakerOutput`-Schlüssel in der JSON-Eingabedatei enthalten. Beispiel: Wenn die Eingabe eine JSON-Datei mit dem Schlüssel-Wert-Paar `{"key":1}` ist, lautet das Ergebnis der Datentransformation z. B. `{"label":1}`.
SageMaker AI speichert beide in der Eingabedatei im `SageMakerInput` Schlüssel.
```
{
"key":1,
"SageMakerOutput":{"label":1}
}
```
**Anmerkung**
Das verknüpfte Ergebnis für JSON muss ein Schlüssel-Wert-Paar-Objekt sein. Wenn es sich bei der Eingabe nicht um ein Schlüssel-Wert-Paar-Objekt handelt, erstellt SageMaker AI eine neue JSON-Datei. In der neuen JSON-Datei werden die Eingabedaten im `SageMakerInput`-Schlüssel und die Ergebnisse als `SageMakerOutput`-Wert gespeichert.
Wenn der Datensatz für eine CSV-Datei z. B. `[1,2,3]` lautet und das Beschriftungsergebnis `[1]` ist, dann würde die Ausgabedatei `[1,2,3,1]` enthalten.
### Beispiel: Mit Eingabedaten verknüpfte Inferenzen ausgeben und die ID-Spalte von der Eingabe ausschließen (CSV)
Wenn Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) verwenden, um Ihre Eingabedaten mit der Inferenzausgabe zu verknüpfen und dabei eine ID-Spalte von der Transformer-Eingabe auszuschließen, geben Sie dieselben Parameter aus dem vorherigen Beispiel sowie einen JSONPath Unterausdruck für `input_filter` in Ihrem Transformer-Aufruf an. Beispiel: Wenn Ihre Eingabedaten fünf Spalten umfassen, wobei die erste die ID-Spalte ist, verwenden Sie die folgende Transformer-Anforderung, um alle Spalten außer der ID-Spalte als Merkmale zu verwenden. Der Transformator gibt weiterhin alle Eingabespalten aus, die mit den Inferenzen verknüpft sind. Weitere Informationen zu den Parametern und ihren akzeptierten Werten finden Sie auf der [Transformer-Seite](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) im *Amazon SageMaker AI Python SDK*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input")
```
Wenn Sie das AWS SDK für Python (Boto 3) verwenden, fügen Sie Ihrer `[ CreateTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)` Anfrage den folgenden Code hinzu.
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
Verwenden Sie den Index der Array-Elemente, um Spalten in SageMaker AI anzugeben. Die erste Spalte ist Index 0, die zweite Spalte ist Index 1 und die sechste Spalte ist Index 5.
Um die erste Spalte aus der Eingabe auszuschließen, legen Sie `[InputFilter](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter )` auf `"$[1:]"` fest. Der Doppelpunkt (`:`) weist SageMaker AI an, alle Elemente zwischen zwei Werten (einschließlich) einzubeziehen. `$[1:4]` gibt beispielsweise die zweite bis fünfte Spalte an.
Wenn Sie die Zahl nach dem Doppelpunkt weglassen, z. B. `[5:]`, enthält die Teilmenge alle Spalten von der 6. bis zur letzten Spalte. Wenn Sie die Zahl vor dem Doppelpunkt weglassen, z. B. `[:5]`, enthält die Teilmenge alle Spalten von der ersten Spalte (Index 0) bis zur sechsten Spalte.
### Beispiel: Ausgabe von Inferenzen in Verbindung mit einer ID-Spalte und Ausschließen der ID-Spalte aus der Eingabe (CSV)
Wenn Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) verwenden, können Sie die Ausgabe so angeben, dass nur bestimmte Eingabespalten (z. B. die ID-Spalte) mit den Inferenzen verknüpft werden, indem Sie die `output_filter` im Transformer-Aufruf angeben. Der `output_filter` verwendet einen JSONPath Unterausdruck, um anzugeben, welche Spalten als Ausgabe zurückgegeben werden sollen, nachdem die Eingabedaten mit den Inferenzergebnissen verknüpft wurden. Die folgende Anforderung zeigt, wie Sie Vorhersagen treffen können, während Sie eine ID-Spalte ausschließen und dann die ID-Spalte mit den Inferenzen verknüpfen können. Beachten Sie, dass im folgenden Beispiel die letzte Spalte (`-1`) der Ausgabe die Inferenzen enthält. Wenn Sie JSON-Dateien verwenden, speichert SageMaker AI die Inferenzergebnisse im Attribut. `SageMakerOutput` Weitere Informationen zu den Parametern und ihren akzeptierten Werten finden Sie auf der [Transformer-Seite](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) im *Amazon SageMaker AI Python SDK*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input", output_filter="$[0,-1]")
```
Wenn Sie das AWS SDK für Python (Boto 3) verwenden, verknüpfen Sie nur die ID-Spalte mit den Inferenzen, indem Sie Ihrer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)Anfrage den folgenden Code hinzufügen.
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input",
"OutputFilter": "$[0,-1]"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
**Warnung**
Wenn Sie eine JSON-formatierte Eingabedatei verwenden, darf die Datei den Attributnamen `SageMakerOutput` nicht enthalten. Dieser Attributname ist für die Inferenzen in der Ausgabedatei reserviert. Wenn Ihre JSON-formatierte Eingabedatei ein Attribut mit diesem Namen enthält, können Werte in der Eingabedatei durch die Inferenz überschrieben werden.
# Speichern in Stapeltransformation
Wenn Sie einen Batch-Transformationsauftrag ausführen, hängt Amazon SageMaker AI ein Amazon Elastic Block Store-Speichervolume an Amazon EC2 EC2-Instances an, die Ihren Job verarbeiten. Das Volume speichert Ihr Modell, und die Größe des Speichervolumens ist auf 30 GB festgelegt. Sie haben die Möglichkeit, Ihr Modell im Ruhezustand auf dem Speichervolumen zu verschlüsseln.
**Anmerkung**
Wenn Sie ein großes Modell haben, stoßen Sie möglicherweise auf einen `InternalServerError`.
Weitere Informationen zu Amazon-EBS-Speicher und Funktionen finden Sie auf den folgenden Seiten:
+ [Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) im Amazon-EC2-Benutzerhandbuch
+ [Amazon-EBS-Volumes](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes.html) im Amazon-EC2-Benutzerhandbuch
**Anmerkung**
G4dn-Instances verfügen über ihren eigenen lokalen SSD-Speicher. Weitere Informationen zu G4dn-Instances finden Sie auf der Seite [Amazon-EC2-G4-Instances](https://aws.amazon.com/ec2/instance-types/g4/).
# Fehlerbehebung
Wenn Sie Fehler in Amazon SageMaker AI Batch Transform haben, lesen Sie die folgenden Tipps zur Fehlerbehebung.
## Fehler bei der maximalen Zeitüberschreitung
Wenn Sie bei der Ausführung von Stapeltransformationsaufträgen Fehler mit der maximalen Zeitüberschreitung erhalten, versuchen Sie Folgendes:
+ Beginnen Sie mit dem Einzeldatensatz-`[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)`, einer Stapelgröße der Standardgröße (6 MB) oder kleiner, die Sie im Parameter `[MaxPayloadInMB](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)` angeben, und einem kleinen Beispieldatensatz. Passen Sie den Parameter für die maximale Zeitüberschreitung `[InvocationsTimeoutInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html#sagemaker-Type-ModelClientConfig-InvocationsTimeoutInSeconds)` (der maximal 1 Stunde beträgt) so lange an, bis Sie eine erfolgreiche Aufrufantwort erhalten.
+ Nachdem Sie eine erfolgreiche Aufrufantwort erhalten haben, erhöhen Sie den Wert `MaxPayloadInMB` (mit einem Maximum von 100 MB) und die Parameter `InvocationsTimeoutInSeconds` zusammen, um die maximale Stapelgröße zu ermitteln, die Ihr gewünschtes Zeitüberschreitung des Modells unterstützen kann. In diesem Schritt können Sie entweder den Einzeldatensatz oder mehrere Datensätze `BatchStrategy` verwenden.
**Anmerkung**
Das Überschreiten des `MaxPayloadInMB`-Limits führt zu einem Fehler. Dies kann der Fall sein, wenn ein großer Datensatz nicht aufgeteilt werden kann und der Parameter `SplitType` auf „Keine“ festgelegt ist oder wenn einzelne Datensätze innerhalb des Datensatzes das Limit überschreiten.
+ (Optional) Passen Sie den Parameter `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)` an, der die maximale Anzahl paralleler Anforderungen angibt, die in einem Stapeltransformationsauftrag an jede Instance gesendet werden können. Der Wert von `MaxConcurrentTransforms * MaxPayloadInMB` darf jedoch 100 MB nicht überschreiten.
## Unvollständige Ausgabe
SageMaker KI verwendet die Amazon S3 [Multipart Upload API](https://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html), um Ergebnisse aus einem Batch-Transformationsauftrag in Amazon S3 hochzuladen. Wenn ein Fehler auftritt, werden die hochgeladenen Ergebnisse aus Amazon S3 entfernt. In einigen Fällen, z. B. bei einem Netzwerkausfall, verbleibt möglicherweise ein unvollständiger mehrteiliger Upload in Amazon S3. Ein unvollständiger Upload kann auch auftreten, wenn Sie mehrere Eingabedateien haben, aber einige der Dateien nicht von SageMaker AI Batch Transform verarbeitet werden können. Die Eingabedateien, die nicht verarbeitet werden konnten, haben in Amazon S3 keine entsprechenden Ausgabedateien.
Zur Vermeidung von Gebühren für Speicherplatz empfehlen wir, den S3-Bucket-Lebenszyklusregeln die [S3-Bucket-Richtlinie](https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config) hinzuzufügen. Diese Richtlinie löscht unvollständige mehrteilige Uploads, die möglicherweise im S3-Bucket gespeichert sind. Weitere Informationen hierzu finden Sie im Abschnitt [Objektlebenszyklusverwaltung](https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html).
## Auftrag wird als `failed` angezeigt.
Wenn ein Batch-Transformationsauftrag eine Eingabedatei aufgrund eines Problems mit dem Datensatz nicht verarbeiten kann, markiert SageMaker AI den Job als`failed`. Wenn eine Eingabedatei einen ungültigen Datensatz enthält, generiert der Transformationsauftrag für diese Eingabedatei keine Ausgabedatei, da für die transformierten Daten nicht dieselbe Reihenfolge wie in der Eingabedatei beibehalten werden kann. Bei mehrere Eingabedateien in einem Datensatz wird die Verarbeitung der Eingabedateien fortgesetzt, auch wenn der Transformationsauftrag eine Datei nicht verarbeiten kann. Die verarbeiteten Dateien erzeugen dessen ungeachtet verwertbare Ergebnisse.
Wenn Sie eigene Algorithmen verwenden, können Sie Platzhaltertext wie beispielsweise `ERROR` verwenden, wenn der Algorithmus einen fehlerhaften Datensatz in einer Eingabedatei findet. Beispiel: Wenn der letzte Datensatz in einem Datensatz ungültig ist, platziert der Algorithmus anstelle dieses Datensatzes den Platzhaltertext in der Ausgabedatei.
# Modellparallelität und Inferenz großer Modelle
Amazon SageMaker AI umfasst spezielle Deep-Learning-Container (DLCs), Bibliotheken und Tools für Modellparallelität und Large Model Inference (LMI). In den folgenden Abschnitten finden Sie Ressourcen für die ersten Schritte mit LMI auf SageMaker AI.
**Topics**
+ [Die Dokumentation zum LMI-Container (Large Model Inference)](large-model-inference-container-docs.md)
+ [SageMaker-AI-Endpunktparameter zur Inferenz großer Modelle](large-model-inference-hosting.md)
+ [Bereitstellung unkomprimierter Modelle](large-model-inference-uncompressed.md)
+ [Stellen Sie große Modelle für Inferenz bereit mit TorchServe](large-model-inference-tutorials-torchserve.md)
# Die Dokumentation zum LMI-Container (Large Model Inference)
Die [Dokumentation für LMI-Container (Large Model Inference)](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/index.html) finden Sie auf der Dokumentationsseite der Deep Java Library.
Die Dokumentation richtet sich an Entwickler, Datenwissenschaftler und Ingenieure für maschinelles Lernen, die umfangreiche Sprachmodelle (LLMs) auf Amazon SageMaker AI bereitstellen und optimieren müssen. Es hilft Ihnen bei der Verwendung von LMI-Containern, bei denen es sich um spezialisierte Docker-Container für LLM-Inferenz handelt, die von bereitgestellt werden. AWS Sie bietet einen Überblick, Bereitstellungsleitfäden, Benutzerhandbücher für unterstützte Inferenzbibliotheken und weiterführende Tutorials.
Mithilfe der LMI-Container-Dokumentation können Sie:
+ sich mit den Komponenten und der Architektur von LMI-Containern vertraut machen;
+ erfahren, wie Sie den geeigneten Instance-Typ und das passende Backend für Ihren Anwendungsfall auswählen;
+ Konfiguration und Bereitstellung LLMs auf KI mithilfe von LMI-Containern SageMaker
+ die Leistung mithilfe von Features wie Quantisierung, Tensorparallelität und kontinuierlicher Stapelverarbeitung optimieren;
+ Benchmarken und optimieren Sie Ihre SageMaker KI-Endpunkte, um einen optimalen Durchsatz und eine optimale Latenz zu erzielen
# SageMaker-AI-Endpunktparameter zur Inferenz großer Modelle
Sie können die folgenden Parameter anpassen, um die Inferenz großer Modelle (LMI) mit niedriger Latenz mit SageMaker AI zu ermöglichen:
+ **Maximale Amazon EBS-Volume-Größe auf der Instance (`VolumeSizeInGB`)** – Wenn die Größe des Modells größer als 30 GB ist und Sie eine Instance ohne lokale Festplatte verwenden, sollten Sie diesen Parameter erhöhen, sodass er etwas größer als die Größe Ihres Modells ist.
+ **Timeout-Kontingent für Integritätsprüfungen (`ContainerStartupHealthCheckTimeoutInSeconds`)** – Wenn Ihr Container korrekt eingerichtet ist und die CloudWatch-Protokolle auf ein Timeout für Integritätsprüfungen hinweisen, sollten Sie dieses Kontingent erhöhen, damit der Container genügend Zeit hat, um auf Integritätsprüfungen zu reagieren.
+ **Timeout-Kontingent für Modell-Downloads (`ModelDataDownloadTimeoutInSeconds`)** – Wenn die Größe Ihres Modells größer als 40 GB ist, sollten Sie dieses Kontingent erhöhen, um genügend Zeit für das Herunterladen des Modells von Amazon S3 auf die Instance zur Verfügung zu haben.
Der folgende Codeausschnitt zeigt, wie die oben genannten Parameter programmatisch konfiguriert werden. Um diese Richtlinie zu verwenden, ersetzen Sie den *kursiv gedruckten Platzhaltertext* in der Beispielrichtlinie durch Ihre eigenen Informationen.
```
import boto3
aws_region = "aws-region"
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name = "endpoint-name"
# Create an endpoint config name.
endpoint_config_name = "endpoint-config-name"
# The name of the model that you want to host.
model_name = "the-name-of-your-model"
instance_type = "instance-type"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": instance_type, # Specify the compute instance type.
"InitialInstanceCount": 1, # Number of instances to launch initially.
"VolumeSizeInGB": 256, # Specify the size of the Amazon EBS volume.
"ModelDataDownloadTimeoutInSeconds": 1800, # Specify the model download timeout in seconds.
"ContainerStartupHealthCheckTimeoutInSeconds": 1800, # Specify the health checkup timeout in seconds
},
],
)
sagemaker_client.create_endpoint(EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)
```
Weitere Informationen zu den Schlüsseln für `ProductionVariants` finden Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html).
Beispiele, die zeigen, wie Sie die Inferenz großer Modelle mit niedriger Latenz erreichen, finden Sie unter [Beispiele zur Inferenz mit generativer KI auf Amazon SageMaker AI](https://github.com/aws-samples/sagemaker-genai-hosting-examples/tree/main) im GitHub-Repository „aws-samples“.
# Bereitstellung unkomprimierter Modelle
Bei der Bereitstellung von ML-Modellen besteht eine Option darin, die Modellartefakte zu archivieren und in ein `tar.gz` Format zu komprimieren. Diese Methode eignet sich zwar gut für kleine Modelle, aber das Komprimieren eines großen Modellartefakts mit Hunderten von Milliarden von Parametern und das anschließende Dekomprimieren auf einem Endpunkt kann viel Zeit in Anspruch nehmen. Für große Modellinferenzen empfehlen wir, ein unkomprimiertes ML-Modell bereitzustellen. Dieser Leitfaden zeigt, wie Sie ein unkomprimiertes ML-Modell bereitstellen können.
Um unkomprimierte ML-Modelle bereitzustellen, laden Sie alle Modellartefakte auf Amazon S3 hoch und organisieren Sie sie unter einem gemeinsamen Amazon S3-Präfix. Ein Amazon S3-Präfix ist eine Zeichenfolge am Anfang eines Amazon S3-Objektschlüsselnamens, die durch ein Trennzeichen vom Rest des Namens getrennt ist. Weitere Informationen zu Präfixen finden Sie unter [Organisieren von Objekten mit Präfixen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-prefixes.html).
Für die Bereitstellung mit SageMaker AI müssen Sie den Schrägstrich (/) als Trennzeichen verwenden. Sie müssen sicherstellen, dass nur Artefakte, die mit Ihrem ML-Modell verknüpft sind, mit dem Präfix organisiert sind. Bei ML-Modellen mit einem einzigen unkomprimierten Artefakt ist das Präfix identisch mit dem Schlüsselnamen. Sie können überprüfen, welche Objekte Ihrem Präfix zugeordnet sind, indem Sie: AWS CLI
```
aws s3 ls --recursive s3://bucket/prefix
```
Nachdem Sie die Modellartefakte auf Amazon S3 hochgeladen und unter einem gemeinsamen Präfix organisiert haben, können Sie ihren Speicherort als Teil des Felds [ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDataSource.html) angeben, wenn Sie die [CreateModel-Anforderung aufrufen](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html). SageMaker AI lädt die unkomprimierten Modellartefakte automatisch zur `/opt/ml/model` Inferenz herunter. Weitere Informationen zu den Regeln, die SageMaker AI beim Herunterladen der Artefakte verwendet, finden Sie unter [S3ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3ModelDataSource.html).
Der folgende Codeausschnitt zeigt, wie Sie die `CreateModel` API aufrufen können, wenn Sie ein unkomprimiertes Modell bereitstellen. Ersetzen Sie den *kursiv gedruckten Benutzertext* durch Ihre eigenen Informationen.
```
model_name = "model-name"
sagemaker_role = "arn:aws:iam::123456789012:role/SageMakerExecutionRole"
container = "123456789012.dkr.ecr.us-west-2.amazonaws.com/inference-image:latest"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
"Image": container,
"ModelDataSource": {
"S3DataSource": {
"S3Uri": "s3://amzn-s3-demo-bucket/prefix/to/model/data/",
"S3DataType": "S3Prefix",
"CompressionType": "None",
},
},
},
)
```
Im oben genannten Beispiel wird davon ausgegangen, dass Ihre Modellartefakte unter einem gemeinsamen Präfix organisiert sind. Wenn es sich bei Ihrem Modellartefakt stattdessen um ein einzelnes unkomprimiertes Amazon S3-Objekt handelt, ändern Sie es so, dass `"S3Uri"` es auf das Amazon S3-Objekt zeigt, und wechseln Sie `"S3DataType"` zu `"S3Object"`.
**Anmerkung**
Derzeit können Sie `ModelDataSource` nicht mit AWS Marketplace, SageMaker-AI-Stapeltransformation, SageMaker-Serverless-Inferenzendpunkten und SageMaker-Multimodell-Endpunkten verwenden.
# Stellen Sie große Modelle für Inferenz bereit mit TorchServe
Dieses Tutorial zeigt, wie Sie große Modelle bereitstellen und Inferenzen in Amazon SageMaker AI mit TorchServe on GPUs bereitstellen. In diesem Beispiel wird das [Opt-30b](https://huggingface.co/facebook/opt-30b)-Modell auf einer `ml.g5` Instance bereitgestellt. Sie können dies so ändern, dass es mit anderen Modellen und Instance-Typen funktioniert. Ersetzen Sie die `italicized placeholder text` in den Beispielen durch Ihre eigenen Angaben.
TorchServe ist eine leistungsstarke offene Plattform für die Inferenz großer verteilter Modelle. Durch die Unterstützung beliebter Bibliotheken wie PyTorch Native Pi PPy und HuggingFace Accelerate bietet sie einen einheitlichen Handler APIs , der für Inferenzszenarien mit verteilten großen Modellen und nicht verteilten Modellen konsistent bleibt. DeepSpeed Weitere Informationen finden Sie in [TorchServeder umfangreichen Modellinferenzdokumentation](https://pytorch.org/serve/large_model_inference.html#).
## Deep-Learning-Container mit TorchServe
Um ein großes Modell ohne TorchServe SageMaker KI bereitzustellen, können Sie einen der SageMaker KI-Deep-Learning-Container (DLCs) verwenden. Standardmäßig TorchServe ist in allen installiert AWS PyTorch DLCs. TorchServe Kann beim Laden des Modells spezielle Bibliotheken installieren, die auf große Modelle wie PiPPy, Deepspeed und Accelerate zugeschnitten sind.
In der folgenden Tabelle sind alle [SageMaker KI DLCs mit TorchServe](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) aufgeführt.
| DLC-Kategorie | Framework | Hardware (Hardware) | Beispiel-URL |
| --- | --- | --- | --- |
| [SageMaker AI Framework-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) | PyTorch 2.0.0\$1 | CPU, GPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /pytorch-inference:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [SageMaker KI-Framework Graviton-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) | PyTorch 2.0.0\$1 | CPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /:2.0.1-cpu-py310-ubuntu20.04-sagemaker pytorch-inference-graviton |
| [Stabilität/KI-Inferenzcontainer](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#stabilityai-inference-containers) | PyTorch 2.0.0 und höher | GPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /:2.0.1-sgm0.1.0-gpu-py310-cu118-ubuntu20.04-sagemaker stabilityai-pytorch-inference |
| [Behälter für Neuronen](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) | PyTorch 1.13,1 | Neuronen | 763104351884.dkr. ecr.us-west-2.amazonaws.com /:1.13.1-neuron-py310-sdk2.12.0-ubuntu20.04 pytorch-inference-neuron |
## Erste Schritte
Bevor Sie Ihr Modell bereitstellen, müssen Sie die Voraussetzungen erfüllen. Sie können auch die Modellparameter konfigurieren und den Handler Code anpassen.
### Voraussetzungen
Um mit der Arbeit zu beginnen, müssen Sie die folgenden Voraussetzungen erfüllen:
1. Stellen Sie sicher, dass Sie Zugriff auf ein Konto haben. AWS [Richten Sie Ihre Umgebung](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) so ein, dass sie entweder über einen AWS IAM-Benutzer oder eine IAM-Rolle auf Ihr Konto zugreifen AWS CLI können. Wir empfehlen die Verwendung einer IAM-Rolle. Zu Testzwecken in Ihrem persönlichen Konto können Sie der IAM-Rolle die folgenden Richtlinien für verwaltete Berechtigungen hinzufügen:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWSServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
Weitere Informationen zum Zuordnen von IAM-Richtlinien zu einer Rolle finden Sie unter [Hinzufügen und Entfernen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) im *AWS IAM-Benutzerhandbuch*.
1. Konfigurieren Sie die Abhängigkeiten lokal, wie in den folgenden Beispielen gezeigt.
1. Installieren Sie Version 2 von: AWS CLI
```
# Install the latest AWS CLI v2 if it is not installed
!curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" !unzip awscliv2.zip
#Follow the instructions to install v2 on the terminal
!cat aws/README.md
```
1. Installieren Sie SageMaker AI und den Boto3-Client:
```
# If already installed, update your client
#%pip install sagemaker pip --upgrade --quiet
!pip install -U sagemaker
!pip install -U boto
!pip install -U botocore
!pip install -U boto3
```
### Modelleinstellungen und Parameter konfigurieren
TorchServe verwendet [https://pytorch.org/docs/stable/elastic/run.html](https://pytorch.org/docs/stable/elastic/run.html), um die verteilte Umgebung für die Modellparallelverarbeitung einzurichten. TorchServe ist in der Lage, mehrere Worker für ein großes Modell zu unterstützen. TorchServe Verwendet standardmäßig einen Round-Robin-Algorithmus für die Zuweisung GPUs an einen Worker auf einem Host. Bei großen Modellinferenzen wird die Anzahl der jedem Worker GPUs zugewiesenen Workers automatisch anhand der in der `model_config.yaml` Datei GPUs angegebenen Anzahl berechnet. Die Umgebungsvariable`CUDA_VISIBLE_DEVICES`, die angibt, welche GPU-Geräte IDs zu einem bestimmten Zeitpunkt sichtbar sind, wird anhand dieser Zahl festgelegt.
Nehmen wir zum Beispiel an, es gibt 8 GPUs auf einem Knoten und ein Worker benötigt 4 GPUs auf einem Knoten (`nproc_per_node=4`). In diesem Fall werden dem ersten Worker (`CUDA_VISIBLE_DEVICES="0,1,2,3"`) vier GPUs und dem zweiten Worker (`CUDA_VISIBLE_DEVICES="4,5,6,7”`) vier TorchServe zugewiesen. GPUs
Zusätzlich zu diesem Standardverhalten TorchServe bietet es Benutzern die Flexibilität, Daten GPUs für eine Arbeitskraft festzulegen. Wenn Sie beispielsweise die Variable `deviceIds: [2,3,4,5]` in der [YAML-Datei für die Modellkonfiguration](https://github.com/pytorch/serve/blob/5ee02e4f050c9b349025d87405b246e970ee710b/model-archiver/README.md?plain=1#L164) festlegen und festlegen`nproc_per_node=2`, wird sie dann dem ersten Worker und `CUDA_VISIBLE_DEVICES="4,5”` dem zweiten Worker TorchServe zugewiesen`CUDA_VISIBLE_DEVICES=”2,3”`.
Im folgenden `model_config.yaml` Beispiel konfigurieren wir sowohl Front-End- als auch Back-End-Parameter für das [Opt-30b](https://huggingface.co/facebook/opt-30b)-Modell. Die konfigurierten Front-End-Parameter sind `parallelType`, `deviceType`, `deviceIds `und `torchrun`. [Ausführlichere Informationen zu den Frontend-Parametern, die Sie konfigurieren können, finden Sie in der Dokumentation. PyTorch GitHub ](https://github.com/pytorch/serve/blob/2bf505bae3046b0f7d0900727ec36e611bb5dca3/docs/configuration.md?plain=1#L267) Die Back-End-Konfiguration basiert auf einer YAML-Map, die eine individuelle Anpassung ermöglicht. Für die Back-End-Parameter definieren wir die DeepSpeed Konfiguration und zusätzliche Parameter, die vom benutzerdefinierten Handlercode verwendet werden.
```
# TorchServe front-end parameters
minWorkers: 1
maxWorkers: 1
maxBatchDelay: 100
responseTimeout: 1200
parallelType: "tp"
deviceType: "gpu"
# example of user specified GPU deviceIds
deviceIds: [0,1,2,3] # sets CUDA_VISIBLE_DEVICES
torchrun:
nproc-per-node: 4
# TorchServe back-end parameters
deepspeed:
config: ds-config.json
checkpoint: checkpoints.json
handler: # parameters for custom handler code
model_name: "facebook/opt-30b"
model_path: "model/models--facebook--opt-30b/snapshots/ceea0a90ac0f6fae7c2c34bcb40477438c152546"
max_length: 50
max_new_tokens: 10
manual_seed: 40
```
### Handler anpassen
TorchServe bietet [Basis-Handler](https://github.com/pytorch/serve/tree/master/ts/torch_handler/distributed) und [Handler-Hilfsprogramme](https://github.com/pytorch/serve/tree/master/ts/handler_utils) für umfangreiche Modellinferenzen, die mit gängigen Bibliotheken erstellt wurden. [Das folgende Beispiel zeigt, wie die benutzerdefinierte Handler-Klasse die [TransformersSeqClassifierHandler[BaseDeepSpeedHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/ts/torch_handler/distributed/base_deepspeed_handler.py#L8)](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/examples/large_models/deepspeed/custom_handler.py#L16C7-L16C39)Handler-Dienstprogramme erweitert und verwendet.](https://github.com/pytorch/serve/blob/master/ts/handler_utils/distributed/deepspeed.py) Ein vollständiges Codebeispiel finden Sie im [`custom_handler.py`Code in der PyTorch GitHub Dokumentation](https://github.com/pytorch/serve/blob/master/examples/large_models/deepspeed/custom_handler.py).
```
class TransformersSeqClassifierHandler(BaseDeepSpeedHandler, ABC):
"""
Transformers handler class for sequence, token classification and question answering.
"""
def __init__(self):
super(TransformersSeqClassifierHandler, self).__init__()
self.max_length = None
self.max_new_tokens = None
self.tokenizer = None
self.initialized = False
def initialize(self, ctx: Context):
"""In this initialize function, the HF large model is loaded and
partitioned using DeepSpeed.
Args:
ctx (context): It is a JSON Object containing information
pertaining to the model artifacts parameters.
"""
super().initialize(ctx)
model_dir = ctx.system_properties.get("model_dir")
self.max_length = int(ctx.model_yaml_config["handler"]["max_length"])
self.max_new_tokens = int(ctx.model_yaml_config["handler"]["max_new_tokens"])
model_name = ctx.model_yaml_config["handler"]["model_name"]
model_path = ctx.model_yaml_config["handler"]["model_path"]
seed = int(ctx.model_yaml_config["handler"]["manual_seed"])
torch.manual_seed(seed)
logger.info("Model %s loading tokenizer", ctx.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.tokenizer.pad_token = self.tokenizer.eos_token
config = AutoConfig.from_pretrained(model_name)
with torch.device("meta"):
self.model = AutoModelForCausalLM.from_config(
config, torch_dtype=torch.float16
)
self.model = self.model.eval()
ds_engine = get_ds_engine(self.model, ctx)
self.model = ds_engine.module
logger.info("Model %s loaded successfully", ctx.model_name)
self.initialized = True
def preprocess(self, requests):
"""
Basic text preprocessing, based on the user's choice of application mode.
Args:
requests (list): A list of dictionaries with a "data" or "body" field, each
containing the input text to be processed.
Returns:
tuple: A tuple with two tensors: the batch of input ids and the batch of
attention masks.
"""
def inference(self, input_batch):
"""
Predicts the class (or classes) of the received text using the serialized transformers
checkpoint.
Args:
input_batch (tuple): A tuple with two tensors: the batch of input ids and the batch
of attention masks, as returned by the preprocess function.
Returns:
list: A list of strings with the predicted values for each input text in the batch.
"""
def postprocess(self, inference_output):
"""Post Process Function converts the predicted response into Torchserve readable format.
Args:
inference_output (list): It contains the predicted response of the input text.
Returns:
(list): Returns a list of the Predictions and Explanations.
"""
```
## Vorbereiten Ihrer Modellartefakte
Bevor Sie Ihr Modell auf SageMaker KI bereitstellen, müssen Sie Ihre Modellartefakte verpacken. Für große Modelle empfehlen wir, das PyTorch [torch-model-archiver](https://github.com/pytorch/serve/blob/master/model-archiver/README.md)Tool mit dem Argument zu verwenden`--archive-format no-archive`, wodurch die Komprimierung von Modellartefakten übersprungen wird. Im folgenden Beispiel werden alle Modellartefakte in einem neuen Ordner mit dem Namen `opt/` gespeichert.
```
torch-model-archiver --model-name opt --version 1.0 --handler custom_handler.py --extra-files ds-config.json -r requirements.txt --config-file opt/model-config.yaml --archive-format no-archive
```
[Sobald der `opt/` Ordner erstellt ist, laden Sie das Opt-30B-Modell mithilfe des Tools Download\$1Model in den Ordner herunter. PyTorch ](https://github.com/pytorch/serve/blob/master/examples/large_models/utils/Download_model.py)
```
cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main
```
Laden Sie abschließend die Modellartefakte zu einem Amazon S3 Bucket hoch.
```
aws s3 cp opt {your_s3_bucket}/opt --recursive
```
Sie sollten jetzt Modellartefakte in Amazon S3 gespeichert haben, die bereit sind, auf einem SageMaker KI-Endpunkt bereitgestellt zu werden.
## Stellen Sie das Modell mit dem SageMaker Python-SDK bereit
Nachdem Sie Ihre Modellartefakte vorbereitet haben, können Sie Ihr Modell auf einem SageMaker KI-Hosting-Endpunkt bereitstellen. In diesem Abschnitt wird beschrieben, wie Sie ein einzelnes großes Modell auf einem Endpunkt bereitstellen und Streaming-Antwortprognosen erstellen. Weitere Informationen zum Streamen von Antworten von Endpunkten finden Sie unter [Echtzeit-Endpunkte aufrufen](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-test-endpoints.html).
Führen Sie die folgenden Schritte aus, um Ihr Modell bereitzustellen:
1. Erstellen Sie eine SageMaker KI-Sitzung, wie im folgenden Beispiel gezeigt.
```
import boto3
import sagemaker
from sagemaker import Model, image_uris, serializers, deserializers
boto3_session=boto3.session.Session(region_name="us-west-2")
smr = boto3.client('sagemaker-runtime-demo')
sm = boto3.client('sagemaker')
role = sagemaker.get_execution_role() # execution role for the endpoint
sess= sagemaker.session.Session(boto3_session, sagemaker_client=sm, sagemaker_runtime_client=smr) # SageMaker AI session for interacting with different AWS APIs
region = sess._region_name # region name of the current SageMaker Studio Classic environment
account = sess.account_id() # account_id of the current SageMaker Studio Classic environment
# Configuration:
bucket_name = sess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}"
print(f'account={account}, region={region}, role={role}, output_path={output_path}')
```
1. Erstellen Sie ein unkomprimiertes Modell in SageMaker AI, wie im folgenden Beispiel gezeigt.
```
from datetime import datetime
instance_type = "ml.g5.24xlarge"
endpoint_name = sagemaker.utils.name_from_base("ts-opt-30b")
s3_uri = {your_s3_bucket}/opt
model = Model(
name="torchserve-opt-30b" + datetime.now().strftime("%Y-%m-%d-%H-%M-%S"),
# Enable SageMaker uncompressed model artifacts
model_data={
"S3DataSource": {
"S3Uri": s3_uri,
"S3DataType": "S3Prefix",
"CompressionType": "None",
}
},
image_uri=container,
role=role,
sagemaker_session=sess,
env={"TS_INSTALL_PY_DEP_PER_MODEL": "true"},
)
print(model)
```
1. Stellen Sie das Modell auf einer Amazon-EC2-Instance bereit, wie im folgenden Beispiel gezeigt.
```
model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
volume_size=512, # increase the size to store large model
model_data_download_timeout=3600, # increase the timeout to download large model
container_startup_health_check_timeout=600, # increase the timeout to load large model
)
```
1. Initialisieren Sie eine Klasse, wie im folgenden Beispiel gezeigt, um die Streaming-Antwort zu verarbeiten.
```
import io
class Parser:
"""
A helper class for parsing the byte stream input.
The output of the model will be in the following format:
```
b'{"outputs": [" a"]}\n'
b'{"outputs": [" challenging"]}\n'
b'{"outputs": [" problem"]}\n'
...
```
While usually each PayloadPart event from the event stream will contain a byte array
with a full json, this is not guaranteed and some of the json objects may be split across
PayloadPart events. For example:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
This class accounts for this by concatenating bytes written via the 'write' function
and then exposing a method which will return lines (ending with a '\n' character) within
the buffer via the 'scan_lines' function. It maintains the position of the last read
position to ensure that previous bytes are not exposed again.
"""
def __init__(self):
self.buff = io.BytesIO()
self.read_pos = 0
def write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
data = self.buff.getvalue()
def scan_lines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
if line[-1] != b'\n':
self.read_pos += len(line)
yield line[:-1]
def reset(self):
self.read_pos = 0
```
1. Testen Sie eine Streaming-Antwortvorhersage, wie im folgenden Beispiel gezeigt.
```
import json
body = "Today the weather is really nice and I am planning on".encode('utf-8')
resp = smr.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=body, ContentType="application/json")
event_stream = resp['Body']
parser = Parser()
for event in event_stream:
parser.write(event['PayloadPart']['Bytes'])
for line in parser.scan_lines():
print(line.decode("utf-8"), end=' ')
```
Sie haben Ihr Modell jetzt auf einem SageMaker KI-Endpunkt bereitgestellt und sollten es für Antworten aufrufen können. Weitere Informationen zu SageMaker KI-Echtzeit-Endpunkten finden Sie unter. [Endpunkte für ein einzelnes Modell](realtime-single-model.md)
# Bereitstellungsleitlinien für die Aktualisierung von Modellen in der Produktion
Bereitstellungsleitlinien sind eine Reihe von Modellbereitstellungsoptionen in Amazon SageMaker AI Inference, mit denen Sie Ihre Machine-Learning-Modelle in der Produktion aktualisieren können. Mithilfe der vollständig verwalteten Bereitstellungsoptionen können Sie den Wechsel vom aktuellen Modell in der Produktion zu einem neuen steuern. Die Modi zur Verkehrsverlagerung in blauen/grünen Bereitstellungen, wie z. B. Canary und Linear, geben Ihnen eine detaillierte Kontrolle über den Prozess der Verkehrsverlagerung von Ihrem aktuellen Modell auf das neue Modell im Laufe des Updates. Darüber hinaus gibt es integrierte Schutzmechanismen wie z. B. automatische Rollbacks, die Ihnen helfen, Probleme frühzeitig zu erkennen und automatisch Korrekturmaßnahmen zu ergreifen, bevor sie die Produktion erheblich beeinträchtigen.
Einsatzleitplanken bieten die folgenden Vorteile:
+ **Sicherheit bei der Bereitstellung bei gleichzeitiger Aktualisierung der Produktionsumgebungen.** Eine regressive Aktualisierung einer Produktionsumgebung kann zu ungeplanten Ausfallzeiten und geschäftlichen Auswirkungen führen, z. B. zu einer erhöhten Modelllatenz und hohen Fehlerraten. Leitplanken für die Implementierung helfen Ihnen, diese Risiken zu minimieren, indem sie bewährte Verfahren und integrierte Sicherheitsleitplanken bereitstellen.
+ **Vollständig verwaltete Bereitstellung.** SageMaker AI kümmert sich um die Einrichtung und Orchestrierung dieser Bereitstellungen und integriert sie in Endpunkt-Aktualisierungsmechanismen. Sie müssen keine Orchestrierungs-, Überwachungs- oder Rollback-Mechanismen entwickeln und verwalten. Sie können SageMaker AI nutzen, um diese Bereitstellungen einzurichten und zu orchestrieren und sich darauf zu konzentrieren, ML für Ihre Anwendungen zu nutzen.
+ **Sichtbarkeit.** Sie können den Fortschritt Ihrer Bereitstellung über die [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)-API oder über Amazon CloudWatch Events (für [unterstützte Endpunkte](deployment-guardrails-exclusions.md)) verfolgen. Weitere Informationen zu Ereignissen in SageMaker AI finden Sie im Abschnitt Änderung des Endpunkt-Bereitstellungsstatus unter [Ereignisse, die Amazon SageMaker AI an Amazon sendet EventBridge](automating-sagemaker-with-eventbridge.md). Beachten Sie, dass Sie CloudWatch Events nicht verwenden können, wenn Ihr Endpunkt eine der Funktionen auf der [Ausschlüsse](deployment-guardrails-exclusions.md) Seite verwendet.
**Anmerkung**
Leitplanken für die Bereitstellung gelten nur für Endpunkttypen [Asynchrone Inferenz-Inferenz](async-inference.md) und [Echtzeit-Inferenz](realtime-endpoints.md).
## Erste Schritte
Wir unterstützen zwei Arten von Bereitstellungen zur Aktualisierung von Modellen in der Produktion: Bereitstellungen mit Blau/Grün und fortlaufende Bereitstellungen.
+ [Blau/Grün-Bereitstellungen](deployment-guardrails-blue-green.md): Mit den Updates können Sie den Verkehr von Ihrer alten Flotte (der blauen Flotte) auf eine neue Flotte (grüne Flotte) verlagern. Blaue/grüne Bereitstellungen bieten [mehrere Modi zur Verkehrsverlagerung](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green.html). Ein Verkehrsverlagerungsmodus ist eine Konfiguration, die festlegt, wie SageMaker AI den Endpunktverkehr an eine neue Flotte weiterleitet, die Ihre Updates enthält. Die folgenden Modi zur Verkehrsverlagerung bieten Ihnen unterschiedliche Kontrollmöglichkeiten für den Endpunkt-Aktualisierungsprozess:
+ [Verlagerung des gesamten Datenverkehrs](deployment-guardrails-blue-green-all-at-once.md) verlagert Ihren gesamten Endpunktverkehr von der blauen Flotte auf die grüne Flotte. Sobald der Verkehr auf die grüne Flotte umgestellt wird, beginnen Ihre vordefinierten Amazon CloudWatch-Alarme mit der Überwachung der grünen Flotte für einen bestimmten Zeitraum (die *Backphase*). Wenn während der Backphase keine Alarme ausgelöst werden, beendet SageMaker AI die blaue Flotte.
+ [Canary-Verkehrsverlagerung nutzen](deployment-guardrails-blue-green-canary.md) verlagert einen kleinen Teil Ihres Traffics (ein *Canary*) auf die grüne Flotte und überwacht diese während einer Backphase. Wenn der Canary auf der grünen Flotte erfolgreich ist, verlagert SageMaker AI den Rest des Datenverkehrs von der blauen Flotte auf die grüne Flotte, bevor die blaue Flotte beendet wird.
+ [Lineare Verkehrsverlagerung](deployment-guardrails-blue-green-linear.md) bietet noch mehr Anpassungsmöglichkeiten in Bezug auf die Anzahl der Schritte zur Verkehrsverlagerung und den Prozentsatz des Verkehrs, der für jeden Schritt verlagert werden muss. Mit Canary Shifting können Sie den Verkehr zwar in zwei Schritten verlagern, bei linearem Shifting wird dies jedoch auf *n* linear verteilte Schritte ausgedehnt.
+ [Rollende Bereitstellungen verwenden](deployment-guardrails-rolling.md): Sie können Ihren Endpunkt aktualisieren, da SageMaker AI schrittweise Kapazität bereitstellt und den Verkehr in Schritten einer von Ihnen angegebenen Chargengröße auf eine neue Flotte verlagert. Instances auf der neuen Flotte werden mit der neuen Bereitstellungskonfiguration aktualisiert. Wenn während der Backphase keine CloudWatch-Alarme ausgelöst werden, bereinigt SageMaker AI die Instances auf der alten Flotte. Mit dieser Option haben Sie die genaue Kontrolle über die Anzahl der Instances oder den Kapazitätsprozentsatz, der bei jedem Schritt verschoben wurde.
Sie können Ihre Bereitstellung über die SageMaker-API und die Befehle [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) und [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) und AWS Command Line Interface-Befehle, erstellen und verwalten. Weitere Informationen zur Einrichtung Ihrer Bereitstellung finden Sie auf den einzelnen Bereitstellungsseiten. Beachten Sie, dass Sie keine Bereitstellungsleitlinien verwenden können, wenn Ihr Endpunkt eine der auf der [Ausschlüsse](deployment-guardrails-exclusions.md) Seite aufgeführten Features verwendet.
Anleitungen zur Verwendung von Deployment Guardrails finden Sie in unseren [Beispiel-Jupyter Notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails) für die Modi Canary und Linear Traffic Shifting.
# Konfiguration und Überwachung von Auto-Rollback
CloudWatch Amazon-Alarme sind eine Voraussetzung für die Verwendung von Backzeiten in Einsatzleitplanken. Sie können die Auto-Rollback-Funktion in Bereitstellungsleitplanken nur verwenden, wenn Sie CloudWatch Alarme einrichten, die einen Endpunkt überwachen können. Wenn einer Ihrer Alarme während des angegebenen Überwachungszeitraums ausgelöst wird, leitet SageMaker KI zum Schutz Ihrer Anwendung ein vollständiges Rollback zum alten Endpunkt ein. Wenn Sie keine CloudWatch Alarme zur Überwachung Ihres Endpunkts eingerichtet haben, funktioniert die Auto-Rollback-Funktion während Ihrer Bereitstellung nicht.
Weitere Informationen zu Amazon CloudWatch finden Sie unter [Was ist Amazon CloudWatch?](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) im * CloudWatch Amazon-Benutzerhandbuch*.
**Anmerkung**
Stellen Sie sicher, dass Ihre IAM-Ausführungsrolle berechtigt ist, die `cloudwatch:DescribeAlarms` Aktion für die von Ihnen angegebenen Auto-Rollback-Alarme auszuführen.
## Alarmbeispiele
Um Ihnen den Einstieg zu erleichtern, stellen wir Ihnen die folgenden Beispiele zur Verfügung, um die Funktionen von CloudWatch Alarmen zu demonstrieren. Zusätzlich zur Verwendung oder Änderung der folgenden Beispiele können Sie Ihre eigenen Alarme erstellen und die Alarme so konfigurieren, dass verschiedene Messwerte für die angegebenen Flotten für einen bestimmten Zeitraum überwacht werden. Weitere SageMaker KI-Metriken und -Dimensionen, die Sie Ihren Alarmen hinzufügen können, finden Sie unter[SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md).
**Topics**
+ [Überwachen Sie Aufruffehler sowohl bei alten als auch bei neuen Flotten](#deployment-guardrails-configuration-alarm-examples-errors-both)
+ [Überwachen Sie die Modelllatenz der neuen Flotte](#deployment-guardrails-configuration-alarm-examples-latency-new)
### Überwachen Sie Aufruffehler sowohl bei alten als auch bei neuen Flotten
Der folgende CloudWatch Alarm überwacht die durchschnittliche Fehlerrate eines Endpunkts. Sie können diesen Alarm für jede Art von Einsatz, Leitplanken und Verkehrsverlagerung verwenden, um eine umfassende Überwachung sowohl der alten als auch der neuen Flotten zu gewährleisten. Wenn der Alarm ausgelöst wird, leitet die SageMaker KI einen Rollback zur alten Flotte ein.
Aufruffehler, die sowohl von der alten als auch von der neuen Flotte stammen, tragen zur durchschnittlichen Fehlerquote bei. Wenn die durchschnittliche Fehlerrate den angegebenen Schwellenwert überschreitet, wird der Alarm ausgelöst. In diesem speziellen Beispiel werden die 4xx-Fehler (Client-Fehler) sowohl auf der alten als auch auf der neuen Flotte für die Dauer eines Einsatzes überwacht. Sie können die 5xx-Fehler (Serverfehler) auch überwachen, indem Sie die -Metrik `Invocation5XXErrors` verwenden.
**Anmerkung**
Bei diesem Alarmtyp beendet SageMaker KI Ihren Einsatz, wenn Ihre alte Flotte während des Einsatzes den Alarm auslöst. Wenn Ihre aktuelle Produktionsflotte bereits Fehler verursacht, sollten Sie daher in Erwägung ziehen, eines der folgenden Beispiele zu verwenden oder zu ändern, das nur die neue Flotte auf Fehler überwacht.
```
#Applied deployment type: all types
{
"AlarmName": "EndToEndDeploymentHighErrorRateAlarm",
"AlarmDescription": "Monitors the error rate of 4xx errors",
"MetricName": "Invocation4XXErrors",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
}
],
"Period": 600,
"EvaluationPeriods": 2,
"Threshold": 1,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
Notieren Sie sich im vorherigen Beispiel die Werte für die folgenden Felder:
+ Für `AlarmName` und `AlarmDescription` geben Sie einen Namen und eine Beschreibung ein, die Sie für den Alarm wählen.
+ Verwenden Sie für `MetricName` den Wert `Invocation4XXErrors`, um auf 4xx-Fehler am Endpunkt zu achten
+ Für `Namespace` ist der Wert `AWS/SageMaker` zu verwenden. Sie können gegebenenfalls auch Ihre eigene benutzerdefinierte Metrik angeben.
+ Geben Sie als `Statistic` `Average`ein. Das bedeutet, dass der Alarm bei der Berechnung, ob die Fehlerrate den Schwellenwert überschritten hat, anhand der durchschnittlichen Fehlerrate über die Bewertungszeiträume berechnet wird.
+ Verwenden Sie für die Dimension `EndpointName` den Namen des Endpunkts, den Sie aktualisieren, als Wert.
+ Verwenden Sie für die Dimension `VariantName` den Wert `AllTraffic`, um den gesamten Endpunktverkehr anzugeben.
+ Geben Sie als `Period` `600`ein. Dadurch werden die Bewertungszeiträume des Alarms auf 10 Minuten festgelegt.
+ Geben Sie als `EvaluationPeriods` `2`ein. Dieser Wert weist den Alarm an, bei der Bestimmung des Alarmstatus die beiden letzten Bewertungszeiträume zu berücksichtigen.
### Überwachen Sie die Modelllatenz der neuen Flotte
Das folgende CloudWatch Alarmbeispiel überwacht die Latenz des Modells der neuen Flotte während Ihres Einsatzes. Sie können diesen Alarm verwenden, um nur die neue Flotte zu überwachen und die alte Flotte auszuschließen. Der Alarm hält für den gesamten Einsatz an. Dieses Beispiel bietet Ihnen eine umfassende end-to-end Überwachung der neuen Flotte und leitet einen Rollback zur alten Flotte ein, falls die neue Flotte Probleme mit der Reaktionszeit hat.
CloudWatch veröffentlicht die Metriken mit der Dimension, `EndpointConfigName:{New-Ep-Config}` nachdem die neue Flotte den Verkehr aufgenommen hat. Diese Metriken bleiben auch nach Abschluss der Bereitstellung erhalten.
Sie können das folgende Alarme Beispiel für jeden Bereitstellungstyp verwenden.
```
#Applied deployment type: all types
{
"AlarmName": "NewEndpointConfigVersionHighModelLatencyAlarm",
"AlarmDescription": "Monitors the model latency on new fleet",
"MetricName": "ModelLatency",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
},
{
"Name": "EndpointConfigName",
"Value":
],
"Period": 300,
"EvaluationPeriods": 2,
"Threshold": 100000, # 100ms
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
Notieren Sie sich im vorherigen Beispiel die Werte für die folgenden Felder:
+ Für `MetricName` verwenden Sie den Wert `ModelLatency`, um die Reaktionszeit des Modells zu überwachen.
+ Für `Namespace` ist der Wert `AWS/SageMaker` zu verwenden. Sie können gegebenenfalls auch Ihre eigene benutzerdefinierte Metrik angeben.
+ Verwenden Sie für die Dimension `EndpointName` den Namen des Endpunkts, den Sie aktualisieren, als Wert.
+ Für die Dimension `VariantName` verwenden Sie den Wert `AllTraffic`, um den gesamten Endpunktverkehr anzugeben.
+ Bei der Dimension `EndpointConfigName` sollte sich der Wert auf den Namen der Endpunktkonfiguration für Ihren neuen oder aktualisierten Endpunkt beziehen.
**Anmerkung**
Wenn Sie Ihre alte Flotte statt der neuen Flotte überwachen möchten, können Sie die Dimension `EndpointConfigName` ändern, um den Namen der Konfiguration Ihrer alten Flotte anzugeben.
# Blau/Grün-Bereitstellungen
Wenn Sie Ihren Endpunkt aktualisieren, verwendet Amazon SageMaker AI automatisch eine Blau/Grün-Bereitstellung, um die Verfügbarkeit Ihrer Endgeräte zu maximieren. Bei einer Blau/Grün-Bereitstellung stellt SageMaker AI eine neue Flotte mit den Updates bereit (die grüne Flotte). Dann verlagert SageMaker AI den Verkehr von der alten Flotte (der blauen Flotte) auf die grüne Flotte. Sobald die grüne Flotte für einen festgelegten Testzeitraum (die sogenannte Backphase) reibungslos funktioniert, beendet SageMaker AI die blaue Flotte. Mit den zusätzlichen Funktionen in blauen/grünen Bereitstellungen können Sie Modi zur Verkehrsverlagerung und automatische Rollback-Überwachung nutzen, um Ihren Endpunkt vor erheblichen Produktionsauswirkungen zu schützen.
In der folgenden Liste werden die wichtigsten Funktionen von Blau/Grün-Bereitstellungen in SageMaker AI beschrieben:
+ **Modi zur Verkehrsverlagerung.** Mit den Verkehrsverlagerungsmodi für Einsatzleitplanken können Sie das Verkehrsaufkommen und die Anzahl der Verkehrsverlagerungsstufen zwischen der blauen Flotte und der grünen Flotte steuern. Diese Funktion gibt Ihnen die Möglichkeit, die Leistung der umweltfreundlichen Flotte schrittweise zu bewerten, ohne sich vollständig auf eine hundertprozentige Verkehrsverlagerung festlegen zu müssen.
+ **Backzeit.** Die Backphase ist ein festgelegter Zeitraum, um die grüne Flotte zu überwachen, bevor mit der nächsten Einsatzphase fortgefahren wird. Wenn einer der vordefinierten Alarme während einer Back-Periode ausgelöst wird, wird der gesamte Endpunktverkehr auf die blaue Flotte zurückgesetzt. Die Backphase hilft Ihnen dabei, Vertrauen in Ihr Update aufzubauen, bevor der Traffic dauerhaft verlagert wird.
+ **Automatisches Zurücksetzen.** Sie können Amazon CloudWatch-Alarme angeben, die SageMaker AI zur Überwachung der grünen Flotte verwendet. Wenn ein Problem mit dem aktualisierten Code einen der Alarme auslöst, leitet SageMaker AI einen automatischen Rollback zur blauen Flotte ein, um die Verfügbarkeit aufrechtzuerhalten und so das Risiko zu minimieren.
## Modi zur Verkehrsverlagerung
Die verschiedenen Modi zur Verkehrsverlagerung in blauen/grünen Bereitstellungen bieten Ihnen eine genauere Kontrolle über die Verkehrsverlagerung zwischen der blauen Flotte und der grünen Flotte. Die verfügbaren Verkehrsverlagerungsmodi für blaue/grüne Bereitstellungen sind alle gleichzeitig, kanarisch und linear. Die folgende Tabelle zeigt einen Vergleich der Optionen.
**Wichtig**
Bei Bereitstellungen in Blau/Grün, die mehrstufige Verkehrsverlagerung oder Back-Phasen beinhalten, werden Ihnen für die Dauer des Updates beide Flotten in Rechnung gestellt, unabhängig vom Verkehr zur Flotte. Dies steht im Gegensatz zu Bereitstellungen in Blau/Grün, bei denen der Verkehr auf einmal verlagert wird und es keine Back-Phasen gibt, bei denen Ihnen im Laufe des Updates nur eine Flotte in Rechnung gestellt wird.
| Name | Was ist es? | Vorteile | Nachteile | Empfehlung |
| --- | --- | --- | --- | --- |
| Alle auf einmal | Verlagerung des gesamten Verkehrs auf die neue Flotte in einem einzigen Schritt. | Minimiert die Gesamtdauer des Updates. | Regressive Updates betreffen 100% des Datenverkehrs. | Verwenden Sie diese Option, um die Aktualisierungszeit und die Kosten zu minimieren. |
| Canary | Der Verkehr verlagert sich in zwei Schritten. Der erste (kanarische) Schritt verlagert einen kleinen Teil des Datenverkehrs, gefolgt vom zweiten Schritt, der den Rest des Verkehrs verschiebt. | Beschränkt den Explosionsradius der regressiven Updates nur auf die kanarische Flotte. | Beide Flotten sind während des gesamten Einsatzes parallel im Einsatz. | Verwenden Sie diese Option, um ein Gleichgewicht zwischen der Minimierung des Explosionsradius regressiver Updates und der Minimierung der Betriebszeit von zwei Flotten herzustellen. |
| Linear | Ein fester Teil des Verkehrs verlagert sich in eine vorab festgelegte Anzahl von Schritten mit gleichem Abstand. | Minimiert das Risiko regressiver Aktualisierungen, indem der Verkehr über mehrere Schritte verteilt wird. | Die Dauer und die Kosten der Aktualisierung sind proportional zur Anzahl der Schritte. | Verwenden Sie diese Option, um das Risiko zu minimieren, indem Sie die Bereitstellung auf mehrere Schritte verteilen. |
## Erste Schritte
Sobald Sie Ihre gewünschte Bereitstellungskonfiguration angegeben haben, übernimmt SageMaker AI die Bereitstellung neuer Instances, die Kündigung alter Instances und die Verlagerung des Datenverkehrs für Sie. Sie können Ihren Einsatz über die bestehenden SageMaker API und AWS Command Line Interface-Befehle [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) und [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) erstellen und verwalten. Beachten Sie, dass Sie keine Bereitstellungsleitlinien verwenden können, wenn Ihr Endpunkt eine der auf der [Ausschlüsse](deployment-guardrails-exclusions.md) Seite aufgeführten Funktionen verwendet. Weitere Informationen zur Einrichtung Ihrer Bereitstellung finden Sie auf den einzelnen Bereitstellungsseiten:
+ [Blau/Grünes Update mit Verkehrsverlagerung auf einmal](deployment-guardrails-blue-green-all-at-once.md)
+ [Blau/Grünes Update mit Canary Traffic Shifting](deployment-guardrails-blue-green-canary.md)
+ [Blau/Grünes Update mit linearer Verkehrsverlagerung](deployment-guardrails-blue-green-linear.md)
In unseren Beispiel-[Jupyter Notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails) für die Modi Canary und Linear Traffic Shifting finden Sie Anleitungen, die zeigen, wie Deployment Guardrails verwendet werden.
# Verlagerung des gesamten Datenverkehrs
Da sich der Verkehr auf einmal verlagert, können Sie schnell ein Endpunkt-Update durchführen, indem Sie die Sicherheitsvorkehrungen einer blau/grünen Implementierung nutzen. Sie können diese Option zur Verkehrsverlagerung verwenden, um die Aktualisierungsdauer zu minimieren und gleichzeitig die Verfügbarkeitsgarantien von Blau/Grün-Bereitstellungen zu nutzen. Mit der Back-Perioden-Funktion können Sie die Leistung und Funktionalität Ihrer neuen Instances überwachen, bevor Sie Ihre alten Instances beenden. So wird sichergestellt, dass Ihre neue Flotte voll funktionsfähig ist.
Das folgende Diagramm zeigt, wie die alten und neuen Flotten mit einer einzigen Verkehrsverlagerung verwaltet werden.
![\[Eine erfolgreiche 100-prozentige Verkehrsverlagerung von der alten zu der neuen Flotte.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/deployment-guardrails-blue-green-all-at-once.png)
Wenn Sie den gesamten Datenverkehr verlagern, leitet SageMaker AI 100 % des Datenverkehrs an die neue Flotte (grüne Flotte) weiter. Sobald die grüne Flotte Traffic empfängt, beginnt die Backphase. Die Backphase ist ein festgelegter Zeitraum, in dem vordefinierte Amazon CloudWatch-Alarme die Leistung der grünen Flotte überwachen. Wenn während der Backphase keine Alarme ausgelöst werden, beendet SageMaker AI die alte Flotte (blaue Flotte). Wenn während der Backphase Alarme ausgelöst werden, wird ein automatischer Rollback ausgelöst und der Verkehr wird zu 100% wieder auf die blaue Flotte umgestellt.
## Voraussetzungen
Bevor Sie eine Bereitstellung einrichten, bei der der gesamte Datenverkehr auf einmal verlagert wird, müssen Sie Amazon CloudWatch-Alarme erstellen, um Metriken von Ihrem Endpunkt aus zu überwachen. Wenn einer der Alarme während der Backphase ausgelöst wird, wird der Traffic wieder auf Ihre blaue Flotte übertragen. Informationen zum Einrichten von CloudWatch-Alarmen auf einem Endpunkt finden Sie auf der Seite [Konfiguration und Überwachung von Auto-Rollback](deployment-guardrails-configuration.md) mit den Voraussetzungen. Informationen über CloudWatch-Alarme finden Sie unter [Vewenden von Amazon-CloudWatch-Alarmen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) im *Amazon-CloudWatch-Benutzerhandbuch*.
## Konfigurieren Sie Traffic Shifting auf einmal
Sobald Sie für Ihre Bereitstellung bereit sind und CloudWatch-Alarme für Ihren Endpunkt eingerichtet haben, können Sie entweder die SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API oder den Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) in der AWS Command Line Interface verwenden, um die Bereitstellung zu initiieren.
**Topics**
+ [So aktualisieren Sie einen Endpunkt (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-update)
+ [Wie aktualisiert man einen Endpunkt mit einer vorhandenen blau/grünen Update-Richtlinie (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-existing)
+ [So aktualisieren Sie einen Endpunkt (CLI)](#deployment-guardrails-blue-green-all-at-once-configure-cli-update)
### So aktualisieren Sie einen Endpunkt (API)
Das folgende Beispiel zeigt, wie Sie Ihren Endpunkt mit [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) in der Amazon SageMaker-API aktualisieren können, sodass der gesamte Datenverkehr auf einmal verlagert wird.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "ALL_AT_ONCE"
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
}
}
)
```
Um die Optionen All-at-Once-Datenverkehrs-Verlagerung zu konfigurieren, machen Sie Folgendes:
+ Verwenden Sie für `EndpointName` den Namen des vorhandenen Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `EndpointConfigName` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Stellen Sie unter `DeploymentConfig` und `BlueGreenUpdatePolicy`, in `TrafficRoutingConfiguration`, den `Type` Parameter auf `ALL_AT_ONCE` ein. Dies gibt an, dass die Bereitstellung den All-in-Once-Modus zur Verkehrsverlagerung verwendet.
+ Geben Sie als `TerminationWaitInSeconds` `600`ein. Dieser Parameter weist SageMaker AI an, die angegebene Zeit (in Sekunden) zu warten, nachdem Ihre grüne Flotte voll aktiv ist, bevor die Instances in der blauen Flotte beendet werden. In diesem Beispiel wartet SageMaker AI nach der letzten Backphase 10 Minuten, bevor die blaue Flotte beendet wird.
+ Geben Sie als `MaximumExecutionTimeoutInSeconds` `1800`ein. Dieser Parameter legt die maximale Zeit fest, die die Bereitstellung ausgeführt werden kann, bevor eine Zeitbeschränkung auftritt. Im vorherigen Beispiel gilt für Ihre Bereitstellung ein Limit von 30 Minuten bis zum Abschluss.
+ In `AutoRollbackConfiguration` können Sie im Feld `Alarms` Ihre CloudWatch-Alarme nach Namen hinzufügen. Erstellen Sie einen `AlarmName: ` Eintrag für jeden Alarm, den Sie verwenden möchten.
### Wie aktualisiert man einen Endpunkt mit einer vorhandenen blau/grünen Update-Richtlinie (API)
Wenn Sie die [CreateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) verwenden, um einen Endpunkt zu erstellen, können Sie optional eine Bereitstellungskonfiguration angeben, die für future Endpunkt-Updates wiederverwendet werden soll. Sie können dieselben `DeploymentConfig` Optionen wie im vorherigen UpdateEndpoint-API-Beispiel verwenden. Das Verhalten der CreateEndpoint-API wurde nicht geändert. Durch die Angabe der Bereitstellungskonfiguration wird nicht automatisch ein blau/grünes Update auf Ihrem Endpunkt durchgeführt.
Die Option, eine vorherige Bereitstellungskonfiguration zu verwenden, ist verfügbar, wenn Sie die [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)-API verwenden, um Ihren Endpunkt zu aktualisieren. Wenn Sie Ihren Endpunkt aktualisieren, können Sie die `RetainDeploymentConfig` Option verwenden, um die Bereitstellungskonfiguration beizubehalten, die Sie bei der Erstellung des Endpunkts angegeben haben.
Stellen Sie beim Aufrufen der [UpdateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) `RetainDeploymentConfig` auf `True` ein, um die `DeploymentConfig` Optionen aus Ihrer ursprünglichen Endpunktkonfiguration beizubehalten.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### So aktualisieren Sie einen Endpunkt (CLI)
Wenn Sie den AWS CLI verwenden, zeigt das folgende Beispiel, wie Sie mit dem Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) eine blaue/grüne All-in-one-Bereitstellung starten.
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "ALL_AT_ONCE"},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Um die Optionen All-at-Once-Datenverkehrs-Verlagerung zu konfigurieren, machen Sie Folgendes:
+ Verwenden Sie für `endpoint-name` den Namen des Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `endpoint-config-name` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Verwenden Sie für `deployment-config` ein [BlueGreenUpdatePolicy-JSON-Objekt](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**Anmerkung**
Wenn Sie Ihr JSON-Objekt lieber in einer Datei speichern möchten, finden Sie weitere Informationen unter [Generieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) von AWS CLI Skelett- und Eingabeparametern im *AWS CLIBenutzerhandbuch*.
# Canary-Verkehrsverlagerung nutzen
Mit Canary Traffic Shifting können Sie einen Teil Ihres Endpunktverkehrs auf der neuen Flotte testen, während die alte Flotte den Rest des Datenverkehrs abwickelt. Bei diesem Testschritt handelt es sich um eine Sicherheitsleitplanke, mit der die Funktionalität der neuen Flotte überprüft wird, bevor Ihr gesamter Verkehr auf die neue Flotte verlagert wird. Sie haben immer noch die Vorteile einer blauen/grünen Implementierung, und mit der zusätzlichen Canary-Funktion können Sie sicherstellen, dass Ihre neue (grüne) Flotte Rückschlüsse verarbeiten kann, bevor sie den gesamten Verkehr bewältigen kann.
Der Teil Ihrer grünen Flotte, der aktiviert wird, um Traffic zu empfangen, wird als Kanarienvogel bezeichnet, und Sie können die Größe dieses Kanarienvogels wählen. Beachten Sie, dass die Kanariengröße höchstens 50% der Kapazität der neuen Flotte betragen sollte. Sobald die Backphase abgelaufen ist und keine vordefinierten Amazon CloudWatch-Alarme ausgelöst werden, verlagert sich der restliche Verkehr von der alten (blauen) Flotte auf die grüne Flotte. Canary Traffic Shifting bietet Ihnen mehr Sicherheit bei der Bereitstellung, da alle Probleme mit dem aktualisierten Modell nur den Canary betreffen.
Das folgende Diagramm zeigt, wie Canary Traffic Shifting die Verteilung des Verkehrs zwischen den blauen und grünen Flotten regelt.
![\[Eine erfolgreiche zweistufige Verlagerung des kanarischen Datenverkehrs von der alten zu der neuen Flotte.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/deployment-guardrails-blue-green-canary.png)
Sobald SageMaker AI die grüne Flotte bereitgestellt hat, leitet SageMaker AI einen Teil des eingehenden Datenverkehrs (z. B. 25 %) an den Canary weiter. Dann beginnt die Backphase, in der Ihre CloudWatch-Alarme die Leistung der grünen Flotte überwachen. Während dieser Zeit sind sowohl die blaue als auch die grüne Flotte teilweise aktiv und empfangen Verkehr. Wenn einer der Alarme während der Backphase ausgelöst wird, leitet SageMaker AI einen Rollback ein und der gesamte Verkehr kehrt zur blauen Flotte zurück. Wenn keiner der Alarme ausgelöst wird, wird der gesamte Verkehr auf die grüne Flotte verlagert und es gibt eine letzte Backphase. Wenn die letzte Backphase endet, ohne dass ein Alarm ausgelöst wurde, bedient die grüne Flotte den gesamten Verkehr und SageMaker AI beendet die blaue Flotte.
## Voraussetzungen
Bevor Sie eine Bereitstellung mit Canary Traffic Shifting einrichten, müssen Sie Amazon CloudWatch-Alarme erstellen, um Metriken von Ihrem Endpunkt aus zu überwachen. Die Alarme sind während der Backphase aktiv, und wenn Alarme ausgelöst werden, wird der gesamte Endpunktverkehr auf die blaue Flotte zurückgesetzt. Informationen zum Einrichten von CloudWatch-Alarmen auf einem Endpunkt finden Sie auf der Seite [Konfiguration und Überwachung von Auto-Rollback](deployment-guardrails-configuration.md) mit den Voraussetzungen. Um mehr über [CloudWatch-Alarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) zu erfahren, siehe Verwenden von Amazon CloudWatch-Alarmen im *Amazon CloudWatch-Benutzerhandbuch*.
## Konfigurieren Sie Canary Traffic Shifting
Sobald Sie für Ihre Bereitstellung bereit sind und Amazon CloudWatch-Alarme für Ihren Endpunkt eingerichtet haben, können Sie entweder die Amazon SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API oder den Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) in der AWS CLI verwenden, um die Bereitstellung zu initiieren.
**Topics**
+ [So aktualisieren Sie einen Endpunkt (API)](#deployment-guardrails-blue-green-canary-configure-api-update)
+ [Wie aktualisiert man einen Endpunkt mit einer vorhandenen blau/grünen Update-Richtlinie (API)](#deployment-guardrails-blue-green-canary-configure-api-existing)
+ [So aktualisieren Sie einen Endpunkt (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### So aktualisieren Sie einen Endpunkt (API)
Das folgende Beispiel der [updateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) zeigt, wie Sie einen Endpunkt mit Canary Traffic Shifting aktualisieren können.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "CANARY",
"CanarySize": {
"Type": "CAPACITY_PERCENT",
"Value": 30
},
"WaitIntervalInSeconds": 600
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Um die Optionen Canary Traffic Shifting zu konfigurieren, machen Sie Folgendes:
+ Verwenden Sie für `EndpointName` den Namen des vorhandenen Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `EndpointConfigName` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Stellen Sie unter `DeploymentConfig` und `BlueGreenUpdatePolicy`, in `TrafficRoutingConfiguration`, den `Type` Parameter auf ein `CANARY`. Dies gibt an, dass die Bereitstellung Canary Traffic Shifting verwendet.
+ Im Feld `CanarySize` können Sie die Größe des Canary ändern, indem Sie die Parameter `Type` und `Value` ändern. Für `Type`, verwenden Sie `CAPACITY_PERCENT`, also den Prozentsatz Ihrer grünen Flotte, den Sie als Canary verwenden möchten, und setzen Sie dann `Value` auf `30`. In diesem Beispiel nutzen Sie 30% der Kapazität der grünen Flotte als Kanarienvogel. Beachten Sie, dass die Größe des Kanarienvogels 50% oder weniger der Kapazität der grünen Flotte entsprechen sollte.
+ Geben Sie als `WaitIntervalInSeconds` `600`ein. Der Parameter weist SageMaker AI an, zwischen jeder Intervallverschiebung die angegebene Zeit (in Sekunden) zu warten. Dieses Intervall entspricht der Dauer der Kanarienbackzeit. Im vorherigen Beispiel wartet SageMaker AI 10 Minuten nach der Canary-Verlagerung und schließt dann die zweite und letzte Verkehrsverlagerung ab.
+ Geben Sie als `TerminationWaitInSeconds` `600`ein. Dieser Parameter weist SageMaker AI an, die angegebene Zeit (in Sekunden) zu warten, nachdem Ihre grüne Flotte voll aktiv ist, bevor die Instances in der blauen Flotte beendet werden. In diesem Beispiel wartet SageMaker AI nach der letzten Backphase 10 Minuten, bevor die blaue Flotte beendet wird.
+ Geben Sie als `MaximumExecutionTimeoutInSeconds` `1800`ein. Dieser Parameter legt die maximale Zeit fest, die die Bereitstellung ausgeführt werden kann, bevor eine Zeitbeschränkung auftritt. Im vorherigen Beispiel gilt für Ihre Bereitstellung ein Limit von 30 Minuten bis zum Abschluss.
+ In `AutoRollbackConfiguration` können Sie im Feld `Alarms` Ihre CloudWatch-Alarme nach Namen hinzufügen. Erstellen Sie einen `AlarmName: ` Eintrag für jeden Alarm, den Sie verwenden möchten.
### Wie aktualisiert man einen Endpunkt mit einer vorhandenen blau/grünen Update-Richtlinie (API)
Wenn Sie die [CreateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) verwenden, um einen Endpunkt zu erstellen, können Sie optional eine Bereitstellungskonfiguration angeben, die für future Endpunkt-Updates wiederverwendet werden soll. Sie können dieselben `DeploymentConfig` Optionen wie im vorherigen UpdateEndpoint-API-Beispiel verwenden. Das Verhalten der CreateEndpoint-API wurde nicht geändert. Durch die Angabe der Bereitstellungskonfiguration wird nicht automatisch ein blau/grünes Update auf Ihrem Endpunkt durchgeführt.
Die Option, eine vorherige Bereitstellungskonfiguration zu verwenden, ist verfügbar, wenn Sie die [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)-API verwenden, um Ihren Endpunkt zu aktualisieren. Wenn Sie Ihren Endpunkt aktualisieren, können Sie die `RetainDeploymentConfig` Option verwenden, um die Bereitstellungskonfiguration beizubehalten, die Sie bei der Erstellung des Endpunkts angegeben haben.
Stellen Sie beim Aufrufen der [UpdateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) `RetainDeploymentConfig` auf `True` ein, um die `DeploymentConfig` Optionen aus Ihrer ursprünglichen Endpunktkonfiguration beizubehalten.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### So aktualisieren Sie einen Endpunkt (CLI)
Wenn Sie den AWS CLI verwenden, zeigt das folgende Beispiel, wie Sie mit dem Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) eine Blue/Green-Canary-Bereitstellung starten.
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "CANARY",
"CanarySize": {"Type": "CAPACITY_PERCENT", "Value": 30}, "WaitIntervalInSeconds": 600},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Um die Optionen Canary Traffic Shifting zu konfigurieren, machen Sie Folgendes:
+ Verwenden Sie für `endpoint-name` den Namen des Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `endpoint-config-name` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Verwenden Sie für `deployment-config` ein [BlueGreenUpdatePolicy-JSON-Objekt](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**Anmerkung**
Wenn Sie Ihr JSON-Objekt lieber in einer Datei speichern möchten, finden Sie weitere Informationen unter [Generieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) von AWS CLI Skelett- und Eingabeparametern im *AWS CLIBenutzerhandbuch*.
# Lineare Verkehrsverlagerung
Durch die lineare Verkehrsverlagerung können Sie den Verkehr schrittweise von Ihrer alten Flotte (blaue Flotte) auf Ihre neue Flotte (grüne Flotte) verlagern. Mit der linearen Verkehrsverlagerung können Sie den Verkehr in mehreren Schritten verlagern und so das Risiko einer Störung an Ihrem Endpunkt minimieren. Diese blaue/grüne Bereitstellungsoption bietet Ihnen die genaueste Kontrolle über die Verkehrsverlagerung.
Sie können entweder die Anzahl der Instances oder den Prozentsatz der Kapazität der grünen Flotte wählen, die bei jedem Schritt aktiviert werden sollen. Jeder lineare Schritt sollte nur zwischen 10 und 50% der Kapazität der grünen Flotte liegen. Für jeden Schritt gibt es eine Back-Phase, in der Ihre vordefinierten Amazon CloudWatch-Alarme die Metriken der grünen Flotte überwachen. Sobald die Backphase abgelaufen ist und keine Alarme ausgelöst werden, empfängt der aktive Teil Ihrer grünen Flotte weiterhin Traffic und ein neuer Schritt beginnt. Wenn während einer der Back-Phasen Alarme ausgelöst werden, werden 100% des Endpunktverkehrs wieder auf die blaue Flotte übertragen.
Das folgende Diagramm zeigt, wie die lineare Verkehrsverlagerung den Verkehr an die blauen und grünen Flotten weiterleitet.
![\[Eine erfolgreiche lineare Verkehrsverlagerung aus drei Schritten von der alten zu der neuen Flotte.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/deployment-guardrails-blue-green-linear.png)
Sobald SageMaker AI die neue Flotte bereitgestellt hat, wird der erste Teil der grünen Flotte eingeschaltet und empfängt Verkehr. SageMaker AI deaktiviert den gleichen Teil der blauen Flotte und die Backphase beginnt. Wenn Alarme ausgelöst werden, wird der gesamte Datenverkehr an den Endpunkten wieder auf die blaue Flotte übertragen. Wenn die Backzeit beendet ist, beginnt der nächste Schritt. Ein anderer Teil der grünen Flotte wird aktiviert und empfängt Verkehr, ein Teil der blauen Flotte wird deaktiviert und eine weitere Backphase beginnt. Derselbe Vorgang wiederholt sich, bis die blaue Flotte vollständig deaktiviert ist und die grüne Flotte voll aktiv ist und den gesamten Verkehr empfängt. Wenn zu irgendeinem Zeitpunkt ein Alarm ausgelöst wird, beendet SageMaker AI den Schichtvorgang und 100% des Traffics werden wieder der blauen Flotte zugewiesen.
## Voraussetzungen
Bevor Sie eine Bereitstellung mit linearer Verkehrsverlagerung einrichten, müssen Sie CloudWatch-Alarme erstellen, um Metriken von Ihrem Endpunkt aus zu überwachen. Die Alarme sind während der Backphase aktiv, und wenn Alarme ausgelöst werden, wird der gesamte Endpunktverkehr auf die blaue Flotte zurückgesetzt. Informationen zum Einrichten von CloudWatch-Alarmen auf einem Endpunkt finden Sie auf der Seite [Konfiguration und Überwachung von Auto-Rollback](deployment-guardrails-configuration.md) mit den Voraussetzungen. Um mehr über [CloudWatch-Alarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) zu erfahren, siehe Verwenden von Amazon CloudWatch-Alarmen im *Amazon CloudWatch-Benutzerhandbuch*.
## Konfigurieren Sie die lineare Verkehrsverlagerung
Sobald Sie für Ihre Bereitstellung bereit sind und CloudWatch-Alarme für Ihren Endpunkt eingerichtet haben, können Sie entweder die Amazon SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API oder den Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) in AWS CLI verwenden, um die Bereitstellung zu initiieren.
**Topics**
+ [So aktualisieren Sie einen Endpunkt (API)](#deployment-guardrails-blue-green-linear-configure-api-update)
+ [Wie aktualisiert man einen Endpunkt mit einer vorhandenen blau/grünen Update-Richtlinie (API)](#deployment-guardrails-blue-green-linear-configure-api-existing)
+ [So aktualisieren Sie einen Endpunkt (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### So aktualisieren Sie einen Endpunkt (API)
Das folgende Beispiel der [updateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) zeigt, wie Sie einen Endpunkt mit linearer Verkehrsverlagerung aktualisieren können.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "LINEAR",
"LinearStepSize": {
"Type": "CAPACITY_PERCENT",
"Value": 20
},
"WaitIntervalInSeconds": 300
},
"TerminationWaitInSeconds": 300,
"MaximumExecutionTimeoutInSeconds": 3600
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Um die Optionen Linear Traffic Shifting zu konfigurieren, machen Sie Folgendes:
+ Verwenden Sie für `EndpointName` den Namen des vorhandenen Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `EndpointConfigName` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Stellen Sie unter `DeploymentConfig` und `BlueGreenUpdatePolicy`, in `TrafficRoutingConfiguration`,, den `Type` Parameter auf `LINEAR` ein. Dies gibt an, dass bei der Bereitstellung eine lineare Verkehrsverlagerung verwendet wird.
+ Im Feld `LinearStepSize` können Sie die Größe der Schritte ändern, indem Sie die Parameter `Type` und `Value` ändern. Für `Type` verwenden Sie `CAPACITY_PERCENT`, d. h. den Prozentsatz Ihrer grünen Flotte, den Sie als Schrittgröße verwenden wollen, und setzen Sie `Value` auf `20`. In diesem Beispiel schalten Sie für jeden Schritt der Verkehrsverlagerung 20% der Kapazität der umweltfreundlichen Flotte ein. Beachten Sie, dass Sie bei der Anpassung Ihrer linearen Schrittgröße nur Stufen verwenden sollten, die 10-50% der Kapazität der grünen Flotte ausmachen.
+ Geben Sie als `WaitIntervalInSeconds` `300`ein. Der Parameter weist SageMaker AI an, zwischen jeder Datenverkehrs-Verlagerung den angegebenen Zeitraum (in Sekunden) zu warten. Dieses Intervall ist die Dauer der Backzeit zwischen den einzelnen linearen Schritten. Im vorherigen Beispiel wartet SageMaker AI zwischen jeder Verkehrsschicht 5 Minuten.
+ Geben Sie als `TerminationWaitInSeconds` `300`ein. Dieser Parameter weist SageMaker AI an, die angegebene Zeit (in Sekunden) zu warten, nachdem Ihre grüne Flotte voll aktiv ist, bevor die Instances in der blauen Flotte beendet werden. In diesem Beispiel wartet SageMaker AI nach der letzten Backphase 5 Minuten, bevor die blaue Flotte beendet wird.
+ Geben Sie als `MaximumExecutionTimeoutInSeconds` `3600`ein. Dieser Parameter legt die maximale Zeit fest, die die Bereitstellung ausgeführt werden kann, bevor eine Zeitbeschränkung auftritt. Im vorherigen Beispiel gilt für Ihre Bereitstellung ein Limit von 1 Stunde bis zum Abschluss.
+ In `AutoRollbackConfiguration` können Sie im Feld `Alarms` Ihre CloudWatch-Alarme nach Namen hinzufügen. Erstellen Sie einen `AlarmName: ` Eintrag für jeden Alarm, den Sie verwenden möchten.
### Wie aktualisiert man einen Endpunkt mit einer vorhandenen blau/grünen Update-Richtlinie (API)
Wenn Sie die [CreateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) verwenden, um einen Endpunkt zu erstellen, können Sie optional eine Bereitstellungskonfiguration angeben, die für future Endpunkt-Updates wiederverwendet werden soll. Sie können dieselben `DeploymentConfig` Optionen wie im vorherigen UpdateEndpoint-API-Beispiel verwenden. Das Verhalten der CreateEndpoint-API wurde nicht geändert. Durch die Angabe der Bereitstellungskonfiguration wird nicht automatisch ein blau/grünes Update auf Ihrem Endpunkt durchgeführt.
Die Option, eine vorherige Bereitstellungskonfiguration zu verwenden, ist verfügbar, wenn Sie die [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)-API verwenden, um Ihren Endpunkt zu aktualisieren. Wenn Sie Ihren Endpunkt aktualisieren, können Sie die `RetainDeploymentConfig` Option verwenden, um die Bereitstellungskonfiguration beizubehalten, die Sie bei der Erstellung des Endpunkts angegeben haben.
Stellen Sie beim Aufrufen der [UpdateEndpoint-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) `RetainDeploymentConfig` auf `True` ein, um die `DeploymentConfig` Optionen aus Ihrer ursprünglichen Endpunktkonfiguration beizubehalten.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### So aktualisieren Sie einen Endpunkt (CLI)
Wenn Sie den verwenden AWS CLI, zeigt das folgende Beispiel, wie Sie mit dem Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) eine lineare Blau/Grün-Bereitstellung starten.
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '{"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "LINEAR",
"LinearStepSize": {"Type": "CAPACITY_PERCENT", "Value": 20}, "WaitIntervalInSeconds": 300},
"TerminationWaitInSeconds": 300, "MaximumExecutionTimeoutInSeconds": 3600},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Um die Optionen Linear Traffic Shifting zu konfigurieren, machen Sie Folgendes:
+ Verwenden Sie für `endpoint-name` den Namen des Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `endpoint-config-name` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Verwenden Sie für `deployment-config` ein [BlueGreenUpdatePolicy-JSON-Objekt](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**Anmerkung**
Wenn Sie Ihr JSON-Objekt lieber in einer Datei speichern möchten, finden Sie weitere Informationen unter [Generieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) von AWS CLI Skelett- und Eingabeparametern im *AWS CLIBenutzerhandbuch*.
# Rollende Bereitstellungen verwenden
Wenn Sie Ihren Endpunkt aktualisieren, können Sie einen fortlaufenden Einsatz angeben, um den Verkehr schrittweise von Ihrer alten Flotte auf eine neue Flotte zu verlagern. Sie können die Größe der Schritte zur Verkehrsverlagerung steuern und einen Testzeitraum festlegen, in dem die neuen Instances auf Probleme hin überwacht werden, bevor Instances aus der alten Flotte beendet werden. Bei fortlaufenden Bereitstellungen werden die Instances auf der alten Flotte nach jeder Verlagerung des Datenverkehrs auf die neue Flotte bereinigt, wodurch die Anzahl der zusätzlichen Instances, die für die Aktualisierung Ihres Endpunkts erforderlich sind, reduziert wird. Dies ist insbesondere für beschleunigte Instances nützlich, die stark nachgefragt werden.
Bei fortlaufenden Bereitstellungen wird die vorherige Bereitstellung Ihrer Modellversion schrittweise durch die neue Version ersetzt, indem Ihr Endpunkt in konfigurierbaren Batchgrößen aktualisiert wird. Das Verhalten von rollierenden Bereitstellungen ähnelt dem [linearen Verkehrsverlagerungsmodus](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green-linear.html) in blue/green Bereitstellungen, aber rollierende Bereitstellungen bieten Ihnen im Vergleich zu Bereitstellungen den Vorteil geringerer Kapazitätsanforderungen. blue/green Bei rollierenden Bereitstellungen sind weniger Instances gleichzeitig aktiv, und Sie haben eine genauere Kontrolle darüber, wie viele Instances Sie in der neuen Flotte aktualisieren möchten. Sie sollten die Verwendung einer fortlaufenden Bereitstellung anstelle einer Bereitstellung in Betracht ziehen, wenn Sie über große Modelle oder einen großen Endpunkt mit vielen Instanzen verfügen. blue/green
In der folgenden Liste werden die wichtigsten Funktionen von fortlaufenden Bereitstellungen in Amazon SageMaker AI beschrieben:
+ **Backzeit.**Die Backphase ist ein festgelegter Zeitraum, um die neue Flotte zu überwachen, bevor mit der nächsten Einsatzphase begonnen wird. Wenn einer der vordefinierten Alarme während einer Back-Phase ausgelöst wird, wird der gesamte Endpunktverkehr auf die alte Flotte zurückgesetzt. Die Backphase hilft Ihnen dabei, Vertrauen in Ihr Update aufzubauen, bevor Sie den Traffic dauerhaft verlagern.
+ **Größe der rollenden Charge.** Sie haben die genaue Kontrolle über die Größe jedes Batches für die Verkehrsverlagerung oder über die Anzahl der Instances, die Sie in jedem Batch aktualisieren möchten. Diese Zahl kann zwischen 5 und 50% der Größe Ihrer Flotte liegen. Sie können die Batchgröße als Anzahl von Instances oder als Gesamtanteil Ihrer Flotte angeben.
+ **Automatisches Zurücksetzen.**Sie können CloudWatch Amazon-Alarme angeben, die SageMaker KI zur Überwachung der neuen Flotte verwendet. Wenn ein Problem mit dem aktualisierten Code einen der Alarme auslöst, leitet SageMaker KI ein automatisches Rollback zur alten Flotte ein, um die Verfügbarkeit aufrechtzuerhalten und so das Risiko zu minimieren.
**Anmerkung**
Wenn Ihr Endgerät eine der auf der Seite [Ausnahmen](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html) aufgeführten Funktionen verwendet, können Sie keine fortlaufenden Bereitstellungen verwenden.
## Funktionsweise
Während einer fortlaufenden Bereitstellung stellt SageMaker KI die Infrastruktur bereit, um den Verkehr von der alten Flotte auf die neue Flotte zu verlagern, ohne dass alle neuen Instanzen gleichzeitig bereitgestellt werden müssen. SageMaker KI verwendet die folgenden Schritte, um den Verkehr zu verlagern:
1. SageMaker KI stellt die erste Gruppe von Instances in der neuen Flotte bereit.
1. Ein Teil des Datenverkehrs wird von den alten Instances auf den ersten Batch neuer Instances verlagert.
1. Wenn nach der Backphase keine CloudWatch Amazon-Alarme ausgelöst werden, bereinigt SageMaker KI einen Stapel alter Instances.
1. SageMaker KI stellt Instances weiterhin stapelweise bereit, verschiebt und bereinigt, bis die Bereitstellung abgeschlossen ist.
Wenn während einer der Back-Phasen ein Alarm ausgelöst wird, wird der Traffic in Batches einer von Ihnen angegebenen Größe auf die alte Flotte zurückgeführt. Alternativ können Sie den fortlaufenden Einsatz so festlegen, dass 100% des Verkehrs wieder auf die alte Flotte umgeleitet werden, wenn ein Alarm ausgelöst wird.
Das folgende Diagramm zeigt den Verlauf eines erfolgreichen rollierenden Einsatzes, wie in den vorherigen Schritten beschrieben.
![\[Die Schritte der erfolgreichen Verlagerung des Datenverkehrs von der alten zu der neuen Flotte während eines laufenden Einsatzes\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/deployment-guardrails-rolling-diagram.png)
Um eine fortlaufende Bereitstellung zu erstellen, müssen Sie nur Ihre gewünschte Bereitstellungskonfiguration angeben. Dann kümmert sich SageMaker KI für Sie um die Bereitstellung neuer Instanzen, die Kündigung alter Instanzen und die Verlagerung des Datenverkehrs. Sie können Ihre Bereitstellung mithilfe der vorhandenen [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)und der Befehle erstellen und verwalten. AWS Command Line Interface
## Voraussetzungen
Bevor Sie eine fortlaufende Bereitstellung einrichten, müssen Sie CloudWatch Amazon-Alarme erstellen, um Metriken von Ihrem Endpunkt aus zu überwachen. Wenn einer der Alarme während der Backphase ausgelöst wird, wird der Traffic wieder auf Ihre alte Flotte übertragen. Informationen zum Einrichten von CloudWatch Alarmen auf einem Endpunkt finden Sie auf der Seite mit den Voraussetzungen für die [automatische Rollback-Konfiguration und Überwachung](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-configuration.html). Weitere Informationen zu CloudWatch Alarmen finden Sie unter [Verwenden von CloudWatch Amazon-Alarmen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) im * CloudWatch Amazon-Benutzerhandbuch*.
Sehen Sie sich auch die Seite mit den [Ausnahmen](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html) an, um sicherzustellen, dass Ihr Endpunkt die Anforderungen für eine fortlaufende Bereitstellung erfüllt.
## Ermitteln Sie die Größe der fortlaufenden Charge
Bevor Sie Ihren Endpunkt aktualisieren, bestimmen Sie die Batchgröße, die Sie für die schrittweise Verlagerung des Datenverkehrs auf die neue Flotte verwenden möchten.
Für fortlaufende Bereitstellungen können Sie eine Chargengröße angeben, die 5-50% der Kapazität Ihrer Flotte entspricht. Wenn Sie sich für eine große Batchgröße entscheiden, wird die Bereitstellung schneller abgeschlossen. Beachten Sie jedoch, dass der Endpunkt bei der Aktualisierung mehr Kapazität benötigt, was in etwa dem Mehraufwand für die Batchgröße entspricht. Wenn Sie eine kleinere Batchgröße wählen, dauert die Bereitstellung länger, aber Sie verbrauchen während der Bereitstellung weniger Kapazität.
## Eine laufende Bereitstellung konfigurieren
Sobald Sie für Ihre Bereitstellung bereit sind und CloudWatch Alarme für Ihren Endpunkt eingerichtet haben, können Sie die SageMaker [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)KI-API oder den Befehl [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) in der verwenden, AWS Command Line Interface um die Bereitstellung zu starten.
**Wie aktualisiert man einen Endpunkt**
Das folgende Beispiel zeigt, wie Sie Ihren Endpunkt mithilfe der Methode [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html) des Boto3 AI-Clients mit einer fortlaufenden Bereitstellung aktualisieren können. SageMaker
Verwenden Sie das folgende Beispiel und die folgenden Felder, um eine fortlaufende Bereitstellung zu konfigurieren:
+ Verwenden Sie für `EndpointName` den Namen des vorhandenen Endpunkts, den Sie aktualisieren möchten.
+ Verwenden Sie für `EndpointConfigName` den Namen der Endpunkt-Konfiguration, die Sie verwenden möchten.
+ Im `AutoRollbackConfiguration` Objekt, innerhalb des `Alarms` Feldes, können Sie Ihre CloudWatch Alarme nach Namen hinzufügen. Erstellen Sie einen `AlarmName: ` Eintrag für jeden Alarm, den Sie verwenden möchten.
+ Geben Sie unter `DeploymentConfig` für das `RollingUpdatePolicy` Objekt die folgenden Felder an:
+ `MaximumExecutionTimeoutInSeconds` – Das Zeitlimit für die gesamte Bereitstellung. Eine Überschreitung dieses Limits führt zu einem Timeout. Der Höchstwert, den Sie für dieses Feld angeben können, ist 28800 Sekunden oder 8 Stunden.
+ `WaitIntervalInSeconds`— Die Dauer der Backphase, in der die SageMaker KI die Alarme für jede Charge der neuen Flotte überwacht.
+ `MaximumBatchSize` – Geben Sie die `Type` Charge an, die Sie verwenden möchten (entweder die Anzahl der Instances oder der Gesamtanteil Ihrer Flotte) und die `Value` oder die Größe jeder Charge.
+ `RollbackMaximumBatchSize` – Verwenden Sie dieses Objekt, um die Rollback-Strategie für den Fall festzulegen, dass ein Alarm ausgelöst wird. Geben Sie die `Type` Anzahl der Chargen an, die Sie verwenden möchten (entweder die Anzahl der Instances oder der Gesamtanteil Ihrer Flotte) und die `Value` oder die Größe der einzelnen Chargen. Wenn Sie diese Felder nicht angeben oder den Wert auf 100% Ihres Endpunkts setzen, verwendet SageMaker KI eine blue/green Rollback-Strategie und rollt den gesamten Verkehr auf die alte Flotte zurück, wenn ein Alarm ausgelöst wird.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
},
"RollingUpdatePolicy": {
"MaximumExecutionTimeoutInSeconds": number,
"WaitIntervalInSeconds": number,
"MaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
"RollbackMaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
}
}
)
```
Nach der Aktualisierung Ihres Endpunkts möchten Sie möglicherweise den Status Ihrer fortlaufenden Bereitstellung und den Zustand Ihres Endpunkts überprüfen. Sie können den Status Ihres Endpunkts in der SageMaker KI-Konsole überprüfen, oder Sie können den Status Ihres Endpunkts mithilfe der [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API überprüfen.
In dem von der `DescribeEndpoint` API zurückgegebenen `VariantStatus` Objekt informiert Sie das `Status` Feld über den aktuellen Bereitstellungs- oder Betriebsstatus Ihres Endgeräts. Weitere Informationen zu den möglichen Status und ihrer Bedeutung finden Sie unter [ProductionVariantStatus](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantStatus.html).
Wenn Sie versucht haben, eine fortlaufende Bereitstellung durchzuführen und der Status Ihres Endpunkts lautet `UpdateRollbackFailed`, finden Sie im folgenden Abschnitt Hilfe zur Fehlerbehebung.
## Fehlerbehandlung
Wenn Ihre rollenden Bereitstellungen fehlschlagen und auch das automatische Rollback fehlschlägt, kann Ihr Endpunkt den Status von `UpdateRollbackFailed` behalten. Dieser Status bedeutet, dass für die Instances hinter Ihrem Endpunkt unterschiedliche Endpunktkonfigurationen bereitgestellt werden und Ihr Endpunkt mit einer Mischung aus alten und neuen Endpunktkonfigurationen in Betrieb ist.
Sie können die [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API erneut aufrufen, um Ihren Endpunkt wieder in einen fehlerfreien Zustand zu versetzen. Geben Sie Ihre gewünschte Endpunktkonfiguration und Bereitstellungskonfiguration an (entweder als fortlaufende Bereitstellung, als blaue/grüne Bereitstellung oder beides), um Ihren Endpunkt zu aktualisieren.
Sie können die [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API aufrufen, um den Zustand Ihres Endpunkts erneut zu überprüfen, der im `VariantStatus` Objekt als `Status` Feld zurückgegeben wird. Wenn Ihr Update erfolgreich ist, kehrt Ihr Endpunkt `Status` zu `InService` zurück.
# Ausschlüsse
Bei einer blauen/grünen oder fortlaufenden Bereitstellung muss Ihre neue Endpunktkonfiguration denselben Variantennamen wie die alte Endpunktkonfiguration haben. Es gibt auch funktionsbasierte Ausschlüsse, die dazu führen, dass Ihr Endpunkt derzeit nicht mit den Bereitstellungsrichtlinien kompatibel ist. Wenn Ihr Endpunkt eine der folgenden Funktionen verwendet, können Sie auf Ihrem Endpunkt keine Deployment Guardrails verwenden, und Ihr Endpunkt wird auf eine blaue/grüne Bereitstellung zurückgreifen, bei der der gesamte Datenverkehr auf einmal verlagert wird und es keine letzte Backphase gibt:
+ Marketplace Container
+ Endpunkte, die Inf1-Instances (Inferentia-basiert) verwenden
Wenn Sie eine fortlaufende Bereitstellung durchführen, gibt es zusätzliche, auf Funktionen basierende Ausnahmen:
+ Serverless Inference Endpoints
+ Inferenzendpunkte mit mehreren Varianten
# Schattentests
Mit Amazon SageMaker AI können Sie alle Änderungen an Ihrem Modell der Serverinfrastruktur bewerten, indem Sie dessen Leistung mit der aktuell bereitgestellten Infrastruktur vergleichen. Diese Vorgehensweise wird als Schattentest bezeichnet. Schattentests können Ihnen helfen, catch Konfigurationsfehler und Leistungsprobleme zu erkennen, bevor sie sich auf Endbenutzer auswirken. Mit SageMaker AI müssen Sie nicht in den Aufbau Ihrer Shadow-Testing-Infrastruktur investieren, sodass Sie sich auf die Modellentwicklung konzentrieren können.
Sie können diese Funktion nutzen, um Änderungen an jeder Komponente Ihrer Produktionsvariante, d. h. am Modell, am Container oder an der Instance, zu validieren, ohne dass sich dies auf den Endbenutzer auswirkt. Dies ist unter anderem in folgenden Situationen nützlich, ist aber nicht darauf beschränkt:
+ Sie erwägen, ein neues Modell, das offline validiert wurde, in der Produktion einzuführen, möchten aber vor dieser Entscheidung betriebliche Leistungskennzahlen wie Latenz und Fehlerrate auswerten.
+ Sie erwägen Änderungen an Ihrem Serverinfrastruktur-Container, z. B. das Patchen von Sicherheitslücken oder das Upgrade auf neuere Versionen, und möchten die Auswirkungen dieser Änderungen abschätzen, bevor Sie zur Produktion übergehen.
+ Sie erwägen, Ihre ML-Instance zu ändern, und möchten evaluieren, wie die neue Instance bei Live-Inferenzanfragen abschneiden würde.
Die SageMaker-AI-Konsole bietet eine geführte Erfahrung zur Verwaltung des Workflows von Shadow Testing. Sie können Schattentests für einen vordefinierten Zeitraum einrichten, den Fortschritt des Tests über ein Live-Dashboard überwachen, nach Abschluss bereinigen und auf der Grundlage der Ergebnisse handeln. Wählen Sie eine Produktionsvariante aus, mit der Sie testen möchten, und SageMaker AI stellt die neue Variante automatisch im Schattenmodus bereit und leitet eine Kopie der Inferenzanfragen in Echtzeit innerhalb desselben Endpunkts an sie weiter. Nur die Antworten der Produktionsvariante werden an die aufrufende Anwendung zurückgegeben. Sie können wählen, ob Sie die Antworten der Schattenvariante verwerfen oder protokollieren möchten, um sie offline vergleichen zu können. Weitere Informationen zu Produktions- und Schattenvarianten finden Sie unter [Validieren von Modellen in der Produktion](model-validation.md).
Anweisungen zum Erstellen eines Schattentests finden Sie unter [Erstellen Sie ein Shadow Testing](shadow-tests-create.md).
**Anmerkung**
Bestimmte Endpunkt-Features können dazu führen, dass Ihr Endpunkt nicht mit Schattentests kompatibel ist. Wenn Ihr Endpunkt eine der folgenden Features verwendet, können Sie auf Ihrem Endpunkt keine Schattentests verwenden und Ihre Anfrage zur Einrichtung von Schattentests führt zu Validierungsfehlern.
Serverlose Inferenz
Asynchrone Inferenz
Marketplace Container
Endpunkte mit mehreren Containern
Endpunkte mit mehreren Knoten
Endpunkte, die Inf1-Instances (auf Inferenz basieren) verwenden
# Erstellen Sie ein Shadow Testing
Sie können ein Shadow Testing erstellen, um die Leistung einer Shadow-Variante mit einer Produktionsvariante zu vergleichen. Sie können den Test auf einem vorhandenen Endpunkt ausführen, der Inferenzanforderungen bedient, oder Sie können einen neuen Endpunkt erstellen, auf dem der Test ausgeführt werden soll.
Um einen Shadow-Test zu erstellen, benötigen Sie folgende Informationen:
+ Eine *Produktionsvariante*, die 100 Prozent der eingehenden Inferenzanfragen empfängt und beantwortet.
+ Eine *Shadow-Variante*, die einen Prozentsatz der eingehenden Anfragen empfängt, die aus der Produktionsvariante repliziert werden, aber keine Antworten zurückgibt.
Für jede Variante können Sie SageMaker KI verwenden, um das Modell, den Instance-Typ und die Anzahl der Instanzen zu kontrollieren. Sie können den Prozentsatz der eingehenden Anfragen, den sogenannten Traffic Sampling-Prozentsatz, konfigurieren, der auf Ihre Shadow-Variante repliziert werden soll. SageMaker KI verwaltet die Replikation von Anfragen an Ihre Shadow-Variante, und Sie können den Prozentsatz der Traffic-Abtastung ändern, wenn Ihr Test geplant ist oder läuft. Sie können optional auch Data Capture aktivieren, um Anfragen und Antworten Ihrer Produktions- und Shadow-Varianten zu protokollieren.
**Anmerkung**
SageMaker KI unterstützt maximal eine Shadow-Variante pro Endpunkt. Für einen Endpunkt mit einer Shadow-Variante kann es maximal eine Produktionsvariante geben.
Sie können den Test so planen, dass er zu einem beliebigen Zeitpunkt beginnt und für eine bestimmte Dauer fortgesetzt wird. Die Standarddauer beträgt 7 Tage und die Höchstdauer 30 Tage. Nach Abschluss des Tests kehrt der Endpunkt in den Zustand zurück, in dem er sich vor dem Start des Tests befand. Dadurch wird sichergestellt, dass Sie Ressourcen nach Abschluss des Tests nicht manuell bereinigen müssen.
Sie können einen Test, der gerade läuft, über ein Dashboard in der SageMaker AI-Konsole überwachen. Das Dashboard bietet einen direkten Vergleich der Aufrufmetriken und Instance-Metriken zwischen der Produktions- und der Shadow-Variante sowie eine tabellarische Ansicht mit relevanten Metrikstatistiken. Dieses Dashboard ist auch für abgeschlossene Tests verfügbar. Nachdem Sie die Kennzahlen überprüft haben, können Sie entweder die Shadow-Variante zur neuen Produktionsvariante heraufstufen oder die bestehende Produktionsvariante beibehalten. Sobald Sie die Shadow-Variante hochgestuft haben, beantwortet sie alle eingehenden Anfragen. Weitere Informationen finden Sie unter [Hochstufen einer Schattenvariante](shadow-tests-complete.md#shadow-tests-complete-promote).
Das folgende Verfahren beschreibt, wie Sie einen Shadow-Test über die SageMaker AI-Konsole erstellen. Je nachdem, ob Sie einen vorhandenen Endpunkt verwenden oder einen neuen Endpunkt für den Shadow-Test erstellen möchten, gibt es Variationen im Arbeitsablauf.
**Topics**
+ [Voraussetzungen](#shadow-tests-create-prerequisites)
+ [Geben Sie die Details zum Shadow-Test ein](#shadow-tests-create-console-shadow-test-details)
+ [Geben Sie die Shadow-Test-Einstellungen ein](#shadow-tests-create-console-shadow-test-settings)
## Voraussetzungen
Bevor Sie einen Shadow-Test mit der SageMaker AI-Konsole erstellen, müssen Sie über ein einsatzbereites SageMaker KI-Modell verfügen. Weitere Informationen zur Erstellung eines SageMaker KI-Modells finden Sie unter[Modelle für Echtzeit-Inferenzen bereitstellen](realtime-endpoints-deploy-models.md).
Sie können mit Schattentests mit einem vorhandenen Endpunkt mit einer Produktionsvariante und einer Schattenvariante, einem vorhandenen Endpunkt mit nur einer Produktionsvariante oder nur mit den SageMaker KI-Modellen beginnen, die Sie vergleichen möchten. Shadow-Tests unterstützen die Erstellung eines Endpunkts und das Hinzufügen von Varianten, bevor Ihr Test beginnt.
**Anmerkung**
Bestimmte Endpunkt-Features können dazu führen, dass Ihr Endpunkt nicht mit Schattentests kompatibel ist. Wenn Ihr Endpunkt eine der folgenden Features verwendet, können Sie auf Ihrem Endpunkt keine Schattentests verwenden und Ihre Anfrage zur Einrichtung von Schattentests führt zu Validierungsfehlern.
Serverlose Inferenz
Asynchrone Inferenz
Marketplace Container
Endpunkte mit mehreren Containern
Endpunkte mit mehreren Knoten
Endpunkte, die Inf1-Instances (auf Inferenz basieren) verwenden
## Geben Sie die Details zum Shadow-Test ein
Um mit der Erstellung Ihres Shadow-Tests zu beginnen, füllen Sie die Seite **Shadow-Testdetails eingeben** wie folgt aus:
1. Öffnen Sie die [SageMaker AI-Konsole](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im linken Navigationsbereich **Inferenz** und anschließend **Shadow-Tests** aus.
1. Wählen Sie **Shadow-Test**.
1. Geben Sie für **Name** einen Namen für den Test ein.
1. (Optional) Geben Sie im Feld **Description** eine Beschreibung für den Test ein.
1. (Optional) Geben Sie **Tags** mithilfe von **Schlüssel** – und **Wertepaaren** an.
1. Wählen Sie **Weiter** aus.
## Geben Sie die Shadow-Test-Einstellungen ein
Nachdem Sie die Seite **Shadow-Test-Details** eingeben ausgefüllt haben, füllen Sie die Seite **Shadow-Test-Einstellungen eingeben** aus. Wenn Sie bereits über einen SageMaker KI-Inferenz-Endpunkt und eine Produktionsvariante verfügen, folgen Sie dem Workflow **Bestehenden Endpunkt verwenden**. Wenn Sie noch keinen Endpunkt haben, folgen Sie dem Workflow **Neuen Endpunkt erstellen**.
------
#### [ Use an existing endpoint ]
Wenn Sie einen vorhandenen Endpunkt für Ihren Test verwenden möchten, füllen Sie die Seite **Shadow-Testeinstellungen eingeben** wie folgt aus:
1. Wählen Sie eine Rolle, der die `AmazonSageMakerFullAccess` IAM-Richtlinie zugeordnet ist.
1. Wählen Sie **Vorhandenen Endpunkt verwenden** und wählen Sie dann einen der verfügbaren Endpunkte aus.
1. (Optional) Um das Speichervolumen auf Ihrem Endpunkt zu verschlüsseln, wählen Sie entweder einen vorhandenen **KMS-Schlüssel** oder wählen Sie KMS-Schlüssel-ARN eingeben aus der Dropdown-Liste unter **Verschlüsselungsschlüssel**. Wenn Sie die zweite Option wählen, wird ein Feld zur Eingabe des KMS-Schlüssels ARN angezeigt. Geben Sie den KMS-Schlüssel ARN in dieses Feld ein.
1. Wenn hinter diesem Endpunkt mehrere Produktionsvarianten stehen, entfernen Sie diejenigen, die Sie nicht für den Test verwenden möchten. Sie können eine Modellvariante entfernen, indem Sie sie auswählen und dann **Entfernen** wählen.
1. Wenn Sie noch keine Shadow-Variante haben, fügen Sie eine Shadow-Variante hinzu. Fügen Sie wie folgt eine Shadow-Variante hinzu:
1. Wählen Sie **Hinzufügen** aus.
1. Wählen Sie die **Shadow-Variante**.
1. Wählen Sie im Dialogfeld **Modell hinzufügen** das Modell, das Sie für Ihre Shadow-Variante verwenden möchten.
1. Wählen Sie **Speichern**.
1. (Optional) Im vorherigen Schritt wurde die Shadow-Variante mit den Standardeinstellungen hinzugefügt. Um diese Einstellungen zu ändern, wählen Sie die Shadow-Variante aus und klicken Sie auf **Bearbeiten**. Das Dialogfenster **Shadow-Variante bearbeiten** wird angezeigt. Weitere Informationen über das Ausfüllen dieses Dialogfelds finden Sie unter [Bearbeiten Sie einen Schattentest](shadow-tests-view-monitor-edit-individual.md).
1. Geben Sie im Abschnitt **Zeitplan** die Dauer des Tests ein, indem Sie wie folgt vorgehen:
1. Wählen Sie das Feld unter **Dauer** aus. Es wird ein Popup-Kalender angezeigt.
1. Wählen Sie das Start- und Enddatum aus dem Kalender aus, oder geben Sie das Start- und Enddatum in die Felder für **Startdatum** bzw. **Enddatum** ein.
1. (Optional) Geben Sie für die Felder **Startzeit** und **Endzeit** jeweils die Start- und Endzeit im 24-Stunden-Format ein.
1. Wählen Sie **Anwenden** aus.
Die Mindestdauer beträgt 1 Stunde und die Höchstdauer 30 Tage.
1. (Optional) Aktivieren Sie die Option **Datenerfassung aktivieren**, um Informationen zu Inferenzanfragen und -antworten von Ihrem Endpunkt in einem Amazon-S3-Bucket zu speichern, und geben Sie dann den Speicherort des Amazon-S3-Buckets ein.
1. Wählen Sie **Shadow-Test erstellen**.
------
#### [ Create a new endpoint ]
Wenn Sie noch keinen vorhandenen Endpunkt haben oder einen neuen Endpunkt für Ihren Test erstellen möchten, füllen Sie die Seite **Shadow-Testeinstellungen eingeben** wie folgt aus:
1. Wählen Sie eine Rolle, der die`AmazonSageMakerFullAccess` IAM-Richtlinie zugeordnet ist.
1. Wählen Sie **Neuen Endpunkt erstellen** aus.
1. Geben Sie unter **Name tag** einen Namen für den Endpunkt ein.
1. Fügen Sie dem Endpunkt eine Produktionsvariante und eine Shadow-Variante hinzu:
+ Um eine Produktionsvariante hinzuzufügen, wählen Sie **Hinzufügen** und dann **Produktionsvariante**. Wählen Sie im Dialogfeld **Modell hinzufügen** das Modell, das Sie für Ihre Produktionsvariante verwenden möchten, und klicken Sie dann auf **Speichern**.
+ Um eine Shadow-Variante hinzuzufügen, wählen Sie **Hinzufügen** und anschließend **Shadow-Variante**. Wählen Sie im Dialogfeld **Modell hinzufügen**, das Sie für Ihre Shadow-Variante verwenden möchten, und klicken Sie dann auf **Speichern**.
1. (Optional) Im vorherigen Schritt wurde die Shadow-Variante mit den Standardeinstellungen hinzugefügt. Um diese Einstellungen zu ändern, wählen Sie die Shadow-Variante aus und klicken Sie auf **Bearbeiten**. Das Dialogfenster **Shadow-Variante bearbeiten** wird angezeigt. Weitere Informationen über das Ausfüllen dieses Dialogfelds finden Sie unter [Bearbeiten Sie einen Schattentest](shadow-tests-view-monitor-edit-individual.md).
1. Geben Sie im Abschnitt **Zeitplan** die Dauer des Tests ein, indem Sie wie folgt vorgehen:
1. Wählen Sie das Feld unter **Dauer** aus. Es wird ein Popup-Kalender angezeigt.
1. Wählen Sie das Start- und Enddatum aus dem Kalender aus, oder geben Sie das Start- und Enddatum unter **Startdatum** bzw. **Enddatum** ein.
1. (Optional) Geben Sie unter **Startzeit** und **Endzeit** die Start- bzw. Endzeit im 24-Stunden-Format ein.
1. Wählen Sie **Anwenden** aus.
Die Mindestdauer beträgt 1 Stunde und die Höchstdauer 30 Tage.
1. (Optional) Aktivieren Sie die Option **Datenerfassung aktivieren**, um Informationen zu Inferenzanfragen und -antworten von Ihrem Endpunkt in einem Amazon-S3-Bucket zu speichern, und geben Sie dann den Speicherort des Amazon-S3-Buckets ein.
1. Wählen Sie **Shadow-Test erstellen**.
------
Nachdem Sie die vorherigen Verfahren abgeschlossen haben, sollte nun ein Test geplant sein, der an dem von Ihnen angegebenen Startdatum und der angegebenen Startzeit beginnt. Sie können den Fortschritt des Tests von einem Dashboard aus verfolgen. Weitere Informationen über das Anzeigen Ihres Tests und die Aktionen, die Sie ergreifen können, finden Sie unter [Anzeigen, Überwachen und Bearbeiten von Schattentests](shadow-tests-view-monitor-edit.md).
# Anzeigen, Überwachen und Bearbeiten von Schattentests
Sie können den Status Ihrer Shadow-Tests einsehen, deren Fortschritt von einem Dashboard aus überwachen und Aktionen ausführen, z. B. einen Test vorzeitig starten oder beenden oder einen Test löschen. In den folgenden Themen wird gezeigt, wie Sie Ihre Shadow-Tests mithilfe der SageMaker-AI-Konsole anzeigen und ändern können.
**Topics**
+ [Shadow-Tests anzeigen](shadow-tests-view-monitor-edit-list.md)
+ [Überwachen Sie einen Schattentest](shadow-tests-view-monitor-edit-dashboard.md)
+ [Starten Sie frühzeitig einen Schattentest](shadow-tests-view-monitor-edit-start.md)
+ [Löschen Sie einen Shadow-Test](shadow-tests-view-monitor-edit-delete.md)
+ [Bearbeiten Sie einen Schattentest](shadow-tests-view-monitor-edit-individual.md)
# Shadow-Tests anzeigen
Sie können den Status all Ihrer Schattentests auf der Seite **Schattentests** in der SageMaker-AI-Konsole einsehen.
Führen Sie die folgenden Schritte aus, um Ihre Tests in der Konsole anzuzeigen:
1. Öffnen Sie die [SageMaker-AI-Konsole](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im Navigationsbereich **Inferenz** aus.
1. Wählen Sie **Shadow-Tests**, um die Seite aufzurufen, auf der all Ihre Shadow-Tests aufgeführt sind. Die Seite sollte wie der folgende Screenshot aussehen, wobei alle Tests im Abschnitt **Shadow-Test** aufgeführt sind.
![\[Liste aller Schattentests.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/juxtaposer/shadow-test-landing-page.png)
Sie können den Status eines Tests in der Konsole auf der Seite **Shadow-Tests** einsehen, indem Sie das **Statusfeld** für den Test überprüfen.
Im Folgenden sind die möglichen Status für einen Test aufgeführt:
+ `Creating` – SageMaker AI erstellt Ihren Test.
+ `Created` – SageMaker AI hat die Erstellung Ihres Tests abgeschlossen und er beginnt zur geplanten Zeit.
+ `Updating`– Wenn Sie Änderungen an Ihrem Test vornehmen, wird Ihr Test als Aktualisierung angezeigt.
+ `Starting` – SageMaker AI startet Ihren Test.
+ `Running`– Ihr Test ist im Gange.
+ `Stopping` – SageMaker AI stoppt Ihren Test.
+ `Completed`– Ihr Test ist abgeschlossen.
+ `Cancelled`– Wenn Sie Ihren Test vorzeitig beenden, wird er als storniert angezeigt.
# Überwachen Sie einen Schattentest
Sie können die Details eines Shadow-Tests einsehen und ihn überwachen, während er ausgeführt wird oder nachdem er abgeschlossen wurde. SageMaker AI präsentiert ein Live-Dashboard, in dem die Betriebskennzahlen wie Modelllatenz und aggregierte Fehlerrate der Produktions- und Shadow-Varianten verglichen werden.
Führen Sie die folgenden Schritte aus, um die Details eines einzelnen Tests in der Konsole anzuzeigen:
1. Wählen Sie auf der Seite **Shadow-Tests** im Abschnitt **Shadow-Test** den Test aus, den Sie überwachen möchten.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Ansicht** aus. Eine Übersichtsseite mit den Details des Tests und einem Metrik-Dashboard wird angezeigt.
Die Übersichtsseite besteht aus den folgenden drei Abschnitten.
**Übersicht**
In diesem Abschnitt werden der Fortschritt und der Status des Tests zusammengefasst. Außerdem werden die zusammenfassenden Statistiken der Metrik angezeigt, die aus der Dropdown-Liste **Metrik auswählen** im Unterabschnitt **Metriken** ausgewählt wurde. Im folgenden Screenshot wird dieser Abschnitt gezeigt.
![\[Zusammenfassung auf der Übersichtsseite.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/juxtaposer/shadow-test-summary.png)
Im vorherigen Screenshot zeigen die Registerkarten **Einstellungen** und **Details** die Einstellungen, die Sie ausgewählt haben, sowie die Details, die Sie bei der Erstellung des Tests eingegeben haben.
**Analyse**
In diesem Abschnitt wird ein Metriken-Dashboard mit separaten Diagrammen für die folgenden Metriken gezeigt:
+ `Invocations`
+ `InvocationsPerInstance`
+ `ModelLatency`
+ `Invocation4XXErrors`
+ `Invocation5XXErrors`
+ `InvocationModelErrors`
+ `CPUUtilization`
+ `MemoryUtilization`
+ `DiskUtilization`
Die letzten drei Metriken überwachen die Nutzung der Laufzeitressourcen des Modellcontainers. Der Rest sind CloudWatch-Metriken, mit denen Sie die Leistung Ihrer Variante analysieren können. Im Allgemeinen deuten weniger Fehler auf ein stabileres Modell hin. Eine geringere Latenz deutet entweder auf ein schnelleres Modell oder eine schnellere Infrastruktur hin. Weitere Informationen zu CloudWatch-Metriken finden Sie unter [SageMaker Metriken zum Aufrufen von KI-Endpunkten](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation). Der folgende Screenshot zeigt das Dashboard mit den Metriken.
![\[Dashboard zur Metrikenanalyse.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/juxtaposer/shadow-test-analysis.png)
**Umgebung**
In diesem Abschnitt werden die Varianten angezeigt, die Sie im Test verglichen haben. Wenn Sie mit der Leistung der Shadow-Variante auf der Grundlage der oben genannten Metriken zufrieden sind, können Sie die Shadow-Variante zur Produktion hochstufen, indem Sie **Shadow-Variante bereitstellen** wählen. Weitere Informationen zur Bereitstellung einer Shadow-Variante finden Sie unter [Hochstufen einer Schattenvariante](shadow-tests-complete.md#shadow-tests-complete-promote). Sie können auch den Prozentsatz der Datenverkehrssamplungen ändern und mit dem Testen fortfahren, indem Sie **Traffic bearbeiten** wählen. Weitere Informationen zur Bearbeitung einer Shadow-Variante finden Sie unter [Bearbeiten Sie einen Schattentest](shadow-tests-view-monitor-edit-individual.md). Im folgenden Screenshot wird dieser Abschnitt gezeigt.
![\[Bereich Umgebung auf der Übersichtsseite.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/juxtaposer/shadow-test-environment.png)
# Starten Sie frühzeitig einen Schattentest
Sie können Ihren Test vor der geplanten Startzeit starten. Wenn die neue Testdauer 30 Tage überschreitet, legt SageMaker AI das Ende des Tests automatisch auf 30 Tage nach der neuen Startzeit fest. Durch diese Aktion wird der Test sofort gestartet. Wenn Sie die Start- oder Endzeit des Tests ändern möchten, finden Sie weitere Informationen unter[Bearbeiten Sie einen Schattentest](shadow-tests-view-monitor-edit-individual.md).
Gehen Sie wie folgt vor, um den Test direkt vor der geplanten Startzeit über die Konsole zu starten:
1. Wählen Sie im Abschnitt **Shadow-Test** auf der Seite **Shadow-Tests** den Test aus, den Sie sofort starten möchten.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Start** aus. Der **Shadow-Test starten ?** wird ein Dialogfeld angezeigt.
1. Wählen Sie **Jetzt starten**.
# Löschen Sie einen Shadow-Test
Sie können einen Test löschen, den Sie nicht mehr benötigen. Durch das Löschen Ihres Tests werden nur die Testmetadaten gelöscht und nicht Ihr Endpunkt, Ihre Varianten oder in Amazon S3 erfassten Daten. Wenn Sie möchten, dass Ihr Endpunkt nicht mehr läuft, müssen Sie Ihren Endpunkt löschen. Weitere Informationen zum Löschen eines Endpunkts finden Sie unter [Endpunkte und Ressourcen löschen](realtime-endpoints-delete-resources.md)
Führen Sie die folgenden Schritte aus, um einen Test über die Konsole zu löschen:
1. Wählen Sie den Test, den Sie löschen möchten, im Abschnitt **Shadow-Test** auf der Seite **Shadow-Tests** aus.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Löschen**. Das Dialogfeld **Shadow-Test löschen** wird angezeigt.
1. Geben Sie in **das Feld Um das Löschen zu bestätigen**, *löschen* ein. Textfeld, **delete** eingeben.
1. Wählen Sie **Löschen** aus.
# Bearbeiten Sie einen Schattentest
Sie können sowohl geplante als auch laufende Tests ändern. Bevor Ihr Test beginnt, können Sie die Beschreibung, die Konfiguration der Shadow-Variante, das Startdatum und das Enddatum des Tests ändern. Sie können die Datenerfassung auch ein- oder ausschalten.
Nach dem Start des Tests können Sie nur die Beschreibung, den Prozentsatz der Traffic-Abtastung für die Shadow-Variante und das Enddatum ändern.
Führen Sie die folgenden Schritte aus, um die Details Ihres Tests über die Konsole zu bearbeiten:
1. Wählen Sie den Test, den Sie bearbeiten möchten, im Abschnitt **Shadow-Test** auf der Seite **Shadow-Tests** aus.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Bearbeiten** aus. Die Seite **Shadow-Testdetails eingeben** wird angezeigt.
1. (Optional) Geben Sie im Feld **Description (Beschreibung)** eine Beschreibung für Ihr Test ein.
1. Wählen Sie **Weiter** aus. Die Seite **Shadow-Testeinstellungen eingeben** wird angezeigt.
1. (Optional) Um Ihre Shadow-Variante zu bearbeiten, gehen Sie wie folgt vor:
1. Wählen Sie die Shadow-Variante aus und wählen Sie **Bearbeiten**. Das Dialogfenster **Shadow-Variante bearbeiten** wird angezeigt. Wenn Ihr Test bereits gestartet wurde, können Sie nur den Prozentsatz der Traffic-Abtastung ändern.
1. (Optional) Geben Sie unter **Name** den neuen Namen ein, der den alten Namen ersetzen soll.
1. (Optional) Geben Sie unter **Traffic-Stichprobe** den neuen Prozentsatz der Verkehrsstichprobe ein, der den alten Prozentsatz der Stichprobenerhebung ersetzen soll.
1. (Optional) Wählen Sie unter **Instance-Typ** den neuen Instance-Typ aus der Dropdown-Liste aus.
1. (Optional) Geben Sie unter **Instance-Anzahl** die neue Instance-Anzahl ein, um die alte Instance-Zahl zu ersetzen.
1. Wählen Sie **Anwenden** aus.
Sie können das Modell in Ihrer Shadow-Variante nicht mit dem oben beschriebenen Verfahren ändern. Wenn Sie das Modell ändern möchten, entfernen Sie zunächst die Shadow-Variante, indem Sie sie auswählen und **Entfernen** wählen. Fügen Sie anschließend eine neue Shadow-Variante hinzu.
1. (Optional) Um die Dauer des Tests zu bearbeiten, gehen Sie wie folgt vor:
1. Wählen Sie im Abschnitt **Zeitplan** das Kästchen unter **Dauer** aus. Es wird ein Popup-Kalender angezeigt.
1. Wenn Ihr Test noch nicht begonnen hat, können Sie sowohl das Start- als auch das Enddatum ändern. Wählen Sie das neue Start- und Enddatum aus dem Kalender aus oder geben Sie die neuen Start- und Enddaten unter **Startdatum** bzw. **Enddatum** ein.
Wenn Ihr Test bereits begonnen hat, können Sie nur das Enddatum ändern. Geben Sie unter Enddatum das neue **Enddatum** ein.
1. (Optional) Wenn Ihr Test noch nicht begonnen hat, können Sie sowohl die Start- als auch die Endzeit ändern. Geben Sie die neuen Start- und Endzeiten unter **Startzeit** und **Endzeit** im 24-Stunden-Format ein.
Wenn Ihr Test bereits begonnen hat, können Sie nur die Endzeit ändern. Geben Sie unter Endzeit die neue **Endzeit** im 24-Stunden-Format ein.
1. Wählen Sie **Anwenden** aus.
1. (Optional) Aktivieren oder Deaktivieren der Option **Datenerfassung aktivieren**.
1. Wählen Sie **Shadow-Test aktualisieren**.
# Schließe einen Schattentest ab
Ihr Test wird am Ende der geplanten Dauer automatisch abgeschlossen, oder Sie können einen laufenden Test vorzeitig beenden. Nach Abschluss Ihres Tests wird der Status des Tests im Abschnitt **Schattentests** auf der Seite **Schattentests** als **Abgeschlossen** angezeigt. Anschließend können Sie die endgültigen Messwerte Ihres Tests überprüfen und analysieren.
Sie können das Metrik-Dashboard verwenden, um zu entscheiden, ob Sie die Schattenvariante in die Produktion aufnehmen möchten. Weitere Informationen zur Analyse des Metrik-Dashboards Ihres Tests finden Sie unter [Überwachen Sie einen Schattentest](shadow-tests-view-monitor-edit-dashboard.md).
Anweisungen dazu, wie Sie Ihren Test vor Ablauf der geplanten Abschlusszeit abschließen können, finden Sie unter [Schließen Sie einen Schattentest frühzeitig ab](#shadow-tests-complete-early).
Anweisungen zum Heraufstufen Ihrer Schattenvariante in die Produktionsumgebung finden Sie unter [Hochstufen einer Schattenvariante](#shadow-tests-complete-promote).
## Schließen Sie einen Schattentest frühzeitig ab
Ein Grund, warum Sie vielleicht einen laufenden Schattentest abschließen möchten, ist, wenn Sie zu dem Schluss gekommen sind, dass die Metriken für Ihre Schattenvariante gut aussehen, und Sie sie in die Produktionsumgebung aufnehmen möchten. Sie könnten sich auch dafür entscheiden, den Test abzuschließen, wenn eine oder mehrere der Varianten nicht gut abschneiden.
Um Ihren Test vor dem geplanten Enddatum abzuschließen, gehen Sie folgendermaßen vor:
1. Wählen Sie auf der Seite **Schattentests** im Abschnitt **Schattentests** den Test aus, den Sie als abgeschlossen markieren möchten.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Abgeschlossen** aus. Daraufhin wird das Dialogfeld **Schattentests abschließen** angezeigt.
1. Wählen Sie in der Dialogbox eine der folgenden Optionen aus:
+ **Ja, Schattenvariante bereitstellen**
+ **Nein, Schattenvariante entfernen**
1. (Optional) Geben Sie im Textfeld **Kommentar** Ihren Grund für den Abschluss des Tests vor der geplanten Endzeit ein.
1.
1. Wenn Sie sich für die Bereitstellung der Schattenvariante entschieden haben, wählen Sie **Abgeschlossen und mit der Bereitstellung fortfahren**. Die Seite **Schattenvariante bereitstellen** wird angezeigt. Eine Anleitung zum Ausfüllen dieser Seite finden Sie unter [Hochstufen einer Schattenvariante](#shadow-tests-complete-promote).
1. Wenn Sie sich entscheiden, die Schattenvariante zu entfernen, wählen Sie **Bestätigen**.
## Hochstufen einer Schattenvariante
Wenn Sie sich entschieden haben, Ihre Produktionsvariante durch Ihre Schattenvariante zu ersetzen, können Sie Ihren Endpunkt aktualisieren und Ihre Schattenvariante hochstufen, um auf Inferenzanfragen zu reagieren. Dadurch wird Ihre aktuelle Produktionsvariante aus der Produktion entfernt und durch Ihre Schattenvariante ersetzt.
Wenn Ihr Schattentest noch läuft, müssen Sie zuerst Ihren Test abschließen. Um Ihren Schattentest vor dem geplanten Ende abzuschließen, folgen Sie den Anweisungen unter [Schließen Sie einen Schattentest frühzeitig ab](#shadow-tests-complete-early), bevor Sie mit diesem Abschnitt fortfahren.
Wenn Sie eine Schattenvariante zur Produktion hochstufen, haben Sie die folgenden Optionen für die Anzahl der Instances der Schattenvariante.
+ Sie können die Anzahl und den Typ der Instances aus der Produktionsvariante beibehalten. Wenn Sie diese Option auswählen, wird Ihre Schattenvariante mit der aktuellen Instance-Zahl in der Produktion gestartet. Dadurch wird sichergestellt, dass Ihr Modell weiterhin den Anforderungsverkehr im gleichen Umfang verarbeiten kann.
+ Sie können die Anzahl und den Typ Ihrer Schattenvariante beibehalten. Wenn Sie diese Option verwenden möchten, empfehlen wir, einen Schattentest mit 100-prozentiger Traffic-Abtastung durchzuführen, um sicherzustellen, dass die Schattenvariante den Anforderungsverkehr im aktuellen Umfang verarbeiten kann.
+ Sie können benutzerdefinierte Werte für die Anzahl und den Typ der Instances verwenden. Wenn Sie diese Option verwenden möchten, empfehlen wir, einen Schattentest mit 100-prozentiger Traffic-Abtastung durchzuführen, um sicherzustellen, dass die Schattenvariante den Anforderungsverkehr im aktuellen Umfang verarbeiten kann.
Sofern Sie nicht gerade den Instance-Typ oder die Anzahl oder beide Varianten der Schattenvariante validieren, empfehlen wir Ihnen dringend, die Anzahl und den Typ der Produktionsvariante beizubehalten, wenn Sie für Ihre Schattenvariante werben.
Um Ihre Schattenvariante zu bewerben, gehen Sie folgendermaßen vor:
1. Wenn Ihr Test abgeschlossen ist, gehen Sie folgendermaßen vor:
1. Wählen Sie den Test im Abschnitt **Schattentest** auf der Seite **Schattentests** aus.
1. Wählen Sie in der Dropdown-Liste **Aktionen** die Option **Ansicht** aus. Das Dashboard wird angezeigt.
1. Wählen Sie im Bereich **Umgebung** die Option **Schattenvariante bereitstellen** aus. Die Seite **Schattenvariante bereitstellen** wird angezeigt.
Falls Ihr Test noch nicht abgeschlossen wurde, finden Sie weitere Informationen unter [Schließen Sie einen Schattentest frühzeitig ab](#shadow-tests-complete-early) um ihn abzuschließen.
1. Wählen Sie im Abschnitt **Varianteneinstellungen** eine der folgenden Optionen aus:
+ **Produktionseinstellungen beibehalten**
+ **Schatteneinstellungen beibehalten**
+ **Benutzerdefinierte Instance-Einstellungen**
Wenn Sie **Benutzerdefinierte Instance-Einstellungen** ausgewählt haben, gehen Sie folgendermaßen vor:
1. Wählen Sie aus der Dropdown-Liste **Instance-Typ** einen Instance-Typ aus.
1. Geben Sie in **Instance-Zahl** die Anzahl der Instances ein.
1. Geben Sie im Textfeld **„Bereitstellen“ eingeben, um die Bereitstellung zu bestätigen**, **deploy** ein.
1. Wählen Sie **Schatetenvariante bereitstellen** aus.
Ihr SageMaker-AI-Inferenzendpunkt verwendet jetzt die Schattenvariante als Produktionsvariante, und Ihre Produktionsvariante wurde vom Endpunkt entfernt.
# Bewährte Methoden
Beachten Sie bei der Erstellung eines Inferenzexperiments Folgendes:
+ **Prozentsatz der Traffic-Abtastung** – Mit einer Stichprobe von 100 Prozent der Inferenzanfragen können Sie überprüfen, ob Ihre Schattenvariante den Produktionsdatenverkehr bewältigen kann, wenn sie beworben wird. Sie können mit einem niedrigeren Prozentsatz an Stichprobenzahlen beginnen und diese dann erhöhen, wenn Sie Vertrauen in Ihre Variante gewinnen. Es empfiehlt sich jedoch, vor der Promotion sicherzustellen, dass Sie den Traffic auf 100 Prozent erhöht haben.
+ **Instance-Typ** – Sofern Sie Shadow-Varianten nicht verwenden, um alternative Instance-Typen oder -Größen zu bewerten, empfehlen wir Ihnen, denselben Instance-Typ, dieselbe Größe und dieselbe Anzahl zu verwenden, damit Sie sicher sein können, dass Ihre Schattenvariante das Volumen der Inferenzanfragen bewältigen kann, nachdem Sie sie hochgestuft haben.
+ **Auto Scaling** – Um sicherzustellen, dass Ihre Schattenvariante auf Spitzen bei der Anzahl von Inferenzanfragen oder Änderungen der Muster von Inferenzanfragen reagieren kann, empfehlen wir Ihnen dringend, Autoscaling für Ihre Schattenvariante zu konfigurieren. Zur Konfiguration automatischer Aktualisierungen vgl. [Automatische Skalierung von Amazon SageMaker AI-Modellen](endpoint-auto-scaling.md). Wenn Sie Autoscaling konfiguriert haben, können Sie auch Änderungen an Autoscaling-Richtlinien validieren, ohne dass dies Auswirkungen auf die Benutzer hat.
+ **Überwachung von Metriken** – Nachdem Sie ein Schattenexperiment initiiert haben und genügend Aufrufe erhalten haben, überprüfen Sie das Metrik-Dashboard, um sicherzustellen, dass die Metriken wie Latenz und Fehlerrate innerhalb akzeptabler Grenzen liegen. So können Sie Fehlkonfigurationen frühzeitig erkennen und korrigierend eingreifen. Informationen zur Überwachung der Messwerte eines laufenden Inferenzexperiments finden Sie unter [Anzeigen, Überwachen und Bearbeiten von Schattentests](shadow-tests-view-monitor-edit.md).
# Greifen Sie über SSM auf Container zu
Mit Amazon SageMaker AI können Sie mithilfe von AWS Systems Manager (SSM) eine sichere Verbindung zu den Docker-Containern herstellen, auf denen Ihre Modelle für Inference bereitgestellt werden. Dadurch erhalten Sie Zugriff auf den Container auf Shell-Ebene, sodass Sie die im Container laufenden Prozesse debuggen und Befehle und Antworten bei Amazon CloudWatch protokollieren können. Sie können auch eine AWS PrivateLink Verbindung zu den ML-Instances einrichten, die Ihre Container hosten, um privat über SSM auf die Container zuzugreifen.
**Warnung**
Die Aktivierung des SSM-Zugriffs kann sich auf die Leistung Ihres Endpunkts auswirken. Wir empfehlen, diese Funktion mit Ihren Entwicklungs- oder Testendpunkten und nicht mit den Endpunkten in der Produktion zu verwenden. Außerdem wendet SageMaker KI automatisch Sicherheitspatches an und ersetzt oder beendet fehlerhafte Endpunktinstanzen innerhalb von 10 Minuten. Bei Endgeräten mit SSM-fähigen Produktionsvarianten verzögert SageMaker KI das Patchen von Sicherheitspatches und das Ersetzen oder Beenden fehlerhafter Endpunktinstanzen jedoch um einen Tag, damit Sie debuggen können.
In den folgenden Abschnitten wird detailliert beschrieben, wie Sie diese Funktion verwenden können.
## Liste der zugelassenen
Um diese Funktion nutzen zu können, müssen Sie sich an den Kundensupport wenden und Ihr Konto auf die Zulassungsliste setzen lassen. Sie können keinen Endpunkt mit aktiviertem SSM-Zugriff erstellen, wenn Ihr Konto für diesen Zugriff nicht zugelassen ist.
## Aktivieren des SSM-Zugangs
Um den SSM-Zugriff für einen vorhandenen Container auf einem Endpunkt zu aktivieren, aktualisieren Sie den Endpunkt mit einer neuen Endpunktkonfiguration, wobei der `EnableSSMAccess` Parameter auf `true` gesetzt ist. Das folgende Beispiel bietet eine Beispiel-Endpunktkonfiguration.
```
{
"EndpointConfigName": "endpoint-config-name",
"ProductionVariants": [
{
"InitialInstanceCount": 1,
"InitialVariantWeight": 1.0,
"InstanceType": "ml.t2.medium",
"ModelName": model-name,
"VariantName": variant-name,
"EnableSSMAccess": true,
},
]
}
```
[Weitere Informationen zur Aktivierung des SSM-Zugriffs finden Sie unter Aktivieren. SSMAccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#API_EnableSSMAccess)
## IAM-Konfiguration
### Endpunkt-IAM-Berechtigungen
Wenn Sie den SSM-Zugriff für eine Endpunktinstanz aktiviert haben, startet und verwaltet SageMaker AI den [SSM-Agenten](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html), wenn er die Endpunktinstanz initiiert. Damit der SSM-Agent mit den SSM-Diensten kommunizieren kann, fügen Sie der Ausführungsrolle, unter der der Endpunkt läuft, die folgende Richtlinie hinzu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssmmessages:CreateControlChannel",
"ssmmessages:CreateDataChannel",
"ssmmessages:OpenControlChannel",
"ssmmessages:OpenDataChannel"
],
"Resource": "*"
}
]
}
```
------
### IAM-Benutzerberechtigungen
Fügen Sie die folgende Richtlinie hinzu, um einem IAM-Benutzer SSM-Sitzungsberechtigungen zum Herstellen einer Verbindung mit einem SSM-Ziel zu erteilen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession",
"ssm:TerminateSession"
],
"Resource": "*"
}
]
}
```
------
Mit der folgenden Richtlinie können Sie die Endpunkte einschränken, mit denen ein IAM-Benutzer eine Verbindung herstellen kann. Ersetzen Sie *italicized placeholder text* durch Ihre Informationen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession"
],
"Resource": "arn:aws:sagemaker:us-east-2:111122223333:endpoint/endpoint-name"
}
]
}
```
------
## SSM-Zugriff mit AWS PrivateLink
Wenn Ihre Endgeräte in einer Virtual Private Cloud (VPC) ausgeführt werden, die nicht mit dem öffentlichen Internet verbunden ist, können Sie SSM verwenden, um SSM AWS PrivateLink zu aktivieren. AWS PrivateLink schränkt den gesamten Netzwerkverkehr zwischen Ihren Endpunkt-Instances, SSM und Amazon EC2 auf das Amazon-Netzwerk ein. Weitere Informationen zur Einrichtung des SSM-Zugriffs mit AWS PrivateLink finden Sie unter [VPC-Endpunkt für Session Manager einrichten](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-privatelink.html).
## Protokollierung mit Amazon CloudWatch Logs
Für Endgeräte mit SSM-Zugriff können Sie Fehler des SSM-Agenten mit Amazon Logs protokollieren. CloudWatch Weitere Informationen zum CloudWatch Protokollieren von Fehlern mit Logs finden Sie unter Sitzungsaktivität [protokollieren](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-logging.html). Das Protokoll ist im SSM-Protokollstream, `variant-name/ec2-instance-id/ssm`, unter der Endpunkt-Protokollgruppe `/aws/sagemaker/endpoints/endpoint-name` verfügbar. Weitere Informationen zum Anzeigen des Protokolls finden Sie unter An [ CloudWatch Protokolle gesendete Protokolldaten anzeigen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData).
Produktionsvarianten hinter Ihrem Endpunkt können mehrere Modellcontainer haben. Das Protokoll für jeden Modellcontainer wird im Protokollstream aufgezeichnet. Jedem Protokoll wird ein `[sagemaker ssm logs][container-name]` vorangestellt, wobei `container-name` entweder der Name ist, den Sie dem Container gegeben haben, oder der Standardname, z. B. `container_0` und `container_1`.
## Zugreifen auf Modellcontainer
Um auf einen Modellcontainer auf Ihrer Endpunkt-Instance zuzugreifen, benötigen Sie dessen Ziel-ID. Die Ziel-ID weist eines der folgenden Formate auf:
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id` für Container auf Einzelcontainer-Endpunkten
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id_container-name` für Container auf Endpunkten mit mehreren Containern
Das folgende Beispiel zeigt, wie Sie mithilfe der AWS CLI auf einen Modellcontainer zugreifen können, indem Sie dessen Ziel-ID verwenden.
```
aws ssm start-session --target sagemaker-endpoint:prod-image-classifier_variant1_i-003a121c1b21a90a9_container_1
```
Wenn Sie die Protokollierung aktivieren, wie unter beschrieben[Protokollierung mit Amazon CloudWatch Logs](#ssm-access-logging), können Sie das Ziel IDs für alle Container finden, die am Anfang des SSM-Protokollstreams aufgeführt sind.
**Anmerkung**
Sie können mit SSM keine Verbindung zu Containern mit 1P-Algorithmus oder Containern MarketPlace mit Modellen herstellen, die von SageMaker KI abgerufen wurden. Sie können jedoch eine Verbindung zu Deep-Learning-Containern (DLCs) herstellen, die von bereitgestellt werden, AWS oder zu einem beliebigen benutzerdefinierten Container, den Sie besitzen.
Wenn Sie die Netzwerkisolierung für einen Modellcontainer aktiviert haben, die verhindert, dass er ausgehende Netzwerkaufrufe tätigt, können Sie keine SSM-Sitzung für diesen Container starten.
Sie können von einer SSM-Sitzung aus nur auf einen Container zugreifen. Um auf einen anderen Container zuzugreifen, auch wenn er sich hinter demselben Endpunkt befindet, starten Sie eine neue SSM-Sitzung mit der Ziel-ID dieses Endpunkts.
# Modellserver für die Modellbereitstellung mit Amazon SageMaker AI
Sie können beliebte Modellserver wie TorchServe DJL Serving und Triton Inference Server verwenden, um Ihre Modelle auf KI bereitzustellen. SageMaker In den folgenden Themen wird erläutert, wie.
**Topics**
+ [Stellen Sie Modelle bereit mit TorchServe](deploy-models-frameworks-torchserve.md)
+ [Stellen Sie Modelle mit DJL Serving bereit](deploy-models-frameworks-djl-serving.md)
+ [Modellbereitstellung mit Triton Inference Server](deploy-models-frameworks-triton.md)
# Stellen Sie Modelle bereit mit TorchServe
TorchServe ist der empfohlene Modellserver für PyTorch, der im AWS PyTorch Deep Learning Container (DLC) vorinstalliert ist. Dieses leistungsstarke Tool bietet Kunden eine konsistente und benutzerfreundliche Erfahrung und bietet eine hohe Leistung bei der Bereitstellung mehrerer PyTorch Modelle in verschiedenen AWS Instanzen, einschließlich CPU, GPU, Neuron und Graviton, unabhängig von der Modellgröße oder Verteilung.
TorchServe unterstützt eine Vielzahl fortschrittlicher Funktionen, darunter dynamisches Batching, Microbatching, A/B Modelltests, Streaming, Torch XLA, TensorRT, ONNX und IPEX. Darüber hinaus integriert es die Lösung für große Modelle, PiPPy, nahtlos und ermöglicht PyTorch so die effiziente Handhabung großer Modelle. Darüber hinaus TorchServe erweitert es die Unterstützung auf beliebte Open-Source-Bibliotheken wie Accelerate DeepSpeed, Fast Transformers und mehr und erweitert so seine Funktionen noch weiter. Mit TorchServe können AWS Benutzer ihre PyTorch Modelle vertrauensvoll einsetzen und bereitstellen und dabei die Vorteile der Vielseitigkeit und optimierten Leistung für verschiedene Hardwarekonfigurationen und Modelltypen nutzen. Ausführlichere Informationen finden Sie in der [PyTorchDokumentation](https://pytorch.org/serve/) und [TorchServeauf GitHub](https://github.com/pytorch/serve).
In der folgenden Tabelle sind die AWS PyTorch DLCs unterstützten von aufgeführt TorchServe.
| Instance-Typ | SageMaker AI PyTorch DLC-Link |
| --- | --- |
| CPU und GPU | [SageMaker KI-Container PyTorch ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Behälter für Neuronen](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker PyTorch KI-Graviton-Behälter](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
In den folgenden Abschnitten wird die Einrichtung zum Erstellen und Testen PyTorch DLCs auf Amazon SageMaker AI beschrieben.
## Erste Schritte
Stellen Sie vor Beginn sicher, dass die folgenden Voraussetzungen erfüllt sind:
1. Stellen Sie sicher, dass Sie Zugriff auf ein AWS Konto haben. Richten Sie Ihre Umgebung so ein, dass sie entweder über einen AWS IAM-Benutzer oder eine IAM-Rolle auf Ihr Konto zugreifen AWS CLI können. Wir empfehlen die Verwendung einer IAM-Rolle. Zu Testzwecken in Ihrem persönlichen Konto können Sie der IAM-Rolle die folgenden Richtlinien für verwaltete Berechtigungen hinzufügen:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWS ServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Konfigurieren Sie Ihre Abhängigkeiten lokal wie im folgenden Beispiel gezeigt:
```
from datetime import datetime
import os
import json
import logging
import time
# External Dependencies:
import boto3
from botocore.exceptions import ClientError
import sagemaker
sess = boto3.Session()
sm = sess.client("sagemaker")
region = sess.region_name
account = boto3.client("sts").get_caller_identity().get("Account")
smsess = sagemaker.Session(boto_session=sess)
role = sagemaker.get_execution_role()
# Configuration:
bucket_name = smsess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}/models"
print(f"account={account}, region={region}, role={role}")
```
1. Rufen Sie das PyTorch DLC-Image ab, wie im folgenden Beispiel gezeigt.
SageMaker PyTorch AI-DLC-Images sind in allen AWS Regionen verfügbar. Weitere Informationen finden Sie in der [Liste der DLC-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only).
```
baseimage = sagemaker.image_uris.retrieve(
framework="pytorch",
region="",
py_version="py310",
image_scope="inference",
version="2.0.1",
instance_type="ml.g4dn.16xlarge",
)
```
1. Einen lokalen Workspace erstellen.
```
mkdir -p workspace/
```
## Hinzufügen eines Pakets
In den folgenden Abschnitten wird beschrieben, wie Sie Ihrem PyTorch DLC-Image Pakete hinzufügen und vorinstallieren.
**BYOC-Anwendungsfälle**
In den folgenden Schritten wird beschrieben, wie Sie Ihrem PyTorch DLC-Image ein Paket hinzufügen. Weitere Informationen zum Anpassen Ihres Containers finden Sie unter [Benutzerdefinierte Images für AWS Deep Learning Containers erstellen](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Angenommen, Sie möchten dem PyTorch DLC-Docker-Image ein Paket hinzufügen. Erstellen Sie ein Dockerfile unter dem `docker` Verzeichnis, wie im folgenden Beispiel gezeigt:
```
mkdir -p workspace/docker
cat workspace/docker/Dockerfile
ARG BASE_IMAGE
FROM $BASE_IMAGE
#Install any additional libraries
RUN pip install transformers==4.28.1
```
1. Erstellen und veröffentlichen Sie das benutzerdefinierte Docker-Image mithilfe des folgenden Skripts [build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh).
```
# Download script build_and_push.sh to workspace/docker
ls workspace/docker
build_and_push.sh Dockerfile
# Build and publish your docker image
reponame = "torchserve"
versiontag = "demo-0.1"
./build_and_push.sh {reponame} {versiontag} {baseimage} {region} {account}
```
**SageMaker Anwendungsfälle für KI-Vorinstallationen**
Das folgende Beispiel zeigt Ihnen, wie Sie ein Paket in Ihrem PyTorch DLC-Container vorinstallieren. Sie müssen lokal im Verzeichnis `workspace/code` eine `requirements.txt` Datei erstellen.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Modellartefakte erstellen TorchServe
Im folgenden Beispiel verwenden wir das vortrainierte [ MNIST-Modell](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist). Wir erstellen ein Verzeichnis`workspace/mnist`, implementieren [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py), indem wir den [TorchServe benutzerdefinierten Serviceanweisungen](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) folgen, und [konfigurieren die Modellparameter](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) (wie Batchgröße und Worker) in [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). Anschließend verwenden wir das TorchServe Tool, `torch-model-archiver` um die Modellartefakte zu erstellen und auf Amazon S3 hochzuladen.
1. Konfigurieren Sie die Modellparameter in `model-config.yaml`.
```
ls -al workspace/mnist-dev
mnist.py
mnist_handler.py
mnist_cnn.pt
model-config.yaml
# config the model
cat workspace/mnist-dev/model-config.yaml
minWorkers: 1
maxWorkers: 1
batchSize: 4
maxBatchDelay: 200
responseTimeout: 300
```
1. Erstellen Sie die Modellartefakte mithilfe von [torch-model-archiver ](https://github.com/pytorch/serve/tree/master/model-archiver#torch-model-archiver-for-torchserve).
```
torch-model-archiver --model-name mnist --version 1.0 --model-file workspace/mnist-dev/mnist.py --serialized-file workspace/mnist-dev/mnist_cnn.pt --handler workspace/mnist-dev/mnist_handler.py --config-file workspace/mnist-dev/model-config.yaml --archive-format tgz
```
Wenn Sie ein Paket vorinstallieren möchten, müssen Sie das `code` Verzeichnis in die Datei `tar.gz` aufnehmen.
```
cd workspace
torch-model-archiver --model-name mnist --version 1.0 --model-file mnist-dev/mnist.py --serialized-file mnist-dev/mnist_cnn.pt --handler mnist-dev/mnist_handler.py --config-file mnist-dev/model-config.yaml --archive-format no-archive
cd mnist
mv ../code .
tar cvzf mnist.tar.gz .
```
1. Laden Sie `mnist.tar.gz` auf Amazon S3 hoch.
```
# upload mnist.tar.gz to S3
output_path = f"s3://{bucket_name}/{prefix}/models"
aws s3 cp mnist.tar.gz {output_path}/mnist.tar.gz
```
## Verwenden von Endpunkten mit einem einzigen Modell für die Bereitstellung mit TorchServe
Das folgende Beispiel zeigt Ihnen, wie Sie einen [Echtzeit-Inferenzendpunkt für ein einzelnes Modell](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html) erstellen, das Modell auf dem Endpunkt bereitstellen und den Endpunkt mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) testen.
```
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
predictor_cls = Predictor,
name = "mnist",
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
predictor = model.deploy(instance_type='ml.g4dn.xlarge',
initial_instance_count=1,
endpoint_name = endpoint_name,
serializer=JSONSerializer(),
deserializer=JSONDeserializer())
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(dummy_data)
```
## Verwendung von Endpunkten mit mehreren Modellen für die Bereitstellung TorchServe
[Multi-Modell-Endpunkte](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) sind eine skalierbare und kostengünstige Lösung für das Hosting einer großen Anzahl von Modellen hinter einem Endpunkt. Sie verbessern die Nutzung der Endgeräte, indem sie dieselbe Ressourcenflotte gemeinsam nutzen und Container zum Hosten all Ihrer Modelle bereitstellen. Sie reduzieren auch den Bereitstellungsaufwand, da SageMaker KI das dynamische Laden und Entladen von Modellen sowie die Skalierung von Ressourcen auf der Grundlage von Verkehrsmustern verwaltet. Endgeräte mit mehreren Modellen eignen sich besonders für Deep-Learning- und generative KI-Modelle, die eine beschleunigte Rechenleistung erfordern.
Durch den Einsatz TorchServe von SageMaker KI-Endpunkten mit mehreren Modellen können Sie Ihre Entwicklung beschleunigen, indem Sie einen Serving-Stack verwenden, mit dem Sie vertraut sind, und gleichzeitig die gemeinsame Nutzung von Ressourcen und das vereinfachte Modellmanagement nutzen, die SageMaker KI-Endgeräte mit mehreren Modellen bieten.
Das folgende Beispiel zeigt Ihnen, wie Sie einen Endpunkt mit mehreren Modellen erstellen, das Modell auf dem Endpunkt bereitstellen und den Endpunkt mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) testen. Weitere Details finden Sie in diesem [Notebook-Beispiel](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/torchserve_multi_model_endpoint.ipynb).
```
from sagemaker.multidatamodel import MultiDataModel
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
mme = MultiDataModel(
name = endpoint_name,
model_data_prefix = output_path,
model = model,
sagemaker_session = smsess)
mme.deploy(
initial_instance_count = 1,
instance_type = "ml.g4dn.xlarge",
serializer=sagemaker.serializers.JSONSerializer(),
deserializer=sagemaker.deserializers.JSONDeserializer())
# list models
list(mme.list_models())
# create mnist v2 model artifacts
cp mnist.tar.gz mnistv2.tar.gz
# add mnistv2
mme.add_model(mnistv2.tar.gz)
# list models
list(mme.list_models())
predictor = Predictor(endpoint_name=mme.endpoint_name, sagemaker_session=smsess)
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(date=dummy_data, target_model="mnist.tar.gz")
```
## Kennzahlen
TorchServe unterstützt sowohl Metriken auf System- als auch auf Modellebene. Sie können Metriken entweder im Protokollformatmodus oder im Prometheus-Modus über die Umgebungsvariable `TS_METRICS_MODE` aktivieren. Sie können die TorchServe zentrale Metrik-Konfigurationsdatei verwenden`metrics.yaml`, um die Arten von Metriken anzugeben, die verfolgt werden sollen, z. B. Anzahl der Anfragen, Latenz, Speichernutzung, GPU-Auslastung und mehr. Mithilfe dieser Datei können Sie Einblicke in die Leistung und den Zustand der bereitgestellten Modelle gewinnen und das TorchServe Serververhalten effektiv in Echtzeit überwachen. Ausführlichere Informationen finden Sie in der [Dokumentation zu den TorchServe Metriken](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Sie können über den CloudWatch Amazon-Protokollfilter auf TorchServe Metrikprotokolle zugreifen, die dem StatsD-Format ähneln. Im Folgenden finden Sie ein Beispiel für ein TorchServe Metrikprotokoll:
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```
# Stellen Sie Modelle mit DJL Serving bereit
DJL Serving ist eine leistungsstarke, universelle, eigenständige Serverlösung. Sie verwendet ein Deep-Learning-Modell, mehrere Modelle oder Workflows und stellt sie über einen HTTP-Endpunkt zur Verfügung.
Sie können einen der DJL Serving [Deep Learning Containers (DLCs)](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) verwenden, um Ihre Modelle bereitzustellen. AWS Informationen zu den unterstützten Modelltypen und Frameworks finden Sie im [DJL Serving GitHub Repository](https://github.com/deepjavalibrary/djl-serving).
DJL Serving bietet viele Funktionen, die Ihnen helfen, Ihre Modelle mit hoher Leistung einzusetzen:
+ Benutzerfreundlichkeit – DJL Serving kann die meisten Modelle ohne Änderungen bedienen. Sie bringen Ihre Modellartefakte mit und DJL Serving kann sie hosten.
+ Unterstützung mehrerer Geräte und Beschleuniger — DJL Serving unterstützt die Bereitstellung von Modellen auf CPUs GPUs, und AWS Inferentia.
+ Leistung – DJL Serving führt Multithread-Inferenzen in einer einzigen Java Virtual Machine (JVM) aus, um den Durchsatz zu erhöhen.
+ Dynamisches Batching – DJL Serving unterstützt dynamisches Batching, um den Durchsatz zu erhöhen.
+ Automatische Skalierung – DJL Serving skaliert die Worker je nach Auslastung automatisch nach oben oder unten.
+ Unterstützung mehrerer Engines — DJL Serving kann gleichzeitig Modelle hosten, die verschiedene Frameworks verwenden (z. B. und). PyTorch TensorFlow
+ Ensemble- und Workflow-Modelle — DJL Serving unterstützt die Implementierung komplexer Workflows, die aus mehreren Modellen bestehen, und kann Teile des Workflows auf CPUs und andere Teile darauf ausführen. GPUs Modelle innerhalb eines Workflows können verschiedene Frameworks nutzen.
In den folgenden Abschnitten wird beschrieben, wie Sie mit DJL Serving auf SageMaker KI einen Endpunkt einrichten.
## Erste Schritte
Stellen Sie vor Beginn sicher, dass die folgenden Voraussetzungen erfüllt sind:
1. Stellen Sie sicher, dass Sie Zugriff auf ein AWS Konto haben. Richten Sie Ihre Umgebung so ein, dass sie entweder über einen AWS IAM-Benutzer oder eine IAM-Rolle auf Ihr Konto zugreifen AWS CLI können. Wir empfehlen die Verwendung einer IAM-Rolle. Zu Testzwecken in Ihrem persönlichen Konto können Sie der IAM-Rolle die folgenden Richtlinien für verwaltete Berechtigungen hinzufügen:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Stellen Sie sicher, dass Sie den [Docker-Client](https://docs.docker.com/get-docker/) auf Ihrem System eingerichtet haben.
1. Melden Sie sich bei Amazon Elastic Container Registry an und legen Sie die folgenden Umgebungsvariablen fest:
```
export ACCOUNT_ID=
export REGION=
aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com
```
1. Rufen Sie das Docker-Image ab.
```
docker pull 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
```
Alle verfügbaren DJL Serving-Container-Images finden Sie in den [großen Modell-Inferenzcontainern](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) und den [DJL Serving CPU-Inferenzcontainern](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#djl-cpu-full-inference-containers). Wenn Sie ein Bild aus den Tabellen in den obigen Links auswählen, ersetzen Sie die AWS Region in der Beispiel-URL-Spalte durch die Region, in der Sie sich befinden. Sie DLCs sind in den Regionen verfügbar, die in der Tabelle oben auf der Seite [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) aufgeführt sind.
## Passen Sie Ihren Container an
Sie können den DLC-Basisimages Pakete hinzufügen, um Ihren Container anzupassen. Angenommen, Sie möchten dem `763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118` Docker-Image ein Paket hinzufügen. Sie müssen eine Docker-Datei mit dem gewünschten Image als Basis-Image erstellen, die erforderlichen Pakete hinzufügen und das Image an Amazon ECR übertragen.
Um ein Paket hinzuzufügen, führen Sie die folgenden Schritte aus:
1. Geben Sie Anweisungen zum Ausführen der gewünschten Bibliotheken oder Pakete in der Docker-Datei des Basis-Images an.
```
FROM 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
## add custom packages/libraries
RUN git clone https://github.com/awslabs/amazon-sagemaker-examples
```
1. Erstellen Sie das Docker-Image aus der Docker-Datei. Geben Sie Ihr Amazon ECR-Repository, den Namen des Basis-Images und ein Tag für das Image an. Wenn Sie kein Amazon ECR-Repository haben, finden Sie unter [ Verwenden von Amazon ECR mit dem AWS CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html) im *Amazon ECR-Benutzerhandbuch* Anweisungen zur Erstellung eines solchen.
```
docker build -f Dockerfile -t /:
```
1. Pushen Sie die Docker-Manifestliste in Ihr Amazon ECR-Repository.
```
docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/:
```
Sie sollten jetzt über ein benutzerdefiniertes Container-Image verfügen, das Sie für die Modellbereitstellung verwenden können. Weitere Beispiele für die Anpassung Ihres Containers finden Sie unter [Benutzerdefinierte Images für AWS Deep Learning Containers erstellen](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
## Vorbereiten Ihrer Modellartefakte
Bevor Sie Ihr Modell auf SageMaker KI bereitstellen, müssen Sie Ihre Modellartefakte in einer `.tar.gz` Datei verpacken. DJL Serving akzeptiert die folgenden Artefakte in Ihrem Archiv:
+ Modell-Checkpoint: Dateien, in denen Ihre Modellgewichte gespeichert sind.
+ `serving.properties`: Eine Konfigurationsdatei, die Sie für jedes Modell hinzufügen können. Platzieren Sie `serving.properties` im selben Verzeichnis wie Ihre Modelldatei.
+ `model.py`: Der Code für den Inferenz-Handler. Dies gilt nur, wenn der Python-Modus verwendet wird. Wenn Sie `model.py` nicht angeben, verwendet djl-Serving einen der Standard-Handler.
Im Folgenden wird ein Beispiel für eine `model.tar.gz` Struktur dargestellt:
```
- model_root_dir # root directory
- serving.properties
- model.py # your custom handler file for Python, if you choose not to use the default handlers provided by DJL Serving
- model binary files # used for Java mode, or if you don't want to use option.model_id and option.s3_url for Python mode
```
DJL Serving unterstützt Java-Engines, die auf DJL- oder Python-Engines basieren. Nicht alle der oben genannten Artefakte sind erforderlich. Die erforderlichen Artefakte variieren je nach ausgewähltem Modus. Im Python-Modus müssen Sie beispielsweise nur `option.model_id` in der `serving.properties` Datei angeben. Sie müssen den Modell-Checkpoint innerhalb von LMI-Containern nicht angeben. Im Java-Modus müssen Sie den Modell-Checkpoint verpacken. Weitere Informationen zur Konfiguration von `serving.properties` und zum Betrieb verschiedener Engines finden Sie unter [Betriebsmodi für DJL Serving](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md).
## Verwenden Sie Endpunkte mit einem einzigen Modell für die Bereitstellung mit DJL Serving
Nachdem Sie Ihre Modellartefakte vorbereitet haben, können Sie Ihr Modell auf einem SageMaker KI-Endpunkt bereitstellen. In diesem Abschnitt wird beschrieben, wie Sie mit DJL Serving ein einzelnes Modell auf einem Endpunkt bereitstellen. Wenn Sie mehrere Modelle bereitstellen, überspringen Sie diesen Abschnitt und gehen Sie zu [Verwenden Sie Endpunkte mit mehreren Modellen für die Bereitstellung mit DJL Serving](#deploy-models-frameworks-djl-mme).
Das folgende Beispiel zeigt Ihnen eine Methode zum Erstellen eines Modellobjekts mit dem Amazon SageMaker Python SDK. Sie müssen die folgenden Felder angeben:
+ `image_uri`: Sie können entweder eines der DJL Serving-Basisimages abrufen, wie in diesem Beispiel gezeigt, oder Sie können ein benutzerdefiniertes Docker-Image aus Ihrem Amazon ECR-Repository angeben, wenn Sie die Anweisungen unter [Passen Sie Ihren Container an](#deploy-models-frameworks-djl-byoc) befolgt haben.
+ `model_s3_url`: Dies sollte ein Amazon-S3-URI sein, der auf Ihre `.tar.gz`Datei verweist.
+ `model_name`: Geben Sie einen Namen für das Modellobjekt an.
```
import boto3
import sagemaker
from sagemaker.model import Model
from sagemaker import image_uris, get_execution_role
aws_region = "aws-region"
sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name=aws_region))
role = get_execution_role()
def create_model(model_name, model_s3_url):
# Get the DJL DeepSpeed image uri
image_uri = image_uris.retrieve(
framework="djl-deepspeed",
region=sagemaker_session.boto_session.region_name,
version="0.20.0"
)
model = Model(
image_uri=image_uri,
model_data=model_s3_url,
role=role,
name=model_name,
sagemaker_session=sagemaker_session,
)
return model
```
## Verwenden Sie Endpunkte mit mehreren Modellen für die Bereitstellung mit DJL Serving
Wenn Sie mehrere Modelle auf einem Endpunkt bereitstellen möchten, bietet SageMaker KI Endpunkte mit mehreren Modellen, die eine skalierbare und kostengünstige Lösung für die Bereitstellung einer großen Anzahl von Modellen darstellen. DJL Serving unterstützt auch das gleichzeitige Laden mehrerer Modelle und das gleichzeitige Ausführen von Inferenzen für jedes der Modelle. DJL Serving Container halten sich an die SageMaker AI-Verträge für Endgeräte mit mehreren Modellen und können zur Bereitstellung von Endpunkten mit mehreren Modellen verwendet werden.
Jedes einzelne Modellartefakt muss auf die gleiche Weise verpackt werden, wie im vorherigen Abschnitt [Vorbereiten Ihrer Modellartefakte](#deploy-models-frameworks-djl-artifacts)beschrieben. Sie können modellspezifische Konfigurationen in der `serving.properties` Datei und modellspezifischen Code für den Inferenz-Handler in `model.py` festlegen. Für einen Multimodell-Endpunkt müssen die Modelle wie folgt angeordnet werden:
```
root_dir
|-- model_1.tar.gz
|-- model_2.tar.gz
|-- model_3.tar.gz
.
.
.
```
Das Amazon SageMaker Python SDK verwendet das [MultiDataModel](https://sagemaker.readthedocs.io/en/stable/api/inference/multi_data_model.html)Objekt, um einen Endpunkt mit mehreren Modellen zu instanziieren. Die Amazon-S3-URI für das Stammverzeichnis sollte als `model_data_prefix`-Argument an den `MultiDataModel`-Konstruktor übergeben werden.
DJL Serving bietet auch mehrere Konfigurationsparameter zur Verwaltung der Speicheranforderungen des Modells, wie z. B. `required_memory_mb` und `reserved_memory_mb`, die für jedes Modell in der Datei [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties) konfiguriert werden können. Diese Parameter sind nützlich, um Fehler aufgrund unzureichenden Speichers besser behandeln zu können. Alle konfigurierbaren Parameter finden Sie unter [OutofMemory Handling](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/out_of_memory_management.md) in djl-Serving.
Mit der Auto-Scaling-Funktion von DJL Serving kann auf einfache Weise sichergestellt werden, dass die Modelle für den eingehenden Verkehr angemessen skaliert werden. Standardmäßig bestimmt DJL Serving die maximale Anzahl von Workern für ein Modell, die auf der Grundlage der verfügbaren Hardware (wie CPU-Kerne oder GPU-Geräte) unterstützt werden kann. Sie können für jedes Modell Unter- und Obergrenzen festlegen, um sicherzustellen, dass immer ein Mindestdatenvolumen bereitgestellt werden kann und dass ein einzelnes Modell nicht alle verfügbaren Ressourcen verbraucht. Sie können die folgenden Eigenschaften in der Datei [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties) festlegen:
+ `gpu.minWorkers`: Mindestanzahl von Arbeitern für. GPUs
+ `gpu.maxWorkers`: Maximale Anzahl von Arbeitnehmern für GPUs.
+ `cpu.minWorkers`: Mindestanzahl von Arbeitnehmern für CPUs.
+ `cpu.maxWorkers`: Maximale Anzahl von Arbeitnehmern für CPUs.
[Ein end-to-end Beispiel für die Bereitstellung eines Multi-Modell-Endpunkts auf SageMaker KI mithilfe eines DJL Serving-Containers finden Sie im Beispiel-Notizbuch Multi-Model-Inference-Demo.ipynb.](https://github.com/deepjavalibrary/djl-demo/blob/master/aws/sagemaker/Multi-Model-Inference-Demo.ipynb)
# Modellbereitstellung mit Triton Inference Server
[Triton Inference Server](https://github.com/triton-inference-server/server) ist eine Open-Source-Inferenz-Server-Software, die die KI-Inferenz optimiert. Mit Triton können Sie jedes Modell bereitstellen, das mit mehreren Frameworks für Deep Learning und maschinelles Lernen erstellt wurde, darunter TensorRT,,, ONX TensorFlow PyTorch, OpenVINO, Python, RAPIDS FIL und mehr.
Die SageMaker KI-Triton-Container helfen Ihnen bei der Bereitstellung von Triton Inference Server auf der KI-Hosting-Plattform, um trainierte Modelle in der SageMaker Produktion bereitzustellen. Es unterstützt die verschiedenen Modi, in denen SageMaker KI arbeitet. Eine Liste der verfügbaren Triton Inference Server-Container, die auf SageMaker KI verfügbar sind, finden Sie unter [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).
[Für end-to-end Notebook-Beispiele empfehlen wir, einen Blick in das Repository zu werfen. amazon-sagemaker-examples ](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-triton)
## Hosting-Modi
Die folgenden SageMaker KI-Hosting-Modi werden von Triton-Containern unterstützt:
+ Endpunkte für ein einzelnes Modell
+ Dies ist der Standardbetriebsmodus von SageMaker AI. In diesem Modus kann der Triton-Container ein einzelnes Modell oder ein einzelnes Ensemble-Modell laden.
+ Der Name des Modells muss als Eigenschaft der Containerumgebung übergeben werden, die Teil des `CreateModel` SageMaker AI-API-Aufrufs ist. Die Umgebungsvariable, die zur Übergabe des Modellnamens verwendet wird, ist `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`.
+ Endpunkte eines einzelnen Modells mit Ensemble
+ Triton Inference Server unterstützt ein *Ensemble*, bei dem es sich um eine Pipeline oder einen DAG (gerichteter azyklischer Graph) von Modellen handelt. Während ein Ensemble technisch gesehen aus mehreren Modellen besteht, kann SageMaker KI im standardmäßigen Einzelmodell-Endpunktmodus das *eigentliche Ensemble* (das Metamodell, das die Pipeline darstellt) als das zu ladende Hauptmodell behandeln und anschließend die zugehörigen Modelle laden.
+ Zum Laden des Modells muss der Modellname des eigentlichen Ensembles verwendet werden. Es muss als Eigenschaft der Container-Umgebung übergeben werden, die Teil des `CreateModel` SageMaker API-Aufrufs ist. Die Umgebungsvariable, die zur Übergabe des Modellnamens verwendet wird, ist `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`.
+ Multimodell-Endpunkte
+ In diesem Modus kann SageMaker KI mehrere Modelle auf einem einzigen Endpunkt bedienen. Sie können diesen Modus verwenden, indem Sie die Umgebungsvariable `‘MultiModel’: true` als Eigenschaft der Container-Umgebung angeben, die Teil des `CreateModel` SageMaker API-Aufrufs ist.
+ Standardmäßig wird beim Start der Instance kein Modell geladen. Um eine Inferenzanforderung für ein bestimmtes Modell auszuführen, geben Sie die `*.tar.gz` Datei des entsprechenden Modells als Argument für die `TargetModel` Eigenschaft des `InvokeEndpoint` SageMaker API-Aufrufs an.
+ Endpunkte mit mehreren Modellen und Ensemble
+ In diesem Modus funktioniert SageMaker KI wie für Endpunkte mit mehreren Modellen beschrieben. Der SageMaker AI Triton-Container kann jedoch mehrere Ensemble-Modelle laden, was bedeutet, dass mehrere Modell-Pipelines auf derselben Instanz ausgeführt werden können. SageMaker AI behandelt jedes Ensemble als ein Modell, und das eigentliche Ensemble jedes Modells kann aufgerufen werden, indem das entsprechende `*.tar.gz` Archiv als angegeben wird. `TargetModel`
+ Für eine bessere Speicherverwaltung während des dynamischen Speichers `LOAD` und `UNLOAD` empfehlen wir, die Ensemblegröße klein zu halten.
## Inferenz-Payload-Typen
Triton unterstützt zwei Methoden zum Senden einer Inferenz-Payload über das Netzwerk – `json` und `binary+json` (oder binär codiertes JSON). Die JSON-Nutzlast umfasst in beiden Fällen den Datentyp, die Form und den eigentlichen Tensor für die Inferenzanforderung. Der Anforderungstensor muss ein binärer Tensor sein.
Bei dem `binary+json` Format müssen Sie die Länge der Anforderungsmetadaten im Header angeben, damit Triton die binäre Nutzlast korrekt analysieren kann. Im SageMaker AI Triton-Container erfolgt dies mithilfe eines benutzerdefinierten `Content-Type` Headers:. `application/vnd.sagemaker-triton.binary+json;json-header-size={}` Dies unterscheidet sich von der Verwendung des `Inference-Header-Content-Length` Headers auf einem eigenständigen Triton Inference Server, da benutzerdefinierte Header in KI nicht zulässig sind. SageMaker
## Verwenden Sie config.pbtxt, um die Modellkonfiguration festzulegen
Bei Triton Inference Servern auf SageMaker KI muss jedes Modell eine `config.pbtxt` Datei enthalten, die mindestens die folgenden Konfigurationen für das Modell spezifiziert:
+ `name`: Für Modelle, die außerhalb von SageMaker KI laufen, ist dies zwar optional, wir empfehlen jedoch, dass Sie immer einen Namen für die Modelle angeben, die in Triton on AI ausgeführt werden sollen. SageMaker
+ [`platform` und/oder `backend`](https://github.com/triton-inference-server/backend/blob/main/README.md#backends): Die Einrichtung eines Backends ist wichtig, um den Typ des Modells zu spezifizieren. Einige Backends haben eine weitere Klassifizierung, wie `tensorflow_savedmodel` oder ` tensorflow_graphdef` zum Beispiel. Solche Optionen können zusätzlich zum Schlüssel `backend` als Teil des `platform` Schlüssels angegeben werden. Die gängigsten Backends sind `tensorrt`, `onnxruntime`, `tensorflow`, `pytorch`, `python`, `dali`, `fil`, und `openvino`.
+ `input`: Geben Sie drei Attribute für die Eingabe an: `name`, `data_type` und `dims` (die Form).
+ `output`: Geben Sie drei Attribute für die Ausgabe an: `name`, `data_type` und `dims` (die Form).
+ `max_batch_size`: Stellen Sie die Chargengröße auf einen Wert größer oder gleich 1 ein, der die maximale Chargengröße angibt, die Triton für das Modell verwenden sollte.
[Weitere Informationen zur Konfiguration finden `config.pbtxt` Sie im Triton-Repository. GitHub ](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md) Triton bietet verschiedene Konfigurationen zur Optimierung des Modellverhaltens. Einige der gängigsten und wichtigsten Konfigurationsoptionen sind:
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups): Instance-Gruppen helfen bei der Angabe der Nummer und des Standorts für ein bestimmtes Modell. Sie haben die Attribute `count``kind`, und `gpus` (werden verwendet, wenn `kind` `KIND_GPU` ist). Das `count` Attribut entspricht der Anzahl der Worker. Für die reguläre Bereitstellung von Models hat jeder Worker seine eigene Kopie des Modells. In ähnlicher Weise `count` gibt der in Triton die Anzahl der Modellkopien pro Gerät an. Wenn der `instance_group` Typ beispielsweise `KIND_CPU` ist, hat die CPU die `count` Anzahl der Modellkopien.
**Anmerkung**
Auf einer GPU-Instance gilt die `instance_group` Konfiguration pro GPU-Gerät. Beispielsweise wird die `count` Anzahl der Modellkopien auf jedem GPU-Gerät platziert, sofern Sie nicht explizit angeben, welche GPU-Geräte das Modell laden sollen.
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher) und [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models): Dynamisches Batching wird für statuslose Modelle verwendet, und Sequenz-Batching wird für statusbehaftete Modelle verwendet (bei denen Sie jedes Mal eine Anfrage an dieselbe Modell-Instance weiterleiten möchten). Batching-Scheduler ermöglichen eine modellspezifische Warteschlange, wodurch der Durchsatz je nach Batching-Konfiguration erhöht werden kann.
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models): Ein Ensemble-Modell stellt eine *Pipeline* aus einem oder mehreren Modellen und die Verbindung von Eingabe- und Ausgangstensoren zwischen diesen Modellen dar. Es kann konfiguriert werden, indem `platform` als `ensemble` angegeben wird. Die Ensemble-Konfiguration ist nur eine Darstellung der Modellpipeline. Bei SageMaker KI werden alle Modelle eines Ensembles als vom Ensemble-Modell abhängige Modelle behandelt und bei SageMaker KI-Metriken als ein einziges Modell gezählt, wie z. `LoadedModelCount`
## Veröffentlichung von Triton-Standardmetriken auf Amazon CloudWatch
Der NVIDIA Triton Inference Container stellt Metriken an Port 8002 (konfigurierbar) für die verschiedenen Modelle zur Verfügung GPUs , die im Triton Inference Server verwendet werden. [Vollständige Informationen zu den verfügbaren Standardmetriken finden Sie auf der GitHub Seite mit den Triton Inference Server-Metriken.](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/metrics.md) Diese Metriken liegen im Prometheus-Format vor und können mit einer Prometheus-Scraper-Konfiguration gescrapt werden.
Ab Version v23.07 unterstützt der SageMaker AI Triton-Container die Veröffentlichung dieser Metriken auf Amazon, CloudWatch indem er einige Umgebungsvariablen angibt. Um die Prometheus-Metriken zu ermitteln, nutzt der SageMaker KI-Triton-Container den Amazon-Agenten. CloudWatch
Die erforderlichen Umgebungsvariablen, die Sie für die Erfassung von Metriken angeben müssen, lauten wie folgt:
| Umgebungsvariable | Description | Beispielwert |
| --- | --- | --- |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | Geben Sie diese Option an, damit Triton Metriken auf seinem Prometheus-Endpunkt veröffentlichen kann. | „true“ |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | Geben Sie diese Option an, um die Vorabprüfungen zu starten, die für die Veröffentlichung von Metriken auf Amazon CloudWatch erforderlich sind. | „true“ |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Geben Sie diese Option an, um auf die Protokollgruppe zu verweisen, in die die Metriken geschrieben werden. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesTest" |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Geben Sie diese Option an, um auf den Metrik-Namespace zu verweisen, in dem Sie die Metriken sehen und grafisch darstellen möchten. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesPublicTest" |
| `SAGEMAKER_TRITON_METRICS_PORT` | Geben Sie dies als 8002 oder einen anderen Port an. Wenn SageMaker AI den angegebenen Port nicht blockiert hat, wird er verwendet. Andernfalls wird automatisch ein anderer nicht blockierter Port ausgewählt. | „8002" |
Beachten Sie bei der Veröffentlichung von Metriken mit Triton auf SageMaker KI die folgenden Einschränkungen:
+ Sie können zwar benutzerdefinierte Metriken über die C-API und das Python-Backend (ab Version 23.05) generieren, diese werden jedoch derzeit nicht für die Veröffentlichung auf Amazon unterstützt. CloudWatch
+ Im Modus SageMaker AI Multi-Model Endpoints (MME) läuft Triton in einer Umgebung, in der Modell-Namespacing aktiviert sein muss, da jedes Modell (außer Ensemble-Modellen) so behandelt wird, als ob es sich in seinem eigenen Modell-Repository befände. Derzeit führt dies zu einer Einschränkung für Metriken. Wenn Modell-Namespacing aktiviert ist, unterscheidet Triton die Metriken nicht zwischen zwei Modellen mit demselben Namen, die zu unterschiedlichen Ensembles gehören. Um das Problem zu umgehen, stellen Sie sicher, dass jedes bereitgestellte Modell einen eindeutigen Namen hat. Dies macht es auch einfacher, Ihre Metriken darin nachzuschlagen. CloudWatch
## Umgebungsvariablen
In der folgenden Tabelle sind die unterstützten Umgebungsvariablen für Triton on SageMaker AI aufgeführt.
| Umgebungsvariable | Description | Typ | Mögliche Werte |
| --- | --- | --- | --- |
| `SAGEMAKER_MULTI_MODEL` | Ermöglicht Triton den Betrieb im SageMaker KI-Modus für Endgeräte mit mehreren Modellen. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` | Geben Sie das Modell an, das im SageMaker AI-Einzelmodellmodus (Standard) geladen werden soll. Geben Sie für den Ensemble-Modus den Namen des eigentlichen Ensembles an. | Zeichenfolge | **wie in config.pbtxt angegeben |
| `SAGEMAKER_TRITON_PING_MODE` | `'ready'`ist der Standardmodus im Einzelmodellmodus von SageMaker AI und der Standardmodus im `'live'` Mehrmodell-Endpunktmodus von SageMaker AI. | Zeichenfolge | `ready`, `live` |
| `SAGEMAKER_TRITON_DISABLE_MODEL_NAMESPACING` | Im SageMaker KI-Triton-Container ist dieser Wert standardmäßig auf `true` eingestellt. | Boolesch | `true`, `false` |
| `SAGEMAKER_BIND_TO_PORT` | Bei Verwendung von SageMaker AI ist der Standardport 8080. In Szenarien mit mehreren Containern können Sie eine Anpassung an einen anderen Port vornehmen. | Zeichenfolge | ** |
| `SAGEMAKER_SAFE_PORT_RANGE` | Dies wird von der SageMaker AI-Plattform festgelegt, wenn der Multi-Container-Modus verwendet wird. | Zeichenfolge | **–** |
| `SAGEMAKER_TRITON_ALLOW_GRPC` | SageMaker KI unterstützt GRPC derzeit zwar nicht, aber wenn Sie Triton vor einem benutzerdefinierten Reverse-Proxy verwenden, können Sie GRPC aktivieren. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_GRPC_PORT` | Der Standardport für GRPC ist 8001, aber Sie können ihn ändern. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_THREAD_COUNT` | Sie können die Anzahl der Standard-HTTP-Request-Handler-Threads festlegen. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_LOG_VERBOSE` | `true`standardmäßig auf SageMaker KI, aber Sie können diese Option selektiv ausschalten. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_INFO` | `false`standardmäßig auf SageMaker KI. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_WARNING` | `false`standardmäßig auf SageMaker KI. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_ERROR` | `false`standardmäßig auf SageMaker KI. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_SHM_DEFAULT_BYTE_SIZE` | Geben Sie die Shm-Größe für das Python-Backend in Byte an. Der Standardwert ist 16 MB, kann aber erhöht werden. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_SHM_GROWTH_BYTE_SIZE` | Geben Sie die Shm-Wachstumsgröße für das Python-Backend in Byte an. Der Standardwert ist 1 MB, kann aber erhöht werden, um größere Inkremente zu ermöglichen. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_TENSORFLOW_VERSION` | Der Standardwert ist `2`. Triton unterstützt Tensorflow 2 ab Triton v23.04 nicht mehr. Sie können diese Variable für frühere Versionen konfigurieren. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_MODEL_LOAD_GPU_LIMIT` | Schränken Sie den maximalen Prozentsatz des GPU-Speichers ein, der für das Laden des Modells verwendet wird, sodass der Rest für die Inferenzanforderungen verwendet werden kann. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | `false`standardmäßig auf SageMaker KI. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_METRICS_PORT` | Der Standard-Port ist 8002. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | `false`standardmäßig auf SageMaker KI. Setzen Sie diese Variable auf, `true` um die Übertragung von Triton-Standardmetriken an Amazon CloudWatch zu ermöglichen. Wenn diese Option aktiviert ist, sind Sie für die CloudWatch Kosten verantwortlich, die entstehen, wenn Kennzahlen auf Ihrem Konto veröffentlicht werden. | Boolesch | `true`, `false` |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Erforderlich, wenn Sie die Veröffentlichung von Kennzahlen auf aktiviert haben CloudWatch. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Erforderlich, wenn Sie die Veröffentlichung von Metriken für aktiviert haben CloudWatch. | Zeichenfolge | ** |
| `SAGEMAKER_TRITON_ADDITIONAL_ARGS` | Hängt beim Starten des Triton-Servers alle zusätzlichen Argumente an. | Zeichenfolge | ** |
# Modellieren Sie die Bereitstellung am Netzwerkrand mit Edge Manager SageMaker
**Warnung**
SageMaker Edge Manager wird am 26. April 2024 eingestellt. Weitere Informationen zum weiteren Einsatz Ihrer Modelle auf Edge-Geräten finden Sie unter [SageMaker Ende der Nutzungsdauer von Edge Manager](edge-eol.md).
Amazon SageMaker Edge Manager bietet Modellmanagement für Edge-Geräte, sodass Sie Modelle für maschinelles Lernen auf Flotten von Edge-Geräten wie Smart-Kameras, Robotern, PCs und Mobilgeräten optimieren, sichern, überwachen und verwalten können.
## Warum Edge Manager verwenden?
In vielen Anwendungsfällen für Machine Learning (ML) müssen ML-Modelle auf einer Flotte von Edge-Geräten laufen. So können Sie Prognosen in Echtzeit abrufen, die Daten der Endnutzer schützen und die Kosten für die Netzwerkkonnektivität senken. Mit der zunehmenden Verfügbarkeit von Edge-Hardware mit geringem Stromverbrauch, die für ML entwickelt wurde, ist es jetzt möglich, das mehrere komplexe neuronale Netzwerkmodelle auf Edge-Geräten laufen.
Der Betrieb von ML-Modellen auf Edge-Geräten ist jedoch eine Herausforderung, da die Geräte im Unterschied zu Cloud-Instances nur über begrenzte Rechenleistung, Speicherplatz und Konnektivität verfügen. Wenn das Modell bereitgestellt wird, müssen Sie die Modelle kontinuierlich überwachen, da Modellabweichungen dazu führen können, dass die Qualität des Modells mit der Zeit nachlässt. Die Überwachung von Modellen für Ihre Geräteflotten ist schwierig, da Sie eigens dafür bestimmten Code schreiben müssen, um Datenstichproben von Ihrem Gerät zu nehmen und fehlerhafte Vorhersagen zu erkennen. Darüber hinaus sind Modelle häufig fest in der Anwendung codiert. Um das Modell zu aktualisieren, müssen Sie die gesamte Anwendungs- oder Gerätefirmware neu erstellen und aktualisieren, was Ihren Betrieb stören kann.
Mit SageMaker Edge Manager können Sie Modelle für maschinelles Lernen für Geräteflotten am Netzwerkrand optimieren, ausführen, überwachen und aktualisieren.
## Wie das funktioniert?
Auf einer höheren Ebene besteht der SageMaker Edge Manager-Workflow aus fünf Hauptkomponenten: Kompilieren von Modellen mit SageMaker Neo, Verpacken von NEO-kompilierten Modellen, Bereitstellung von Modellen auf Ihren Geräten, Ausführung von Modellen auf der SageMaker KI-Inferenz-Engine (Edge Manager-Agent) und Verwaltung von Modellen auf den Geräten.
![\[Die fünf Hauptkomponenten des SageMaker Edge Manager-Workflows.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/smith/smith_overview.png)
SageMaker Edge Manager verwendet SageMaker Neo, um Ihre Modelle mit einem Klick für die Zielhardware zu optimieren und anschließend Ihre Modelle vor der Bereitstellung kryptografisch zu signieren. Mit SageMaker Edge Manager können Sie Modelleingabe- und -ausgabedaten von Edge-Geräten abfragen und sie zur Überwachung und Analyse an die Cloud senden. Außerdem können Sie ein Dashboard aufrufen, das den Betrieb der bereitgestellten Modelle in der SageMaker KI-Konsole verfolgt und visuell darüber berichtet.
SageMaker Edge Manager erweitert Funktionen, die bisher nur in der Cloud verfügbar waren, auf den Edge, sodass Entwickler die Modellqualität kontinuierlich verbessern können, indem sie Amazon SageMaker Model Monitor für die Drifterkennung verwenden, die Daten anschließend mit SageMaker AI Ground Truth umetikettieren und die Modelle in SageMaker KI neu trainieren.
## Wie verwende ich SageMaker Edge Manager?
Wenn Sie SageMaker Edge Manager zum ersten Mal verwenden, empfehlen wir Ihnen, Folgendes zu tun:
1. **Lesen Sie den Abschnitt [Erste Schritte](https://docs.aws.amazon.com/sagemaker/latest/dg/edge-manager-getting-started.html)** – In diesem Abschnitt erfahren Sie, wie Sie Ihren ersten Edge-Paketerstellungsauftrag einrichten und Ihre erste Flotte erstellen.
1. **Erkunden Sie die Beispiele für Edge Manager-Jupyter-Notebooks** [— Beispiel-Notebooks werden im [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub Repository im Ordner sagemaker\$1edge\$1manager gespeichert.](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker_edge_manager)
# Erste Schritte mit Amazon SageMaker AI Edge Manager
In diesem Handbuch wird gezeigt, wie Sie die erforderlichen Schritte zur Registrierung, Bereitstellung und Verwaltung einer Geräteflotte ausführen und die Voraussetzungen für Amazon SageMaker AI Edge Manager erfüllen.
**Topics**
+ [Einrichten](edge-getting-started-step1.md)
+ [Vorbereiten Ihres Modells für die Bereitstellung](edge-getting-started-step2.md)
+ [Registrieren und Authentifizieren Ihrer Geräteflotte](edge-getting-started-step3.md)
+ [Laden Sie Edge Manager herunter und richten Sie es ein](edge-getting-started-step4.md)
+ [Agent ausführen](edge-getting-started-step5.md)
# Einrichten
Bevor Sie SageMaker Edge Manager zur Verwaltung von Modellen auf Ihren Geräteflotten verwenden, müssen Sie zunächst IAM-Rollen für SageMaker KI und erstellen. AWS IoT Sie sollten auch mindestens einen Amazon S3 S3-Bucket erstellen, in dem Sie Ihr vortrainiertes Modell, die Ausgabe Ihres SageMaker Neo-Kompilierungsjobs sowie Eingabedaten von Ihren Edge-Geräten speichern.
## Melden Sie sich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.
## Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
## Rollen und Speicher erstellen
SageMaker Edge Manager benötigt Zugriff auf Ihre Amazon S3 S3-Bucket-URI. Um dies zu erleichtern, erstellen Sie eine IAM-Rolle, die SageMaker KI ausführen kann und über die Berechtigung für den Zugriff auf Amazon S3 verfügt. Mit dieser Rolle kann SageMaker KI unter Ihrem Konto ausgeführt werden und auf Ihren Amazon S3 S3-Bucket zugreifen.
Sie können eine IAM-Rolle mithilfe der IAM-Konsole, des AWS SDK for Python (Boto3) oder erstellen. AWS CLI Im Folgenden sehen Sie ein Beispiel dafür, wie Sie eine IAM-Rolle erstellen, die erforderlichen Richtlinien mit der IAM-Konsole verknüpfen und einen Amazon-S3-Bucket erstellen.
1. **Erstellen Sie eine IAM-Rolle für Amazon SageMaker AI.**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Klicken Sie im Navigationsbereich der IAM-Konsole auf **Roles** und wählen Sie dann **Create role**.
1. Wählen Sie unter **Select type of trusted entity (Typ der vertrauenswürdigen Entität wählen)** die Option **AWS service (Service)**.
1. Wählen Sie den Service aus, dem Sie das Übernehmen dieser Rolle erlauben wollen. Wählen Sie in diesem Fall **SageMaker AI**. Wählen Sie dann **Next: Permissions**.
+ Dadurch wird automatisch eine IAM-Richtlinie erstellt, die Zugriff auf verwandte Dienste wie Amazon S3, Amazon ECR und CloudWatch Logs gewährt.
1. Wählen Sie **Weiter: Tags** aus.
1. (Optional) Fügen Sie der Rolle Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen dazu, wie Sie verwenden können von Tags mit IAM finden Sie unter [Tagging von Amazon RDSIAM-Ressourcen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Wählen Sie **Weiter: Prüfen** aus.
1. Geben Sie einen **Namen für die Rolle** ein.
1. Geben Sie möglichst einen Rollennamen oder ein Rollennamen-Suffix ein. Rollennamen müssen innerhalb Ihres AWS Kontos eindeutig sein. Sie werden nicht nach Groß- und Kleinschreibung unterschieden. z. B. können Sie keine Rollen erstellen, die `PRODROLE` bzw. `prodrole` heißen. Da andere AWS Ressourcen möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nicht bearbeiten, nachdem sie erstellt wurde.
1. (Optional) Geben Sie im Feld **Role description** eine Beschreibung für die neue Rolle ein.
1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.
Notieren Sie sich den ARN der SageMaker AI-Rolle, mit dem Sie einen Kompilierungsjob mit SageMaker Neo und einen Paketierungsjob mit Edge Manager erstellen. Gehen Sie wie folgt vor, um mithilfe der Konsole die Rollen-ARN zu ermitteln:
1. Gehen Sie zu IAMconsole: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie **Rollen** aus.
1. Suchen Sie nach der Rolle, die Sie gerade erstellt haben, indem Sie den Namen der Rolle in das Suchfeld eintippen.
1. Wählen Sie die Rolle aus.
1. Der Rollen-ARN befindet sich oben auf der **Übersichtsseite**.
1. **Erstellen Sie eine IAM-Rolle für AWS IoT.**
Die von Ihnen AWS IoT erstellte IAM-Rolle wird verwendet, um Ihre Ding-Objekte zu autorisieren. Sie verwenden auch die IAM-Rolle ARN, um Geräteflotten mit einem SageMaker AI-Client-Objekt zu erstellen und zu registrieren.
Konfigurieren Sie in Ihrem AWS Konto eine IAM-Rolle, die der Anbieter für Anmeldeinformationen im Namen der Geräte in Ihrer Geräteflotte übernimmt. Fügen Sie dann eine Richtlinie hinzu, um Ihre Geräte zur Interaktion mit AWS IoT Diensten zu autorisieren.
Erstellen Sie eine Rolle für AWS IoT entweder programmgesteuert oder mit der IAM-Konsole, ähnlich wie Sie es getan haben, als Sie eine Rolle für KI erstellt haben. SageMaker
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Klicken Sie im Navigationsbereich der IAM-Konsole auf **Roles** und wählen Sie dann **Create role**.
1. Wählen Sie unter **Select type of trusted entity (Typ der vertrauenswürdigen Entität wählen)** die Option **AWS service (Service)**.
1. Wählen Sie den Service aus, dem Sie das Übernehmen dieser Rolle erlauben wollen. Wählen Sie in diesem Fall **IoT** aus. Wählen Sie **IoT** als **Anwendungsfall** aus.
1. Wählen Sie **Next: Permissions** aus.
1. Wählen Sie **Next: Tags (Weiter: Tags)** aus.
1. (Optional) Fügen Sie der Rolle Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen dazu, wie Sie verwenden können von Tags mit IAM finden Sie unter [Tagging von Amazon RDSIAM-Ressourcen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Wählen Sie **Weiter: Prüfen** aus.
1. Geben Sie einen **Namen für die Rolle** ein. Der Rollenname muss mit `SageMaker AI` anfangen.
1. (Optional) Geben Sie im Feld **Role description** eine Beschreibung für die neue Rolle ein.
1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.
1. Sobald die Rolle erstellt wurde, wählen Sie in der IAM-Konsole **Rollen** aus. Suchen Sie nach der Rolle, die Sie erstellt haben, indem Sie den Rollennamen in das **Suchfeld** eingeben.
1. Wählen Sie Ihre Rolle aus.
1. Wählen Sie dann **Richtlinien anhängen** aus.
1. Suchen Sie nach `AmazonSageMakerEdgeDeviceFleetPolicy` im Feld **Suchen**. Wählen Sie `AmazonSageMakerEdgeDeviceFleetPolicy` aus.
1. Wählen Sie **Richtlinie anfügen** aus.
1. Fügen Sie zur Vertrauensstellung die folgende Richtlinienanweisung hinzu:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "credentials.iot.amazonaws.com"},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
------
Eine Vertrauensrichtlinie ist ein [JSON-Richtliniendokument](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_grammar), in dem Sie die Prinzipale definieren, denen Sie bei der Übernahme der Rolle vertrauen. Weitere Informationen zu Vertrauensrichtlinien finden Sie unter [Begriffe und Konzepte für Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html).
1. Notieren Sie sich die AWS IoT Rolle ARN. Sie verwenden die AWS IoT Rolle ARN, um die Geräteflotte zu erstellen und zu registrieren. So finden Sie die IAM-Rollen-ARN über die Konsole:
1. Gehen Sie zur IAM-Konsole: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie **Roles**.
1. Suchen Sie nach der Rolle, die Sie erstellt haben, indem Sie den Namen der Rolle in das **Suchfeld** eingeben.
1. Wählen Sie die Rolle aus.
1. Die Rollen-ARN finden Sie auf der Seite mit der Zusammenfassung.
1. **Erstellen Sie einen Amazon-S3-Bucket.**
SageMaker Neo und Edge Manager greifen über einen Amazon S3 S3-Bucket auf Ihr vorkompiliertes Modell und Ihr kompiliertes Modell zu. Edge Manager speichert Beispieldaten aus Ihrer Geräteflotte auch in Amazon S3.
1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.
1. Geben Sie in **Bucketname** einen Namen für Ihren Bucket ein.
1. Wählen Sie **unter Region** die AWS Region aus, in der sich der Bucket befinden soll.
1. Wählen Sie unter **Bucket-Einstellungen für Öffentlichen Zugriff Blockieren** die Einstellungen, die Sie auf den Bucket anwenden möchten.
1. Wählen Sie **Bucket erstellen** aus.
Weitere Informationen dazu, wie von Amazon-S3-Buckets erstellt werden, finden Sie unter [Erste Schritte mit Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html).
# Vorbereiten Ihres Modells für die Bereitstellung
In diesem Abschnitt erstellen Sie SageMaker KI- und AWS IoT Client-Objekte, laden ein vortrainiertes Modell für maschinelles Lernen herunter, laden Ihr Modell in Ihren Amazon S3 S3-Bucket hoch, kompilieren Ihr Modell für Ihr Zielgerät mit SageMaker Neo und verpacken Ihr Modell, sodass es mit dem Edge Manager-Agenten bereitgestellt werden kann.
1. **Bibliotheken importieren und Client-Objekte erstellen.**
In diesem Tutorial werden Clients AWS SDK für Python (Boto3) für die Interaktion mit SageMaker KI, Amazon S3 und erstellt AWS IoT.
Importieren Sie Boto3, geben Sie Ihre Region an und initialisieren Sie die benötigten Client-Objekte, wie im folgenden Beispiel gezeigt:
```
import boto3
import json
import time
AWS_REGION = 'us-west-2'# Specify your Region
bucket = 'bucket-name'
sagemaker_client = boto3.client('sagemaker', region_name=AWS_REGION)
iot_client = boto3.client('iot', region_name=AWS_REGION)
```
Definieren Sie Variablen und weisen Sie ihnen die Rolle ARN zu, die Sie für SageMaker KI erstellt haben, und zwar AWS IoT als Zeichenketten:
```
# Replace with the role ARN you created for SageMaker
sagemaker_role_arn = "arn:aws:iam:::role/*"
# Replace with the role ARN you created for AWS IoT.
# Note: The name must start with 'SageMaker'
iot_role_arn = "arn:aws:iam:::role/SageMaker*"
```
1. **Ein Machine-Learning-Modell trainieren.**
Weitere Informationen zum [Trainieren eines Modells SageMaker für maschinelles Lernen mithilfe von SageMaker KI finden Sie unter Train a Model with Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html). Sie können Ihr lokal trainiertes Modell optional direkt in einen Amazon-S3-URI-Bucket hochladen.
Wenn Sie noch kein Modell haben, können Sie für die nächsten Schritte in diesem Tutorial ein vortrainiertes Modell verwenden. Sie können beispielsweise die MobileNet V2-Modelle aus dem TensorFlow Framework speichern. MobileNet V2 ist ein für mobile Anwendungen optimiertes Bildklassifizierungsmodell. Weitere Informationen zu MobileNet V2 finden Sie in der [MobileNet GitHub README-Datei](https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet).
Geben Sie Folgendes in Ihr Jupyter Notebook ein, um das vortrainierte V2-Modell zu speichern: MobileNet
```
# Save the MobileNet V2 model to local storage
import tensorflow as tf
model = tf.keras.applications.MobileNetV2()
model.save(“mobilenet_v2.h5”)
```
**Anmerkung**
Wenn Sie es noch nicht TensorFlow installiert haben, können Sie dies tun, indem Sie Folgendes ausführen `pip install tensorflow=2.4`
Verwenden Sie TensorFlow Version 2.4 oder niedriger für dieses Tutorial.
Das Modell wird in der Datei `mobilenet_v2.h5` gespeichert. Bevor Sie das Modell verpacken, müssen Sie Ihr Modell zunächst mit SageMaker Neo kompilieren. Prüfen [Unterstützte Frameworks, Geräte, Systeme und Architekturen](neo-supported-devices-edge.md) Sie, ob Ihre Version von TensorFlow (oder ein anderes Framework Ihrer Wahl) derzeit von SageMaker Neo unterstützt wird.
SageMaker Neo erfordert, dass Modelle als komprimierte TAR-Datei gespeichert werden. Erstellen Sie ein neues Paket dafür als komprimierte TAR-Datei (\$1.tar.gz):
```
# Package MobileNet V2 model into a TAR file
import tarfile
tarfile_name='mobilenet-v2.tar.gz'
with tarfile.open(tarfile_name, mode='w:gz') as archive:
archive.add('mobilenet-v2.h5')
```
1. **Laden Sie Ihr Modell auf Amazon S3 hoch.**
Sobald Sie ein Machine-Learning-Modell haben, speichern Sie es in einem Amazon-S3-Bucket. Im folgenden Beispiel wird ein AWS CLI Befehl verwendet, um das Modell in den Amazon S3 S3-Bucket hochzuladen, den Sie zuvor in einem Verzeichnis namens *models* erstellt haben. Geben Sie Folgendes in Ihr Jupyter Notebook ein:
```
!aws s3 cp mobilenet-v2.tar.gz s3://{bucket}/models/
```
1. **Kompilieren Sie Ihr Modell mit SageMaker Neo.**
Kompilieren Sie Ihr Modell für maschinelles Lernen mit SageMaker Neo für ein Edge-Gerät. Sie müssen Ihren Amazon-S3-Bucket-URI, unter dem Sie das trainierte Modell gespeichert haben, das Machine-Learning-Framework, mit dem Sie Ihr Modell trainiert haben, die Form der Eingabe Ihres Modells und Ihr Zielgerät kennen.
Verwenden Sie für das MobileNet V2-Modell Folgendes:
```
framework = 'tensorflow'
target_device = 'jetson_nano'
data_shape = '{"data":[1,3,224,224]}'
```
SageMaker Neo benötigt eine bestimmte Modelleingabeform und ein bestimmtes Modellformat, die auf dem von Ihnen verwendeten Deep-Learning-Framework basieren. Weitere Informationen dazu, wie Sie Ihr Modell speichern können, finden Sie unter [Welche Formen der Eingabedaten erwartet SageMaker Neo?](neo-compilation-preparing-model.md#neo-job-compilation-expected-inputs). Weitere Informationen zu Geräten und Frameworks, die von Neo unterstützt werden, finden Sie unter [Unterstützte Frameworks, Geräte, Systeme und Architekturen](neo-supported-devices-edge.md).
Verwenden Sie die `CreateCompilationJob` API, um einen Kompilierungsjob mit SageMaker Neo zu erstellen. Geben Sie einen Namen für den Kompilierungsauftrag, den SageMaker AI-Rollen-ARN, die Amazon S3 S3-URI, in der Ihr Modell gespeichert ist, die Eingabeform des Modells, den Namen des Frameworks, die Amazon S3 S3-URI, in der SageMaker AI Ihr kompiliertes Modell speichern soll, und Ihr Edge-Geräteziel an.
```
# Specify the path where your model is stored
model_directory = 'models'
s3_model_uri = 's3://{}/{}/{}'.format(bucket, model_directory, tarfile_name)
# Store compiled model in S3 within the 'compiled-models' directory
compilation_output_dir = 'compiled-models'
s3_output_location = 's3://{}/{}/'.format(bucket, compilation_output_dir)
# Give your compilation job a name
compilation_job_name = 'getting-started-demo'
sagemaker_client.create_compilation_job(CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
InputConfig={
'S3Uri': s3_model_uri,
'DataInputConfig': data_shape,
'Framework' : framework.upper()},
OutputConfig={
'S3OutputLocation': s3_output_location,
'TargetDevice': target_device},
StoppingCondition={'MaxRuntimeInSeconds': 900})
```
1. **Erstellen Sie ein Paket für Ihr kompiliertes Modell.**
Bei Paketierungsaufträgen werden SageMaker NEO-kompilierte Modelle verwendet und alle Änderungen vorgenommen, die für die Bereitstellung des Modells mit der Inferenz-Engine, dem Edge Manager-Agent, erforderlich sind. Um Ihr Modell zu verpacken, erstellen Sie einen Edge-Paketierungsauftrag mit der `create_edge_packaging` API oder der SageMaker KI-Konsole.
Sie müssen den Namen angeben, den Sie für Ihren Neo-Kompilierungsauftrag verwendet haben, einen Namen für den Paketerstellungsauftrag, eine Rollen-ARN (siehe den Abschnitt [Einrichten](edge-getting-started-step1.md)), einen Namen für das Modell, eine Modellversion und den Amazon-S3-Bucket-URI für die Ausgabe des Paketerstellungsauftrags. Beachten Sie, dass bei den Namen von Edge-Manager-Paketerstellungsaufträgen die Groß- und Kleinschreibung wichtig ist. Im Folgenden finden Sie ein Beispiel dafür, wie Sie mit der API erstellen einen Paketerstellungsauftrag.
```
edge_packaging_name='edge-packaging-demo'
model_name="sample-model"
model_version="1.1"
```
Definieren Sie den Amazon-S3-URI, in dem Sie das verpackte Modell speichern möchten.
```
# Output directory where you want to store the output of the packaging job
packaging_output_dir = 'packaged_models'
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)
```
Verwenden Sie `CreateEdgePackagingJob` zur Paketerstellung für Ihr mit NEO kompiliertes Modell. Geben Sie einen Namen für Ihren Edge-Paketerstellungsauftrag und den Namen an, den Sie für Ihren Kompilierungsauftrag angegeben haben (in diesem Beispiel wurde dieser in der `compilation_job_name` Variablen gespeichert). Geben Sie außerdem einen Namen für Ihr Modell, eine Version für Ihr Modell (damit Sie den Überblick darüber behalten, welche Modellversion Sie verwenden) und die S3-URI an, unter der SageMaker KI das verpackte Modell speichern soll.
```
sagemaker_client.create_edge_packaging_job(
EdgePackagingJobName=edge_packaging_name,
CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
ModelName=model_name,
ModelVersion=model_version,
OutputConfig={
"S3OutputLocation": packaging_s3_output
}
)
```
# Registrieren und Authentifizieren Ihrer Geräteflotte
In diesem Abschnitt erstellen Sie Ihr AWS IoT Ding-Objekt, erstellen eine Geräteflotte, registrieren Ihre Geräteflotte, damit sie mit der Cloud interagieren kann, erstellen X.509-Zertifikate zur Authentifizierung Ihrer Geräte AWS IoT Core, verknüpfen den Rollenalias mit AWS IoT dem, der bei der Erstellung Ihrer Flotte generiert wurde, ermitteln Ihren AWS kontospezifischen Endpunkt für den Anbieter von Anmeldeinformationen, rufen eine offizielle Amazon Root-CA-Datei ab und laden die Amazon CA-Datei auf Amazon S3 hoch.
1. **Dinge erstellen. AWS IoT **
SageMaker Edge Manager nutzt die AWS IoT Core Dienste, um die Verbindung zwischen den Edge-Geräten und Endpunkten in der AWS Cloud zu erleichtern. Sie können die vorhandenen AWS IoT Funktionen nutzen, nachdem Sie Ihre Geräte für die Verwendung mit Edge Manager eingerichtet haben.
Um Ihr Gerät mit zu verbinden AWS IoT, müssen Sie AWS IoT *Ding-Objekte* erstellen, ein Client-Zertifikat bei AWS IoT erstellen und registrieren und die IAM-Rolle für Ihre Geräte erstellen und konfigurieren.
Erstellen Sie AWS IoT zunächst Dingobjekte mit dem AWS IoT Client (`iot_client`), den Sie zuvor mit Boto3 erstellt haben. Das folgende Beispiel zeigt, wie man zwei Objekte erstellt:
```
iot_thing_name = 'sample-device'
iot_thing_type = 'getting-started-demo'
iot_client.create_thing_type(
thingTypeName=iot_thing_type
)
# Create an AWS IoT thing objects
iot_client.create_thing(
thingName=iot_thing_name,
thingTypeName=iot_thing_type
)
```
1. **Geräteflotte erstellen.**
Erstellen Sie eine Geräteflotte mit dem SageMaker KI-Client-Objekt, das in einem vorherigen Schritt definiert wurde. Sie können die SageMaker KI-Konsole auch verwenden, um eine Geräteflotte zu erstellen.
```
import time
device_fleet_name="demo-device-fleet" + str(time.time()).split('.')[0]
device_name="sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
```
Geben Sie den ARN Ihrer IoT-Rolle an. Auf diese Weise können temporäre Anmeldeinformationen für Geräte AWS IoT vergeben werden.
```
device_model_directory='device_output'
s3_device_fleet_output = 's3://{}/{}'.format(bucket, device_model_directory)
sagemaker_client.create_device_fleet(
DeviceFleetName=device_fleet_name,
RoleArn=iot_role_arn, # IoT Role ARN specified in previous step
OutputConfig={
'S3OutputLocation': s3_device_fleet_output
}
)
```
Ein AWS IoT Rollenalias wird erstellt, wenn Sie eine Geräteflotte erstellen. Dieser Rollenalias wird mit der AWS IoT Verwendung des `iot_client` Objekts in einem späteren Schritt verknüpft.
1. **Registrieren Sie Ihre Geräteflotte.**
Um mit der Cloud zu interagieren, müssen Sie Ihr Gerät bei SageMaker Edge Manager registrieren. In diesem Beispiel registrieren Sie ein einzelnes Gerät bei der Flotte, die Sie erstellt haben. Um das Gerät zu registrieren, müssen Sie einen Gerätenamen und den Namen des AWS IoT Objekts angeben, wie im folgenden Beispiel gezeigt:
```
# Device name should be 36 characters
device_name = "sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
sagemaker_client.register_devices(
DeviceFleetName=device_fleet_name,
Devices=[
{
"DeviceName": device_name,
"IotThingName": iot_thing_name
}
]
)
```
1. **X.509-Zertifikate erstellen.**
Nachdem Sie das AWS IoT Ding-Objekt erstellt haben, müssen Sie ein X.509-Gerätezertifikat für Ihr Ding-Objekt erstellen. Dieses Zertifikat authentifiziert Ihr Gerät gegenüber AWS IoT Core.
Gehen Sie wie folgt vor, um einen privaten Schlüssel, einen öffentlichen Schlüssel und eine X.509-Zertifikatsdatei mit dem zuvor definierten AWS IoT Client (`iot_client`) zu erstellen.
```
# Creates a 2048-bit RSA key pair and issues an X.509 # certificate
# using the issued public key.
create_cert = iot_client.create_keys_and_certificate(
setAsActive=True
)
# Get certificate from dictionary object and save in its own
with open('./device.pem.crt', 'w') as f:
for line in create_cert['certificatePem'].split('\n'):
f.write(line)
f.write('\n')
# Get private key from dictionary object and save in its own
with open('./private.pem.key', 'w') as f:
for line in create_cert['keyPair']['PrivateKey'].split('\n'):
f.write(line)
f.write('\n')
# Get a private key from dictionary object and save in its own
with open('./public.pem.key', 'w') as f:
for line in create_cert['keyPair']['PublicKey'].split('\n'):
f.write(line)
f.write('\n')
```
1. **Ordnen Sie den Rollenalias zu AWS IoT.**
Wenn Sie eine Geräteflotte mit SageMaker KI (`sagemaker_client.create_device_fleet()`) erstellen, wird ein Rollenalias für Sie generiert. Ein AWS IoT Rollenalias bietet einen Mechanismus, mit dem sich verbundene Geräte AWS IoT mithilfe von X.509-Zertifikaten authentifizieren und dann kurzlebige AWS Anmeldeinformationen von einer IAM-Rolle abrufen können, die einem Rollenalias zugeordnet ist. AWS IoT Mit dem Rollenalias können Sie die Rolle des Gerätes ändern, ohne das Gerät aktualisieren zu müssen. Verwenden Sie `DescribeDeviceFleet`, um den Aliasnamen und den ARN der Rolle abzurufen.
```
# Print Amazon Resource Name (ARN) and alias that has access
# to AWS Internet of Things (IoT).
sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)
# Store iot role alias string in a variable
# Grabs role ARN
full_role_alias_name = sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)['IotRoleAlias']
start_index = full_role_alias_name.find('SageMaker') # Find beginning of role name
role_alias_name = full_role_alias_name[start_index:]
```
Verwenden Sie den`iot_client`, um die Zuordnung des bei der Erstellung der Geräteflotte generierten Rollenalias zu vereinfachen mit: AWS IoT
```
role_alias = iot_client.describe_role_alias(
roleAlias=role_alias_name)
```
Weitere Informationen zum IAM-Rollenalias finden Sie unter [Rollenalias ermöglicht Zugriff auf ungenutzte Dienste](https://docs.aws.amazon.com/iot/latest/developerguide/audit-chk-role-alias-unused-svcs.html).
Sie haben AWS IoT zuvor ein Zertifikat erstellt und registriert, um Ihr Gerät erfolgreich zu authentifizieren. Jetzt müssen Sie eine Richtlinie erstellen und an das Zertifikat anhängen, um die Anforderung des Sicherheitstokens zu autorisieren.
```
alias_policy = {
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": role_alias['roleAliasDescription']['roleAliasArn']
}
}
policy_name = 'aliaspolicy-'+ str(time.time()).split('.')[0]
aliaspolicy = iot_client.create_policy(policyName=policy_name,
policyDocument=json.dumps(alias_policy))
# Attach policy
iot_client.attach_policy(policyName=policy_name,
target=create_cert['certificateArn'])
```
1. **Rufen Sie Ihren AWS kontospezifischen Endpunkt für den Anbieter der Anmeldeinformationen ab.**
Edge-Geräte brauchen einen Endpunkt, um Anmeldeinformationen annehmen zu können. Rufen Sie Ihren AWS kontospezifischen Endpunkt für den Anbieter der Anmeldeinformationen ab.
```
# Get the unique endpoint specific to your AWS account that is making the call.
iot_endpoint = iot_client.describe_endpoint(
endpointType='iot:CredentialProvider'
)
endpoint="https://{}/role-aliases/{}/credentials".format(iot_endpoint['endpointAddress'],role_alias_name)
```
1. **Holen Sie sich die offizielle Amazon-Root-CA-Datei und laden Sie sie in den Amazon-S3-Bucket hoch.**
Verwenden Sie Folgendes in Ihrem Jupyter Notebook oder AWS CLI (wenn Sie Ihr Terminal verwenden, entfernen Sie das '\$1' magische Funktion):
```
!wget https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
Verwenden Sie den Endpunkt, um eine HTTPS-Anfrage an den Anmeldeinformationsanbieter zu stellen, ein Sicherheits-Token zurückzugeben. Der folgende Beispielbefehl verwendet `curl`, aber Sie können jeden beliebigen HTTP-Client verwenden.
```
!curl --cert device.pem.crt --key private.pem.key --cacert AmazonRootCA1.pem $endpoint
```
Wenn das Zertifikat verifiziert ist, laden Sie die Schlüssel und das Zertifikat in Ihren Amazon-S3-Bucket-URI hoch:
```
!aws s3 cp private.pem.key s3://{bucket}/authorization-files/
!aws s3 cp device.pem.crt s3://{bucket}/authorization-files/
!aws s3 cp AmazonRootCA1.pem s3://{bucket}/authorization-files/
```
Bereinigen Sie Ihr Arbeitsverzeichnis, indem Sie Ihre Schlüssel und Ihr Zertifikat in ein anderes Verzeichnis verschieben:
```
# Optional - Clean up working directory
!mkdir authorization-files
!mv private.pem.key device.pem.crt AmazonRootCA1.pem authorization-files/
```
# Laden Sie Edge Manager herunter und richten Sie es ein
Der Edge Manager-Agent ist ein Inference-Engine für Ihre Edge-Geräte. Verwenden Sie den Agenten, um Vorhersagen anhand von Modellen zu treffen, die auf Ihre Edge-Geräte geladen werden. Der Agent sammelt auch Modellkennzahlen und erfasst in bestimmten Intervallen Daten.
In diesem Abschnitt richten Sie mit dem Agenten Ihr Gerät ein. Kopieren Sie dazu zunächst einen Release-Artefakt und ein signiertes Stammzertifikat aus dem Release-Bucket lokal auf Ihren Computer. Wenn Sie den Release-Artefakt entpackt haben, laden Sie ihn auf Amazon S3 hoch. Definieren und speichern Sie als Nächstes eine Konfigurationsdatei für den Agenten. Es wird eine Vorlage bereitgestellt, die Sie kopieren und einfügen können. Kopieren Sie abschließend die Release-Artefakte, die Konfigurationsdatei und die Anmeldeinformationen auf Ihr Gerät.
1. **Laden Sie den SageMaker Edge Manager-Agenten herunter.**
Der Agent wird für unterstützte Betriebssysteme im Binärformat veröffentlicht. In diesem Beispiel wird Inferenz auf einem Jetson Nano ausgeführt, der ein Linux-Betriebssystem verwendet und über eine ARM64 Architektur verfügt. Weitere Informationen darüber, welches Betriebssystem und welche Architektur unterstützte Geräte verwenden, finden Sie unter [Unterstützte Geräte, Chip-Architekturen und Systeme](neo-supported-devices-edge-devices.md).
Rufen Sie die neueste Version der Binärdateien aus dem SageMaker Edge Manager-Release-Bucket aus der Region us-west-2 ab.
```
!aws s3 ls s3://sagemaker-edge-release-store-us-west-2-linux-armv8/Releases/ | sort -r
```
Somit werden Release-Artefakte sortiert nach ihrer Version zurückgegeben.
```
PRE 1.20210512.96da6cc/
PRE 1.20210305.a4bc999/
PRE 1.20201218.81f481f/
PRE 1.20201207.02d0e97/
```
Die Version hat das folgende Format: `..`. Sie besteht aus drei Komponenten:
+ ``: Die Release-Version. Die Release-Version ist derzeit auf `1` eingestellt.
+ ``: Der Zeitstempel der Artefakt-Veröffentlichung.
+ : Die Commit-ID des Repositorys, aus der das Release erstellt wird.
Kopieren Sie die komprimierte TAR-Datei lokal oder direkt auf Ihr Gerät. Im folgenden Beispiel wird gezeigt, wie Sie den Artefakt der neuesten Version zum Zeitpunkt der Veröffentlichung dieses Dokuments kopieren.
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases/1.20201218.81f481f/1.20201218.81f481f.tgz ./
```
Sobald Sie den Artefakt haben, entpacken Sie die komprimierte TAR-Datei. Im Folgenden wird die TAR-Datei entpackt und in einem Verzeichnis mit dem Namen: `agent_demo` gespeichert.
```
!mkdir agent_demo
!tar -xvzf 1.20201218.81f481f.tgz -C ./agent_demo
```
Laden Sie die Release-Artefakte für den Agenten auf Ihren Amazon-S3-Bucket hoch. Der folgende Beispiel-Code kopiert den Inhalt in `agent_demo` und lädt ihn in ein Verzeichnis in Ihrem Amazon-S3-Bucket mit dem Namen: `agent_demo` hoch.
```
!aws s3 cp --recursive ./agent_demo s3://{bucket}/agent_demo
```
Sie brauchen außerdem die Signatur-Root-Zertifikate aus dem Release-Bucket:
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Certificates/us-west-2/us-west-2.pem ./
```
Laden Sie das Signatur-Root-Zertifikat auf Ihren Amazon-S3-Bucket hoch:
```
!aws s3 cp us-west-2.pem s3://{bucket}/authorization-files/
```
1. **Definieren Sie eine SageMaker Edge Manager-Agent-Konfigurationsdatei.**
Definieren Sie zunächst die Konfigurationsdatei für den Agenten wie folgt:
```
sagemaker_edge_config = {
"sagemaker_edge_core_device_name": "device_name",
"sagemaker_edge_core_device_fleet_name": "device_fleet_name",
"sagemaker_edge_core_capture_data_buffer_size": 30,
"sagemaker_edge_core_capture_data_push_period_seconds": 4,
"sagemaker_edge_core_folder_prefix": "demo_capture",
"sagemaker_edge_core_region": "us-west-2",
"sagemaker_edge_core_root_certs_path": "/agent_demo/certificates",
"sagemaker_edge_provider_aws_ca_cert_file": "/agent_demo/iot-credentials/AmazonRootCA1.pem",
"sagemaker_edge_provider_aws_cert_file": "/agent_demo/iot-credentials/device.pem.crt",
"sagemaker_edge_provider_aws_cert_pk_file": "/agent_demo/iot-credentials/private.pem.key",
"sagemaker_edge_provider_aws_iot_cred_endpoint": "endpoint",
"sagemaker_edge_provider_provider": "Aws",
"sagemaker_edge_provider_s3_bucket_name": bucket,
"sagemaker_edge_core_capture_data_destination": "Cloud"
}
```
Ersetzen Sie Folgendes:
+ `"device_name"` mit dem Namen Ihres Gerätes (diese Zeichenfolge wurde in einem früheren Schritt in einer Variable mit dem Namen `device_name` gespeichert).
+ `"device_fleet_name`“ mit dem Namen Ihres Gerätes (diese Zeichenfolge wurde in einem früheren Schritt in einer Variable mit dem Namen `device_fleet_name` gespeichert)
+ `"endpoint"`mit Ihrem AWS kontospezifischen Endpunkt für den Anmeldeinformationsanbieter (diese Zeichenfolge wurde in einem früheren Schritt in einer Variablen mit dem Namen `endpoint` gespeichert).
Speichern Sie ihn als Nächstes als JSON-Datei:
```
edge_config_file = open("sagemaker_edge_config.json", "w")
json.dump(sagemaker_edge_config, edge_config_file, indent = 6)
edge_config_file.close()
```
Laden Sie die Konfigurationsdatei auf Ihr Amazon-S3-Bucket hoch:
```
!aws s3 cp sagemaker_edge_config.json s3://{bucket}/
```
1. **Kopieren Sie die Release-Artefakte, die Konfigurationsdatei und die Anmeldeinformationen auf Ihr Gerät.**
Die folgenden Anweisungen werden auf dem Edge-Gerät selbst ausgeführt.
**Anmerkung**
Sie müssen zuerst Python AWS SDK für Python (Boto3), the und the AWS CLI auf Ihrem Edge-Gerät installieren.
Öffnen Sie ein Terminal auf Ihrem Gerät. Erstellen Sie einen Ordner zum Speichern der Release-Artefakte, Ihrer Anmeldeinformationen und der Konfigurationsdatei.
```
mkdir agent_demo
cd agent_demo
```
Kopieren Sie den Inhalt der Release-Artefakte, die Sie in Ihrem Amazon-S3-Bucket gespeichert haben, auf Ihr Gerät:
```
# Copy release artifacts
aws s3 cp s3:///agent_demo/ ./ --recursive
```
(Der Inhalt des Release-Artefakts wurde in einem Verzeichnis gespeichert, das in einem früheren Schritt als `agent_demo` bezeichnet wurde). Ersetzen Sie `