Core ML — cos'è, modello di machine learning e funzionamento in iOS

Cos'è Core ML?

Core ML è un framework di machine learning presentato da Apple al WWDC 2017 come parte dell'ecosistema di sviluppo per iPhone, iPad, Mac, Apple Watch e Apple TV. Core ML fornisce un runtime per eseguire modelli ML sul dispositivo, astraendo lo sviluppatore dai dettagli dell'ottimizzazione hardware. Il framework seleziona automaticamente il miglior motore di calcolo — Neural Engine sui chip A12+, GPU o CPU — per ogni operazione del modello.

Il vantaggio chiave di Core ML è la profonda integrazione con Apple Silicon. Le operazioni delle reti neurali vengono eseguite sul Neural Engine dedicato, che non carica i core principali del processore. Secondo Apple (WWDC 2025), i modelli Core ML funzionano 6 volte più velocemente rispetto a TensorFlow Lite su dispositivi Android simili.

Caratteristiche principali

Core ML supporta un'ampia gamma di attività di machine learning: classificazione di immagini, rilevamento oggetti, segmentazione semantica, elaborazione del linguaggio naturale, analisi audio e dati tabulari. Il framework lavora con vari tipi di modelli: reti neurali (convoluzionali, ricorrenti, transformer), ensemble di alberi, regressioni lineari e processi gaussiani.

Come funziona Core ML

Core ML riceve un modello addestrato in formato .mlpackage, lo compila in codice macchina ottimizzato per il dispositivo specifico ed esegue l'inferenza tramite un'API unificata. L'intera pipeline — dal caricamento del modello all'ottenimento del risultato — richiede 3–5 righe di codice Swift.

Formato modello .mlpackage

.mlpackage è un formato contenitore introdotto da Apple nel 2020 per sostituire il vecchio .mlmodel. Il pacchetto è una directory contenente un manifesto JSON, un file modello in formato binario MLProgram, metadati (autore, versione, descrizione) e risorse come etichette di classi. Secondo Apple, .mlpackage riduce la dimensione del modello del 30–50% rispetto a .mlmodel grazie all'ottimizzazione dei pesi.

Apple Neural Engine

Apple Neural Engine (ANE) è un neuroprocessore dedicato integrato nei chip Apple a partire dall'A12 Bionic (2018). L'ANE elabora operazioni matriciali decine di volte più efficientemente della CPU con lo stesso consumo energetico. Le prestazioni dell'ANE sono passate da 5 TOPS sull'A12 a 35 TOPS sul M4 Ultra (2025), consentendo l'esecuzione di modelli con miliardi di parametri. L'ANE viene utilizzato automaticamente per tutti i modelli Core ML con architettura di rete neurale.

Una caratteristica importante di Core ML è il supporto per la quantizzazione dei modelli in FP16 e INT8 senza perdita di precisione. La quantizzazione riduce la dimensione del modello di 2–4 volte e accelera l'inferenza del 40–60% sull'ANE. Apple fornisce lo strumento Xcode Model Quantization per la selezione automatica della precisione ottimale: lo sviluppatore carica un modello, specifica la perdita di qualità accettabile (di solito 0.1–0.5%), e Xcode seleziona il miglior formato di rappresentazione dei pesi.

Confronto prestazioni Core ML

Convertire modelli in Core ML

La maggior parte dei modelli ML viene creata in PyTorch o TensorFlow e necessita di conversione nel formato .mlpackage per l'uso in Core ML. Apple fornisce l'utilità coremltools — un pacchetto Python per convertire, ottimizzare e convalidare i modelli.

Strumento coremltools

coremltools è l'utilità ufficiale di Apple per convertire modelli ML. Supporta l'importazione da PyTorch (tramite torch.onnx o direttamente), TensorFlow (SavedModel, H5, Frozen Graph) e ONNX. Dopo la conversione, è possibile attivare la quantizzazione FP16 o INT8, riducendo la dimensione del modello di 2–4 volte senza significativa perdita di precisione.

Esempio di conversione da PyTorch

Esaminiamo la conversione di un modello PyTorch addestrato nel formato Core ML utilizzando coremltools versione 8.0. Il processo richiede 2–3 passaggi in Python.

import torch
import coremltools as ct

# Caricamento modello PyTorch addestrato
model = torch.load('model.pth')
model.eval()

# Tracing del modello con input di esempio
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Conversione in Core ML .mlpackage
mlmodel = ct.convert(
    traced_model,
    convert_to='mlprogram',
    inputs=[ct.TensorType(shape=(1, 3, 224, 224))]
)
mlmodel.save('Model.mlpackage')

Il codice carica il modello PyTorch addestrato, esegue il tracing JIT con un input di esempio e lo converte nel formato mlprogram (formato binario Core ML). Il .mlpackage risultante può essere trascinato in Xcode e utilizzato immediatamente nel codice Swift.

Integrare Core ML in un'app iOS

Dopo la conversione del modello, la sua integrazione in un'app iOS in Swift avviene in poche righe. Xcode genera automaticamente una classe Swift per il modello basata sui metadati .mlpackage.

Esempio di codice Swift

Esaminiamo un esempio di classificazione delle immagini utilizzando Core ML e il framework Vision. Vision trasforma automaticamente l'immagine nella dimensione e nel formato pixel richiesti.

import CoreML
import Vision

// Caricamento modello Core ML
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

// Creazione VNCoreMLRequest
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results
        as? [VNClassificationObservation]
    else { return }

    // Output top-3 previsioni
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Avvio elaborazione immagine
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Il codice Swift carica il modello MobileNetV2 tramite il framework Vision, crea una richiesta di classificazione e elabora il risultato — un array di oggetti VNClassificationObservation con etichette di classe e percentuali di confidenza. L'intera pipeline, dal caricamento all'output del risultato, richiede 5–50 ms a seconda del modello.

Per ottimizzare il tempo di avvio, Core ML compila il modello al primo utilizzo. La precompilazione riduce l'avvio a freddo da 2–3 secondi a 100–200 ms. Si consiglia di compilare il modello in fase di build in Xcode, piuttosto che al primo avvio dell'app. Questo è particolarmente importante per le app con più modelli ML — ad esempio, rilevamento oggetti + classificazione + NLP.

Core ML vs ML Kit

Core ML e ML Kit risolvono attività ML simili sul dispositivo, ma sono orientati a ecosistemi diversi. Core ML è profondamente integrato con Apple Silicon e supporta solo piattaforme Apple. ML Kit di Google è una soluzione multipiattaforma per Android e iOS.

Scegli Core ML se il tuo ecosistema è esclusivamente Apple e hai bisogno delle massime prestazioni tramite ANE. Se hai bisogno di supporto multipiattaforma o API pronte senza conversione, ML Kit sarà più pratico.

Nella pratica, molti progetti utilizzano entrambi i framework: iOS Core ML per alte prestazioni e ML Kit o TensorFlow Lite su Android. Un modello PyTorch unificato viene convertito in .mlpackage per Apple e in .tflite per Android, consentendo di mantenere la stessa qualità delle funzionalità ML su entrambe le piattaforme. Questo approccio richiede un po' più di impegno DevOps, ma offre la massima copertura del pubblico.

Nella scelta tra Core ML e alternative, considera il costo di sviluppo: Core ML richiede meno codice di integrazione (3–5 righe di Swift contro 15–20 righe con TFLite), ma richiede un Mac e Xcode per la compilazione. ML Kit, d'altra parte, funziona su qualsiasi piattaforma ma offre prestazioni inferiori su iOS a causa della mancanza di accesso all'Apple Neural Engine.