Conversione di modelli Core ML: cos'è, fasi e metodi di conversione

Cos'è Core ML Model Conversion

Core ML Model Conversion è il processo di trasformazione di un modello di machine learning addestrato dal formato del framework di origine nel formato .mlmodel compreso da Core ML Runtime sui dispositivi Apple. Senza conversione, un modello addestrato in PyTorch o TensorFlow non può essere caricato ed eseguito direttamente su iOS o macOS.

Il processo di conversione include la traduzione del grafo di calcolo: ogni operatore del framework di origine (Conv2D, BatchNorm, ReLU) viene mappato all'operatore Core ML corrispondente. Se non esiste una sostituzione diretta, coremltools utilizza operazioni composte o layer personalizzati. Secondo Apple ML Research, la libreria copre oltre 200 operatori provenienti da vari framework.

Dopo la conversione, il modello viene salvato nel formato bundle .mlmodel, che include una descrizione del grafo in protobuf, pesi in forma binaria e metadati. Questo file viene poi compilato in mlmodelc per l'esecuzione sul dispositivo di destinazione.

Framework e formati supportati

coremltools versione 7.x supporta la conversione da sei fonti. PyTorch — tramite torch.jit.trace o torch.export, TensorFlow 2.x — tramite SavedModel e Keras H5, TensorFlow 1.x — tramite grafo congelato .pb. Per ONNX viene utilizzata una rappresentazione intermedia, che viene poi tradotta in Core ML.

Matrice di compatibilità dei framework

Strumenti di conversione: coremltools

coremltools è la libreria Python open source ufficiale di Apple, disponibile tramite pip install coremltools. La libreria fornisce un'API unificata per la conversione da tutti i framework supportati, oltre a strumenti di post-elaborazione: quantizzazione, controllo della precisione e visualizzazione del grafo.

Installazione e conversione base del modello da 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")

Per la conversione da TensorFlow, utilizzare SavedModel come origine. coremltools determina automaticamente i tensori di input e output in base a signature_def:

import coremltools as ct

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

Fasi della conversione del modello

Il processo di conversione consiste in quattro fasi. Nella prima fase, coremltools carica il modello sorgente ed esegue il tracciamento (tracing) o la scansione del grafo. Per PyTorch viene utilizzato torch.jit.trace, che esegue un input campione attraverso il modello e registra la sequenza delle operazioni.

Nella seconda fase viene eseguito il mapping degli operatori. Ogni operatore del grafo sorgente viene mappato a un operatore Core ML. Se non esiste una sostituzione diretta, coremltools suddivide l'operatore in una sequenza di operatori supportati. Secondo la documentazione di coremltools, la copertura degli operatori PyTorch supera il 95% per le architetture tipiche.

La terza fase è l'ottimizzazione del grafo. coremltools esegue la fusione delle operazioni (ad esempio, conv + batch norm), la rimozione di trasformazioni non necessarie e il riordinamento degli operatori per migliorare l'efficienza. La quarta fase è la serializzazione nel formato .mlmodel con conservazione di pesi e metadati.

Problemi comuni e relative soluzioni

Il problema più frequente nella conversione sono le operazioni non supportate. Se il modello contiene un operatore assente in Core ML, coremltools segnala un errore con il nome dell'operazione. La soluzione è sostituire l'operatore con una combinazione equivalente di operatori supportati o implementare un layer personalizzato tramite l'API dei layer personalizzati.

Il secondo problema è la discrepanza dimensionale. PyTorch utilizza il formato NCHW, mentre Core ML utilizza NHWC per impostazione predefinita. coremltools inserisce automaticamente la trasposizione, ma a volte l'ordine degli assi viene determinato in modo errato. Controllare le dimensioni di input e output nei log di conversione e, se necessario, specificare input_features con i nomi corretti.

Il terzo problema è la perdita di precisione dopo la quantizzazione. Quando si converte con tavolozza FP16 o INT8, la precisione del modello può diminuire. coremltools fornisce l'utility ct.models.CompiledModel per confrontare gli output del modello originale e convertito sugli stessi dati di input. Se la discrepanza supera l'1%, utilizzare la quantizzazione con tavolozza FP16 senza calibrazione o evitare del tutto la quantizzazione.

Esempi di conversione da PyTorch e TensorFlow

Un esempio di conversione del modello MobileNetV3 da PyTorch con specifica del tipo di input e versione minima iOS. Utilizzare ct.ImageType per la normalizzazione automatica delle immagini:

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
)

# Salvare in .mlmodel per la successiva compilazione in Xcode
mlmodel.save("MobileNetV3.mlmodel")

Un esempio di conversione da TensorFlow Keras con quantizzazione FP16. Specificare minimum_deployment_target per abilitare il supporto FP16 sui dispositivi con Apple A13 e successivi:

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
)

# Quantizzare i pesi in FP16 per una riduzione delle dimensioni di 2x
mlmodel_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    mlmodel, 16
)
mlmodel_fp16.save("EfficientNetB0_fp16.mlmodel")