Apple-Core-AI-Integration#

Core AI ist Apples neues Framework, mit dem neuronale Netze direkt auf Apple Silicon ausgeführt werden können. Es führt das Modellformat .aimodel, eine moderne Swift-Inferenz-API, PyTorch-basierte Konvertierungswerkzeuge, Ahead-of-Time-Kompilierung, Modellspezialisierung sowie spezielle Werkzeuge zum Debuggen und Profiling ein.

Apple bezeichnet Core AI als nächste Entwicklungsstufe der KI-Ausführung auf dem Gerät und als Inferenz-Framework hinter Apple Intelligence auf dem Gerät. Es wurde für aktuelle neuronale Netzwerkarchitekturen entwickelt, von kompakten Bildverarbeitungsmodellen bis hin zu großen generativen Modellen, und kann die Arbeit auf CPU, GPU und die neuronale Recheneinheit von Apple (ANE) verteilen.

Core AI ist ein neuer Bereitstellungsweg und keine neue Bezeichnung für Core ML. Die Frameworks verwenden unterschiedliche Modellformate, Konvertierungswerkzeuge, Laufzeit-APIs und Muster zur Integration in Anwendungen.

Core AI und Core ML im Vergleich#

Core ML bleibt die passende Wahl, wenn eine Anwendung eine breite Geräteabdeckung, die Integration des Vision-Frameworks oder Modelltypen wie Entscheidungsbäume und tabellarische Pipelines benötigt. Apple unterstützt Core ML weiterhin und verweist Entwickler mit nicht neuronalen Modelltypen darauf.

So funktioniert das Core-AI-Format#

Der Core-AI-Erstellungsablauf geht von einem PyTorch-Modell aus:

PyTorch model
    ↓ torch.export
ExportedProgram
    ↓ coreai-torch
Core AI program
    ↓ optimize and save
.aimodel
    ↓ specialize or compile ahead of time
Apple silicon executable

Apples Paket coreai-torch konvertiert ein torch.export.ExportedProgram, indem PyTorch-ATen-Operationen in Core-AI-Operationen überführt werden. Nicht unterstützte Operationen lassen sich mit einem benutzerdefinierten Lowering oder einem benutzerdefinierten Metal-Kernel implementieren.

Das resultierende .aimodel ist ein nicht spezialisiertes Modell-Asset. Wenn eine Anwendung das Modell vorbereitet, spezialisiert Core AI es für das Zielgerät. Anwendungen können die Spezialisierung bei der ersten Verwendung ausführen lassen, sie früher anfordern oder ein Ahead-of-Time-kompiliertes Modell bereitstellen, um die anfängliche Ladezeit zu verkürzen.

In Swift laden Anwendungen das Asset mit dem Core-AI-Framework, wählen eine Inferenzfunktion aus, übergeben typisierte NDArray-Eingaben und erhalten benannte Ausgaben. Das unterscheidet sich davon, ein Core-ML-Modell in eine Vision-Anfrage einzubetten. Für die Einführung von Core AI ist daher eine Anwendungs-Laufzeit erforderlich, die für .aimodel-Assets ausgelegt ist.

Implementierungsdetails findest du in Apples Dokumentation zu AIModel, zu Modellspezialisierung und Caching sowie zur Ahead-of-Time-Kompilierung.

YOLO26-Modelle nach Core AI exportieren#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="coreai")  # erstellt 'yolo26n.aimodel'
model.export(format="coreai", quantize=16)  # FP16 asset

# Das exportierte Modell ausführen
coreai_model = YOLO("yolo26n.aimodel")
results = coreai_model("https://ultralytics.com/images/bus.jpg")

Die vollständige Liste der Argumente findest du im Exportmodus. Der Graph ist statisch: Er wird mit der imgsz nachgezeichnet, die an export übergeben wird. Führe Vorhersagen daher mit derselben Größe aus. Die Ultralytics-Metadaten werden im eigenen metadata.json des Assets gespeichert, sodass Klassennamen, Stride und Aufgabe beim Hin- und Rückweg erhalten bleiben.

Den Head auswählen#

Mit nms=False exportiert YOLO26 seinen End-to-End-Head, der die Erkennungen innerhalb des Graphen auswählt. Core AI bietet keine Top-k-Primitive, daher wird diese Auswahl in eine vollständige Sortierung umgewandelt. Dafür fällt an der Partitionierungsgrenze der Apple Neural Engine ein fester Aufwand von etwa 1,7 ms an – unabhängig von max_det. Beim Export mit nms=None werden stattdessen die rohen (1, 84, 8400)-Vorhersagen ausgegeben; die Non-Maximum-Unterdrückung übernimmt dann der Predictor:

yolo export model=yolo26n.pt format=coreai nms=None quantize=16

Auf einem iPhone 17 Pro mit iOS 27.0 benötigt YOLO26n bei 640 mit dem Head im Graphen 3,01 ms und ohne ihn 1,28 ms (FP16, Ahead-of-Time-kompiliert, drei verschachtelte Blöcke mit je 50 Iterationen). Für die Inferenz werden beide über YOLO(...) ausgeführt. Verwende nms=False, wenn ein einzelner Graphenaufruf fertige Erkennungen zurückgeben muss, oder behalte für externe NMS die Standardeinstellung nms=None bei.

Unter iOS 27 oder macOS 27 würde eine Anwendung das exportierte Asset anschließend über Apples Core-AI-Swift-API laden und ausführen. Exportierte Assets verwenden den Einstiegspunkt main, nehmen eine einzelne Eingabe images mit der Form [batch, 3, imgsz, imgsz] entgegen und geben output0 zurück (Modelle zur Instanzsegmentierung geben außerdem output1 zurück):

import CoreAI

let modelURL = Bundle.main.url(forResource: "yolo26n", withExtension: "aimodel")!
let model = try await AIModel(contentsOf: modelURL)
guard let function = try model.loadFunction(named: "main") else {
    throw AppError.missingInferenceFunction
}

let outputs = try await function.run(inputs: ["images": imageTensor])

Anders als beim aktuellen Core-ML- und Vision-Ablauf übernimmt der Core-AI-Pfad im Ultralytics iOS SDK die Letterbox-Vorverarbeitung und die Erstellung von NDArray selbst, liest dieselben Ultralytics-Metadaten aus dem metadata.json des Assets und verwendet die Core-ML-Ausgabedecoder erneut. Das Asset wird geladen, wenn eine Anwendung einen Pfad zu .aimodel oder eine URL zu .aimodel.zip übergibt. Aktuelle API-Details stellt Apple in der Dokumentation zum Core-AI-Framework bereit; funktionierende Modellbeispiele findest du im Repository mit Core-AI-Modellen.

Gemessene Leistung#

End-to-End-Inferenz mit einem einzelnen Bild für YOLO26n FP16 (quantize=16), Core ML- und Core AI-Exporte mit dem standardmäßigen unverarbeiteten Head (nms=None) auf einem Mac mini mit Apple M4 (4 Performance- und 6 Effizienz-CPU-Kerne, 10-Core-GPU, 16-Core Neural Engine), 16 GB Arbeitsspeicher und macOS 27.0, mit ultralytics 8.4.168, coremltools 9.0 für die Core ML-Inferenz sowie coreai-torch 0.4.3 mit coreai-core 1.0.0b3 für die Core AI-Inferenz unter Python 3.13. Jede Zelle zeigt die Gesamtzeit (Vorverarbeitung + Inferenz + Nachverarbeitung); darunter ist die Aufschlüsselung nach Phasen angegeben.

• Geschwindigkeitswerte sind Latenzen bei aufeinanderfolgenden Einzelbildaufrufen: der Mittelwert aus 15 predict-Aufrufen nach 3 Aufwärmaufrufen auf bus.jpg über die Ultralytics Python API, wobei jedes Modell und jede Recheneinheit in einem neuen Prozess ausgeführt wurde. Die Reihenfolge von CPU und Beschleuniger wechselte zwischen den Aufgaben in einem einzigen sequenziellen Durchlauf. Core ML-Zeilen werden mit coremltools.ComputeUnit.CPU_ONLY oder CPU_AND_NE geladen; Core AI-Zeilen werden mit SpecializationOptions.cpu_only() oder SpecializationOptions.from_preferred_compute_unit_kind(ComputeUnitKind.neural_engine()) spezialisiert, wobei jedes Framework die endgültige Platzierung der Operationen steuert.
• Detect, segment, classify, pose und OBB lieferten auf jeder Recheneinheit in beiden Formaten dieselben Vorhersagen. Das semantische Core ML-FP16-Modell läuft auf diesem Mac mit bevorzugter Neural Engine langsamer als ausschließlich auf der CPU, und die semantische Nachverarbeitung von Core AI dauert 6.4 bis 7.4 ms gegenüber 0.4 ms bei Core ML.
• Vergleiche die Ergebnisse auf dem iPhone 17 Pro in der CoreML-Integration.

Vorteile von Core AI#

Core AI bietet mehrere vielversprechende Vorteile für künftige Bereitstellungen mit Ultralytics:

• Moderner PyTorch-Exportpfad: Die Konvertierung beginnt mit torch.export und erhält einen ausdrucksstärkeren PyTorch-Graphen als der Tracing-Ablauf vieler vorhandener Exportwerkzeuge.
• Präzise Steuerung der Laufzeit: Anwendungen können Spezialisierung, Caches für kompilierte Modelle, Inferenzfunktionen, Speicher und die Platzierung der Berechnungen verwalten.
• Erweiterte Modellunterstützung: Zustandsbehaftete Ausführung, dynamische Formen, mehrere Funktionen in einem Artefakt und benutzerdefinierte Metal-Kernels sind auf moderne Bildverarbeitungs- und generative Architekturen ausgelegt.
• Spezielle Entwicklerwerkzeuge: Mit dem Core AI Debugger lassen sich Graphen und Tensorwerte untersuchen und auf den ursprünglichen Python-Code zurückführen. Xcode und Instruments ermöglichen Laufzeit-Profiling.
• Möglichkeiten zur Vermeidung von Kopien: Core AI bietet Steuerungsmöglichkeiten für Speicher und Puffer, die Kopien zwischen Kamera, Grafik und Inferenz reduzieren sollen.
• Optimierung für Apple Silicon: Durch Gerätespezialisierung kann Apple ein Modell für die CPU, GPU und Neural Engine des jeweiligen Geräts optimieren.
• Flexible Komprimierung: Apples Core-AI-Optimierungswerkzeuge unterstützen Quantisierung, Palettierung und Pruning, einschließlich Gewichtsformaten mit niedriger Bitbreite.

Diese Funktionen könnten besonders für künftige YOLO-Modelle mit dynamischer Ausführung, größeren multimodalen Komponenten oder benutzerdefinierten Operationen nützlich sein, die sich nicht ohne Weiteres auf vorhandene Core-ML-Operationen abbilden lassen.

Derzeitige Nachteile und Einschränkungen#

Core AI ist derzeit kein Ersatz für den produktiven Core-ML-Pfad:

• Neue Betriebssysteme erforderlich: Das öffentliche Framework ist für die Generation von iOS 27 und macOS 27 vorgesehen, während Core ML eine wesentlich größere installierte Basis unterstützt.
• Beta-Software: Apples Core-AI-Framework und Teile der Python-Werkzeugkette befinden sich noch in einem vorläufigen Stadium und können sich vor den stabilen Versionen ändern.
• Engere Exportumgebung: coreai-torch erfordert derzeit Python 3.11 bis 3.14 sowie aktuelle PyTorch-Versionen. Das ist ein deutlich engerer Bereich als die von Ultralytics unterstützten Python- und PyTorch-Versionen.
• Eingeschränkte Exportplattformen: coreai-core veröffentlicht nur macosx_26_0_arm64- und manylinux_2_34_x86_64-Wheel-Dateien. Daher benötigt format=coreai einen Mac mit Apple silicon und macOS 26 oder neuer oder x86_64 Linux mit glibc 2.34 oder neuer (zum Beispiel Ubuntu 22.04+). Für die Ausführung von .aimodel ist weiterhin Apple-Hardware erforderlich.
• In den Ultralytics-SDKs optional, nicht standardmäßig aktiviert: Auf einem iPhone 17 Pro liegt Core AI laut Vergleich auf dem Gerät bei der gesamten Pipeline gleichauf mit Core ML und ist nicht schneller. Semantische Inferenz, Tiefeninferenz und Inferenz nur auf der CPU sind langsamer, und FP16-Assets sind etwa doppelt so groß. Daher behalten das iOS SDK und das Flutter-Plugin Core ML als Standardeinstellung bei.
• Für die SDKs den Raw Head verwenden: Mit nms=False dauert die Ausführung von YOLO26n mit Core AI etwa doppelt so lange wie mit Core ML (3,06 gegenüber 1,53 ms in einem Vergleichslauf). Außerdem liefert das FP16-End-to-End-Posemodell bei der Standardplatzierung von Core AI unter iOS 27.0 keine Erkennungen (apple/coreai-torch#115). Der Raw Head (nms=None, die Standardeinstellung) vermeidet beide Probleme, und die SDKs führen NMS in Swift aus. Weitere Informationen findest du unter Den Head auswählen.
• Keine Laufzeit für den iOS Simulator: Das iOS-Simulator-SDK enthält Core AI nicht.
• Anpassung der Anwendung erforderlich: Ein .aimodel lässt sich nicht anstelle eines .mlpackage verwenden. Das Laden des Modells, die Vorverarbeitung, Inferenzaufrufe, die Verarbeitung von Metadaten und die Decodierung der Ausgaben müssen außerhalb der Ultralytics-SDKs mit einer Core-AI-Implementierung umgesetzt werden; die SDKs bieten eine solche Implementierung.
• Begrenzte Praxiserfahrung: Leistung, Stromverbrauch, Spezialisierungsdauer beim ersten Start, Genauigkeit und Komprimierung müssen für die unterstützten YOLO-Aufgaben und Geräte systematisch geprüft werden.
• Keine NMS-Pipeline: Core ML kann für ältere YOLO-Erkennungsmodelle eine NMS-Stufe einbinden. Core AI exportiert standardmäßig rohe One-to-Many-Vorhersagen. Verwende nms=False für den NMS-freien Head von YOLO26. Eingebettetes NMS (nms=True) und dynamic=True werden nicht unterstützt. Für coreai-torch gibt es kein Lowering für torchvision::nms, daher wird NMS auf dem Host ausgeführt.
• Feste Eingabegröße: Der exportierte Graph wird mit einer einzigen imgsz nachgezeichnet und unterstützt keine dynamischen Formen. Führe Vorhersagen daher mit der Größe aus, für die das Modell exportiert wurde.
• FP16-Assets können beim Laden einen Abbruch verursachen: Bei manchen FP16-.aimodel-Assets schlägt das Laden des Programms für die Apple Neural Engine fehl. MPSGraph löst dann eine fehlgeschlagene Assertion aus, die den Prozess beendet, statt auf eine andere Ausführungsmöglichkeit zurückzugreifen. Das geschieht innerhalb der Apple-Laufzeit, bevor Ultralytics-Code ausgeführt wird; dasselbe Asset lässt sich mit einer Spezialisierung nur für die CPU laden. Verwende FP32 als Ausweichlösung, wenn dieses Problem auftritt. Die auf einem iPhone 17 Pro geprüften FP16-SDK-Assets (alle Nano-Modelle, das Erkennungsmodell in allen Größen und das jeweils größte Modell jeder Aufgabe) ließen sich ohne Abbruch laden.

Welches Apple-Format solltest du verwenden?#

Verwende Core ML vorerst, wenn du Folgendes benötigst:

• Bereitstellung auf aktuellen und älteren Apple-Betriebssystemen
• Den Standardpfad des Ultralytics iOS- oder Flutter-SDKs
• Bildverarbeitung mit dem Vision-Framework
• Geprüfte YOLO-Bereitstellung mit FP16 und INT8
• Eingebettetes NMS für kompatible ältere Erkennungsmodelle

Prüfe Core AI, wenn du iOS 27 oder macOS 27 voraussetzen kannst und Folgendes benötigst:

• Die neueste Apple-Laufzeit für neuronale Netze auf dem Gerät
• Explizite Verwaltung von Spezialisierung und Caches
• Erweiterte dynamische oder zustandsbehaftete Modellausführung
• Benutzerdefinierte Core-AI-Operationen oder Metal-Kernels
• Detailliertes Debugging von Core-AI-Graphen und Laufzeit-Profiling

Core ML und Core AI werden voraussichtlich parallel bestehen, während Anwendungen umgestellt werden. Die Unterstützung von Core AI macht Core ML nicht sofort überflüssig, denn die Bereitstellungsziele und Anwendungsschnittstellen unterscheiden sich.

Ultralytics-Roadmap#

Das dedizierte Exportziel coreai ist implementiert: Der Export und die numerische Validierung decken die unterstützten YOLO26-Aufgabenmodelle ab und laufen kontinuierlich in der Ultralytics-CI unter macOS 26. Außerdem wird die FP16-Latenz auf dem Gerät gemessen. Folgende Punkte sind noch offen, bevor Core AI den Funktionsumfang des Core-ML-Pfads erreicht:

1. Die Latenzlücke des End-to-End-Heads auf der Apple Neural Engine schließen (apple/coreai-torch#66) und die Korrektheitsprobleme mit der Neural Engine beheben (apple/coreai-torch#115, #116).
2. INT8- und palettierte Core-AI-Assets; die SDK-Assets verwenden FP16 und sind etwa doppelt so groß wie die INT8-Core-ML-Assets.
3. Stabile Versionen des Apple-Frameworks und der Konvertierungswerkzeuge (die Generation von iOS 27 und macOS 27 befindet sich derzeit in der Beta).
4. Benchmarks zu Speicher, Stromverbrauch und Spezialisierung für die unterstützte Geräteauswahl.

Das Ultralytics iOS SDK und das Flutter-Plugin laden Core AI unter iOS 27 und neuer optional; Core ML bleibt ihre Standardeinstellung und das empfohlene Ziel für Geräte mit einer iOS-Version unter 27. Verfolge die Ultralytics-Roadmap und die Versionshinweise, um über die übrigen Punkte auf dem Laufenden zu bleiben.

Weitere Ressourcen#

• Überblick zu Apple Core AI
• Dokumentation zum Core-AI-Framework
• Core-AI-Erweiterungen für PyTorch
• Core-AI-Optimierung
• Repository der Apple-Core-AI-Modelle
• Core-ML-Integration von Ultralytics

Häufig gestellte Fragen#