Export CoreML pour les modèles YOLO26#

Apple intègre une puce dédiée à l'IA — le Neural Engine — à chaque iPhone, iPad et Mac moderne, et CoreML est aujourd'hui le parcours pris en charge par Ultralytics pour y déployer des modèles. L'export des modèles Ultralytics YOLO26 vers CoreML transforme un point de contrôle .pt entraîné en un .mlpackage natif qui exécute les sept tâches YOLO sur l'appareil avec une faible latence, sans connexion réseau et sans que les données quittent l'appareil.

Qu’est-ce que CoreML ?#

CoreML (nommé « Core ML » par Apple) est le framework d’apprentissage automatique intégré aux appareils d’Apple. Il charge les modèles au format moderne ML Program — le bundle .mlpackage produit par l’exportateur Ultralytics — et les répartit entre le CPU, le GPU et l’Apple Neural Engine (ANE) de l’appareil, le NPU dédié présent dans chaque puce Apple Silicon. Comme tout s’exécute localement, l’inférence fonctionne hors ligne, n’ajoute aucune latence réseau et conserve les données utilisateur sur l’appareil.

CoreML s’intègre directement au framework Vision d’Apple, qui gère le redimensionnement et l’orientation des images avant leur entrée dans le modèle — c’est ainsi que le SDK Ultralytics pour iOS transmet les images de la caméra à YOLO avec un coût de prétraitement pratiquement nul.

Pourquoi exporter YOLO26 vers CoreML ?#

• Vitesse du Neural Engine : CoreML planifie les opérations prises en charge sur le Neural Engine d’Apple pour une inférence à faible latence sur l’appareil. Consulte le tableau des appareils physiques ci-dessous et évalue précisément ton export sur le matériel cible.
• Choisir la sortie : les exports par défaut laissent le NMS à ton application. Utilise nms=True pour intégrer le NMS, ou nms=False pour la tête sans NMS de YOLO26.
• Confidentialité et fonctionnement hors ligne : tous les calculs restent sur l’appareil — aucun aller-retour vers le cloud, aucune clé API, confidentialité totale des données.
• Un seul export pour tout l’écosystème : le même .mlpackage fonctionne sur iOS, iPadOS, macOS, watchOS, tvOS et visionOS, et alimente le SDK iOS et le plugin Flutter officiels d’Ultralytics.

Performances mesurées#

Inférence de bout en bout sur une seule image pour les ressources CoreML INT8 YOLO26n standardisées v8.3.0 sur un iPhone 17 Pro doté de 12 Go de mémoire et d’iOS 26.5.2. Sa puce A19 Pro comprend un CPU à 6 cœurs (2 cœurs Performance et 4 cœurs Efficiency), un GPU à 6 cœurs avec accélérateurs neuronaux et un Neural Engine à 16 cœurs. Chaque cellule indique le temps total (prétraitement + inférence + post-traitement, hors annotation), avec le détail par étape juste en dessous. Sous iOS, Vision effectue le redimensionnement de l’entrée dans la requête d’inférence ; le prétraitement est donc indiqué à 0 et son coût est inclus dans l’inférence.

• Les ressources de publication exactes v8.3.0 déclarent des entrées de 224×224 pour la classification et de 640×640 pour toutes les autres tâches.
• Les valeurs de vitesse correspondent à des latences en rafale sur une seule image — la moyenne de 15 exécutions après 3 exécutions de préchauffage sur bus.jpg, mesurées à chaque étape via le SDK iOS, à l’aide du banc d’essai du plugin Flutter en mode profil (code natif optimisé). L’ordre CPU/accélérateur a alterné entre les tâches lors d’un seul passage séquentiel. Les lignes CPU demandent Core ML .cpuOnly ; les lignes CPU + ANE privilégié demandent .cpuAndNeuralEngine, Core ML déterminant finalement le placement des opérations. En fonctionnement continu de la caméra en temps réel, les valeurs sont plus élevées, car le pipeline de capture et de mise à l’échelle ainsi que la stabilisation thermique sont pris en compte. Lors d’une mesure historique sur caméra, avant la standardisation, on a obtenu 11.3 ms/image pour la détection avec YOLO26n et 16.5 ms/image pour la profondeur avec YOLO26n sur le même appareil — consulte la documentation sur les performances du SDK iOS pour le profilage en régime stabilisé.
• Compare les résultats CPU/GPU sur Android dans l’intégration LiteRT et les résultats du NPU Snapdragon dans l’intégration Qualcomm QNN.

Tâches prises en charge#

L’export CoreML prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont uniquement disponibles avec YOLO26, la seule famille qui inclut ces têtes.

Exporter des modèles YOLO26 vers CoreML#

Installation#

Pour installer le package requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Le convertisseur coremltools s’installe automatiquement lors du premier export. L’export s’exécute sous macOS ou Linux x86 ; pour obtenir des instructions détaillées et des bonnes pratiques, consulte notre guide d’installation et notre guide des problèmes courants.

Utilisation#

Le format CoreML prend en charge les modes Export, Predict et Validate. L’inférence et la validation avec CoreML fonctionnent uniquement sous macOS. Exporte ton modèle, puis charge le modèle exporté pour effectuer l’inférence ou valider sa précision.

from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter vers CoreML avec une quantification des poids INT8, comme pour les modèles officiels de l’application
model.export(format="coreml", quantize=8, imgsz=640)  # utiliser imgsz=224 pour la classification

from ultralytics import YOLO

# Charger le modèle CoreML exporté (macOS)
model = YOLO("yolo26n.mlpackage")

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

from ultralytics import YOLO

# Charger le modèle CoreML exporté (macOS)
model = YOLO("yolo26n.mlpackage")

# 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.

Cibler le Neural Engine#

CoreML choisit le matériel via MLModelConfiguration.computeUnits. Par défaut, le SDK Ultralytics pour iOS utilise .cpuAndNeuralEngine sous iOS 16 et versions ultérieures, plutôt que .all : dans une application de caméra en temps réel, le GPU est déjà occupé à composer l’aperçu et les incrustations. L’exclure évite donc la contention et les variations du temps de trame, tandis que l’ANE prend en charge l’essentiel du travail. Ne fixe .cpuOnly que pour tester la compatibilité — le tableau ci-dessus montre le coût associé.

L’exécution d’un modèle CoreML depuis Python sur un hôte Mac (via Ultralytics ou coremltools) suit la même règle : Ultralytics charge le modèle avec ComputeUnit.CPU_AND_NE (macOS 13 et versions ultérieures, avec repli sur CPU_ONLY sous les anciennes versions de macOS), ce qui maintient l’inférence sur le Neural Engine (~3× plus rapide que sur CPU). Cela évite également une limitation actuelle de macOS sur l’hôte : le réglage par défaut ComputeUnit.ALL / CPU_AND_GPU — qui ajoute le chemin de compilation GPU/MPSGraph — interrompt le processus avec une assertion Error: MLIR pass manager failed sur coremltools 9.x.

Déployer les modèles YOLO26 CoreML exportés#

Le moyen le plus rapide consiste à utiliser le SDK Ultralytics YOLO officiel pour iOS, le même package Swift qui alimente l’application Ultralytics pour iOS et le plugin Flutter. Il résout automatiquement les noms de modèles officiels, télécharge et met en cache le .mlpackage, puis renvoie des résultats entièrement décodés :

import UltralyticsYOLO

// Loads the official INT8 model (downloaded and cached on first use), then runs inference
let yolo = YOLO("yolo26n", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

Pour les applications de caméra, ajoute le YOLOView du SDK pour bénéficier de l’inférence en temps réel avec des incrustations natives, ou utilise le plugin Flutter pour créer des applications multiplateformes partageant une base de code avec Android.

Tu peux aussi facilement intégrer toi-même un .mlpackage brut avec la pile Apple : charge-le avec MLModel, enveloppe-le dans un VNCoreMLRequest et transmets les images via VNImageRequestHandler. Ces ressources détaillent la procédure :

• Intégrer un modèle Core ML dans ton application : le guide d’Apple pour intégrer et appeler un modèle CoreML.
• Outils CoreML : référence sur la conversion, la quantification et l’optimisation de la chaîne d’outils coremltools utilisée pour cet export.
• Rapports de performances Core ML de Xcode : profilage du placement des opérations par couche et de la latence pour ton modèle et ton appareil précis.

Livre le modèle soit intégré au bundle de l’application (disponibilité immédiate, idéal pour les modèles nano/petits), soit téléchargé au premier lancement et mis en cache (binaire plus léger, mises à jour faciles du modèle). Les applications officielles combinent les deux approches : les modèles nano par défaut sont intégrés pour être disponibles immédiatement, tandis que les variantes plus volumineuses sont téléchargées à la demande et mises en cache localement.

Flux de travail recommandé#

1. Entraîne ton modèle avec le mode Train d’Ultralytics, ou pars des poids officiels YOLO26
2. Exporte avec model.export(format="coreml", quantize=8, imgsz=640) sous macOS ou Linux x86 (imgsz=224 pour la classification)
3. Vérifie la précision avec model.val() sur un Mac, puis profile le modèle avec un rapport de performances Core ML de Xcode sur ton appareil cible
4. Déploie avec le SDK iOS, le plugin Flutter ou ta propre intégration Vision, en ciblant .cpuAndNeuralEngine

Résumé#

Dans ce guide, tu as appris à exporter les modèles Ultralytics YOLO26 au format .mlpackage de CoreML, à les quantifier pour l’Apple Neural Engine et à les déployer avec des latences de quelques millisecondes — à l’aide du SDK iOS officiel et du plugin Flutter, ou de ta propre intégration Vision. Pour d’autres cibles de déploiement, consulte la page du guide d’intégration et compare les formats avec le mode Benchmark.

FAQ#