Export Sony IMX500 pour Ultralytics YOLO11#

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

Le déploiement de modèles de vision par ordinateur sur des appareils à puissance de calcul limitée, comme la Raspberry Pi AI Camera, peut être compliqué. L’utilisation d’un format de modèle optimisé pour accélérer les performances fait toute la différence.

Le format de modèle IMX500 est conçu pour consommer peu d’énergie tout en offrant des performances rapides pour les réseaux neuronaux. Il permet d’optimiser tes modèles Ultralytics YOLO11 afin d’effectuer des inférences rapides et peu énergivores. Dans ce guide, nous allons voir comment exporter et déployer tes modèles au format IMX500 afin qu’ils fonctionnent efficacement 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. C’est le premier capteur de vision intelligent au monde doté de capacités d’IA intégrées à la puce. Ce capteur permet de surmonter de nombreux défis liés à 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 produire des informations exploitables en temps réel.

Export Sony IMX500 pour les modèles YOLO11#

L’IMX500 est conçu pour transformer la façon dont les appareils traitent les données directement sur le capteur, sans devoir les envoyer dans le cloud pour les traiter.

L’IMX500 est compatible avec les modèles quantifiés. La quantification rend les modèles plus petits et plus rapides sans perte importante de précision. Elle convient parfaitement aux ressources limitées de l’informatique en périphérie : les applications peuvent ainsi répondre rapidement grâce à une latence réduite et à un traitement local rapide des données, sans dépendre du cloud. Le traitement local préserve également la confidentialité et la sécurité des données des utilisateurs, puisqu’elles ne sont pas envoyées à un serveur distant.

Principales fonctionnalité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 de l’inférence), ou uniquement les métadonnées afin de réduire la taille des données, la bande passante nécessaire et les coûts.
• Répond aux enjeux de confidentialité : en traitant les données sur l’appareil, l’IMX500 répond aux enjeux de confidentialité et convient parfaitement aux applications centrées sur l’humain, comme le comptage des personnes et le suivi de l’occupation des espaces.
• Traitement en temps réel : le traitement rapide directement sur le capteur permet de prendre des décisions en temps réel, ce qui convient parfaitement aux applications d’IA en périphérie, comme les systèmes autonomes.

Avant de commencer : pour obtenir les meilleurs résultats, assure-toi que ton modèle YOLO11 est bien préparé pour l’exportation 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’exportation IMX500 prend en charge quatre des sept tâches Ultralytics, uniquement pour YOLOv8n et YOLO11n : les autres familles, tailles et architectures de modèles ne sont pas prises en charge, et l’exportation d’un modèle de segmentation sémantique, OBB ou d’estimation de profondeur génère une erreur.

Exemples d'utilisation#

Exporte un modèle Ultralytics YOLO11 au format IMX500 et lance l’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

# Charger un modèle YOLO11n PyTorch
model = YOLO("yolo11n.pt")

# Exporter le modèle
model.export(format="imx", data="coco8.yaml")  # les exportations utilisent la quantification PTQ par défaut

# Charger le modèle exporté
imx_model = YOLO("yolo11n_imx_model")

# Exécuter l’inférence
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Charger un modèle YOLO11n-pose PyTorch
model = YOLO("yolo11n-pose.pt")

# Exporter le modèle
model.export(format="imx", data="coco8-pose.yaml")  # les exportations utilisent la quantification PTQ par défaut

# Charger le modèle exporté
imx_model = YOLO("yolo11n-pose_imx_model")

# Exécuter l’inférence
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Charger un modèle YOLO11n-cls PyTorch
model = YOLO("yolo11n-cls.pt")

# Exporter le modèle
model.export(format="imx", data="imagenet10")  # les exportations utilisent la quantification PTQ par défaut

# Charger le modèle exporté
imx_model = YOLO("yolo11n-cls_imx_model")

# Exécuter l’inférence
results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

from ultralytics import YOLO

# Charger un modèle YOLO11n-seg PyTorch
model = YOLO("yolo11n-seg.pt")

# Exporter le modèle
model.export(format="imx", data="coco8-seg.yaml")  # les exportations utilisent la quantification PTQ par défaut

# Charger le modèle exporté
imx_model = YOLO("yolo11n-seg_imx_model")

# Exécuter l’inférence
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Charger le modèle IMX500 exporté
model = YOLO("yolo11n_imx_model")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

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

Le processus d’exportation crée un modèle ONNX pour la validation de 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. De plus, le dossier <model-name>_imx_model contient un fichier texte (labels.txt) qui répertorie 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

Utiliser l’exportation IMX500 pour le déploiement#

Après l’exportation d’un modèle Ultralytics YOLO11n au format IMX500, tu peux le déployer sur la Raspberry Pi AI Camera pour effectuer des inférences.

Prérequis matériels#

Assure-toi de disposer du matériel suivant :

1. Raspberry Pi 5 ou Raspberry Pi 4 Model B
2. Caméra AI Raspberry Pi

Connecte la caméra Raspberry Pi AI Camera au connecteur MIPI CSI à 15 broches du Raspberry Pi, puis allume le Raspberry Pi

Prérequis logiciels#

Étape 1 : ouvre une fenêtre de terminal et exécute les commandes suivantes pour mettre à jour le logiciel Raspberry Pi vers la version la plus récente.

sudo apt update && sudo apt full-upgrade

Étape 2 : installe le micrologiciel IMX500 nécessaire au fonctionnement du capteur IMX500.

sudo apt install imx500-all

Étape 3 : redémarre le Raspberry Pi pour que les modifications 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 à l’aide des 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()

Benchmarks#

Les benchmarks ci-dessous pour YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls et YOLO11n-cls ont été réalisés par l’équipe Ultralytics sur la Raspberry Pi AI Camera, au format de modèle imx, afin de mesurer la vitesse et la précision.

Qu’y a-t-il sous le capot ?#

Sony Model Compression Toolkit (MCT)#

Le Model Compression Toolkit (MCT) de Sony est un puissant outil qui optimise les modèles d’apprentissage profond par quantification et élagage. Il prend en charge diverses méthodes de quantification et fournit des algorithmes avancés pour réduire la taille des modèles et leur complexité computationnelle sans sacrifier significativement la précision. MCT est particulièrement utile pour déployer des modèles sur des appareils aux ressources limitées, afin de garantir une inférence efficace et une latence réduite.

Fonctionnalités prises en charge par MCT#

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, comme la normalisation par lots, avec les couches précédentes.
2. Recherche des paramètres de quantification : minimise le bruit de quantification à l’aide de métriques comme l’erreur quadratique moyenne, l’absence d’écrêtage et l’erreur absolue moyenne.
3. Algorithmes de quantification avancés :
   • Correction des décalages négatifs : corrige les problèmes de performances dus à 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 correspondre à la distribution.
   • Recherche à précision mixte : attribue différents nombres de bits de quantification à chaque couche en fonction de sa sensibilité.
4. Visualisation : utilise TensorBoard pour examiner les informations sur les performances du modèle, les phases de quantification et les configurations du nombre de bits.

Quantification#

MCT prend en charge plusieurs méthodes de quantification pour réduire la taille des modèles et accélérer l’inférence :

1. Quantification après entraînement (PTQ) :
   • Disponible via les API Keras et PyTorch.
   • Complexité : faible
   • Coût de calcul : faible (quelques minutes sur CPU)
2. Quantification après 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. Entraînement sensible à la quantification (QAT) :
   • Complexité : élevée
   • Coût de calcul : élevé (12 à 36 heures sur GPU)

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

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

Élagage structuré#

MCT propose un élagage structuré des modèles, adapté au matériel et conçu pour des architectures matérielles spécifiques. Cette technique exploite les capacités SIMD de la plateforme cible en élaguant des groupes SIMD. Elle réduit la taille et la complexité des modèles tout en optimisant l’utilisation des canaux, conformément à l’architecture SIMD, afin d’utiliser de manière ciblée les ressources liées à 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 l’ensemble d’outils IMX500 : il permet de compiler des modèles pour les déployer sur le capteur IMX500 de Sony (par exemple, les caméras Raspberry Pi AI Camera). Cet outil facilite le transfert des modèles Ultralytics YOLO11 traités avec les logiciels Ultralytics et garantit leur compatibilité ainsi que leur bon fonctionnement sur le matériel spécifié. Après la quantification du modèle, la procédure d’exportation génère des fichiers binaires contenant les données essentielles et les configurations propres à l’appareil, ce qui simplifie le déploiement sur la Raspberry Pi AI Camera.

Cas d'utilisation concrets#

L’exportation 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 à faible consommation 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’exportation des modèles Ultralytics YOLO11 au format IMX500 de Sony te permet de les déployer sur des caméras basées sur IMX500 pour une inférence efficace. Grâce à des techniques de quantification avancées, tu peux réduire la taille des modèles et accélérer l’inférence sans compromettre significativement la précision.

Pour en savoir plus et consulter des instructions détaillées, rends-toi sur le site Web IMX500 de Sony.

FAQ#