Ein Leitfaden für die Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints#

Die Bereitstellung moderner Computer-Vision-Modelle wie Ultralytics' YOLO26 auf Amazon SageMaker Endpoints eröffnet eine Vielzahl von Möglichkeiten für verschiedene Machine-Learning-Anwendungen. Der Schlüssel zur effektiven Nutzung dieser Modelle liegt im Verständnis ihrer Einrichtung, Konfiguration und der Bereitstellungsprozesse. YOLO26 wird noch leistungsstärker, wenn es nahtlos in Amazon SageMaker integriert wird, einen robusten und skalierbaren Machine-Learning-Dienst von AWS.

Diese Anleitung führt dich Schritt für Schritt durch den Prozess der Bereitstellung von YOLO26 PyTorch-Modellen auf Amazon SageMaker Endpoints. Du lernst das Wesentliche über die Vorbereitung deiner AWS-Umgebung, die passende Konfiguration des Modells und die Nutzung von Tools wie AWS CloudFormation und dem AWS Cloud Development Kit (CDK) für das Deployment.

Amazon SageMaker#

Amazon SageMaker ist ein Machine-Learning-Dienst von Amazon Web Services (AWS), der den Prozess des Erstellens, Trainierens und Bereitstellens von Machine-Learning-Modellen vereinfacht. Er bietet eine breite Palette an Werkzeugen zur Handhabung verschiedener Aspekte von Machine-Learning-Workflows. Dazu gehören automatisierte Funktionen zur Modelloptimierung, Optionen für das skalierbare Training von Modellen und unkomplizierte Methoden zur Bereitstellung von Modellen in der Produktion. SageMaker unterstützt gängige Machine-Learning-Frameworks und bietet die nötige Flexibilität für diverse Projekte. Seine Funktionen umfassen zudem Daten-Labeling, Workflow-Management und Leistungsanalysen.

Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints#

Die Bereitstellung von YOLO26 auf Amazon SageMaker ermöglicht es dir, deren verwaltete Umgebung für Echtzeit-Inferenz zu nutzen und von Funktionen wie Autoscaling zu profitieren. Wirf einen Blick auf die untenstehende AWS-Architektur.

Schritt 1: Einrichten deiner AWS-Umgebung#

Stelle zunächst sicher, dass die folgenden Voraussetzungen erfüllt sind:

• Ein AWS-Konto: Falls du noch keines hast, registriere dich für ein AWS-Konto.

• Konfigurierte IAM-Rollen: Du benötigst eine IAM-Rolle mit den erforderlichen Berechtigungen für Amazon SageMaker, AWS CloudFormation und Amazon S3. Diese Rolle sollte über Richtlinien verfügen, die den Zugriff auf diese Dienste erlauben.

• AWS CLI: Lade die AWS Command Line Interface (CLI) herunter und installiere sie (falls noch nicht geschehen) und konfiguriere sie mit deinen Account-Details. Folge zur Installation den Anweisungen für die AWS CLI.

• AWS CDK: Installiere das AWS Cloud Development Kit (CDK), das für das Skripting der Bereitstellung verwendet wird, falls es noch nicht installiert ist. Folge zur Installation den Anweisungen für das AWS CDK.

• Ausreichende Service-Quoten: Bestätige, dass du über ausreichende Quoten für zwei separate Ressourcen in Amazon SageMaker verfügst: eine für ml.m5.4xlarge für die Endpunktnutzung und eine weitere für ml.m5.4xlarge für die Nutzung von Notebook-Instanzen. Jede davon erfordert einen Mindestwert für die Quote. Wenn deine aktuellen Quoten unter diesen Anforderungen liegen, ist es wichtig, für jede eine Erhöhung zu beantragen. Du kannst eine Quotenerhöhung beantragen, indem du den detaillierten Anweisungen in der Dokumentation zu AWS Service Quotas folgst.

Schritt 2: Klonen des YOLO26 SageMaker-Repositorys#

Der nächste Schritt besteht darin, das spezifische AWS-Repository zu klonen, das die Ressourcen für die Bereitstellung von YOLO26 auf SageMaker enthält. Dieses auf GitHub gehostete Repository enthält die erforderlichen CDK-Skripte und Konfigurationsdateien.

• GitHub-Repository klonen: Führe den folgenden Befehl in deinem Terminal aus, um das host-yolov8-on-sagemaker-endpoint-Repository zu klonen:

  git clone https://github.com/aws-samples/host-yolov8-on-sagemaker-endpoint.git

• In das geklonte Verzeichnis navigieren: Wechsle in das Verzeichnis des geklonten Repositorys:

  cd host-yolov8-on-sagemaker-endpoint/yolov8-pytorch-cdk

Schritt 3: Einrichtung der CDK-Umgebung#

Nachdem du nun den notwendigen Code hast, richte deine Umgebung für die Bereitstellung mit dem AWS CDK ein.

• Erstelle eine virtuelle Python-Umgebung: Dies isoliert deine Python-Umgebung und Abhängigkeiten. Führe aus:

  python3 -m venv .venv

• Aktiviere die virtuelle Umgebung:

  source .venv/bin/activate

• Installiere Abhängigkeiten: Installiere die erforderlichen Python-Abhängigkeiten für das Projekt:

  pip3 install -r requirements.txt

• AWS CDK-Bibliothek aktualisieren: Stelle sicher, dass du die neueste Version der AWS CDK-Bibliothek installiert hast:

  pip install --upgrade aws-cdk-lib

Schritt 4: Erstellen des AWS CloudFormation-Stacks#

• Synthetisiere die CDK-Anwendung: Generiere die AWS CloudFormation-Vorlage aus deinem CDK-Code:

  cdk synth

• Bootstrapping der CDK-Anwendung: Bereite deine AWS-Umgebung für die CDK-Bereitstellung vor:

  cdk bootstrap

• Stapel bereitstellen: Dies erstellt die notwendigen AWS-Ressourcen und stellt dein Modell bereit:

  cdk deploy

Schritt 5: Bereitstellung des YOLO-Modells#

Bevor du in die Bereitstellungsanweisungen eintauchst, solltest du dir unbedingt die Auswahl an von Ultralytics angebotenen YOLO26-Modellen ansehen. Dies hilft dir dabei, das am besten geeignete Modell für deine Projektanforderungen auszuwählen.

Nach dem Erstellen des AWS CloudFormation-Stacks ist der nächste Schritt die Bereitstellung von YOLO26.

• Öffne die Notebook-Instanz: Gehe zur AWS-Konsole und navigiere zum Amazon SageMaker-Dienst. Wähle im Dashboard "Notebook Instances" aus und suche dann die Notebook-Instanz, die von deinem CDK-Bereitstellungsskript erstellt wurde. Öffne die Notebook-Instanz, um auf die Jupyter-Umgebung zuzugreifen.

• Zugriff auf und Änderung von inference.py: Nachdem du die SageMaker-Notebook-Instanz in Jupyter geöffnet hast, suche die Datei inference.py. Bearbeite die Funktion output_fn in inference.py wie unten gezeigt und speichere deine Änderungen am Skript, wobei du sicherstellst, dass keine Syntaxfehler vorliegen.

  import json
  
  def output_fn(prediction_output):
      """Formats model outputs as JSON string, extracting attributes like boxes, masks, keypoints."""
      print("Executing output_fn from inference.py ...")
      infer = {}
      for result in prediction_output:
          if result.boxes is not None:
              infer["boxes"] = result.boxes.numpy().data.tolist()
          if result.masks is not None:
              infer["masks"] = result.masks.numpy().data.tolist()
          if result.keypoints is not None:
              infer["keypoints"] = result.keypoints.numpy().data.tolist()
          if result.obb is not None:
              infer["obb"] = result.obb.numpy().data.tolist()
          if result.probs is not None:
              infer["probs"] = result.probs.numpy().data.tolist()
      return json.dumps(infer)

• Endpunkt mit 1_DeployEndpoint.ipynb bereitstellen: Öffne in der Jupyter-Umgebung das Notebook 1_DeployEndpoint.ipynb, das sich im Verzeichnis sm-notebook befindet. Befolge die Anweisungen im Notebook und führe die Zellen aus, um das YOLO26-Modell herunterzuladen, es mit dem aktualisierten Inferenz-Code zu verpacken und in einen Amazon S3-Bucket hochzuladen. Das Notebook führt dich durch das Erstellen und Bereitstellen eines SageMaker-Endpunkts für das YOLO26-Modell.

Schritt 6: Testen deiner Bereitstellung#

Nachdem dein YOLO26-Modell nun bereitgestellt ist, ist es wichtig, seine Leistung und Funktionalität zu testen.

• Öffne das Test-Notebook: Suche in derselben Jupyter-Umgebung das Notebook 2_TestEndpoint.ipynb, das sich ebenfalls im Verzeichnis sm-notebook befindet, und öffne es.

• Führe das Test-Notebook aus: Folge den Anweisungen im Notebook, um den bereitgestellten SageMaker-Endpunkt zu testen. Dazu gehört das Senden eines Bildes an den Endpunkt und das Ausführen von Inferenzen. Anschließend plottest du das Ergebnis, um die Leistung und Genauigkeit des Modells zu visualisieren, wie unten gezeigt.

• Ressourcen bereinigen: Das Test-Notebook führt dich auch durch den Prozess des Bereinigens des Endpunkts und des gehosteten Modells. Dies ist ein wichtiger Schritt, um Kosten und Ressourcen effektiv zu verwalten, insbesondere wenn du nicht planst, das bereitgestellte Modell sofort zu verwenden.

Schritt 7: Überwachung und Verwaltung#

Nach dem Testen sind eine kontinuierliche Überwachung und Verwaltung deines bereitgestellten Modells unerlässlich.

• Überwachung mit Amazon CloudWatch: Überprüfe die Leistung und den Status deines SageMaker-Endpunkts regelmäßig mit Amazon CloudWatch.

• Endpunkt verwalten: Nutze die SageMaker-Konsole für die laufende Verwaltung des Endpunkts. Dies umfasst das Skalieren, Aktualisieren oder erneute Bereitstellen des Modells nach Bedarf.

Durch den Abschluss dieser Schritte hast du erfolgreich ein YOLO26-Modell auf Amazon SageMaker Endpoints bereitgestellt und getestet. Dieser Prozess vermittelt dir nicht nur praktische Erfahrung im Einsatz von AWS-Diensten für die Bereitstellung von Machine Learning-Modellen, sondern legt auch den Grundstein für die Bereitstellung anderer fortschrittlicher Modelle in der Zukunft.

Zusammenfassung#

Dieser Leitfaden hat dich Schritt für Schritt durch die Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints mithilfe von AWS CloudFormation und dem AWS Cloud Development Kit (CDK) geführt. Der Prozess umfasst das Klonen des notwendigen GitHub-Repositorys, das Einrichten der CDK-Umgebung, das Bereitstellen des Modells mithilfe von AWS-Diensten und das Testen seiner Leistung auf SageMaker.

Weitere technische Details findest du in diesem Artikel im AWS Machine Learning Blog. Du kannst auch einen Blick in die offizielle Amazon SageMaker Documentation werfen, um weitere Einblicke in verschiedene Features und Funktionen zu erhalten.

Möchtest du mehr über verschiedene YOLO26-Integrationen erfahren? Besuche die Seite des Ultralytics-Integrationsleitfadens, um zusätzliche Tools und Funktionen zu entdecken, die deine Machine-Learning-Projekte verbessern können.

FAQ#