Esportazione Sony IMX500 per Ultralytics YOLO11

Questa guida illustra l'esportazione e la distribuzione di modelli Ultralytics YOLO11 su telecamere AI Raspberry Pi dotate di sensore Sony IMX500.

Distribuire modelli di computer vision su dispositivi con potenza di calcolo limitata, come la Raspberry Pi AI Camera, può essere complesso. L'utilizzo di un formato di modello ottimizzato per prestazioni più veloci fa una grande differenza.

Il formato del modello IMX500 è progettato per utilizzare una potenza minima offrendo al contempo prestazioni elevate per le reti neurali. Consente di ottimizzare i modelli Ultralytics YOLO11 per un'inferenza ad alta velocità e a basso consumo energetico. In questa guida, ti accompagneremo attraverso l'esportazione e l'implementazione dei tuoi modelli nel formato IMX500, semplificando al contempo le prestazioni dei tuoi modelli sulla Raspberry Pi AI Camera.

Perché dovresti esportare in IMX500

Il sensore di visione intelligente IMX500 di Sony è un hardware innovativo per l'elaborazione dell'intelligenza artificiale. È il primo sensore di visione intelligente al mondo con funzionalità AI on-chip. Questo sensore aiuta a superare molte sfide dell'IA edge, tra cui i colli di bottiglia dell'elaborazione dei dati, i problemi di privacy e le limitazioni delle prestazioni. Mentre altri sensori si limitano a trasmettere immagini e fotogrammi, l'IMX500 racconta un'intera storia. Elabora i dati direttamente sul sensore, consentendo ai dispositivi di generare approfondimenti in tempo reale.

Esportazione IMX500 di Sony per modelli YOLO11

L'IMX500 è progettato per trasformare il modo in cui i dispositivi gestiscono i dati direttamente sul sensore, senza la necessità di inviarli al cloud per l'elaborazione.

L'IMX500 funziona con modelli quantizzati. La quantizzazione rende i modelli più piccoli e veloci senza perdere molta precisione. È ideale per le risorse limitate dell'edge computing, consentendo alle applicazioni di rispondere rapidamente riducendo la latenza e consentendo una rapida elaborazione dei dati in locale, senza dipendenza dal cloud. L'elaborazione locale mantiene inoltre privati e sicuri i dati dell'utente poiché non vengono inviati a un server remoto.

Caratteristiche principali di IMX500:

• Output di metadati: Invece di trasmettere solo immagini, l'IMX500 può emettere sia immagini che metadati (risultato dell'inferenza) e può emettere solo metadati per ridurre al minimo le dimensioni dei dati, ridurre la larghezza di banda e ridurre i costi.
• Affronta i problemi di privacy: Elaborando i dati sul dispositivo, l'IMX500 affronta i problemi di privacy, ideale per applicazioni incentrate sull'uomo come il conteggio delle persone e il monitoraggio dell'occupazione.
• Elaborazione in tempo reale: L'elaborazione rapida sul sensore supporta decisioni in tempo reale, perfetta per applicazioni AI edge come i sistemi autonomi.

Before You Begin: Per ottenere risultati ottimali, assicurati che il tuo modello YOLO11 sia ben preparato per l'esportazione seguendo la nostra Guida all'addestramento del modello, la Guida alla preparazione dei dati e la Guida alla messa a punto degli iperparametri.

Attività supportate

Attualmente, è possibile esportare solo i modelli che includono le seguenti attività in formato IMX500.

• Rilevamento di oggetti
• Stima della posa

Esempi di utilizzo

Esporta un modello Ultralytics YOLO11 in formato IMX500 ed esegui l'inferenza con il modello esportato.

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'

Argomenti di esportazione

Per maggiori dettagli sul processo di esportazione, visita la pagina della documentazione di Ultralytics sull'esportazione.

Il processo di esportazione creerà un modello ONNX per la convalida della quantizzazione, insieme a una directory denominata <model-name>_imx_model. Questa directory includerà il packerOut.zip file, essenziale per il packaging del modello per la distribuzione sull'hardware IMX500. Inoltre, la <model-name>_imx_model cartella conterrà un file di testo (labels.txt) che elenca tutte le etichette associate al modello.

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

Utilizzo dell'esportazione IMX500 nella distribuzione

Dopo aver esportato il modello Ultralytics YOLO11n in formato IMX500, può essere implementato su Raspberry Pi AI Camera per l'inferenza.

Prerequisiti hardware

Assicurati di avere l'hardware indicato di seguito:

1. Raspberry Pi 5 o Raspberry Pi 4 Model B
2. Telecamera AI Raspberry Pi

Collega la telecamera AI Raspberry Pi al connettore MIPI CSI a 15 pin sul Raspberry Pi e accendi il Raspberry Pi.

Prerequisiti software

Passo 1: Apri una finestra del terminale ed esegui i seguenti comandi per aggiornare il software Raspberry Pi all'ultima versione.

sudo apt update && sudo apt full-upgrade

Passaggio 2: installare il firmware IMX500 necessario per il funzionamento del sensore IMX500.

sudo apt install imx500-all

Passo 3: Riavvia Raspberry Pi affinché le modifiche abbiano effetto

sudo reboot

Passo 4: Installa la libreria del modulo applicativo Aitrios Raspberry Pi

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

Passo 5: Esegui il rilevamento oggetti e la stima della posa YOLO11 utilizzando gli script seguenti disponibili negli esempi della libreria del modulo applicativo aitrios-rpi.

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

Benchmark

I benchmark di YOLOv8n, YOLO11n, YOLOv8n-pose e YOLO11n-pose riportati di seguito sono stati eseguiti dal team di Ultralytics su Raspberry Pi AI Camera con imx misurando velocità e precisione.

Cosa c'è sotto il cofano?

Sony Model Compression Toolkit (MCT)

Il Model Compression Toolkit (MCT) di Sony è un potente strumento per ottimizzare i modelli di deep learning attraverso la quantizzazione e la pruning. Supporta vari metodi di quantizzazione e fornisce algoritmi avanzati per ridurre le dimensioni del modello e la complessità computazionale senza sacrificare significativamente l'accuratezza. MCT è particolarmente utile per distribuire modelli su dispositivi con risorse limitate, garantendo un'inferenza efficiente e una latenza ridotta.

Funzionalità supportate di MCT

L'MCT di Sony offre una serie di funzionalità progettate per ottimizzare i modelli di reti neurali:

1. Ottimizzazioni del grafo: Trasforma i modelli in versioni più efficienti integrando layer come la normalizzazione batch nei layer precedenti.
2. Ricerca dei parametri di quantizzazione: Riduce al minimo il rumore di quantizzazione utilizzando metriche come Mean-Square-Error, No-Clipping e Mean-Average-Error.
3. Algoritmi avanzati di quantizzazione:
   • Correzione dello shift negativo: Risolve i problemi di prestazioni derivanti dalla quantizzazione simmetrica dell'attivazione.
   • Filtraggio degli outlier: Utilizza lo z-score per rilevare e rimuovere gli outlier.
   • Clustering: Utilizza griglie di quantizzazione non uniformi per una migliore corrispondenza della distribuzione.
   • Ricerca di precisione mista: Assegna diverse bit-width di quantizzazione per layer in base alla sensibilità.
4. Visualizzazione: Utilizza TensorBoard per osservare informazioni sulle prestazioni del modello, fasi di quantizzazione e configurazioni di bit-width.

Quantizzazione

MCT supporta diversi metodi di quantizzazione per ridurre le dimensioni del modello e migliorare la velocità di inferenza:

1. Quantizzazione post-training (PTQ):
   • Disponibile tramite API Keras e PyTorch.
   • Complessità: Bassa
   • Costo computazionale: Basso (minuti di CPU)
2. Quantizzazione post-training basata su gradienti (GPTQ):
   • Disponibile tramite API Keras e PyTorch.
   • Complessità: Media
   • Costo computazionale: Moderato (2-3 ore di GPU)
3. Quantization-Aware Training (QAT):
   • Complessità: Alta
   • Costo computazionale: Alto (12-36 ore di GPU)

MCT supporta anche vari schemi di quantizzazione per pesi e attivazioni:

1. Potenza di due (hardware-friendly)
2. Simmetrica
3. Uniforme

Potatura strutturata

MCT introduce la potatura strutturata del modello, consapevole dell'hardware, progettata per specifiche architetture hardware. Questa tecnica sfrutta le capacità Single Instruction, Multiple Data (SIMD) della piattaforma di destinazione potando i gruppi SIMD. Ciò riduce le dimensioni e la complessità del modello ottimizzando al contempo l'utilizzo dei canali, in linea con l'architettura SIMD per l'utilizzo mirato delle risorse dell'impronta di memoria dei pesi. Disponibile tramite API Keras e PyTorch.

Strumento di conversione IMX500 (Compiler)

Lo strumento IMX500 Converter è parte integrante del toolset IMX500 e consente la compilazione di modelli per l'implementazione sul sensore IMX500 di Sony (ad esempio, Raspberry Pi AI Cameras). Questo strumento facilita la transizione dei modelli Ultralytics YOLO11 elaborati tramite il software Ultralytics, garantendo che siano compatibili e funzionino in modo efficiente sull'hardware specificato. La procedura di esportazione successiva alla quantizzazione del modello prevede la generazione di file binari che incapsulano dati essenziali e configurazioni specifiche del dispositivo, semplificando il processo di implementazione sulla Raspberry Pi AI Camera.

Casi d'uso reali

L'esportazione in formato IMX500 ha un'ampia applicabilità in diversi settori. Ecco alcuni esempi:

• Edge AI e IoT: Abilita il rilevamento di oggetti su droni o telecamere di sicurezza, dove l'elaborazione in tempo reale su dispositivi a bassa potenza è essenziale.
• Dispositivi indossabili: Implementa modelli ottimizzati per l'elaborazione AI su piccola scala su dispositivi indossabili per il monitoraggio della salute.
• Smart City: Utilizza i modelli YOLO11 esportati da IMX500 per il monitoraggio del traffico e l'analisi della sicurezza con un'elaborazione più rapida e una latenza minima.
• Retail Analytics: Migliora il monitoraggio in negozio implementando modelli ottimizzati nei sistemi point-of-sale o negli scaffali intelligenti.

Conclusione

L'esportazione di modelli Ultralytics YOLO11 in formato IMX500 di Sony consente di distribuire i modelli per un'inferenza efficiente su telecamere basate su IMX500. Sfruttando tecniche avanzate di quantizzazione, è possibile ridurre le dimensioni del modello e migliorare la velocità di inferenza senza compromettere significativamente l'accuratezza.

Per ulteriori informazioni e linee guida dettagliate, consultare il sito web IMX500 di Sony.

FAQ

Come posso esportare un modello YOLO11 in formato IMX500 per Raspberry Pi AI Camera?

Per esportare un modello YOLO11 in formato IMX500, usa l'API Python o il comando CLI:

from ultralytics import YOLO

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

Il processo di esportazione creerà una directory contenente i file necessari per l'implementazione, tra cui packerOut.zip.

Quali sono i principali vantaggi dell'utilizzo del formato IMX500 per la distribuzione di intelligenza artificiale edge?

Il formato IMX500 offre diversi vantaggi importanti per la distribuzione edge:

• L'elaborazione AI on-chip riduce la latenza e il consumo energetico
• Restituisce sia l'immagine che i metadati (risultato dell'inferenza) invece delle sole immagini
• Maggiore privacy grazie all'elaborazione locale dei dati senza dipendenza dal cloud
• Capacità di elaborazione in tempo reale ideali per applicazioni sensibili al fattore tempo
• Quantizzazione ottimizzata per un'implementazione efficiente del modello su dispositivi con risorse limitate

Quali sono i prerequisiti hardware e software necessari per la distribuzione IMX500?

Per l'implementazione di modelli IMX500, è necessario:

Hardware:

• Raspberry Pi 5 o Raspberry Pi 4 Model B
• Raspberry Pi AI Camera con sensore IMX500

Software:

• Raspberry Pi OS Bookworm
• Firmware e strumenti IMX500 (sudo apt install imx500-all)

Quali prestazioni posso aspettarmi dai modelli YOLO11 sull'IMX500?

Basato sui benchmark di Ultralytics su Raspberry Pi AI Camera:

• YOLO11n raggiunge un tempo di inferenza di 62,50 ms per immagine
• mAP50-95 di 0.492 sul dataset COCO128
• Dimensione del modello di soli 3,2 MB dopo la quantizzazione

Questo dimostra che il formato IMX500 fornisce un'inferenza efficiente in tempo reale, mantenendo al contempo una buona accuratezza per le applicazioni di edge AI.

📅 Creato 10 mesi fa ✏️ Aggiornato 19 giorni fa

Commenti