Core ML: architettura del framework e integrazione dei modelli

Cos’è Core ML?

Core ML è un componente chiave dell’ecosistema di machine learning di Apple, presentato al WWDC 2017. Prima di Core ML, gli sviluppatori iOS utilizzavano librerie di terze parti (TensorFlow Mobile, Caffe2) o soluzioni personalizzate per eseguire modelli ML sul dispositivo. Core ML ha fornito un’interfaccia unificata singola per tutti i tipi di modello — dalle regressioni classiche alle reti neurali profonde — e ha assunto l’ottimizzazione di basso livello per il dispositivo specifico.

Storia dello sviluppo

La prima versione di Core ML (2017) supportava solo modelli statici con dimensioni di input fisse. Core ML 2 (2018) ha aggiunto il supporto per la predizione batch e gli aggiornamenti dei modelli in tempo reale. Core ML 3 (2019) ha portato l’addestramento sul dispositivo e il supporto per decine di nuovi layer di reti neurali. Core ML 4 (2021) ha introdotto il supporto per modelli con output multipli e l’elaborazione delle immagini migliorata. Core ML 5 (2024) ha aggiunto il supporto per reti neurali dinamiche e apprendimento supervisionato sul dispositivo utilizzando nuovi layer ML.

ML sul dispositivo: vantaggi

Eseguire il machine learning sul dispositivo offre tre vantaggi principali: privacy — i dati non lasciano mai il dispositivo (soddisfacendo i requisiti GDPR e HIPAA), velocità — l’inferenza viene completata in millisecondi senza latenza di rete, disponibilità offline — il modello funziona senza connessione Internet. Secondo Apple Privacy Report (2025), oltre il 90% delle inferenze ML sulle piattaforme Apple viene eseguito sul dispositivo grazie a Core ML.

Architettura di Core ML e backend di calcolo

L’architettura di Core ML è basata su un principio multistrato: al livello superiore — l’API sviluppatore (MLModel, MLFeatureProvider, MLPredictionOptions), al livello intermedio — il modello in formato .mlpackage, al livello inferiore — i backend di calcolo: Apple Neural Engine (ANE), GPU (Metal Shaders) e CPU (BNNS, Accelerate framework). Core ML seleziona automaticamente il backend migliore in base al modello e all’hardware del dispositivo.

Apple Neural Engine

Neural Engine (ANE) è un neuroprocessore specializzato integrato nei chip Apple A12+ e M1+. ANE è ottimizzato per operazioni di reti neurali convoluzionali (CNN) e moltiplicatori di matrici con prestazioni fino a 15.8 TOPS su A17 Pro e 38 TOPS su M4. Core ML determina automaticamente se il modello può essere eseguito su ANE e, in caso affermativo, lo carica lì. Se il modello contiene operazioni non supportate da ANE, Core ML distribuisce il calcolo tra GPU e CPU.

Metal Performance Shaders

Per i calcoli su GPU, Core ML utilizza Metal Performance Shaders Graph (MPSGraph), un framework per costruire ed eseguire grafi computazionali sulla GPU. MPSGraph prende il grafo della rete neurale da Core ML e lo compila in Metal Shaders ottimizzati per l’architettura GPU specifica (GPU A17 a 7 core o GPU M4 Ultra a 40 core). Le ottimizzazioni automatiche di MPSGraph includono la fusione dei layer, l’eliminazione delle operazioni ridondanti e la selezione del formato di dati ottimale.

Tipi di modelli e formati supportati

Core ML supporta tutti i principali tipi di modelli di machine learning, divisi in tre categorie: reti neurali (CNN convoluzionali, RNN/LSTM ricorrenti, trasformatori), modelli ensemble (Random Forest, Gradient Boosting, XGBoost, Alberi Decisionali) e modelli di regressione (regressione lineare, SVM, CRF). Ogni tipo di modello ha il proprio sottoprotocollo MLModelType e Core ML seleziona automaticamente il backend e il formato di esecuzione appropriati.

Layer di reti neurali supportati

Core ML supporta oltre 150 tipi di layer di reti neurali: Convoluzione (1D/2D/3D), BatchNormalization, Pooling (Max/Average), Attivazione (ReLU, Sigmoid, Tanh, LeakyReLU, PReLU), Ricorrenti (LSTM/GRU/SimpleRNN), Trasformatori (MultiHeadAttention, LayerNorm), layer specifici di Metal. Per i layer non supportati, Core ML fornisce un meccanismo di layer personalizzato — la possibilità di scrivere un’implementazione di layer in Metal Shading Language o 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)

Formati di file del modello

Prima del 2021, Core ML utilizzava il formato .mlmodel — un file binario contenente tutti i pesi e i metadati del modello. A partire da Xcode 13 e Core ML 4, Apple ha introdotto il nuovo formato .mlpackage — una struttura a pacchetto basata su directory contenente il modello, i metadati, le descrizioni di input/output e i file di pre e post-elaborazione in JSON. mlpackage supporta il versionamento git, semplificando lo sviluppo di squadra. La conversione da .mlmodel a .mlpackage viene eseguita con l’utilità Xcode Model Compiler o lo script coremltools in Python.

Conversione di modelli in Core ML

La conversione di modelli da framework di terze parti a Core ML viene eseguita utilizzando la libreria coremltools in Python. coremltools supporta l’importazione di modelli da TensorFlow 1.x/2.x (SavedModel, PB, HDF5), PyTorch (TorchScript, modelli tracciati/scriptati), Keras (H5), ONNX e quelli creati con Create ML. La pipeline di conversione standard comprende tre passaggi: caricamento del modello nel formato originale, conversione in MIL (Model Intermediate Language) — la rappresentazione interna di Core ML — ed esportazione in .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")

Verifica del modello dopo la conversione

Dopo la conversione, è necessario verificare l’accuratezza del modello confrontando le previsioni del modello originale e del modello Core ML convertito sugli stessi dati. La deviazione accettabile non supera 1e-3 (0,1%) per Float32 e 1e-2 (1%) per Float16/Int8. coremltools fornisce l’utilità ct.utils.compare_models() per il confronto automatico. Se la deviazione supera la norma, potrebbe esserci un problema con operazioni non supportate — devono essere sostituite con layer personalizzati o il modello semplificato.

Ottimizzazione delle prestazioni di Core ML

L’ottimizzazione di un modello Core ML è il processo di riduzione delle dimensioni del modello e aumento della velocità di inferenza senza perdita significativa di accuratezza. Apple fornisce diversi strumenti di ottimizzazione integrati in coremltools e Xcode: quantizzazione (riduzione della precisione dei pesi), potatura (rimozione di neuroni insignificanti), rimozione di layer ridondanti e fusione di layer per ridurre il grafo computazionale.

Quantizzazione in Float16 e Int8

La quantizzazione riduce le dimensioni del modello di circa 2 volte (Float16) o 4 volte (Int8) rispetto a Float32. Core ML supporta tre modalità di quantizzazione: quantizzazione post-addestramento (PTQ) con un dataset di calibrazione, durante la conversione tramite coremltools e addestramento consapevole della quantizzazione (QAT). Per la maggior parte dei modelli di visione artificiale, PTQ in Float16 comporta una perdita di accuratezza inferiore allo 0,5% raddoppiando la velocità di inferenza.

Profilazione del modello in Xcode

Xcode fornisce lo strumento Core ML Model Profiler, che consente di misurare le prestazioni del modello su vari dispositivi nel simulatore o su un dispositivo reale. Il profiler mostra il tempo di esecuzione di ogni layer, il carico del backend (ANE/GPU/CPU), il picco di utilizzo della memoria e i colli di bottiglia del modello. Secondo Apple Performance Optimization Guide, oltre l’80% dei modelli ha almeno un layer che funziona significativamente più lentamente degli altri (anomalia del layer), che può essere ottimizzato mediante sostituzione o fusione.

Esempio pratico di integrazione di Core ML

Esaminiamo l’integrazione di un modello Core ML addestrato in un’app iOS utilizzando Swift. Dopo aver aggiunto il file .mlpackage al progetto Xcode (trascinandolo o tramite Swift Package Manager), Xcode genera automaticamente una classe modello Swift con input e output tipizzati. Lo sviluppatore non deve analizzare manualmente i dati di input — la classe generata accetta UIImage, MLMultiArray, String o altri tipi in base ai metadati del modello.

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])

Gestione degli errori e fallback

Quando si integra Core ML, è necessario implementare la gestione degli errori: il modello potrebbe non caricarsi a causa di incompatibilità del dispositivo (versione iOS troppo vecchia), memoria insufficiente o corruzione del file del modello. Si consiglia di implementare una logica di fallback: se il modello non si carica nel formato Int8 quantizzato, caricare la versione Float16 e, se anch’essa fallisce — Float32. Secondo Apple Crash Analytics, oltre il 5% degli arresti anomali delle app ML è causato da un caricamento errato del modello.

Core ML vs Create ML: differenze

Core ML e Create ML sono due strumenti complementari dell’ecosistema Apple ML. Core ML si occupa dell’esecuzione dei modelli sul dispositivo (inferenza), mentre Create ML si occupa dell’addestramento dei modelli. I modelli creati in Create ML vengono esportati specificamente nel formato Core ML (.mlpackage) per la successiva integrazione nelle applicazioni. In termini di sviluppo web, Core ML è il browser (esecuzione) e Create ML è l’IDE per scrivere codice (addestramento).