Leitfaden zur Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints#

Die Bereitstellung fortschrittlicher Computer-Vision-Modelle wie Ultralytics' YOLO26 auf Amazon SageMaker Endpoints eröffnet zahlreiche Möglichkeiten für verschiedene Anwendungen des maschinellen Lernens. Der Schlüssel zur effektiven Nutzung dieser Modelle liegt im Verständnis ihrer Einrichtung, Konfiguration und Bereitstellung. YOLO26 wird noch leistungsfähiger, wenn es nahtlos in Amazon SageMaker integriert wird, einen 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 Vorbereitung deiner AWS-Umgebung, der passenden Konfiguration des Modells und der Verwendung von Tools wie AWS CloudFormation und dem AWS Cloud Development Kit (CDK) für die Bereitstellung kennen.

Amazon SageMaker#

Amazon SageMaker ist ein Dienst für maschinelles Lernen von Amazon Web Services (AWS), der die Entwicklung, das Training und die Bereitstellung von Modellen für maschinelles Lernen vereinfacht. Er bietet eine breite Palette von Tools zur Bearbeitung verschiedener Aspekte von Arbeitsabläufen des maschinellen Lernens. Dazu gehören automatisierte Funktionen zur Feinabstimmung von Modellen, Optionen für das Training von Modellen in großem Maßstab sowie einfache Methoden zur Bereitstellung von Modellen in Produktionsumgebungen. SageMaker unterstützt gängige Frameworks für maschinelles Lernen und bietet damit die nötige Flexibilität für vielfältige Projekte. Zu den Funktionen gehören außerdem Datenkennzeichnung, Workflowverwaltung und Leistungsanalyse.

YOLO26 auf Amazon SageMaker Endpoints bereitstellen#

Wenn du YOLO26 auf Amazon SageMaker bereitstellst, kannst du die verwaltete Umgebung für Inferenz in Echtzeit sowie Funktionen wie automatische Skalierung nutzen. Sieh dir die AWS-Architektur unten an.

Schritt 1: Deine AWS-Umgebung einrichten#

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

• Ein AWS-Konto: Wenn 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 Richtlinien enthalten, die den Zugriff auf diese Dienste erlauben.

• AWS CLI: Falls noch nicht geschehen, lade die AWS-Befehlszeilenschnittstelle (CLI) herunter, installiere sie und konfiguriere sie mit deinen Kontodaten. Befolge zur Installation die Anweisungen für AWS CLI.

• AWS CDK: Falls noch nicht geschehen, installiere das AWS Cloud Development Kit (CDK), das zum Skripten der Bereitstellung verwendet wird. Befolge zur Installation die Anweisungen für AWS CDK.

• Ausreichende Dienstkontingente: Vergewissere dich, dass du in Amazon SageMaker über ausreichende Kontingente für zwei getrennte Ressourcen verfügst: eines für ml.m5.4xlarge zur Nutzung von Endpoints und ein weiteres für ml.m5.4xlarge zur Nutzung von Notebook-Instanzen. Für jede dieser Ressourcen ist mindestens ein Kontingentwert erforderlich. Liegen deine aktuellen Kontingente unter dieser Anforderung, solltest 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 anfordern.

Schritt 2: Das YOLO26-SageMaker-Repository klonen#

Als Nächstes klonst du das AWS-Repository, das die Ressourcen für die Bereitstellung von YOLO26 auf SageMaker enthält. Dieses auf GitHub gehostete Repository umfasst 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 deinem Terminal in das geklonte Repository:

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

Schritt 3: Die CDK-Umgebung einrichten#

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

• Eine virtuelle Python-Umgebung erstellen: Dadurch werden deine Python-Umgebung und ihre 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

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

  pip install --upgrade aws-cdk-lib

Schritt 4: Den AWS-CloudFormation-Stack erstellen#

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

  cdk synth

• Die CDK-Anwendung bootstrappen: Bereite deine AWS-Umgebung für die CDK-Bereitstellung 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#

Bevor du mit den Anweisungen zur Bereitstellung beginnst, sieh dir unbedingt die verschiedenen von Ultralytics angebotenen YOLO26-Modelle an. So kannst du das für deine Projektanforderungen am besten geeignete Modell auswählen.

Nach der Erstellung des AWS-CloudFormation-Stacks besteht der nächste Schritt darin, YOLO26 bereitzustellen.

• Die Notebook-Instanz öffnen: Öffne die AWS-Konsole und navigiere zum Dienst Amazon SageMaker. 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.

• Auf inference.py zugreifen und die Datei ändern: 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. Stelle dabei sicher, dass keine Syntaxfehler vorhanden sind.

  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)

• Den Endpoint mit 1_DeployEndpoint.ipynb bereitstellen: Öffne in der Jupyter-Umgebung das Notebook 1_DeployEndpoint.ipynb im Verzeichnis sm-notebook. Befolge die 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 dein YOLO26-Modell bereitgestellt wurde, ist es wichtig, seine Leistung und Funktionalität zu testen.

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

• Das Test-Notebook ausführen: Befolge die 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 eine grafische Darstellung der Ausgabe, um die Leistung und Genauigkeit des Modells zu visualisieren.

• Ressourcen bereinigen: Das Test-Notebook führt dich außerdem 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 zur laufenden Verwaltung des Endpoints. Dazu gehören je nach Bedarf die Skalierung, Aktualisierung oder erneute Bereitstellung des Modells.

Wenn du diese Schritte abschließt, hast du ein YOLO26-Modell erfolgreich auf Amazon SageMaker Endpoints bereitgestellt und getestet. Dieser Prozess vermittelt dir nicht nur praktische Erfahrung mit AWS-Diensten für die Bereitstellung von Anwendungen des maschinellen Lernens, sondern schafft auch die Grundlage für die zukünftige Bereitstellung weiterer fortschrittlicher Modelle.

Zusammenfassung#

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

Weitere technische Informationen findest du in diesem Artikel im AWS Machine Learning Blog. Weitere Einblicke in verschiedene Funktionen und Möglichkeiten bietet außerdem die offizielle Dokumentation zu Amazon SageMaker.

Möchtest du mehr über verschiedene YOLO26-Integrationen erfahren? Besuche die Übersichtsseite zu den Ultralytics-Integrationen, um weitere Tools und Funktionen zu entdecken, die deine Projekte im Bereich maschinelles Lernen erweitern können.

FAQ#