Link to this sectionCoreML-Export für YOLO26-Modelle#

Apple verbaut in jedem modernen iPhone, iPad und Mac dedizierte KI-Hardware – die Neural Engine – und CoreML ist der von Ultralytics unterstützte Weg, um Modelle heute darauf bereitzustellen. Der Export von Ultralytics YOLO26 Modellen nach CoreML wandelt einen trainierten .pt Checkpoint in ein natives .mlpackage um, das alle sieben YOLO-Aufgaben direkt auf dem Gerät mit niedriger Latenz ausführt, ohne Netzwerkverbindung und ohne dass Daten das Gerät verlassen.

Link to this sectionWas ist CoreML?#

CoreML (von Apple als „Core ML“ bezeichnet) ist Apples Framework für maschinelles Lernen direkt auf dem Gerät. Es lädt Modelle im modernen ML Program-Format – dem .mlpackage-Paket, das der Ultralytics-Exporter erstellt – und plant deren Ausführung auf der CPU, GPU und der Apple Neural Engine (ANE), der dedizierten NPU in jedem Apple-Silicon-Chip. Da alles lokal ausgeführt wird, funktioniert die Inferenz offline, verursacht keine Netzwerklatenz und hält Benutzerdaten auf dem Gerät.

CoreML lässt sich direkt in Apples Vision-Framework integrieren, das die Bildskalierung und -ausrichtung vor der Modellverarbeitung übernimmt – genau so speist das Ultralytics iOS SDK Kamerabilder mit praktisch null Vorverarbeitungsaufwand in YOLO ein.

Link to this sectionWarum YOLO26 nach CoreML exportieren?#

• Neural Engine-Geschwindigkeit: Die YOLO26n-Detektion läuft auf einem iPhone 17 Pro in 3,8 ms von Ende zu Ende für Einzelbilder und in 11,3 ms/Frame bei kontinuierlicher Echtzeit-Kameranutzung; YOLO26n Depth benötigt 5,5 ms für ein Einzelbild und 16,5 ms/Frame bei der Live-Kamera (siehe Tabelle und Hinweise unten).
• Von Haus aus NMS-frei: YOLO26 ist end-to-end, daher benötigt der exportierte Graph keine NMS-Pipeline und die Dekodierung erfolgt in unter einer Millisekunde. Ältere Detektionsmodelle wie YOLO11 können eine CoreML NMS-Pipeline mit nms=True einbetten.
• Privat und offline: Alle Berechnungen verbleiben auf dem Gerät – keine Roundtrips zur Cloud, keine API-Schlüssel, vollständige Datenschutz.
• Ein Export, das gesamte Ökosystem: Dasselbe .mlpackage läuft auf iOS, iPadOS, macOS, watchOS, tvOS und visionOS und treibt das offizielle Ultralytics iOS SDK sowie das Flutter-Plugin an.

Link to this sectionGemessene Leistung#

Ende-zu-Ende Einzelbild-Inferenz für die offiziellen YOLO26n INT8 CoreML-Modelle auf einem iPhone 17 Pro (Apple A19, iOS 26.5.2). Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachverarbeitung, exklusive Annotation) mit der Aufschlüsselung der einzelnen Phasen darunter. Unter iOS führt Vision die Eingabeskalierung innerhalb der Inferenzanfrage durch, daher wird die Vorverarbeitung als 0 angegeben und deren Kosten sind in der Inferenz enthalten.

• ¹ Semantische CoreML-Exporte betten den ArgMax in den Graphen ein und geben eine kompakte Klassen-Map mit voller Auflösung ([1, 1024, 1024]) anstelle von Float-Logits zurück, sodass die Nachbearbeitung ein Farbdurchlauf von unter einer Millisekunde ist und Masken pixelgenau gerendert werden.
• Geschwindigkeitswerte sind Burst-Latenzen für Einzelbilder – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmläufen auf bus.jpg, gemessen über das phasenbasierte Timing des iOS SDK mittels der Benchmark-Umgebung des Flutter plugin im Profil-Modus (optimierter nativer Code). Der kontinuierliche Echtzeit-Kamerabetrieb läuft langsamer, da er die Aufnahme- und Skalierungspipeline sowie thermische Anpassungen umfasst: YOLO26n detect misst 11,3 ms/Frame und YOLO26n Depth 16,5 ms/Frame in der Live-Kamera-App auf demselben Gerät – siehe die iOS SDK performance doc für Profiling im stationären Zustand.
• Die entsprechende Tabelle für Snapdragon CPU/GPU/NPU findest du in der Qualcomm QNN-Integration.

Link to this sectionExportieren von YOLO26-Modellen nach CoreML#

Link to this sectionInstallation#

Um das erforderliche Paket zu installieren, führe Folgendes aus:

# Install the required package for YOLO26
pip install ultralytics

Der coremltools-Konverter wird beim ersten Export automatisch installiert. Der Export läuft auf macOS oder x86-Linux; detaillierte Anweisungen und Best Practices findest du in unserer Installationsanleitung sowie im Leitfaden zu häufigen Problemen.

Link to this sectionVerwendung#

Das CoreML-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung mit CoreML funktionieren nur auf macOS. Exportiere dein Modell und lade es dann, um Inferenz auszuführen oder die Genauigkeit zu validieren.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export to CoreML with INT8 weight quantization, matching the official app models
model.export(format="coreml", quantize=8)  # creates 'yolo26n.mlpackage'

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionExport-Argumente#

Weitere Details zum Exportprozess findest du auf der Ultralytics-Dokumentationsseite zum Exportieren.

Link to this sectionAusrichtung auf die Neural Engine#

CoreML wählt die Hardware über MLModelConfiguration.computeUnits. Das Ultralytics iOS SDK verwendet standardmäßig .cpuAndNeuralEngine unter iOS 16+ anstelle von .all: In einer Echtzeit-Kamera-App ist die GPU bereits mit der Komposition der Vorschau und Overlays beschäftigt, daher vermeidet das Ausschließen der GPU Konflikte und Frame-Time-Jitter, während die ANE die Hauptarbeit übernimmt. Verwende .cpuOnly nur für Kompatibilitätstests – die obige Tabelle zeigt, was das an Leistung kostet.

Das Ausführen eines CoreML-Modells von Python aus auf einem Mac-Host (über Ultralytics oder coremltools) folgt derselben Regel: Ultralytics lädt mit ComputeUnit.CPU_AND_NE (macOS 13+, mit Fallback auf CPU_ONLY bei älteren macOS-Versionen) und hält die Inferenz auf der Neural Engine (~3× schneller als die CPU). Dies umgeht zudem eine aktuelle Einschränkung auf macOS-Hosts, bei der die Standardeinstellung ComputeUnit.ALL / CPU_AND_GPU — die den GPU/MPSGraph-Kompilierungspfad hinzufügt — den Prozess mit einer Error: MLIR pass manager failed-Assertion unter coremltools 9.x abbricht.

Link to this sectionBereitstellung exportierter YOLO26 CoreML-Modelle#

Der schnellste Weg ist das offizielle Ultralytics YOLO iOS SDK, dasselbe Swift-Paket, das die Ultralytics iOS App und das Flutter-Plugin antreibt. Es löst offizielle Modellnamen automatisch auf, lädt das .mlpackage herunter, cacht es 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 einfach YOLOView aus dem SDK für Echtzeit-Inferenz mit nativen Overlays einbauen oder das Flutter-Plugin für plattformübergreifende Apps nutzen, die sich eine Codebasis mit Android teilen.

Die Integration eines rohen .mlpackage in eigener Regie ist mit Apples Stack ebenfalls unkompliziert – lade es mit MLModel, verpacke es in eine VNCoreMLRequest und leite Bilder durch VNImageRequestHandler. Diese Ressourcen behandeln die Details:

• Integration eines Core ML-Modells in deine App: Apples Leitfaden zum Einbinden und Aufrufen eines CoreML-Modells.
• CoreML Tools: Referenz für Konvertierung, Quantisierung und Optimierung der coremltools-Toolchain, die diesen Export ermöglicht.
• Xcode Core ML Performance Reports: Layer-spezifische Geräteplatzierung und Latenz-Profiling für genau dein Modell und Gerät.

Liefere das Modell entweder eingebettet im App-Bundle (sofortige Verfügbarkeit, ideal für Nano-/Small-Modelle) oder lade es beim ersten Start herunter und cache es (kleinere Binärdatei, einfache Modell-Updates) – die offiziellen Apps verwenden den zweiten Ansatz mit den GitHub Release Assets.

Link to this sectionEmpfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics Train-Modus oder starte mit den offiziellen YOLO26-Gewichten
2. Exportiere mit model.export(format="coreml", quantize=8) auf macOS oder x86 Linux
3. Überprüfe die Genauigkeit mit model.val() auf einem Mac und erstelle ein Profil mit einem Xcode Core ML Performance Report auf deinem Zielgerät
4. Stelle bereit mit dem iOS SDK, dem Flutter-Plugin oder deiner eigenen Vision-Integration und nutze dabei .cpuAndNeuralEngine

Link to this sectionZusammenfassung#

In diesem Leitfaden hast du gelernt, wie man Ultralytics YOLO26-Modelle in das .mlpackage-Format von CoreML exportiert, sie für die Apple Neural Engine quantisiert und mit Latenzen im einstelligen Millisekundenbereich bereitstellt – entweder über das offizielle iOS SDK und das Flutter-Plugin oder deine eigene Vision-Integration. Für andere Bereitstellungsziele durchsuche die Integrationsübersicht und vergleiche Formate mit dem Benchmark-Modus.

Link to this sectionFAQ#

Link to this sectionWie exportiere ich YOLO26-Modelle in das CoreML-Format?#

Führe model.export(format="coreml") in Python oder yolo export model=yolo26n.pt format=coreml über das CLI auf macOS oder x86 Linux aus. Füge quantize=8 hinzu, um den offiziellen App-Modellen zu entsprechen. Der Export erzeugt ein yolo26n.mlpackage ML Program, das bereit für Xcode, das iOS SDK oder das Flutter-Plugin ist.

Link to this sectionBenötige ich nms=True beim Exportieren von YOLO26?#

Nein. YOLO26 ist von Haus aus NMS-frei (end-to-end), daher gibt der exportierte Graph bereits endgültige Detektionen aus und die Dekodierung kostet deutlich unter einer Millisekunde. Die Option nms=True existiert für frühere Detektionsmodelle wie YOLO11, bei denen sie eine CoreML NMS-Pipeline einbettet, damit deine App die Unterdrückung nicht selbst implementieren muss. CoreML NMS-Pipelines unterstützen nur Objektdetektion, daher wird nms=True bei anderen Aufgaben wie Segmentierung und Pose mit einer Warnung ignoriert.

Link to this sectionWelche Präzision sollte ich verwenden – FP16 oder INT8?#

Die offiziellen Ultralytics App-Modelle werden als INT8 ausgeliefert, was die Downloadgröße minimiert und die in der obigen Tabelle aufgeführten Geschwindigkeiten ermöglicht. quantize=16 (FP16) ist eine konservative Alternative ohne nennenswerten Genauigkeitsverlust. Überprüfe deinen exakten Export mit model.val() auf einem Mac, bevor du ihn veröffentlichst.

Link to this sectionWie stelle ich sicher, dass die Inferenz auf der Neural Engine läuft?#

Setze MLModelConfiguration.computeUnits = .cpuAndNeuralEngine (der Standard des iOS SDK ab iOS 16+). Vermeide .all in Kamera-Apps – die GPU ist mit der Komposition der Vorschau beschäftigt, und das Planen der Inferenz dort verursacht Frame-Time-Jitter. Bestätige die Platzierung mit einem Xcode Core ML Performance Report.

Link to this sectionKann ich CoreML-Modelle mit dem Ultralytics CLI ausführen und validieren?#

Ja, auf macOS: yolo predict model=yolo26n.mlpackage source=image.jpg und yolo val model=yolo26n.mlpackage data=coco8.yaml funktionieren wie jedes andere Format. Die CoreML-Ausführung erfordert Apple-Hardware, daher sind diese Modi auf Linux und Windows nicht verfügbar.

Link to this sectionWas ist der schnellste Weg, YOLO26 in einer iOS- oder Flutter-App zum Laufen zu bringen?#

Verwende das offizielle Ultralytics YOLO iOS SDK (Swift Package) oder das Flutter-Plugin. Beide laden offizielle Modelle namentlich mit automatischem Download und Caching, führen sie auf der Neural Engine aus und enthalten vollständige Echtzeit-Kamera-UIs – die obige Leistungstabelle wurde genau mit diesem Stack erstellt.