Erste Schritte

Apple Core ML-Export

Core ML ist Apples Framework zum Ausführen von Machine-Learning-Modellen auf iPhone, iPad, Mac, Apple Watch, Apple TV und Apple Vision Pro. Beim Export eines Ultralytics YOLO26-Modells mit format="coreml" entsteht ein yolo26n.mlpackage-Modellpaket, das Core ML auf CPU, GPU und Apple Neural Engine mit FP32, FP16 oder 8-Bit-Gewichten ausführt.

Apples neues Core-AI-Format

Apple hat das neue Core-AI-Framework und das Format .aimodel für die Generation von iOS 27 und macOS 27 eingeführt; Ultralytics exportiert in dieses Format mit format="coreai". Core ML bleibt das Standardformat der Ultralytics-SDKs für iOS und Flutter. Auf Geräten mit iOS 27 laden sie Core AI optional; für frühere Apple-Betriebssysteme bleibt Core ML das Format.

Auf einen Blick#

EigenschaftDetails
Argument formatcoreml (Aliase: mlpackage, mlprogram, apple, ios). mlmodel exportiert das frühere Neuronennetzformat
Ausgabeyolo26n.mlpackage, ein Modellpaket (ein Verzeichnis) im ML-Program-Format, in dem Klassennamen, Aufgabe und Bildgröße als Metadaten gespeichert sind
Ausführbar aufiPhone, iPad, Mac, Apple Watch, Apple TV und Apple Vision Pro, auf CPU, GPU und Apple Neural Engine
LaufzeitumgebungCore ML, das in Apples Betriebssysteme integriert ist; das exportierte ML-Programm gibt die Core-ML-Spezifikation 6 (iOS 15, macOS 12) oder, für INT8, die Spezifikation 7 (iOS 16, macOS 13) an. In Python das Paket coremltools unter macOS
PrecisionFP32, FP16, INT8 (8-Bit-Gewichte). YOLO26n ist 9,9 MB groß in FP32, 5,1 MB in FP16 und 2,7 MB in INT8
ExportrechnermacOS oder Linux x86-64 mit Python 3.13 oder älter. Nicht Windows. Für den Export ist keine GPU erforderlich
In der Cloud exportieren

Die Ultralytics Platform kann ein trainiertes Modell für dich nach Core ML exportieren, sodass du keine lokale Exportumgebung benötigst.

Schnellstart#

Installiere das Ultralytics-Paket mit den Abhängigkeiten für den Core-ML-Export unter macOS oder Linux x86-64:

pip install "ultralytics[export-coreml]"

Damit werden coremltools, scikit-learn und eine Version von numpy installiert, mit der coremltools funktioniert. Bei einer einfachen pip install ultralytics-Installation wird beim ersten Export coremltools installiert. Muss dabei auch eine neuere Version von numpy ersetzt werden, schlägt dieser Export fehl; der nächste funktioniert. Für den Export gelten diese Versionsanforderungen:

PaketErforderliche Version
Python3.13 oder älter, die neueste Version, für die coremltools 9.0 vorgefertigte Pakete bereitstellt
coremltools9.0 oder neuer
numpy2.3.5 oder älter. Beim Export wird Version 2.3.5 über eine neuere Version installiert
torch1.11 oder neuer
scikit-learnNur für quantize=8 und 'w8a16'. Das Extra export-coreml installiert Version 1.3.2 oder neuer; fehlt sie, wird sie beim Export installiert

Weitere Installationsmethoden findest du in der Installationsanleitung. Exportiere anschließend dein Modell und lade das exportierte Paket, um Inferenz auszuführen oder die Genauigkeit zu validieren.

Exportieren
from ultralytics import YOLO

# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Modell ins Core-ML-Format exportieren
model.export(format="coreml")  # erstellt „yolo26n.mlpackage“

# Oder exportiere stattdessen in FP16. Dadurch halbiert sich die Größe, und das Modell läuft auf der Neural Engine
model.export(format="coreml", quantize=16)  # erstellt „yolo26n.mlpackage“

Beide Exporte schreiben dasselbe yolo26n.mlpackage; der zweite ersetzt daher den ersten. Predict und Validate laufen nur unter macOS:

Vorhersagen
from ultralytics import YOLO

# Das exportierte Core-ML-Modell auf einem Mac laden
model = YOLO("yolo26n.mlpackage")

# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")
Validieren
from ultralytics import YOLO

# Das exportierte Core-ML-Modell auf einem Mac laden
model = YOLO("yolo26n.mlpackage")

# Die Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Unterstützte Aufgaben#

Der Core-ML-Export unterstützt alle sieben Ultralytics-Aufgaben mit YOLOv8-, YOLO11- und YOLO26-Modellen: Objekterkennung, Segmentierung, semantische Segmentierung, Tiefenschätzung, Klassifizierung, Posenschätzung und OBB. Semantische Segmentierung und Tiefenschätzung gibt es nur für YOLO26, die einzige Familie mit diesen Ausgabeköpfen. Auch Erkennungsmodelle von YOLOv5u, YOLOv9, YOLOv10 und YOLO12 lassen sich exportieren, ebenso RT-DETR- und YOLO-Worldv2-Modelle. Jede Kombination wurde mit einem Checkpoint pro Aufgabe getestet, zum Beispiel yolo11n-seg.pt, rtdetr-l.pt und yolov8s-worldv2.pt.

Exportargumente#

ArgumentTypStandardBeschreibung
formatstr'coreml'Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt.
imgszint oder tuple640Bildgröße der Modelleingabe, die beim Standardexport festgelegt wird: eine Ganzzahl für quadratische Bilder oder ein Tupel (height, width). Wenn du keinen Wert angibst, verwendet der Export die Bildgröße, mit der der Checkpoint trainiert wurde. Die offiziellen YOLO26-Checkpoints verwenden 640 für Erkennungs-, Segmentierungs- und Posenschätzungsmodelle sowie für semantische Modelle, die mit ADE20K vortrainiert wurden, 1024 für OBB-Modelle und semantische Modelle, die mit Cityscapes vortrainiert wurden, 768 für Tiefenschätzung und 224 für Klassifizierung.
quantizeint oder strNoneGenauigkeit: 16 (FP16) oder 8 (8-Bit-Gewichte mit FP16-Berechnung; 'w8a16' ergibt denselben Export); 32 bzw. kein Wert bedeutet FP32. Bei nms=True bedeutet kein Wert FP16. Ein mit quantize=8 trainierter Checkpoint kann nicht nach Core ML exportiert werden; siehe Einschränkungen und Fehlerbehebung. Ersetzt die veralteten Optionen half/int8.
nmsbool, optionalNoneWähle die Rohausgabe (None, Standard), eingebettetes NMS (True, für Erkennungs-, Segmentierungs- und Posenschätzungsmodelle mit dynamic=False) oder den NMS-freien Ausgabekopf (False). Siehe Ausgabeformat.
conffloatNoneKonfidenzschwelle, die in einem nms=True-Export gespeichert wird. Wenn nicht angegeben, wird 0.25 verwendet.
ioufloat0.5IoU-Schwelle, die in einem nms=True-Export gespeichert wird.
agnostic_nmsboolFalseKlassenunabhängige Auswahl: Bei einem nms=True-Export unterdrückt eine Box auch überlappende Boxen anderer Klassen. Außerdem ändert sich dadurch die Auswahl der Zeilen eines nms=False-Exports.
max_detint300Anzahl der Zeilen in der Ausgabe eines nms=False-Exports sowie eines Segmentierungs- oder Posenschätzungs-Exports mit nms=True. Für einen nms=True-Erkennungsexport gilt diese Begrenzung nicht.
dynamicboolFalseMacht Batchgröße, Höhe und Breite der Eingabe dynamisch und ändert die Eingabe von einem Bild in ein Array. Für Klassifizierungs- und RT-DETR-Modelle sowie mit nms=True nicht verfügbar. Siehe Bereitstellung.
batchint1Maximale Batchgröße eines dynamic=True-Exports. Ein Standardexport hat die Batchgröße 1; andere Werte führen zu einem Fehler.
devicestrNoneGerät, auf dem das Modell für die Konvertierung nachverfolgt wird; standardmäßig cpu. Ein mit mps erstellter FP32-Export hatte dieselbe Paketgröße und lieferte dieselben Ausgaben wie ein auf der CPU erstellter Export.

Die für alle Formate geltenden Argumente findest du in der Dokumentation zum Exportmodus.

Bildgröße und Einstellungen der offiziellen Mobilmodelle

Die offiziellen Core-ML-, LiteRT- und QNN-Mobilmodelle werden mit imgsz=640 exportiert, Klassifizierungsmodelle mit imgsz=224. Die semantischen Cityscapes-, Tiefenschätzungs- und OBB-Checkpoints werden standardmäßig mit einer größeren Bildgröße exportiert; gib daher imgsz=640 an, damit sie übereinstimmt. Die Core-ML-Modelle des Ultralytics-iOS-SDKs werden mit quantize=8 nms=False exportiert.

Precision#

quantize legt fest, wie die Gewichte gespeichert werden und mit welcher Genauigkeit Core ML rechnet. Für keine der drei Genauigkeitsstufen werden Kalibrierungsdaten benötigt. Die Größen beziehen sich auf ein YOLO26n-Erkennungsmodell, das mit imgsz=640 exportiert wurde:

quantizeGewichteBerechnungMindestversion des BetriebssystemsGröße von YOLO26n
nicht angegeben oder 32FP32FP32iOS 15, macOS 129.9 MB
16FP16FP16iOS 15, macOS 125.1 MB
8 oder 'w8a16'8 BitFP16iOS 16, macOS 132.7 MB
  • FP32: Standard, wenn nms=True nicht festgelegt ist. Auf einem Apple M4 lieferten die FP32-Exporte aller sieben Aufgaben mit den Recheneinheiten CPU_AND_NE, die Ultralytics verwendet, dieselben Ausgaben wie mit CPU_ONLY und waren damit nicht schneller. Exportiere in FP16 oder INT8, um die Neural Engine zu nutzen. Auf einem iPhone 17 Pro war ein FP32-YOLO26n-Erkennungsmodell bei drei Durchläufen im Median mit der Neural Engine höchstens 5 % schneller; siehe Gemessene Leistung.
  • FP16: quantize=16 speichert die Gewichte und rechnet mit halber Genauigkeit. Die Bildeingabe und die Ausgabearrays behalten die Datentypen des FP32-Exports (float32 oder bei semantischer Segmentierung int32), sodass für das FP32-Modell geschriebener Inferenzcode unverändert funktioniert.
  • INT8: quantize=8 und quantize="w8a16" ergeben denselben Export. Dabei werden die Gewichte jeder Schicht mit k-means in Gruppen zu 256 Werten eingeteilt und für jedes Gewicht ein 8-Bit-Index gespeichert (Palettierung); gerechnet wird wie bei einem FP16-Export in FP16. Gewichtstensoren mit höchstens 512 Werten werden nicht palettiert. Dies ist eine Komprimierung der Gewichte und keine kalibrierte Aktivierungsquantisierung, die quantize=8 bei anderen Formaten auswählt; daher ist kein Argument data erforderlich. Bei bereits installiertem scikit-learn dauerte der Export eines YOLO26n-Erkennungsmodells auf einem Apple M4 18 bis 26 Sekunden und auf einem x86-64-Server 23 bis 24 Sekunden; der Export von YOLO26x dauerte auf diesem Server 104 Sekunden.
  • Genauigkeit: COCO-Ergebnisse für jede Genauigkeitsstufe findest du in den Apple-M4-Tabellen. Validiere ein exportiertes Modell mit deinen eigenen Daten, bevor du es bereitstellst.

Ausgabeformat#

Beim Export wird ein Paket geschrieben – ein Verzeichnis, das Xcode, Core ML und coremltools als einzelnes Modell öffnen:

Datei in yolo26n.mlpackage/Inhalt
Manifest.jsonDie Liste der Dateien im Paket
Data/com.apple.CoreML/model.mlmodelDer Netzwerkgraph, die Beschreibungen der Eingaben und Ausgaben sowie die Metadaten: Klassennamen, Aufgabe, Bildgröße, Batchgröße, Schrittweite und Exportargumente, die Ultralytics beim Laden des Modells ausliest
Data/com.apple.CoreML/weights/weight.binDie Gewichte

Das Modell erwartet eine Eingabe namens image. Bei einem Standardexport ist dies eine Core-ML-Bildeingabe: ein RGB-Bild in der Exportgröße imgsz mit Pixelwerten von 0 bis 255. Die Division durch 255 ist Teil des Modells; skaliere das Bild also nicht selbst. In einer App kann Apples Vision-Framework ein Kamerabild auf diese Eingabegröße skalieren. Ein Export mit dynamic=True erwartet stattdessen ein float32-Array der Form (batch, 3, height, width), in RGB und auf 0–1 skaliert.

Die Namen der Ausgabearrays werden vom Konverter erzeugt, zum Beispiel var_1401, und unterscheiden sich je nach Modell und Exporteinstellungen. Lies sie daher aus der Modellbeschreibung aus, statt sie fest zu kodieren. Das Argument nms und die Aufgabe bestimmen die Ausgaben. Die Formen unten beziehen sich auf die offiziellen YOLO26n-Checkpoints bei ihrer standardmäßigen Exportgröße; für semantische Segmentierung ist der Cityscapes-Checkpoint yolo26n-sem.pt angegeben:

AufgabeStandardmäßiges imgszAusgabe mit nms=NoneAusgabe mit nms=FalseAusgabe mit nms=True
Detect640(1, 84, 8400)(1, 300, 6)confidence (boxes, 80) und coordinates (boxes, 4)
Segment640(1, 116, 8400) und (1, 32, 160, 160)(1, 300, 38) und (1, 32, 160, 160)(1, 300, 38) und (1, 32, 160, 160)
Semantisch1024(1, 1024, 1024), Klassenindex für jedes PixelWie nms=NoneWie nms=None
Tiefe768(1, 1, 768, 768), TiefenkarteWie nms=NoneWie nms=None
Klassifizieren224classLabel und classLabel_probsWie nms=NoneWie nms=None
Pose640(1, 56, 8400)(1, 300, 57): 6 Boxwerte, dann 17 Keypoints mit je 3 Werten(1, 300, 57)
OBB1024(1, 20, 21504)(1, 300, 7): 4 Boxwerte, Score, Klasse, WinkelWie nms=None
  • Rohausgabe (nms=None): Form (1, values, anchors), dieselben Rohvorhersagen wie bei einem standardmäßigen ONNX-Export: für jeden Anker die Boxmitte x, Boxmitte y, Breite und Höhe in Eingabepixeln, danach die Klassenwerte und schließlich die Werte der jeweiligen Aufgabe (32 Maskenkoeffizienten, 17 x 3 Schlüsselpunkte oder der OBB-Winkel im Bogenmaß). Wende NMS selbst an.
  • NMS-freie Ausgabe (nms=False): max_det (standardmäßig 300) Zeilen mit x1, y1, x2, y2, score, class in Eingabepixeln, ohne NMS-Schritt. OBB-Zeilen haben die Form center x, center y, width, height, score, class, angle. Filtere die Zeilen nach dem Score. Verfügbar für Modelle mit NMS-freiem Ausgabekopf, etwa YOLO26 und YOLOv10.
  • Eingebettetes NMS für Erkennung (nms=True): Das Paket ist eine Core-ML-Pipeline aus dem Modell und Apples NMS-Stufe. Sie gibt confidence zurück, eine Zeile mit Klassenwerten für jede beibehaltene Box, sowie coordinates, Boxmitte x, Boxmitte y, Breite und Höhe jeder beibehaltenen Box relativ zur Bildgröße (0–1). Die Zeilenanzahl variiert je nach Bild. conf (standardmäßig 0.25), iou (standardmäßig 0.5) und agnostic_nms werden beim Export in der Pipeline gespeichert. Die Eingaben confidenceThreshold und iouThreshold können weggelassen werden und ersetzen für eine einzelne Vorhersage die beiden Schwellenwerte. max_det hat keine Wirkung: Ein Export mit max_det=2 gab für ein Testbild trotzdem fünf Boxen zurück. Bei Modellen, deren Klassenzahl kein Vielfaches von 80 ist, ergänzt der Export confidence um zusätzliche Spalten bis zum nächsten Vielfachen von 80.
  • Eingebettetes NMS für Segmentierung und Posenschätzung (nms=True): NMS wird im Modellgraphen ausgeführt. Dieser gibt max_det Zeilen mit x1, y1, x2, y2, score, class zurück, gefolgt von den Maskenkoeffizienten oder Schlüsselpunkten. Zeilen nach der letzten Erkennung haben einen Score von 0; filtere sie daher nach dem Score. conf, iou, agnostic_nms und max_det werden beim Export festgelegt; diese Exporte verwenden immer FP16 oder INT8.
  • Segmentierung: Die 3D-Ausgabe enthält die Vorhersagen, die 4D-Ausgabe die Maskenprototypen.
  • Semantische Segmentierung: Die Ausgabe enthält für jedes Pixel den Klassenindex als int32, nicht einen Score für jede Klasse.
  • Klassifizierung: Das Paket ist ein Core-ML-Klassifikator, der classLabel, den Namen der obersten Klasse, und classLabel_probs, ein Wörterbuch mit Klassennamen und Wahrscheinlichkeiten, zurückgibt. coremltools gibt die Wahrscheinlichkeiten außerdem als (1, classes)-Array zurück.

YOLO("yolo26n.mlpackage") liest das Layout aus den Modellmetadaten aus; diese Angaben brauchst du also nur, wenn du das Modell in deinem eigenen Code ausführst. Die Metadaten sind als Zeichenfolgen in den benutzerdefinierten Metadaten des Modells gespeichert. Zu den Schlüsseln gehören names, task, imgsz, stride, batch, end2end, args und bei Posenschätzungsmodellen kpt_shape.

Mit coremltools ausführen#

Um das Paket auf einem Mac außerhalb des Ultralytics-Pakets auszuführen, lade es mit coremltools. Damit wählst du auch die Recheneinheiten aus:

# Zuerst exportieren: yolo export model=yolo26n.pt format=coreml quantize=16 nms=False
import ast

import coremltools as ct
import numpy as np
from PIL import Image

model = ct.models.MLModel("yolo26n.mlpackage", compute_units=ct.ComputeUnit.CPU_AND_NE)

image = Image.fromarray(np.zeros((640, 640, 3), dtype=np.uint8))  # dein Letterbox-Bild: RGB, 0–255
outputs = model.predict({"image": image})
detections = next(iter(outputs.values()))[0]  # das einzige Ausgabe-Array, erstes Bild: Form (300, 6)
assert detections.shape == (300, 6), "export a detection model at imgsz=640 with nms=False"
detections = detections[detections[:, 4] > 0.25]  # Zeilen oberhalb des Konfidenzschwellenwerts beibehalten

names = ast.literal_eval(model.user_defined_metadata["names"])  # {0: 'person', 1: 'bicycle', ...}

Bereitstellen#

Füge auf einem iPhone oder iPad .mlpackage zu deinem Xcode-Projekt hinzu oder nutze das Ultralytics-iOS-SDK, das das Paket lädt und die Ausgaben für dich dekodiert. Installiere auf einem Mac das Paket mit pip install ultralytics und kopiere .mlpackage dorthin: YOLO("yolo26n.mlpackage") führt das Modell mit coremltools aus, das Ultralytics bei der ersten Verwendung installiert.

  • Recheneinheiten: Ultralytics lädt ein Modell mit den Core-ML-Recheneinheiten CPU_AND_NE, also CPU und Neural Engine; für RT-DETR-Modelle wird ALL verwendet. Lässt sich das Modell damit nicht laden, wird es mit CPU_ONLY geladen. Es gibt kein Argument zur Auswahl anderer Recheneinheiten; lade das Paket dazu mit coremltools. Auf einem Apple M4 mit macOS 27.2 liefen außerdem die FP32-, FP16- und INT8-Modelle aller sieben YOLO26n-Aufgaben mit ALL und CPU_AND_GPU; andere macOS-Versionen wurden nicht getestet.
  • device: Das Argument device wählt nicht die Core-ML-Hardware aus. Mit device="mps" führt Ultralytics die Vor- und Nachverarbeitung auf der Apple GPU aus, während Core ML weiterhin dieselben Recheneinheiten nutzt. Auf einem M4 wurde die Inferenz dadurch nicht schneller: Ein FP16-YOLO26n-Modell brauchte mit device="mps" etwa 8 ms pro Bild und ohne diese Option etwa 6 ms. Lass device daher weg.
  • Genauigkeit und Neural Engine: Auf einem Apple M4 dauerte die Inferenzphase von YOLO() bei einem FP32-YOLO26n-Modell in predict 18 bis 20 ms pro Bild (21,0 ms bei der COCO-Validierung in Apple M4) und bei den FP16- und INT8-Modellen etwa 6 ms. Die Messungen erfolgten mit Standardexporten (nms=None) für ein Testbild unter macOS 27.2. Nur mit coremltools brauchten dieselben FP16- und INT8-Modelle mit CPU_AND_NE etwa 2 ms gegenüber 9 bis 10 ms mit CPU_ONLY.
  • Feste Eingabeform: Ein Standardexport läuft immer mit der Export-imgsz, die Ultralytics aus den Modellmetadaten ausliest. Ein an predict oder val übergebenes imgsz wird ignoriert. Ultralytics übergibt jedes Bild eines Batches als separate Einzelbildanfrage an Core ML, sodass beliebig viele Bilder verarbeitet werden können; val legt batch=1 fest.
  • Dynamischer Export (dynamic=True): Das Modell unterstützt Batchgrößen von 1 bis zur Export-batch und Bildgrößen von 32 Pixeln bis zum Doppelten der Export-imgsz. Ultralytics übergibt Bildgrößen als Vielfache der Schrittweite des Modells. Größere Batches teilt Ultralytics in Teilbatches der Export-batch auf. Beim NMS-freien Ausgabekopf ist die Mindestgröße größer: 128 Pixel für ein YOLO26n-Modell, das mit imgsz=640 und nms=False exportiert wurde. Getestet mit einem Erkennungsmodell bei 320, 640 und 1280 Pixeln sowie mit einem Segmentierungsmodell bei 640 Pixeln.

Ultralytics-iOS-SDK und Flutter-Plug-in#

Das Ultralytics-iOS-SDK ist ein Swift-Paket, das Core-ML-Exporte für alle sieben YOLO26-Aufgaben lädt und dekodierte Ergebnisse zurückgibt. Exportiere mit den Einstellungen der offiziellen App-Modelle:

# INT8 weights and the NMS-free head; use imgsz=224 for classification models
yolo export model=yolo26n.pt format=coreml quantize=8 nms=False imgsz=640

Füge deiner App mit Swift Package Manager https://github.com/ultralytics/yolo-ios-app.git hinzu und lade anschließend das exportierte Paket:

import UltralyticsYOLO

// Load your exported Core ML model, then run inference on a UIImage
let yolo = YOLO("/path/to/yolo26n.mlpackage", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

Das SDK führt Core-ML-Modelle über VNCoreMLRequest von Vision aus, das jedes Bild auf die Modelleingabe skaliert. Für Kamera-Apps ermöglicht YOLOView des SDKs Echtzeitinferenz mit nativen Einblendungen. Das Ultralytics-YOLO-Flutter-Plug-in führt dieselben Core-ML-Exporte unter iOS mit einer mit Android gemeinsam genutzten Codebasis aus. Ab iOS 16 fordert das SDK bei Core ML .cpuAndNeuralEngine statt .all an, da in einer Kamera-App die GPU bereits mit Vorschau und Einblendungen ausgelastet ist.

Leitfäden zur Bereitstellung#

Einschränkungen und Fehlerbehebung#

  • Erster Export nach einer einfachen Installation: Muss beim ersten Export numpy ersetzt werden (Versionen über 2.3.5 verhindern die Konvertierung), protokolliert Ultralytics Restart runtime or rerun command for updates to take effect, und der Export schlägt mit TypeError: only 0-dimensional arrays can be converted to Python scalars fehl. Führe den Export in einem neuen Prozess erneut aus – in einem Notebook bedeutet das einen Kernelneustart – oder installiere "ultralytics[export-coreml]" vor dem ersten Export wie im Schnellstart beschrieben.
  • Exportumgebung: Der Export läuft unter macOS und Linux x86-64. Windows und Linux ARM64, etwa auf einem Raspberry Pi, werden nicht unterstützt: coremltools 9.0 veröffentlicht vorgefertigte Pakete nur für macOS und Linux x86-64.
  • Python-Version: coremltools 9.0 bietet vorgefertigte Pakete für Python 3.13 und älter. Unter Python 3.14 installiert pip install "ultralytics[export-coreml]" keine Core-ML-Pakete, sodass der Export coremltools aus dem Quellcode erstellt. Wie nach einer einfachen Installation schlägt der erste Export dann fehl; der nächste Export mit RuntimeError: BlobWriter not loaded funktioniert. Richte die Umgebung mit Python 3.13 oder älter ein.
  • Für die Inferenz ist macOS erforderlich: Unter Linux schlägt die Vorhersage oder Validierung mit YOLO("yolo26n.mlpackage") mit Model prediction is only supported on macOS version 10.13 or later. fehl. Validiere dort den PyTorch-Checkpoint oder kopiere das Paket auf einen Mac.
  • Automatische Installation deaktiviert: Bei YOLO_AUTOINSTALL=false schlägt der Export in einer Umgebung ohne das Paket mit No module named 'coremltools' fehl.
  • Mit quantize=8 trainierte Checkpoints: Ein mit quantisierungsbewusstem Training feinabgestimmter Checkpoint lässt sich nicht mit format='coreml' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends exportieren. Exportiere stattdessen den Checkpoint, von dem aus du die Feinabstimmung begonnen hast, mit quantize=8, oder exportiere den feinabgestimmten Checkpoint nach ONNX oder TensorRT.
  • quantize="w8a32": schlägt mit quantize='w8a32' is not supported; format='coreml' supports quantize=16 (FP16), 8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 32 or None (FP32). fehl. Für Core ML ergibt 'w8a16' denselben Export wie 8, mit FP16-Berechnung.
  • Eingebettetes NMS bei anderen Aufgaben: nms=True funktioniert mit Erkennungs-, Segmentierungs- und Posenschätzungsmodellen. Bei OBB- und Klassifizierungsmodellen protokolliert der Export CoreML 'nms=True' is only supported for detect, segment and pose models. Forcing 'nms=None'., bei Modellen für semantische Segmentierung und Tiefenschätzung 'nms=True' is not valid for semantic models. Forcing 'nms=None'. (oder depth models) und bei RT-DETR-Modellen 'nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.. In allen Fällen wird die Ausgabe eines Standardexports geschrieben.
  • Genauigkeit bei eingebettetem NMS: Ein nms=True-Export ohne quantize verwendet FP16. quantize=32 erzeugt eine FP32-Pipeline für ein Erkennungsmodell; bei Segmentierungs- und Posenschätzungsmodellen protokolliert der Export CoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'. (oder pose models).
  • Eingebettetes NMS und Validierung: Ein nms=True-Export entfernt Boxen unterhalb von conf, bevor val sie verarbeitet. Daher erzielt er einen niedrigeren Wert als dasselbe Modell mit externem NMS: Auf COCO val2017 erreichte ein FP16-Export von YOLO26n mit nms=True beim standardmäßigen conf=0.25 einen Wert von 33,8 mAPval 50-95 und beim Export mit conf=0.001 einen Wert von 39,9 – weiterhin 1,0 unter den 40,9 eines standardmäßigen FP16-Exports. Exportiere mit conf=0.001, um ein solches Modell zu validieren, und wähle den Bereitstellungsschwellenwert separat.
  • NMS-freier Kopf bei anderen Modellen: nms=False erfordert ein Modell mit NMS-freiem Kopf, etwa YOLO26 oder YOLOv10. Bei anderen Modellen, zum Beispiel YOLO11, gibt der Export die Warnung This model has no one-to-one head; using one-to-many outputs. aus und schreibt die Rohausgabe (1, 84, 8400).
  • Batchgröße: Ein batch über 1 ohne dynamic=True schlägt mit batch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'. fehl.
  • Dynamische Formen: dynamic=True ohne batch protokolliert 'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'. und exportiert ein Modell mit maximaler Batchgröße 1. Mit nms=True schlägt der Export mit 'nms=True' cannot be used together with 'dynamic=True' for CoreML export. Please disable one of them. fehl; bei Klassifizierungs- und RT-DETR-Modellen schlägt er mit 'dynamic=True' is not supported for CoreML classification or RT-DETR models. fehl. Eine Bildgröße außerhalb des zulässigen Bereichs führt bei der Vorhersage zu einem Fehler wie Size (1312) of dimension (2) is not in allowed range (32..1280).
  • Semantische Segmentierung auf der Neural Engine: Auf einem Apple M4 dauerte die Ausführung eines YOLO26n-sem-Modells mit CPU_AND_NE länger als mit CPU_ONLY, allein mit coremltools und einem Testbild: 59 bis 64 ms gegenüber 22 ms beim FP16-Export mit imgsz=1024 sowie etwa 15 ms gegenüber 9 ms beim INT8-Export mit imgsz=640. Die FP16-Modelle der übrigen sechs Aufgaben und ihre INT8-Modelle mit imgsz=640 (224 für Klassifizierung) liefen mit CPU_AND_NE schneller. Auch auf dem iPhone 17 Pro war das INT8-Modell für semantische Segmentierung mit der Neural Engine schneller. YOLO() verwendet für diese Modelle immer CPU_AND_NE; miss daher ein semantisches Modell in deinem eigenen Code mit beiden Einstellungen.
  • .cpuOnly unter iOS 27.0.1: Auf einem iPhone 17 Pro stürzte die Inferenz von .cpuOnly bei den Tiefenschätzungs-, Posenschätzungs- und OBB-Modellen YOLO26l und YOLO26x in den CPU-Kernels von Core ML ab (EXC_BAD_ACCESS in libBNNS). Mit .cpuAndNeuralEngine, das vom iOS-SDK angefordert wird, laufen sie.
  • Paketname: Jeder Export desselben Checkpoints schreibt dasselbe yolo26n.mlpackage, unabhängig von quantize, imgsz, nms oder dynamic; der spätere Export ersetzt daher den früheren. Benenne das Paket um, wenn du beide behalten möchtest, und behalte die Endung .mlpackage, zum Beispiel yolo26n_fp16.mlpackage, da Ultralytics das Format daran erkennt. Ein Paket ohne diese Endung schlägt mit is not a supported model format fehl.
  • Warnung zur PyTorch-Version: Mit einer aktuellen PyTorch-Version protokolliert coremltools beim Laden Torch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors.; mit einer aktuellen Version von scikit-learn protokolliert es scikit-learn version 1.9.1 is not supported.. Die Exporte und Mac-Ergebnisse auf dieser Seite wurden mit diesen Versionen erstellt.
  • Ältere .mlmodel-Dateien: format="mlmodel" exportiert das frühere Core-ML-Neuronennetzformat als einzelne yolo26n.mlmodel-Datei für Apps, die kein ML-Programm laden können. Dafür ermöglichen quantize=8 und 'w8a16' eine lineare 8-Bit-Gewichtsquantisierung. Verwende für neue Projekte das Standard-.mlpackage.

Weitere Fehler findest du im Leitfaden zu häufigen Problemen.

Gemessene Leistung#

Die folgenden Tabellen wurden auf einem iPhone 17 Pro und einem Apple-M4-Mac gemessen. Auf der YOLO26-Modellseite findest du die Genauigkeit der PyTorch-Checkpoints für alle Aufgaben.

iPhone 17 Pro#

Hardware: iPhone 17 Pro mit iOS 26.6. Der A19 Pro verfügt über eine 6-Kern-CPU (2 Performance- und 4 Effizienzkerne), eine 6-Kern-GPU und eine 16-Kern-Neural Engine.

Die erste Tabelle zeigt die Latenz für ein einzelnes Bild mit dem offiziellen INT8-Modell für jede Aufgabe. Verwendet werden die v8.3.0-Modelle des Ultralytics iOS SDK, die mit nms=False exportiert wurden. Jede Zelle zeigt die Gesamtzeit in Millisekunden; darunter ist sie in Vorverarbeitung, Inferenz und Nachverarbeitung aufgeschlüsselt. Die schnellere Recheneinheit ist fett markiert:

ModellAufgabeGröße
(Pixel)
CPU
Core ML .cpuOnly
(ms)
CPU + Neural Engine
Core ML .cpuAndNeuralEngine
(ms)
YOLO26nDetect6409.7
0.0 / 9.7 / 0.0
4.7
0.0 / 4.7 / 0.0
YOLO26n-segSegment64012.8
0.0 / 12.2 / 0.6
5.8
0.0 / 5.0 / 0.7
YOLO26n-semSemantisch6409.3
0.0 / 8.9 / 0.5
5.3
0.0 / 4.8 / 0.5
YOLO26n-depthTiefe64025.8
0.0 / 24.8 / 1.0
8.0
0.0 / 6.9 / 1.1
YOLO26n-clsKlassifizieren2242.1
0.0 / 2.0 / 0.0
1.8
0.0 / 1.8 / 0.0
YOLO26n-posePose64011.9
0.0 / 11.9 / 0.0
5.4
0.0 / 5.4 / 0.0
YOLO26n-obbOBB64010.6
0.0 / 10.6 / 0.0
4.9
0.0 / 4.9 / 0.0

Dieselbe Messung für die fünf Erkennungsmodelle, einschließlich der Zeit, die das SDK zum Laden jedes Modells benötigt:

ModellCPU
.cpuOnly
(ms)
CPU + Neural Engine
.cpuAndNeuralEngine
(ms)
Modellladezeit
.cpuAndNeuralEngine
(s)
YOLO26n9.24.50.9
YOLO26s19.510.51.3
YOLO26m46.711.81.8
YOLO26l60.112.02.4
YOLO26x125.920.53.3

YOLO26n-Erkennung mit drei Genauigkeitsstufen und zwei nms-Einstellungen, exportiert mit ultralytics 8.4.215 unter imgsz=640; angegeben ist die Gesamtzeit in Millisekunden:

Precisionnms=None, CPUnms=None, CPU + Neural Enginenms=False, CPUnms=False, CPU + Neural Engine
FP3215.514.714.514.4
FP169.24.99.25.0
INT89.24.29.15.0
  • Methode: Mittelwert aus 15 Vorhersagen nach 3 Aufwärmvorhersagen auf bus.jpg, ausgeführt mit dem Swift SDK 8.9.23 in einem Release-Build. .cpuOnly und .cpuAndNeuralEngine sind die Core ML-Recheneinheiten, die das SDK anfordert. Core ML entscheidet, wo die einzelnen Schichten ausgeführt werden. Jede Tabelle wurde in drei separaten Durchläufen gemessen und zeigt den Median. Die Ergebnisse der drei Durchläufe stimmten bis auf 15 % überein, außer bei YOLO26n mit .cpuAndNeuralEngine: In der Größentabelle lag die Laufzeit zwischen 2.6 und 4.8 ms, beim INT8-Export nms=None zwischen 3.8 und 4.8 ms. Für die Aufgaben- und Größentabellen wurden die offiziellen v8.3.0-Modelle verwendet, für die Genauigkeitstabelle Exporte mit ultralytics 8.4.215. Daher unterscheiden sich die YOLO26n-Werte in den Tabellen um bis zu 0.5 ms mit der Neural Engine und 0.6 ms auf der CPU.
  • Vorverarbeitung: Vision skaliert das Bild innerhalb der Inferenzanfrage. Daher wird für die Vorverarbeitung 0 angegeben; ihr Aufwand ist in der Inferenz enthalten.
  • FP32: Gemäß diesen Medianwerten war der FP32-Export mit .cpuAndNeuralEngine höchstens 5 % schneller als mit .cpuOnly, während FP16 und INT8 etwa doppelt so schnell waren. Für die Neural Engine solltest du in FP16 oder INT8 exportieren.
  • nms: Bei der YOLO26n-Erkennung dauerten der NMS-freie Kopf (nms=False) und die Rohdaten mit NMS im SDK (nms=None) mit der Neural Engine in FP16 und INT8 jeweils 4 bis 5 ms.
  • Kamera-Apps: Dies sind Latenzwerte für ein einzelnes Bild. Eine Echtzeit-Kamera-App benötigt zusätzlich Zeit für Aufnahme und Anzeige. Weitere Informationen findest du in den Leistungshinweisen zum iOS SDK.
  • Vergleiche die Android-Ergebnisse für CPU und GPU in der LiteRT-Integration und die MediaTek-Dimensity-Ergebnisse mit den NPU-Ergebnissen von Snapdragon in der Qualcomm-QNN-Integration.

Apple M4#

Die folgenden Tabellen vergleichen PyTorch mit FP32-, FP16- und INT8-Core-ML-Modellen aller YOLO26-Erkennungsmodelle auf einem Apple M4 (4 Performance- und 6 Effizienzkerne) mit macOS 27.2. Die Validierung erfolgte mit YOLO() auf COCO val2017. PyTorch lief mit 8 Threads auf der CPU, batch=1 und rect=False, sodass dieselbe Eingabe mit 640x640 Pixeln wie bei den Core ML-Modellen verwendet wurde. Die Core ML-Modelle liefen mit den standardmäßigen Recheneinheiten von Ultralytics.

Millisekunden pro Bild; niedrigere Werte sind besser. Das schnellste Format für jedes Modell ist fett hervorgehoben.

ModellimgszPyTorchCore ML FP32Core ML FP16Core ML INT8
YOLO26n64025.621.06.06.0
YOLO26s64060.050.07.97.6
YOLO26m640137.2127.614.311.3
YOLO26l640191.2187.717.213.5
YOLO26x640341.1334.228.624.3

Mit dem NMS-freien Kopf (nms=False) erreichte YOLO26n in PyTorch und FP32 40.3 mAPval 50-95, in FP16 40.2 und in INT8 40.1.

Latenz von YOLO26n mit den einzelnen Core ML-Recheneinheiten, gemessen ausschließlich mit coremltools als Median aus 20 Vorhersagen für ein Bild, in Millisekunden:

PrecisionCPU_ONLYCPU_AND_NEALLCPU_AND_GPU
FP3213.713.68.38.0
FP169.61.82.07.7
INT89.41.81.88.1
  • FP16 und INT8 liefen mit YOLO() 3.5- bis 14-mal schneller als FP32. Die Genauigkeit lag bei FP16 höchstens 0.1 mAP und bei INT8 höchstens 0.2 mAP unter FP32. Bei YOLO26n war INT8 genauso schnell wie FP16; bei den größeren Modellen war INT8 bis zu 1.3-mal schneller.
  • FP32 lieferte mit CPU_AND_NE dieselben Ausgaben wie mit CPU_ONLY. Nur mit den GPU-Recheneinheiten war die Ausführung schneller.
  • INT8 verkleinerte das Paket im Vergleich zu FP32 um den Faktor 3.7 bis 4.0.

Gemessen mit ultralytics 8.4.215, coremltools 9.0 und PyTorch 2.15.0 unter batch=1 am 17. November 2026. Die Latenz entspricht der von val gemeldeten Inferenzphase und umfasst weder Vor- noch Nachverarbeitung. Ein zweiter Durchlauf der drei YOLO26n-Core-ML-Fälle am selben Tag wich um bis zu 2.3 ms ab: 21.0 gegenüber 18.8 ms bei FP32.

Über Core ML#

Core ML ist in iOS, iPadOS, macOS, watchOS, tvOS und visionOS integriert. Core ML lädt Modelle im ML-Program-Format, das .mlpackage bei diesem Export erzeugt, und führt jede Schicht auf der CPU, der GPU oder der Apple Neural Engine aus. Die Apple Neural Engine ist die NPU von Apple Silicon. Dadurch funktioniert die Inferenz offline und die Daten bleiben auf dem Gerät. Die vollständige Referenz findest du in der Core-ML-Dokumentation.

Apple Core ML deployment pipeline



Ansehen: So exportierst du Ultralytics YOLO26 mit INT8-Quantisierung nach CoreML | Bereitstellung auf Apple-Geräten | iOS/macOS 🍎

Häufig gestellte Fragen#

  • Beide Formate laufen auf der Neural Engine und rechnen mit FP16; entscheidend ist daher die Größe. FP16 (quantize=16) halbiert die Paketgröße: 5.1 MB statt 9.9 MB bei YOLO26n. INT8 (quantize=8) speichert 8-Bit-Gewichte, ist bei YOLO26n 2.7 MB groß und wird für die offiziellen Ultralytics-App-Modelle verwendet. Auf COCO val2017 erreichte ein standardmäßiger YOLO26n-Export auf einem Apple M4 mit FP16 40.9 mAPval 50-95 und mit INT8 40.8. Beide benötigten dort etwa gleich viel Zeit pro Bild. Auf einem iPhone 17 Pro dauerten beide mit der Neural Engine bei YOLO26n 4 bis 5 ms und lagen damit innerhalb der Schwankungen zwischen den Durchläufen. INT8 erfordert iOS 16 oder macOS 13; FP16 läuft auch unter iOS 15 und macOS 12. Für keines der Formate sind Kalibrierungsdaten erforderlich. Vermeide für den Einsatz den standardmäßigen FP32-Export: Er ist am größten und war in unseren Tests mit den Neural-Engine-Recheneinheiten höchstens 5 % schneller als allein auf der CPU. Weitere Informationen findest du unter Genauigkeit. Validiere das exportierte Modell mit deinen eigenen Daten und auf deinem eigenen Gerät, bevor du es bereitstellst.

  • Es hängt davon ab, wer die Ausgabe dekodiert. Exportiere YOLO26-Modelle mit dem Ultralytics iOS SDK oder dem Flutter-Plug-in mit nms=False, wie es auch für die offiziellen Modelle gilt: Das SDK liest dann die endgültigen Erkennungen des Kopfs ohne NMS aus und benötigt keinen NMS-Schritt. Auf COCO val2017 erreichte YOLO26n mit INT8 mit dem Kopf ohne NMS 40.1 mAPval 50-95 gegenüber 40.8 mit der Standardausgabe und externer NMS. Auf einem iPhone 17 Pro benötigten beide Varianten 4 bis 5 ms pro Bild. Mit Apples Vision-Framework und deinem eigenen Code wandelt nms=True ein Erkennungsmodell in eine Core-ML-Pipeline mit Apples NMS-Stufe um, deren Schwellenwerte du für jede Vorhersage ändern kannst. Vision gibt die Erkennungen als VNRecognizedObjectObservation-Objekte zurück; der Score einer Box entspricht dem confidence der Beobachtung. Bei einem nms=True-Erkennungsmodell melden SDK 8.9.23 und frühere Versionen statt der Box-Scores etwa 1.0, also die Konfidenz des obersten Labels jeder Box; spätere Versionen melden das confidence der Beobachtung. Die Standardeinstellung nms=None gibt Rohvorhersagen zurück und überlässt die NMS deinem Code. Unter Ausgabeformat findest du die Ausgaben der einzelnen Einstellungen.

  • Für den Export brauchst du keinen Mac: Der Export läuft unter x86-64 Linux, und die Ultralytics Platform kann Modelle in der Cloud exportieren. Zum Ausführen des Modells ist Apple-Hardware erforderlich, da Core ML Bestandteil der Betriebssysteme von Apple ist. Validiere unter Linux und Windows den PyTorch-Checkpoint oder einen ONNX-Export davon. Validiere anschließend das Core-ML-Modell selbst auf einem Mac, auf dem YOLO("yolo26n.mlpackage").val() ausgeführt wird, oder direkt auf dem Gerät.

Kommentare13

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

  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(bearbeitet)

      @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! 😊