Sony IMX500 Export für Ultralytics YOLO11

Dieser Leitfaden behandelt den Export und die Bereitstellung von Ultralytics YOLO11-Modellen auf Raspberry Pi AI-Kameras, die mit dem Sony IMX500-Sensor ausgestattet sind.

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

Das IMX500-Modellformat ist darauf ausgelegt, bei schneller Leistung für neuronale Netze minimalen Strom zu verbrauchen. Es ermöglicht Ihnen, Ihre Ultralytics YOLO11-Modelle für High-Speed- und Low-Power-Inferencing zu optimieren. In diesem Leitfaden führen wir Sie durch den Export und die Bereitstellung Ihrer Modelle im IMX500-Format und erleichtern es Ihren Modellen, auf der Raspberry Pi AI-Kamera eine gute Leistung zu erzielen.

Warum sollten Sie in IMX500 exportieren?

Der IMX500 Intelligent Vision Sensor von Sony ist ein bahnbrechendes Stück Hardware für die KI-Verarbeitung. Er ist der weltweit erste intelligente Vision-Sensor mit On-Chip-KI-Funktionen. Dieser Sensor hilft bei der Überwindung vieler Herausforderungen im Bereich der Edge-KI, einschließlich Engpässen bei der Datenverarbeitung, Datenschutzbedenken und Leistungseinschränkungen. Während andere Sensoren lediglich Bilder und Frames weitergeben, erzählt der IMX500 eine ganze Geschichte. Er verarbeitet die Daten direkt auf dem Sensor und ermöglicht es den Geräten, Erkenntnisse in Echtzeit zu gewinnen.

Sonys 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 verarbeiten, ohne sie zur Verarbeitung in die Cloud senden zu müssen.

Der IMX500 arbeitet mit quantisierten Modellen. Die Quantisierung macht Modelle kleiner und schneller, ohne viel Genauigkeit zu verlieren. Sie ist ideal für die begrenzten Ressourcen des Edge-Computing, da sie es Anwendungen ermöglicht, schnell zu reagieren, indem sie die Latenz reduziert und eine schnelle Datenverarbeitung lokal ermöglicht, ohne Cloud-Abhängigkeit. Die lokale Verarbeitung schützt auch die Privatsphäre und Sicherheit der Benutzerdaten, da diese nicht an einen Remote-Server gesendet werden.

IMX500 Hauptmerkmale:

• Metadata-Ausgabe: Anstatt nur Bilder zu übertragen, kann der IMX500 sowohl Bild- als auch Metadaten (Inferenz-Ergebnis) ausgeben und nur Metadaten ausgeben, um die Datengröße zu minimieren, die Bandbreite zu reduzieren und die Kosten zu senken.
• Berücksichtigung von Datenschutzbedenken: Durch die Verarbeitung von Daten auf dem Gerät berücksichtigt der IMX500 Datenschutzbedenken, ideal für auf den Menschen ausgerichtete Anwendungen wie Personenzählung und Anwesenheitsverfolgung.
• Echtzeitverarbeitung: Die schnelle On-Sensor-Verarbeitung unterstützt Echtzeitentscheidungen, perfekt für Edge-KI-Anwendungen wie autonome Systeme.

Before You Begin: Um optimale Ergebnisse zu erzielen, stellen Sie sicher, dass Ihr YOLO11-Modell gut auf den Export vorbereitet ist, indem Sie unsere Modelltrainingsanleitung, Datenaufbereitungsanleitung und Anleitung zur Hyperparameter-Optimierung befolgen.

Unterstützte Aufgaben

Derzeit können Sie nur Modelle, die die folgenden Aufgaben enthalten, in das IMX500-Format exportieren.

• Objekterkennung
• Pose-Schätzung

Anwendungsbeispiele

Exportieren Sie ein Ultralytics YOLO11-Modell in das IMX500-Format und führen Sie Inferenz mit dem exportierten Modell aus.

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

# Export a YOLO11n PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n.pt format=imx data=coco8.yaml

# Run inference with the exported model
yolo predict model=yolo11n_imx_model source='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")

# Export a YOLO11n-pose PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n-pose.pt format=imx data=coco8-pose.yaml

# Run inference with the exported model
yolo predict model=yolo11n-pose_imx_model source='https://ultralytics.com/images/bus.jpg'

Export-Argumente

Weitere Informationen zum Exportprozess finden Sie auf der Ultralytics-Dokumentationsseite zum Exportieren.

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

yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n_imx.onnx
├── yolo11n_imx_MemoryReport.json
└── yolo11n_imx.pbtxt

yolo11n-pose_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n-pose_imx.onnx
├── yolo11n-pose_imx_MemoryReport.json
└── yolo11n-pose_imx.pbtxt

Verwendung des IMX500-Exports bei der Bereitstellung

Nach dem Exportieren des Ultralytics YOLO11n-Modells in das IMX500-Format kann es zur Inferenz auf der Raspberry Pi AI-Kamera eingesetzt werden.

Hardware-Voraussetzungen

Stellen Sie sicher, dass Sie die folgende Hardware besitzen:

1. Raspberry Pi 5 oder Raspberry Pi 4 Modell B
2. Raspberry Pi AI-Kamera

Verbinden Sie die Raspberry Pi AI-Kamera mit dem 15-poligen MIPI-CSI-Anschluss des Raspberry Pi und schalten Sie den Raspberry Pi ein.

Software-Voraussetzungen

Schritt 1: Öffnen Sie ein Terminalfenster und führen Sie die folgenden Befehle aus, um die Raspberry Pi-Software auf die neueste Version zu aktualisieren.

sudo apt update && sudo apt full-upgrade

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

sudo apt install imx500-all

Schritt 3: Starten Sie Raspberry Pi neu, damit die Änderungen wirksam werden

sudo reboot

Schritt 4: Installieren Sie die Aitrios Raspberry Pi Application Module Library

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

Schritt 5: Führen Sie die YOLO11-Objekterkennung und -Pose-Schätzung mithilfe der unten stehenden Skripte aus, 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 DPS 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()

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_yolo_pose_ultralytics


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

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

    def post_process(self, output_tensors):
        """Post-process the output tensors for pose estimation."""
        return pp_yolo_pose_ultralytics(output_tensors)


device = AiCamera(frame_rate=17)  # Optimal frame rate for maximum DPS of the YOLO-pose model running on the AI Camera
model = YOLOPose()
device.deploy(model)

annotator = Annotator()

with device as stream:
    for frame in stream:
        detections = frame.detections[frame.detections.confidence > 0.4]

        annotator.annotate_keypoints(frame, detections)
        annotator.annotate_boxes(frame, detections, corner_length=20)
        frame.display()

Benchmarks

YOLOv8n, YOLO11n, YOLOv8n-Pose und YOLO11n-Pose Benchmarks unten wurden vom Ultralytics Team auf der Raspberry Pi AI-Kamera mit imx Modellformat durchgeführt, wobei Geschwindigkeit und Genauigkeit gemessen wurden.

Was steckt dahinter?

Sony Model Compression Toolkit (MCT)

Sonys Model Compression Toolkit (MCT) ist ein leistungsstarkes Tool zur Optimierung von Deep-Learning-Modellen durch Quantisierung und Beschneidung. Es unterstützt verschiedene Quantisierungsmethoden und bietet fortschrittliche Algorithmen zur Reduzierung der Modellgröße und der Rechenkomplexität, ohne die Genauigkeit wesentlich zu beeinträchtigen. MCT ist besonders nützlich für den Einsatz von Modellen auf Geräten mit beschränkten Ressourcen, um eine effiziente Inferenz und reduzierte Latenzzeiten zu gewährleisten.

Unterstützte Funktionen von MCT

Sonys MCT bietet eine Reihe von Funktionen zur Optimierung von neuronalen Netzwerkmodellen:

1. Graphenoptimierungen: Transformiert Modelle in effizientere Versionen, indem Layer wie Batch-Normalisierung in vorhergehende Layer integriert werden.
2. Quantisierungs-Parameter-Suche: Minimiert Quantisierungsrauschen mithilfe von Metriken wie Mean-Square-Error, No-Clipping und Mean-Average-Error.
3. Fortschrittliche Quantisierungsalgorithmen:
   • Shift Negative Correction: Behebt Leistungsprobleme, die durch symmetrische Aktivierungsquantisierung entstehen.
   • Ausreißer-Filterung: Verwendet Z-Score, um Ausreißer zu erkennen und zu entfernen.
   • Clustering: Nutzt nicht-uniforme Quantisierungsgitter für eine bessere Verteilungsanpassung.
   • Mixed-Precision Search: Weist jeder Schicht basierend auf der Sensitivität unterschiedliche Quantisierungs-Bitbreiten zu.
4. Visualisierung: Verwenden Sie TensorBoard, um Einblicke in die Modellleistung, Quantisierungsphasen und Bitbreitenkonfigurationen zu erhalten.

Quantisierung

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

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

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

1. Potenz-von-Zwei (Hardware-freundlich)
2. Symmetrisch
3. Uniform

Strukturiertes Pruning

MCT führt eine strukturierte, hardwaregestützte Modellbeschneidung ein, die für spezifische Hardwarearchitekturen entwickelt wurde. Diese Technik nutzt die Single Instruction, Multiple Data (SIMD)-Fähigkeiten der Zielplattform, indem sie SIMD-Gruppen beschneidet. Dies reduziert die Modellgröße und -komplexität und optimiert gleichzeitig die Kanalauslastung, die auf die SIMD-Architektur abgestimmt ist, um die Ressourcennutzung des Gewichtsspeicherbedarfs gezielt zu nutzen. Verfügbar über Keras und PyTorch APIs.

IMX500 Converter Tool (Compiler)

Das IMX500 Converter Tool ist ein integraler Bestandteil des IMX500-Toolsets und ermöglicht die Kompilierung von Modellen für den Einsatz auf dem IMX500-Sensor von Sony (z. B. Raspberry Pi AI-Kameras). Dieses Tool erleichtert den Übergang von Ultralytics YOLO11-Modellen, die mit der Ultralytics-Software verarbeitet wurden, und stellt sicher, dass sie kompatibel sind und effizient auf der angegebenen Hardware laufen. Der Exportvorgang nach der Modellquantisierung umfasst die Erstellung von Binärdateien, die wesentliche Daten und gerätespezifische Konfigurationen enthalten, wodurch der Bereitstellungsprozess auf der Raspberry Pi AI-Kamera vereinfacht wird.

Anwendungsfälle in der Praxis

Der Export in das IMX500-Format ist branchenübergreifend einsetzbar. Hier sind einige Beispiele:

• Edge AI und IoT: Ermöglichen Sie Objekterkennung auf Drohnen oder Überwachungskameras, wo Echtzeitverarbeitung auf Geräten mit geringem Stromverbrauch unerlässlich ist.
• Wearable Devices: Stellen Sie Modelle bereit, die für die KI-Verarbeitung im kleinen Maßstab auf Wearables zur Gesundheitsüberwachung optimiert sind.
• Smart Cities: Verwenden Sie IMX500-exportierte YOLO11-Modelle für die Verkehrsüberwachung und Sicherheitsanalyse mit schnellerer Verarbeitung und minimaler Latenz.
• Retail Analytics: Verbessern Sie die Überwachung im Geschäft durch den Einsatz optimierter Modelle in Point-of-Sale-Systemen oder intelligenten Regalen.

Fazit

Das Exportieren von Ultralytics YOLO11-Modellen in das IMX500-Format von Sony ermöglicht es Ihnen, Ihre Modelle für eine effiziente Inferenz auf IMX500-basierten Kameras bereitzustellen. Durch die Nutzung fortschrittlicher Quantisierungstechniken können Sie die Modellgröße reduzieren und die Inferenzgeschwindigkeit verbessern, ohne die Genauigkeit wesentlich zu beeinträchtigen.

Weitere Informationen und detaillierte Richtlinien finden Sie auf der IMX500-Website von Sony.

FAQ

Wie exportiere ich ein YOLO11-Modell in das IMX500-Format für die Raspberry Pi AI-Kamera?

Um ein YOLO11-Modell in das IMX500-Format zu exportieren, verwenden Sie 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 mit den notwendigen Dateien für die Bereitstellung, einschließlich packerOut.zip.

Welche Hauptvorteile bietet die Verwendung des IMX500-Formats für die Edge-KI-Bereitstellung?

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

• On-Chip-KI-Verarbeitung reduziert Latenz und Stromverbrauch
• Gibt sowohl Bild als auch Metadaten (Inferenz-Ergebnis) anstelle von nur Bildern aus
• Verbesserter Datenschutz durch lokale Datenverarbeitung ohne Cloud-Abhängigkeit
• Echtzeitverarbeitungsfunktionen, ideal für zeitkritische Anwendungen
• Optimierte Quantisierung für effiziente Modellbereitstellung auf ressourcenbeschränkten Geräten

Welche Hardware- und Softwarevoraussetzungen sind für die IMX500-Bereitstellung erforderlich?

Für die Bereitstellung von IMX500-Modellen benötigen Sie:

Hardware:

• Raspberry Pi 5 oder Raspberry Pi 4 Modell B
• Raspberry Pi AI-Kamera mit IMX500-Sensor

Software:

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

Welche Leistung kann ich von YOLO11-Modellen auf dem IMX500 erwarten?

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

• YOLO11n erreicht eine Inferenzzeit von 62,50 ms pro Bild.
• mAP50-95 von 0.492 auf dem COCO128-Datensatz
• Modellgröße von nur 3,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.

📅 Erstellt vor 10 Monaten ✏️ Aktualisiert vor 19 Tagen

Kommentare