Link to this sectionSony IMX500 Export für Ultralytics YOLO11#

Diese Anleitung behandelt den Export und die Bereitstellung von Ultralytics YOLO11-Modellen auf Raspberry Pi AI Cameras, die über den Sony IMX500-Sensor verfügen.

Die Bereitstellung von Computer-Vision-Modellen auf Geräten mit begrenzter Rechenleistung, wie z. B. der Raspberry Pi AI Camera, kann schwierig sein. Die Verwendung eines für schnellere Leistung optimierten Modellformats macht einen riesigen Unterschied.

Das IMX500-Modellformat wurde entwickelt, um bei minimalem Stromverbrauch eine schnelle Leistung für neuronale Netze zu erzielen. Es ermöglicht dir, deine Ultralytics YOLO11-Modelle für Hochgeschwindigkeits- und stromsparende Inferenz zu optimieren. In dieser Anleitung führen wir dich durch den Export und die Bereitstellung deiner Modelle im IMX500-Format und erleichtern es dir, eine gute Modellperformance auf der Raspberry Pi AI Camera zu erreichen.

Link to this sectionWarum solltest du in das IMX500-Format exportieren?#

Sonys IMX500 Intelligent Vision Sensor ist ein bahnbrechendes Stück Hardware in der Edge-AI-Verarbeitung. Es ist der weltweit erste intelligente Bildsensor mit KI-Funktionen direkt auf dem Chip. Dieser Sensor hilft dabei, viele Herausforderungen in der Edge-KI zu überwinden, einschließlich Datenverarbeitungsengpässen, Datenschutzbedenken und Leistungsbeschränkungen. Während andere Sensoren lediglich Bilder und Frames weiterleiten, erzählt der IMX500 eine ganze Geschichte. Er verarbeitet Daten direkt auf dem Sensor, was es Geräten ermöglicht, Erkenntnisse in Echtzeit zu generieren.

Link to this sectionSonys IMX500 Export für YOLO11-Modelle#

Der IMX500 wurde entwickelt, um die Art und Weise zu verändern, wie Geräte Daten direkt auf dem Sensor handhaben, ohne diese zur Verarbeitung in die Cloud senden zu müssen.

Der IMX500 arbeitet mit quantisierten Modellen. Quantisierung macht Modelle kleiner und schneller, ohne viel Genauigkeit zu verlieren. Sie ist ideal für die begrenzten Ressourcen des Edge-Computings und ermöglicht Anwendungen, schnell zu reagieren, indem Latenzzeiten reduziert und eine lokale Datenverarbeitung ohne Cloud-Abhängigkeit ermöglicht wird. Die lokale Verarbeitung hält zudem Nutzerdaten privat und sicher, da sie nicht an einen entfernten Server gesendet werden.

Hauptmerkmale des IMX500:

• Metadatenausgabe: Anstatt nur Bilder zu übertragen, kann der IMX500 sowohl Bild als auch Metadaten (Inferenzergebnis) ausgeben und kann nur Metadaten ausgeben, um die Datengröße zu minimieren, die Bandbreite zu reduzieren und Kosten zu senken.
• Adressiert Datenschutzbedenken: Durch die Verarbeitung der Daten auf dem Gerät adressiert der IMX500 Datenschutzbedenken, was ideal für menschenzentrierte Anwendungen wie Personenzählung und Belegungsverfolgung ist.
• Echtzeitverarbeitung: Schnelle Sensor-nahe Verarbeitung unterstützt Echtzeitentscheidungen, perfekt für Edge-KI-Anwendungen wie autonome Systeme.

Bevor du beginnst: Für beste Ergebnisse stelle sicher, dass dein YOLO11-Modell gut für den Export vorbereitet ist, indem du unserem Modell-Training-Guide, Datenvorbereitungs-Guide und Hyperparameter-Tuning-Guide folgst.

Link to this sectionUnterstützte Aufgaben#

Derzeit kannst du nur Modelle in das IMX500-Format exportieren, die die folgenden Aufgaben beinhalten.

• Object Detection
• Pose Estimation
• Classification
• Instanz-Segmentierung

Link to this sectionAnwendungsbeispiele#

Exportiere ein Ultralytics YOLO11-Modell in das IMX500-Format und führe eine Inferenz mit dem exportierten Modell durch.

Das IMX500-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung laufen auf der Raspberry Pi AI Camera (IMX500).

 from ultralytics import YOLO

 # Load a YOLO11n PyTorch model
 model = YOLO("yolo11n.pt")

 # Export the model
 model.export(format="imx", data="coco8.yaml")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg")

 from ultralytics import YOLO

 # Load a YOLO11n-pose PyTorch model
 model = YOLO("yolo11n-pose.pt")

 # Export the model
 model.export(format="imx", data="coco8-pose.yaml")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n-pose_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg")

 from ultralytics import YOLO

 # Load a YOLO11n-cls PyTorch model
 model = YOLO("yolo11n-cls.pt")

 # Export the model
 model.export(format="imx", data="imagenet10")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n-cls_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

 from ultralytics import YOLO

 # Load a YOLO11n-seg PyTorch model
 model = YOLO("yolo11n-seg.pt")

 # Export the model
 model.export(format="imx", data="coco8-seg.yaml")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n-seg_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg")

 from ultralytics import YOLO

 # Load the exported IMX500 model
 model = YOLO("yolo11n_imx_model")

 # Validate accuracy on the COCO8 dataset
 metrics = model.val(data="coco8.yaml")

Link to this sectionExport-Argumente#

Weitere Details zum Exportprozess findest du auf der Ultralytics-Dokumentationsseite zum Exportieren.

Der Exportprozess erstellt ein ONNX-Modell für die Quantisierungsvalidierung sowie ein Verzeichnis namens <model-name>_imx_model. Dieses Verzeichnis enthält die Datei packerOut.zip, die für das Paketieren des Modells zur Bereitstellung auf der IMX500-Hardware unerlässlich ist. Zusätzlich wird der Ordner <model-name>_imx_model eine Textdatei (labels.txt) enthalten, die alle mit dem Modell verknüpften Labels auflistet.

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

Link to this sectionVerwendung des IMX500-Exports bei der Bereitstellung#

Nach dem Export des Ultralytics YOLO11n-Modells in das IMX500-Format kann es zur Inferenz auf der Raspberry Pi AI Camera bereitgestellt werden.

Link to this sectionHardware-Voraussetzungen#

Stelle sicher, dass du über die folgende Hardware verfügst:

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.

Link to this sectionSoftware-Voraussetzungen#

Schritt 1: Öffne ein Terminalfenster und führe die folgenden Befehle aus, um die Raspberry Pi-Software 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 Aitrios Raspberry Pi application module library.

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

Schritt 5: Führe YOLO11-Objekterkennung, Pose-Schätzung, Klassifizierung und Segmentierung durch, indem du die folgenden Skripte verwendest, die in den aitrios-rpi-application-module-library-Beispielen verfügbar sind.

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()

Link to this sectionBenchmarks#

Die unten stehenden 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 imx-Modellformat durchgeführt, um Geschwindigkeit und Genauigkeit zu messen.

Link to this sectionWas steckt unter der Haube?#

Link to this sectionSony Model Compression Toolkit (MCT)#

Sonys Model Compression Toolkit (MCT) ist ein leistungsstarkes Werkzeug zur Optimierung von Deep-Learning-Modellen durch Quantisierung und Pruning. Es unterstützt verschiedene Quantisierungsmethoden und bietet fortgeschrittene Algorithmen, um die Modellgröße und Rechenkomplexität zu reduzieren, ohne dabei signifikant an Genauigkeit einzubüßen. MCT ist besonders nützlich für die Bereitstellung von Modellen auf ressourcenbeschränkten Geräten und sorgt für effiziente Inferenz und reduzierte Latenz.

Link to this sectionUnterstützte Funktionen von MCT#

Sonys MCT bietet eine Reihe von Funktionen, die darauf ausgelegt sind, neuronale Netzwerkmodelle zu optimieren:

1. Graph-Optimierungen: Transformiert Modelle in effizientere Versionen, indem Schichten wie Batch-Normalisierung in vorangegangene Schichten gefaltet werden.
2. Suche nach Quantisierungsparametern: Minimiert Quantisierungsrauschen unter Verwendung von Metriken wie Mean-Square-Error, No-Clipping und Mean-Average-Error.
3. Fortgeschrittene Quantisierungsalgorithmen:
   • Shift Negative Correction: Adressiert Leistungsprobleme durch symmetrische Aktivierungsquantisierung.
   • Outliers Filtering: Verwendet den Z-Score, um Ausreißer zu erkennen und zu entfernen.
   • Clustering: Nutzt nicht-gleichförmige Quantisierungsgitter für eine bessere Verteilungsanpassung.
   • Mixed-Precision-Suche: Weist je nach Empfindlichkeit unterschiedliche Quantisierungs-Bitbreiten pro Schicht zu.
4. Visualisierung: Nutze TensorBoard, um Einblicke in die Modellleistung, Quantisierungsphasen und Bitbreiten-Konfigurationen zu erhalten.

Link to this sectionQuantisierung#

MCT unterstützt verschiedene Quantisierungsmethoden, um die Modellgröße zu reduzieren und die Inferenzgeschwindigkeit zu verbessern:

1. Post-Training Quantization (PTQ):
   • Verfügbar über Keras- und PyTorch-APIs.
   • Komplexität: Niedrig
   • Rechenaufwand: Niedrig (CPU-Minuten)
2. Gradient-based Post-Training Quantization (GPTQ):
   • Verfügbar über Keras- und PyTorch-APIs.
   • Komplexität: Mittel
   • Rechenaufwand: Moderat (2-3 GPU-Stunden)
3. Quantization-Aware Training (QAT):
   • Komplexität: Hoch
   • Rechenaufwand: Hoch (12-36 GPU-Stunden)

MCT unterstützt zudem verschiedene Quantisierungsschemata für Gewichte und Aktivierungen:

1. Power-of-Two (hardwarefreundlich)
2. Symmetrisch
3. Gleichförmig

Link to this sectionStrukturiertes Pruning#

MCT führt strukturiertes, hardwareorientiertes Modell-Pruning ein, das für spezifische Hardwarearchitekturen konzipiert ist. Diese Technik nutzt die Single Instruction, Multiple Data (SIMD)-Fähigkeiten der Zielplattform durch das Pruning von SIMD-Gruppen. Dies reduziert die Modellgröße und -komplexität bei gleichzeitiger Optimierung der Kanalauslastung, abgestimmt auf die SIMD-Architektur für eine gezielte Ressourcennutzung des Speicherplatzes für Gewichte. Verfügbar über Keras- und PyTorch-APIs.

Link to this sectionIMX500 Converter Tool (Compiler)#

Das IMX500 Converter Tool ist fester Bestandteil des IMX500-Toolsets und ermöglicht die Kompilierung von Modellen für den Einsatz auf dem Sony IMX500-Sensor (zum Beispiel Raspberry Pi AI Cameras). Dieses Tool erleichtert den Transfer von Ultralytics YOLO11-Modellen, die mittels Ultralytics-Software verarbeitet wurden, und stellt sicher, dass sie kompatibel sind und auf der angegebenen Hardware effizient funktionieren. Das Exportverfahren nach der Modellquantisierung beinhaltet die Erstellung von Binärdateien, die wesentliche Daten und gerätespezifische Konfigurationen enthalten, was den Bereitstellungsprozess auf der Raspberry Pi AI Camera optimiert.

Link to this sectionAnwendungsfälle aus der Praxis#

Der Export in das IMX500-Format bietet branchenübergreifend vielfältige Einsatzmöglichkeiten. Hier sind einige Beispiele:

• Edge AI und IoT: Ermögliche Objekterkennung auf Drohnen oder Sicherheitskameras, bei denen Echtzeitverarbeitung auf Geräten mit geringem Stromverbrauch essenziell ist.
• Wearables: Implementiere Modelle, die für KI-Verarbeitung im kleinen Maßstab auf gesundheitsüberwachenden Wearables optimiert sind.
• Smart Cities: Nutze IMX500-exportierte YOLO11-Modelle für Verkehrsüberwachung und Sicherheitsanalysen mit schnellerer Verarbeitung und minimaler Latenz.
• Einzelhandelsanalytik: Verbessere die Überwachung im Geschäft durch den Einsatz optimierter Modelle in Point-of-Sale-Systemen oder intelligenten Regalen.

Link to this sectionFazit#

Der Export von Ultralytics YOLO11-Modellen in das IMX500-Format von Sony ermöglicht es dir, deine Modelle für eine effiziente Inferenz auf IMX500-basierten Kameras bereitzustellen. Durch die Nutzung fortschrittlicher Quantisierungstechniken kannst du die Modellgröße reduzieren und die Inferenzgeschwindigkeit verbessern, ohne die Genauigkeit maßgeblich zu beeinträchtigen.

Für weitere Informationen und detaillierte Richtlinien beachte Sonys IMX500 website.

Link to this sectionFAQ#

Link to this sectionWie exportiere ich ein YOLO11-Modell in das IMX500-Format für die Raspberry Pi AI Camera?#

Um ein YOLO11-Modell in das IMX500-Format zu exportieren, verwende entweder die Python-API oder den CLI-Befehl:

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="imx")  # Exports with PTQ quantization by default

Der Exportprozess erstellt ein Verzeichnis, das die notwendigen Dateien für die Bereitstellung enthält, einschließlich packerOut.zip.

Link to this sectionWas sind die Hauptvorteile der Verwendung des IMX500-Formats für die Edge-KI-Bereitstellung?#

Das IMX500-Format bietet verschiedene wichtige Vorteile für die Edge-Bereitstellung:

• On-Chip-KI-Verarbeitung reduziert Latenz und Stromverbrauch
• Gibt sowohl Bilder als auch Metadaten (Inferenzergebnis) aus, anstatt nur Bilder
• Erhöhte Privatsphäre durch lokale Datenverarbeitung ohne Cloud-Abhängigkeit
• Echtzeit-Verarbeitungsfähigkeiten ideal für zeitkritische Anwendungen
• Optimierte Quantisierung für effiziente Modellbereitstellung auf ressourcenbeschränkten Geräten

Link to this sectionWelche Hardware- und Softwarevoraussetzungen sind für die IMX500-Bereitstellung erforderlich?#

Für die Bereitstellung von IMX500-Modellen benötigst du:

Hardware:

• Raspberry Pi 5 oder Raspberry Pi 4 Model B
• Raspberry Pi AI Camera mit IMX500-Sensor

Software:

• Raspberry Pi OS Bookworm
• IMX500-Firmware und Tools (sudo apt install imx500-all)

Link to this sectionWelche Leistung kann ich von YOLO11-Modellen auf dem IMX500 erwarten?#

Basierend auf Ultralytics-Benchmarks auf der Raspberry Pi AI Camera:

• YOLO11n erreicht 58,82 ms Inferenzzeit pro Bild
• mAP50-95 von 0,517 auf dem COCO128-Datensatz
• Modellgröße von nur 2,2 MB nach der Quantisierung

Dies zeigt, dass das IMX500-Format eine effiziente Echtzeit-Inferenz bietet und gleichzeitig eine gute Genauigkeit für Edge-KI-Anwendungen beibehält.