Esportazione Sony IMX500 per Ultralytics YOLO11#

Questa guida illustra come esportare e distribuire i modelli Ultralytics YOLO11 sulle Raspberry Pi AI Cameras dotate del sensore Sony IMX500.

Distribuire modelli di visione artificiale su dispositivi con potenza di calcolo limitata, come Raspberry Pi AI Camera, può essere complicato. Utilizzare un formato del modello ottimizzato per prestazioni più elevate fa una grande differenza.

Il formato del modello IMX500 è progettato per utilizzare una potenza minima offrendo al contempo prestazioni elevate per le reti neurali. Ti consente di ottimizzare i tuoi modelli Ultralytics YOLO11 per l'inferenza ad alta velocità e a basso consumo energetico. In questa guida ti illustreremo come esportare e distribuire i tuoi modelli nel formato IMX500, semplificando al contempo l'ottenimento di buone prestazioni sulla Raspberry Pi AI Camera.

Perché esportare nel formato IMX500?#

Il sensore di visione intelligente IMX500 di Sony è un componente hardware rivoluzionario per l'elaborazione edge AI. È il primo sensore di visione intelligente al mondo con funzionalità AI integrate nel chip. Questo sensore contribuisce a superare molte difficoltà dell'edge AI, tra cui i colli di bottiglia nell'elaborazione dei dati, i problemi di privacy e le limitazioni delle prestazioni. Mentre gli altri sensori si limitano a trasmettere immagini e fotogrammi, IMX500 racconta l'intera storia. Elabora i dati direttamente sul sensore, consentendo ai dispositivi di generare informazioni in tempo reale.

Esportazione Sony IMX500 per i modelli YOLO11#

IMX500 è progettato per trasformare il modo in cui i dispositivi gestiscono i dati direttamente sul sensore, senza doverli inviare al cloud per l'elaborazione.

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

Funzionalità principali di IMX500:

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

Prima di iniziare: Per ottenere i risultati migliori, assicurati che il tuo modello YOLO11 sia preparato correttamente per l'esportazione seguendo la nostra Guida all'addestramento del modello, la Guida alla preparazione dei dati e la Guida all'ottimizzazione degli iperparametri.

Attività supportate#

L'esportazione IMX500 supporta quattro delle sette attività Ultralytics, e solo per YOLOv8n e YOLO11n: le altre famiglie di modelli, gli altri fattori di scala e le altre architetture non sono supportati; inoltre, l'esportazione di un modello di segmentazione semantica, OBB o stima della profondità genera un errore.

Esempi di utilizzo#

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

Il formato IMX500 supporta le modalità Esportazione, Predizione e Validazione. L'inferenza e la validazione 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")

Argomenti di esportazione#

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

Il processo di esportazione creerà un modello ONNX per la validazione della quantizzazione, insieme a una directory denominata <model-name>_imx_model. Questa directory includerà il file packerOut.zip, essenziale per preparare il modello alla distribuzione 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

Utilizzo dell'esportazione IMX500 nella distribuzione#

Dopo aver esportato il modello Ultralytics YOLO11n nel formato IMX500, puoi distribuirlo sulla Raspberry Pi AI Camera per eseguire l'inferenza.

Prerequisiti hardware#

Assicurati di avere il seguente hardware:

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.

Prerequisiti software#

Passaggio 1: apri una finestra del 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 utilizzare il sensore IMX500.

sudo apt install imx500-all

Passaggio 3: riavvia la Raspberry Pi per rendere effettive le modifiche.

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 il rilevamento degli oggetti, la stima della posa, la classificazione e la segmentazione con 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()

Benchmark#

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

Cosa succede internamente?#

Model Compression Toolkit (MCT) di Sony#

Il Model Compression Toolkit (MCT) di Sony è uno strumento potente per ottimizzare i modelli di deep learning tramite quantizzazione e pruning. Supporta diversi metodi di quantizzazione e offre algoritmi avanzati per ridurre le dimensioni e la complessità computazionale del modello 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 da MCT#

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

1. Ottimizzazioni del grafo: trasformano i modelli in versioni più efficienti incorporando livelli come la normalizzazione dei batch nei livelli precedenti.
2. Ricerca dei parametri di quantizzazione: minimizza il rumore di quantizzazione utilizzando metriche come l'errore quadratico medio, No-Clipping e l'errore medio assoluto.
3. Algoritmi avanzati di quantizzazione:
   • Correzione dello shift negativo: affronta i problemi di prestazioni derivanti dalla quantizzazione simmetrica delle attivazioni.
   • Filtraggio degli outlier: utilizza lo z-score per rilevare e rimuovere gli outlier.
   • Clustering: utilizza griglie di quantizzazione non uniformi per adattarsi meglio alla distribuzione.
   • Ricerca a precisione mista: assegna ampiezze diverse in bit per la quantizzazione di ogni livello in base alla sensibilità.
4. Visualizzazione: utilizza TensorBoard per osservare informazioni sulle prestazioni del modello, le fasi di quantizzazione e le configurazioni dell'ampiezza in bit.

Quantizzazione#

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

1. Quantizzazione post-addestramento (PTQ):
   • Disponibile tramite le API Keras e PyTorch.
   • Complessità: bassa
   • Costo computazionale: basso (minuti di CPU)
2. Quantizzazione post-addestramento basata sul gradiente (GPTQ):
   • Disponibile tramite le API Keras e PyTorch.
   • Complessità: media
   • Costo computazionale: moderato (2-3 ore di GPU)
3. Addestramento consapevole della quantizzazione (QAT):
   • Complessità: alta
   • Costo computazionale: alto (12-36 ore di GPU)

MCT supporta inoltre diversi schemi di quantizzazione per pesi e attivazioni:

1. Potenza di due (compatibile con l'hardware)
2. Simmetrica
3. Uniforme

Pruning strutturato#

MCT introduce il pruning strutturato e consapevole dell'hardware, progettato per architetture hardware specifiche. Questa tecnica sfrutta le funzionalità Single Instruction, Multiple Data (SIMD) della piattaforma di destinazione eseguendo il pruning dei gruppi SIMD. 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 dell'ingombro in memoria dei pesi. Disponibile tramite le API Keras e PyTorch.

Strumento di conversione IMX500 (compilatore)#

IMX500 Converter Tool è parte integrante dell'insieme di strumenti IMX500 e consente di compilare i modelli per la distribuzione sul sensore IMX500 di Sony (ad esempio, sulle Raspberry Pi AI Cameras). Questo strumento facilita la transizione dei modelli Ultralytics YOLO11 elaborati tramite il software Ultralytics, garantendone la compatibilità e prestazioni efficienti sull'hardware specificato. La procedura di esportazione successiva alla quantizzazione del modello prevede la generazione di file binari che racchiudono dati essenziali e configurazioni specifiche del dispositivo, semplificando il processo di distribuzione sulla Raspberry Pi AI Camera.

Casi d'uso nel mondo reale#

L'esportazione nel formato IMX500 è ampiamente applicabile in diversi settori. Ecco alcuni esempi:

• Edge AI e IoT: abilita il rilevamento degli 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 in dispositivi indossabili per il monitoraggio della salute.
• Città intelligenti: utilizza i modelli YOLO11 esportati in IMX500 per il monitoraggio del traffico e l'analisi della sicurezza, con un'elaborazione più rapida e una latenza minima.
• Analisi del commercio al dettaglio: migliora il monitoraggio nei negozi distribuendo modelli ottimizzati nei sistemi dei punti vendita o sugli scaffali intelligenti.

Conclusioni#

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 avanzate di quantizzazione, 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.

FAQ#