Esportazione Apple Core ML
Core ML รจ il framework di Apple per eseguire modelli di machine learning su iPhone, iPad, Mac, Apple Watch, Apple TV e Apple Vision Pro. Esportando un modello Ultralytics YOLO26 con format="coreml" viene creato un pacchetto modello yolo26n.mlpackage, che Core ML esegue su CPU, GPU e Apple Neural Engine, in FP32, FP16 o con pesi a 8 bit.
Apple ha introdotto il nuovo framework Core AI e il formato .aimodel per la generazione iOS 27 e macOS 27, ed Ultralytics lo esporta con format="coreai". Core ML resta il formato predefinito degli SDK Ultralytics per iOS e Flutter, che caricano Core AI come opzione sui dispositivi iOS 27, oltre a essere il formato per i sistemi operativi Apple precedenti.
In breve#
| Proprietร | Dettagli |
|---|---|
argomento format | coreml (alias: mlpackage, mlprogram, apple, ios). mlmodel esporta il precedente formato di rete neurale |
| Output | yolo26n.mlpackage, un pacchetto modello (una directory) nel formato ML Program, con i nomi delle classi, il task e le dimensioni dell'immagine archiviati al suo interno come metadati |
| Esecuzione su | iPhone, iPad, Mac, Apple Watch, Apple TV e Apple Vision Pro, su CPU, GPU e Apple Neural Engine |
| Runtime | Core ML, integrato nei sistemi operativi Apple; il programma ML esportato dichiara la specifica Core ML 6 (iOS 15, macOS 12) oppure, per INT8, la specifica 7 (iOS 16, macOS 13). In Python, il pacchetto coremltools su macOS |
| Precisione | FP32, FP16, INT8 (pesi a 8 bit). YOLO26n รจ di 9,9 MB in FP32, 5,1 MB in FP16 e 2,7 MB in INT8 |
| Sistema per l'esportazione | macOS o Linux x86-64, con Python 3.13 o precedente. Non Windows. L'esportazione non richiede una GPU |
Ultralytics Platform puรฒ esportare per te un modello addestrato in Core ML, cosรฌ non ti serve un ambiente di esportazione locale.
Guida rapida#
Installa il pacchetto Ultralytics con le dipendenze per l'esportazione Core ML, su macOS o Linux x86-64:
pip install "ultralytics[export-coreml]"Vengono installati coremltools, scikit-learn e una versione di numpy compatibile con coremltools. Con un'installazione semplice di pip install ultralytics, la prima esportazione installa coremltools; se deve anche sostituire una versione piรน recente di numpy, l'esportazione non riesce; quella successiva va a buon fine. L'esportazione richiede queste versioni:
| Pacchetto | Versione richiesta |
|---|---|
| Python | 3.13 o precedente, la versione piรน recente per cui coremltools 9.0 dispone di pacchetti precompilati |
coremltools | 9.0 o successiva |
numpy | 2.3.5 o precedente. L'esportazione installa la versione 2.3.5 al posto di una versione piรน recente |
torch | 1.11 o successiva |
scikit-learn | Solo per quantize=8 e 'w8a16'. L'extra export-coreml installa la versione 1.3.2 o successiva; se manca, la installa l'esportazione |
Per altri metodi di installazione, consulta la guida all'installazione. Quindi esporta il modello e carica il pacchetto esportato per eseguire l'inferenza o convalidarne l'accuratezza.
from ultralytics import YOLO
# Carica un modello YOLO26
model = YOLO("yolo26n.pt")
# Esporta il modello nel formato Core ML
model.export(format="coreml") # crea 'yolo26n.mlpackage'
# Oppure esporta in FP16, dimezzando le dimensioni e consentendo l'esecuzione sul Neural Engine
model.export(format="coreml", quantize=16) # crea 'yolo26n.mlpackage'Entrambe le esportazioni scrivono lo stesso yolo26n.mlpackage, quindi la seconda sostituisce la prima. Predict e Validate vengono eseguiti solo su macOS:
from ultralytics import YOLO
# Carica il modello Core ML esportato su un Mac
model = YOLO("yolo26n.mlpackage")
# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Carica il modello Core ML esportato su un Mac
model = YOLO("yolo26n.mlpackage")
# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")Attivitร supportate#
L'esportazione Core ML supporta tutti e sette i task Ultralytics con i modelli YOLOv8, YOLO11 e YOLO26: rilevamento, segmentazione, segmentazione semantica, stima della profonditร , classificazione, stima della posa e OBB. La segmentazione semantica e la stima della profonditร sono disponibili solo con YOLO26, l'unica famiglia che include queste head. Si possono esportare anche i modelli di rilevamento YOLOv5u, YOLOv9, YOLOv10 e YOLO12, cosรฌ come i modelli RT-DETR e YOLO-Worldv2. Ogni task รจ stato testato con un checkpoint, ad esempio yolo11n-seg.pt, rtdetr-l.pt e yolov8s-worldv2.pt.
Argomenti di esportazione#
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
format | str | 'coreml' | Formato di destinazione del modello esportato, che definisce la compatibilitร con i vari ambienti di distribuzione. |
imgsz | int o tuple | 640 | Dimensione dell'immagine di input del modello, fissa nell'esportazione predefinita: un intero per immagini quadrate o una tupla (height, width). Se non viene specificata, l'esportazione usa la dimensione con cui รจ stato addestrato il checkpoint. I checkpoint ufficiali YOLO26 usano 640 per i modelli detect, segment e pose e per i modelli semantici preaddestrati su ADE20K, 1024 per i modelli OBB e per i modelli semantici preaddestrati su Cityscapes, 768 per depth e 224 per classify. |
quantize | int o str | None | Precisione: 16 (FP16) o 8 (pesi a 8 bit con calcolo FP16; 'w8a16' รจ la stessa esportazione); 32/non specificato corrisponde a FP32. Con nms=True, il valore non specificato corrisponde a FP16. Un checkpoint addestrato con quantize=8 non puรฒ essere esportato in Core ML; consulta Limitazioni e risoluzione dei problemi. Sostituisce i flag deprecati half/int8. |
nms | bool, facoltativo | None | Seleziona l'output grezzo (None, predefinito), NMS integrato (True, per i modelli detect, segment e pose con dynamic=False) oppure la head senza NMS (False). Consulta formato di output. |
conf | float | None | Soglia di confidenza memorizzata in un'esportazione nms=True. Se non specificata, usa 0.25. |
iou | float | 0.5 | Soglia IoU memorizzata in un'esportazione nms=True. |
agnostic_nms | bool | False | Selezione indipendente dalla classe: in un'esportazione nms=True, un riquadro elimina anche i riquadri sovrapposti di altre classi. Modifica inoltre la selezione delle righe in un'esportazione nms=False. |
max_det | int | 300 | Numero di righe nell'output di un'esportazione nms=False e di un'esportazione di segmentazione o posa nms=True. Un'esportazione di rilevamento nms=True non ha questo limite. |
dynamic | bool | False | Rende dinamiche le dimensioni del batch, l'altezza e la larghezza dell'input e trasforma l'input da immagine ad array. Non disponibile per i modelli di classificazione e RT-DETR o con nms=True. Consulta Distribuzione. |
batch | int | 1 | Dimensione massima del batch di un'esportazione dynamic=True. L'esportazione predefinita ha una dimensione del batch pari a 1; altri valori generano un errore. |
device | str | None | Dispositivo usato per tracciare il modello durante la conversione; per impostazione predefinita, cpu. Un'esportazione FP32 tracciata con mps aveva le stesse dimensioni del pacchetto e restituiva gli stessi output di una tracciata su CPU. |
Per gli argomenti condivisi da tutti i formati, consulta la documentazione della modalitร di esportazione.
I modelli mobili ufficiali Core ML, LiteRT e QNN vengono esportati con imgsz=640 e, per la classificazione, con imgsz=224. I checkpoint semantici Cityscapes, depth e OBB vengono esportati per impostazione predefinita con dimensioni maggiori, quindi specifica imgsz=640 per uniformarli. I modelli Core ML dell'SDK Ultralytics per iOS vengono esportati con quantize=8 nms=False.
Precisione#
quantize determina come vengono memorizzati i pesi e la precisione dei calcoli Core ML. Nessuna delle tre precisioni richiede dati di calibrazione. Le dimensioni si riferiscono a un modello di rilevamento YOLO26n esportato con imgsz=640:
quantize | Pesi | Calcolo | Sistema operativo minimo | Dimensioni di YOLO26n |
|---|---|---|---|---|
non impostato o 32 | FP32 | FP32 | iOS 15, macOS 12 | 9.9 MB |
16 | FP16 | FP16 | iOS 15, macOS 12 | 5.1 MB |
8 o 'w8a16' | 8 bit | FP16 | iOS 16, macOS 13 | 2.7 MB |
- FP32: il valore predefinito se
nms=Truenon รจ impostato. Su Apple M4, le esportazioni FP32 di tutti e sette i task hanno restituito gli stessi output con le unitร di calcoloCPU_AND_NE, usate da Ultralytics, e conCPU_ONLY, senza risultare piรน veloci con le prime. Esporta in FP16 o INT8 per usare il Neural Engine. Su iPhone 17 Pro, un modello di rilevamento YOLO26n FP32 รจ risultato al massimo il 5% piรน veloce con il Neural Engine, considerando la mediana di tre esecuzioni; consulta Prestazioni misurate. - FP16:
quantize=16memorizza i pesi ed esegue i calcoli in precisione dimezzata. L'input immagine e gli array di output mantengono i tipi dell'esportazione FP32 (float32oppureint32per la segmentazione semantica), quindi il codice di inferenza scritto per il modello FP32 funziona senza modifiche. - INT8:
quantize=8equantize="w8a16"producono la stessa esportazione. Raggruppa i pesi di ogni layer in 256 valori con k-means e memorizza un indice a 8 bit per ogni peso (palettizzazione), eseguendo i calcoli in FP16 come un'esportazione FP16. I tensori dei pesi con 512 valori o meno non vengono palettizzati. Si tratta di compressione dei pesi, non di quantizzazione delle attivazioni calibrata, selezionata daquantize=8per altri formati; non richiede quindi l'argomentodata. Conscikit-learngiร installato, l'esportazione di un modello di rilevamento YOLO26n ha richiesto da 18 a 26 s su Apple M4 e da 23 a 24 s su un server x86-64; l'esportazione di YOLO26x ha richiesto 104 s sullo stesso server. - Accuratezza: consulta le tabelle Apple M4 per i risultati COCO con ciascuna precisione. Convalida un modello esportato sui tuoi dati prima di distribuirlo.
Formato di output#
L'esportazione scrive un pacchetto, una directory che Xcode, Core ML e coremltools aprono come un singolo modello:
File in yolo26n.mlpackage/ | Contenuti |
|---|---|
Manifest.json | L'elenco dei file nel pacchetto |
Data/com.apple.CoreML/model.mlmodel | Il grafo della rete, le descrizioni di input e output e i metadati: nomi delle classi, task, dimensioni dell'immagine, dimensione del batch, stride e argomenti di esportazione, letti da Ultralytics quando carica il modello |
Data/com.apple.CoreML/weights/weight.bin | I pesi |
Il modello accetta un input denominato image. Nell'esportazione predefinita รจ un input immagine Core ML: un'immagine RGB delle dimensioni di esportazione imgsz, con valori dei pixel da 0 a 255. La divisione per 255 fa parte del modello, quindi non ridimensionare l'immagine manualmente; in un'app, il framework Vision di Apple puรฒ ridimensionare un fotogramma della videocamera per adattarlo a questo input. Un'esportazione con dynamic=True accetta invece un array float32 di forma (batch, 3, height, width), in RGB e con valori ridimensionati a 0-1.
I nomi degli array di output sono generati dal convertitore, ad esempio var_1401, e cambiano a seconda del modello e delle impostazioni di esportazione; leggili quindi dalla descrizione del modello invece di codificarli direttamente. L'argomento nms e il task determinano gli output. Le forme riportate di seguito si riferiscono ai checkpoint ufficiali YOLO26n con le dimensioni predefinite di esportazione e al checkpoint Cityscapes yolo26n-sem.pt per la segmentazione semantica:
| Attivitร | imgsz predefinito | Output con nms=None | Output con nms=False | Output con nms=True |
|---|---|---|---|---|
| Rilevamento | 640 | (1, 84, 8400) | (1, 300, 6) | confidence (boxes, 80) e coordinates (boxes, 4) |
| Segmentazione | 640 | (1, 116, 8400) e (1, 32, 160, 160) | (1, 300, 38) e (1, 32, 160, 160) | (1, 300, 38) e (1, 32, 160, 160) |
| Semantica | 1024 | (1, 1024, 1024), indice della classe per ogni pixel | Come nms=None | Come nms=None |
| Profonditร | 768 | (1, 1, 768, 768), mappa di profonditร | Come nms=None | Come nms=None |
| Classificazione | 224 | classLabel e classLabel_probs | Come nms=None | Come nms=None |
| Posa | 640 | (1, 56, 8400) | (1, 300, 57): 6 valori del riquadro, poi 17 keypoint x 3 | (1, 300, 57) |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 valori del riquadro, punteggio, classe, angolo | Come nms=None |
- Output grezzo (
nms=None): forma(1, values, anchors), le stesse predizioni grezze di un'esportazione ONNX predefinita: per ogni anchor, il centro x e il centro y del riquadro, larghezza e altezza in pixel dell'input, poi i punteggi delle classi e infine i valori del task (32 coefficienti di maschera, 17 x 3 valori dei punti chiave oppure l'angolo OBB in radianti). Applica NMS manualmente. - Output senza NMS (
nms=False):max_det(300 per impostazione predefinita) righe dix1, y1, x2, y2, score, classin pixel dell'input, senza passaggio NMS. Le righe OBB sonocenter x, center y, width, height, score, class, angle. Filtra le righe in base al punteggio. Disponibile per i modelli con head senza NMS, come YOLO26 e YOLOv10. - NMS integrato per il rilevamento (
nms=True): il pacchetto รจ una pipeline Core ML composta dal modello e dalla fase NMS di Apple. Restituisceconfidence, una riga di punteggi di classe per ogni riquadro mantenuto, ecoordinates, il centro x e il centro y, la larghezza e l'altezza di ogni riquadro mantenuto rispetto alle dimensioni dell'immagine (0-1). Il numero di righe varia da un'immagine all'altra.conf(predefinito0.25),iou(predefinito0.5) eagnostic_nmsvengono memorizzati nella pipeline durante l'esportazione; gli inputconfidenceThresholdeiouThreshold, che si possono omettere, sostituiscono le due soglie per una singola predizione.max_detnon ha effetto: un'esportazione conmax_det=2ha comunque restituito cinque riquadri per un'immagine di prova. Se il numero di classi di un modello non รจ multiplo di 80, l'esportazione aggiunge colonne aconfidencefino al multiplo di 80 successivo. - NMS integrato per segmentazione e posa (
nms=True): NMS viene eseguito all'interno del grafo del modello, che restituiscemax_detrighe dix1, y1, x2, y2, score, classseguite dai coefficienti della maschera o dai punti chiave. Le righe successive all'ultimo rilevamento hanno punteggio 0, quindi filtrale in base al punteggio.conf,iou,agnostic_nmsemax_detsono fissati durante l'esportazione, e queste esportazioni sono sempre in FP16 o INT8. - Segmentazione: l'output tridimensionale contiene le predizioni, quello quadridimensionale i prototipi delle maschere.
- Segmentazione semantica: l'output รจ l'indice della classe di ogni pixel come
int32, non un punteggio per ogni classe. - Classificazione: il pacchetto รจ un classificatore Core ML che restituisce
classLabel, il nome della classe con il punteggio piรน alto, eclassLabel_probs, un dizionario di nomi delle classi e probabilitร .coremltoolsrestituisce anche le probabilitร come array(1, classes).
YOLO("yolo26n.mlpackage") legge il layout dai metadati del modello, quindi ti servono questi dettagli solo se esegui il modello nel tuo codice. I metadati sono memorizzati come stringhe nei metadati definiti dall'utente del modello. Le chiavi includono names, task, imgsz, stride, batch, end2end, args e, per i modelli pose, kpt_shape.
Esecuzione con coremltools#
Per eseguire il pacchetto su un Mac senza il pacchetto Ultralytics, caricalo con coremltools, che seleziona anche le unitร di calcolo:
# Esporta prima: yolo export model=yolo26n.pt format=coreml quantize=16 nms=False
import ast
import coremltools as ct
import numpy as np
from PIL import Image
model = ct.models.MLModel("yolo26n.mlpackage", compute_units=ct.ComputeUnit.CPU_AND_NE)
image = Image.fromarray(np.zeros((640, 640, 3), dtype=np.uint8)) # la tua immagine con letterbox: RGB, 0-255
outputs = model.predict({"image": image})
detections = next(iter(outputs.values()))[0] # l'unico array di output, prima immagine: forma (300, 6)
assert detections.shape == (300, 6), "export a detection model at imgsz=640 with nms=False"
detections = detections[detections[:, 4] > 0.25] # mantieni le righe sopra la soglia di confidenza
names = ast.literal_eval(model.user_defined_metadata["names"]) # {0: 'person', 1: 'bicycle', ...}Distribuisci#
Su iPhone o iPad, aggiungi .mlpackage al progetto Xcode oppure usa l'SDK Ultralytics per iOS, che lo carica e decodifica gli output per te. Su Mac, installa il pacchetto con pip install ultralytics e copiale .mlpackage: YOLO("yolo26n.mlpackage") esegue il modello con coremltools, che Ultralytics installa al primo utilizzo.
- Unitร di calcolo: Ultralytics carica un modello con le unitร di calcolo Core ML
CPU_AND_NE, ossia CPU e Neural Engine, e i modelli RT-DETR conALL. Se il modello non si carica con queste unitร , lo carica conCPU_ONLY. Non c'รจ un argomento per scegliere altre unitร di calcolo; per farlo, carica il pacchetto concoremltools. Su Apple M4 con macOS 27.2, ancheALLeCPU_AND_GPUhanno eseguito i modelli FP32, FP16 e INT8 di tutti e sette i task YOLO26n; le altre versioni di macOS non sono state testate. device: l'argomentodevicenon seleziona l'hardware Core ML. Condevice="mps", Ultralytics esegue il pre e postprocessing sulla GPU Apple, mentre Core ML continua a usare le stesse unitร di calcolo. Su M4 questo non ha velocizzato l'inferenza: un modello YOLO26n FP16 ha richiesto circa 8 ms per immagine condevice="mps", contro circa 6 ms senza; lascia quindidevicenon impostato.- Precisione e Neural Engine: su Apple M4, la fase di inferenza di
YOLO()ha richiesto da 18 a 20 ms per immagine inpredictcon un modello YOLO26n FP32 (21,0 ms nella convalida COCO in Apple M4) e circa 6 ms con i modelli FP16 e INT8, per le esportazioni predefinite (nms=None) su un'immagine di prova con macOS 27.2. Usando solocoremltools, gli stessi modelli FP16 e INT8 hanno richiesto circa 2 ms conCPU_AND_NE, contro i 9-10 ms conCPU_ONLY. - Forma di input fissa: un'esportazione predefinita viene sempre eseguita con le dimensioni di esportazione
imgsz, lette da Ultralytics nei metadati del modello. Unimgszpassato apredictovalviene ignorato. Ultralytics passa ogni immagine di un batch a Core ML come richiesta separata per una singola immagine, quindi funziona qualsiasi numero di immagini;valimpostabatch=1. - Esportazione dinamica (
dynamic=True): il modello dichiara dimensioni del batch da 1 fino abatchspecificato per l'esportazione e dimensioni delle immagini da 32 pixel fino al doppio diimgszspecificato per l'esportazione; Ultralytics passa immagini le cui dimensioni sono multipli dello stride del modello. Ultralytics suddivide i batch piรน grandi in blocchi dibatch. Con la head senza NMS, la dimensione minima รจ maggiore: 128 pixel per un modello YOLO26n esportato conimgsz=640enms=False. Testato con un modello di rilevamento a 320, 640 e 1280 pixel e con un modello di segmentazione a 640.
SDK Ultralytics per iOS e plugin Flutter#
L'SDK Ultralytics per iOS รจ un pacchetto Swift che carica le esportazioni Core ML di tutti e sette i task YOLO26 e restituisce risultati decodificati. Esporta con le impostazioni dei modelli ufficiali dell'app:
# INT8 weights and the NMS-free head; use imgsz=224 for classification models
yolo export model=yolo26n.pt format=coreml quantize=8 nms=False imgsz=640Aggiungi https://github.com/ultralytics/yolo-ios-app.git alla tua app con Swift Package Manager, quindi carica il pacchetto esportato:
import UltralyticsYOLO
// Load your exported Core ML model, then run inference on a UIImage
let yolo = YOLO("/path/to/yolo26n.mlpackage", task: .detect) { result in
if case .success(let model) = result {
let results = model(uiImage) // boxes, labels, confidences, timing
}
}L'SDK esegue i modelli Core ML tramite VNCoreMLRequest di Vision, che ridimensiona ogni immagine adattandola all'input del modello. Per le app con videocamera, YOLOView dell'SDK esegue inferenze in tempo reale con sovrapposizioni native, mentre il plugin Ultralytics YOLO per Flutter esegue le stesse esportazioni Core ML su iOS da una base di codice condivisa con Android. Su iOS 16 e versioni successive, l'SDK chiede a Core ML .cpuAndNeuralEngine invece di .all, perchรฉ in un'app con videocamera la GPU รจ giร impegnata con l'anteprima e le sovrapposizioni.
Guide alla distribuzione#
- Integrare un modello Core ML nell'app: guida Apple per aggiungere un modello a un progetto Xcode e richiamarlo.
- Riconoscere oggetti in una ripresa dal vivo: esempio Apple per eseguire un rilevatore Core ML sui fotogrammi della videocamera con Vision e
VNCoreMLRequest. - MLComputeUnits: impostazione
computeUnitsdiMLModelConfigurationche seleziona CPU, GPU e Neural Engine. - Ottimizzare l'uso di Core ML: sessione Apple sui report delle prestazioni di Xcode, che mostrano l'unitร di calcolo e la latenza di ogni layer su un dispositivo.
- Guida a Core ML Tools: riferimento per la conversione e l'ottimizzazione del pacchetto
coremltoolsusato da questa esportazione. - Ultralytics Platform: apri un'esportazione Core ML nell'app Ultralytics YOLO su iPhone, scansionando un codice QR.
- Core AI, LiteRT e Qualcomm QNN: il formato di Apple per iOS 27 e i formati per i dispositivi Android e le NPU Snapdragon.
Limitazioni e risoluzione dei problemi#
- Prima esportazione dopo un'installazione semplice: quando la prima esportazione deve sostituire
numpy(le versioni successive alla 2.3.5 impediscono la conversione), Ultralytics registraRestart runtime or rerun command for updates to take effecte l'esportazione non riesce conTypeError: only 0-dimensional arrays can be converted to Python scalars. Ripeti l'esportazione in un nuovo processo, cioรจ dopo aver riavviato il kernel in un notebook, oppure installa"ultralytics[export-coreml]"prima della prima esportazione, come indicato nella Guida rapida. - Sistema su cui eseguire l'esportazione: l'esportazione viene eseguita su macOS e Linux x86-64. Non รจ supportata su Windows o Linux ARM64, ad esempio su Raspberry Pi:
coremltools9.0 pubblica pacchetti precompilati solo per macOS e Linux x86-64. - Versione di Python:
coremltools9.0 dispone di pacchetti precompilati per Python 3.13 e versioni precedenti. Con Python 3.14,pip install "ultralytics[export-coreml]"non installa alcun pacchetto Core ML, quindi l'esportazione compilacoremltoolsdai sorgenti. La prima esportazione non riesce, come dopo un'installazione semplice; la successiva riesce conRuntimeError: BlobWriter not loaded. Crea l'ambiente con Python 3.13 o una versione precedente. - L'inferenza richiede macOS: su Linux, la predizione o la convalida con
YOLO("yolo26n.mlpackage")non riesce conModel prediction is only supported on macOS version 10.13 or later.. Convalida lรฌ il checkpoint PyTorch oppure copia il pacchetto su un Mac. - Installazione automatica disattivata: con
YOLO_AUTOINSTALL=false, l'esportazione non riesce conNo module named 'coremltools'in un ambiente in cui il pacchetto non รจ installato. - Checkpoint addestrati con
quantize=8: un checkpoint ottimizzato con l'addestramento consapevole della quantizzazione non puรฒ essere esportato conformat='coreml' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Esporta invece il checkpoint da cui hai avviato l'ottimizzazione conquantize=8, oppure esporta il checkpoint ottimizzato in ONNX o TensorRT. quantize="w8a32": non riesce conquantize='w8a32' is not supported; format='coreml' supports quantize=16 (FP16), 8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 32 or None (FP32).. Per Core ML,'w8a16'produce la stessa esportazione di8, con calcolo FP16.- NMS integrato per altri task:
nms=Truefunziona con i modelli detect, segment e pose. Per i modelli OBB e di classificazione, l'esportazione registraCoreML 'nms=True' is only supported for detect, segment and pose models. Forcing 'nms=None'.; per i modelli di segmentazione semantica e stima della profonditร ,'nms=True' is not valid for semantic models. Forcing 'nms=None'.(odepth models); per i modelli RT-DETR,'nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.. Tutti producono l'output di un'esportazione predefinita. - Precisione con NMS integrato: un'esportazione
nms=Truesenzaquantizeรจ in FP16.quantize=32produce una pipeline FP32 per un modello di rilevamento; per i modelli di segmentazione e posa, l'esportazione registraCoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'.(opose models). - NMS integrato e convalida: un'esportazione
nms=Truerimuove i riquadri al di sotto della sogliaconfprima chevalli esamini, quindi ottiene un punteggio inferiore rispetto allo stesso modello con NMS esterno: su COCO val2017, un'esportazione FP16 YOLO26n connms=Trueha raggiunto 33,8 mAPval 50-95 con il valore predefinitoconf=0.25e 39,9 se esportata conconf=0.001, comunque 1,0 in meno rispetto al valore 40,9 di un'esportazione FP16 predefinita. Per convalidare un modello di questo tipo, esportalo conconf=0.001e scegli separatamente la soglia di distribuzione. - Head senza NMS su altri modelli:
nms=Falserichiede un modello con una head senza NMS, come YOLO26 o YOLOv10. Per altri modelli, ad esempio YOLO11, l'esportazione mostra l'avvisoThis model has no one-to-one head; using one-to-many outputs.e scrive l'output grezzo(1, 84, 8400). - Dimensione del batch: un valore
batchsuperiore a 1 senzadynamic=Truenon riesce conbatch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'.. - Forme dinamiche:
dynamic=Truesenzabatchregistra'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.ed esporta un modello con dimensione massima del batch pari a 1. Connms=Truenon riesce con'nms=True' cannot be used together with 'dynamic=True' for CoreML export. Please disable one of them.; per i modelli di classificazione e RT-DETR, non riesce con'dynamic=True' is not supported for CoreML classification or RT-DETR models.. Se le dimensioni di un'immagine non rientrano nell'intervallo, la predizione genera un errore comeSize (1312) of dimension (2) is not in allowed range (32..1280). - Segmentazione semantica sul Neural Engine: su Apple M4, un modello YOLO26n-sem ha richiesto piรน tempo con
CPU_AND_NEche conCPU_ONLY, usando solocoremltoolssu un'immagine di prova: da 59 a 64 ms contro 22 ms per l'esportazione FP16 conimgsz=1024, e circa 15 ms contro 9 ms per l'esportazione INT8 conimgsz=640. I modelli FP16 degli altri sei task e i relativi modelli INT8 conimgsz=640(224 per la classificazione) sono risultati piรน veloci conCPU_AND_NE; anche su iPhone 17 Pro, il modello semantico INT8 รจ risultato piรน veloce con il Neural Engine.YOLO()usa sempreCPU_AND_NEper questi modelli, quindi misura un modello semantico nel tuo codice con entrambe le impostazioni. .cpuOnlysu iOS 27.0.1: su iPhone 17 Pro, l'inferenza.cpuOnlydei modelli YOLO26l e YOLO26x depth, pose e OBB si รจ interrotta nei kernel CPU di Core ML (EXC_BAD_ACCESSinlibBNNS). Funzionano con.cpuAndNeuralEngine, l'impostazione richiesta dall'SDK iOS.- Nome del pacchetto: ogni esportazione dello stesso checkpoint scrive lo stesso
yolo26n.mlpackage, indipendentemente daquantize,imgsz,nmsodynamic; quindi, l'esportazione successiva sostituisce quella precedente. Rinomina il pacchetto per conservarli entrambi e mantieni il suffisso.mlpackage, ad esempioyolo26n_fp16.mlpackage, perchรฉ Ultralytics riconosce il formato tramite questo suffisso. Un pacchetto senza suffisso non riesce conis not a supported model format. - Avviso sulla versione di PyTorch: con una versione recente di PyTorch,
coremltoolsregistraTorch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors.al caricamento; con una versione recente discikit-learn, registrascikit-learn version 1.9.1 is not supported.. Le esportazioni e i risultati su Mac riportati in questa pagina sono stati ottenuti con queste versioni. - File
.mlmodellegacy:format="mlmodel"esporta il precedente formato di rete neurale Core ML come singolo fileyolo26n.mlmodelper le app che non possono caricare un programma ML. In questo caso,quantize=8e'w8a16'applicano una quantizzazione lineare dei pesi a 8 bit. Per i nuovi progetti, usa il valore predefinito.mlpackage.
Per altri errori, consulta la guida ai problemi comuni.
Prestazioni misurate#
Le tabelle seguenti sono state rilevate su iPhone 17 Pro e su un Mac Apple M4. La pagina del modello YOLO26 riporta l'accuratezza dei checkpoint PyTorch per ogni task.
iPhone 17 Pro#
Hardware: iPhone 17 Pro con iOS 26.6. Il suo A19 Pro ha una CPU a 6 core (2 core Performance e 4 core Efficiency), una GPU a 6 core e un Neural Engine a 16 core.
La prima tabella riporta la latenza di una singola immagine per il modello INT8 ufficiale di ciascuna attivitร , usando gli asset v8.3.0 dell'Ultralytics iOS SDK, esportati con nms=False. Ogni cella mostra il tempo totale in millisecondi, con la suddivisione tra preelaborazione, inferenza e postelaborazione indicata sotto; l'unitร di calcolo piรน veloce รจ in grassetto:
| Modello | Attivitร | dimensione (pixel) | CPU Core ML .cpuOnly(ms) | CPU + Neural Engine Core ML .cpuAndNeuralEngine(ms) |
|---|---|---|---|---|
| YOLO26n | Rilevamento | 640 | 9.7 0.0 / 9.7 / 0.0 | 4.7 0.0 / 4.7 / 0.0 |
| YOLO26n-seg | Segmentazione | 640 | 12.8 0.0 / 12.2 / 0.6 | 5.8 0.0 / 5.0 / 0.7 |
| YOLO26n-sem | Semantica | 640 | 9.3 0.0 / 8.9 / 0.5 | 5.3 0.0 / 4.8 / 0.5 |
| YOLO26n-depth | Profonditร | 640 | 25.8 0.0 / 24.8 / 1.0 | 8.0 0.0 / 6.9 / 1.1 |
| YOLO26n-cls | Classificazione | 224 | 2.1 0.0 / 2.0 / 0.0 | 1.8 0.0 / 1.8 / 0.0 |
| YOLO26n-pose | Posa | 640 | 11.9 0.0 / 11.9 / 0.0 | 5.4 0.0 / 5.4 / 0.0 |
| YOLO26n-obb | OBB | 640 | 10.6 0.0 / 10.6 / 0.0 | 4.9 0.0 / 4.9 / 0.0 |
La stessa misurazione per i cinque modelli di rilevamento, insieme al tempo impiegato dall'SDK per caricare ciascun modello:
| Modello | CPU.cpuOnly(ms) | CPU + Neural Engine.cpuAndNeuralEngine(ms) | Caricamento modello.cpuAndNeuralEngine(s) |
|---|---|---|---|
| YOLO26n | 9.2 | 4.5 | 0.9 |
| YOLO26s | 19.5 | 10.5 | 1.3 |
| YOLO26m | 46.7 | 11.8 | 1.8 |
| YOLO26l | 60.1 | 12.0 | 2.4 |
| YOLO26x | 125.9 | 20.5 | 3.3 |
Rilevamento con YOLO26n nelle tre precisioni e con due impostazioni di nms, esportato con ultralytics 8.4.215 su imgsz=640; รจ riportato il tempo totale in millisecondi:
| Precisione | nms=None, CPU | nms=None, CPU + Neural Engine | nms=False, CPU | nms=False, CPU + Neural Engine |
|---|---|---|---|---|
| FP32 | 15.5 | 14.7 | 14.5 | 14.4 |
| FP16 | 9.2 | 4.9 | 9.2 | 5.0 |
| INT8 | 9.2 | 4.2 | 9.1 | 5.0 |
- Metodo: media di 15 predizioni dopo 3 predizioni di riscaldamento su
bus.jpg, eseguite tramite Swift SDK 8.9.23 in una build release..cpuOnlye.cpuAndNeuralEnginesono le unitร di calcolo Core ML richieste dall'SDK; Core ML decide dove viene eseguito ciascun layer. Ogni tabella รจ stata misurata in tre esecuzioni separate e riporta la mediana. Le tre esecuzioni concordavano entro il 15%, tranne YOLO26n con.cpuAndNeuralEngine, che ha impiegato da 2.6 a 4.8 ms nella tabella delle dimensioni e da 3.8 a 4.8 ms nell'esportazionenms=NoneINT8. Le tabelle delle attivitร e delle dimensioni usano gli asset ufficialiv8.3.0, mentre la tabella delle precisioni usa esportazioni create conultralytics8.4.215; per questo le celle relative a YOLO26n differiscono, fino a 0.5 ms con il Neural Engine e 0.6 ms sulla CPU. - Preelaborazione: Vision ridimensiona l'immagine all'interno della richiesta di inferenza, quindi la preelaborazione รจ riportata come 0 e il suo costo รจ incluso nell'inferenza.
- FP32: in base a queste mediane, l'esportazione FP32 รจ stata al massimo il 5% piรน veloce con
.cpuAndNeuralEnginerispetto a.cpuOnly, mentre FP16 e INT8 sono state circa due volte piรน veloci. Per il Neural Engine, esporta in FP16 o INT8. nms: per il rilevamento con YOLO26n, la testa senza NMS (nms=False) e l'output grezzo con NMS nell'SDK (nms=None) hanno impiegato entrambe da 4 a 5 ms con il Neural Engine in FP16 e INT8.- App per fotocamera: queste sono latenze per una singola immagine. Un'app per fotocamera in tempo reale aggiunge il tempo di acquisizione e visualizzazione; consulta le note sulle prestazioni di iOS SDK.
- Confronta i risultati su CPU/GPU Android nell'integrazione LiteRT, i risultati di MediaTek Dimensity e i risultati NPU di Snapdragon nell'integrazione Qualcomm QNN.
Apple M4#
Le tabelle seguenti confrontano PyTorch in FP32, FP16 e INT8 con i modelli Core ML di ogni modello di rilevamento YOLO26 su un Apple M4 (4 core Performance e 6 core Efficiency) con macOS 27.2, convalidati tramite YOLO() su COCO val2017. PyTorch รจ stato eseguito sulla CPU con 8 thread, batch=1 e rect=False, in modo da ricevere lo stesso input 640x640 dei modelli Core ML, eseguiti con le unitร di calcolo predefinite di Ultralytics.
Millisecondi per immagine; valori inferiori sono migliori. Il formato piรน veloce per ogni modello รจ in grassetto.
| Modello | imgsz | PyTorch | Core ML FP32 | Core ML FP16 | Core ML INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 25.6 | 21.0 | 6.0 | 6.0 |
| YOLO26s | 640 | 60.0 | 50.0 | 7.9 | 7.6 |
| YOLO26m | 640 | 137.2 | 127.6 | 14.3 | 11.3 |
| YOLO26l | 640 | 191.2 | 187.7 | 17.2 | 13.5 |
| YOLO26x | 640 | 341.1 | 334.2 | 28.6 | 24.3 |
Con la testa senza NMS (nms=False), YOLO26n ha raggiunto 40.3 mAPval 50-95 in PyTorch e in FP32, 40.2 in FP16 e 40.1 in INT8.
Latenza di YOLO26n con ciascuna unitร di calcolo Core ML, misurata con coremltools soltanto come mediana di 20 predizioni su una singola immagine, in millisecondi:
| Precisione | CPU_ONLY | CPU_AND_NE | ALL | CPU_AND_GPU |
|---|---|---|---|---|
| FP32 | 13.7 | 13.6 | 8.3 | 8.0 |
| FP16 | 9.6 | 1.8 | 2.0 | 7.7 |
| INT8 | 9.4 | 1.8 | 1.8 | 8.1 |
- FP16 e INT8 sono state da 3.5 a 14 volte piรน veloci di FP32 tramite
YOLO(), con un'accuratezza entro 0.1 mAP rispetto a FP32 per FP16 ed entro 0.2 per INT8. INT8 รจ stata veloce quanto FP16 per YOLO26n e fino a 1.3 volte piรน veloce per i modelli piรน grandi. - FP32 ha prodotto gli stessi output con
CPU_AND_NEe conCPU_ONLY. Solo le unitร di calcolo GPU hanno aumentato la velocitร . - INT8 ha ridotto le dimensioni del pacchetto da 3.7 a 4.0 volte rispetto a FP32.
Misurazioni eseguite con ultralytics 8.4.215, coremltools 9.0 e PyTorch 2.15.0 su batch=1 il 17 novembre 2026. La latenza รจ la fase di inferenza riportata da val e non include la preelaborazione o la postelaborazione. Una seconda esecuzione dei tre casi YOLO26n Core ML nello stesso giorno ha mostrato una differenza fino a 2.3 ms: 21.0 contro 18.8 ms per FP32.
Informazioni su Core ML#
Core ML รจ integrato in iOS, iPadOS, macOS, watchOS, tvOS e visionOS. Carica modelli nel formato ML Program, quello usato da .mlpackage per questa esportazione, ed esegue ogni layer sulla CPU, sulla GPU o sull'Apple Neural Engine, l'NPU dei chip Apple, cosรฌ l'inferenza funziona offline e i dati rimangono sul dispositivo. Per la documentazione completa, consulta la documentazione di Core ML.
Guarda: Come esportare Ultralytics YOLO26 in CoreML con quantizzazione INT8 | Distribuzione Apple | iOS/MacOS ๐
Domande frequenti#
Entrambi funzionano sul Neural Engine ed eseguono i calcoli in FP16, quindi la scelta riguarda le dimensioni. FP16 (
quantize=16) dimezza il pacchetto: 5.1 MB contro 9.9 MB per YOLO26n; INT8 (quantize=8) memorizza pesi a 8 bit, 2.7 MB per YOLO26n, ed รจ la precisione dei modelli ufficiali dell'app Ultralytics. Su COCO val2017, un'esportazione YOLO26n predefinita ha raggiunto 40.9 mAPval 50-95 in FP16 e 40.8 in INT8 su Apple M4, con tempi per immagine pressochรฉ uguali. Su iPhone 17 Pro, entrambe hanno impiegato da 4 a 5 ms per YOLO26n con il Neural Engine, rientrando nelle variazioni tra un'esecuzione e l'altra. INT8 richiede iOS 16 o macOS 13, mentre FP16 funziona anche su iOS 15 e macOS 12. Nessuna delle due richiede dati di calibrazione. Evita l'esportazione FP32 predefinita per la distribuzione: รจ la piรน grande ed รจ risultata al massimo il 5% piรน veloce con le unitร di calcolo Neural Engine rispetto alla sola CPU nei nostri test; consulta Precisione. Convalida il modello esportato sui tuoi dati e sul tuo dispositivo prima di distribuirlo.Dipende da chi decodifica l'output. Con Ultralytics iOS SDK o il plugin Flutter, esporta i modelli YOLO26 con
nms=False, come i modelli ufficiali: l'SDK legge quindi i rilevamenti finali della testa senza NMS e non richiede un passaggio NMS. Su COCO val2017, YOLO26n in INT8 ha raggiunto 40.1 mAPval 50-95 con la testa senza NMS, contro 40.8 con l'output predefinito e NMS esterna. Su iPhone 17 Pro, entrambe le opzioni hanno impiegato da 4 a 5 ms per immagine. Con il framework Vision di Apple e il tuo codice,nms=Trueconverte un modello di rilevamento in una pipeline Core ML con la fase NMS di Apple, le cui soglie puoi modificare per ogni predizione. Vision restituisce i rilevamenti come oggettiVNRecognizedObjectObservatione il punteggio di un riquadro รจ ilconfidencedell'osservazione. Non caricare un modello di rilevamentonms=Truecon l'SDK: in un test su iPhone 17 Pro con iOS 26.6, SDK 8.9.23 ha restituito circa 1.0, la confidenza dell'etichetta principale di ogni riquadro, invece dei punteggi dei riquadri. L'impostazione predefinitanms=Nonerestituisce predizioni grezze e lascia la NMS al tuo codice. Consulta Formato dell'output per gli output di ciascuna impostazione.Puoi esportare anche senza: l'esportazione viene eseguita su Linux x86-64 e Ultralytics Platform esporta nel cloud. Per eseguire il modello serve hardware Apple, perchรฉ Core ML fa parte dei sistemi operativi Apple. Su Linux e Windows, convalida il checkpoint PyTorch o un'esportazione ONNX, quindi convalida il modello Core ML stesso su un Mac, dove
YOLO("yolo26n.mlpackage").val()lo esegue, oppure sul dispositivo.
Commenti13
Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.
Afool4U
Hello! I have trouble when I tried to export yolo11n.pt to coreml model with tracking. for example, the exist tracking method is like this:
# use YOLO tracking results = yolo_model.track(frame, persist=True, verbose=False)And I've export pt format and reloaded the new coreml format model like this:
model.export(format='coreml', nms=True, half=False) model = ct.models.MLModel('yolo11n.mlpackage')But when I tried to make a tracking on my camera stream, it seems that object 'model' have no attribute named 'track'. So how could I use tracking by a coreml format model? It's very important to me because the coreml model works well on my macbook.
Sebastianxhj
I used the example python code you guys gave. Why does output output confidence and coordination after converting my target detection model to mlpackage format. is it normal to not return processed images? Or is there something wrong with my export process.
Glenn JocherUltralytics@taeja7 the CoreML export returns raw detection outputs (confidence, coordinates) rather than processed images by design. This is normal behavior, as post-processing like bounding box rendering is typically handled within the application layer after inference. For implementation guidance, see the CoreML deployment documentation on handling model outputs in Apple apps.
smadsenjc
I have a trained model that is doing very well in Python, but once I convert it to CoreML
.mlpackageformat and run inference in Swift, the results are garbage on the same images.If I export with
nms=True, I get multiple overlapping bounding boxes back, similar-ish to when no NMS is done. The number of clusters matches the objects I expect, and they're kind of relatively positioned correctly, although the boxes themselves are too large and clustered in the wrong location. The predicted labels are right.If I export with
nms=False, I get a different result back fromVNCoreMLRequest: a singleVNCoreMLFeatureValueObservationinstead of an array ofVNRecognizedObjectObservation.I've used both coremltools 8.0 and 8.2. If I run inference in Python using the CoreML model, it's fine (with
nms=False;Truefails).This was working back in November, but I got side-tracked with other work. I haven't touched the model.
Glenn JocherUltralytics@smadsenjc for CoreML inference discrepancies between Python and Swift, ensure you're handling NMS parameters correctly in your Swift implementation. The CoreML export with
nms=Truerequires explicit IOU and confidence threshold inputs during inference - these must match your Python training parameters. We recommend verifying your Swift preprocessing matches Ultralytics' RGB channel ordering and normalization (scale=1/255, bias=[0,0,0]). For direct assistance with Apple's Vision framework implementation, refer to Apple's CoreML integration guide linked in our documentation.
CharanPrasadK
When I am Converting the Yolo .pt model to coreml model , mlpackage is creating and when I am checking it in the xcode the class labels are missing. For the core ml models in ultralytics github page class labels are there. If its solved i can test my custom yolo models. Thank you.
Glenn JocherUltralytics(modificato)@CharanPrasadK it seems the class labels are not being included in your CoreML export. Ensure that your model is correctly labeled during training and export by checking the
namesattribute in the model. If the issue persists, please verify that you're using the latestultralyticspackage. For further details, refer to the CoreML export documentation. Let us know if you need additional assistance!
ChristalZhu
Still the same problem, this is the result of running in the terminal๏ผ PyTorch: starting from '/Users/doublepeng/Desktop/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) ((1, 37, 8400), (1, 32, 160, 160)) (6.5 MB)
CoreML: starting export with coremltools 7.2... CoreML: WARNING โ ๏ธ 'nms=True' is only available for Detect models like 'yolov8n.pt'. Tuple detected at graph output. This will be flattened in the converted model. Converting PyTorch Frontend ==> MIL Ops: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 679/681 [00:00<00:00, 8273.25 ops/s] Running MIL frontend_pytorch pipeline: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 5/5 [00:00<00:00, 157.94 passes/s] Running MIL default pipeline: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 78/78 [00:00<00:00, 82.56 passes/s] Running MIL backend_mlprogram pipeline: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 12/12 [00:00<00:00, 160.71 passes/s] CoreML: export success โ 7.7s, saved as '/Users/doublepeng/Desktop/best.mlpackage' (6.4 MB)
Export complete (8.1s) Results saved to /Users/doublepeng/Desktop Predict: yolo predict task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 Validate: yolo val task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 data=/home/yujialin/Documents/xiaotong/corn/data/corn.yaml Visualize: https://netron.app In the run mlpackage file, the class label is still missing in General, and there is no preview. Since I am only doing corn segmentation, if possible, can I send you my .pt file?
Glenn JocherUltralytics@ChristalZhu hello,
Thank you for providing the detailed output from your terminal. It looks like the CoreML export process completed successfully, but you're experiencing issues with missing class labels and preview in the
.mlpackagefile.To assist you better, could you please confirm the following:
- Are you using the latest versions of
torchandultralytics? If not, please upgrade and try the export process again. - Could you provide a minimum reproducible example of your code? This will help us understand the context and reproduce the issue on our end. You can refer to our minimum reproducible example guide for more details.
Regarding your
.ptfile, we cannot accept direct file submissions. However, you can share the relevant code snippets and configurations you used for training and exporting the model.Here's a quick example of how to export a YOLOv8 model to CoreML and run inference:
from ultralytics import YOLO # Load the YOLOv8 model model = YOLO("yolov8n.pt") # Export the model to CoreML format model.export(format="coreml") # creates 'yolov8n.mlpackage' # Load the exported CoreML model coreml_model = YOLO("yolov8n.mlpackage") # Run inference results = coreml_model("https://ultralytics.com/images/bus.jpg")For more detailed instructions, you can visit our CoreML integration guide.
Looking forward to your response so we can help resolve this issue.
- Are you using the latest versions of
ChristalZhu
ๆๆ็ งhttps://harshavardhanyellanki.github.io/YOLOV8_GUI/tasks/segmentation/็ๆนๆณ๏ผๅฐๆ่ชๅทฑ่ฎญ็ป็ๅๅฒๆจกๅ่ฟ่กๅฏผๅบๆmlpackage๏ผไฝๆฏๅบ็ฐไบ้ฎ้ขๅฐฑๆฏๆๅผ่ฟไธชmlpackageไนๅ๏ผ็ผบๅฐclass labelๆไปถๅ็ผบๅฐไบpreview๏ผ่ฏท้ฎ่ฟไธชๆไปไนๅๆณ่งฃๅณ๏ผๅฆๆๅฏไปฅ็่ฏ๏ผ้บป็ฆๅ้ๅฐๆ็email่ดฆๅท๏ผwenpeng.zhu@foxmail.comไธๅๆ่ฐขใ I followed the method at https://harshavardhanyellanki.github.io/YOLOV8_GUI/tasks/segmentation/ to export the segmentation model I trained myself into mlpackage, but the problem is that after opening this mlpackage, the class label file and the preview are missing. Is there any way to solve this problem? If possible, please send it to my email account: wenpeng.zhu@foxmail.com. Thank you very much.
Paula DerrengerUltralyticsHello @ChristalZhu,
Thank you for reaching out and providing details about the issue you're facing with exporting your YOLOv8 segmentation model to CoreML. Let's work together to resolve this.
Firstly, please ensure that you are using the latest versions of
torchandultralytics. You can update them using the following commands:pip install --upgrade torch ultralyticsIf the issue persists, could you please provide a minimum reproducible code example? This will help us better understand the problem and investigate a solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.
Regarding the missing class label file and preview in the
.mlpackage, this can sometimes occur if the export process does not include all necessary metadata. Here is a Python example to ensure the export includes all required components:from ultralytics import YOLO # Load your trained YOLOv8 model model = YOLO("path/to/your/custom_model.pt") # Export the model to CoreML format model.export(format="coreml", nms=True) # Ensure NMS is included for proper detectionAfter exporting, you can manually check the
.mlpackageto ensure it contains the necessary class labels and preview files. If they are still missing, please let us know, and we can further investigate.For more detailed instructions on exporting to CoreML, you can visit our documentation here: CoreML Export Guide.
Feel free to share any additional details or errors you encounter. We're here to help!
ChristalZhu
Still the same problem, this is the result of running in the terminal๏ผ PyTorch: starting from '/Users/doublepeng/Desktop/best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) ((1, 37, 8400), (1, 32, 160, 160)) (6.5 MB)
CoreML: starting export with coremltools 7.2... CoreML: WARNING โ ๏ธ 'nms=True' is only available for Detect models like 'yolov8n.pt'. Tuple detected at graph output. This will be flattened in the converted model. Converting PyTorch Frontend ==> MIL Ops: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 679/681 [00:00<00:00, 8273.25 ops/s] Running MIL frontend_pytorch pipeline: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 5/5 [00:00<00:00, 157.94 passes/s] Running MIL default pipeline: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 78/78 [00:00<00:00, 82.56 passes/s] Running MIL backend_mlprogram pipeline: 100%|โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ| 12/12 [00:00<00:00, 160.71 passes/s] CoreML: export success โ 7.7s, saved as '/Users/doublepeng/Desktop/best.mlpackage' (6.4 MB)
Export complete (8.1s) Results saved to /Users/doublepeng/Desktop Predict: yolo predict task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640
Validate: yolo val task=segment model=/Users/doublepeng/Desktop/best.mlpackage imgsz=640 data=/home/yujialin/Documents/xiaotong/corn/data/corn.yaml
Visualize: https://netron.app In the run mlpackage file, the class label is still missing in General, and there is no preview. Since I am only doing corn segmentation, if possible, can I send you my .pt file?
Paula DerrengerUltralyticsHello @ChristalZhu,
Thank you for providing the detailed output from your terminal. It looks like the CoreML export process completed successfully, but you're encountering issues with missing class labels and preview in the
.mlpackage.To address this, please ensure you are using the latest versions of
torchandultralytics. You can update them using the following commands:pip install --upgrade torch ultralyticsIf the issue persists, could you please provide a minimum reproducible code example? This will help us better understand the problem and investigate a solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.
Regarding the missing class label file and preview in the
.mlpackage, this can sometimes occur if the export process does not include all necessary metadata. Here is a Python example to ensure the export includes all required components:from ultralytics import YOLO # Load your trained YOLOv8 model model = YOLO("path/to/your/custom_model.pt") # Export the model to CoreML format model.export(format="coreml", nms=True) # Ensure NMS is included for proper detectionAfter exporting, you can manually check the
.mlpackageto ensure it contains the necessary class labels and preview files. If they are still missing, please let us know, and we can further investigate.For more detailed instructions on exporting to CoreML, you can visit our documentation here: CoreML Export Guide.
Feel free to share any additional details or errors you encounter. We're here to help! ๐
