Conversion de modèles Core ML : qu’est-ce que c’est, étapes et méthodes de conversion

Qu’est-ce que Core ML Model Conversion

Core ML Model Conversion est le processus de transformation d’un modèle de machine learning entraîné du format du framework source vers le format .mlmodel compris par Core ML Runtime sur les appareils Apple. Sans conversion, un modèle entraîné dans PyTorch ou TensorFlow ne peut pas être chargé et exécuté directement sur iOS ou macOS.

Le processus de conversion comprend la traduction du graphe de calcul : chaque opérateur du framework source (Conv2D, BatchNorm, ReLU) est mappé à l’opérateur Core ML correspondant. Si aucun remplacement direct n’existe, coremltools utilise des opérations composites ou des couches personnalisées. Selon Apple ML Research, la bibliothèque couvre plus de 200 opérateurs provenant de divers frameworks.

Après conversion, le modèle est enregistré au format bundle .mlmodel, qui comprend une description du graphe en protobuf, des poids sous forme binaire et des métadonnées. Ce fichier est ensuite compilé en mlmodelc pour exécution sur l’appareil cible.

Frameworks et formats pris en charge

coremltools version 7.x prend en charge la conversion depuis six sources. PyTorch — via torch.jit.trace ou torch.export, TensorFlow 2.x — via SavedModel et Keras H5, TensorFlow 1.x — via graphe gelé .pb. Pour ONNX, une représentation intermédiaire est utilisée, puis traduite en Core ML.

Matrice de compatibilité des frameworks

Outils de conversion : coremltools

coremltools est la bibliothèque Python open source officielle d’Apple, disponible via pip install coremltools. La bibliothèque fournit une API unifiée pour la conversion depuis tous les frameworks pris en charge, ainsi que des outils de post-traitement : quantification, vérification de précision et visualisation de graphe.

Installation et conversion de base d’un modèle depuis PyTorch :

import coremltools as ct
import torch
import torchvision

model = torchvision.models.resnet18(pretrained=True)
model.eval()

example_input = torch.rand(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

mlmodel = ct.convert(
    traced_model,
    source="pytorch",
    inputs=[ct.ImageType(shape=example_input.shape)]
)
mlmodel.save("ResNet18.mlmodel")

Pour la conversion depuis TensorFlow, utilisez SavedModel comme source. coremltools détermine automatiquement les tenseurs d’entrée et de sortie selon signature_def :

import coremltools as ct

mlmodel = ct.convert(
    "saved_model_dir",
    source="tensorflow",
    @minimum_deployment_target=ct.target.iOS16
)
mlmodel.save("MyTFModel.mlmodel")

Étapes de conversion du modèle

Le processus de conversion comprend quatre étapes. Dans la première étape, coremltools charge le modèle source et effectue le traçage (tracing) ou l’analyse du graphe. Pour PyTorch, torch.jit.trace est utilisé, qui exécute une entrée échantillon à travers le modèle et enregistre la séquence des opérations.

Dans la deuxième étape, le mappage des opérateurs est effectué. Chaque opérateur du graphe source est mappé à un opérateur Core ML. Si aucun remplacement direct n’existe, coremltools divise l’opérateur en une séquence d’opérateurs pris en charge. Selon la documentation coremltools, la couverture des opérateurs PyTorch dépasse 95% pour les architectures typiques.

La troisième étape est l’optimisation du graphe. coremltools effectue la fusion d’opérations (par exemple, conv + batch norm), la suppression des transformations inutiles et le réordonnancement des opérateurs pour améliorer l’efficacité. La quatrième étape est la sérialisation au format .mlmodel avec préservation des poids et des métadonnées.

Problèmes courants et leurs solutions

Le problème le plus fréquent lors de la conversion est celui des opérations non prises en charge. Si le modèle contient un opérateur absent dans Core ML, coremltools signale une erreur avec le nom de l’opération. La solution consiste à remplacer l’opérateur par une combinaison équivalente d’opérateurs pris en charge ou à implémenter une couche personnalisée via l’API de couches personnalisées.

Le deuxième problème est la discordance de dimensions. PyTorch utilise le format NCHW, tandis que Core ML utilise NHWC par défaut. coremltools insère automatiquement la transposition, mais parfois l’ordre des axes est déterminé incorrectement. Vérifiez les dimensions d’entrée et de sortie dans les journaux de conversion et, si nécessaire, spécifiez input_features avec les noms corrects.

Le troisième problème est la perte de précision après quantification. Lors de la conversion avec une palette FP16 ou INT8, la précision du modèle peut diminuer. coremltools fournit l’utilitaire ct.models.CompiledModel pour comparer les sorties du modèle source et du modèle converti sur les mêmes données d’entrée. Si l’écart dépasse 1%, utilisez la quantification avec palette FP16 sans calibration ou évitez complètement la quantification.

Exemples de conversion depuis PyTorch et TensorFlow

Un exemple de conversion du modèle MobileNetV3 depuis PyTorch avec spécification du type d’entrée et version minimale iOS. Utilisez ct.ImageType pour la normalisation automatique des images :

import coremltools as ct
import torchvision

model = torchvision.models.mobilenet_v3_small(
    pretrained=True
)
model.eval()
example = torch.rand(1, 3, 224, 224)
traced = torch.jit.trace(model, example)

mlmodel = ct.convert(
    traced,
    source="pytorch",
    inputs=[ct.ImageType(
        shape=example.shape,
        scale=1.0/255.0,
        bias=[0, 0, 0]
    )],
    @minimum_deployment_target=ct.target.iOS16
)

# Sauvegarder en .mlmodel pour compilation ultérieure dans Xcode
mlmodel.save("MobileNetV3.mlmodel")

Un exemple de conversion depuis TensorFlow Keras avec quantification FP16. Spécifiez minimum_deployment_target pour activer la prise en charge FP16 sur les appareils avec Apple A13 et plus récents :

import coremltools as ct
from tensorflow import keras

keras_model = keras.applications.EfficientNetB0(
    weights="imagenet"
)

mlmodel = ct.convert(
    keras_model,
    source="tensorflow",
    @minimum_deployment_target=ct.target.iOS17
)

# Quantifier les poids en FP16 pour une réduction de taille 2x
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")