Core ML : architecture du framework et intégration de modèles

Quest-ce que Core ML ?

Core ML est un composant clé de l’écosystème d’apprentissage automatique d’Apple, présenté à la WWDC 2017. Avant Core ML, les développeurs iOS utilisaient des bibliothèques tierces (TensorFlow Mobile, Caffe2) ou des solutions personnalisées pour exécuter des modèles ML sur l’appareil. Core ML a fourni une interface unifiée unique pour tous les types de modèles — des régressions classiques aux réseaux de neurones profonds — et a pris en charge l’optimisation de bas niveau pour l’appareil spécifique.

Historique du développement

La première version de Core ML (2017) ne prenait en charge que les modèles statiques avec des tailles d’entrée fixes. Core ML 2 (2018) a ajouté la prise en charge de la prédiction par lots et des mises à jour de modèles en temps réel. Core ML 3 (2019) a apporté l’entraînement sur l’appareil et la prise en charge de dizaines de nouvelles couches de réseaux de neurones. Core ML 4 (2021) a introduit la prise en charge des modèles à sorties multiples et un traitement d’image amélioré. Core ML 5 (2024) a ajouté la prise en charge des réseaux de neurones dynamiques et de l’apprentissage supervisé sur l’appareil utilisant de nouvelles couches ML.

ML sur lappareil : avantages

Exécuter l’apprentissage automatique sur l’appareil offre trois avantages clés : confidentialité — les données ne quittent jamais l’appareil (répondant aux exigences du RGPD et de la HIPAA), vitesse — l’inférence est effectuée en millisecondes sans latence réseau, disponibilité hors ligne — le modèle fonctionne sans connexion Internet. Selon le Apple Privacy Report (2025), plus de 90 % des inférences ML sur les plateformes Apple sont effectuées sur l’appareil grâce à Core ML.

Architecture de Core ML et backends de calcul

L’architecture de Core ML est basée sur un principe multicouche : au niveau supérieur — l’API développeur (MLModel, MLFeatureProvider, MLPredictionOptions), au niveau intermédiaire — le modèle au format .mlpackage, au niveau inférieur — les backends de calcul : Apple Neural Engine (ANE), GPU (Metal Shaders) et CPU (BNNS, Accelerate framework). Core ML sélectionne automatiquement le meilleur backend en fonction du modèle et du matériel de l’appareil.

Apple Neural Engine

Neural Engine (ANE) est un processeur neuronal spécialisé intégré aux puces Apple A12+ et M1+. ANE est optimisé pour les opérations de réseaux de neurones convolutifs (CNN) et les multiplicateurs de matrices avec des performances allant jusqu’à 15,8 TOPS sur A17 Pro et 38 TOPS sur M4. Core ML détermine automatiquement si le modèle peut s’exécuter sur ANE et, si c’est le cas, l’y charge. Si le modèle contient des opérations non prises en charge par ANE, Core ML répartit le calcul entre le GPU et le CPU.

Metal Performance Shaders

Pour les calculs sur GPU, Core ML utilise Metal Performance Shaders Graph (MPSGraph), un framework pour construire et exécuter des graphes de calcul sur GPU. MPSGraph prend le graphe du réseau de neurones de Core ML et le compile en Metal Shaders optimisés pour l’architecture GPU spécifique (GPU A17 7 cœurs ou GPU M4 Ultra 40 cœurs). Les optimisations automatiques de MPSGraph incluent la fusion de couches, l’élimination des opérations redondantes et la sélection du format de données optimal.

Types de modèles et formats pris en charge

Core ML prend en charge tous les principaux types de modèles d’apprentissage automatique, divisés en trois catégories : réseaux de neurones (CNN convolutifs, RNN/LSTM récurrents, transformeurs), modèles d’ensemble (Random Forest, Gradient Boosting, XGBoost, arbres de décision) et modèles de régression (régression linéaire, SVM, CRF). Chaque type de modèle a son propre sous-protocole MLModelType, et Core ML sélectionne automatiquement le backend et le format d’exécution appropriés.

Couches de réseaux de neurones prises en charge

Core ML prend en charge plus de 150 types de couches de réseaux de neurones : Convolution (1D/2D/3D), BatchNormalization, Pooling (Max/Average), Activation (ReLU, Sigmoid, Tanh, LeakyReLU, PReLU), Récurrentes (LSTM/GRU/SimpleRNN), Transformeurs (MultiHeadAttention, LayerNorm), couches spécifiques à Metal. Pour les couches non prises en charge, Core ML fournit un mécanisme de couche personnalisée — la possibilité d’écrire une implémentation de couche en Metal Shading Language ou Swift.

let model = try MLModel(contentsOf: modelURL)
let input = try MLMultiArray(shape: [1, 224, 224, 3], dataType: .float32)
let prediction = try model.prediction(from: input)

Formats de fichier de modèle

Avant 2021, Core ML utilisait le format .mlmodel — un fichier binaire contenant tous les poids et métadonnées du modèle. À partir de Xcode 13 et Core ML 4, Apple a introduit le nouveau format .mlpackage — une structure de paquet basée sur un répertoire contenant le modèle, les métadonnées, les descriptions d’entrées/sorties et les fichiers de pré et post-traitement en JSON. mlpackage prend en charge le versionnement git, ce qui simplifie le développement en équipe. La conversion de .mlmodel vers .mlpackage s’effectue à l’aide de l’utilitaire Xcode Model Compiler ou du script coremltools en Python.

Conversion de modèles vers Core ML

La conversion de modèles à partir de frameworks tiers vers Core ML est effectuée à l’aide de la bibliothèque coremltools en Python. coremltools prend en charge l’import de modèles depuis TensorFlow 1.x/2.x (SavedModel, PB, HDF5), PyTorch (TorchScript, modèles tracés/scriptés), Keras (H5), ONNX et ceux créés avec Create ML. Le pipeline de conversion standard comprend trois étapes : chargement du modèle dans son format original, conversion en MIL (Model Intermediate Language) — la représentation interne de Core ML — et exportation vers .mlpackage.

import coremltools as ct

model = ct.converters.pytorch.convert(
    source = "model.pt",
    inputs = [ct.TensorType(shape=(1, 3, 224, 224))]
)
model.author = "IT Sectr"
model.short_description = "Image classifier"
model.save("MyModel.mlpackage")

Vérification du modèle après conversion

Après la conversion, vous devez vérifier la précision du modèle en comparant les prédictions du modèle original et du modèle Core ML converti sur les mêmes données. L’écart acceptable n’excède pas 1e-3 (0,1 %) pour Float32 et 1e-2 (1 %) pour Float16/Int8. coremltools fournit l’utilitaire ct.utils.compare_models() pour la comparaison automatique. Si l’écart dépasse la norme, il peut y avoir un problème avec des opérations non prises en charge — elles doivent être remplacées par des couches personnalisées ou le modèle simplifié.

Optimisation des performances de Core ML

L’optimisation d’un modèle Core ML est le processus de réduction de la taille du modèle et d’augmentation de la vitesse d’inférence sans perte significative de précision. Apple fournit plusieurs outils d’optimisation intégrés dans coremltools et Xcode : quantification (réduction de la précision des poids), élagage (suppression des neurones insignifiants), suppression des couches redondantes et fusion de couches pour réduire le graphe de calcul.

Quantification en Float16 et Int8

La quantification réduit la taille du modèle d’environ 2 fois (Float16) ou 4 fois (Int8) par rapport à Float32. Core ML prend en charge trois modes de quantification : la quantification post-entraînement (PTQ) avec un ensemble de données de calibrage, pendant la conversion via coremltools et l’entraînement conscient de la quantification (QAT). Pour la plupart des modèles de vision par ordinateur, la PTQ en Float16 entraîne une perte de précision inférieure à 0,5 % tout en doublant la vitesse d’inférence.

Profilage du modèle dans Xcode

Xcode fournit l’outil Core ML Model Profiler, permettant de mesurer les performances du modèle sur différents appareils dans le simulateur ou sur un appareil réel. Le profileur montre le temps d’exécution de chaque couche, la charge du backend (ANE/GPU/CPU), l’utilisation maximale de la mémoire et les goulots d’étranglement du modèle. Selon le Apple Performance Optimization Guide, plus de 80 % des modèles ont au moins une couche qui fonctionne significativement plus lentement que les autres (anomalie de couche), qui peut être optimisée par remplacement ou fusion.

Exemple pratique dintégration de Core ML

Examinons l’intégration d’un modèle Core ML entraîné dans une application iOS avec Swift. Après avoir ajouté le fichier .mlpackage au projet Xcode (par glisser-déposer ou via Swift Package Manager), Xcode génère automatiquement une classe de modèle Swift avec des entrées et sorties typées. Le développeur n’a pas besoin d’analyser manuellement les données d’entrée — la classe générée accepte UIImage, MLMultiArray, String ou d’autres types selon les métadonnées du modèle.

import CoreML
import Vision

guard let model = try? VNCoreMLModel(
    for: MyImageClassifier().model
) else { return }

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

    if let topResult = results.first {
        print("Class: \(topResult.identifier)")
        print("Confidence: \(topResult.confidence)")
    }
}

let handler = VNImageRequestHandler(
    cgImage: image.cgImage!,
    options: [:]
)
try handler.perform([request])

Gestion des erreurs et repli

Lors de l’intégration de Core ML, vous devez implémenter la gestion des erreurs : le modèle peut ne pas se charger en raison d’une incompatibilité de l’appareil (version iOS trop ancienne), d’une mémoire insuffisante ou d’une corruption du fichier du modèle. Il est recommandé d’implémenter une logique de repli : si le modèle ne se charge pas au format Int8 quantifié, chargez la version Float16, et si celle-ci échoue également — Float32. Selon Apple Crash Analytics, plus de 5 % des plantages d’applications ML sont causés par un chargement incorrect du modèle.

Core ML vs Create ML : différences

Core ML et Create ML sont deux outils complémentaires de l’écosystème Apple ML. Core ML gère l’exécution des modèles sur l’appareil (inférence), tandis que Create ML gère l’entraînement des modèles. Les modèles créés dans Create ML sont exportés spécifiquement au format Core ML (.mlpackage) pour une intégration ultérieure dans les applications. En termes de développement web, Core ML est le navigateur (exécution) et Create ML est l’IDE pour écrire du code (entraînement).