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 einzige Weg, diese zu programmieren. Der Export von Ultralytics YOLO26-Modellen nach CoreML verwandelt einen trainierten .pt-Checkpunkt in ein natives .mlpackage, das alle sechs YOLO-Aufgaben direkt auf dem Gerät in Millisekunden 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-Erkennung läuft bei Einzelbildern auf einem iPhone 17 Pro in 3,8 ms komplett durch und erreicht bei dauerhafter Echtzeit-Kameranutzung ca. 16 ms/Frame (siehe Tabelle und Hinweise unten) – komfortabel in Echtzeit und mit Puffer für den Rest deiner App.
• NMS-frei per Design: YOLO26 ist end-to-end, daher benötigt der exportierte Graph keine NMS-Pipeline und die Dekodierung erfolgt in unter einer Millisekunde. Ältere Modelle 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#

End-to-End-Einzelbild-Inferenz für die offiziellen YOLO26n INT8 CoreML-Modelle auf einem iPhone 17 Pro (Apple A19, iOS 26.5). Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachverarbeitung, ohne Annotation) mit der Aufteilung 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ärmdurchläufen auf bus.jpg, gemessen über das per-stage Timing des iOS SDK mittels des Benchmark-Harness des Flutter-Plugins im Profil-Modus (optimierter nativer Code). Der kontinuierliche Echtzeit-Kamerabetrieb läuft mit höheren Werten (Full-Sensor Letterboxing für jeden Frame plus thermische Stabilisierung): YOLO26n detect misst ~16 ms/Frame in der Live-Kamera-App auf demselben Gerät – siehe das iOS SDK Performance-Dokument für das Profiling im Steady-State.
• 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 (FP16 by default); int8=True matches the official app models
model.export(format="coreml", int8=True)  # 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.

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", int8=True) 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 int8=True 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 NMS-frei End-to-End, daher liefert der exportierte Graph bereits fertige Erkennungen aus, und die Dekodierung kostet deutlich weniger als eine Millisekunde. Die Option nms=True existiert für frühere Modelle wie YOLO11, bei denen sie eine CoreML NMS-Pipeline einbettet, damit deine App keine eigene Unterdrückung implementieren muss.

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 gezeigten Geschwindigkeiten erreicht. half=True (FP16) ist eine konservative Alternative mit praktisch keinem Genauigkeitsverlust. Validiere deinen konkreten Export mit model.val() auf einem Mac, bevor du ihn auslieferst.

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.