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.
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#
| Eigenschaft | Details |
|---|---|
Argument format | coreml (Aliase: mlpackage, mlprogram, apple, ios). mlmodel exportiert das frühere Neuronennetzformat |
| Ausgabe | yolo26n.mlpackage, ein Modellpaket (ein Verzeichnis) im ML-Program-Format, in dem Klassennamen, Aufgabe und Bildgröße als Metadaten gespeichert sind |
| Ausführbar auf | iPhone, iPad, Mac, Apple Watch, Apple TV und Apple Vision Pro, auf CPU, GPU und Apple Neural Engine |
| Laufzeitumgebung | Core 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 |
| Precision | FP32, FP16, INT8 (8-Bit-Gewichte). YOLO26n ist 9,9 MB groß in FP32, 5,1 MB in FP16 und 2,7 MB in INT8 |
| Exportrechner | macOS oder Linux x86-64 mit Python 3.13 oder älter. Nicht Windows. Für den Export ist keine GPU erforderlich |
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:
| Paket | Erforderliche Version |
|---|---|
| Python | 3.13 oder älter, die neueste Version, für die coremltools 9.0 vorgefertigte Pakete bereitstellt |
coremltools | 9.0 oder neuer |
numpy | 2.3.5 oder älter. Beim Export wird Version 2.3.5 über eine neuere Version installiert |
torch | 1.11 oder neuer |
scikit-learn | Nur 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.
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:
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")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#
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
format | str | 'coreml' | Zielformat des exportierten Modells, das die Kompatibilität mit verschiedenen Bereitstellungsumgebungen festlegt. |
imgsz | int oder tuple | 640 | Bildgröß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. |
quantize | int oder str | None | Genauigkeit: 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. |
nms | bool, optional | None | Wä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. |
conf | float | None | Konfidenzschwelle, die in einem nms=True-Export gespeichert wird. Wenn nicht angegeben, wird 0.25 verwendet. |
iou | float | 0.5 | IoU-Schwelle, die in einem nms=True-Export gespeichert wird. |
agnostic_nms | bool | False | Klassenunabhä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_det | int | 300 | Anzahl 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. |
dynamic | bool | False | Macht 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. |
batch | int | 1 | Maximale Batchgröße eines dynamic=True-Exports. Ein Standardexport hat die Batchgröße 1; andere Werte führen zu einem Fehler. |
device | str | None | Gerä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.
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:
quantize | Gewichte | Berechnung | Mindestversion des Betriebssystems | Größe von YOLO26n |
|---|---|---|---|---|
nicht angegeben oder 32 | FP32 | FP32 | iOS 15, macOS 12 | 9.9 MB |
16 | FP16 | FP16 | iOS 15, macOS 12 | 5.1 MB |
8 oder 'w8a16' | 8 Bit | FP16 | iOS 16, macOS 13 | 2.7 MB |
- FP32: Standard, wenn
nms=Truenicht festgelegt ist. Auf einem Apple M4 lieferten die FP32-Exporte aller sieben Aufgaben mit den RecheneinheitenCPU_AND_NE, die Ultralytics verwendet, dieselben Ausgaben wie mitCPU_ONLYund 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=16speichert die Gewichte und rechnet mit halber Genauigkeit. Die Bildeingabe und die Ausgabearrays behalten die Datentypen des FP32-Exports (float32oder bei semantischer Segmentierungint32), sodass für das FP32-Modell geschriebener Inferenzcode unverändert funktioniert. - INT8:
quantize=8undquantize="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, diequantize=8bei anderen Formaten auswählt; daher ist kein Argumentdataerforderlich. Bei bereits installiertemscikit-learndauerte 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.json | Die Liste der Dateien im Paket |
Data/com.apple.CoreML/model.mlmodel | Der 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.bin | Die 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:
| Aufgabe | Standardmäßiges imgsz | Ausgabe mit nms=None | Ausgabe mit nms=False | Ausgabe mit nms=True |
|---|---|---|---|---|
| Detect | 640 | (1, 84, 8400) | (1, 300, 6) | confidence (boxes, 80) und coordinates (boxes, 4) |
| Segment | 640 | (1, 116, 8400) und (1, 32, 160, 160) | (1, 300, 38) und (1, 32, 160, 160) | (1, 300, 38) und (1, 32, 160, 160) |
| Semantisch | 1024 | (1, 1024, 1024), Klassenindex für jedes Pixel | Wie nms=None | Wie nms=None |
| Tiefe | 768 | (1, 1, 768, 768), Tiefenkarte | Wie nms=None | Wie nms=None |
| Klassifizieren | 224 | classLabel und classLabel_probs | Wie nms=None | Wie nms=None |
| Pose | 640 | (1, 56, 8400) | (1, 300, 57): 6 Boxwerte, dann 17 Keypoints mit je 3 Werten | (1, 300, 57) |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 Boxwerte, Score, Klasse, Winkel | Wie 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 mitx1, y1, x2, y2, score, classin Eingabepixeln, ohne NMS-Schritt. OBB-Zeilen haben die Formcenter 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 gibtconfidencezurück, eine Zeile mit Klassenwerten für jede beibehaltene Box, sowiecoordinates, 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äßig0.25),iou(standardmäßig0.5) undagnostic_nmswerden beim Export in der Pipeline gespeichert. Die EingabenconfidenceThresholdundiouThresholdkönnen weggelassen werden und ersetzen für eine einzelne Vorhersage die beiden Schwellenwerte.max_dethat keine Wirkung: Ein Export mitmax_det=2gab für ein Testbild trotzdem fünf Boxen zurück. Bei Modellen, deren Klassenzahl kein Vielfaches von 80 ist, ergänzt der Exportconfidenceum 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 gibtmax_detZeilen mitx1, y1, x2, y2, score, classzurü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_nmsundmax_detwerden 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, undclassLabel_probs, ein Wörterbuch mit Klassennamen und Wahrscheinlichkeiten, zurückgibt.coremltoolsgibt 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 wirdALLverwendet. Lässt sich das Modell damit nicht laden, wird es mitCPU_ONLYgeladen. Es gibt kein Argument zur Auswahl anderer Recheneinheiten; lade das Paket dazu mitcoremltools. Auf einem Apple M4 mit macOS 27.2 liefen außerdem die FP32-, FP16- und INT8-Modelle aller sieben YOLO26n-Aufgaben mitALLundCPU_AND_GPU; andere macOS-Versionen wurden nicht getestet. device: Das Argumentdevicewählt nicht die Core-ML-Hardware aus. Mitdevice="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 mitdevice="mps"etwa 8 ms pro Bild und ohne diese Option etwa 6 ms. Lassdevicedaher weg.- Genauigkeit und Neural Engine: Auf einem Apple M4 dauerte die Inferenzphase von
YOLO()bei einem FP32-YOLO26n-Modell inpredict18 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 mitcoremltoolsbrauchten dieselben FP16- und INT8-Modelle mitCPU_AND_NEetwa 2 ms gegenüber 9 bis 10 ms mitCPU_ONLY. - Feste Eingabeform: Ein Standardexport läuft immer mit der Export-
imgsz, die Ultralytics aus den Modellmetadaten ausliest. Ein anpredictodervalübergebenesimgszwird ignoriert. Ultralytics übergibt jedes Bild eines Batches als separate Einzelbildanfrage an Core ML, sodass beliebig viele Bilder verarbeitet werden können;vallegtbatch=1fest. - Dynamischer Export (
dynamic=True): Das Modell unterstützt Batchgrößen von 1 bis zur Export-batchund 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-batchauf. Beim NMS-freien Ausgabekopf ist die Mindestgröße größer: 128 Pixel für ein YOLO26n-Modell, das mitimgsz=640undnms=Falseexportiert 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=640Fü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#
- Ein Core-ML-Modell in deine App integrieren: Apples Anleitung zum Hinzufügen eines Modells zu einem Xcode-Projekt und dessen Aufruf.
- Objekte in einer Live-Aufnahme erkennen: Apples Beispiel zum Ausführen eines Core-ML-Detektors auf Kamerabildern mit Vision und
VNCoreMLRequest. - MLComputeUnits: die Einstellung
computeUnitsvonMLModelConfiguration, mit der CPU, GPU und Neural Engine ausgewählt werden. - Core-ML-Nutzung optimieren: Apples Session zu Xcode-Leistungsberichten, die für jede Schicht auf einem Gerät die Recheneinheit und Latenz anzeigen.
- Core-ML-Tools-Anleitung: die Referenz zur Konvertierung und Optimierung des Pakets
coremltools, das dieser Export verwendet. - Ultralytics Platform: Öffne einen Core-ML-Export in der Ultralytics-YOLO-App auf einem iPhone, indem du einen QR-Code scannst.
- Core AI, LiteRT und Qualcomm QNN: Apples Format für iOS 27 sowie Formate für Android-Geräte und Snapdragon-NPUs.
Einschränkungen und Fehlerbehebung#
- Erster Export nach einer einfachen Installation: Muss beim ersten Export
numpyersetzt werden (Versionen über 2.3.5 verhindern die Konvertierung), protokolliert UltralyticsRestart runtime or rerun command for updates to take effect, und der Export schlägt mitTypeError: only 0-dimensional arrays can be converted to Python scalarsfehl. 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:
coremltools9.0 veröffentlicht vorgefertigte Pakete nur für macOS und Linux x86-64. - Python-Version:
coremltools9.0 bietet vorgefertigte Pakete für Python 3.13 und älter. Unter Python 3.14 installiertpip install "ultralytics[export-coreml]"keine Core-ML-Pakete, sodass der Exportcoremltoolsaus dem Quellcode erstellt. Wie nach einer einfachen Installation schlägt der erste Export dann fehl; der nächste Export mitRuntimeError: BlobWriter not loadedfunktioniert. 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")mitModel 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=falseschlägt der Export in einer Umgebung ohne das Paket mitNo module named 'coremltools'fehl. - Mit
quantize=8trainierte Checkpoints: Ein mit quantisierungsbewusstem Training feinabgestimmter Checkpoint lässt sich nicht mitformat='coreml' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backendsexportieren. Exportiere stattdessen den Checkpoint, von dem aus du die Feinabstimmung begonnen hast, mitquantize=8, oder exportiere den feinabgestimmten Checkpoint nach ONNX oder TensorRT. quantize="w8a32": schlägt mitquantize='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 wie8, mit FP16-Berechnung.- Eingebettetes NMS bei anderen Aufgaben:
nms=Truefunktioniert mit Erkennungs-, Segmentierungs- und Posenschätzungsmodellen. Bei OBB- und Klassifizierungsmodellen protokolliert der ExportCoreML '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'.(oderdepth 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 ohnequantizeverwendet FP16.quantize=32erzeugt eine FP32-Pipeline für ein Erkennungsmodell; bei Segmentierungs- und Posenschätzungsmodellen protokolliert der ExportCoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'.(oderpose models). - Eingebettetes NMS und Validierung: Ein
nms=True-Export entfernt Boxen unterhalb vonconf, bevorvalsie verarbeitet. Daher erzielt er einen niedrigeren Wert als dasselbe Modell mit externem NMS: Auf COCO val2017 erreichte ein FP16-Export von YOLO26n mitnms=Truebeim standardmäßigenconf=0.25einen Wert von 33,8 mAPval 50-95 und beim Export mitconf=0.001einen Wert von 39,9 – weiterhin 1,0 unter den 40,9 eines standardmäßigen FP16-Exports. Exportiere mitconf=0.001, um ein solches Modell zu validieren, und wähle den Bereitstellungsschwellenwert separat. - NMS-freier Kopf bei anderen Modellen:
nms=Falseerfordert ein Modell mit NMS-freiem Kopf, etwa YOLO26 oder YOLOv10. Bei anderen Modellen, zum Beispiel YOLO11, gibt der Export die WarnungThis 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 ohnedynamic=Trueschlägt mitbatch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'.fehl. - Dynamische Formen:
dynamic=Trueohnebatchprotokolliert'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.und exportiert ein Modell mit maximaler Batchgröße 1. Mitnms=Trueschlä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 wieSize (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_NElänger als mitCPU_ONLY, allein mitcoremltoolsund einem Testbild: 59 bis 64 ms gegenüber 22 ms beim FP16-Export mitimgsz=1024sowie etwa 15 ms gegenüber 9 ms beim INT8-Export mitimgsz=640. Die FP16-Modelle der übrigen sechs Aufgaben und ihre INT8-Modelle mitimgsz=640(224 für Klassifizierung) liefen mitCPU_AND_NEschneller. 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 immerCPU_AND_NE; miss daher ein semantisches Modell in deinem eigenen Code mit beiden Einstellungen. .cpuOnlyunter iOS 27.0.1: Auf einem iPhone 17 Pro stürzte die Inferenz von.cpuOnlybei den Tiefenschätzungs-, Posenschätzungs- und OBB-Modellen YOLO26l und YOLO26x in den CPU-Kernels von Core ML ab (EXC_BAD_ACCESSinlibBNNS). Mit.cpuAndNeuralEngine, das vom iOS-SDK angefordert wird, laufen sie.- Paketname: Jeder Export desselben Checkpoints schreibt dasselbe
yolo26n.mlpackage, unabhängig vonquantize,imgsz,nmsoderdynamic; 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 Beispielyolo26n_fp16.mlpackage, da Ultralytics das Format daran erkennt. Ein Paket ohne diese Endung schlägt mitis not a supported model formatfehl. - Warnung zur PyTorch-Version: Mit einer aktuellen PyTorch-Version protokolliert
coremltoolsbeim LadenTorch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors.; mit einer aktuellen Version vonscikit-learnprotokolliert esscikit-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 einzelneyolo26n.mlmodel-Datei für Apps, die kein ML-Programm laden können. Dafür ermöglichenquantize=8und'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:
| Modell | Aufgabe | Größe (Pixel) | CPU Core ML .cpuOnly(ms) | CPU + Neural Engine Core ML .cpuAndNeuralEngine(ms) |
|---|---|---|---|---|
| YOLO26n | Detect | 640 | 9.7 0.0 / 9.7 / 0.0 | 4.7 0.0 / 4.7 / 0.0 |
| YOLO26n-seg | Segment | 640 | 12.8 0.0 / 12.2 / 0.6 | 5.8 0.0 / 5.0 / 0.7 |
| YOLO26n-sem | Semantisch | 640 | 9.3 0.0 / 8.9 / 0.5 | 5.3 0.0 / 4.8 / 0.5 |
| YOLO26n-depth | Tiefe | 640 | 25.8 0.0 / 24.8 / 1.0 | 8.0 0.0 / 6.9 / 1.1 |
| YOLO26n-cls | Klassifizieren | 224 | 2.1 0.0 / 2.0 / 0.0 | 1.8 0.0 / 1.8 / 0.0 |
| YOLO26n-pose | Pose | 640 | 11.9 0.0 / 11.9 / 0.0 | 5.4 0.0 / 5.4 / 0.0 |
| YOLO26n-obb | OBB | 640 | 10.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:
| Modell | CPU.cpuOnly(ms) | CPU + Neural Engine.cpuAndNeuralEngine(ms) | Modellladezeit.cpuAndNeuralEngine(s) |
|---|---|---|---|
| YOLO26n | 9.2 | 4.5 | 0.9 |
| YOLO26s | 19.5 | 10.5 | 1.3 |
| YOLO26m | 46.7 | 11.8 | 1.8 |
| YOLO26l | 60.1 | 12.0 | 2.4 |
| YOLO26x | 125.9 | 20.5 | 3.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:
| Precision | nms=None, CPU | nms=None, CPU + Neural Engine | nms=False, CPU | nms=False, CPU + Neural Engine |
|---|---|---|---|---|
| FP32 | 15.5 | 14.7 | 14.5 | 14.4 |
| FP16 | 9.2 | 4.9 | 9.2 | 5.0 |
| INT8 | 9.2 | 4.2 | 9.1 | 5.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..cpuOnlyund.cpuAndNeuralEnginesind 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-Exportnms=Nonezwischen 3.8 und 4.8 ms. Für die Aufgaben- und Größentabellen wurden die offiziellenv8.3.0-Modelle verwendet, für die Genauigkeitstabelle Exporte mitultralytics8.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
.cpuAndNeuralEnginehö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.
| Modell | imgsz | PyTorch | Core ML FP32 | Core ML FP16 | Core ML INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 25.6 | 21.0 | 6.0 | 6.0 |
| YOLO26s | 640 | 60.0 | 50.0 | 7.9 | 7.6 |
| YOLO26m | 640 | 137.2 | 127.6 | 14.3 | 11.3 |
| YOLO26l | 640 | 191.2 | 187.7 | 17.2 | 13.5 |
| YOLO26x | 640 | 341.1 | 334.2 | 28.6 | 24.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:
| Precision | CPU_ONLY | CPU_AND_NE | ALL | CPU_AND_GPU |
|---|---|---|---|---|
| FP32 | 13.7 | 13.6 | 8.3 | 8.0 |
| FP16 | 9.6 | 1.8 | 2.0 | 7.7 |
| INT8 | 9.4 | 1.8 | 1.8 | 8.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_NEdieselben Ausgaben wie mitCPU_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.
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 wandeltnms=Trueein Erkennungsmodell in eine Core-ML-Pipeline mit Apples NMS-Stufe um, deren Schwellenwerte du für jede Vorhersage ändern kannst. Vision gibt die Erkennungen alsVNRecognizedObjectObservation-Objekte zurück; der Score einer Box entspricht demconfidenceder Beobachtung. Bei einemnms=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 dasconfidenceder Beobachtung. Die Standardeinstellungnms=Nonegibt 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.
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(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
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! 😊
