Link to this sectionExportation Sony IMX500 pour Ultralytics YOLO11#

Ce guide explique comment exporter et déployer des modèles Ultralytics YOLO11 sur des Raspberry Pi AI Camera équipées du capteur Sony IMX500.

Le déploiement de modèles de vision par ordinateur sur des appareils aux capacités de calcul limitées, comme la Raspberry Pi AI Camera, peut être complexe. Utiliser un format de modèle optimisé pour une performance plus rapide fait une énorme différence.

Le format de modèle IMX500 est conçu pour consommer un minimum d'énergie tout en offrant des performances rapides pour les réseaux neuronaux. Il te permet d'optimiser tes modèles Ultralytics YOLO11 pour une inférence à haute vitesse et basse consommation. Dans ce guide, nous t'accompagnons dans l'exportation et le déploiement de tes modèles vers le format IMX500 tout en facilitant leur exécution sur la Raspberry Pi AI Camera.

Link to this sectionPourquoi exporter vers IMX500 ?#

Le capteur de vision intelligent IMX500 de Sony est une technologie révolutionnaire dans le traitement de l'IA en périphérie (edge AI). C'est le premier capteur de vision intelligent au monde doté de capacités d'IA intégrées sur la puce. Ce capteur aide à surmonter de nombreux défis de l'edge AI, notamment les goulots d'étranglement du traitement des données, les problèmes de confidentialité et les limitations de performance. Alors que d'autres capteurs se contentent de transmettre des images et des flux, l'IMX500 raconte toute l'histoire. Il traite les données directement sur le capteur, permettant aux appareils de générer des informations en temps réel.

Link to this sectionExportation Sony IMX500 pour modèles YOLO11#

L'IMX500 est conçu pour transformer la manière dont les appareils traitent les données directement sur le capteur, sans avoir besoin de les envoyer vers le cloud pour traitement.

L'IMX500 fonctionne avec des modèles quantifiés. La quantification rend les modèles plus petits et plus rapides sans trop perdre en précision. C'est idéal pour les ressources limitées de l'edge computing, permettant aux applications de répondre rapidement en réduisant la latence et en facilitant un traitement local rapide des données, sans dépendance au cloud. Le traitement local préserve également la confidentialité et la sécurité des données utilisateur, car elles ne sont pas envoyées vers un serveur distant.

Principales caractéristiques de l'IMX500 :

• Sortie de métadonnées : Au lieu de transmettre uniquement des images, l'IMX500 peut produire à la fois une image et des métadonnées (résultat d'inférence), ou uniquement des métadonnées pour minimiser la taille des données, réduire la bande passante et diminuer les coûts.
• Répond aux préoccupations de confidentialité : En traitant les données sur l'appareil, l'IMX500 résout les problèmes de confidentialité, ce qui est idéal pour les applications centrées sur l'humain comme le comptage de personnes et le suivi d'occupation.
• Traitement en temps réel : Le traitement rapide sur le capteur prend en charge des décisions en temps réel, parfait pour les applications d'edge AI comme les systèmes autonomes.

Avant de commencer : Pour de meilleurs résultats, assure-toi que ton modèle YOLO11 est bien préparé pour l'exportation en suivant nos guides de formation de modèle, de préparation des données et de réglage des hyperparamètres.

Link to this sectionTâches prises en charge#

Actuellement, tu ne peux exporter vers le format IMX500 que des modèles incluant les tâches suivantes.

• Détection d'objets
• Estimation de pose
• Classification
• Segmentation d'instance

Link to this sectionExemples d'utilisation#

Exporte un modèle Ultralytics YOLO11 au format IMX500 et effectue une inférence avec le modèle exporté.

Le format IMX500 prend en charge les modes Export, Predict et Validate. L'inférence et la validation s'exécutent sur la 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 sectionArguments d'exportation#

Pour plus de détails sur le processus d'exportation, visite la page de documentation Ultralytics sur l'exportation.

Le processus d'exportation créera un modèle ONNX pour la validation de la quantification, ainsi qu'un répertoire nommé <model-name>_imx_model. Ce répertoire inclura le fichier packerOut.zip, essentiel pour empaqueter le modèle en vue d'un déploiement sur le matériel IMX500. De plus, le dossier <model-name>_imx_model contiendra un fichier texte (labels.txt) listant toutes les étiquettes associées au modèle.

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

Link to this sectionUtilisation de l'exportation IMX500 dans le déploiement#

Après avoir exporté le modèle Ultralytics YOLO11n au format IMX500, il peut être déployé sur une Raspberry Pi AI Camera pour l'inférence.

Link to this sectionPrérequis matériels#

Assure-toi de disposer du matériel suivant :

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

Connecte la Raspberry Pi AI Camera au connecteur MIPI CSI 15 broches sur la Raspberry Pi et mets la Raspberry Pi sous tension

Link to this sectionPrérequis logiciels#

Étape 1 : Ouvre une fenêtre de terminal et exécute les commandes suivantes pour mettre à jour le logiciel de la Raspberry Pi vers la dernière version.

sudo apt update && sudo apt full-upgrade

Étape 2 : Installe le firmware IMX500 nécessaire au fonctionnement du capteur IMX500.

sudo apt install imx500-all

Étape 3 : Redémarre la Raspberry Pi pour que les changements prennent effet

sudo reboot

Étape 4 : Installe la bibliothèque du module d'application Aitrios pour Raspberry Pi

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

Étape 5 : Exécute la détection d'objets, l'estimation de pose, la classification et la segmentation YOLO11 en utilisant les scripts ci-dessous disponibles dans les exemples de la bibliothèque du module d'application 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 sectionBenchmarks#

Les benchmarks YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls et YOLO11n-cls ci-dessous ont été réalisés par l'équipe Ultralytics sur une Raspberry Pi AI Camera avec le format de modèle imx, en mesurant la vitesse et la précision.

Link to this sectionQu'y a-t-il sous le capot ?#

Link to this sectionSony Model Compression Toolkit (MCT)#

Le Sony Model Compression Toolkit (MCT) est un outil puissant pour optimiser les modèles de deep learning via la quantification et l'élagage. Il prend en charge diverses méthodes de quantification et fournit des algorithmes avancés pour réduire la taille et la complexité computationnelle du modèle sans sacrifier significativement la précision. MCT est particulièrement utile pour déployer des modèles sur des appareils aux ressources limitées, garantissant une inférence efficace et une latence réduite.

Link to this sectionFonctionnalités prises en charge par MCT#

Le MCT de Sony offre une gamme de fonctionnalités conçues pour optimiser les modèles de réseaux neuronaux :

1. Optimisations de graphes : Transforme les modèles en versions plus efficaces en fusionnant des couches comme la normalisation par lots (batch normalization) dans les couches précédentes.
2. Recherche de paramètres de quantification : Minimise le bruit de quantification en utilisant des métriques comme l'erreur quadratique moyenne (Mean-Square-Error), le No-Clipping et l'erreur absolue moyenne (Mean-Average-Error).
3. Algorithmes de quantification avancés :
   • Correction de décalage négatif : Traite les problèmes de performance liés à la quantification symétrique des activations.
   • Filtrage des valeurs aberrantes : Utilise le score z pour détecter et supprimer les valeurs aberrantes.
   • Clustering : Utilise des grilles de quantification non uniformes pour une meilleure correspondance de distribution.
   • Recherche de précision mixte : Attribue des largeurs de bits de quantification différentes par couche en fonction de leur sensibilité.
4. Visualisation : Utilise TensorBoard pour observer les informations sur les performances du modèle, les phases de quantification et les configurations de largeur de bits.

Link to this sectionQuantification#

MCT prend en charge plusieurs méthodes de quantification pour réduire la taille du modèle et améliorer la vitesse d'inférence :

1. Post-Training Quantization (PTQ) :
   • Disponible via les API Keras et PyTorch.
   • Complexité : Faible
   • Coût computationnel : Faible (minutes CPU)
2. Gradient-based Post-Training Quantization (GPTQ) :
   • Disponible via les API Keras et PyTorch.
   • Complexité : Moyenne
   • Coût computationnel : Modéré (2-3 heures GPU)
3. Quantization-Aware Training (QAT) :
   • Complexité : Élevée
   • Coût computationnel : Élevé (12-36 heures GPU)

MCT prend également en charge divers schémas de quantification pour les poids et les activations :

1. Power-of-Two (adapté au matériel)
2. Symétrique
3. Uniforme

Link to this sectionÉlagage structuré#

MCT introduit un élagage de modèle structuré et conscient du matériel, conçu pour des architectures matérielles spécifiques. Cette technique tire parti des capacités SIMD (Single Instruction, Multiple Data) de la plateforme cible en élaguant les groupes SIMD. Cela réduit la taille et la complexité du modèle tout en optimisant l'utilisation des canaux, en alignement avec l'architecture SIMD pour une utilisation ciblée des ressources de l'empreinte mémoire des poids. Disponible via les API Keras et PyTorch.

Link to this sectionOutil de conversion IMX500 (Compilateur)#

L'outil de conversion IMX500 fait partie intégrante de la suite d'outils IMX500, permettant la compilation de modèles pour un déploiement sur le capteur IMX500 de Sony (par exemple, les caméras Raspberry Pi AI Camera). Cet outil facilite la transition des modèles Ultralytics YOLO11 traités via le logiciel Ultralytics, en assurant leur compatibilité et leurs performances efficaces sur le matériel spécifié. La procédure d'exportation suivant la quantification du modèle implique la génération de fichiers binaires qui encapsulent les données essentielles et les configurations spécifiques à l'appareil, rationalisant ainsi le processus de déploiement sur la Raspberry Pi AI Camera.

Link to this sectionCas d'utilisation réels#

L'exportation vers le format IMX500 a une large applicabilité dans tous les secteurs. Voici quelques exemples :

• Edge AI et IoT : Permet la détection d'objets sur des drones ou des caméras de sécurité, où le traitement en temps réel sur des appareils à faible consommation est essentiel.
• Appareils portables : Déploie des modèles optimisés pour le traitement IA à petite échelle sur des objets connectés de suivi de santé.
• Smart Cities : Utilise les modèles YOLO11 exportés pour IMX500 pour la surveillance du trafic et l'analyse de sécurité avec un traitement plus rapide et une latence minimale.
• Analyse de vente au détail : Améliore la surveillance en magasin en déployant des modèles optimisés dans les systèmes de point de vente ou les étagères intelligentes.

Link to this sectionConclusion#

L'exportation des modèles Ultralytics YOLO11 vers le format IMX500 de Sony te permet de déployer tes modèles pour une inférence efficace sur des caméras basées sur IMX500. En tirant parti de techniques de quantification avancées, tu peux réduire la taille du modèle et améliorer la vitesse d'inférence sans compromettre significativement la précision.

Pour plus d'informations et des directives détaillées, reporte-toi au site Web IMX500 de Sony.

Link to this sectionFAQ#

Link to this sectionComment exporter un modèle YOLO11 au format IMX500 pour la Raspberry Pi AI Camera ?#

Pour exporter un modèle YOLO11 au format IMX500, utilise l'API Python ou la commande CLI :

from ultralytics import YOLO

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

Le processus d'exportation créera un répertoire contenant les fichiers nécessaires au déploiement, y compris packerOut.zip.

Link to this sectionQuels sont les principaux avantages de l'utilisation du format IMX500 pour le déploiement Edge AI ?#

Le format IMX500 offre plusieurs avantages importants pour le déploiement en périphérie (edge) :

• Le traitement IA sur puce réduit la latence et la consommation d'énergie
• Produit à la fois des images et des métadonnées (résultat d'inférence) au lieu d'images uniquement
• Confidentialité renforcée par le traitement local des données sans dépendance au cloud
• Capacités de traitement en temps réel idéales pour les applications sensibles au facteur temps
• Quantification optimisée pour un déploiement efficace des modèles sur des appareils aux ressources limitées

Link to this sectionQuels sont les prérequis matériels et logiciels nécessaires au déploiement sur IMX500 ?#

Pour déployer des modèles IMX500, tu auras besoin de :

Matériel :

• Raspberry Pi 5 ou Raspberry Pi 4 Model B
• Raspberry Pi AI Camera avec capteur IMX500

Logiciel :

• Raspberry Pi OS Bookworm
• Firmware et outils IMX500 (sudo apt install imx500-all)

Link to this sectionQuelles performances puis-je attendre des modèles YOLO11 sur l'IMX500 ?#

Basé sur les benchmarks d'Ultralytics sur la Raspberry Pi AI Camera :

• YOLO11n atteint un temps d'inférence de 58,82 ms par image
• mAP50-95 de 0,517 sur le dataset COCO128
• Taille du modèle de seulement 2,2 Mo après quantification

Cela démontre que le format IMX500 fournit une inférence efficace en temps réel tout en maintenant une bonne précision pour les applications Edge AI.