CoreML-Export für YOLO26-Modelle#

Apple stattet jedes moderne iPhone, iPad und jeden Mac mit spezieller KI-Hardware aus – der Neural Engine – und CoreML ist heute der von Ultralytics unterstützte Weg, Modelle darauf bereitzustellen. Beim Export von Ultralytics YOLO26-Modellen wird ein trainierter Checkpoint .pt in ein natives .mlpackage umgewandelt, das alle sieben YOLO-Aufgaben bei niedriger Latenz direkt auf dem Gerät 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 – das .mlpackage-Paket, das der Ultralytics-Exporter erzeugt – und verteilt sie auf CPU, GPU und Apple Neural Engine (ANE), die spezielle NPU in jedem Chip mit Apple-Silizium. Da alles lokal ausgeführt wird, funktioniert die Inferenz offline, verursacht keine Netzwerklatenz und hält Nutzerdaten auf dem Gerät.

CoreML ist direkt in Apples Vision-Framework integriert. Dieses übernimmt die Skalierung und Ausrichtung von Bildern auf dem Weg zum Modell. So übergibt das Ultralytics iOS SDK Kamerabilder mit praktisch keinem zusätzlichen Vorverarbeitungsaufwand an YOLO.

Warum YOLO26 nach CoreML exportieren?#

• Geschwindigkeit des Neural Engine: CoreML plant unterstützte Operationen auf Apples Neural Engine ein, um eine Inferenz mit niedriger Latenz auf dem Gerät zu ermöglichen. Sieh dir die Tabelle mit den Ergebnissen auf physischen Geräten unten an und benchmarke deinen exakten Export auf der Zielhardware.
• Wähle die Ausgabe: Standardexporte überlassen NMS deiner App. Nutze nms=True, um NMS einzubinden, oder nms=False für den NMS-freien Kopf von YOLO26.
• Privat und offline: Die gesamte Berechnung bleibt auf dem Gerät – keine Cloud-Anfragen, keine API-Schlüssel, umfassender Datenschutz.
• Ein Export für das gesamte Ökosystem: Dasselbe .mlpackage läuft auf iOS, iPadOS, macOS, watchOS, tvOS und visionOS und bildet die Grundlage für das offizielle iOS SDK und Flutter-Plugin von Ultralytics.

Gemessene Leistung#

End-to-End-Inferenz für einzelne Bilder mit den standardisierten v8.3.0 YOLO26n-INT8-CoreML-Assets auf einem iPhone 17 Pro mit 12 GB Arbeitsspeicher und iOS 26.5.2. Der A19 Pro verfügt über eine 6-Kern-CPU (2 Performance- und 4 Effizienzkerne), eine 6-Kern-GPU mit Neural Accelerators und einen 16-Kern-Neural Engine. Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachverarbeitung, ohne Annotation) mit der Aufschlüsselung der einzelnen Phasen darunter. Unter iOS führt Vision die Skalierung der Eingabe innerhalb der Inferenzanfrage aus, daher wird die Vorverarbeitung mit 0 angegeben und ihre Zeit der Inferenz zugerechnet.

• Die exakten v8.3.0-Release-Assets geben Eingaben mit 224×224 für die Klassifikation und 640×640 für alle anderen Aufgaben an.
• Geschwindigkeitswerte sind Burst-Latenzen für einzelne Bilder – der Mittelwert aus 15 Durchläufen nach 3 Aufwärmdurchläufen auf bus.jpg, gemessen über die Phasen-Zeitmessung des iOS SDKs mithilfe des Benchmark-Harness des Flutter-Plugins im Profilmodus (optimierter nativer Code). Die Reihenfolge von CPU und Beschleuniger wurde zwischen den Aufgaben in einem sequenziellen Durchlauf abwechselnd verwendet. Die CPU-Zeilen fordern Core ML .cpuOnly an; die Zeilen mit bevorzugter CPU + ANE fordern .cpuAndNeuralEngine an, wobei Core ML die endgültige Platzierung der Operationen steuert. Ein längerer Echtzeit-Kamerabetrieb weist höhere Werte auf, da er die Aufnahme- und Skalierungspipeline sowie die thermische Stabilisierung umfasst. Bei einem historischen Kameradurchlauf vor der Standardisierung wurden auf demselben Gerät 11.3 ms/Frame für YOLO26n Detect und 16.5 ms/Frame für YOLO26n Depth gemessen – Einzelheiten zur Messung im eingeschwungenen Zustand findest du in der Leistungsdokumentation des iOS SDKs.
• Vergleiche die Android-Ergebnisse für CPU/GPU in der LiteRT-Integration und die Ergebnisse der Snapdragon-NPU in der Qualcomm-QNN-Integration.

Unterstützte Aufgaben#

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

YOLO26-Modelle nach CoreML exportieren#

Installation#

Führe zur Installation des erforderlichen Pakets folgenden Befehl aus:

# Install the required package for YOLO26
pip install ultralytics

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

Verwendung#

Das CoreML-Format unterstützt die Modi Export, Predict und Validate. Inferenz und Validierung mit CoreML laufen nur unter macOS. Exportiere dein Modell und lade es anschließend, um Inferenz auszuführen oder seine 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")

Exportargumente#

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

Auf den Neural Engine zielen#

CoreML wählt die Hardware über MLModelConfiguration.computeUnits aus. Das Ultralytics iOS SDK verwendet unter iOS 16+ standardmäßig .cpuAndNeuralEngine statt .all: In einer Echtzeit-Kamera-App ist die GPU bereits mit der Darstellung der Vorschau und der Einblendungen beschäftigt. Durch ihren Ausschluss werden Konkurrenz um Ressourcen und Schwankungen der Frame-Zeit vermieden, während der ANE die Hauptlast übernimmt. Verwende .cpuOnly nur für Kompatibilitätstests – die obige Tabelle zeigt die dadurch entstehenden Kosten.

Das Ausführen eines CoreML-Modells aus Python auf einem Mac-Host (über Ultralytics oder coremltools) folgt derselben Regel: Ultralytics lädt mit ComputeUnit.CPU_AND_NE (macOS 13+, mit Rückfall auf CPU_ONLY bei älteren macOS-Versionen) und hält die Inferenz auf dem Neural Engine (ca. 3× schneller als auf der CPU). Dadurch wird außerdem eine aktuelle Einschränkung von macOS-Hosts vermieden, bei der die standardmäßigen Optionen ComputeUnit.ALL / CPU_AND_GPU – die den GPU-/MPSGraph-Kompilierungspfad hinzufügen – den Prozess mit einer Error: MLIR pass manager failed-Assertion auf coremltools 9.x abbrechen.

Exportierte YOLO26-CoreML-Modelle bereitstellen#

Der schnellste Weg führt über das offizielle Ultralytics YOLO iOS SDK, dasselbe Swift-Paket, das die Ultralytics-iOS-App und das Flutter-Plugin verwendet. Es löst offizielle Modellnamen automatisch auf, lädt und cached .mlpackage 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 Echtzeit-Inferenz mit nativen Einblendungen einsetzen oder das Flutter-Plugin für plattformübergreifende Apps verwenden, die eine gemeinsame Codebasis mit Android nutzen.

Die direkte Integration eines rohen .mlpackage ist mit Apples Stack ebenfalls unkompliziert: Lade es mit MLModel, verpacke es in ein VNCoreMLRequest und übergib Bilder über VNImageRequestHandler. Diese Ressourcen enthalten die Einzelheiten:

• Ein Core-ML-Modell in deine App integrieren: Apples Anleitung zum Bündeln und Aufrufen eines CoreML-Modells.
• CoreML Tools: Referenz zu Konvertierung, Quantisierung und Optimierung für die Toolchain coremltools, die diesen Export ermöglicht.
• Xcode Core-ML-Leistungsberichte: Profiling der Geräteplatzierung und Latenz pro Schicht für dein exaktes Modell und Gerät.

Bette das Modell entweder in das App-Bundle ein (sofort verfügbar, ideal für Nano- und kleine Modelle) oder lade es beim ersten Start herunter und cache es (kleineres Binärprogramm, einfache Modellaktualisierungen). Die offiziellen Apps kombinieren beide Ansätze: Standardmäßige Nano-Modelle sind zur sofortigen Verwendung enthalten, während größere Varianten bei Bedarf heruntergeladen und lokal gecacht werden.

Empfohlener Arbeitsablauf#

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

Zusammenfassung#

In diesem Leitfaden hast du gelernt, wie du Ultralytics YOLO26-Modelle in das .mlpackage-Format von CoreML exportierst, für den Apple Neural Engine quantisierst und mit Latenzen im einstelligen Millisekundenbereich bereitstellst – entweder über das offizielle iOS SDK und Flutter-Plugin oder deine eigene Vision-Integration. Weitere Bereitstellungsziele findest du auf der Integrationsleitfadenseite; mit dem Benchmark-Modus kannst du Formate vergleichen.

FAQ#