Export Sony IMX500 pour Ultralytics YOLO11#

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

Le déploiement de modèles de vision par ordinateur sur des appareils disposant d'une puissance de calcul limitée, comme la Raspberry Pi AI Camera, peut être complexe. Utiliser un format de modèle optimisé pour de meilleures performances fait une grande différence.

Le format de modèle IMX500 est conçu pour consommer peu d'énergie tout en offrant de hautes performances pour les réseaux neuronaux. Il te permet d'optimiser tes modèles Ultralytics YOLO11 pour des inférences rapides et économes en énergie. Dans ce guide, nous t'expliquerons comment exporter et déployer tes modèles au format IMX500 afin de faciliter leur exécution efficace sur la Raspberry Pi AI Camera.

Pourquoi exporter au format IMX500 ?#

Le capteur de vision intelligent IMX500 de Sony est un composant matériel révolutionnaire pour le traitement de l'IA en périphérie. Il s'agit du premier capteur de vision intelligent au monde doté de capacités d'IA directement intégrées à la puce. Ce capteur permet de relever de nombreux défis de l'IA en périphérie, notamment les goulots d'étranglement du traitement des données, les problèmes de confidentialité et les limites de performance. Alors que les autres capteurs se contentent de transmettre des images et des trames, l'IMX500 raconte toute l'histoire. Il traite les données directement sur le capteur, ce qui permet aux appareils de générer des informations en temps réel.

Export Sony IMX500 pour les 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 dans 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 perte importante d'exactitude. Elle est idéale pour les ressources limitées de l'informatique en périphérie : les applications peuvent répondre rapidement grâce à la réduction de la latence et au traitement local accéléré des données, sans dépendre du cloud. Le traitement local protège également la confidentialité et la sécurité des données des utilisateurs, puisqu'elles ne sont pas envoyées à un serveur distant.

Fonctionnalités clés de l'IMX500 :

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

Avant de commencer : Pour obtenir les meilleurs résultats, assure-toi que ton modèle YOLO11 est correctement préparé pour l'export en suivant notre guide d'entraînement des modèles, notre guide de préparation des données et notre guide de réglage des hyperparamètres.

Tâches prises en charge#

L'export IMX500 prend en charge quatre des sept tâches Ultralytics, et uniquement pour YOLOv8n et YOLO11n : les autres familles de modèles, tailles et architectures ne sont pas prises en charge, et l'export d'un modèle de segmentation sémantique, OBB ou d'estimation de profondeur génère une erreur.

Exemples d’utilisation#

Exporter un modèle Ultralytics YOLO11 au format IMX500 et effectuer des inférences avec le modèle exporté.

Le format IMX500 prend en charge les modes Export, Predict et Validate. Les inférences 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")

Arguments d'exportation#

Pour plus de détails sur le processus d’exportation, consulte la page de la documentation Ultralytics consacrée à l’exportation.

Le processus d'export crée un modèle ONNX pour valider la quantification, ainsi qu'un répertoire nommé <model-name>_imx_model. Ce répertoire contient le fichier packerOut.zip, indispensable pour empaqueter le modèle en vue de son déploiement sur le matériel IMX500. En outre, le dossier <model-name>_imx_model contient un fichier texte (labels.txt) qui répertorie tous les labels associés au modèle.

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

Utiliser l'export IMX500 lors du déploiement#

Après l'export du modèle Ultralytics YOLO11n au format IMX500, celui-ci peut être déployé sur une Raspberry Pi AI Camera pour effectuer des inférences.

Prérequis matériels#

Assure-toi de disposer du matériel ci-dessous :

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

Connecte la caméra Raspberry Pi AI au connecteur MIPI CSI à 15 broches de la Raspberry Pi, puis allume la Raspberry Pi.

Pré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 requis pour faire fonctionner le capteur IMX500.

sudo apt install imx500-all

Étape 3 : Redémarre la Raspberry Pi pour appliquer les modifications.

sudo reboot

Étape 4 : Installe la bibliothèque de modules d'application Aitrios 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 à l'aide des scripts ci-dessous, disponibles dans les exemples de la bibliothèque de modules 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()

Benchmarks#

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 l'exactitude.

Que se passe-t-il en coulisses ?#

Kit de compression de modèles de Sony (MCT)#

Le kit de compression de modèles de Sony (MCT) est un outil puissant permettant d'optimiser les modèles de deep learning grâce à 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é des modèles sans sacrifier significativement l'exactitude. MCT est particulièrement utile pour déployer des modèles sur des appareils aux ressources limitées, en garantissant des inférences efficaces et une latence réduite.

Fonctionnalités prises en charge par MCT#

Le MCT de Sony propose diverses fonctionnalités conçues pour optimiser les modèles de réseaux neuronaux :

1. Optimisations du graphe : Transforme les modèles en versions plus efficaces en fusionnant des couches telles que la normalisation par lots avec les couches précédentes.
2. Recherche des paramètres de quantification : Réduit le bruit de quantification à l'aide de métriques telles que l'erreur quadratique moyenne, No-Clipping et l'erreur moyenne absolue.
3. Algorithmes avancés de quantification :
   • Correction des décalages négatifs : Répond aux 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.
   • Regroupement : Utilise des grilles de quantification non uniformes pour mieux faire correspondre les distributions.
   • Recherche en précision mixte : Attribue différentes largeurs de bits de quantification à chaque couche en fonction de sa 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.

Quantification#

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

1. Quantification post-entraînement (PTQ) :
   • Disponible via les API Keras et PyTorch.
   • Complexité : faible
   • Coût de calcul : faible (quelques minutes sur CPU)
2. Quantification post-entraînement basée sur le gradient (GPTQ) :
   • Disponible via les API Keras et PyTorch.
   • Complexité : moyenne
   • Coût de calcul : modéré (2 à 3 heures sur GPU)
3. Quantification consciente de l'entraînement (QAT) :
   • Complexité : élevée
   • Coût de calcul : élevé (12 à 36 heures sur GPU)

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

1. Puissance de deux (adapté au matériel)
2. Symétrique
3. Uniforme

Élagage structuré#

MCT introduit un élagage structuré et adapté au matériel, conçu pour des architectures matérielles spécifiques. Cette technique exploite les capacités de traitement « instruction unique, données multiples » (SIMD) de la plateforme cible en élaguant des groupes SIMD. Elle réduit la taille et la complexité du modèle tout en optimisant l'utilisation des canaux, conformément à l'architecture SIMD, afin d'optimiser l'utilisation ciblée de l'empreinte mémoire des poids. Disponible via les API Keras et PyTorch.

Outil de conversion IMX500 (compilateur)#

L'outil de conversion IMX500 est un élément essentiel de la suite d'outils IMX500. Il permet de compiler des modèles pour leur déploiement sur le capteur IMX500 de Sony, notamment dans les Raspberry Pi AI Cameras. Cet outil facilite la transition des modèles Ultralytics YOLO11 traités avec le logiciel Ultralytics, en garantissant leur compatibilité et leur efficacité sur le matériel spécifié. Après la quantification du modèle, la procédure d'export génère des fichiers binaires contenant les données essentielles et les configurations spécifiques à l'appareil, ce qui simplifie le déploiement sur la Raspberry Pi AI Camera.

Cas d’utilisation réels#

L'export au format IMX500 est largement applicable dans de nombreux secteurs. En voici quelques exemples :

• IA en périphérie et IoT : Active 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 peu énergivores est essentiel.
• Appareils portables : Déploie des modèles optimisés pour le traitement de l'IA à petite échelle sur des appareils portables de suivi de la santé.
• Villes intelligentes : Utilise des modèles YOLO11 exportés au format IMX500 pour surveiller le trafic et analyser la sécurité, avec un traitement plus rapide et une latence minimale.
• Analyse du commerce de détail : Améliore la surveillance en magasin en déployant des modèles optimisés dans des systèmes de point de vente ou des rayons intelligents.

Conclusion#

L'export des modèles Ultralytics YOLO11 au format IMX500 de Sony permet de les déployer pour effectuer des inférences efficaces sur des caméras basées sur l'IMX500. Grâce à des techniques avancées de quantification, tu peux réduire la taille du modèle et améliorer la vitesse d'inférence sans compromettre significativement l'exactitude.

Pour plus d'informations et des consignes détaillées, consulte le site web IMX500 de Sony.

FAQ#