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.

Was ist CoreML?#

CoreML (von Apple als „Core ML“ geschrieben) ist Apples Framework für maschinelles Lernen auf dem Gerät. 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) des Geräts, die dedizierte NPU in jedem Apple-Silicon-Chip. Da alles lokal läuft, funktioniert die Inferenz offline, verursacht keine Netzwerklatenz und lä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 übernimmt deine App NMS. 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#

Ende-zu-Ende-Inferenz eines einzelnen Bildes mit den standardisierten v8.3.0-YOLO26n-INT8-CoreML-Assets auf einem iPhone 17 Pro mit 12 GB Arbeitsspeicher und iOS 26.5.2. Das A19 Pro verfügt über eine 6-Kern-CPU (2 Leistungskerne und 4 Effizienzkerne), eine 6-Kern-GPU mit Neural Accelerators und eine 16-Kern-Neural Engine. Jede Zelle zeigt die Gesamtdauer (Vorverarbeitung + Inferenz + Nachverarbeitung, ohne Annotation) mit der Aufschlüsselung der einzelnen Phasen darunter. Unter iOS übernimmt Vision die Skalierung der 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.
• 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.

Auch bei der Ausführung eines CoreML-Modells mit Python auf einem Mac-Host (über Ultralytics oder coremltools) gilt dieselbe Regel: Ultralytics lädt das Modell mit ComputeUnit.CPU_AND_NE (macOS 13 und neuer, bei älteren macOS-Versionen mit Rückgriff auf CPU_ONLY) und führt die Inferenz dadurch auf der Neural Engine aus (~3× schneller als auf der CPU). So wird auch eine aktuelle Einschränkung von macOS-Hosts umgangen: Die standardmäßige Kombination aus ComputeUnit.ALL und CPU_AND_GPU – die den Kompilierungspfad für GPU/MPSGraph hinzufügt – bricht den Prozess mit einer Error: MLIR pass manager failed-Assertion unter coremltools 9.x ab.

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, wie du Ultralytics-YOLO26-Modelle in das CoreML-Format .mlpackage exportierst, für die Apple Neural Engine quantisierst und mit Latenzen im einstelligen Millisekundenbereich bereitstellst – entweder über das offizielle iOS-SDK und Flutter-Plugin oder über deine eigene Vision-Integration. Weitere Bereitstellungsziele findest du auf der Seite mit Integrationsleitfäden; Formate kannst du mit dem Benchmark-Modus vergleichen.

Häufig gestellte Fragen#