Link to this sectionEsportazione Sony IMX500 per Ultralytics YOLO11#

Questa guida copre l'esportazione e il deployment dei modelli Ultralytics YOLO11 su Raspberry Pi AI Camera dotate di sensore Sony IMX500.

Il deployment di modelli di computer vision su dispositivi con potenza computazionale limitata, come la Raspberry Pi AI Camera, può essere complesso. Utilizzare un formato di modello ottimizzato per prestazioni più veloci fa una grande differenza.

Il formato del modello IMX500 è progettato per consumare energia minima fornendo al contempo prestazioni veloci per le reti neurali. Ti consente di ottimizzare i tuoi modelli Ultralytics YOLO11 per un'inferenza ad alta velocità e basso consumo. In questa guida, ti guideremo attraverso l'esportazione e il deployment dei tuoi modelli nel formato IMX500, facilitando le prestazioni dei tuoi modelli sulla Raspberry Pi AI Camera.

Link to this sectionPerché esportare in IMX500?#

Il sensore di visione intelligente IMX500 di Sony è un pezzo di hardware rivoluzionario nell'elaborazione edge AI. È il primo sensore di visione intelligente al mondo con funzionalità AI on-chip. Questo sensore aiuta a superare molte sfide nell'edge AI, inclusi colli di bottiglia nell'elaborazione dei dati, problemi di privacy e limitazioni di prestazioni. Mentre altri sensori si limitano a trasmettere immagini e frame, l'IMX500 racconta una storia completa. Elabora i dati direttamente sul sensore, consentendo ai dispositivi di generare insight in tempo reale.

Link to this sectionEsportazione Sony IMX500 per modelli YOLO11#

L'IMX500 è progettato per trasformare il modo in cui i dispositivi gestiscono i dati direttamente sul sensore, senza bisogno 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 permettendo un'elaborazione veloce dei dati localmente, senza dipendenza dal cloud. L'elaborazione locale mantiene anche i dati degli utenti privati e sicuri 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 abbassare i costi.
• Affronta le preoccupazioni sulla privacy: Elaborando i dati sul dispositivo, l'IMX500 affronta le preoccupazioni sulla privacy, ideale per applicazioni incentrate sull'uomo come il conteggio delle persone e il monitoraggio dell'occupazione.
• Elaborazione in tempo reale: L'elaborazione veloce on-sensor supporta decisioni in tempo reale, perfetta per applicazioni edge AI come i sistemi autonomi.

Prima di iniziare: Per 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 all'ottimizzazione degli iperparametri.

Link to this sectionAttività supportate#

Attualmente, puoi esportare nel formato IMX500 solo i modelli che includono le seguenti attività.

• Object Detection
• Pose Estimation
• Classification
• Segmentazione dell'istanza

Link to this sectionEsempi di Utilizzo#

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

Il formato IMX500 supporta le modalità Export, Predict e Validate. L'inferenza e la convalida vengono eseguite sulla 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 sectionArgomenti di esportazione#

Per ulteriori 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 chiamata <model-name>_imx_model. Questa directory includerà il file packerOut.zip, essenziale per impacchettare il modello per il deployment sull'hardware IMX500. Inoltre, la cartella <model-name>_imx_model conterrà un file di testo (labels.txt) che elenca tutte le etichette associate al modello.

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

Link to this sectionUtilizzo dell'esportazione IMX500 nel deployment#

Dopo aver esportato il modello Ultralytics YOLO11n nel formato IMX500, può essere distribuito sulla Raspberry Pi AI Camera per l'inferenza.

Link to this sectionPrerequisiti hardware#

Assicurati di avere l'hardware seguente:

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

Collega la Raspberry Pi AI Camera al connettore MIPI CSI a 15 pin sulla Raspberry Pi e accendi la Raspberry Pi.

Link to this sectionPrerequisiti software#

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

sudo apt update && sudo apt full-upgrade

Passaggio 2: Installa il firmware IMX500, necessario per far funzionare il sensore IMX500.

sudo apt install imx500-all

Passaggio 3: Riavvia la Raspberry Pi affinché le modifiche abbiano effetto.

sudo reboot

Passaggio 4: Installa la libreria del modulo applicativo Aitrios Raspberry Pi.

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

Passaggio 5: Esegui rilevamento oggetti, stima della posa, classificazione e segmentazione 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 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 sectionBenchmark#

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

Link to this sectionCosa c'è sotto il cofano?#

Link to this sectionSony Model Compression Toolkit (MCT)#

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

Link to this sectionFunzionalità supportate da MCT#

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

1. Ottimizzazioni del grafo: Trasforma i modelli in versioni più efficienti ripiegando livelli come la batch normalization nei livelli 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 di quantizzazione avanzati:
   • Correzione dei negativi (Shift Negative Correction): Affronta i problemi di prestazioni derivanti dalla quantizzazione simmetrica dell'attivazione.
   • Filtraggio degli outlier: Utilizza il punteggio z per rilevare e rimuovere gli outlier.
   • Clustering: Utilizza griglie di quantizzazione non uniformi per una migliore corrispondenza della distribuzione.
   • Ricerca a precisione mista: Assegna diverse larghezze di bit di quantizzazione per livello in base alla sensibilità.
4. Visualizzazione: Utilizza TensorBoard per osservare gli insight sulle prestazioni del modello, le fasi di quantizzazione e le configurazioni della larghezza di bit.

Link to this sectionQuantizzazione#

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

1. Post-Training Quantization (PTQ):
   • Disponibile tramite API Keras e PyTorch.
   • Complessità: Bassa
   • Costo computazionale: Basso (minuti CPU)
2. Gradient-based Post-Training Quantization (GPTQ):
   • Disponibile tramite API Keras e PyTorch.
   • Complessità: Media
   • Costo computazionale: Moderato (2-3 ore GPU)
3. Quantization-Aware Training (QAT):
   • Complessità: Alta
   • Costo computazionale: Elevato (12-36 ore GPU)

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

1. Power-of-Two (compatibile con l'hardware)
2. Simmetrico
3. Uniforme

Link to this sectionPotatura strutturata#

MCT introduce la potatura del modello strutturata e hardware-aware progettata per architetture hardware specifiche. Questa tecnica sfrutta le capacità Single Instruction, Multiple Data (SIMD) della piattaforma target 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 un utilizzo mirato delle risorse di memoria dei pesi. Disponibile tramite le API Keras e PyTorch.

Link to this sectionStrumento di conversione IMX500 (Compilatore)#

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

Link to this sectionCasi d'uso nel mondo reale#

L'esportazione nel formato IMX500 ha un'ampia applicabilità in tutti i 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 basso consumo è essenziale.
• Dispositivi indossabili: distribuisci modelli ottimizzati per l'elaborazione AI su piccola scala su dispositivi indossabili per il monitoraggio della salute.
• Smart Cities: utilizza modelli YOLO11 esportati per IMX500 per il monitoraggio del traffico e l'analisi della sicurezza con un'elaborazione più rapida e una latenza minima.
• Analisi retail: migliora il monitoraggio in negozio distribuendo modelli ottimizzati nei sistemi point-of-sale o negli scaffali intelligenti.

Link to this sectionConclusione#

Esportare i modelli Ultralytics YOLO11 nel formato IMX500 di Sony ti consente di distribuire i tuoi modelli per un'inferenza efficiente su telecamere basate su IMX500. Sfruttando tecniche di quantizzazione avanzate, puoi ridurre le dimensioni del modello e migliorare la velocità di inferenza senza compromettere significativamente l'accuratezza.

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

Link to this sectionFAQ#

Link to this sectionCome posso esportare un modello YOLO11 nel formato IMX500 per Raspberry Pi AI Camera?#

Per esportare un modello YOLO11 nel formato IMX500, utilizza le 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 il deployment, incluso packerOut.zip.

Link to this sectionQuali sono i principali vantaggi dell'utilizzo del formato IMX500 per il deployment di Edge AI?#

Il formato IMX500 offre diversi importanti vantaggi per il deployment edge:

• L'elaborazione AI on-chip riduce la latenza e il consumo energetico
• Produce sia immagini che metadati (risultato dell'inferenza) invece delle sole immagini
• Privacy migliorata elaborando i dati localmente senza dipendenza dal cloud
• Capacità di elaborazione in tempo reale ideali per applicazioni sensibili al fattore tempo
• Quantizzazione ottimizzata per un efficiente deployment dei modelli su dispositivi con risorse limitate

Link to this sectionQuali prerequisiti hardware e software sono necessari per il deployment IMX500?#

Per il deployment dei modelli IMX500, ti serviranno:

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)

Link to this sectionQuali prestazioni posso aspettarmi dai modelli YOLO11 su IMX500?#

Basato sui benchmark di Ultralytics su Raspberry Pi AI Camera:

• YOLO11n raggiunge 58,82 ms di tempo di inferenza per immagine
• mAP50-95 di 0,517 sul dataset COCO128
• Dimensioni del modello di soli 2,2 MB dopo la quantizzazione

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