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 voie prise en charge par Ultralytics pour y déployer des modèles aujourd'hui. Exporter 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 à 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 au 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é de chaque puce Apple silicon. Tout s'exécutant localement, l'inférence fonctionne hors ligne, n'ajoute aucune latence réseau et maintient 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 à l'entrée du modèle — c'est ainsi que le SDK iOS Ultralytics 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 appareil à faible latence. Consulte le tableau des appareils physiques ci-dessous et évalue ton exportation exacte sur ton matériel cible.
• Sans NMS par conception : YOLO26 est de bout en bout, le graphe exporté ne nécessite donc aucun pipeline NMS et le décodage prend moins d'une 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 : Tout le calcul reste sur l'appareil — pas d'allers-retours cloud, pas de clés API, 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 les iOS SDK et Flutter plugin officiels d'Ultralytics.

Performances mesurées#

Inférence de bout en bout sur image unique pour les assets standardisés v8.3.0 YOLO26n INT8 CoreML sur un iPhone 17 Pro avec 12 Go de mémoire et iOS 26.5.2. Son A19 Pro dispose d'un CPU à 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 assets de version exacts v8.3.0 déclarent des entrées 224×224 pour la classification et 640×640 pour toutes les autres tâches.
• Les valeurs de vitesse sont des latences en rafale sur image unique — la moyenne de 15 exécutions après 3 exécutions d'échauffement sur bus.jpg, mesurées via le minutage par étape du SDK iOS via le banc d'essai du plugin Flutter en mode profil (code natif optimisé). L'ordre CPU/accélérateur a alterné entre les tâches en un 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 en continu 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 YOLO26n Depth sur le même appareil — consulte la doc de performance du SDK 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 x86 Linux ; 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 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, visite la page de documentation d'Ultralytics sur l'exportation.

Cibler le Neural Engine#

CoreML choisit le matériel via MLModelConfiguration.computeUnits. Le SDK iOS d'Ultralytics utilise par défaut .cpuAndNeuralEngine sur iOS 16+ 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, donc l'exclure évite les conflits et la gigue du temps de trame pendant que l'ANE fait le gros du travail. Épingle .cpuOnly uniquement pour les tests de compatibilité — le tableau ci-dessus montre ce que cela coûte.

Exécuter 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 sur les anciens macOS), maintenant l'inférence sur le Neural Engine (~3x plus rapide que le CPU). Cela évite également une limitation actuelle de l'hôte macOS où les valeurs par défaut ComputeUnit.ALL / CPU_AND_GPU — 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 iOS Ultralytics YOLO officiel, le même package Swift qui alimente l'application iOS d'Ultralytics 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 de caméra, intègre le YOLOView du SDK pour une inférence en temps réel avec des superpositions natives, ou utilise le plugin Flutter pour les applications multiplateformes qui partagent une seule base de code avec Android.

Intégrer toi-même un .mlpackage brut est également simple avec la pile d'Apple — charge-le avec MLModel, enveloppe-le dans un VNCoreMLRequest et alimente les images via VNImageRequestHandler. Ces ressources couvrent les détails :

• Intégration d'un modèle Core ML dans ton application : Le guide d'Apple pour regrouper et appeler un modèle CoreML.
• Outils CoreML : Référence de conversion, de quantification et d'optimisation pour la chaîne d'outils coremltools qui alimente cette exportation.
• Rapports de performance Xcode Core ML : Placement matériel par couche et profilage de 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 à partir des 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 à 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, parcours la page du guide d'intégration et compare les formats avec le mode Benchmark.

FAQ#