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 Machine Learning-Anwendungen. Der Schlüssel zur effektiven Nutzung dieser Modelle liegt im Verständnis ihrer Einrichtung, Konfiguration und Bereitstellungsprozesse. YOLO26 wird noch leistungsfähiger, wenn es nahtlos mit Amazon SageMaker integriert wird, einem robusten und skalierbaren Machine Learning-Dienst von AWS.

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

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 Tools für verschiedene Aspekte von Machine Learning-Workflows. Dazu gehören automatisierte Funktionen zur Modelloptimierung, Optionen für das Training von Modellen im großen Maßstab sowie unkomplizierte Methoden für die Bereitstellung in der Produktion. SageMaker unterstützt gängige Machine Learning-Frameworks und bietet die nötige Flexibilität für diverse Projekte. Die Funktionen umfassen zudem Datenlabeling, Workflow-Management und Leistungsanalysen.

Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints

Durch die Bereitstellung von YOLO26 auf Amazon SageMaker kannst du dessen verwaltete Umgebung für Echtzeit-Inferenz nutzen und von Funktionen wie Autoscaling profitieren. Schau dir die AWS-Architektur unten an.

Schritt 1: Einrichtung deiner AWS-Umgebung

Stelle zuerst sicher, dass du die folgenden Voraussetzungen erfüllt hast:

• 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: Falls noch nicht geschehen, lade die AWS Command Line Interface (CLI) herunter, installiere sie und konfiguriere sie mit deinen Kontodaten. Folge den AWS CLI-Anweisungen für die Installation.

• AWS CDK: Falls noch nicht geschehen, installiere das AWS Cloud Development Kit (CDK), das für die Skripterstellung der Bereitstellung verwendet wird. Folge den AWS CDK-Anweisungen für die Installation.

• Ausreichende Service-Kontingente: Bestätige, dass du über ausreichende Kontingente für zwei separate Ressourcen in Amazon SageMaker verfügst: eines für ml.m5.4xlarge für die Endpunktnutzung und ein weiteres für ml.m5.4xlarge für die Nutzung von Notebook-Instanzen. Jedes davon erfordert einen Mindestwert von eins. Wenn deine aktuellen Kontingente unter diesem Wert liegen, ist es wichtig, eine Erhöhung für jedes zu beantragen. Du kannst eine Kontingenterhöhung beantragen, indem du die detaillierten Anweisungen in der AWS Service Quotas-Dokumentation befolgst.

Schritt 2: Klonen des YOLO26 SageMaker-Repositorys

Der nächste Schritt ist das Klonen des speziellen AWS-Repositorys, 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 Repository host-yolov8-on-sagemaker-endpoint zu klonen:

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

• Zum geklonten Verzeichnis navigieren: Wechsle in das Verzeichnis des geklonten Repositorys:

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

Schritt 3: Einrichtung der CDK-Umgebung

Jetzt, da du den erforderlichen 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

• 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 hast:

  pip install --upgrade aws-cdk-lib

Schritt 4: Erstellung des AWS CloudFormation-Stacks

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

  cdk synth

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

  cdk bootstrap

• Stack bereitstellen: Dies erstellt die erforderlichen AWS-Ressourcen und stellt dein Modell bereit:

  cdk deploy

Schritt 5: Bereitstellung des YOLO-Modells

Bevor du in die Bereitstellungsanweisungen eintauchst, schau dir unbedingt die Auswahl der von Ultralytics angebotenen YOLO26-Modelle an. Dies hilft dir bei der Auswahl des passendsten Modells für deine Projektanforderungen.

Nachdem du den AWS CloudFormation-Stack erstellt hast, ist der nächste Schritt die Bereitstellung von YOLO26.

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

• inference.py aufrufen und ändern: 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 im Verzeichnis sm-notebook. Folge den Anweisungen im Notebook und führe die Zellen aus, um das YOLO26-Modell herunterzuladen, es mit dem aktualisierten Inferenz-Code zu verpacken und es 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

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

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

• Test-Notebook ausführen: Folge den Anweisungen im Notebook, um den bereitgestellten SageMaker-Endpunkt zu testen. Dies beinhaltet das Senden eines Bildes an den Endpunkt und das Ausführen von Inferenzen. Danach wirst du die Ausgabe plotten, um die Leistung und Genauigkeit des Modells zu visualisieren, wie unten dargestellt.

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

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 regelmäßig die Leistung und den Status deines SageMaker-Endpunkts mit Amazon CloudWatch.

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

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

Zusammenfassung

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

Für weitere technische Details lies diesen Artikel im AWS Machine Learning Blog. Du kannst auch die offizielle Amazon SageMaker-Dokumentation für weitere Einblicke in verschiedene Features und Funktionen besuchen.

Interessierst du dich für weitere Informationen zu verschiedenen YOLO26-Integrationen? Besuche die Ultralytics-Integrationsleitfaden-Seite, um zusätzliche Tools und Fähigkeiten zu entdecken, die deine Machine Learning-Projekte verbessern können.

FAQ

Wie stelle ich das Ultralytics YOLO26-Modell auf Amazon SageMaker Endpoints bereit?

Um das Ultralytics YOLO26-Modell auf Amazon SageMaker Endpoints bereitzustellen, befolge diese Schritte:

1. Einrichtung der AWS-Umgebung: Stelle sicher, dass du ein AWS-Konto, IAM-Rollen mit den erforderlichen Berechtigungen und die konfigurierte AWS CLI hast. Installiere das AWS CDK, falls noch nicht geschehen (siehe AWS CDK-Anweisungen).
2. Klonen des YOLO26 SageMaker-Repositorys:

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

3. Einrichtung der CDK-Umgebung: Erstelle eine virtuelle Python-Umgebung, aktiviere sie, installiere Abhängigkeiten und aktualisiere die AWS CDK-Bibliothek.

   python3 -m venv .venv
   source .venv/bin/activate
   pip3 install -r requirements.txt
   pip install --upgrade aws-cdk-lib

4. Bereitstellung mit AWS CDK: Synthetisiere und stelle den CloudFormation-Stack bereit, führe ein Bootstrap der Umgebung durch.

   cdk synth
   cdk bootstrap
   cdk deploy

Weitere Details findest du im Dokumentationsabschnitt.

Was sind die Voraussetzungen für die Bereitstellung von YOLO26 auf Amazon SageMaker?

Um YOLO26 auf Amazon SageMaker bereitzustellen, stelle sicher, dass du folgende Voraussetzungen erfüllst:

1. AWS-Konto: Aktives AWS-Konto (hier registrieren).
2. IAM-Rollen: Konfigurierte IAM-Rollen mit Berechtigungen für SageMaker, CloudFormation und Amazon S3.
3. AWS CLI: Installierte und konfigurierte AWS Command Line Interface (AWS CLI-Installationsanleitung).
4. AWS CDK: Installiertes AWS Cloud Development Kit (CDK-Einrichtungsanleitung).
5. Service-Kontingente: Ausreichende Kontingente für ml.m5.4xlarge-Instanzen sowohl für die Endpunkt- als auch für die Notebook-Nutzung (Kontingenterhöhung beantragen).

Für eine detaillierte Einrichtung siehe diesen Abschnitt.

Warum sollte ich Ultralytics YOLO26 auf Amazon SageMaker verwenden?

Die Verwendung von Ultralytics YOLO26 auf Amazon SageMaker bietet mehrere Vorteile:

1. Skalierbarkeit und Verwaltung: SageMaker bietet eine verwaltete Umgebung mit Funktionen wie Autoscaling, was bei Anforderungen an Echtzeit-Inferenz hilft.
2. Integration mit AWS-Diensten: Nahtlose Integration mit anderen AWS-Diensten wie S3 für die Datenspeicherung, CloudFormation für Infrastructure as Code und CloudWatch für die Überwachung.
3. Einfache Bereitstellung: Vereinfachte Einrichtung mittels AWS CDK-Skripten und optimierten Bereitstellungsprozessen.
4. Leistung: Nutze die leistungsstarke Infrastruktur von Amazon SageMaker, um Inferenzaufgaben im großen Maßstab effizient auszuführen.

Erfahre mehr über die Vorteile der Nutzung von SageMaker im Einführungsabschnitt.

Kann ich die Inferenzlogik für YOLO26 auf Amazon SageMaker anpassen?

Ja, du kannst die Inferenzlogik für YOLO26 auf Amazon SageMaker anpassen:

1. inference.py modifizieren: Suche und passe die Funktion output_fn in der Datei inference.py an, um Ausgabeformate anzupassen.

   import json
   
   def output_fn(prediction_output):
       """Formats model outputs as JSON string, extracting attributes like boxes, masks, keypoints."""
       infer = {}
       for result in prediction_output:
           if result.boxes is not None:
               infer["boxes"] = result.boxes.numpy().data.tolist()
           # Add more processing logic if necessary
       return json.dumps(infer)

2. Aktualisiertes Modell bereitstellen: Stelle sicher, dass du das Modell erneut mithilfe der bereitgestellten Jupyter-Notebooks (1_DeployEndpoint.ipynb) bereitstellst, um diese Änderungen zu übernehmen.

Siehe die detaillierten Schritte zur Bereitstellung des modifizierten Modells.

Wie kann ich das bereitgestellte YOLO26-Modell auf Amazon SageMaker testen?

Um das bereitgestellte YOLO26-Modell auf Amazon SageMaker zu testen:

1. Test-Notebook öffnen: Suche das Notebook 2_TestEndpoint.ipynb in der SageMaker Jupyter-Umgebung.
2. Notebook ausführen: Folge den Anweisungen im Notebook, um ein Bild an den Endpunkt zu senden, eine Inferenz durchzuführen und die Ergebnisse anzuzeigen.
3. Ergebnisse visualisieren: Nutze die integrierten Plotting-Funktionen, um Leistungskennzahlen zu visualisieren, wie z.B. Begrenzungsrahmen um erkannte Objekte.

Für umfassende Testanweisungen besuche den Test-Abschnitt.