Sony IMX500-Export für Ultralytics YOLO11#

In dieser Anleitung erfährst du, wie du Ultralytics YOLO11-Modelle für Raspberry Pi AI Cameras mit Sony IMX500-Sensor exportierst und bereitstellst.

Die Bereitstellung von Computer-Vision-Modellen auf Geräten mit begrenzter Rechenleistung, wie der Raspberry Pi AI Camera, kann schwierig sein. Ein für höhere Leistung optimiertes Modellformat macht einen großen Unterschied.

Das IMX500-Modellformat wurde entwickelt, um möglichst wenig Energie zu verbrauchen und gleichzeitig eine hohe Geschwindigkeit bei neuronalen Netzen zu bieten. Es ermöglicht dir, deine Ultralytics YOLO11-Modelle für schnelle Inferenz bei geringem Energieverbrauch zu optimieren. In dieser Anleitung zeigen wir dir, wie du deine Modelle ins IMX500-Format exportierst und bereitstellst, damit sie auf der Raspberry Pi AI Camera optimale Leistung erzielen.

Warum solltest du ins IMX500-Format exportieren?#

Der intelligente Bildsensor IMX500 von Sony ist eine bahnbrechende Hardware für Edge-KI-Verarbeitung. Er ist der weltweit erste intelligente Bildsensor mit integrierten KI-Funktionen. Dieser Sensor hilft, viele Herausforderungen im Bereich Edge-KI zu bewältigen, darunter Engpässe bei der Datenverarbeitung, Datenschutzbedenken und Leistungseinschränkungen. Während andere Sensoren lediglich Bilder und Einzelbilder weiterleiten, liefert der IMX500 ein Gesamtbild. Er verarbeitet Daten direkt auf dem Sensor, sodass Geräte in Echtzeit Erkenntnisse gewinnen können.

Sonys IMX500-Export für YOLO11-Modelle#

Der IMX500 wurde entwickelt, um die direkte Verarbeitung von Daten auf dem Sensor zu ermöglichen, ohne dass diese zur Verarbeitung an die Cloud gesendet werden müssen.

Der IMX500 unterstützt quantisierte Modelle. Durch Quantisierung werden Modelle kleiner und schneller, ohne dass die Genauigkeit wesentlich leidet. Das eignet sich ideal für die begrenzten Ressourcen des Edge-Computing: Anwendungen reagieren schneller, weil die Latenz sinkt und Daten lokal zügig verarbeitet werden können, ohne auf die Cloud angewiesen zu sein. Die lokale Verarbeitung schützt außerdem die Privatsphäre und Sicherheit der Nutzerdaten, da diese nicht an einen Remote-Server gesendet werden.

Wichtige Funktionen des IMX500:

• Metadatenausgabe: Statt ausschließlich Bilder zu übertragen, kann der IMX500 sowohl Bilder als auch Metadaten (Inferenzergebnisse) ausgeben. Zur Verringerung der Datenmenge, des Bandbreitenbedarfs und der Kosten kann er auch ausschließlich Metadaten ausgeben.
• Schutz der Privatsphäre: Da der IMX500 Daten auf dem Gerät verarbeitet, trägt er dem Datenschutz Rechnung und eignet sich ideal für menschenbezogene Anwendungen wie das Zählen von Personen und die Erfassung der Belegung.
• Echtzeitverarbeitung: Die schnelle Verarbeitung direkt auf dem Sensor ermöglicht Entscheidungen in Echtzeit und eignet sich ideal für Edge-KI-Anwendungen wie autonome Systeme.

Vorbereitung: Um optimale Ergebnisse zu erzielen, solltest du dein YOLO11-Modell sorgfältig für den Export vorbereiten. Folge dazu unserer Anleitung zum Modelltraining, Anleitung zur Datenaufbereitung und Anleitung zur Hyperparameteroptimierung.

Unterstützte Aufgaben#

Der IMX500-Export unterstützt vier der sieben Ultralytics-Aufgaben und zwar nur für YOLOv8n und YOLO11n: Andere Modellfamilien, Größen und Architekturen werden nicht unterstützt. Beim Export eines Modells für semantische Segmentierung, OBB oder Tiefenschätzung wird ein Fehler ausgegeben.

Anwendungsbeispiele#

Exportiere ein Ultralytics YOLO11-Modell ins IMX500-Format und führe mit dem exportierten Modell eine Inferenz aus.

Das IMX500-Format unterstützt die Modi Export, Vorhersage und Validierung. Inferenz und Validierung werden auf der Raspberry Pi AI Camera (IMX500) ausgeführt.

from ultralytics import YOLO

# YOLO11n-PyTorch-Modell laden
model = YOLO("yolo11n.pt")

# Modell exportieren
model.export(format="imx", data="coco8.yaml")  # exportiert standardmäßig mit PTQ-Quantisierung

# Exportiertes Modell laden
imx_model = YOLO("yolo11n_imx_model")

# Inferenz ausführen
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# YOLO11n-pose-PyTorch-Modell laden
model = YOLO("yolo11n-pose.pt")

# Modell exportieren
model.export(format="imx", data="coco8-pose.yaml")  # exportiert standardmäßig mit PTQ-Quantisierung

# Exportiertes Modell laden
imx_model = YOLO("yolo11n-pose_imx_model")

# Inferenz ausführen
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# YOLO11n-cls-PyTorch-Modell laden
model = YOLO("yolo11n-cls.pt")

# Modell exportieren
model.export(format="imx", data="imagenet10")  # exportiert standardmäßig mit PTQ-Quantisierung

# Exportiertes Modell laden
imx_model = YOLO("yolo11n-cls_imx_model")

# Inferenz ausführen
results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

from ultralytics import YOLO

# YOLO11n-seg-PyTorch-Modell laden
model = YOLO("yolo11n-seg.pt")

# Modell exportieren
model.export(format="imx", data="coco8-seg.yaml")  # exportiert standardmäßig mit PTQ-Quantisierung

# Exportiertes Modell laden
imx_model = YOLO("yolo11n-seg_imx_model")

# Inferenz ausführen
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Exportiertes IMX500-Modell laden
model = YOLO("yolo11n_imx_model")

# Die Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Exportargumente#

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Beim Export wird ein ONNX-Modell zur Validierung der Quantisierung sowie ein Verzeichnis namens <model-name>_imx_model erstellt. Dieses Verzeichnis enthält die Datei packerOut.zip, die für die Paketierung des Modells zur Bereitstellung auf der IMX500-Hardware erforderlich ist. Außerdem enthält der Ordner <model-name>_imx_model eine Textdatei (labels.txt) mit allen Bezeichnungen, die dem Modell zugeordnet sind.

yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── model_imx.onnx
├── model_imx_MemoryReport.json
└── model_imx.pbtxt

IMX500-Export bei der Bereitstellung verwenden#

Nach dem Export eines Ultralytics YOLO11n-Modells ins IMX500-Format kannst du es für Inferenzen auf der Raspberry Pi AI Camera bereitstellen.

Hardwarevoraussetzungen#

Stelle sicher, dass die folgende Hardware vorhanden ist:

1. Raspberry Pi 5 oder Raspberry Pi 4 Model B
2. Raspberry Pi AI Camera

Verbinde die Raspberry Pi AI Camera mit dem 15-poligen MIPI-CSI-Anschluss des Raspberry Pi und schalte den Raspberry Pi ein

Softwarevoraussetzungen#

Schritt 1: Öffne ein Terminalfenster und führe die folgenden Befehle aus, um die Software des Raspberry Pi auf die neueste Version zu aktualisieren.

sudo apt update && sudo apt full-upgrade

Schritt 2: Installiere die IMX500-Firmware, die für den Betrieb des IMX500-Sensors erforderlich ist.

sudo apt install imx500-all

Schritt 3: Starte den Raspberry Pi neu, damit die Änderungen wirksam werden.

sudo reboot

Schritt 4: Installiere die Bibliothek des Aitrios-Anwendungsmoduls für Raspberry Pi

pip install git+https://github.com/SonySemiconductorSolutions/aitrios-rpi-application-module-library.git

Schritt 5: Führe mit den folgenden Skripten Objekterkennung, Pose-Schätzung, Klassifizierung und Segmentierung mit YOLO11 aus. Die Skripte sind in den Beispielen der aitrios-rpi-application-module-library verfügbar.

import numpy as np
from modlib.apps import Annotator
from modlib.devices import AiCamera
from modlib.models import COLOR_FORMAT, MODEL_TYPE, Model
from modlib.models.post_processors import pp_od_yolo_ultralytics

class YOLO(Model):
    """YOLO model for IMX500 deployment."""

    def __init__(self):
        """Initialize the YOLO model for IMX500 deployment."""
        super().__init__(
            model_file="yolo11n_imx_model/packerOut.zip",  # replace with proper directory
            model_type=MODEL_TYPE.CONVERTED,
            color_format=COLOR_FORMAT.RGB,
            preserve_aspect_ratio=False,
        )

        self.labels = np.genfromtxt(
            "yolo11n_imx_model/labels.txt",  # replace with proper directory
            dtype=str,
            delimiter="\n",
        )

    def post_process(self, output_tensors):
        """Post-process the output tensors for object detection."""
        return pp_od_yolo_ultralytics(output_tensors)

device = AiCamera(frame_rate=16)  # Optimal frame rate for maximum FPS of the YOLO model running on the AI Camera
model = YOLO()
device.deploy(model)

annotator = Annotator()

with device as stream:
    for frame in stream:
        detections = frame.detections[frame.detections.confidence > 0.55]
        labels = [f"{model.labels[class_id]}: {score:0.2f}" for _, score, class_id, _ in detections]

        annotator.annotate_boxes(frame, detections, labels=labels, alpha=0.3, corner_radius=10)
        frame.display()

Benchmarks#

Die folgenden Benchmarks für YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls und YOLO11n-cls wurden vom Ultralytics-Team auf der Raspberry Pi AI Camera mit dem Modellformat imx durchgeführt; dabei wurden Geschwindigkeit und Genauigkeit gemessen.

Was steckt dahinter?#

Sony-Toolkit zur Modellkomprimierung (MCT)#

Das Model Compression Toolkit (MCT) von Sony ist ein leistungsstarkes Werkzeug zur Optimierung von Deep-Learning-Modellen durch Quantisierung und Pruning. Es unterstützt verschiedene Quantisierungsmethoden und bietet fortschrittliche Algorithmen, um Modellgröße und Rechenaufwand zu verringern, ohne die Genauigkeit wesentlich zu beeinträchtigen. MCT eignet sich besonders für die Bereitstellung von Modellen auf Geräten mit begrenzten Ressourcen und gewährleistet eine effiziente Inferenz bei geringerer Latenz.

Unterstützte Funktionen von MCT#

MCT von Sony bietet zahlreiche Funktionen zur Optimierung neuronaler Netze:

1. Graphoptimierungen: Wandelt Modelle in effizientere Versionen um, indem es beispielsweise Ebenen wie die Batch-Normalisierung in vorhergehende Ebenen integriert.
2. Suche nach Quantisierungsparametern: Minimiert Quantisierungsrauschen anhand von Kennzahlen wie mittlerem quadratischem Fehler, keinem Clipping und mittlerem absoluten Fehler.
3. Fortschrittliche Quantisierungsalgorithmen:
   • Korrektur negativer Verschiebungen: Behebt Leistungseinbußen durch symmetrische Aktivierungsquantisierung.
   • Ausreißerfilterung: Erkennt und entfernt Ausreißer mithilfe des z-Werts.
   • Clustering: Verwendet nicht gleichmäßige Quantisierungsgitter, um die Verteilung besser abzubilden.
   • Suche nach gemischter Präzision: Weist jeder Ebene abhängig von ihrer Empfindlichkeit eine andere Quantisierungsbitbreite zu.
4. Visualisierung: Nutze TensorBoard, um Einblicke in die Modellleistung, Quantisierungsphasen und Bitbreitenkonfigurationen zu erhalten.

Quantisierung#

MCT unterstützt mehrere Quantisierungsmethoden, um die Modellgröße zu verringern und die Inferenz zu beschleunigen:

1. Quantisierung nach dem Training (PTQ):
   • Über Keras- und PyTorch-APIs verfügbar.
   • Komplexität: Niedrig
   • Rechenaufwand: Niedrig (CPU-Minuten)
2. Gradientenbasierte Quantisierung nach dem Training (GPTQ):
   • Über Keras- und PyTorch-APIs verfügbar.
   • Komplexität: Mittel
   • Rechenaufwand: Mittel (2–3 GPU-Stunden)
3. Quantisierungsbewusstes Training (QAT):
   • Komplexität: Hoch
   • Rechenaufwand: Hoch (12–36 GPU-Stunden)

MCT unterstützt außerdem verschiedene Quantisierungsschemata für Gewichte und Aktivierungen:

1. Zweierpotenzen (hardwarefreundlich)
2. Symmetrisch
3. Gleichmäßig

Strukturiertes Pruning#

MCT bietet strukturiertes, hardwarebewusstes Pruning von Modellen, das auf bestimmte Hardwarearchitekturen ausgelegt ist. Bei dieser Technik werden die Fähigkeiten der Zielplattform für Einzelinstruktion, mehrere Daten (SIMD) genutzt, indem SIMD-Gruppen entfernt werden. Dadurch werden Modellgröße und Komplexität verringert und zugleich die Kanalauslastung optimiert. Die Optimierung ist an die SIMD-Architektur angepasst, um die Speichernutzung der Gewichte gezielt zu optimieren. Über Keras- und PyTorch-APIs verfügbar.

IMX500-Konverterwerkzeug (Compiler)#

Das IMX500-Konverterwerkzeug ist ein zentraler Bestandteil des IMX500-Werkzeugsatzes und ermöglicht das Kompilieren von Modellen für die Bereitstellung auf dem IMX500-Sensor von Sony, beispielsweise in Raspberry Pi AI Cameras. Mit diesem Werkzeug lassen sich Ultralytics YOLO11-Modelle, die mit Ultralytics-Software verarbeitet wurden, so umwandeln, dass sie mit der angegebenen Hardware kompatibel sind und effizient darauf laufen. Beim Export nach der Modellquantisierung werden Binärdateien erzeugt, die wichtige Daten und gerätespezifische Konfigurationen enthalten. Das vereinfacht die Bereitstellung auf der Raspberry Pi AI Camera.

Anwendungsfälle in der Praxis#

Der Export ins IMX500-Format eignet sich für zahlreiche Branchen. Hier sind einige Beispiele:

• Edge AI und IoT: Ermögliche die Objekterkennung auf Drohnen oder Überwachungskameras, bei denen die Echtzeitverarbeitung auf Geräten mit geringem Stromverbrauch wichtig ist.
• Tragbare Geräte: Stelle Modelle bereit, die für KI-Verarbeitung im kleinen Maßstab auf tragbaren Geräten zur Gesundheitsüberwachung optimiert sind.
• Intelligente Städte: Nutze exportierte YOLO11-Modelle im IMX500-Format zur Verkehrsüberwachung und Sicherheitsanalyse mit schnellerer Verarbeitung und minimaler Latenz.
• Einzelhandelsanalysen: Verbessere die Überwachung in Geschäften, indem du optimierte Modelle in Kassensystemen oder intelligenten Regalen einsetzt.

Fazit#

Wenn du Ultralytics YOLO11-Modelle ins IMX500-Format von Sony exportierst, kannst du sie für eine effiziente Inferenz auf Kameras mit IMX500 bereitstellen. Mit fortschrittlichen Quantisierungstechniken kannst du die Modellgröße verringern und die Inferenz beschleunigen, ohne die Genauigkeit wesentlich zu beeinträchtigen.

Weitere Informationen und ausführliche Anleitungen findest du auf der IMX500-Website von Sony.

Häufig gestellte Fragen#