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 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 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 Sie Schritt für Schritt durch den Prozess der Bereitstellung von YOLO26 PyTorch-Modellen auf Amazon SageMaker Endpoints. Sie lernen die Grundlagen der Vorbereitung Ihrer AWS-Umgebung, der entsprechenden Modellkonfiguration und der Verwendung von Tools wie AWS CloudFormation und dem AWS Cloud Development Kit (CDK) für die Bereitstellung.

Amazon SageMaker

Architektur der Amazon SageMaker ML-Plattform

Amazon SageMaker ist ein Machine-Learning-Service von Amazon Web Services (AWS), der den Prozess des Erstellens, Trainierens und Bereitstellens von Machine-Learning-Modellen vereinfacht. Er bietet eine breite Palette von Tools zur Handhabung verschiedener Aspekte von Machine-Learning-Workflows. Dazu gehören automatisierte Funktionen zur Optimierung von Modellen, Optionen zum Trainieren von Modellen im großen Maßstab und unkomplizierte Methoden zur Bereitstellung von Modellen in der Produktion. SageMaker unterstützt gängige Machine-Learning-Frameworks und bietet die Flexibilität, die für vielfältige Projekte erforderlich ist. Seine Funktionen umfassen auch Datenkennzeichnung, Workflow-Management und Leistungsanalyse.

Bereitstellung von YOLO26 auf Amazon SageMaker Endpoints

Die Bereitstellung von YOLO26 auf Amazon SageMaker ermöglicht es Ihnen, dessen verwaltete Umgebung für die Echtzeit-Inferenz zu nutzen und Funktionen wie Autoscaling zu verwenden. Werfen Sie einen Blick auf die untenstehende AWS-Architektur.

AWS SageMaker YOLO

Schritt 1: Richten Sie Ihre AWS-Umgebung ein

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

Ein AWS-Konto: Wenn Sie noch keines haben, registrieren Sie sich für ein AWS-Konto.
Konfigurierte IAM-Rollen: Sie benötigen eine IAM-Rolle mit den erforderlichen Berechtigungen für Amazon SageMaker, AWS CloudFormation und Amazon S3. Diese Rolle sollte Richtlinien haben, die es ihr ermöglichen, auf diese Dienste zuzugreifen.
AWS CLI: Falls noch nicht installiert, laden Sie die AWS Command Line Interface (CLI) herunter, installieren Sie sie und konfigurieren Sie sie mit Ihren Kontodetails. Befolgen Sie die AWS CLI-Anweisungen für die Installation.
AWS CDK: Falls noch nicht installiert, installieren Sie das AWS Cloud Development Kit (CDK), das für die Skripterstellung der Bereitstellung verwendet wird. Befolgen Sie die AWS CDK-Anweisungen für die Installation.
Ausreichendes Servicekontingent: Stellen Sie sicher, dass Sie über ausreichende Kontingente für zwei separate Ressourcen in Amazon SageMaker verfügen: 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. Jede davon erfordert mindestens einen Kontingentwert. Wenn Ihre aktuellen Kontingente unter diesem Bedarf liegen, ist es wichtig, eine Erhöhung für jedes Kontingent zu beantragen. Sie können eine Kontingenterhöhung beantragen, indem Sie die detaillierten Anweisungen im AWS Service Quotas Dokumentation.

Schritt 2: Klonen Sie das YOLO26 SageMaker Repository

Der nächste Schritt ist das Klonen des spezifischen AWS-Repositorys, das die Ressourcen für die Bereitstellung von YOLO26 auf SageMaker enthält. Dieses auf GitHub gehostete Repository umfasst die notwendigen CDK-Skripte und Konfigurationsdateien.

Klonen Sie das GitHub-Repository: Führen Sie den folgenden Befehl in Ihrem 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
```
Navigieren Sie zum geklonten Verzeichnis: Wechseln Sie mit dem Befehl cd in das geklonte Repository:
```
cd host-yolov8-on-sagemaker-endpoint/yolov8-pytorch-cdk
```

Schritt 3: Die CDK-Umgebung einrichten

Nachdem Sie nun den notwendigen Code haben, richten Sie Ihre Umgebung für die Bereitstellung mit AWS CDK ein.

Erstellen Sie eine virtuelle Python-Umgebung: Dies isoliert Ihre Python-Umgebung und -Abhängigkeiten. Ausführen:
```
python3 -m venv .venv
```
Die virtuelle Umgebung aktivieren:
```
source .venv/bin/activate
```
Abhängigkeiten installieren: Installieren Sie die erforderlichen Python-Abhängigkeiten für das Projekt:
```
pip3 install -r requirements.txt
```
AWS CDK Bibliothek aktualisieren: Stellen Sie sicher, dass Sie die neueste Version der AWS CDK Bibliothek haben:
```
pip install --upgrade aws-cdk-lib
```

Schritt 4: Den AWS CloudFormation Stack erstellen

Synthetisieren der CDK-Anwendung: Generieren Sie die AWS CloudFormation-Vorlage aus Ihrem CDK-Code:
```
cdk synth
```
Bootstrap der CDK-Anwendung: Bereiten Sie Ihre AWS-Umgebung für die CDK-Bereitstellung vor:
```
cdk bootstrap
```
Stack bereitstellen: Dadurch werden die erforderlichen AWS-Ressourcen erstellt und Ihr Modell bereitgestellt:
```
cdk deploy
```

Schritt 5: Das YOLO-Modell bereitstellen

Bevor Sie sich mit den Bereitstellungsanweisungen befassen, sollten Sie sich die Palette der von Ultralytics angebotenen YOLO26-Modelle ansehen. Dies wird Ihnen helfen, das am besten geeignete Modell für Ihre Projektanforderungen auszuwählen.

Nachdem der AWS CloudFormation Stack erstellt wurde, ist der nächste Schritt die Bereitstellung von YOLO26.

Notebook-Instanz öffnen: Gehen Sie zur AWS-Konsole und navigieren Sie zum Amazon SageMaker-Service. Wählen Sie im Dashboard "Notebook-Instanzen" aus und suchen Sie dann die Notebook-Instanz, die von Ihrem CDK-Bereitstellungsskript erstellt wurde. Öffnen Sie die Notebook-Instanz, um auf die Jupyter-Umgebung zuzugreifen.

Zugriff und Änderung von inference.py: Nachdem Sie die SageMaker-Notebook-Instanz in Jupyter geöffnet haben, suchen Sie die Datei inference.py. Bearbeiten Sie die Funktion output_fn in inference.py wie unten gezeigt und speichern Sie Ihre Änderungen am Skript, wobei Sie sicherstellen, 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)

Bereitstellen des Endpunkts mit 1_DeployEndpoint.ipynb: Öffnen Sie in der Jupyter-Umgebung das Notebook 1_DeployEndpoint.ipynb im Verzeichnis sm-notebook. Befolgen Sie die Anweisungen im Notebook und führen Sie die Zellen aus, um das YOLO26-Modell herunterzuladen, es mit dem aktualisierten Inferenzcode zu paketieren und in einen Amazon S3-Bucket hochzuladen. Das Notebook führt Sie durch die Erstellung und Bereitstellung eines SageMaker-Endpunkts für das YOLO26-Modell.

Schritt 6: Testen Ihrer Bereitstellung

Nachdem Ihr YOLO26-Modell bereitgestellt wurde, ist es wichtig, dessen Leistung und Funktionalität zu testen.

Test-Notebook öffnen: Suchen und öffnen Sie in derselben Jupyter-Umgebung das Notebook 2_TestEndpoint.ipynb, das sich ebenfalls im Verzeichnis sm-notebook befindet.
Test-Notebook ausführen: Befolgen Sie die Anweisungen im Notebook, um den bereitgestellten SageMaker-Endpunkt zu testen. Dies beinhaltet das Senden eines Bildes an den Endpunkt und das Ausführen von Inferenzvorgängen. Anschließend plotten Sie die Ausgabe, um die Leistung und Genauigkeit des Modells zu visualisieren, wie unten dargestellt.

Testergebnisse YOLO26

Ressourcen bereinigen: Das Test-Notebook führt Sie 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 Sie nicht planen, das bereitgestellte Modell sofort zu verwenden.

Schritt 7: Überwachung und Verwaltung

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

Überwachen mit Amazon CloudWatch: Überprüfen Sie regelmäßig die Leistung und den Zustand Ihres SageMaker-Endpunkts mit Amazon CloudWatch.
Endpunkt verwalten: Verwenden Sie die SageMaker-Konsole für die laufende Verwaltung des Endpunkts. Dies umfasst die Skalierung, Aktualisierung oder erneute Bereitstellung des Modells nach Bedarf.

Durch das Ausführen dieser Schritte haben Sie erfolgreich ein YOLO26-Modell auf Amazon SageMaker Endpoints bereitgestellt und getestet. Dieser Prozess vermittelt Ihnen nicht nur praktische Erfahrungen im Einsatz von AWS-Diensten für die Machine-Learning-Bereitstellung, sondern legt auch den Grundstein für die zukünftige Bereitstellung weiterer fortschrittlicher Modelle.

Zusammenfassung

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

Weitere technische Details finden Sie in diesem Artikel im AWS Machine Learning Blog. Sie können auch die offizielle Amazon SageMaker Dokumentation für weitere Einblicke in verschiedene Funktionen und Funktionalitäten einsehen.

Möchten Sie mehr über verschiedene YOLO26-Integrationen erfahren? Besuchen Sie die Ultralytics Integrations-Leitfaden-Seite, um zusätzliche Tools und Funktionen zu entdecken, die Ihre 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, befolgen Sie diese Schritte:

Richten Sie Ihre AWS-Umgebung ein: Stellen Sie sicher, dass Sie ein AWS-Konto, IAM-Rollen mit den erforderlichen Berechtigungen und die AWS CLI konfiguriert haben. Installieren Sie AWS CDK, falls noch nicht geschehen (siehe die AWS CDK-Anweisungen).

Klonen Sie das YOLO26 SageMaker Repository:

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

CDK-Umgebung einrichten: Erstellen Sie eine Python Virtual Environment, aktivieren Sie sie, installieren Sie Abhängigkeiten und aktualisieren Sie die AWS CDK-Bibliothek.
```
python3 -m venv .venv
source .venv/bin/activate
pip3 install -r requirements.txt
pip install --upgrade aws-cdk-lib
```
Bereitstellung mit AWS CDK: Synthetisieren und stellen Sie den CloudFormation-Stack bereit, und starten Sie die Umgebung.
```
cdk synth
cdk bootstrap
cdk deploy
```

Weitere Details finden Sie im Dokumentationsbereich.

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

Um YOLO26 auf Amazon SageMaker bereitzustellen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:

AWS-Konto: Aktives AWS-Konto (hier anmelden).
IAM-Rollen: Konfigurierte IAM-Rollen mit Berechtigungen für SageMaker, CloudFormation und Amazon S3.
AWS CLI: Installierte und konfigurierte AWS Command Line Interface (AWS CLI Installationsanleitung).
AWS CDK: Installiertes AWS Cloud Development Kit (CDK-Einrichtungsanleitung).
Servicekontingente: Ausreichende Quoten für ml.m5.4xlarge Instanzen sowohl für die Endpunkt- als auch für die Notebook-Nutzung (eine Kontingenterhöhung beantragen), oder Auto-Modus mit angegebener Auslastungsfraktion (

Detaillierte Informationen zur Einrichtung finden Sie in diesem Abschnitt.

Warum sollte ich Ultralytics YOLO26 auf Amazon SageMaker verwenden?

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

Skalierbarkeit und Management: SageMaker bietet eine verwaltete Umgebung mit Funktionen wie Autoscaling, die bei Echtzeit-Inferenzanforderungen hilft.
Integration mit AWS-Services: Nahtlose Integration mit anderen AWS-Services wie S3 für Datenspeicherung, CloudFormation für Infrastructure as Code und CloudWatch für Überwachung.
Einfache Bereitstellung: Vereinfachte Einrichtung mit AWS CDK-Skripten und optimierten Bereitstellungsprozessen.
Performance: Nutzen Sie die hochleistungsfähige Infrastruktur von Amazon SageMaker, um umfangreiche Inferenzaufgaben effizient auszuführen.

Erfahren Sie mehr über die Vorteile der Verwendung von SageMaker im Einführungsabschnitt.

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

Ja, Sie können die Inferenzlogik für YOLO26 auf Amazon SageMaker anpassen:

Ändern inference.py: Suchen und passen Sie die output_fn Funktion in der inference.py Datei, 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)

Aktualisiertes Modell bereitstellen: Stellen Sie sicher, dass Sie das Modell mit den bereitgestellten Jupyter Notebooks erneut bereitstellen (1_DeployEndpoint.ipynb), um diese Änderungen zu übernehmen.

Die detaillierten Schritte für die Bereitstellung des modifizierten Modells finden Sie hier.

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

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

Test-Notebook öffnen: Lokalisieren Sie die 2_TestEndpoint.ipynb Notebook in der SageMaker Jupyter-Umgebung.
Notebook ausführen: Befolgen Sie die Anweisungen des Notebooks, um ein Bild an den Endpunkt zu senden, eine Inferenz durchzuführen und Ergebnisse anzuzeigen.
Ergebnisse visualisieren: Verwenden Sie integrierte Plotfunktionen, um Leistungsmetriken wie Begrenzungsrahmen um erkannte Objekte zu visualisieren.

Umfassende Testanweisungen finden Sie im Testabschnitt.

📅 Erstellt vor 2 Jahren ✏️ Aktualisiert vor 5 Tagen