Eine Anleitung zur Bereitstellung von YOLO11 auf Amazon SageMaker-Endpunkten

Die Bereitstellung fortschrittlicher Computer Vision-Modelle wie Ultralytics' YOLO11 auf Amazon SageMaker Endpoints eröffnet eine breite Palette 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. YOLO11 wird noch leistungsfähiger, wenn es nahtlos in Amazon SageMaker integriert wird, einem robusten und skalierbaren Machine-Learning-Service von AWS.

Dieser Leitfaden führt Sie Schritt für Schritt durch den Prozess der Bereitstellung von YOLO11 PyTorch-Modellen auf Amazon SageMaker Endpoints. Sie lernen die Grundlagen der Vorbereitung Ihrer AWS-Umgebung, der entsprechenden Konfiguration des Modells und der Verwendung von Tools wie AWS CloudFormation und dem AWS Cloud Development Kit (CDK) für die Bereitstellung.

Amazon SageMaker

Amazon SageMaker Übersicht

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 YOLO11 auf Amazon SageMaker Endpoints

Durch die Bereitstellung von YOLO11 auf Amazon SageMaker können Sie dessen verwaltete Umgebung für Echtzeit-Inferenz nutzen und Funktionen wie Autoscaling nutzen. Sehen Sie sich die AWS-Architektur unten an.

AWS-Architektur

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 YOLO11 SageMaker Repository

Der nächste Schritt ist das Klonen des spezifischen AWS-Repositorys, das die Ressourcen für die Bereitstellung von YOLO11 auf SageMaker enthält. Dieses auf GitHub gehostete Repository enthält 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 das Angebot an YOLO11-Modellen von Ultralytics 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 YOLO11.

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)

Endpoint mit 1_DeployEndpoint.ipynb bereitstellen: Ö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 YOLO11-Modell herunterzuladen, es mit dem aktualisierten Inferenzcode zu verpacken und in einen Amazon S3-Bucket hochzuladen. Das Notebook führt Sie durch die Erstellung und Bereitstellung eines SageMaker-Endpunkts für das YOLO11-Modell.

Schritt 6: Testen Ihrer Bereitstellung

Nachdem Ihr YOLO11-Modell nun bereitgestellt ist, ist es wichtig, seine 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 YOLO11

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.

Nach Abschluss dieser Schritte haben Sie ein YOLO11-Modell erfolgreich auf Amazon SageMaker Endpoints bereitgestellt und getestet. Dieser Prozess vermittelt Ihnen nicht nur praktische Erfahrung im Umgang mit AWS-Diensten für die Bereitstellung von maschinellem Lernen, sondern legt auch den Grundstein für die Bereitstellung anderer fortschrittlicher Modelle in der Zukunft.

Zusammenfassung

Dieser Leitfaden hat Sie Schritt für Schritt durch die Bereitstellung von YOLO11 auf Amazon SageMaker Endpoints mit 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 mit 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 YOLO11-Integrationen erfahren? Besuchen Sie die Ultralytics Seite zum Integrationsleitfaden, um weitere Tools und Funktionen zu entdecken, die Ihre Machine-Learning-Projekte verbessern können.

FAQ

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

Um das Ultralytics YOLO11 Modell auf Amazon SageMaker Endpoints bereitzustellen, führen Sie die folgenden Schritte aus:

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 YOLO11 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 YOLO11 auf Amazon SageMaker?

Um YOLO11 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 YOLO11 auf Amazon SageMaker verwenden?

Die Verwendung von Ultralytics YOLO11 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 YOLO11 auf Amazon SageMaker anpassen?

Ja, Sie können die Inferenzlogik für YOLO11 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 YOLO11-Modell auf Amazon SageMaker testen?

So testen Sie das bereitgestellte YOLO11-Modell auf Amazon SageMaker:

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 1 Jahr ✏️ Aktualisiert vor 2 Monaten