CoreML-Export für YOLO26-Modelle#

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

Was ist CoreML?#

CoreML (von Apple als „Core ML“ bezeichnet) ist Apples Framework für maschinelles Lernen auf dem Gerät. Es lädt Modelle im modernen ML Program-Format – dem .mlpackage-Paket, das der Ultralytics-Exporter erstellt –, und plant sie auf der CPU, der GPU und der Apple Neural Engine (ANE) des Geräts ein, 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 Skalierung und Ausrichtung von Bildern auf dem Weg in das Modell übernimmt – auf diese Weise speist das Ultralytics iOS SDK Kameraframes mit effektiv null Vorverarbeitungskosten in YOLO ein.

Warum YOLO26 nach CoreML exportieren?#

• Neural Engine-Geschwindigkeit: CoreML plant unterstützte Operationen auf Apples Neural Engine für eine latenzarme On-Device-Inferenz ein. Siehe die Tabelle für physische Geräte unten und benchmarke deinen genauen Export auf deiner Zielhardware.
• NMS-frei von Natur aus: YOLO26 ist End-to-End, sodass der exportierte Graph keine NMS-Pipeline benötigt und die Decodierung im Submillisekundenbereich liegt. Ältere Erkennungsmodelle wie YOLO11 können eine CoreML NMS-Pipeline mit nms=True einbetten.
• Privat und offline: Die gesamte Berechnung verbleibt auf dem Gerät – keine Cloud-Hin- und Rückwege, keine API-Schlüssel, vollständige Datenschutz.
• Ein Export, das gesamte Ökosystem: Derselbe .mlpackage läuft auf iOS, iPadOS, macOS, watchOS, tvOS und visionOS und treibt das offizielle Ultralytics iOS SDK sowie das Flutter-Plugin an.

Gemessene Leistung#

End-to-End-Einzelbild-Inferenz für die standardisierten v8.3.0 YOLO26n INT8 CoreML-Ressourcen auf einem iPhone 17 Pro mit 12 GB Speicher und iOS 26.5.2. Dessen A19 Pro verfügt über eine 6-Kern-CPU (2 Performance- und 4 Effizienzkerne), eine 6-Kern-GPU mit Neural Accelerators und eine 16-Kern-Neural Engine. Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachbereitung, ohne Annotation) mit der Aufteilung nach Phasen direkt darunter. Unter iOS führt Vision die Eingabeskalierung innerhalb der Inferenzanfrage durch, sodass die Vorverarbeitung als 0 gemeldet wird und ihre Kosten in der Inferenz enthalten sind.

• Die genauen v8.3.0-Release-Ressourcen deklarieren 224×224 Eingaben für die Klassifizierung und 640×640 für alle anderen Aufgaben.
• Geschwindigkeitswerte sind Einzelbild-Burst-Latenzen – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmläufen auf bus.jpg, gemessen über das phasenbasierte Timing des iOS SDKs über das Benchmark-Harness des Flutter-Plugins im Profilmodus (optimierter nativer Code). Die Reihenfolge von CPU und Beschleuniger wechselte zwischen den Aufgaben in einem sequenziellen Durchlauf. CPU-Zeilen fordern Core ML .cpuOnly an; Zeilen mit bevorzugter CPU + ANE fordern .cpuAndNeuralEngine an, wobei die finale Operationsplatzierung von Core ML gesteuert wird. Der anhaltende Echtzeit-Kamerabetrieb läuft höher, da er die Erfassungs- und Skalierungspipeline sowie die thermische Beruhigung umfasst. Ein historischer Kamera-Durchlauf vor dem Standard maß 11,3 ms/Frame für YOLO26n Detect und 16,5 ms/frame für YOLO26n Depth auf demselben Gerät – siehe das iOS SDK-Leistungsdokument für das Profiling im eingeschwungenen Zustand.
• Vergleiche die Android-CPU/GPU-Ergebnisse in der LiteRT-Integration und die Snapdragon-NPU-Ergebnisse in der Qualcomm QNN-Integration.

Unterstützte Aufgaben#

CoreML-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Familie, die diese Heads enthält.

Exportieren von YOLO26-Modellen nach CoreML#

Installation#

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; für detaillierte Anweisungen und bewährte Methoden schaue in unseren Installationsleitfaden und den Leitfaden zu häufigen Problemen.

Verwendung#

Das CoreML-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung mit CoreML laufen nur auf macOS. Exportiere dein Modell und lade dann das exportierte Modell, um eine Inferenz auszuführen oder dessen 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, imgsz=640)  # use imgsz=224 for classification

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")

Export-Argumente#

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

Ausrichtung auf die Neural Engine#

CoreML wählt die Hardware über MLModelConfiguration.computeUnits aus. 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 Zusammensetzung der Vorschau und von Overlays beschäftigt, sodass ein Ausschluss Konkurrenz und Frame-Zeit-Jitter vermeidet, während die ANE die schwere Arbeit erledigt. Fixiere .cpuOnly nur für Kompatibilitätstests – die obige Tabelle zeigt, was das 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+, fällt auf CPU_ONLY auf älteren macOS-Versionen zurück), wodurch die Inferenz auf der Neural Engine gehalten wird (~3× schneller als CPU). Dies vermeidet auch eine aktuelle macOS-Host-Einschränkung, bei der die Standardwerte ComputeUnit.ALL / CPU_AND_GPU – die den GPU/MPSGraph-Kompilierungspfad hinzufügen – den Prozess abbrechen mit einer Error: MLIR pass manager failed-Assertion auf coremltools 9.x.

Bereitstellung 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 den .mlpackage herunter und zwischenspeichert ihn, und gibt vollständig decodierte 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 fügst du einfach die YOLOView des SDKs für Echtzeit-Inferenz mit nativen Overlays ein oder nutzt das Flutter-Plugin für plattformübergreifende Apps, die sich eine Codebasis mit Android teilen.

Die eigenständige Integration eines rohen .mlpackage ist mit Apples Stack ebenfalls unkompliziert – lade es mit MLModel, verpacke es in ein VNCoreMLRequest und füttere Bilder über VNImageRequestHandler ein. Diese Ressourcen decken die Details ab:

• Integrieren eines Core ML-Modells in deine App: Apples Leitfaden zum Bündeln und Aufrufen eines CoreML-Modells.
• CoreML Tools: Konvertierungs-, Quantisierungs- und Optimierungsreferenz für die coremltools-Toolchain, die diesen Export antreibt.
• Xcode Core ML Performance Reports: Schichtbezogene Hardware-Platzierung und Latenz-Profiling für dein exaktes Modell und Gerät.

Liefere das Modell entweder direkt in das App-Bundle eingebettet aus (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 kombinieren beide Ansätze: Standard-Nano-Modelle sind für die sofortige Nutzung gebündelt, während größere Varianten bei Bedarf heruntergeladen und lokal gecacht werden.

Empfohlener Arbeitsablauf#

1. Trainiere dein Modell mit dem Ultralytics Train-Modus oder beginne mit den offiziellen YOLO26-Gewichten
2. Exportiere mit model.export(format="coreml", quantize=8, imgsz=640) auf macOS oder x86 Linux (imgsz=224 für Klassifizierung)
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 ziele auf .cpuAndNeuralEngine ab

Zusammenfassung#

In diesem Leitfaden hast du gelernt, wie du Ultralytics YOLO26-Modelle in das .mlpackage-Format von CoreML exportierst, sie für die Apple Neural Engine quantisierst und mit Latenzen im einstelligen Millisekundenbereich bereitstellst – entweder über das offizielle iOS SDK und das Flutter-Plugin oder deine eigene Vision-Integration. Für andere Bereitstellungsziele durchstöbere die Seite des Integrationsleitfadens und vergleiche Formate mit dem Benchmark-Modus.

FAQ#