Link to this sectionExport CoreML pour les modèles YOLO26#

Le déploiement de modèles de computer vision sur des appareils Apple comme les iPhones et les Macs nécessite un format qui garantit des performances fluides.

Le format d'exportation CoreML te permet d'optimiser tes modèles Ultralytics YOLO26 pour une object detection efficace dans tes applications iOS et macOS. Dans ce guide, nous te guiderons à travers les étapes de conversion de tes modèles vers le format CoreML, facilitant ainsi leur exécution sur les appareils Apple.

Link to this sectionCoreML#

CoreML est le framework d'apprentissage automatique fondamental d'Apple qui s'appuie sur Accelerate, BNNS et Metal Performance Shaders. Il fournit un format de modèle d'apprentissage automatique qui s'intègre parfaitement dans les applications iOS et prend en charge des tâches telles que l'analyse d'images, le natural language processing, la conversion audio-texte et l'analyse sonore.

Les applications peuvent tirer parti de Core ML sans avoir besoin d'une connexion réseau ou d'appels API, car le framework Core ML fonctionne via le calcul sur l'appareil. Cela signifie que l'inférence du modèle peut être effectuée localement sur l'appareil de l'utilisateur.

Link to this sectionFonctionnalités clés des modèles CoreML#

Le framework CoreML d'Apple offre des fonctionnalités robustes pour l'apprentissage automatique sur l'appareil. Voici les caractéristiques clés qui font de CoreML un outil puissant pour les développeurs :

• Prise en charge complète des modèles : Convertit et exécute des modèles provenant de frameworks populaires comme TensorFlow, PyTorch, scikit-learn, XGBoost et LibSVM.

• Machine Learning sur l'appareil : Garantit la confidentialité des données et un traitement rapide en exécutant les modèles directement sur l'appareil de l'utilisateur, éliminant ainsi le besoin de connectivité réseau.

• Performance et optimisation : Utilise le CPU, le GPU et le Neural Engine de l'appareil pour des performances optimales avec une consommation d'énergie et de mémoire minimale. Offre des outils pour la compression et l'optimisation des modèles tout en maintenant une accuracy élevée.

• Facilité d'intégration : Fournit un format unifié pour divers types de modèles et une API conviviale pour une intégration transparente dans les applications. Prend en charge des tâches spécifiques au domaine via des frameworks comme Vision et Natural Language.

• Fonctionnalités avancées : Inclut des capacités d'entraînement sur l'appareil pour des expériences personnalisées, des prédictions asynchrones pour des expériences ML interactives, ainsi que des outils d'inspection et de validation de modèles.

Link to this sectionOptions de déploiement CoreML#

Avant d'examiner le code pour exporter des modèles YOLO26 au format CoreML, comprenons où les modèles CoreML sont généralement utilisés.

CoreML offre diverses options de déploiement pour les modèles d'apprentissage automatique, notamment :

• Déploiement sur l'appareil : Cette méthode intègre directement les modèles CoreML dans ton application iOS. Elle est particulièrement avantageuse pour garantir une faible latence, une confidentialité accrue (car les données restent sur l'appareil) et une fonctionnalité hors ligne. Cette approche peut toutefois être limitée par les capacités matérielles de l'appareil, en particulier pour les modèles plus grands et plus complexes, et peut être exécutée de deux manières :

  • Modèles intégrés : Ces modèles sont inclus dans le bundle de l'application et sont immédiatement accessibles. Ils sont idéaux pour les petits modèles qui ne nécessitent pas de mises à jour fréquentes.

  • Modèles téléchargés : Ces modèles sont récupérés depuis un serveur selon les besoins. Cette approche est adaptée aux modèles plus grands ou à ceux nécessitant des mises à jour régulières. Elle permet de conserver une taille de bundle d'application plus petite.

• Déploiement basé sur le cloud : Les modèles CoreML sont hébergés sur des serveurs et accédés par l'application iOS via des requêtes API. Cette option évolutive et flexible permet des mises à jour faciles des modèles sans révisions de l'application. Elle est idéale pour les modèles complexes ou les applications à grande échelle nécessitant des mises à jour régulières. Cependant, elle nécessite une connexion Internet et peut poser des problèmes de latence et de sécurité.

Link to this sectionExporter des modèles YOLO26 vers CoreML#

L'exportation de YOLO26 vers CoreML permet des performances d'apprentissage automatique optimisées sur l'appareil au sein de l'écosystème Apple, offrant des avantages en termes d'efficacité, de sécurité et d'intégration transparente avec les plateformes iOS, macOS, watchOS et tvOS.

Link to this sectionInstallation#

Pour installer le package requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation YOLO26. Si tu rencontres des difficultés lors de l'installation des packages requis pour YOLO26, consulte notre guide des problèmes courants pour obtenir des solutions et des conseils.

Link to this sectionUtilisation#

Avant de plonger dans les instructions d'utilisation, assure-toi de consulter la gamme de modèles YOLO26 proposés par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié pour les exigences de ton projet.

Le format CoreML prend en charge les modes Export, Predict et Validate. L'inférence et la validation avec CoreML ne s'exécutent que sur macOS. Exporte ton modèle, puis charge le modèle exporté pour exécuter l'inférence ou valider sa précision.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to CoreML format
model.export(format="coreml")  # creates 'yolo26n.mlpackage'

from ultralytics import YOLO

# Load the exported CoreML model
model = YOLO("yolo26n.mlpackage")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported CoreML model
model = YOLO("yolo26n.mlpackage")

# 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 d'Ultralytics sur l'exportation.

Link to this sectionDéploiement des modèles YOLO26 CoreML exportés#

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 vers CoreML, la phase critique suivante est le déploiement efficace de ces modèles. Pour des conseils détaillés sur le déploiement de modèles CoreML dans divers environnements, consulte ces ressources :

• CoreML Tools : Ce guide inclut des instructions et des exemples pour convertir des modèles provenant de TensorFlow, PyTorch et d'autres bibliothèques vers Core ML.

• ML and Vision : Une collection de vidéos complètes qui couvrent divers aspects de l'utilisation et de l'implémentation des modèles CoreML.

• Intégration d'un modèle Core ML dans ton application : Un guide complet sur l'intégration d'un modèle CoreML dans une application iOS, détaillant les étapes de la préparation du modèle à son implémentation dans l'application pour diverses fonctionnalités.

Link to this sectionRésumé#

Dans ce guide, nous avons passé en revue comment exporter les modèles Ultralytics YOLO26 au format CoreML. En suivant les étapes décrites dans ce guide, tu peux garantir une compatibilité et des performances maximales lors de l'exportation de tes modèles YOLO26 vers CoreML.

Pour plus de détails sur l'utilisation, visite la documentation officielle de CoreML.

De plus, si tu souhaites en savoir plus sur d'autres intégrations Ultralytics YOLO26, visite notre page du guide d'intégration. Tu y trouveras de nombreuses ressources et idées précieuses.

Link to this sectionFAQ#

Link to this sectionComment puis-je exporter des modèles YOLO26 au format CoreML ?#

Pour exporter tes modèles Ultralytics YOLO26 au format CoreML, tu dois d'abord t'assurer que le package ultralytics est installé. Tu peux l'installer en utilisant :

pip install ultralytics

Ensuite, tu peux exporter le modèle en utilisant les commandes Python ou CLI suivantes :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="coreml")

Pour plus de détails, réfère-toi à la section Exporting YOLO26 Models to CoreML de notre documentation.

Link to this sectionQuels sont les avantages d'utiliser CoreML pour déployer des modèles YOLO26 ?#

CoreML offre de nombreux avantages pour le déploiement de modèles Ultralytics YOLO26 sur les appareils Apple :

• Traitement sur l'appareil : Permet l'inférence locale du modèle sur les appareils, garantissant la data privacy et minimisant la latence.
• Optimisation des performances : Tire parti du plein potentiel du CPU, du GPU et du Neural Engine de l'appareil, optimisant à la fois la vitesse et l'efficacité.
• Facilité d'intégration : Offre une expérience d'intégration fluide avec les écosystèmes d'Apple, incluant iOS, macOS, watchOS et tvOS.
• Polyvalence : Prend en charge un large éventail de tâches d'apprentissage automatique telles que l'analyse d'images, le traitement audio et le traitement du langage naturel en utilisant le framework CoreML.

Pour plus de détails sur l'intégration de ton modèle CoreML dans une application iOS, consulte le guide sur l' intégration d'un modèle Core ML dans ton application.

Link to this sectionQuelles sont les options de déploiement pour les modèles YOLO26 exportés vers CoreML ?#

Une fois que tu as exporté ton modèle YOLO26 au format CoreML, tu disposes de plusieurs options de déploiement :

1. Déploiement sur l'appareil : Intègre directement les modèles CoreML dans ton application pour une confidentialité accrue et une fonctionnalité hors ligne. Cela peut être fait comme :

   • Modèles intégrés : Inclus dans le bundle de l'application, accessibles immédiatement.
   • Modèles téléchargés : Récupérés depuis un serveur selon les besoins, ce qui permet de maintenir la taille du bundle de l'application plus petite.

2. Déploiement basé sur le cloud : Héberge les modèles CoreML sur des serveurs et y accède via des requêtes API. Cette approche facilite les mises à jour et peut gérer des modèles plus complexes.

Pour des conseils détaillés sur le déploiement des modèles CoreML, réfère-toi aux Options de déploiement CoreML.

Link to this sectionComment CoreML garantit-il des performances optimisées pour les modèles YOLO26 ?#

CoreML garantit des performances optimisées pour les modèles Ultralytics YOLO26 en utilisant diverses techniques d'optimisation :

• Accélération matérielle : Utilise le CPU, le GPU et le Neural Engine de l'appareil pour un calcul efficace.
• Compression de modèle : Fournit des outils pour compresser les modèles afin de réduire leur empreinte sans compromettre la précision.
• Inférence adaptative : Ajuste l'inférence en fonction des capacités de l'appareil pour maintenir un équilibre entre vitesse et performance.

Pour plus d'informations sur l'optimisation des performances, visite la documentation officielle de CoreML.

Link to this sectionPuis-je exécuter l'inférence directement avec le modèle CoreML exporté ?#

Oui, tu peux exécuter l'inférence directement en utilisant le modèle CoreML exporté. Voici les commandes pour Python et CLI :

from ultralytics import YOLO

coreml_model = YOLO("yolo26n.mlpackage")
results = coreml_model("https://ultralytics.com/images/bus.jpg")

Pour plus d'informations, réfère-toi à la section Utilisation du guide d'exportation CoreML.