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.
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.
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.
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 ?#
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=Truepour intégrer la NMS, ounms=Falsepour 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
.mlpackagefonctionne 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èle | Tâche | taille (pixels) | CPU Core ML .cpuOnly(ms) | CPU + ANE privilégié Core ML .cpuAndNeuralEngine(ms) |
|---|---|---|---|---|
| YOLO26n | Détection | 640 | 8.8 0.0 / 8.8 / 0.0 | 3.7 0.0 / 3.7 / 0.0 |
| YOLO26n-seg | Segmentation | 640 | 12.3 0.0 / 11.7 / 0.6 | 4.9 0.0 / 4.3 / 0.6 |
| YOLO26n-sem | Sémantique | 640 | 9.3 0.0 / 9.0 / 0.3 | 4.4 0.0 / 4.1 / 0.3 |
| YOLO26n-depth | Profondeur | 640 | 26.0 0.0 / 25.1 / 1.0 | 5.5 0.0 / 4.7 / 0.9 |
| YOLO26n-cls | Classification | 224 | 4.1 0.0 / 4.1 / 0.0 | 2.0 0.0 / 1.9 / 0.0 |
| YOLO26n-pose | Pose | 640 | 12.0 0.0 / 12.0 / 0.0 | 4.0 0.0 / 4.0 / 0.0 |
| YOLO26n-obb | OBB | 640 | 10.7 0.0 / 10.7 / 0.0 | 3.9 0.0 / 3.9 / 0.0 |
- Les ressources de publication exactes
v8.3.0dé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
.cpuOnlydes modèles de profondeur, de pose et OBBletxplante dans les noyaux CPU de Core ML (EXC_BAD_ACCESSdanslibBNNS) ; 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âche | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| Détecter | ✅ | ✅ | ✅ |
| Segmenter | ✅ | ✅ | ✅ |
| Sémantique | ❌ | ❌ | ✅ |
| Profondeur | ❌ | ❌ | ✅ |
| Classifier | ✅ | ✅ | ✅ |
| Pose | ✅ | ✅ | ✅ |
| OBB | ✅ | ✅ | ✅ |
Exporter des modèles YOLO26 vers CoreML#
Installation#
Pour installer le package requis, exécute :
# Install the required package for YOLO26
pip install ultralyticsLe 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 classificationfrom 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#
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'coreml' | Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement. |
imgsz | int ou tuple | 640 | Taille 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. |
quantize | int ou str | None | Pré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. |
nms | bool, facultatif | None | Sé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. |
dynamic | bool | False | Permet des tailles d’entrée dynamiques. Non pris en charge pour les modèles de classification ou RT-DETR, et incompatible avec nms=True. |
batch | int | 1 | Dé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. |
device | str | None | Dé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 :
- 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
coremltoolsutilisé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é#
- Entraîne ton modèle avec le mode Train d’Ultralytics, ou commence avec les poids officiels de YOLO26.
- Exporte avec
model.export(format="coreml", quantize=8, imgsz=640)sous macOS ou Linux x86 (imgsz=224pour la classification) - 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 - 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 ouyolo export model=yolo26n.pt format=coreml imgsz=640depuis la CLI sous macOS ou Linux x86. Utiliseimgsz=224pour la classification et ajoutequantize=8pour correspondre aux modèles officiels de l’application. L’export produit un programme MLyolo26n.mlpackageprêt à être utilisé avec Xcode, le SDK iOS ou le plugin Flutter.Utilise
nms=Truesi ton application a besoin de détections avec le NMS intégré. Par défaut,nms=Noneexporte des sorties brutes one-to-many que ton application peut traiter ;nms=Falsesé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 avecmodel.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.alldans 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.jpgetyolo val model=yolo26n.mlpackage data=coco8.yamlfonctionnent 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.
Afool4U
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.
Sebastianxhj
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.
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.
smadsenjc
I have a trained model that is doing very well in Python, but once I convert it to CoreML
.mlpackageformat 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 fromVNCoreMLRequest: a singleVNCoreMLFeatureValueObservationinstead of an array ofVNRecognizedObjectObservation.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;Truefails).This was working back in November, but I got side-tracked with other work. I haven't touched the model.
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=Truerequires 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.
CharanPrasadK
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.
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
namesattribute in the model. If the issue persists, please verify that you're using the latestultralyticspackage. For further details, refer to the CoreML export documentation. Let us know if you need additional assistance!
ChristalZhu
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?
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
.mlpackagefile.To assist you better, could you please confirm the following:
- Are you using the latest versions of
torchandultralytics? If not, please upgrade and try the export process again. - 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
.ptfile, 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.
- Are you using the latest versions of
ChristalZhu
我按照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.
Paula DerrengerUltralyticsHello @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
torchandultralytics. You can update them using the following commands:pip install --upgrade torch ultralyticsIf 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 detectionAfter exporting, you can manually check the
.mlpackageto 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!
ChristalZhu
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?
Paula DerrengerUltralyticsHello @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
torchandultralytics. You can update them using the following commands:pip install --upgrade torch ultralyticsIf 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 detectionAfter exporting, you can manually check the
.mlpackageto 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! 😊
