Link to this sectionEin Leitfaden für die Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints#

Die Bereitstellung fortschrittlicher Computer Vision-Modelle wie Ultralytics' YOLO26 auf Amazon SageMaker Endpoints eröffnet eine Vielzahl von Möglichkeiten für unterschiedliche 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 in Amazon SageMaker integriert wird, einen 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 erfährst die Grundlagen zur Vorbereitung deiner AWS-Umgebung, zur geeigneten Konfiguration des Modells und zur Verwendung von Tools wie AWS CloudFormation und dem AWS Cloud Development Kit (CDK) für die Bereitstellung.

Link to this sectionAmazon 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 für die Handhabung verschiedener 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 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. Die Funktionen umfassen zudem Datenlabeling, Workflow-Management und Leistungsanalysen.

Link to this sectionBereitstellung 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.

Link to this sectionSchritt 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: Falls noch nicht geschehen, lade das AWS Command Line Interface (CLI) herunter, installiere es und konfiguriere es mit deinen Kontodaten. Befolge für die Installation die AWS CLI-Anweisungen.

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

• Ausreichendes Service-Kontingent: 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 Notebook-Instanznutzung. Jedes davon erfordert mindestens einen Kontingentwert. Wenn deine aktuellen Kontingente unter diesem Bedarf liegen, ist es wichtig, eine Erhöhung für jedes zu beantragen. Du kannst eine Kontingenterhöhung beantragen, indem du den detaillierten Anweisungen in der AWS Service Quotas-Dokumentation folgst.

Link to this sectionSchritt 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

Link to this sectionSchritt 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

Link to this sectionSchritt 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

Link to this sectionSchritt 5: Bereitstellung des YOLO-Modells#

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

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.

Link to this sectionSchritt 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: Befolge die Anweisungen innerhalb des Notebooks, um den bereitgestellten SageMaker-Endpunkt zu testen. Dies beinhaltet das Senden eines Bildes an den Endpunkt und das Ausführen von Inferenzen. Danach zeichnest du die Ausgabe auf, 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.

Link to this sectionSchritt 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 mithilfe von 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.

Link to this sectionZusammenfassung#

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 dir auch die offizielle Amazon SageMaker-Dokumentation ansehen, um weitere Einblicke in verschiedene Funktionen und Möglichkeiten zu erhalten.

Bist du daran interessiert, mehr über verschiedene YOLO26-Integrationen zu erfahren? Besuche die Integrations-Seite von Ultralytics, um zusätzliche Tools und Fähigkeiten zu entdecken, die deine Machine Learning-Projekte verbessern können.

Link to this sectionFAQ#

Link to this sectionWie 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. Richte deine AWS-Umgebung ein: Stelle sicher, dass du ein AWS-Konto hast, IAM-Rollen mit den notwendigen Berechtigungen besitzt und die AWS CLI konfiguriert ist. Installiere das AWS CDK, falls noch nicht geschehen (siehe die 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-Stapel bereit, führe das Bootstrapping der Umgebung durch.

   cdk synth
   cdk bootstrap
   cdk deploy

Weitere Details findest du im Dokumentationsabschnitt.

Link to this sectionWas sind die Voraussetzungen für die Bereitstellung von YOLO26 auf Amazon SageMaker?#

Um YOLO26 auf Amazon SageMaker bereitzustellen, stelle sicher, dass du die folgenden 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: Installiertes und konfiguriertes AWS Command Line Interface (Installationsanleitung für AWS CLI).
4. AWS CDK: Installiertes AWS Cloud Development Kit (CDK-Einrichtungsanleitung).
5. Service-Kontingente: Ausreichende Kontingente für ml.m5.4xlarge-Instanzen für Endpunkt- und Notebook-Nutzung (Kontingenterhöhung beantragen).

Für eine detaillierte Einrichtung siehe diesen Abschnitt.

Link to this sectionWarum 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 Echtzeit-Inferenz-Anforderungen hilfreich ist.
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 optimierte Bereitstellungsprozesse.
4. Leistung: Nutze die leistungsstarke Infrastruktur von Amazon SageMaker, um Inferenzaufgaben in großem Maßstab effizient auszuführen.

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

Link to this sectionKann 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 ändern: Suche und passe die output_fn-Funktion in der inference.py-Datei 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 mithilfe der bereitgestellten Jupyter-Notebooks (1_DeployEndpoint.ipynb) erneut bereitstellst, um diese Änderungen einzubeziehen.

Siehe die detaillierten Schritte für die Bereitstellung des modifizierten Modells.

Link to this sectionWie kann ich das bereitgestellte YOLO26-Modell auf Amazon SageMaker testen?#

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

1. Öffne das Test-Notebook: Suche das Notebook 2_TestEndpoint.ipynb in der SageMaker Jupyter-Umgebung.
2. Führe das Notebook aus: Befolge die Anweisungen im Notebook, um ein Bild an den Endpunkt zu senden, Inferenzen durchzuführen und Ergebnisse anzuzeigen.
3. Ergebnisse visualisieren: Nutze integrierte Plotting-Funktionen, um Leistungsmetriken zu visualisieren, wie z. B. Begrenzungsrahmen (BBox) um erkannte Objekte.

Für umfassende Testanweisungen besuche den Testabschnitt.