Exportation CoreML pour les modèles YOLO26#

Apple intègre du silicium IA dédié — le Neural Engine — dans chaque iPhone, iPad et Mac moderne, et CoreML est la solution supportée par Ultralytics pour y déployer tes modèles dès aujourd'hui. Exporter tes 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 qu'aucune donnée ne quitte l'appareil.

Qu'est-ce que CoreML ?#

CoreML (stylisé « Core ML » par Apple) est le framework d'apprentissage automatique sur appareil d'Apple. Il charge les modèles dans le format moderne ML Program — le bundle .mlpackage produit par l'exportateur Ultralytics — et les planifie sur 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 la mise à l'échelle et l'orientation des images avant qu'elles n'atteignent le modèle — c'est ainsi que le SDK iOS Ultralytics transmet les flux de 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 appareil à faible latence. Consulte le tableau des appareils physiques ci-dessous et évalue ton exportation exacte sur ton matériel cible.
• Conçu sans NMS : YOLO26 est end-to-end, donc le graphe exporté ne nécessite aucun pipeline NMS et le décodage est inférieur à la milliseconde. Les modèles de détection plus anciens comme YOLO11 peuvent intégrer un pipeline NMS CoreML avec nms=True.
• Privé et hors ligne : Tous les calculs restent sur l'appareil — pas d'aller-retour avec le cloud, pas de clés API, une confidentialité des données totale.
• Une seule exportation, 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 standardisées v8.3.0 de YOLO26n sur un iPhone 17 Pro avec 12 Go de mémoire et iOS 26.5.2. Son A19 Pro dispose d'un processeur à 6 cœurs (2 cœurs de performance et 4 cœurs d'efficacité), d'un GPU à 6 cœurs avec accélérateurs neuronaux et d'un Neural Engine à 16 cœurs. Chaque cellule indique le temps total (prétraitement + inférence + post-traitement, hors annotation) avec la répartition par étape en dessous. Sur iOS, Vision effectue la mise à l'échelle des entrées dans la requête d'inférence, le prétraitement est donc rapporté à 0 et son coût est inclus dans l'inférence.

• Les ressources de version 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 aux latences en rafale pour une seule image — la moyenne de 15 exécutions après 3 exécutions d'échauffement sur bus.jpg, mesurées via le minutage par étape du Kit de développement iOS par le biais de l'outil de test de performance du plugin Flutter en mode profil (code natif optimisé). L'ordre CPU/accélérateur a alterné entre les tâches en un seul balayage 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 de la caméra en temps réel soutenu est plus élevé car il inclut le pipeline de capture et de mise à l'échelle ainsi que la stabilisation thermique. Un balayage de caméra pré-standard historique a mesuré 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 kit de développement iOS pour le profilage en régime permanent.
• Compare les résultats CPU/GPU Android dans l'intégration LiteRT et les résultats NPU Snapdragon dans l'intégration Qualcomm QNN.

Tâches prises en charge#

L'exportation CoreML prend en charge les sept tâches d'Ultralytics. La segmentation sémantique et l'estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille qui intègre 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 des instructions détaillées et les meilleures 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 ne s'exécutent que sur macOS. Exporte ton modèle, puis charge-le pour effectuer des inférences 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, visite la page de documentation Ultralytics sur l'exportation.

Cibler le Neural Engine#

CoreML choisit le matériel via MLModelConfiguration.computeUnits. Le SDK iOS Ultralytics utilise par défaut .cpuAndNeuralEngine sur iOS 16+ plutôt que .all : dans une application caméra en temps réel, le GPU est déjà occupé par la composition de la prévisualisation et des superpositions, donc l'exclure évite les conflits et la gigue de temps de trame pendant que l'ANE fait le gros 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 hôte Mac (via Ultralytics ou coremltools) suit la même règle : Ultralytics se charge avec ComputeUnit.CPU_AND_NE (macOS 13+, avec repli sur CPU_ONLY pour les anciennes versions de macOS), ce qui maintient l'inférence sur le Neural Engine (~3× plus rapide que le CPU). Cela permet également d'éviter une limitation actuelle des hôtes macOS où 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 des modèles CoreML YOLO26 exportés#

Le chemin le plus rapide est le SDK Ultralytics YOLO iOS officiel, le même package Swift qui alimente 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, et 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 caméra, utilise le YOLOView du SDK pour une inférence en temps réel avec des superpositions natives, ou utilise le plugin Flutter pour des applications multiplateformes qui partagent une base de code avec Android.

L'intégration manuelle d'un .mlpackage brut est également simple avec la stack Apple — charge-le avec MLModel, encapsule-le dans une VNCoreMLRequest et transmets les images via VNImageRequestHandler. Ces ressources couvrent les détails :

• Intégrer un modèle Core ML dans ton application : Le guide d'Apple pour intégrer et appeler un modèle CoreML.
• CoreML Tools : Référence sur la conversion, la quantification et l'optimisation pour la chaîne d'outils coremltools qui alimente cette exportation.
• Rapports de performance Xcode Core ML : Placement des couches sur le périphérique et profilage de la latence pour ton modèle et ton appareil exacts.

Livre le modèle soit intégré dans le paquet de l'application (disponibilité instantanée, idéal pour les modèles nano/small), soit téléchargé au premier lancement et mis en cache (binaire plus léger, mises à jour de modèle faciles). Les applications officielles combinent les deux approches : les modèles nano par défaut sont fournis pour une utilisation immédiate, tandis que les variantes plus grandes se téléchargent à la demande et sont mises en cache localement.

Flux de travail recommandé#

1. Entraîne ton modèle avec le mode Train d'Ultralytics, ou commence avec les poids officiels YOLO26
2. Exporte avec model.export(format="coreml", quantize=8, imgsz=640) sur macOS ou x86 Linux (imgsz=224 pour la classification)
3. Vérifie la précision avec model.val() sur un Mac, et profile avec un rapport de performance Xcode Core ML 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 des modèles Ultralytics YOLO26 vers le format .mlpackage de CoreML, à les quantifier pour l'Apple Neural Engine et à les déployer avec des latences de l'ordre de la milliseconde — que ce soit via le SDK iOS officiel et le plugin Flutter ou 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#

Comment exporter des modèles YOLO26 vers le format CoreML ?#

Exécute model.export(format="coreml", imgsz=640) en Python ou yolo export model=yolo26n.pt format=coreml imgsz=640 depuis la CLI sur macOS ou x86 Linux. Utilise imgsz=224 pour la classification et ajoute quantize=8 pour correspondre aux modèles d'application officiels. L'exportation produit un programme ML yolo26n.mlpackage prêt pour Xcode, le SDK iOS ou le plugin Flutter.

Dois-je utiliser nms=True lors de l'exportation de YOLO26 ?#

Non. YOLO26 est conçu sans NMS de bout en bout, donc le graphe exporté émet déjà les détections finales et les coûts de décodage sont bien inférieurs à une milliseconde. L'option nms=True existe pour les modèles de détection antérieurs tels que YOLO11, où elle intègre un pipeline NMS CoreML afin que ton application n'ait pas à implémenter la suppression. Les pipelines NMS CoreML ne prennent en charge que la détection d'objets, donc nms=True est ignoré avec un avertissement pour d'autres tâches comme la segmentation et la pose.

Quelle précision dois-je utiliser — FP16 ou INT8 ?#

Les modèles officiels de l'application Ultralytics sont fournis en INT8, ce qui minimise la taille du téléchargement et permet d'atteindre les vitesses indiquées dans le tableau ci-dessus. quantize=16 (FP16) est une alternative prudente sans perte de précision notable. Valide ton export spécifique avec model.val() sur un Mac avant la mise en production.

Comment m'assurer que l'inférence s'exécute sur le Neural Engine ?#

Définit MLModelConfiguration.computeUnits = .cpuAndNeuralEngine (le défaut du SDK iOS sur iOS 16+). Évite .all dans les applications caméra — le GPU est occupé par la composition de la prévisualisation, et planifier l'inférence dessus provoque une gigue de temps de trame. Confirme le placement avec un rapport de performance Xcode Core ML.

Puis-je exécuter et valider des modèles CoreML avec la CLI Ultralytics ?#

Oui, sur macOS : yolo predict model=yolo26n.mlpackage source=image.jpg et yolo val model=yolo26n.mlpackage data=coco8.yaml fonctionnent comme n'importe quel autre format. L'exécution CoreML nécessite du matériel Apple, donc ces modes ne sont pas disponibles sur Linux et Windows.

Quel est le moyen le plus rapide de faire fonctionner YOLO26 dans une application iOS ou Flutter ?#

Utilise le SDK Ultralytics YOLO iOS officiel (Swift Package) ou le plugin Flutter. Les deux chargent les modèles officiels par nom avec téléchargement et mise en cache automatiques, les exécutent sur le Neural Engine et incluent des interfaces utilisateur caméra temps réel complètes — le tableau de performance mesuré ci-dessus a été produit avec exactement cette stack.