mlmodelc: formato di modello compilato e compilazione

Cos'è mlmodelc e in cosa differisce da .mlmodel

mlmodelc è un formato di modello Core ML binario compilato, progettato per l'esecuzione diretta su dispositivi Apple. Il formato originale .mlmodel è un pacchetto contenente una descrizione del modello in protobuf, i pesi come array e metadati in JSON. Durante la compilazione, questa struttura viene trasformata in una rappresentazione binaria compatta ottimizzata per la piattaforma hardware specifica.

La differenza chiave di mlmodelc è l'assenza di una fase di interpretazione durante l'inferenza. Core ML Runtime non analizza lo schema protobuf né costruisce il grafo di computazione dinamicamente — tutti questi passaggi vengono eseguiti al momento della compilazione. Ciò migliora il tempo di primo caricamento del modello dal 30% al 60% a seconda della complessità dell'architettura.

Secondo la sessione WWDC 2023 “Core ML Tools e Ottimizzazione dei Modelli”, la compilazione include l'ottimizzazione delle operazioni in virgola mobile, la fusione di livelli consecutivi e la conversione in un formato comprensibile da Apple Neural Engine. Lo sviluppatore non deve gestire questo processo manualmente — Xcode esegue la compilazione automaticamente al momento della build.

Confronto tra mlmodelc e .mlmodel

Come funziona il processo di compilazione di mlmodelc

La compilazione del modello in mlmodelc attraversa tre fasi. Nella prima fase, Core ML Tools legge la specifica protobuf del .mlmodel e costruisce un grafo di computazione interno nel formato MIL (Model Intermediate Language). Lo strumento verifica la compatibilità di ogni operazione con il dispositivo di destinazione e segna i livelli non supportati per l'esecuzione su CPU.

Nella seconda fase viene eseguita l'ottimizzazione del grafo: fusione di livelli consecutivi (convoluzione + batch norm → convoluzione fusa), rimozione di nodi morti e quantizzazione dei pesi da FP32 a FP16 o INT8. Secondo il rapporto di ingegneria Apple “Core ML Optimization Pipeline” (2024), la fusione dei livelli riduce il numero di operazioni di inferenza fino al 40%.

La terza fase è la generazione della rappresentazione binaria. Il grafo ottimizzato viene serializzato nel formato proprietario Core ML Runtime. I pesi vengono salvati allineati alle linee di cache della CPU e i metadati vengono memorizzati in un indice separato per un accesso rapido. Il risultato è una cartella con estensione .mlmodelc, pronta per essere inclusa nel bundle dell'applicazione.

Architettura interna di mlmodelc

La struttura di mlmodelc include tre componenti chiave. Model Description contiene i metadati del modello: tipi di input e output, loro dimensioni, nomi dei tensori e parametri di pre-elaborazione. Questa sezione è memorizzata in un formato simile a JSON per la compatibilità con l'API Core ML.

Program è la rappresentazione binaria del grafo di computazione nel linguaggio interno MIL. Apple utilizza MIL come rappresentazione intermedia analoga a MLIR in TensorFlow o ONNX. Un programma MIL consiste in operazioni, ciascuna con un tipo, tensori di input e output e attributi. Il formato MIL è ottimizzato per un'esecuzione efficiente su Apple Neural Engine.

Il terzo componente è weights.bin — un file contenente tutti i pesi addestrati del modello. I pesi vengono salvati allineati a 64 byte per un caricamento ottimale nella cache. Se viene specificata la quantizzazione durante la compilazione, i pesi vengono salvati in FP16 o INT8, riducendo le dimensioni del file e accelerando l'inferenza sui chip Apple A17 e M4 con supporto hardware per questi formati.

Modalità di distribuzione di mlmodelc in un'applicazione

Apple supporta tre modalità per includere mlmodelc in un'applicazione. La prima è l'inclusione statica nel bundle: il file mlmodelc viene aggiunto al progetto Xcode e finisce nel .app durante la build. Questo approccio è ottimale per modelli piccoli fino a 100 MB e non richiede accesso alla rete per il primo avvio.

La seconda modalità è il download dalla rete con compilazione sul dispositivo tramite MLModel.compile(at:). Lo sviluppatore scarica il .mlmodel, lo inserisce in una directory temporanea e chiama il compilatore Core ML. Il risultato è un mlmodelc che può essere memorizzato nella cache per avvii successivi. Secondo le HIG Apple per Core ML, questo approccio è raccomandato per modelli superiori a 100 MB e per aggiornamenti dinamici senza pubblicare una nuova versione dell'app.

La terza modalità sono le Risorse su Richiesta (On-Demand Resources) per modelli scaricati al bisogno. L'ODR di Apple consente di archiviare mlmodelc nel cloud e scaricarlo solo quando necessario. Questo è uno scenario comune per applicazioni con decine di modelli in cui l'utente ne utilizza solo alcuni.

Compilazione asincrona sul dispositivo

Quando si scarica un modello dalla rete, è importante considerare il tempo di compilazione. MLModel.compile(at:) viene eseguito in modo sincrono e può bloccare l'interfaccia utente su dispositivi con A12 e precedenti fino a 5–10 secondi per modelli di medie dimensioni. Si consiglia di eseguire la compilazione in un thread in background e di informare l'utente sull'avanzamento tramite un indicatore di caricamento.

Vantaggi prestazionali di mlmodelc

Il principale vantaggio di mlmodelc è la velocità di caricamento del modello. Secondo i Benchmark delle Prestazioni Apple (2024), un modello ResNet-50 da 100 MB si carica il 58% più velocemente in formato mlmodelc rispetto a .mlmodel. Ciò è particolarmente importante per applicazioni che lavorano con più modelli in sequenza.

Il secondo vantaggio è la riduzione del consumo di memoria di picco. Durante il caricamento di .mlmodel, Core ML Runtime alloca un buffer per analizzare protobuf e un secondo buffer per la compilazione del grafo. mlmodelc si avvia direttamente, saltando queste fasi. Il consumo di memoria di picco si riduce del 30–45% per i modelli di visione artificiale.

Il terzo è l'ottimizzazione hardware. Il compilatore coremlc analizza il dispositivo di destinazione al momento della build e seleziona la ripartizione ottimale delle operazioni tra ANE, GPU e CPU. Se la build è universale, la compilazione viene rinviata al dispositivo al primo avvio e il risultato viene memorizzato nella cache per le sessioni successive.

Esempi di codice per lavorare con mlmodelc in Swift

Esempio di caricamento di un modello compilato dal bundle dell'applicazione. Basta specificare l'URL del modello e chiamare MLModel.load(contentsOf:). Core ML Runtime rileverà automaticamente il formato mlmodelc dall'estensione ed eseguirà l'inizializzazione.

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)

Esempio di compilazione di un .mlmodel sul dispositivo con successiva memorizzazione nella cache. Utilizzare MLModel.compile(at:) per ottenere il percorso temporaneo verso mlmodelc, quindi copiarlo nella directory della 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)