Core ML — Was es ist, maschinelles Lernmodell und Arbeitsweise in iOS

Was ist Core ML?

Core ML ist ein Machine-Learning-Framework, das von Apple auf der WWDC 2017 als Teil des Entwicklungssystems für iPhone, iPad, Mac, Apple Watch und Apple TV vorgestellt wurde. Core ML bietet eine Laufzeitumgebung zur Ausführung von ML-Modellen auf dem Gerät und abstrahiert den Entwickler von den Details der Hardwareoptimierung. Das Framework wählt automatisch die beste Rechenengine — Neural Engine auf A12+-Chips, GPU oder CPU — für jede Modelloperation aus.

Der Hauptvorteil von Core ML ist die tiefe Integration mit Apple Silicon. Neuronale Netzwerkoperationen werden auf der dedizierten Neural Engine ausgeführt, die die Hauptprozessorkerne nicht belastet. Laut Apple (WWDC 2025) arbeiten Core ML-Modelle 6-mal schneller als TensorFlow Lite auf vergleichbaren Android-Geräten.

Hauptfunktionen

Core ML unterstützt eine breite Palette von Machine-Learning-Aufgaben: Bildklassifikation, Objekterkennung, semantische Segmentierung, Verarbeitung natürlicher Sprache, Audioanalyse und tabellarische Daten. Das Framework arbeitet mit verschiedenen Modelltypen: neuronale Netze (faltende, rekurrente, Transformer), Baum-Ensembles, lineare Regressionen und Gaußprozesse.

Wie Core ML funktioniert

Core ML nimmt ein trainiertes Modell im .mlpackage-Format entgegen, kompiliert es in optimierten Maschinencode für das jeweilige Gerät und führt die Inferenz über eine einheitliche API aus. Die gesamte Pipeline — vom Laden des Modells bis zum Erhalten des Ergebnisses — benötigt 3–5 Zeilen Swift-Code.

.mlpackage-Modellformat

.mlpackage ist ein Containerformat, das von Apple im Jahr 2020 eingeführt wurde, um das veraltete .mlmodel zu ersetzen. Das Paket ist ein Verzeichnis mit einem JSON-Manifest, einer Modelldatei im binären MLProgram-Format, Metadaten (Autor, Version, Beschreibung) und Ressourcen wie Klassenbezeichnern. Laut Apple reduziert .mlpackage die Modellgröße durch Gewichtsoptimierung um 30–50% im Vergleich zu .mlmodel.

Apple Neural Engine

Apple Neural Engine (ANE) ist ein dedizierter Neuralprozessor, der in Apple-Chips ab dem A12 Bionic (2018) integriert ist. Die ANE verarbeitet Matrixoperationen um ein Vielfaches effizienter als die CPU bei gleichem Stromverbrauch. Die ANE-Leistung stieg von 5 TOPS beim A12 auf 35 TOPS beim M4 Ultra (2025), was die Ausführung von Modellen mit Milliarden von Parametern ermöglicht. Die ANE wird automatisch für alle Core ML-Modelle mit neuronaler Netzwerkarchitektur verwendet.

Eine wichtige Funktion von Core ML ist die Unterstützung der Quantisierung von Modellen auf FP16 und INT8 ohne Genauigkeitsverlust. Die Quantisierung reduziert die Modellgröße um das 2- bis 4-fache und beschleunigt die Inferenz auf der ANE um 40–60%. Apple bietet das Tool Xcode Model Quantization zur automatischen Auswahl der optimalen Präzision: Der Entwickler lädt ein Modell hoch, gibt den akzeptablen Qualitätsverlust an (in der Regel 0.1–0.5%), und Xcode wählt das beste Format für die Gewichtsdarstellung.

Core ML Leistungsvergleich

Modelle in Core ML konvertieren

Die meisten ML-Modelle werden in PyTorch oder TensorFlow erstellt und müssen für die Verwendung in Core ML in das .mlpackage-Format konvertiert werden. Apple stellt das Dienstprogramm coremltools zur Verfügung — ein Python-Paket zum Konvertieren, Optimieren und Validieren von Modellen.

coremltools-Tool

coremltools ist das offizielle Apple-Tool zur Konvertierung von ML-Modellen. Es unterstützt den Import aus PyTorch (über torch.onnx oder direkt), TensorFlow (SavedModel, H5, Frozen Graph) und ONNX. Nach der Konvertierung kann die FP16- oder INT8-Quantisierung aktiviert werden, wodurch die Modellgröße um das 2- bis 4-fache ohne signifikanten Genauigkeitsverlust reduziert wird.

Konvertierungsbeispiel aus PyTorch

Betrachten wir die Konvertierung eines trainierten PyTorch-Modells in das Core ML-Format mit coremltools Version 8.0. Der Vorgang umfasst 2–3 Schritte in Python.

import torch
import coremltools as ct

# Lade trainiertes PyTorch-Modell
model = torch.load('model.pth')
model.eval()

# Tracing des Modells mit Beispieleingabe
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Konvertierung in Core ML .mlpackage
mlmodel = ct.convert(
    traced_model,
    convert_to='mlprogram',
    inputs=[ct.TensorType(shape=(1, 3, 224, 224))]
)
mlmodel.save('Model.mlpackage')

Der Code lädt das trainierte PyTorch-Modell, führt JIT-Tracing mit einer Beispieleingabe durch und konvertiert es in das mlprogram-Format (binäres Core ML-Format). Das resultierende .mlpackage kann in Xcode gezogen und sofort in Swift-Code verwendet werden.

Integration von Core ML in eine iOS-App

Nach der Modellkonvertierung erfolgt die Integration in eine iOS-App in Swift mit wenigen Zeilen. Xcode generiert automatisch eine Swift-Klasse für das Modell basierend auf den .mlpackage-Metadaten.

Swift-Codebeispiel

Betrachten wir ein Beispiel zur Bildklassifikation mit Core ML und dem Vision-Framework. Vision wandelt das Bild automatisch in die erforderliche Größe und das Pixelformat um.

import CoreML
import Vision

// Lade Core ML-Modell
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

// Erstelle VNCoreMLRequest
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results
        as? [VNClassificationObservation]
    else { return }

    // Top-3-Vorhersagen ausgeben
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Starte Bildverarbeitung
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Der Swift-Code lädt das MobileNetV2-Modell über das Vision-Framework, erstellt eine Klassifikationsanfrage und verarbeitet das Ergebnis — ein Array von VNClassificationObservation-Objekten mit Klassenbezeichnern und Konfidenzprozenten. Die gesamte Pipeline vom Laden bis zur Ausgabe des Ergebnisses dauert je nach Modell 5–50 ms.

Zur Optimierung der Startzeit kompiliert Core ML das Modell bei der ersten Verwendung. Ein vorcompiliertes Modell reduziert den Kaltstart von 2–3 Sekunden auf 100–200 ms. Es wird empfohlen, das Modell zur Build-Zeit in Xcode zu kompilieren, nicht beim ersten App-Start. Dies ist besonders wichtig für Apps mit mehreren ML-Modellen — z. B. Objekterkennung + Klassifikation + NLP.

Core ML vs. ML Kit

Core ML und ML Kit lösen ähnliche On-Device-ML-Aufgaben, sind aber auf unterschiedliche Ökosysteme ausgerichtet. Core ML ist tief in Apple Silicon integriert und unterstützt nur Apple-Plattformen. ML Kit von Google ist eine plattformübergreifende Lösung für Android und iOS.

Wählen Sie Core ML, wenn Ihr Ökosystem ausschließlich Apple ist und Sie maximale Leistung durch die ANE benötigen. Wenn plattformübergreifende Unterstützung oder fertige APIs ohne Konvertierung erforderlich sind, ist ML Kit praktischer.

In der Praxis verwenden viele Projekte beide Frameworks: iOS Core ML für hohe Leistung und ML Kit oder TensorFlow Lite auf Android. Ein einheitliches PyTorch-Modell wird für Apple in .mlpackage und für Android in .tflite konvertiert, was eine gleichbleibende ML-Funktionsqualität auf beiden Plattformen ermöglicht. Dieser Ansatz erfordert etwas mehr DevOps-Aufwand, bietet aber die maximale Zielgruppenabdeckung.

Bei der Wahl zwischen Core ML und Alternativen sollten Sie die Entwicklungskosten berücksichtigen: Core ML benötigt weniger Integrationscode (3–5 Zeilen Swift gegenüber 15–20 Zeilen mit TFLite), erfordert aber einen Mac und Xcode für die Entwicklung. ML Kit hingegen funktioniert auf jeder Plattform, bietet aber auf iOS aufgrund des fehlenden Zugriffs auf die Apple Neural Engine eine geringere Leistung.