Exportation Sony IMX500 pour Ultralytics YOLO11
Ce guide couvre l'exportation et le déploiement des modèles Ultralytics YOLO11 vers les caméras Raspberry Pi AI dotées du capteur Sony IMX500.
Le déploiement de modèles de vision par ordinateur sur des appareils à puissance de calcul limitée, tels que la caméra IA Raspberry Pi, peut s'avérer délicat. L'utilisation d'un format de modèle optimisé pour des performances plus rapides fait une énorme différence.
Le format de modèle IMX500 est conçu pour utiliser une puissance minimale tout en offrant des performances rapides pour les réseaux neuronaux. Il vous permet d'optimiser vos modèles Ultralytics YOLO11 pour une inférence à haute vitesse et à faible consommation d'énergie. Dans ce guide, nous vous expliquerons comment exporter et déployer vos modèles au format IMX500 tout en facilitant les performances de vos modèles sur la Raspberry Pi AI Camera.
Pourquoi exporter vers IMX500 ?
Le capteur de vision intelligent IMX500 de Sony est un élément matériel révolutionnaire dans le domaine du 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 sur puce. Ce capteur aide à surmonter de nombreux défis de l'IA en périphérie, notamment les goulets d'étranglement du traitement des données, les problèmes de confidentialité et les limitations de performance.
Tandis que d'autres capteurs se contentent de transmettre des images et des trames, l'IMX500 raconte toute une 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.
Exportation Sony IMX500 de Sony 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 avoir besoin de les envoyer vers le cloud pour le traitement.
L'IMX500 fonctionne avec des modèles quantifiés. La quantification rend les modèles plus petits et plus rapides sans perdre beaucoup de précision. Elle est idéale pour les ressources limitées de l'edge computing, permettant aux applications de répondre rapidement en réduisant la latence et en permettant un traitement rapide des données localement, 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 à un serveur distant.
Principales caractéristiques d'IMX500 :
- Sortie des métadonnées: Au lieu de transmettre uniquement des images, l'IMX500 peut sortir à la fois l'image et les métadonnées (résultat de l'inférence), et peut sortir uniquement les 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 en matière de confidentialité : En traitant les données sur l’appareil, l’IMX500 répond aux préoccupations en matière de confidentialité, ce qui est idéal pour les applications centrées sur l’humain comme le comptage de 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, parfait pour les applications d'IA en périphérie telles que les systèmes autonomes.
Before You Begin : Pour de meilleurs résultats, assurez-vous que votre modèle YOLO11 est bien préparé pour l’exportation en suivant notre Guide d’entraînement du modèle, notre Guide de préparation des données et notre Guide de réglage des hyperparamètres.
Tâches prises en charge
Actuellement, vous ne pouvez exporter vers le format IMX500 que les modèles incluant les tâches suivantes.
Exemples d'utilisation
Exportez un modèle Ultralytics YOLO11 au format IMX500 et exécutez l'inférence avec le modèle exporté.
Remarque
Ici, nous effectuons une inférence juste pour nous assurer que le modèle fonctionne comme prévu. Cependant, pour le déploiement et l'inférence sur la caméra Raspberry Pi AI, veuillez passer à la section Utilisation de l'exportation IMX500 dans le déploiement.
Détection d'objets
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")
# Export a YOLO11n PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n.pt format=imx data=coco8.yaml
# Run inference with the exported model
yolo predict model=yolo11n_imx_model source='https://ultralytics.com/images/bus.jpg'
Estimation de pose
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")
# Export a YOLO11n-pose PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n-pose.pt format=imx data=coco8-pose.yaml
# Run inference with the exported model
yolo predict model=yolo11n-pose_imx_model source='https://ultralytics.com/images/bus.jpg'
Avertissement
Le package Ultralytics installe des dépendances d'exportation supplémentaires lors de l'exécution. La première fois que vous exécutez la commande d'exportation, vous devrez peut-être redémarrer votre console pour vous assurer qu'elle fonctionne correctement.
Arguments d'exportation
Argument | Type | Par défaut | Description |
---|---|---|---|
format |
str |
'imx' |
Format cible pour le modèle exporté, définissant la compatibilité avec divers environnements de déploiement. |
imgsz |
int ou tuple |
640 |
Taille d'image souhaitée pour l'entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour des dimensions spécifiques. |
int8 |
bool |
True |
Active la quantification INT8, compressant davantage le modèle et accélérant l'inférence avec une perte de précision minimale, principalement pour les appareils périphériques. |
data |
str |
'coco8.yaml' |
Chemin d'accès au ensemble de données fichier de configuration (par défaut : coco8.yaml ), essentiel pour la quantification. |
fraction |
float |
1.0 |
Spécifie la fraction de l'ensemble de données à utiliser pour le calibrage de la quantification INT8. Permet de calibrer sur un sous-ensemble de l'ensemble de données complet, ce qui est utile pour les expériences ou lorsque les ressources sont limitées. S'il n'est pas spécifié avec INT8 activé, l'ensemble de données complet sera utilisé. |
device |
str |
None |
Spécifie le dispositif pour l'exportation : GPU (device=0 ), CPU (device=cpu ). |
Astuce
Si vous exportez sur un GPU avec prise en charge de CUDA, veuillez passer l'argument device=0
pour une exportation plus rapide.
Pour plus de détails sur le processus d'exportation, consultez la page de la 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 contiendra le packerOut.zip
fichier, qui est essentiel pour l'empaquetage du modèle en vue de son déploiement sur le matériel IMX500. De plus, <model-name>_imx_model
Le dossier contiendra un fichier texte (labels.txt
) listant toutes les étiquettes associées au modèle.
Structure des dossiers
yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n_imx.onnx
├── yolo11n_imx_MemoryReport.json
└── yolo11n_imx.pbtxt
yolo11n-pose_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n-pose_imx.onnx
├── yolo11n-pose_imx_MemoryReport.json
└── yolo11n-pose_imx.pbtxt
Utilisation 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 la caméra Raspberry Pi AI pour l’inférence.
Prérequis matériels
Assurez-vous d'avoir le matériel ci-dessous :
- Raspberry Pi 5 ou Raspberry Pi 4 Model B
- Caméra IA Raspberry Pi
Connectez la caméra Raspberry Pi AI au connecteur MIPI CSI à 15 broches sur le Raspberry Pi et mettez le Raspberry Pi sous tension.
Prérequis logiciels
Remarque
Ce guide a été testé avec Raspberry Pi OS Bookworm exécuté sur un Raspberry Pi 5
Étape 1 : Ouvrez une fenêtre de terminal et exécutez les commandes suivantes pour mettre à jour le logiciel Raspberry Pi vers la dernière version.
sudo apt update && sudo apt full-upgrade
Étape 2 : Installez le micrologiciel IMX500 qui est nécessaire pour faire fonctionner le capteur IMX500.
sudo apt install imx500-all
Étape 3 : Redémarrez Raspberry Pi pour que les modifications prennent effet
sudo reboot
Étape 4 : Installez 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écutez la détection d'objets et l'estimation de pose YOLO11 à l'aide des scripts ci-dessous qui sont disponibles dans les exemples de la bibliothèque de modules d'application aitrios-rpi.
Remarque
Assurez-vous de remplacer model_file
et labels.txt
répertoires en fonction de votre environnement avant d'exécuter ces scripts.
Scripts Python
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 DPS 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()
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_yolo_pose_ultralytics
class YOLOPose(Model):
"""YOLO pose estimation model for IMX500 deployment."""
def __init__(self):
"""Initialize the YOLO pose estimation model for IMX500 deployment."""
super().__init__(
model_file="yolo11n-pose_imx_model/packerOut.zip", # replace with proper directory
model_type=MODEL_TYPE.CONVERTED,
color_format=COLOR_FORMAT.RGB,
preserve_aspect_ratio=False,
)
def post_process(self, output_tensors):
"""Post-process the output tensors for pose estimation."""
return pp_yolo_pose_ultralytics(output_tensors)
device = AiCamera(frame_rate=17) # Optimal frame rate for maximum DPS of the YOLO-pose model running on the AI Camera
model = YOLOPose()
device.deploy(model)
annotator = Annotator()
with device as stream:
for frame in stream:
detections = frame.detections[frame.detections.confidence > 0.4]
annotator.annotate_keypoints(frame, detections)
annotator.annotate_boxes(frame, detections, corner_length=20)
frame.display()
Bancs d'essai
Les benchmarks YOLOv8n, YOLO11n, YOLOv8n-pose et YOLO11n-pose ci-dessous ont été exécutés par l'équipe Ultralytics sur Raspberry Pi AI Camera avec imx
format de modèle mesurant la vitesse et la précision.
Modèle | Format | Statut | Taille de packerOut.zip (MB) |
mAP50-95(B) | Temps d'inférence (ms/im) |
---|---|---|---|---|---|
YOLOv8n | imx | ✅ | 2.1 | 0.470 | 58.79 |
YOLO11n | imx | ✅ | 2.2 | 0.517 | 58.82 |
YOLOv8n-pose | imx | ✅ | 2.0 | 0.687 | 58.79 |
YOLO11n-pose | imx | ✅ | 2.1 | 0.788 | 62.50 |
Remarque
La validation pour les benchmarks ci-dessus a été effectuée en utilisant l'ensemble de données COCO128 pour les modèles de détection et l'ensemble de données COCO8-Pose pour les modèles d'estimation de pose.
Qu’y a-t-il sous le capot ?
Sony Model Compression Toolkit (MCT)
Sony's Model Compression Toolkit (MCT) est un outil puissant pour optimiser les modèles d'apprentissage profond 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 du modèle et la complexité de calcul sans sacrifier de manière significative 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.
Fonctionnalités prises en charge de MCT
Le MCT de Sony offre une gamme de fonctionnalités conçues pour optimiser les modèles de réseaux neuronaux :
- Optimisations du graphe : Transforme les modèles en versions plus efficaces en intégrant des couches telles que la normalisation par lots dans les couches précédentes.
- Recherche de paramètres de quantification : Réduit le bruit de quantification à l’aide de mesures telles que l’erreur quadratique moyenne, l’absence d’écrêtage et l’erreur moyenne.
- Algorithmes de quantification avancés:
- Correction du décalage négatif : Résout les problèmes de performances liés à la quantification de l'activation symétrique.
- 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 la distribution.
- Recherche de précision mixte: Attribue différentes largeurs de bits de quantification par couche en fonction de la sensibilité.
- Visualisation : Utilisez 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 du modèle et améliorer la vitesse d'inférence :
- Quantification post-formation (QPT):
- Disponible via les API Keras et PyTorch.
- Complexité : faible
- Coût de calcul : Faible (minutes de CPU)
- 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 de GPU)
- Entraînement sensible à la quantification (QAT):
- Complexité : élevée
- Coût de calcul : Élevé (12 à 36 heures de GPU)
MCT prend également en charge divers schémas de quantification pour les poids et les activations :
- Puissance de deux (compatible avec le matériel)
- Symétrique
- Uniforme
É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 exploite les 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 accord 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.
Outil de conversion IMX500 (compilateur)
L'outil de conversion IMX500 fait partie intégrante de l'ensemble d'outils IMX500, permettant la compilation de modèles pour le déploiement sur le capteur IMX500 de Sony (par exemple, les caméras Raspberry Pi AI). Cet outil facilite la transition des modèles Ultralytics YOLO11 traités via le logiciel Ultralytics, garantissant qu'ils sont compatibles et fonctionnent efficacement 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 caméra Raspberry Pi AI.
Cas d'utilisation concrets
L'exportation au format IMX500 a une large applicabilité dans divers secteurs. Voici quelques exemples :
- IA en périphérie et IoT : Permet la détection d'objets sur les drones ou les caméras de sécurité, où le traitement en temps réel sur les appareils à faible consommation d'énergie est essentiel.
- Appareils portables : Déployez des modèles optimisés pour le traitement de l’IA à petite échelle sur des appareils portables de surveillance de la santé.
- Villes intelligentes : Utiliser les modèles YOLO11 exportés par IMX500 pour la surveillance du trafic et l’analyse de la sécurité avec un traitement plus rapide et une latence minimale.
- Analyse de vente au détail : Améliorez 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.
Conclusion
L'exportation de modèles Ultralytics YOLO11 au format IMX500 de Sony vous permet de déployer vos modèles pour une inférence efficace sur les caméras basées sur IMX500. En tirant parti de techniques de quantification avancées, vous pouvez réduire la taille du modèle et améliorer la vitesse d'inférence sans compromettre de manière significative la précision.
Pour plus d'informations et des directives détaillées, consultez le site web IMX500 de Sony.
FAQ
Comment puis-je exporter un modèle YOLO11 au format IMX500 pour la caméra d'IA Raspberry Pi ?
Pour exporter un modèle YOLO11 au format IMX500, utilisez 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, notamment packerOut.zip
.
Quels sont les principaux avantages de l'utilisation du format IMX500 pour le déploiement de l'IA en périphérie ?
Le format IMX500 offre plusieurs avantages importants pour le déploiement en périphérie :
- Le traitement de l'IA sur puce réduit la latence et la consommation d'énergie.
- Sorties à la fois de l'image et des métadonnées (résultat de l'inférence) au lieu des images uniquement
- Confidentialité améliorée grâce au traitement des données en local 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 du modèle sur des appareils aux ressources limitées
Quels sont les prérequis matériels et logiciels nécessaires pour le déploiement d’IMX500 ?
Pour déployer des modèles IMX500, vous aurez besoin de :
Matériel :
- Raspberry Pi 5 ou Raspberry Pi 4 Model B
- Caméra IA Raspberry Pi avec capteur IMX500
Logiciel :
- Raspberry Pi OS Bookworm
- Micrologiciel et outils IMX500 (
sudo apt install imx500-all
)
Quelles performances puis-je attendre des modèles YOLO11 sur l'IMX500 ?
Basé sur les benchmarks d'Ultralytics sur la caméra IA Raspberry Pi :
- YOLO11n atteint un temps d'inférence de 62,50 ms par image
- mAP50-95 de 0.492 sur l'ensemble de données COCO128
- Taille du modèle de seulement 3,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 d'IA en périphérie.