Esportazione di Sony IMX500 per Ultralytics YOLO11#

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

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

Il formato del modello IMX500 è progettato per ridurre al minimo il consumo energetico e offrire prestazioni elevate per le reti neurali. Ti consente di ottimizzare i modelli Ultralytics YOLO11 per inferenze rapide e a basso consumo. In questa guida vedremo come esportare e distribuire i tuoi modelli in formato IMX500, facilitandone l'esecuzione efficiente su Raspberry Pi AI Camera.

Perché esportare in formato IMX500?#

Il sensore di visione intelligente IMX500 di Sony è una novità rivoluzionaria nell'elaborazione di IA edge. È il primo sensore di visione intelligente al mondo dotato di funzionalità IA integrate nel chip. Questo sensore aiuta a superare molte sfide dell'IA edge, tra cui i colli di bottiglia nell'elaborazione dei dati, i problemi di privacy e i limiti di prestazioni. Mentre gli altri sensori si limitano a trasmettere immagini e fotogrammi, l'IMX500 racconta una storia completa. Elabora i dati direttamente sul sensore, consentendo ai dispositivi di generare informazioni utili in tempo reale.

Esportazione di 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 è compatibile con i modelli quantizzati. La quantizzazione riduce le dimensioni e aumenta la velocità dei modelli senza compromettere in modo significativo la precisione. È ideale per le risorse limitate dell'edge computing: consente alle applicazioni di rispondere rapidamente riducendo la latenza e permettendo l'elaborazione locale e rapida dei dati, senza dipendere dal cloud. L'elaborazione locale protegge inoltre la privacy e la sicurezza dei dati degli utenti, poiché non vengono inviati a un server remoto.

Funzionalità principali di IMX500:

• Output dei metadati: Invece di trasmettere soltanto immagini, IMX500 può fornire sia le immagini sia i metadati (risultati dell'inferenza), oppure soltanto i metadati per ridurre al minimo la quantità di dati, il consumo di banda e i costi.
• Tutela della 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 degli spazi.
• Elaborazione in tempo reale: L'elaborazione rapida direttamente sul sensore permette di prendere decisioni in tempo reale ed è perfetta per applicazioni di IA edge come i sistemi autonomi.

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

Attività supportate#

L'esportazione IMX500 supporta quattro dei sette task Ultralytics, esclusivamente per YOLOv8n e YOLO11n: le altre famiglie di modelli, dimensioni e architetture non sono supportate; inoltre, l'esportazione di un modello di segmentazione semantica, OBB o stima della profondità genera un errore.

Esempi d'uso#

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

Il formato IMX500 supporta le modalità Esportazione, Predizione e Convalida. L'inferenza e la convalida vengono eseguite su Raspberry Pi AI Camera (IMX500).

from ultralytics import YOLO

# Carica un modello YOLO11n PyTorch
model = YOLO("yolo11n.pt")

# Esporta il modello
model.export(format="imx", data="coco8.yaml")  # esporta con la quantizzazione PTQ per impostazione predefinita

# Carica il modello esportato
imx_model = YOLO("yolo11n_imx_model")

# Esegui l'inferenza
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carica un modello YOLO11n-pose PyTorch
model = YOLO("yolo11n-pose.pt")

# Esporta il modello
model.export(format="imx", data="coco8-pose.yaml")  # esporta con la quantizzazione PTQ per impostazione predefinita

# Carica il modello esportato
imx_model = YOLO("yolo11n-pose_imx_model")

# Esegui l'inferenza
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carica un modello YOLO11n-cls PyTorch
model = YOLO("yolo11n-cls.pt")

# Esporta il modello
model.export(format="imx", data="imagenet10")  # esporta con la quantizzazione PTQ per impostazione predefinita

# Carica il modello esportato
imx_model = YOLO("yolo11n-cls_imx_model")

# Esegui l'inferenza
results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

from ultralytics import YOLO

# Carica un modello YOLO11n-seg PyTorch
model = YOLO("yolo11n-seg.pt")

# Esporta il modello
model.export(format="imx", data="coco8-seg.yaml")  # esporta con la quantizzazione PTQ per impostazione predefinita

# Carica il modello esportato
imx_model = YOLO("yolo11n-seg_imx_model")

# Esegui l'inferenza
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carica il modello IMX500 esportato
model = YOLO("yolo11n_imx_model")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Argomenti di esportazione#

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

Il processo di esportazione crea un modello ONNX per la convalida della quantizzazione e una directory chiamata <model-name>_imx_model. Questa directory include il file packerOut.zip, indispensabile per preparare il modello alla distribuzione sull'hardware IMX500. Inoltre, la cartella <model-name>_imx_model contiene un file di testo (labels.txt) con l'elenco di 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

Usare l'esportazione IMX500 nella distribuzione#

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

Requisiti hardware#

Assicurati di disporre del seguente hardware:

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

Collega la fotocamera Raspberry Pi AI Camera al connettore MIPI CSI a 15 pin del Raspberry Pi, quindi accendi il Raspberry Pi

Requisiti software#

Passaggio 1: apri una finestra del terminale ed esegui i seguenti comandi per aggiornare il software Raspberry Pi alla versione più recente.

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 Raspberry Pi affinché le modifiche abbiano effetto

sudo reboot

Passaggio 4: installa la libreria del modulo applicativo Aitrios per Raspberry Pi

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

Passaggio 5: esegui il rilevamento di oggetti, la stima della posa, la classificazione e la 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()

Benchmark#

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

Cosa succede sotto il cofano?#

Toolkit di compressione dei modelli Sony (MCT)#

Toolkit di compressione dei modelli di Sony (MCT) è 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 dei modelli senza comprometterne significativamente la precisione. MCT è particolarmente utile per distribuire modelli su dispositivi con risorse limitate, garantendo inferenze efficienti e latenza ridotta.

Funzionalità supportate di MCT#

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, incorporando nei livelli precedenti livelli come quelli di normalizzazione del batch.
2. Ricerca dei parametri di quantizzazione: riduce al minimo il rumore di quantizzazione usando metriche come l'errore quadratico medio, l'assenza di clipping e l'errore medio assoluto.
3. Algoritmi avanzati di quantizzazione:
   • Correzione degli shift negativi: risolve i problemi di prestazioni derivanti dalla quantizzazione simmetrica delle attivazioni.
   • Filtraggio dei valori anomali: usa lo z-score per rilevare e rimuovere i valori anomali.
   • Clustering: usa griglie di quantizzazione non uniformi per adattarsi meglio alla distribuzione.
   • Ricerca a precisione mista: assegna a ogni livello una diversa larghezza di bit per la quantizzazione in base alla sensibilità.
4. Visualizzazione: usa TensorBoard per esaminare informazioni sulle prestazioni del modello, le fasi di quantizzazione e le configurazioni della larghezza di bit.

Quantizzazione#

MCT supporta diversi metodi di quantizzazione per ridurre le dimensioni dei modelli 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: elevato (12-36 ore di GPU)

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

1. Potenza di due (adatta all'hardware)
2. Simmetrica
3. Uniforme

Pruning strutturato#

MCT introduce il pruning strutturato dei modelli, consapevole dell'hardware e progettato per architetture hardware specifiche. Questa tecnica sfrutta le funzionalità SIMD (istruzione singola, dati multipli) della piattaforma di destinazione applicando il pruning ai 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 indirizzare l'utilizzo delle risorse e l'ingombro in memoria dei pesi. Disponibile tramite le API Keras e PyTorch.

Strumento di conversione IMX500 (compilatore)#

Lo strumento di conversione IMX500 è una parte essenziale del set di strumenti IMX500 e consente di compilare modelli da distribuire sul sensore IMX500 di Sony (ad esempio, sulle fotocamere AI per Raspberry Pi). 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 genera file binari che contengono dati essenziali e configurazioni specifiche del dispositivo, semplificando la distribuzione sulla fotocamera AI per Raspberry Pi.

Casi d’uso nel mondo reale#

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

• AI edge e IoT: abilita il rilevamento degli oggetti su droni o telecamere di sicurezza, dove è essenziale elaborare i dati in tempo reale su dispositivi a basso consumo.
• Dispositivi indossabili: distribuisci modelli ottimizzati per l'elaborazione AI su piccola scala su dispositivi indossabili per il monitoraggio della salute.
• Città intelligenti: usa i modelli YOLO11 esportati in IMX500 per il monitoraggio del traffico e l'analisi della sicurezza, con elaborazione più rapida e latenza minima.
• Analisi per il commercio al dettaglio: migliora il monitoraggio in negozio distribuendo modelli ottimizzati nei sistemi di pagamento o sugli scaffali intelligenti.

Conclusione#

Esportare i modelli Ultralytics YOLO11 nel formato IMX500 di Sony ti consente di distribuirli per eseguire inferenze in modo efficiente sulle telecamere basate su IMX500. Sfruttando tecniche di quantizzazione avanzate, puoi ridurre le dimensioni dei modelli e migliorare la velocità di inferenza senza comprometterne significativamente la precisione.

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

Domande frequenti#