Ein Leitfaden zur Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints#

Die Bereitstellung fortschrittlicher Computer-Vision-Modelle wie Ultralytics' YOLO26 auf Amazon SageMaker Endpoints eröffnet vielfältige Möglichkeiten für verschiedene Anwendungen des maschinellen Lernens. Für die effektive Nutzung dieser Modelle ist es entscheidend, ihre Einrichtung, Konfiguration und Bereitstellung zu verstehen. YOLO26 wird noch leistungsfähiger, wenn es nahtlos mit Amazon SageMaker integriert wird, einem robusten und skalierbaren Dienst für maschinelles Lernen von AWS.

Dieser Leitfaden führt dich Schritt für Schritt durch die Bereitstellung von YOLO26-PyTorch-Modellen auf Amazon SageMaker Endpoints. Du lernst die Grundlagen der Einrichtung deiner AWS-Umgebung, der passenden Konfiguration des Modells und der Verwendung von Werkzeugen wie AWS CloudFormation und dem AWS Cloud Development Kit (CDK) für die Bereitstellung.

Amazon SageMaker#

Amazon SageMaker ist ein Dienst für maschinelles Lernen von Amazon Web Services (AWS), der das Erstellen, Trainieren und Bereitstellen von Modellen des maschinellen Lernens vereinfacht. Er bietet eine breite Palette von Werkzeugen für verschiedene Aspekte von Arbeitsabläufen des maschinellen Lernens. Dazu gehören automatische Funktionen zur Abstimmung von Modellen, Optionen für das Training von Modellen in großem Umfang und einfache Methoden, um Modelle in einer Produktionsumgebung bereitzustellen. SageMaker unterstützt beliebte Frameworks für maschinelles Lernen und bietet so die nötige Flexibilität für vielfältige Projekte. Zu den Funktionen gehören außerdem Datenbeschriftung, Workflow-Verwaltung und Leistungsanalyse.

YOLO26 auf Amazon SageMaker Endpoints bereitstellen#

Wenn du YOLO26 auf Amazon SageMaker bereitstellst, kannst du die verwaltete Umgebung für Echtzeit-Inferenz nutzen und von Funktionen wie der automatischen Skalierung profitieren. Sieh dir unten die AWS-Architektur an.

Schritt 1: Deine AWS-Umgebung einrichten#

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

• Ein AWS-Konto: Falls du noch keines hast, erstelle 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. Die Richtlinien dieser Rolle müssen den Zugriff auf diese Dienste erlauben.

• AWS CLI: Falls noch nicht installiert, lade die AWS-Befehlszeilenschnittstelle (CLI) herunter, installiere sie und richte sie mit deinen Kontodaten ein. Folge zur Installation den Anweisungen für AWS CLI.

• AWS CDK: Falls noch nicht installiert, installiere das AWS Cloud Development Kit (CDK), das zum Erstellen der Bereitstellungsskripte verwendet wird. Folge zur Installation den Anweisungen für AWS CDK.

• Ausreichendes Servicekontingent: Vergewissere dich, dass du in Amazon SageMaker über ausreichende Kontingente für zwei separate Ressourcen verfügst: eines für ml.m5.4xlarge zur Nutzung mit Endpoints und ein weiteres für ml.m5.4xlarge zur Nutzung mit Notebook-Instanzen. Für jede dieser Ressourcen ist mindestens ein Kontingentwert erforderlich. Liegen deine aktuellen Kontingente unter diesem Wert, musst du für jede Ressource eine Erhöhung beantragen. Eine Kontingenterhöhung kannst du gemäß den ausführlichen Anweisungen in der Dokumentation zu AWS Service Quotas beantragen.

Schritt 2: Das YOLO26-SageMaker-Repository klonen#

Als Nächstes klonst du das spezielle AWS-Repository mit den Ressourcen zur Bereitstellung von YOLO26 auf SageMaker. 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 Repository host-yolov8-on-sagemaker-endpoint zu klonen:

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

• Zum geklonten Verzeichnis wechseln: Wechsle in das geklonte Repository:

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

Schritt 3: Die CDK-Umgebung einrichten#

Nachdem du den erforderlichen Code bereitgestellt hast, richtest du deine Umgebung für die Bereitstellung mit AWS CDK ein.

• Eine virtuelle Python-Umgebung erstellen: Dadurch werden deine Python-Umgebung und Abhängigkeiten isoliert. Führe Folgendes aus:

  python3 -m venv .venv

• Die virtuelle Umgebung aktivieren:

  source .venv/bin/activate

• Abhängigkeiten installieren: 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 verwendest:

  pip install --upgrade aws-cdk-lib

Schritt 4: Den AWS-CloudFormation-Stack erstellen#

• Die CDK-Anwendung synthetisieren: Erzeuge aus deinem CDK-Code eine AWS-CloudFormation-Vorlage:

  cdk synth

• Die CDK-Anwendung bootstrappen: Bereite deine AWS-Umgebung für die Bereitstellung mit CDK vor:

  cdk bootstrap

• Den Stack bereitstellen: Dadurch werden die erforderlichen AWS-Ressourcen erstellt und dein Modell bereitgestellt:

  cdk deploy

Schritt 5: Das YOLO-Modell bereitstellen#

Sieh dir vor Beginn der Bereitstellungsanleitung unbedingt die Auswahl an YOLO26-Modellen von Ultralytics an. So findest du das am besten zu den Anforderungen deines Projekts passende Modell.

Nachdem du den AWS-CloudFormation-Stack erstellt hast, stellst du als Nächstes YOLO26 bereit.

• Notebook-Instanz öffnen: Öffne die AWS-Konsole und rufe den Amazon-SageMaker-Dienst auf. Wähle im Dashboard „Notebook-Instances“ aus und suche anschließend die Notebook-Instanz, die von deinem CDK-Bereitstellungsskript erstellt wurde. Öffne die Notebook-Instanz, um auf die Jupyter-Umgebung zuzugreifen.

• inference.py aufrufen und bearbeiten: Suche nach dem Öffnen der SageMaker-Notebook-Instanz in Jupyter die Datei inference.py. Bearbeite die Funktion output_fn in inference.py wie unten gezeigt und speichere deine Änderungen am Skript. Achte dabei darauf, dass keine Syntaxfehler vorhanden sind.

  import json
  
  def output_fn(prediction_output, content_type):
      """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)

• Endpoint mit 1_DeployEndpoint.ipynb bereitstellen: Öffne in der Jupyter-Umgebung das Notebook 1_DeployEndpoint.ipynb im Verzeichnis sm-notebook. Folge den Anweisungen im Notebook und führe die Zellen aus, um das YOLO26-Modell herunterzuladen, es zusammen mit dem aktualisierten Inferenzcode zu paketieren und in einen Amazon-S3-Bucket hochzuladen. Das Notebook führt dich durch die Erstellung und Bereitstellung eines SageMaker-Endpoints für das YOLO26-Modell.

Schritt 6: Deine Bereitstellung testen#

Nachdem du dein YOLO26-Modell bereitgestellt hast, solltest du seine Leistung und Funktionsweise unbedingt testen.

• Test-Notebook öffnen: Suche in derselben Jupyter-Umgebung das Notebook 2_TestEndpoint.ipynb im Verzeichnis sm-notebook und öffne es.

• Test-Notebook ausführen: Folge den Anweisungen im Notebook, um den bereitgestellten SageMaker-Endpoint zu testen. Dazu sendest du ein Bild an den Endpoint und führst Inferenzen aus. Anschließend erstellst du wie unten gezeigt ein Diagramm der Ausgabe, um die Leistung und Genauigkeit des Modells zu visualisieren.

• Ressourcen bereinigen: Das Test-Notebook führt dich auch durch die Bereinigung des Endpoints und des gehosteten Modells. Dieser Schritt ist wichtig, um Kosten und Ressourcen effizient zu verwalten, insbesondere wenn du das bereitgestellte Modell nicht sofort verwenden möchtest.

Schritt 7: Überwachung und Verwaltung#

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

• Mit Amazon CloudWatch überwachen: Überprüfe regelmäßig die Leistung und den Zustand deines SageMaker-Endpoints mit Amazon CloudWatch.

• Den Endpoint verwalten: Verwende die SageMaker-Konsole für die laufende Verwaltung des Endpoints. Dazu gehören die Skalierung, Aktualisierung oder erneute Bereitstellung des Modells nach Bedarf.

Wenn du diese Schritte abgeschlossen hast, hast du ein YOLO26-Modell erfolgreich auf Amazon SageMaker Endpoints bereitgestellt und getestet. Dabei sammelst du praktische Erfahrung mit AWS-Diensten für die Bereitstellung von Machine-Learning-Modellen und schaffst zugleich die Grundlage für die Bereitstellung weiterer fortschrittlicher Modelle in der Zukunft.

Zusammenfassung#

Diese Anleitung führt dich Schritt für Schritt durch die Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints mithilfe von AWS CloudFormation und dem AWS-Cloud-Entwicklungskit (CDK). Dazu gehören das Klonen des erforderlichen GitHub-Repositorys, das Einrichten der CDK-Umgebung, die Bereitstellung des Modells mit AWS-Diensten und das Testen seiner Leistung auf SageMaker.

Weitere technische Details findest du in diesem Artikel im AWS Machine Learning Blog. Weitere Informationen zu den verschiedenen Funktionen und Möglichkeiten findest du auch in der offiziellen Amazon-SageMaker-Dokumentation.

Möchtest du mehr über verschiedene YOLO26-Integrationen erfahren? Besuche die Ultralytics-Seite mit dem Integrationsleitfaden, um weitere Tools und Möglichkeiten kennenzulernen, die deine Machine-Learning-Projekte verbessern können.

Häufig gestellte Fragen#