Commencer

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.

Exécute YOLO dès aujourd'hui sur Apple Neural Engine avec les applications mobiles officielles

Le SDK iOS officiel Ultralytics YOLO et le plugin Flutter exécutent les exports CoreML sur Apple Neural Engine dès l'installation : inférence de caméra en temps réel, prédiction sur une seule image et téléchargement automatique de modèles pour les sept tâches YOLO26, y compris la profondeur. Pour le déploiement sur NPU Android, consulte l'intégration Qualcomm QNN.

Tailles d'entrée mobiles officielles

Exporter les modèles de classification à imgsz=224. Exporter les modèles de détection, de segmentation, de segmentation sémantique, de profondeur, de pose et OBB à imgsz=640. Cette norme 224/640 est commune aux ressources mobiles officielles CoreML, LiteRT et QNN.

Le nouveau format Core AI d’Apple

Apple a introduit le nouveau framework Core AI et le format .aimodel pour la génération iOS 27 et macOS 27, et Ultralytics l’exporte avec format="coreai". CoreML reste le format par défaut des SDK Ultralytics pour iOS et Flutter, qui chargent Core AI en option sur les appareils iOS 27, ainsi que le format offrant une compatibilité plus étendue avec les appareils Apple.



À regarder : Comment exporter Ultralytics YOLO26 vers CoreML avec une quantification INT8 | Déploiement sur Apple | iOS/MacOS 🍎

Qu’est-ce que CoreML ?#

Apple CoreML deployment pipeline

CoreML (stylisé « Core ML » par Apple) est le framework d’apprentissage automatique d’Apple conçu pour fonctionner sur l’appareil. Il charge les modèles au format moderne Programme ML — le bundle .mlpackage produit par l’exportateur Ultralytics — et répartit leur exécution entre le CPU, le GPU et le moteur neuronal Apple (ANE), le NPU dédié intégré à 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 des utilisateurs 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.
  • Choisis la sortie : les exports par défaut laissent la NMS à ton application. Utilise nms=True pour intégrer la NMS, ou nms=False pour la tête de YOLO26 sans NMS.
  • 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 artefacts CoreML INT8 YOLO26n standardisés v8.3.0 sur un iPhone 17 Pro doté de 12 Go de mémoire et d’iOS 27.0.1. Son A19 Pro comprend un CPU à 6 cœurs (2 cœurs Performance et 4 cœurs Efficiency), un GPU à 6 cœurs avec Neural Accelerators 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 la mise à l’échelle de l’entrée dans la requête d’inférence ; le prétraitement est donc indiqué comme nul et son coût est inclus dans l’inférence.

ModèleTâchetaille
(pixels)
CPU
Core ML .cpuOnly
(ms)
CPU + ANE privilégié
Core ML .cpuAndNeuralEngine
(ms)
YOLO26nDétection6408.8
0.0 / 8.8 / 0.0
3.7
0.0 / 3.7 / 0.0
YOLO26n-segSegmentation64012.3
0.0 / 11.7 / 0.6
4.9
0.0 / 4.3 / 0.6
YOLO26n-semSémantique6409.3
0.0 / 9.0 / 0.3
4.4
0.0 / 4.1 / 0.3
YOLO26n-depthProfondeur64026.0
0.0 / 25.1 / 1.0
5.5
0.0 / 4.7 / 0.9
YOLO26n-clsClassification2244.1
0.0 / 4.1 / 0.0
2.0
0.0 / 1.9 / 0.0
YOLO26n-posePose64012.0
0.0 / 12.0 / 0.0
4.0
0.0 / 4.0 / 0.0
YOLO26n-obbOBB64010.7
0.0 / 10.7 / 0.0
3.9
0.0 / 3.9 / 0.0
  • 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.
  • Sous iOS 27.0.1, l’inférence .cpuOnly des modèles de profondeur, de pose et OBB l et x plante dans les noyaux CPU de Core ML (EXC_BAD_ACCESS dans libBNNS) ; les mêmes modèles s’exécutent avec .cpuAndNeuralEngine, et toutes les autres tâches et tailles s’exécutent sur le CPU.
  • 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 sur CPU/GPU Android dans l’intégration LiteRT, les résultats MediaTek Dimensity et les résultats 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.

TâcheYOLOv8YOLO11YOLO26
Détecter✅✅✅
Segmenter✅✅✅
Sémantique❌❌✅
Profondeur❌❌✅
Classifier✅✅✅
Pose✅✅✅
OBB✅✅✅

Exporter des modèles YOLO26 vers CoreML#

Installation#

Pour installer le package requis, exécute :

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

Export
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
Prédiction
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")
Valider
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#

ArgumentTypeValeur par défautDescription
formatstr'coreml'Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour définir des dimensions spécifiques.
quantizeint ou strNonePrécision de quantification : 16 (FP16), 8 ou "w8a16" (identiques : poids palettisés k-means sur 8 bits avec calcul FP16), ou 32 ou non défini (FP32). Les programmes ML NMS utilisent FP16 (pour l'aperçu Xcode, et requis pour la segmentation et la pose) ; passe 32 pour remplacer ce réglage en détection. Remplace les indicateurs obsolètes half/int8.
nmsbool, facultatifNoneSélectionne la sortie brute (None, par défaut), le NMS intégré (True) ou la tête sans NMS (False). Le NMS intégré prend en charge la détection, la segmentation et la pose avec dynamic=False.
dynamicboolFalsePermet des tailles d’entrée dynamiques. Non pris en charge pour les modèles de classification ou RT-DETR, et incompatible avec nms=True.
batchint1Définit la taille de lot pour l’inférence du modèle exporté, c’est-à-dire le nombre maximal d’images que le modèle exporté traitera simultanément en mode predict. Les valeurs supérieures à 1 nécessitent dynamic=True.
devicestrNoneDéfinit l’appareil utilisé pour l’export : GPU (device=0), CPU (device=cpu), MPS pour Apple Silicon (device=mps).

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 pour les versions antérieures de macOS), ce qui maintient l'inférence sur le Neural Engine (~3× plus rapide que le CPU). Cela évite également une limitation actuelle de macOS sur l'hôte, 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. Les modèles RT-DETR font exception : ils sont chargés avec ComputeUnit.ALL, car leur précision FP16 diminue lorsqu'ils s'exécutent uniquement sur le Neural Engine.

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 :

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.

  1. Entraîne ton modèle avec le mode Train d’Ultralytics, ou commence avec les poids officiels de 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, soit via le SDK iOS officiel et le plugin Flutter, soit avec ta propre intégration Vision.

FAQ#

  • Exécute model.export(format="coreml", imgsz=640) dans Python ou yolo export model=yolo26n.pt format=coreml imgsz=640 depuis la CLI sous macOS ou Linux x86. Utilise imgsz=224 pour la classification et ajoute quantize=8 pour correspondre aux modèles officiels de l’application. L’export produit un programme ML yolo26n.mlpackage prêt à être utilisé avec Xcode, le SDK iOS ou le plugin Flutter.

  • Utilise nms=True si ton application a besoin de détections avec le NMS intégré. Par défaut, nms=None exporte des sorties brutes one-to-many que ton application peut traiter ; nms=False sélectionne la tête sans NMS de YOLO26. Le NMS intégré prend en charge la détection, la segmentation et la pose avec des formes statiques ; les autres tâches conservent leurs sorties natives.

  • Les modèles de l’application officielle Ultralytics sont distribués en INT8, ce qui réduit la taille du téléchargement au minimum et offre les vitesses indiquées dans le tableau ci-dessus. quantize=16 (FP16) est une solution prudente qui n’entraîne pratiquement aucune perte de précision. Valide ton export précis avec model.val() sur un Mac avant sa mise en production.

  • Définis MLModelConfiguration.computeUnits = .cpuAndNeuralEngine (valeur par défaut du SDK iOS sous iOS 16 et versions ultérieures). Évite .all dans les applications de caméra : le GPU est occupé à composer l’aperçu, et y planifier l’inférence entraîne des variations du temps de trame. Vérifie le placement à l’aide d’un rapport de performances Core ML de Xcode.

  • Oui, sous macOS : yolo predict model=yolo26n.mlpackage source=image.jpg et yolo val model=yolo26n.mlpackage data=coco8.yaml fonctionnent comme pour tout autre format. L’exécution de CoreML nécessite du matériel Apple ; ces modes ne sont donc pas disponibles sous Linux ni Windows.

  • Utilise le SDK Ultralytics YOLO officiel pour iOS (Swift Package) ou le plugin Flutter. Les deux chargent les modèles officiels par leur nom, les téléchargent et les mettent en cache automatiquement, les exécutent sur le Neural Engine et incluent des interfaces complètes pour la caméra en temps réel — le tableau de performances mesurées ci-dessus a été réalisé précisément avec cette pile.

Commentaires13

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. Afool4UGitHub

    Hello! I have trouble when I tried to export yolo11n.pt to coreml model with tracking. for example, the exist tracking method is like this:

    # use YOLO tracking
    results = yolo_model.track(frame, persist=True, verbose=False)

    And I've export pt format and reloaded the new coreml format model like this:

    model.export(format='coreml', nms=True, half=False)
    model = ct.models.MLModel('yolo11n.mlpackage')

    But when I tried to make a tracking on my camera stream, it seems that object 'model' have no attribute named 'track'. So how could I use tracking by a coreml format model? It's very important to me because the coreml model works well on my macbook.

  2. SebastianxhjGitHub

    I used the example python code you guys gave. Why does output output confidence and coordination after converting my target detection model to mlpackage format. is it normal to not return processed images? Or is there something wrong with my export process.

    1. Glenn JocherUltralytics

      @taeja7 the CoreML export returns raw detection outputs (confidence, coordinates) rather than processed images by design. This is normal behavior, as post-processing like bounding box rendering is typically handled within the application layer after inference. For implementation guidance, see the CoreML deployment documentation on handling model outputs in Apple apps.

  3. smadsenjcGitHub

    I have a trained model that is doing very well in Python, but once I convert it to CoreML .mlpackage format and run inference in Swift, the results are garbage on the same images.

    If I export with nms=True, I get multiple overlapping bounding boxes back, similar-ish to when no NMS is done. The number of clusters matches the objects I expect, and they're kind of relatively positioned correctly, although the boxes themselves are too large and clustered in the wrong location. The predicted labels are right.

    If I export with nms=False, I get a different result back from VNCoreMLRequest: a single VNCoreMLFeatureValueObservation instead of an array of VNRecognizedObjectObservation.

    I've used both coremltools 8.0 and 8.2. If I run inference in Python using the CoreML model, it's fine (with nms=False; True fails).

    This was working back in November, but I got side-tracked with other work. I haven't touched the model.

    1. Glenn JocherUltralytics

      @smadsenjc for CoreML inference discrepancies between Python and Swift, ensure you're handling NMS parameters correctly in your Swift implementation. The CoreML export with nms=True requires explicit IOU and confidence threshold inputs during inference - these must match your Python training parameters. We recommend verifying your Swift preprocessing matches Ultralytics' RGB channel ordering and normalization (scale=1/255, bias=[0,0,0]). For direct assistance with Apple's Vision framework implementation, refer to Apple's CoreML integration guide linked in our documentation.

  4. CharanPrasadKGitHub

    When I am Converting the Yolo .pt model to coreml model , mlpackage is creating and when I am checking it in the xcode the class labels are missing. For the core ml models in ultralytics github page class labels are there. If its solved i can test my custom yolo models. Thank you.

    1. Glenn JocherUltralytics(modifié)

      @CharanPrasadK it seems the class labels are not being included in your CoreML export. Ensure that your model is correctly labeled during training and export by checking the names attribute in the model. If the issue persists, please verify that you're using the latest ultralytics package. For further details, refer to the CoreML export documentation. Let us know if you need additional assistance!

  5. ChristalZhuGitHub

    Still the same problem, this is the result of running in the terminal: PyTorch: starting from '/Users/doublepeng/Desktop/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) ((1, 37, 8400), (1, 32, 160, 160)) (6.5 MB)

    CoreML: starting export with coremltools 7.2... CoreML: WARNING ⚠️ 'nms=True' is only available for Detect models like 'yolov8n.pt'. Tuple detected at graph output. This will be flattened in the converted model. Converting PyTorch Frontend ==> MIL Ops: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌| 679/681 [00:00<00:00, 8273.25 ops/s] Running MIL frontend_pytorch pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 157.94 passes/s] Running MIL default pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 78/78 [00:00<00:00, 82.56 passes/s] Running MIL backend_mlprogram pipeline: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 160.71 passes/s] CoreML: export success ✅ 7.7s, saved as '/Users/doublepeng/Desktop/best.mlpackage' (6.4 MB)

    Export complete (8.1s) Results saved to /Users/doublepeng/Desktop Predict: yolo predict task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 Validate: yolo val task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 data=/home/yujialin/Documents/xiaotong/corn/data/corn.yaml Visualize: https://netron.app In the run mlpackage file, the class label is still missing in General, and there is no preview. Since I am only doing corn segmentation, if possible, can I send you my .pt file?

    1. Glenn JocherUltralytics

      @ChristalZhu hello,

      Thank you for providing the detailed output from your terminal. It looks like the CoreML export process completed successfully, but you're experiencing issues with missing class labels and preview in the .mlpackage file.

      To assist you better, could you please confirm the following:

      1. Are you using the latest versions of torch and ultralytics? If not, please upgrade and try the export process again.
      2. Could you provide a minimum reproducible example of your code? This will help us understand the context and reproduce the issue on our end. You can refer to our minimum reproducible example guide for more details.

      Regarding your .pt file, we cannot accept direct file submissions. However, you can share the relevant code snippets and configurations you used for training and exporting the model.

      Here's a quick example of how to export a YOLOv8 model to CoreML and run inference:

      from ultralytics import YOLO
      
      # Load the YOLOv8 model
      model = YOLO("yolov8n.pt")
      
      # Export the model to CoreML format
      model.export(format="coreml")  # creates 'yolov8n.mlpackage'
      
      # Load the exported CoreML model
      coreml_model = YOLO("yolov8n.mlpackage")
      
      # Run inference
      results = coreml_model("https://ultralytics.com/images/bus.jpg")

      For more detailed instructions, you can visit our CoreML integration guide.

      Looking forward to your response so we can help resolve this issue.

  6. ChristalZhuGitHub

    我按照https://harshavardhanyellanki.github.io/YOLOV8_GUI/tasks/segmentation/的方法,将我自己训练的分割模型进行导出成mlpackage,但是出现了问题就是打开这个mlpackage之后,缺少class label文件和缺少了preview,请问这个有什么办法解决,如果可以的话,麻烦发送到我的email账号:wenpeng.zhu@foxmail.com万分感谢。 I followed the method at https://harshavardhanyellanki.github.io/YOLOV8_GUI/tasks/segmentation/ to export the segmentation model I trained myself into mlpackage, but the problem is that after opening this mlpackage, the class label file and the preview are missing. Is there any way to solve this problem? If possible, please send it to my email account: wenpeng.zhu@foxmail.com. Thank you very much.

    1. Paula DerrengerUltralytics

      Hello @ChristalZhu,

      Thank you for reaching out and providing details about the issue you're facing with exporting your YOLOv8 segmentation model to CoreML. Let's work together to resolve this.

      Firstly, please ensure that you are using the latest versions of torch and ultralytics. You can update them using the following commands:

      pip install --upgrade torch ultralytics

      If the issue persists, could you please provide a minimum reproducible code example? This will help us better understand the problem and investigate a solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

      Regarding the missing class label file and preview in the .mlpackage, this can sometimes occur if the export process does not include all necessary metadata. Here is a Python example to ensure the export includes all required components:

      from ultralytics import YOLO
      
      # Load your trained YOLOv8 model
      model = YOLO("path/to/your/custom_model.pt")
      
      # Export the model to CoreML format
      model.export(format="coreml", nms=True)  # Ensure NMS is included for proper detection

      After exporting, you can manually check the .mlpackage to ensure it contains the necessary class labels and preview files. If they are still missing, please let us know, and we can further investigate.

      For more detailed instructions on exporting to CoreML, you can visit our documentation here: CoreML Export Guide.

      Feel free to share any additional details or errors you encounter. We're here to help!

    2. ChristalZhuGitHub

      Still the same problem, this is the result of running in the terminal: PyTorch: starting from '/Users/doublepeng/Desktop/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) ((1, 37, 8400), (1, 32, 160, 160)) (6.5 MB)

      CoreML: starting export with coremltools 7.2... CoreML: WARNING ⚠️ 'nms=True' is only available for Detect models like 'yolov8n.pt'. Tuple detected at graph output. This will be flattened in the converted model. Converting PyTorch Frontend ==> MIL Ops: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌| 679/681 [00:00<00:00, 8273.25 ops/s] Running MIL frontend_pytorch pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 157.94 passes/s] Running MIL default pipeline: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 78/78 [00:00<00:00, 82.56 passes/s] Running MIL backend_mlprogram pipeline: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 160.71 passes/s] CoreML: export success ✅ 7.7s, saved as '/Users/doublepeng/Desktop/best.mlpackage' (6.4 MB)

      Export complete (8.1s) Results saved to /Users/doublepeng/Desktop Predict: yolo predict task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640
      Validate: yolo val task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 data=/home/yujialin/Documents/xiaotong/corn/data/corn.yaml
      Visualize: https://netron.app In the run mlpackage file, the class label is still missing in General, and there is no preview. Since I am only doing corn segmentation, if possible, can I send you my .pt file?

    3. Paula DerrengerUltralytics

      Hello @ChristalZhu,

      Thank you for providing the detailed output from your terminal. It looks like the CoreML export process completed successfully, but you're encountering issues with missing class labels and preview in the .mlpackage.

      To address this, please ensure you are using the latest versions of torch and ultralytics. You can update them using the following commands:

      pip install --upgrade torch ultralytics

      If the issue persists, could you please provide a minimum reproducible code example? This will help us better understand the problem and investigate a solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

      Regarding the missing class label file and preview in the .mlpackage, this can sometimes occur if the export process does not include all necessary metadata. Here is a Python example to ensure the export includes all required components:

      from ultralytics import YOLO
      
      # Load your trained YOLOv8 model
      model = YOLO("path/to/your/custom_model.pt")
      
      # Export the model to CoreML format
      model.export(format="coreml", nms=True)  # Ensure NMS is included for proper detection

      After exporting, you can manually check the .mlpackage to ensure it contains the necessary class labels and preview files. If they are still missing, please let us know, and we can further investigate.

      For more detailed instructions on exporting to CoreML, you can visit our documentation here: CoreML Export Guide.

      Feel free to share any additional details or errors you encounter. We're here to help! 😊