Exportation CoreML pour les modèles YOLO26#

Apple intègre un silicium dédié à l’IA — le Neural Engine — dans chaque iPhone, iPad et Mac moderne, et CoreML est aujourd’hui la voie prise en charge par Ultralytics pour y déployer des modèles. L’exportation des modèles Ultralytics YOLO26 vers CoreML transforme un checkpoint .pt entraîné en un modèle natif .mlpackage 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 ne quittent l’appareil.

Qu’est-ce que CoreML ?#

CoreML (qu’Apple nomme « Core ML ») est le framework d’apprentissage automatique d’Apple, exécuté sur l’appareil. 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é de 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 la mise à l’échelle et l’orientation des images avant leur transmission au modèle — c’est ainsi que le SDK Ultralytics 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 sur l’appareil à faible latence. Consulte le tableau des appareils physiques ci-dessous et évalue ton export exact sur le matériel cible.
• Choisis la sortie : Les exportations par défaut laissent la NMS à ton application. Utilise nms=True pour intégrer la NMS, ou nms=False pour la tête sans NMS de YOLO26.
• Privé et hors ligne : tous les calculs restent sur l’appareil — aucun aller-retour vers le cloud, aucune clé API et une confidentialité des données complète.
• 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 image unique pour les ressources CoreML YOLO26n INT8 standardisées v8.3.0 sur un iPhone 17 Pro doté de 12 Go de mémoire et d’iOS 26.5.2. Son A19 Pro possède un CPU à 6 cœurs (2 cœurs Performance et 4 cœurs Efficiency), un GPU à 6 cœurs avec des 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 en dessous. Sous iOS, Vision effectue la mise à l’échelle de l’entrée dans la requête d’inférence ; le prétraitement est donc indiqué comme égal à 0 et son coût est inclus dans l’inférence.

• Les ressources exactes de la version 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 sont des latences en rafale sur une image unique — la moyenne de 15 exécutions après 3 exécutions d’échauffement sur bus.jpg, mesurée grâce au minutage par étape du SDK iOS via le banc de test du plugin Flutter en mode profilé (code natif optimisé). L’ordre CPU/accélérateur alternait entre les tâches au cours d’un même passage séquentiel. Les lignes CPU demandent Core ML .cpuOnly ; les lignes CPU + ANE préféré demandent .cpuAndNeuralEngine, le placement final des opérations étant contrôlé par Core ML. Le fonctionnement continu de la caméra en temps réel est plus lent, car il inclut le pipeline de capture et de mise à l’échelle ainsi que la stabilisation thermique. Un balayage historique de la caméra, réalisé avant la standardisation, mesurait 11.3 ms/image pour la détection YOLO26n et 16.5 ms/image pour la profondeur YOLO26n sur le même appareil — consulte la documentation sur les performances du SDK iOS pour le profilage en régime stable.
• Compare les résultats CPU/GPU 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’exportation CoreML prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille à proposer 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 est installé automatiquement lors de la première exportation. L’exportation s’exécute sur macOS ou Linux x86 ; pour obtenir des instructions détaillées et les bonnes pratiques, consulte notre guide d’installation et le 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 s’exécutent uniquement 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 to CoreML with INT8 weight quantization, matching the official app models
model.export(format="coreml", quantize=8, imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

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

Cibler le Neural Engine#

CoreML choisit le matériel via MLModelConfiguration.computeUnits. Le SDK Ultralytics iOS utilise par défaut .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 superpositions ; l’exclure évite donc la contention et les variations du temps d’image, tandis que l’ANE effectue l’essentiel du travail. Utilise .cpuOnly uniquement pour les tests de compatibilité — le tableau ci-dessus montre le coût associé.

L’exécution d’un modèle CoreML depuis Python sur un Mac hôte (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 vers CPU_ONLY sur les anciennes versions de macOS), ce qui maintient l’inférence sur le Neural Engine (environ 3 fois plus rapide que le CPU). Cela évite également une limitation actuelle de macOS sur l’hôte : ComputeUnit.ALL / CPU_AND_GPU par défaut — qui ajoutent le chemin de compilation GPU/MPSGraph — interrompent le processus avec une assertion Error: MLIR pass manager failed sur coremltools 9.x.

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

La voie la plus rapide passe par le SDK Ultralytics YOLO pour iOS officiel, le même package Swift que celui utilisé par l’application Ultralytics 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, utilise le YOLOView du SDK pour obtenir une inférence en temps réel avec des superpositions natives, ou le plugin Flutter pour les applications multiplateformes partageant une seule base de code avec Android.

Intégrer toi-même un .mlpackage brut est également simple avec la pile Apple : charge-le avec MLModel, encapsule-le dans un VNCoreMLRequest et transmets les images via VNImageRequestHandler. Ces ressources présentent les détails :

• Intégrer un modèle Core ML à ton application : le guide d’Apple pour intégrer et appeler un modèle CoreML.
• Outils CoreML : référence de conversion, quantification et optimisation pour la chaîne d’outils coremltools utilisée par cette exportation.
• Rapports de performances Core ML de Xcode : placement de chaque couche sur l’appareil et profilage de la latence pour ton modèle et ton appareil exacts.

Intègre le modèle directement dans le bundle de l’application (disponibilité immédiate, idéal pour les modèles nano/petits) ou télécharge-le lors de la première exécution et mets-le 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 une utilisation immédiate, tandis que les variantes plus grandes 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 YOLO26 officiels
2. Exporte avec model.export(format="coreml", quantize=8, imgsz=640) sur macOS ou Linux x86 (imgsz=224 pour la classification)
3. Vérifie la précision avec model.val() sur un Mac et profile le modèle avec un rapport de performances Core ML 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 le Neural Engine d’Apple et à les déployer avec des latences de quelques millisecondes — via le SDK iOS et le plugin Flutter officiels ou ta propre intégration Vision. Pour les autres cibles de déploiement, consulte la page du guide des intégrations et compare les formats avec le mode Benchmark.

FAQ#