Integrazione di 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 debug e la profilazione.

Apple descrive Core AI come la prossima evoluzione dell'esecuzione dell'IA sul dispositivo e come 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 lavoro su CPU, GPU e Neural Engine di Apple (ANE).

Core AI è un nuovo percorso di deployment, non un nuovo nome per Core ML. I framework usano formati di modello, strumenti di conversione, API runtime e schemi di integrazione nelle applicazioni diversi.

Confronto tra Core AI e Core ML#

Core ML rimane la scelta appropriata quando un'applicazione richiede un'ampia copertura di dispositivi, l'integrazione con il framework Vision o tipi di modelli come alberi decisionali e pipeline tabulari. Apple continua a supportare Core ML e indirizza verso di esso gli sviluppatori che usano tipi di modelli non neurali.

Come funziona il formato Core AI#

Il flusso di creazione di 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 del modello non specializzato. Quando un'applicazione prepara il modello, Core AI lo specializza per il dispositivo di destinazione. Le applicazioni possono lasciare che l'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. È diverso dall'inserire un modello Core ML in una richiesta Vision, quindi adottare Core AI richiede un runtime applicativo progettato per gli asset .aimodel.

Per i dettagli di implementazione, consulta la documentazione 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 dimensione imgsz fornita a 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 il ciclo di esportazione e importazione.

Scelta dell'head#

Con nms=False, YOLO26 esporta il proprio head end-to-end, che seleziona le rilevazioni all'interno del grafo. Core AI non ha una primitiva top-k, quindi questa selezione viene convertita in un ordinamento completo e comporta un costo fisso sul confine della partizione Apple Neural Engine: circa 1,7 ms, indipendentemente da max_det. L'esportazione con nms=None produce invece le predizioni grezze (1, 84, 8400) e lascia la soppressione dei massimi locali al predittore:

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 l'head nel grafo e 1,28 ms senza (FP16, compilazione anticipata, tre blocchi intercalati da 50 iterazioni). In entrambi i casi, l'inferenza viene eseguita sull'asset esportato tramite YOLO(...). Usa nms=False quando una singola chiamata al grafo deve restituire rilevazioni definitive, oppure mantieni l'impostazione predefinita nms=None per applicare NMS esternamente.

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 delle 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'SDK iOS di Ultralytics esegue il proprio pre-processing letterbox e crea NDArray, legge gli stessi metadati Ultralytics dal metadata.json dell'asset 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 le esportazioni YOLO26n FP16 (quantize=16) in Core ML e Core AI con la head raw predefinita (nms=None) su un Mac mini con Apple M4 (4 core CPU Performance e 6 Efficiency, GPU a 10 core, Neural Engine 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-elaborazione + inferenza + post-elaborazione) e sotto la suddivisione per fase.

• I valori di velocità indicano le latenze in raffica su una 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 processo nuovo. L'ordine di CPU e 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 è controllato da ciascun framework.
• Rilevamento, segmentazione, classificazione, stima della posa e OBB hanno restituito le stesse predizioni in entrambi i formati su ogni unità di calcolo. Su questo Mac, il modello semantico FP16 di Core ML è più lento con Neural Engine come unità preferita rispetto alla sola CPU, mentre la post-elaborazione semantica di Core AI richiede da 6.4 a 7.4 ms, contro 0.4 ms per Core ML.
• Confronta i risultati ottenuti su iPhone 17 Pro direttamente sul dispositivo nell'integrazione CoreML.

Vantaggi di Core AI#

Core AI offre diversi vantaggi promettenti per il futuro deployment di Ultralytics:

• Percorso di esportazione PyTorch moderno: la conversione parte da torch.export e preserva un grafo PyTorch più espressivo rispetto al flusso di tracciamento 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 unico artefatto e i kernel Metal personalizzati sono progettati per le moderne architetture di visione e generative.
• Strumenti dedicati agli sviluppatori: Core AI Debugger può esaminare i grafi e i valori dei tensori e ricondurli al codice Python di origine. Xcode e Instruments offrono la profilazione del runtime.
• Opportunità di zero-copy: Core AI espone controlli di archiviazione e buffer pensati per ridurre le copie tra i carichi di lavoro della fotocamera, della grafica e dell'inferenza.
• Ottimizzazione per Apple silicon: la specializzazione sul 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 di ottimizzazione Core AI di Apple supportano quantizzazione, palettizzazione e pruning, inclusi i formati dei pesi a basso numero di bit.

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

Svantaggi e limitazioni attuali#

Attualmente Core AI non sostituisce il percorso Core ML per la produzione:

• Sono richiesti nuovi sistemi operativi: il framework pubblico è destinato alla generazione iOS 27 e macOS 27, mentre Core ML supporta una base installata molto più ampia.
• Software beta: il framework Core AI di Apple e parte della relativa toolchain Python sono ancora in fase preliminare e potrebbero cambiare prima delle versioni stabili.
• Ambiente di esportazione più ristretto: coreai-torch attualmente richiede Python dalla versione 3.11 alla 3.14, oltre a versioni recenti di PyTorch; un intervallo molto più ristretto rispetto alle versioni di Python e PyTorch supportate da Ultralytics.
• Piattaforme di esportazione limitate: coreai-core pubblica solo i pacchetti wheel macosx_26_0_arm64 e manylinux_2_34_x86_64, quindi format=coreai richiede un Mac con Apple silicon e macOS 26 o versioni successive, oppure Linux x86_64 con glibc 2.34 o versioni successive (ad esempio Ubuntu 22.04+). Per eseguire .aimodel è comunque necessario hardware Apple.
• Facoltativo negli SDK Ultralytics, non predefinito: su un iPhone 17 Pro, il confronto sul dispositivo mostra che Core AI è alla pari con Core ML per l'intera pipeline, anziché essere più veloce; l'inferenza semantica, di profondità e solo su CPU è più lenta e gli asset FP16 hanno dimensioni di download circa doppie, quindi l'SDK iOS e il plugin Flutter mantengono Core ML come impostazione predefinita.
• Usa l'head grezzo per gli SDK: con nms=False, YOLO26n impiega circa il doppio del tempo su Core AI rispetto a Core ML (3,06 contro 1,53 ms in una delle esecuzioni di confronto) e il modello pose end-to-end FP16 non restituisce rilevazioni con il posizionamento predefinito di Core AI su iOS 27.0 (apple/coreai-torch#115). L'head grezzo (nms=None, l'impostazione predefinita) evita entrambi i problemi e gli SDK eseguono NMS in Swift. Consulta Scelta dell'head.
• Nessun runtime per iOS Simulator: l'SDK di iOS Simulator non include Core AI.
• È necessaria la migrazione dell'applicazione: non è possibile sostituire un .aimodel con un .mlpackage; il caricamento del modello, il pre-processing, le chiamate di inferenza, la gestione dei metadati e la decodifica degli output richiedono un'implementazione Core AI al di fuori degli SDK Ultralytics, che ne forniscono una.
• Poche evidenze per la produzione: prestazioni, consumo energetico, tempo di specializzazione al primo avvio, accuratezza e compressione devono essere convalidati sull'intera matrice di task YOLO e dispositivi supportati.
• Nessuna pipeline NMS: Core ML può includere uno stadio NMS per i vecchi modelli di rilevamento YOLO. Per impostazione predefinita, le esportazioni Core AI producono predizioni grezze one-to-many; usa nms=False per l'head senza NMS di YOLO26. NMS integrata (nms=True) e dynamic=True non sono supportati. coreai-torch non dispone di un lowering per torchvision::nms, quindi NMS viene eseguita sull'host.
• Dimensione di input fissa: il grafo esportato viene tracciato a una sola dimensione imgsz e non supporta forme dinamiche, quindi esegui le predizioni alla dimensione usata per l'esportazione.
• Il caricamento degli asset FP16 può causare un arresto anomalo: alcuni asset FP16 .aimodel non riescono a caricare il programma Apple Neural Engine e MPSGraph genera un'asserzione non valida, terminando il processo invece di usare una soluzione alternativa. Il problema si verifica all'interno del runtime Apple, prima che venga eseguito qualsiasi codice Ultralytics, e lo stesso asset viene caricato con una specializzazione solo CPU. Se succede, passa a FP32; gli asset FP16 dell'SDK verificati su un iPhone 17 Pro (tutti i modelli nano, rilevamento a ogni dimensione e il modello più grande per ogni task) sono stati caricati senza arresti anomali.

Quale formato Apple dovresti usare?#

Usa Core ML oggi se ti serve:

• Deployment con i sistemi operativi Apple attuali e precedenti
• Il percorso predefinito dell'SDK iOS o Flutter di Ultralytics
• Gestione delle immagini tramite il framework Vision
• Deployment YOLO FP16 e INT8 collaudato
• NMS integrata per i modelli di rilevamento legacy compatibili

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

• Il runtime Apple più recente per le reti neurali sul 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

È previsto che Core ML e Core AI coesistano durante la transizione delle applicazioni. Il supporto a Core AI non elimina subito la necessità di Core ML, perché i rispettivi target di deployment e contratti applicativi sono diversi.

Roadmap di Ultralytics#

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

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

L'SDK iOS di Ultralytics e il plugin Flutter caricano Core AI come opzione facoltativa su iOS 27 e versioni successive; Core ML resta l'impostazione predefinita e 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 ancora da completare.

Risorse aggiuntive#

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

Domande frequenti#