CoreML-Export für YOLO26-Modelle#

Apple verbaut in jedem modernen iPhone, iPad und Mac eigens entwickelte KI-Chips — die Neural Engine — und CoreML ist der von Ultralytics unterstützte Weg, Modelle heute darauf bereitzustellen. Beim Export von Ultralytics YOLO26-Modellen nach CoreML wird ein trainierter .pt-Checkpoint in ein natives .mlpackage umgewandelt. Damit lassen sich alle sieben YOLO-Aufgaben mit geringer Latenz direkt auf dem Gerät ausführen, ohne Netzwerkverbindung und ohne dass Daten das Gerät verlassen.

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

Was ist CoreML?#

CoreML (von Apple als „Core ML“ geschrieben) ist Apples geräteinternes Machine-Learning-Framework. Es lädt Modelle im modernen Format ML Program – dem .mlpackage-Paket, das der Ultralytics-Exporter erstellt – und verteilt ihre Ausführung auf CPU, GPU und Apple Neural Engine (ANE), die dedizierte NPU in jedem Apple-Silicon-Chip. Da alles lokal ausgeführt wird, funktioniert die Inferenz offline, verursacht keine Netzwerklatenz und belässt Nutzerdaten auf dem Gerät.

CoreML ist direkt in Apples Vision-Framework integriert. Dieses verarbeitet die Bildskalierung und Ausrichtung, bevor die Bilder in das Modell gelangen. So übergibt das Ultralytics-iOS-SDK Kamerabilder an YOLO – praktisch ohne Vorverarbeitungsaufwand.

Warum YOLO26 nach CoreML exportieren?#

• Geschwindigkeit der Neural Engine: CoreML führt unterstützte Operationen auf Apples Neural Engine aus und ermöglicht so Inferenz mit geringer Latenz auf dem Gerät. Sieh dir die Tabelle mit den Messwerten auf physischen Geräten unten an und miss die Geschwindigkeit deines konkreten Exports auf der Zielhardware.
• Ausgabe auswählen: Bei Standardexporten überlässt du NMS deiner Anwendung. Verwende nms=True, um NMS einzubetten, oder nms=False für den NMS-freien Kopf von YOLO26.
• Privat und offline: Die gesamte Berechnung findet auf dem Gerät statt – keine Cloud-Aufrufe, keine API-Schlüssel, umfassender Datenschutz.
• Ein Export für das gesamte Ökosystem: Dasselbe .mlpackage läuft unter iOS, iPadOS, macOS, watchOS, tvOS und visionOS und bildet die Grundlage für das offizielle iOS-SDK und das offizielle Flutter-Plugin von Ultralytics.

Gemessene Leistung#

End-to-End-Inferenz für ein einzelnes Bild mit den standardisierten v8.3.0 YOLO26n-INT8-CoreML-Assets auf einem iPhone 17 Pro mit 12 GB Speicher und iOS 27.0.1. Der A19 Pro verfügt über eine 6-Core-CPU (2 Performance- und 4 Effizienzkerne), eine 6-Core-GPU mit Neural Accelerators und eine 16-Core Neural Engine. Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachverarbeitung, ohne Annotation) und darunter die Aufteilung nach Phasen. Unter iOS skaliert Vision die Eingabe innerhalb der Inferenzanfrage, daher wird die Vorverarbeitung mit 0 angegeben und ihre Dauer der Inferenz zugerechnet.

• Die exakten v8.3.0-Release-Assets geben Eingabegrößen von 224×224 für die Klassifizierung und 640×640 für alle anderen Aufgaben an.
• Unter iOS 27.0.1 stürzt die .cpuOnly-Inferenz der Tiefen-, Pose- und OBB-Modelle l und x innerhalb der CPU-Kernels von Core ML ab (EXC_BAD_ACCESS in libBNNS); dieselben Modelle laufen mit .cpuAndNeuralEngine, und alle anderen Aufgaben und Größen laufen auf der CPU.
• Geschwindigkeitswerte sind Latenzen bei Einzelbild-Bursts – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmdurchläufen auf bus.jpg. Gemessen wurden sie anhand der Zeitangaben pro Phase des iOS-SDKs über die Benchmark-Testumgebung des Flutter-Plugins im Profilmodus (optimierter nativer Code). Die Reihenfolge von CPU und Beschleuniger wechselte bei den Aufgaben innerhalb eines sequenziellen Durchlaufs. Bei CPU-Zeilen wird Core ML .cpuOnly angefordert, bei Zeilen mit bevorzugter CPU- und ANE-Ausführung .cpuAndNeuralEngine; die endgültige Zuweisung der Operationen übernimmt Core ML. Bei dauerhaftem Echtzeit-Kamerabetrieb fallen die Werte höher aus, da die Aufnahme- und Skalierungspipeline sowie die thermische Stabilisierung hinzukommen. Bei einer historischen Kameramessung vor der Standardisierung wurden auf demselben Gerät 11.3 ms/Bild für YOLO26n detect und 16.5 ms/Bild für YOLO26n Depth gemessen – weitere Informationen zur Profilierung im Dauerbetrieb findest du in der Leistungsdokumentation des iOS-SDKs.
• Vergleiche die CPU-/GPU-Ergebnisse für Android in der LiteRT-Integration und die NPU-Ergebnisse für Snapdragon in der Qualcomm-QNN-Integration.

Unterstützte Aufgaben#

Der CoreML-Export unterstützt alle sieben Aufgaben von Ultralytics. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar – der einzigen Modellfamilie, die diese Ausgabeköpfe mitbringt.

YOLO26-Modelle nach CoreML exportieren#

Installation#

Führe zum Installieren des erforderlichen Pakets Folgendes aus:

# Install the required package for YOLO26
pip install ultralytics

Der coremltools-Konverter wird beim ersten Export automatisch installiert. Der Export läuft unter macOS oder Linux auf x86. Detaillierte Anweisungen und bewährte Vorgehensweisen findest du in unserem Installationsleitfaden und im Leitfaden zu häufigen Problemen.

Verwendung#

Das CoreML-Format unterstützt die Modi Export, Vorhersage und Validierung. Inferenz und Validierung mit CoreML sind nur unter macOS möglich. Exportiere dein Modell und lade anschließend das exportierte Modell, um Inferenz auszuführen oder die Genauigkeit zu validieren.

from ultralytics import YOLO

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

# Mit INT8-Gewichtquantisierung nach CoreML exportieren, passend zu den offiziellen App-Modellen
model.export(format="coreml", quantize=8, imgsz=640)  # für die Klassifizierung imgsz=224 verwenden

from ultralytics import YOLO

# Das exportierte CoreML-Modell laden (macOS)
model = YOLO("yolo26n.mlpackage")

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

from ultralytics import YOLO

# Das exportierte CoreML-Modell laden (macOS)
model = YOLO("yolo26n.mlpackage")

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

Exportargumente#

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Die Neural Engine als Ziel auswählen#

CoreML wählt die Hardware über MLModelConfiguration.computeUnits aus. Das Ultralytics-iOS-SDK verwendet unter iOS 16 und höher standardmäßig .cpuAndNeuralEngine statt .all: In einer Echtzeit-Kamera-App ist die GPU bereits mit der Darstellung der Vorschau und der Overlays beschäftigt. Wenn sie ausgeschlossen wird, lassen sich Ressourcenkonflikte und Schwankungen der Bilddauer vermeiden, während die ANE die rechenintensiven Aufgaben übernimmt. Lege .cpuOnly nur für Kompatibilitätstests fest – die Tabelle oben zeigt die Leistungseinbußen.

Die Ausführung eines CoreML-Modells mit Python auf einem Mac-Host (über Ultralytics oder coremltools) folgt derselben Regel: Ultralytics lädt das Modell mit ComputeUnit.CPU_AND_NE (macOS 13+, bei älteren macOS-Versionen wird auf CPU_ONLY zurückgegriffen), sodass die Inferenz auf der Neural Engine bleibt (~3× schneller als auf der CPU). So wird außerdem eine aktuelle Einschränkung von macOS-Hosts umgangen: Die standardmäßigen Optionen ComputeUnit.ALL / CPU_AND_GPU – die den GPU-/MPSGraph-Kompilierungspfad hinzufügen – brechen den Prozess ab, und zwar mit einer Error: MLIR pass manager failed-Assertion unter coremltools 9.x. RT-DETR-Modelle sind die Ausnahme: Sie werden mit ComputeUnit.ALL geladen, da ihre FP16-Genauigkeit allein auf der Neural Engine abnimmt.

Exportierte YOLO26-CoreML-Modelle bereitstellen#

Am schnellsten geht es mit dem offiziellen Ultralytics-YOLO-iOS-SDK, demselben Swift-Paket, das die Ultralytics-iOS-App und das Flutter-Plugin verwenden. Es erkennt offizielle Modellnamen automatisch, lädt das .mlpackage herunter, speichert es im Cache und gibt vollständig dekodierte Ergebnisse zurück:

import UltralyticsYOLO

// Loads the official INT8 model (downloaded and cached on first use), then runs inference
let yolo = YOLO("yolo26n", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

Für Kamera-Apps kannst du YOLOView des SDKs für Echtzeitinferenz mit nativen Overlays einbinden oder das Flutter-Plugin für plattformübergreifende Apps verwenden, die sich eine Codebasis mit Android teilen.

Auch die direkte Integration eines nicht weiter verarbeiteten .mlpackage ist mit Apples Technologie-Stack unkompliziert: Lade es mit MLModel, binde es in ein VNCoreMLRequest ein und übergib Bilder über VNImageRequestHandler. Weitere Informationen findest du in diesen Ressourcen:

• Ein Core-ML-Modell in deine App integrieren: Apples Anleitung zum Einbinden und Aufrufen eines CoreML-Modells.
• CoreML Tools: Referenz zu Konvertierung, Quantisierung und Optimierung für die Toolchain coremltools, die diesem Export zugrunde liegt.
• Core-ML-Leistungsberichte in Xcode: Profilierung der Gerätezuweisung und Latenz pro Ebene für dein konkretes Modell und Gerät.

Binde das Modell entweder direkt in das App-Paket ein (sofort verfügbar, ideal für Nano-/Small-Modelle) oder lade es beim ersten Start herunter und speichere es im Cache (kleinere Binärdatei, einfache Modellaktualisierungen). Die offiziellen Apps kombinieren beide Ansätze: Standardmäßige Nano-Modelle sind sofort einsatzbereit in der App enthalten, während größere Varianten bei Bedarf heruntergeladen und lokal zwischengespeichert werden.

Empfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Train-Modus von Ultralytics oder verwende die offiziellen YOLO26-Gewichte als Ausgangspunkt.
2. Exportiere mit model.export(format="coreml", quantize=8, imgsz=640) unter macOS oder Linux auf x86 (imgsz=224 für die Klassifizierung)
3. Überprüfe die Genauigkeit mit model.val() auf einem Mac und erstelle mit einem Core-ML-Leistungsbericht in Xcode ein Profil auf deinem Zielgerät
4. Stelle das Modell mit dem iOS-SDK, dem Flutter-Plugin oder deiner eigenen Vision-Integration für .cpuAndNeuralEngine bereit

Zusammenfassung#

In dieser Anleitung hast du gelernt, Ultralytics-YOLO26-Modelle in das .mlpackage-Format von CoreML zu exportieren, sie für die Apple Neural Engine zu quantisieren und mit Latenzen im einstelligen Millisekundenbereich einzusetzen – entweder über das offizielle iOS SDK und das Flutter-Plugin oder deine eigene Vision-Integration.

Häufig gestellte Fragen#