Integrazione con Apple Core AI#

Core AI è il nuovo framework di Apple per eseguire reti neurali direttamente su Apple silicon. Introduce il formato di modello .aimodel, una moderna API Swift per l'inferenza, strumenti di conversione basati su PyTorch, la compilazione anticipata, la specializzazione dei modelli e strumenti dedicati per il debugging e la profilazione.

Apple descrive Core AI come la prossima evoluzione dell'esecuzione dell'AI sul dispositivo e il framework di inferenza alla base di Apple Intelligence sul dispositivo. È progettato per le architetture di reti neurali attuali, dai modelli di visione compatti ai grandi modelli generativi, e può pianificare il carico di lavoro tra CPU, GPU e motore neurale Apple (ANE).

Core AI è un nuovo percorso di distribuzione, non un nuovo nome per Core ML. I framework utilizzano formati di modello, strumenti di conversione, API di runtime e modalità d'integrazione nelle applicazioni differenti.

Confronto tra Core AI e Core ML#

Core ML resta la scelta adatta quando un'applicazione richiede un'ampia compatibilità con i dispositivi, l'integrazione con il framework Vision o tipi di modelli come alberi decisionali e pipeline tabellari. Apple continua a supportare Core ML e indirizza gli sviluppatori che lavorano con tipi di modelli non neurali verso Core ML.

Come funziona il formato Core AI#

Il flusso di creazione con Core AI parte da un modello PyTorch:

PyTorch model
    ↓ torch.export
ExportedProgram
    ↓ coreai-torch
Core AI program
    ↓ optimize and save
.aimodel
    ↓ specialize or compile ahead of time
Apple silicon executable

Il pacchetto coreai-torch di Apple converte un torch.export.ExportedProgram trasformando le operazioni PyTorch ATen in operazioni Core AI. Le operazioni non supportate possono essere implementate con un lowering personalizzato o un kernel Metal personalizzato.

Il risultato, .aimodel, è un asset di modello non specializzato. Quando un'applicazione prepara il modello, Core AI lo specializza per il dispositivo di destinazione. Le applicazioni possono lasciare che questa operazione avvenga al primo utilizzo, richiedere la specializzazione in anticipo oppure distribuire un modello compilato in anticipo per ridurre il tempo di caricamento iniziale.

In Swift, le applicazioni caricano l'asset con il framework Core AI, selezionano una funzione di inferenza, forniscono input tipizzati NDArray e ricevono output con nome. Questo processo differisce dall'inserire un modello Core ML in una richiesta Vision, quindi per adottare Core AI serve un runtime dell'applicazione progettato per gli asset .aimodel.

Per i dettagli di implementazione, consulta la documentazione di Apple per AIModel, la specializzazione e la memorizzazione nella cache dei modelli e la compilazione anticipata.

Esportazione dei modelli YOLO26 in Core AI#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="coreai")  # crea 'yolo26n.aimodel'
model.export(format="coreai", quantize=16)  # FP16 asset

# Esegui il modello esportato
coreai_model = YOLO("yolo26n.aimodel")
results = coreai_model("https://ultralytics.com/images/bus.jpg")

Per l'elenco completo degli argomenti, consulta la modalità di esportazione. Il grafo è statico: viene tracciato alla imgsz specificata per export, quindi esegui le predizioni con la stessa dimensione. I metadati Ultralytics sono inclusi nel metadata.json dell'asset, quindi i nomi delle classi, lo stride e il task vengono mantenuti durante la conversione.

Scelta della head#

Con nms=False, YOLO26 esporta la head end-to-end, che seleziona le detection all'interno del grafo. Core AI non dispone di una primitiva top-k, quindi questa selezione viene implementata tramite un ordinamento completo e comporta un costo fisso al confine della partizione dell'Apple Neural Engine: circa 1,7 ms, indipendentemente da max_det. L'esportazione con nms=None produce invece le predizioni (1, 84, 8400) grezze e lascia la soppressione non massima al predictor:

yolo export model=yolo26n.pt format=coreai nms=None quantize=16

Su un iPhone 17 Pro con iOS 27.0, YOLO26n a 640 misura 3.01 ms con la head nel grafo e 1.28 ms senza (FP16, compilato in anticipo, tre blocchi intercalati da 50 iterazioni). Entrambe le varianti passano attraverso YOLO(...) per l'inferenza. Usa nms=False quando una singola chiamata al grafo deve restituire detection già elaborate, oppure mantieni il valore predefinito nms=None per la NMS esterna.

Su iOS 27 o macOS 27, un'applicazione caricherebbe ed eseguirebbe quindi l'asset esportato tramite l'API Swift Core AI di Apple. Gli asset esportati usano l'entrypoint main, accettano un singolo input images con forma [batch, 3, imgsz, imgsz] e restituiscono output0 (i modelli di segmentazione di istanze restituiscono anche output1):

import CoreAI

let modelURL = Bundle.main.url(forResource: "yolo26n", withExtension: "aimodel")!
let model = try await AIModel(contentsOf: modelURL)
guard let function = try model.loadFunction(named: "main") else {
    throw AppError.missingInferenceFunction
}

let outputs = try await function.run(inputs: ["images": imageTensor])

A differenza dell'attuale flusso di lavoro Core ML e Vision, il percorso Core AI nell'Ultralytics iOS SDK esegue autonomamente il pre-processing letterbox e la creazione di NDArray, legge gli stessi metadati Ultralytics dall'asset metadata.json e riutilizza i decoder di output Core ML. Il caricamento avviene quando un'app passa un percorso .aimodel o un URL .aimodel.zip. Apple fornisce i dettagli aggiornati delle API nella documentazione del framework Core AI e modelli di esempio funzionanti nel repository dei modelli Core AI.

Prestazioni misurate#

Inferenza end-to-end su una singola immagine per YOLO26n FP16 (quantize=16) esportato in Core ML e Core AI con la head grezza predefinita (nms=None), su un Mac mini con Apple M4 (CPU con 4 core Performance e 6 core Efficiency, GPU a 10 core, motore neurale a 16 core), 16 GB di memoria e macOS 27.0, usando ultralytics 8.4.168, coremltools 9.0 per l'inferenza Core ML e coreai-torch 0.4.3 con coreai-core 1.0.0b3 per l'inferenza Core AI con Python 3.13. Ogni cella mostra il tempo totale (pre-processing + inferenza + post-processing), con la suddivisione per fase riportata sotto.

• I valori di velocità sono latenze di burst su singola immagine: la media di 15 chiamate predict dopo 3 chiamate di riscaldamento su bus.jpg tramite l'API Python di Ultralytics, con ogni modello e unità di calcolo eseguiti in un nuovo processo. L'ordine CPU/acceleratore è stato alternato tra le attività in un'unica esecuzione sequenziale. Le righe Core ML vengono caricate con coremltools.ComputeUnit.CPU_ONLY o CPU_AND_NE; le righe Core AI vengono specializzate con SpecializationOptions.cpu_only() o SpecializationOptions.from_preferred_compute_unit_kind(ComputeUnitKind.neural_engine()), mentre il posizionamento finale delle operazioni è gestito da ciascun framework.
• Detect, segment, classify, pose e OBB hanno restituito le stesse previsioni in entrambi i formati su ogni unità di calcolo. Su questo Mac, il modello semantico Core ML FP16 è più lento con Neural Engine preferito rispetto alla sola CPU, e il postprocessing semantico Core AI richiede da 6.4 a 7.4 ms, contro 0.4 ms per Core ML.
• Confronta i risultati su iPhone 17 Pro in CoreML integration.

Vantaggi di Core AI#

Core AI offre diversi vantaggi promettenti per le future implementazioni di Ultralytics:

• Percorso di esportazione PyTorch moderno: la conversione parte da torch.export, preservando un grafo PyTorch più espressivo rispetto al flusso di lavoro di tracing usato da molti esportatori esistenti.
• Controllo granulare del runtime: le applicazioni possono gestire la specializzazione, le cache dei modelli compilati, le funzioni di inferenza, la memoria e il posizionamento dei calcoli.
• Supporto avanzato dei modelli: l'esecuzione con stato, le forme dinamiche, più funzioni in un singolo artefatto e i kernel Metal personalizzati sono progettati per le moderne architetture di visione artificiale e generative.
• Strumenti dedicati agli sviluppatori: Core AI Debugger può ispezionare grafi e valori dei tensori e ricondurli al codice Python di origine. Xcode e Instruments offrono la profilazione del runtime.
• Possibilità di copie zero: Core AI espone controlli di archiviazione e dei buffer pensati per ridurre le copie tra i carichi di lavoro della fotocamera, della grafica e dell'inferenza.
• Ottimizzazione per Apple Silicon: la specializzazione per dispositivo consente ad Apple di ottimizzare un modello per la CPU, la GPU e il Neural Engine disponibili sul dispositivo specifico.
• Compressione flessibile: gli strumenti Core AI Optimization di Apple supportano quantizzazione, palettizzazione e pruning, inclusi i formati dei pesi a basso numero di bit.

Queste funzionalità potrebbero rivelarsi particolarmente utili per i futuri modelli YOLO con esecuzione dinamica, componenti multimodali più ampi o operazioni personalizzate che non si adattano bene alle operazioni Core ML esistenti.

Svantaggi e limitazioni attuali#

Al momento Core AI non sostituisce il percorso Core ML per la produzione:

• Sono richiesti sistemi operativi recenti: il framework pubblico è destinato alle generazioni iOS 27 e macOS 27, mentre Core ML supporta una base installata molto più ampia.
• Software beta: il framework Core AI di Apple e alcune parti della toolchain Python sono ancora preliminari e potrebbero cambiare prima delle versioni stabili.
• Ambiente di esportazione più ristretto: coreai-torch richiede attualmente Python dalla versione 3.11 alla 3.14, oltre a versioni recenti di PyTorch, un intervallo molto più limitato rispetto alle versioni di Python e PyTorch supportate da Ultralytics.
• Piattaforme di esportazione limitate: coreai-core pubblica solo wheel macosx_26_0_arm64 e manylinux_2_34_x86_64, quindi format=coreai richiede un Mac Apple Silicon con macOS 26 o versione successiva, oppure Linux x86_64 con glibc 2.34 o versione successiva (ad esempio Ubuntu 22.04+). Per eseguire un .aimodel serve comunque hardware Apple.
• Attivazione facoltativa negli SDK Ultralytics, non predefinita: su iPhone 17 Pro, il confronto su dispositivo mostra Core AI alla pari con Core ML per l'intera pipeline, non più veloce; l'inferenza semantica, di profondità e solo CPU è più lenta e le risorse FP16 hanno dimensioni di download circa doppie. Per questo, l'SDK iOS e il plugin Flutter mantengono Core ML come impostazione predefinita.
• Usa la raw head per gli SDK: con nms=False, YOLO26n richiede circa il doppio del tempo su Core AI rispetto a Core ML (3.06 contro 1.53 ms in un'esecuzione di confronto), e il modello pose end-to-end FP16 non restituisce rilevamenti con il posizionamento predefinito di Core AI su iOS 27.0 (apple/coreai-torch#115). La raw head (nms=None, predefinita) evita entrambi i problemi e gli SDK eseguono NMS in Swift. Vedi Scelta della head.
• Nessun runtime per iOS Simulator: l'SDK di iOS Simulator non include Core AI.
• È necessaria la migrazione dell'applicazione: un .aimodel non può sostituire un .mlpackage; il caricamento del modello, il preprocessing, le chiamate di inferenza, la gestione dei metadati e la decodifica dell'output richiedono un'implementazione Core AI al di fuori degli SDK Ultralytics, che forniscono un'implementazione.
• Evidenze limitate in produzione: le prestazioni, il consumo energetico, il tempo di specializzazione al primo avvio, la precisione e la compressione devono essere convalidati sull'intera matrice di attività YOLO e dispositivi supportati.
• Nessuna pipeline NMS: Core ML può includere una fase NMS per i modelli di rilevamento YOLO legacy. Per impostazione predefinita, Core AI esporta previsioni raw one-to-many; usa nms=False per la head senza NMS di YOLO26. NMS incorporata (nms=True) e dynamic=True non sono supportati. coreai-torch non dispone di un lowering per torchvision::nms, quindi NMS viene eseguito sull'host.
• Dimensione di input fissa: il grafo esportato viene tracciato a una sola imgsz e non supporta forme dinamiche, quindi esegui le predizioni alla dimensione usata per l'esportazione.
• Le risorse FP16 possono causare un arresto anomalo al caricamento: alcune risorse FP16 .aimodel non riescono a caricare il programma Apple Neural Engine e MPSGraph genera un'asserzione non valida, terminando il processo invece di ripiegare su un'alternativa. Ciò accade all'interno del runtime di Apple, prima che venga eseguito qualsiasi codice Ultralytics, e la stessa risorsa si carica con una specializzazione solo CPU. Se succede, passa a FP32; le risorse FP16 dell'SDK verificate su un iPhone 17 Pro (tutti i modelli nano, detect a ogni dimensione e il modello più grande per ogni attività) sono state caricate senza arresti anomali.

Quale formato Apple dovresti usare?#

Usa Core ML oggi quando ti serve:

• Distribuzione su sistemi operativi Apple attuali e meno recenti
• Il percorso predefinito dell'SDK Ultralytics per iOS o Flutter
• Gestione delle immagini tramite il framework Vision
• Distribuzione YOLO FP16 e INT8 testata
• NMS incorporata per i modelli legacy di rilevamento compatibili

Valuta Core AI se puoi richiedere iOS 27 o macOS 27 e ti serve:

• Il più recente runtime Apple per reti neurali su dispositivo
• Gestione esplicita della specializzazione e della cache
• Esecuzione avanzata di modelli dinamici o con stato
• Operazioni Core AI personalizzate o kernel Metal
• Debug dettagliato dei grafi Core AI e profilazione del runtime

Core ML e Core AI dovrebbero coesistere durante la transizione delle applicazioni. Il supporto a Core AI non elimina subito la necessità di Core ML, perché i rispettivi sistemi operativi target e i contratti applicativi sono diversi.

Roadmap di Ultralytics#

Il target di esportazione dedicato coreai è implementato: l'esportazione e la convalida numerica coprono i modelli YOLO26 supportati e vengono eseguite continuamente in Ultralytics CI su macOS 26; inoltre, la latenza FP16 viene misurata su dispositivo. Ecco cosa resta da fare prima che Core AI raggiunga la parità con il percorso Core ML:

1. Ridurre il divario di latenza end-to-end della head su Apple Neural Engine (apple/coreai-torch#66) e risolvere i problemi di correttezza del Neural Engine (apple/coreai-torch#115, #116).
2. Risorse Core AI INT8 e palettizzate; le risorse dell'SDK sono FP16 e hanno dimensioni di download circa doppie rispetto alle risorse Core ML INT8.
3. Versioni stabili dei framework Apple e degli strumenti di conversione (le generazioni iOS 27 e macOS 27 sono attualmente in beta).
4. Benchmark di memoria, consumo energetico e specializzazione sull'intera matrice di dispositivi supportati.

L'SDK Ultralytics per iOS e il plugin Flutter caricano Core AI come opzione attivabile su iOS 27 e versioni successive; Core ML resta l'impostazione predefinita ed è il target consigliato per la compatibilità con versioni precedenti a iOS 27. Segui la roadmap di Ultralytics e le note di rilascio per gli elementi rimanenti.

Risorse aggiuntive#

• Panoramica di Apple Core AI
• Documentazione del framework Core AI
• Estensioni PyTorch di Core AI
• Ottimizzazione Core AI
• Repository dei modelli Apple Core AI
• Integrazione Core ML di Ultralytics

Domande frequenti#