mlmodelc : qu'est-ce que c'est, format de modèle compilé et compilation

Qu'est-ce que mlmodelc et en quoi diffère-t-il de .mlmodel

mlmodelc est un format de modèle Core ML binaire compilé, conçu pour une exécution directe sur les appareils Apple. Le format d'origine .mlmodel est un package contenant une description du modèle en protobuf, les poids sous forme de tableaux et des métadonnées en JSON. Lors de la compilation, cette structure est transformée en une représentation binaire compacte optimisée pour la plateforme matérielle spécifique.

La différence clé de mlmodelc est l'absence d'étape d'interprétation pendant l'inférence. Core ML Runtime n'analyse pas le schéma protobuf ni ne construit le graphe de calcul dynamiquement — toutes ces étapes sont effectuées au moment de la compilation. Cela améliore le temps de premier chargement du modèle de 30 % à 60 % selon la complexité de l'architecture.

Selon la session WWDC 2023 « Core ML Tools et optimisation des modèles », la compilation inclut l'optimisation des opérations en virgule flottante, la fusion de couches consécutives et la conversion vers un format compréhensible par Apple Neural Engine. Le développeur n'a pas besoin de gérer ce processus manuellement — Xcode effectue la compilation automatiquement au moment de la construction.

Comparaison de mlmodelc et .mlmodel

Comment fonctionne le processus de compilation de mlmodelc

La compilation du modèle en mlmodelc passe par trois étapes. Dans la première étape, Core ML Tools lit la spécification protobuf du .mlmodel et construit un graphe de calcul interne au format MIL (Model Intermediate Language). L'outil vérifie la compatibilité de chaque opération avec l'appareil cible et marque les couches non prises en charge pour l'exécution sur CPU.

Dans la deuxième étape, l'optimisation du graphe est effectuée : fusion de couches consécutives (convolution + batch norm → convolution fusionnée), suppression des nœuds morts et quantification des poids de FP32 à FP16 ou INT8. Selon le rapport d'ingénierie Apple « Core ML Optimization Pipeline » (2024), la fusion de couches réduit le nombre d'opérations d'inférence jusqu'à 40 %.

La troisième étape est la génération de la représentation binaire. Le graphe optimisé est sérialisé dans le format propriétaire Core ML Runtime. Les poids sont sauvegardés alignés sur les lignes de cache du CPU, et les métadonnées sont stockées dans un index séparé pour un accès rapide. Le résultat est un dossier avec l'extension .mlmodelc, prêt à être inclus dans le bundle de l'application.

Architecture interne de mlmodelc

La structure de mlmodelc comprend trois composants clés. Model Description contient les métadonnées du modèle : types d'entrée et de sortie, leurs dimensions, noms des tenseurs et paramètres de prétraitement. Cette section est stockée dans un format similaire au JSON pour la compatibilité avec l'API Core ML.

Program est la représentation binaire du graphe de calcul dans le langage interne MIL. Apple utilise MIL comme représentation intermédiaire analogue à MLIR dans TensorFlow ou ONNX. Un programme MIL se compose d'opérations, chacune ayant un type, des tenseurs d'entrée et de sortie et des attributs. Le format MIL est optimisé pour une exécution efficace sur Apple Neural Engine.

Le troisième composant est weights.bin — un fichier contenant tous les poids entraînés du modèle. Les poids sont stockés alignés sur 64 octets pour un chargement optimal dans le cache. Si une quantification est spécifiée lors de la compilation, les poids sont sauvegardés en FP16 ou INT8, ce qui réduit la taille du fichier et accélère l'inférence sur les puces Apple A17 et M4 avec prise en charge matérielle de ces formats.

Moyens de déployer mlmodelc dans une application

Apple prend en charge trois façons d'inclure mlmodelc dans une application. La première est l'inclusion statique dans le bundle : le fichier mlmodelc est ajouté au projet Xcode et se retrouve dans le .app lors de la construction. Cette approche est optimale pour les petits modèles jusqu'à 100 Mo et ne nécessite pas d'accès réseau pour le premier démarrage.

La deuxième façon est le téléchargement depuis le réseau avec compilation sur l'appareil via MLModel.compile(at:). Le développeur télécharge le .mlmodel, le place dans un répertoire temporaire et appelle le compilateur Core ML. Le résultat est un mlmodelc qui peut être mis en cache pour les lancements ultérieurs. Selon les HIG Apple pour Core ML, cette approche est recommandée pour les modèles de plus de 100 Mo et pour les mises à jour dynamiques sans publier une nouvelle version de l'application.

La troisième façon est les Ressources à la Demande (On-Demand Resources) pour les modèles téléchargés selon les besoins. L'ODR d'Apple permet de stocker mlmodelc dans le cloud et de le télécharger uniquement lorsque nécessaire. C'est un scénario courant pour les applications avec des dizaines de modèles où l'utilisateur n'en utilise que quelques-uns.

Compilation asynchrone sur l'appareil

Lors du téléchargement d'un modèle depuis le réseau, il est important de prendre en compte le temps de compilation. MLModel.compile(at:) s'exécute de manière synchrone et peut bloquer l'interface utilisateur sur les appareils avec A12 et plus anciens jusqu'à 5 à 10 secondes pour les modèles de taille moyenne. Il est recommandé d'effectuer la compilation dans un thread d'arrière-plan et d'informer l'utilisateur de la progression via un indicateur de chargement.

Avantages en termes de performances de mlmodelc

Le principal avantage de mlmodelc est la vitesse de chargement du modèle. Selon les Benchmarks de Performance Apple (2024), un modèle ResNet-50 de 100 Mo se charge 58 % plus rapidement au format mlmodelc par rapport au .mlmodel. Ceci est particulièrement important pour les applications travaillant avec plusieurs modèles séquentiellement.

Le deuxième avantage est la réduction de la consommation mémoire de pointe. Lors du chargement de .mlmodel, Core ML Runtime alloue un tampon pour analyser protobuf et un second tampon pour la compilation du graphe. mlmodelc démarre directement, contournant ces étapes. La consommation mémoire de pointe est réduite de 30 à 45 % pour les modèles de vision par ordinateur.

Le troisième est l'optimisation matérielle. Le compilateur coremlc analyse l'appareil cible au moment de la compilation et sélectionne la répartition optimale des opérations entre ANE, GPU et CPU. Si la compilation est universelle, la compilation est différée sur l'appareil au premier démarrage et le résultat est mis en cache pour les sessions suivantes.

Exemples de code pour travailler avec mlmodelc en Swift

Exemple de chargement d'un modèle compilé depuis le bundle de l'application. Il suffit de spécifier l'URL du modèle et d'appeler MLModel.load(contentsOf:). Core ML Runtime détectera automatiquement le format mlmodelc par l'extension et effectuera l'initialisation.

import CoreML

guard let modelURL = Bundle.main.url(
    forResource: "MyModel",
    withExtension: "mlmodelc"
) else { return }

let model = try await MLModel.load(contentsOf: modelURL)
let prediction = try await model.prediction(from: input)

Exemple de compilation d'un .mlmodel sur l'appareil avec mise en cache ultérieure. Utilisez MLModel.compile(at:) pour obtenir le chemin temporaire vers mlmodelc, puis copiez-le dans le répertoire de cache.

let sourceURL = FileManager.default.temporaryDirectory
    .appendingPathComponent("MyModel.mlmodel")

let compiledURL = try await MLModel.compile(at: sourceURL)

let cacheURL = FileManager.default.urls(
    for: .cachesDirectory, in: .userDomainMask
)[0].appendingPathComponent("MyModel.mlmodelc")

try FileManager.default.copyItem(at: compiledURL, to: cacheURL)