Core ML — définition, modèle d'apprentissage automatique et fonctionnement sous iOS

Qu'est-ce que Core ML ?

Core ML est un framework d'apprentissage automatique présenté par Apple à la WWDC 2017 dans le cadre de l'écosystème de développement pour iPhone, iPad, Mac, Apple Watch et Apple TV. Core ML fournit un environnement d'exécution pour exécuter des modèles ML sur l'appareil, en abstraisant le développeur des détails d'optimisation matérielle. Le framework sélectionne automatiquement le meilleur moteur de calcul — Neural Engine sur les puces A12+, GPU ou CPU — pour chaque opération du modèle.

L'avantage clé de Core ML est l'intégration profonde avec Apple Silicon. Les opérations de réseaux de neurones sont exécutées sur le Neural Engine dédié, qui ne sollicite pas les cœurs principaux du processeur. Selon Apple (WWDC 2025), les modèles Core ML fonctionnent 6 fois plus rapidement que TensorFlow Lite sur des appareils Android similaires.

Fonctionnalités principales

Core ML prend en charge un large éventail de tâches d'apprentissage automatique : classification d'images, détection d'objets, segmentation sémantique, traitement du langage naturel, analyse audio et données tabulaires. Le framework fonctionne avec différents types de modèles : réseaux de neurones (convolutifs, récurrents, transformeurs), ensembles d'arbres, régressions linéaires et processus gaussiens.

Comment fonctionne Core ML

Core ML prend un modèle entraîné au format .mlpackage, le compile en code machine optimisé pour l'appareil spécifique et exécute l'inférence via une API unifiée. L'ensemble du pipeline — du chargement du modèle à l'obtention du résultat — nécessite 3–5 lignes de code Swift.

Format de modèle .mlpackage

.mlpackage est un format conteneur introduit par Apple en 2020 pour remplacer l'ancien .mlmodel. Le paquet est un répertoire contenant un manifeste JSON, un fichier de modèle au format binaire MLProgram, des métadonnées (auteur, version, description) et des ressources comme les étiquettes de classes. Selon Apple, .mlpackage réduit la taille du modèle de 30–50% par rapport à .mlmodel grâce à l'optimisation des poids.

Apple Neural Engine

Apple Neural Engine (ANE) est un neuroprocesseur dédié intégré aux puces Apple depuis l'A12 Bionic (2018). L'ANE traite les opérations matricielles des dizaines de fois plus efficacement que le CPU avec la même consommation d'énergie. Les performances de l'ANE sont passées de 5 TOPS sur l'A12 à 35 TOPS sur le M4 Ultra (2025), permettant d'exécuter des modèles avec des milliards de paramètres. L'ANE est utilisé automatiquement pour tous les modèles Core ML avec une architecture de réseaux de neurones.

Une fonctionnalité importante de Core ML est la prise en charge de la quantification des modèles en FP16 et INT8 sans perte de précision. La quantification réduit la taille du modèle de 2 à 4 fois et accélère l'inférence de 40 à 60% sur l'ANE. Apple fournit l'outil Xcode Model Quantization pour la sélection automatique de la précision optimale : le développeur charge un modèle, spécifie la perte de qualité acceptable (généralement 0.1–0.5%), et Xcode sélectionne le meilleur format de représentation des poids.

Comparaison des performances de Core ML

Convertir des modèles en Core ML

La plupart des modèles ML sont créés dans PyTorch ou TensorFlow et nécessitent une conversion au format .mlpackage pour être utilisés dans Core ML. Apple fournit l'utilitaire coremltools — un paquet Python pour convertir, optimiser et valider les modèles.

Outil coremltools

coremltools est l'utilitaire officiel d'Apple pour convertir les modèles ML. Il prend en charge l'importation depuis PyTorch (via torch.onnx ou directement), TensorFlow (SavedModel, H5, Frozen Graph) et ONNX. Après conversion, la quantification FP16 ou INT8 peut être activée, réduisant la taille du modèle de 2 à 4 fois sans perte significative de précision.

Exemple de conversion depuis PyTorch

Examinons la conversion d'un modèle PyTorch entraîné au format Core ML en utilisant coremltools version 8.0. Le processus nécessite 2–3 étapes en Python.

import torch
import coremltools as ct

# Chargement du modèle PyTorch entraîné
model = torch.load('model.pth')
model.eval()

# Tracing du modèle avec une entrée exemple
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

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

Le code charge le modèle PyTorch entraîné, effectue le tracing JIT avec une entrée exemple et le convertit au format mlprogram (format binaire Core ML). Le .mlpackage résultant peut être glissé dans Xcode et utilisé immédiatement dans du code Swift.

Intégrer Core ML dans une app iOS

Après la conversion du modèle, son intégration dans une app iOS en Swift se fait en quelques lignes. Xcode génère automatiquement une classe Swift pour le modèle basée sur les métadonnées .mlpackage.

Exemple de code Swift

Examinons un exemple de classification d'images en utilisant Core ML et le framework Vision. Vision transforme automatiquement l'image à la taille et au format de pixels requis.

import CoreML
import Vision

// Chargement du modèle Core ML
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

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

    // Affichage des top-3 prédictions
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Démarrage du traitement d'image
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Le code Swift charge le modèle MobileNetV2 via le framework Vision, crée une requête de classification et traite le résultat — un tableau d'objets VNClassificationObservation avec des étiquettes de classe et des pourcentages de confiance. L'ensemble du pipeline, du chargement à la sortie du résultat, prend 5–50 ms selon le modèle.

Pour optimiser le temps de démarrage, Core ML compile le modèle lors de la première utilisation. La précompilation réduit le démarrage à froid de 2–3 secondes à 100–200 ms. Il est recommandé de compiler le modèle au moment de la construction dans Xcode, plutôt qu'au premier lancement de l'application. Ceci est particulièrement important pour les applications avec plusieurs modèles ML — par exemple, détection d'objets + classification + NLP.

Core ML vs ML Kit

Core ML et ML Kit résolvent des tâches ML similaires sur appareil, mais ciblent des écosystèmes différents. Core ML est profondément intégré à Apple Silicon et ne prend en charge que les plateformes Apple. ML Kit de Google est une solution multiplateforme pour Android et iOS.

Choisissez Core ML si votre écosystème est exclusivement Apple et que vous avez besoin de performances maximales via l'ANE. Si vous avez besoin de compatibilité multiplateforme ou d'API prêtes à l'emploi sans conversion, ML Kit sera plus pratique.

Dans la pratique, de nombreux projets utilisent les deux frameworks : iOS Core ML pour des performances élevées, et ML Kit ou TensorFlow Lite sur Android. Un modèle PyTorch unifié est converti en .mlpackage pour Apple et en .tflite pour Android, ce qui permet de maintenir la même qualité de fonctionnalités ML sur les deux plateformes. Cette approche nécessite un peu plus d'efforts DevOps mais offre une couverture maximale de l'audience.

Lors du choix entre Core ML et les alternatives, tenez compte du coût de développement : Core ML nécessite moins de code d'intégration (3–5 lignes de Swift contre 15–20 lignes avec TFLite), mais nécessite un Mac et Xcode pour la compilation. ML Kit, en revanche, fonctionne sur n'importe quelle plateforme mais offre des performances moindres sur iOS en raison de l'absence d'accès à l'Apple Neural Engine.