Core ML — wat is het, machine learning-model en werking in iOS

Wat is Core ML?

Core ML — is een machine learning-framework dat door Apple op WWDC 2017 werd geïntroduceerd als onderdeel van het ontwikkelingsecosysteem voor iPhone, iPad, Mac, Apple Watch en Apple TV. Core ML biedt een runtime voor het uitvoeren van ML-modellen op het apparaat, waarbij de ontwikkelaar wordt geabstraheerd van de details van hardware-optimalisatie. Het framework selecteert automatisch de beste rekenmotor — Neural Engine op A12+-chips, GPU of CPU — voor elke modeloperatie.

Het belangrijkste voordeel van Core ML — diepe integratie met Apple Silicon. Neurale netwerkbewerkingen worden uitgevoerd op de speciale Neural Engine, die de belangrijkste processorkernen niet belast. Volgens Apple (WWDC 2025) werken Core ML-modellen 6 keer sneller in vergelijking met TensorFlow Lite op vergelijkbare Android-apparaten.

Belangrijkste mogelijkheden

Core ML ondersteunt een breed scala aan machine learning-taken: beeldclassificatie, objectdetectie, semantische segmentatie, natuurlijke taalverwerking, geluidsanalyse en tabelgegevens. Het framework werkt met modellen van verschillende typen: neurale netwerken (convolutioneel, recurrent, transformatoren), boomensembles, lineaire regressies en Gauss-processen.

Hoe werkt Core ML

Core ML neemt een getraind model in .mlpackage-formaat als invoer, compileert het naar geoptimaliseerde machinecode voor het specifieke apparaat en start de inferentie via een uniforme API. De hele pijplijn — van het laden van het model tot het verkrijgen van het resultaat — vereist 3–5 regels code in Swift.

Modelformaat .mlpackage

.mlpackage — is een containerformaat, geïntroduceerd door Apple in 2020 ter vervanging van het verouderde .mlmodel. Het pakket is een directory met een JSON-manifest, een modelbestand in binair MLProgram-formaat, metadata (auteur, versie, beschrijving) en bronnen zoals klasselabels. Volgens Apple verkleint .mlpackage de modelgrootte met 30–50% in vergelijking met .mlmodel door optimalisatie van gewichten.

Apple Neural Engine

Apple Neural Engine (ANE) — een speciale neuroprocessor ingebouwd in Apple-chips vanaf de A12 Bionic (2018). ANE verwerkt matrixbewerkingen tientallen keren efficiënter dan de CPU bij hetzelfde energieverbruik. De ANE-prestatie is gestegen van 5 TOPS op de A12 naar 35 TOPS op de M4 Ultra (2025), waardoor modellen met miljarden parameters kunnen worden uitgevoerd. ANE wordt automatisch gebruikt voor alle Core ML-modellen met een neuraal netwerkarchitectuur.

Een belangrijke functie van Core ML — ondersteuning voor kwantisering van modellen naar FP16 en INT8 zonder verlies van nauwkeurigheid. Kwantisering verkleint de modelgrootte 2–4 keer en versnelt de inferentie met 40–60% op ANE. Apple biedt de tool Xcode Model Quantization voor automatische selectie van optimale precisie: de ontwikkelaar laadt het model, specificeert het toegestane kwaliteitsverlies (meestal 0.1–0.5%), en Xcode selecteert het beste formaat voor gewichtsrepresentatie.

Vergelijking van Core ML-prestaties

Modellen converteren naar Core ML

De meeste ML-modellen worden gemaakt in PyTorch of TensorFlow en vereisen conversie naar .mlpackage-formaat voor gebruik in Core ML. Apple biedt de tool coremltools — een Python-pakket voor het converteren, optimaliseren en valideren van modellen.

De tool coremltools

coremltools — is de officiële tool van Apple voor het converteren van ML-modellen. Het ondersteunt import uit PyTorch (via torch.onnx of rechtstreeks), TensorFlow (SavedModel, H5, Frozen Graph) en ONNX. Na conversie kan FP16- of INT8-kwantisering worden geactiveerd, wat de modelgrootte 2–4 keer verkleint zonder significant verlies van nauwkeurigheid.

Voorbeeld van conversie uit PyTorch

Laten we de conversie van een getraind PyTorch-model naar Core ML-formaat bekijken met coremltools versie 8.0. Het proces vereist 2–3 stappen in Python.

import torch
import coremltools as ct

# Het getrainde PyTorch-model laden
model = torch.load('model.pth')
model.eval()

# Het model traceren met een voorbeeldinvoer
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

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

De code laadt het getrainde PyTorch-model, voert JIT-tracing uit met een voorbeeldinvoer en converteert het naar mlprogram-formaat (binair Core ML-formaat). Het resulterende .mlpackage kan naar Xcode worden gesleept en onmiddellijk in Swift-code worden gebruikt.

Core ML integreren in een iOS-app

Na conversie van het model gebeurt de integratie in een iOS-app in Swift in een paar regels. Xcode genereert automatisch een Swift-klasse voor het model op basis van de .mlpackage-metadata.

Voorbeeldcode in Swift

Laten we een voorbeeld bekijken van beeldclassificatie met Core ML en het Vision-framework. Vision converteert automatisch de afbeelding naar de vereiste grootte en pixelindeling.

import CoreML
import Vision

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

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

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

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

De Swift-code laadt het MobileNetV2-model via het Vision-framework, maakt een classificatieverzoek aan en verwerkt het resultaat — een array van VNClassificationObservation-objecten met klasselabels en betrouwbaarheid in procenten. De hele pijplijn van laden tot resultaat duurt 5–50 ms, afhankelijk van het model.

Voor optimalisatie van de opstarttijd compileert Core ML het model bij het eerste gebruik. Voorcompilatie (precompiled model) verkort een koude start van 2–3 seconden tot 100–200 ms. Het wordt aanbevolen om de modelcompilatie tijdens de build-fase in Xcode uit te voeren, niet bij de eerste start van de app. Dit is vooral belangrijk voor apps met meerdere ML-modellen — bijvoorbeeld objectdetectie + classificatie + NLP.

Core ML vs ML Kit

Core ML en ML Kit lossen vergelijkbare on-device ML-taken op, maar zijn gericht op verschillende ecosystemen. Core ML is diep geïntegreerd met Apple Silicon en ondersteunt alleen Apple-platformen. ML Kit van Google is een cross-platform oplossing voor Android en iOS.

Kies Core ML als uw ecosysteem uitsluitend Apple is en u maximale prestaties via ANE nodig hebt. Als cross-platform of kant-en-klare API's zonder conversie nodig zijn — dan is ML Kit praktischer.

In de praktijk gebruiken veel projecten beide frameworks: op iOS Core ML voor hoge prestaties, en op Android — ML Kit of TensorFlow Lite. Eén PyTorch-model wordt geconverteerd naar .mlpackage voor Apple en naar .tflite voor Android, waardoor dezelfde ML-kwaliteit op beide platformen behouden blijft. Deze aanpak vergt iets meer inspanning in DevOps, maar biedt maximale doelgroepdekking.

Houd bij de keuze tussen Core ML en alternatieven rekening met de ontwikkelingskosten: Core ML vereist minder code voor integratie (3–5 regels Swift tegenover 15–20 regels met TFLite), maar vereist Mac en Xcode voor de build. ML Kit werkt daarentegen op elk platform, maar levert lagere prestaties op iOS door het gebrek aan toegang tot Apple Neural Engine.