Integrazione di Apple Core AI#

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

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 lavoro tra CPU, GPU e Neural Engine di Apple (ANE).

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

Confronto tra Core AI e Core ML#

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

Come funziona il formato Core AI#

Il flusso di authoring 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 Apple coreai-torch converte un torch.export.ExportedProgram effettuando il lowering delle operazioni PyTorch ATen in operazioni Core AI. Le operazioni non supportate possono essere implementate con un lowering personalizzato o un kernel Metal personalizzato.

Il .aimodel risultante è un asset modello non specializzato. Quando un'applicazione prepara il modello, Core AI lo specializza per il dispositivo di destinazione. Le applicazioni possono consentire che ciò avvenga al primo utilizzo, richiedere prima la specializzazione oppure distribuire un modello compilato ahead-of-time 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 NDArray tipizzati e ricevono output denominati. Questo è diverso dall'avvolgere un modello Core ML in una richiesta Vision, quindi l'adozione di 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 il caching dei modelli e la compilazione ahead-of-time.

Esportazione dei modelli YOLO26 in Core AI#

from ultralytics import YOLO

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

# Run the exported model
coreai_model = YOLO("yolo26n.aimodel")
results = coreai_model("https://ultralytics.com/images/bus.jpg")

Per l'elenco completo degli argomenti, consulta la modalità Export. Il grafo è statico: viene tracciato alla imgsz fornita a export, quindi esegui la predizione su quella stessa dimensione. I metadati Ultralytics viaggiano all'interno del proprio metadata.json dell'asset, quindi i nomi delle classi, lo stride e il task sopravvivono al percorso di andata e ritorno.

Scelta dell'head#

Con nms=False, YOLO26 esporta la sua testa end-to-end, che seleziona i rilevamenti all'interno del grafo. Core AI non ha alcuna primitiva top-k, quindi tale selezione viene convertita in un ordinamento completo e comporta un costo fisso al limite della partizione di Apple Neural Engine — circa 1,7 ms, indipendentemente da max_det. L'esportazione con nms=None emette invece le predizioni grezze di (1, 84, 8400) e affida la soppressione dei massimi non 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 la testa nel grafo e 1,28 ms senza (FP16, compilato ahead-of-time, tre blocchi interlacciati di 50 iterazioni). Entrambi passano attraverso YOLO(...) per l'inferenza. Usa nms=False quando una singola chiamata al grafo deve restituire rilevamenti completati, oppure mantieni il valore predefinito nms=None per la NMS esterna.

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

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 futuro percorso Core AI dovrà definire la pre-elaborazione delle immagini, la costruzione di NDArray, i metadati del modello e la decodifica dell'output nell'SDK Ultralytics per iOS. Apple fornisce i dettagli attuali dell'API nella documentazione del framework Core AI e modelli di esempio funzionanti nel repository dei modelli Core AI.

Vantaggi di Core AI#

Core AI offre diversi vantaggi promettenti per la futura distribuzione Ultralytics:

• Percorso di esportazione PyTorch moderno: la conversione parte da torch.export, preservando un grafo PyTorch più espressivo rispetto al flusso di tracing usato da molti exporter esistenti.
• Controllo runtime granulare: 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 stateful, le forme dinamiche, più funzioni in un singolo artefatto e i kernel Metal personalizzati sono progettati per architetture moderne di visione e generative.
• Strumenti dedicati agli sviluppatori: il Core AI Debugger può ispezionare i grafi e i valori dei tensori e ricondurli al codice Python di origine. Xcode e Instruments offrono il profiling runtime.
• Opportunità di zero-copy: Core AI espone controlli su storage 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 del 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 bassa precisione.

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

Svantaggi e limitazioni attuali#

Core AI non è attualmente un sostituto del 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 in beta: il framework Core AI di Apple e parti della relativa toolchain Python sono ancora preliminari e potrebbero cambiare prima delle release stabili.
• Ambiente di esportazione più ristretto: coreai-torch attualmente richiede Python 3.11 o versione successiva ma inferiore a 3.14, oltre a versioni recenti di PyTorch, un intervallo molto più ristretto rispetto all'intervallo di Python e PyTorch supportato da Ultralytics.
• L'esportazione viene eseguita solo su macOS: coreai-core pubblica solo wheel macosx_26_0_arm64, quindi format=coreai richiede un Mac Apple silicon con macOS 26 o versione successiva.
• Ancora nessun runtime applicativo Ultralytics: l'app YOLO ufficiale per iOS e il plugin Flutter attualmente caricano gli artefatti Core ML tramite MLModel e Vision.
• È necessaria la migrazione dell'applicazione: un .aimodel non può sostituire un .mlpackage; il caricamento del modello, la pre-elaborazione, le chiamate di inferenza, la gestione dei metadati e la decodifica dell'output richiedono un'implementazione Core AI.
• Evidenze limitate in 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 una fase di NMS per i modelli di rilevamento YOLO meno recenti. Core AI esporta predizioni grezze da uno a molti per impostazione predefinita; usa nms=False per la testa senza NMS di YOLO26. La NMS incorporata (nms=True) e dynamic=True non sono supportate. coreai-torch non ha alcuna conversione per torchvision::nms, quindi la NMS rimane sull'host.
• Dimensione di input fissa: il grafo esportato viene tracciato a una imgsz e non ha forme dinamiche, quindi esegui la predizione alla dimensione con cui è stato esportato.
• Gli asset FP16 possono interrompere il caricamento: alcuni asset .aimodel FP16 non riescono a caricare il programma del Neural Engine di Apple e MPSGraph genera un'asserzione fallita, terminando il processo invece di eseguire il fallback. Ciò avviene all'interno del runtime Apple, prima dell'esecuzione di qualsiasi codice Ultralytics, mentre lo stesso asset viene caricato con una specializzazione che usa solo la CPU. Preferisci FP32 finché il problema non viene risolto upstream.

Quale formato Apple dovresti usare?#

Usa Core ML oggi quando ti serve:

• Distribuzione su sistemi operativi Apple attuali e meno recenti
• Integrazione con l'SDK Ultralytics per iOS o Flutter
• Gestione delle immagini tramite il framework Vision
• Distribuzione YOLO FP16 e INT8 testata
• NMS integrato per modelli di detection legacy compatibili

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

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

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

Roadmap di Ultralytics#

Il target di esportazione dedicato coreai è implementato: l'esportazione e la validazione numerica coprono i modelli YOLO26 supportati e vengono eseguite continuamente nella CI di Ultralytics su macOS 26, mentre la latenza FP16 viene misurata sul dispositivo. La roadmap rimanente prima che Core AI raggiunga la parità con il percorso Core ML:

1. Caricamento del modello Core AI e pre-elaborazione nell'SDK Ultralytics per iOS.
2. Integrazione Flutter e strategia di compatibilità per i dispositivi con versioni precedenti a iOS 27.
3. Release 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.

Core ML resta il target consigliato per le applicazioni che richiedono l'SDK Ultralytics per iOS o Flutter oppure il supporto a 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 Core AI per PyTorch
• Core AI Optimization
• Repository dei modelli Apple Core AI
• Integrazione Ultralytics Core ML

FAQ#