Apple Core ML Dışa Aktarımı
Core ML, iPhone, iPad, Mac, Apple Watch, Apple TV ve Apple Vision Pro'da makine öğrenimi modellerini çalıştırmaya yönelik Apple çerçevesidir. Bir Ultralytics YOLO26 modelini format="coreml" ile dışa aktarmak, Core ML'nin CPU, GPU ve Apple Neural Engine üzerinde FP32, FP16 veya 8 bit ağırlıklarla çalıştırdığı bir yolo26n.mlpackage model paketi oluşturur.
Apple, iOS 27 ve macOS 27 nesli için yeni Core AI çerçevesini ve .aimodel biçimini tanıttı; Ultralytics bunu format="coreai" ile dışa aktarır. Core ML, Ultralytics iOS ve Flutter SDK'larının varsayılan biçimi olmaya devam eder; bu SDK'lar iOS 27 aygıtlarında Core AI'ı isteğe bağlı olarak yükler. Core ML ayrıca önceki Apple işletim sistemleri için kullanılan biçimdir.
Genel Bakış#
| Özellik | Ayrıntılar |
|---|---|
format bağımsız değişkeni | coreml (diğer adları: mlpackage, mlprogram, apple, ios). mlmodel, önceki sinir ağı biçimini dışa aktarır |
| Çıktı | yolo26n.mlpackage, ML Program biçiminde, sınıf adları, görev ve görüntü boyutu meta veri olarak içinde saklanan bir model paketi (dizin) |
| Çalıştığı ortamlar | iPhone, iPad, Mac, Apple Watch, Apple TV ve Apple Vision Pro'da, CPU, GPU ve Apple Neural Engine üzerinde |
| Çalışma zamanı | Apple'ın işletim sistemlerinde yerleşik olan Core ML; dışa aktarılan ML Program, Core ML belirtimi 6'yı (iOS 15, macOS 12) veya INT8 için belirtim 7'yi (iOS 16, macOS 13) tanımlar. Python'da, macOS üzerindeki coremltools paketi |
| Kesinlik | FP32, FP16, INT8 (8 bit ağırlıklar). YOLO26n, FP32'de 9,9 MB, FP16'da 5,1 MB ve INT8'de 2,7 MB'tır |
| Dışa aktarma ana makinesi | macOS veya Linux x86-64; Python 3.13 ya da daha eski bir sürüm gerekir. Windows desteklenmez. Dışa aktarma için GPU gerekmez |
Ultralytics Platform, eğitilmiş bir modeli senin için Core ML'ye aktarabilir; böylece yerel bir dışa aktarma ortamına ihtiyacın olmaz.
Hızlı Başlangıç#
Ultralytics paketini, macOS veya x86-64 Linux üzerinde Core ML dışa aktarma bağımlılıklarıyla birlikte yükle:
pip install "ultralytics[export-coreml]"Bu işlem coremltools, scikit-learn ve coremltools ile çalışan numpy sürümünü yükler. Yalın bir pip install ultralytics ile ilk dışa aktarma coremltools öğesini yükler; daha yeni bir numpy öğesini de değiştirmesi gerektiğinde bu dışa aktarma başarısız olur; sonraki dışa aktarma başarılı olur. Dışa aktarma şu sürüm gereksinimlerine sahiptir:
| Paket | Gerekli sürüm |
|---|---|
| Python | 3.13 veya daha eski; coremltools 9.0 sürümünün önceden derlenmiş paketlerini sunduğu en yeni sürüm |
coremltools | 9.0 veya daha yeni |
numpy | 2.3.5 veya daha eski. Dışa aktarma, daha yeni bir sürümün üzerine 2.3.5'i yükler |
torch | 1.11 veya daha yeni |
scikit-learn | Yalnızca quantize=8 ve 'w8a16' için. export-coreml eki 1.3.2 veya daha yeni bir sürümü yükler; eksikse dışa aktarma bu sürümü yükler |
Diğer yükleme yöntemleri için yükleme kılavuzuna bak. Ardından modelini dışa aktar ve çıkarım yapmak ya da doğruluğunu doğrulamak için dışa aktarılan paketi yükle.
from ultralytics import YOLO
# YOLO26 modelini yükle
model = YOLO("yolo26n.pt")
# Modeli Core ML biçimine aktar
model.export(format="coreml") # 'yolo26n.mlpackage' oluşturur
# Veya bunun yerine boyutu yarıya indiren ve Neural Engine üzerinde çalışan FP16 biçiminde dışa aktar
model.export(format="coreml", quantize=16) # 'yolo26n.mlpackage' oluştururHer iki dışa aktarma da aynı yolo26n.mlpackage dosyasına yazar; dolayısıyla ikincisi ilkinin üzerine yazar. Predict ve Validate yalnızca macOS üzerinde çalışır:
from ultralytics import YOLO
# Dışa aktarılan Core ML modelini Mac'te yükle
model = YOLO("yolo26n.mlpackage")
# Çıkarımı çalıştır
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Dışa aktarılan Core ML modelini Mac'te yükle
model = YOLO("yolo26n.mlpackage")
# COCO8 veri kümesinde doğruluğu doğrula
metrics = model.val(data="coco8.yaml")Desteklenen Görevler#
Core ML dışa aktarımı, YOLOv8, YOLO11 ve YOLO26 modelleriyle Ultralytics'in yedi görevinin tümünü destekler: nesne tespiti, segmentasyon, anlamsal segmentasyon, derinlik tahmini, sınıflandırma, poz tahmini ve OBB. Anlamsal segmentasyon ve derinlik tahmini yalnızca bu başlıkları içeren tek aile olan YOLO26'da kullanılabilir. YOLOv5u, YOLOv9, YOLOv10 ve YOLO12'nin tespit modelleri de dışa aktarılır; RT-DETR ve YOLO-Worldv2 modelleri de öyle. Her biri, her görev için bir kontrol noktasıyla test edildi; örneğin yolo11n-seg.pt, rtdetr-l.pt ve yolov8s-worldv2.pt.
Dışa Aktarma Bağımsız Değişkenleri#
| Bağımsız değişken | Tür | Varsayılan | Açıklama |
|---|---|---|---|
format | str | 'coreml' | Dışa aktarılan modelin hedef biçimi; çeşitli dağıtım ortamlarıyla uyumluluğu tanımlar. |
imgsz | int veya tuple | 640 | Varsayılan dışa aktarmada sabitlenen model girdisinin görüntü boyutu: kare görüntüler için bir tam sayı veya (height, width) demeti. Belirtilmezse dışa aktarma, kontrol noktasının eğitildiği boyutu kullanır. Resmî YOLO26 kontrol noktaları; tespit, segmentasyon ve poz modelleri ile ADE20K üzerinde önceden eğitilmiş anlamsal modeller için 640, OBB modelleri ve Cityscapes üzerinde önceden eğitilmiş anlamsal modeller için 1024, derinlik için 768 ve sınıflandırma için 224 kullanır. |
quantize | int veya str | None | Hassasiyet: 16 (FP16) veya 8 (FP16 hesaplamayla 8 bit ağırlıklar; 'w8a16' aynı dışa aktarmadır); 32/belirtilmemesi FP32 anlamına gelir. nms=True ile belirtilmezse FP16 kullanılır. quantize=8 ile eğitilmiş bir kontrol noktası Core ML'ye aktarılamaz; Sınırlamalar ve Sorun Giderme bölümüne bak. Kullanımdan kaldırılan half/int8 bayraklarının yerini alır. |
nms | bool, isteğe bağlı | None | Ham çıktıyı (None, varsayılan), yerleşik NMS'yi (True, dynamic=False kullanan algılama, segmentasyon ve poz modelleri için) veya NMS içermeyen başlığı (False) seç. Bkz. çıktı biçimi. |
conf | float | None | nms=True dışa aktarımında saklanan güven eşiği. Belirtilmezse 0.25 kullanılır. |
iou | float | 0.5 | nms=True dışa aktarımında saklanan IoU eşiği. |
agnostic_nms | bool | False | Sınıftan bağımsız seçim: nms=True dışa aktarımında bir kutu, diğer sınıflardaki örtüşen kutuları da bastırır. Ayrıca nms=False dışa aktarımında satır seçimini de değiştirir. |
max_det | int | 300 | nms=False dışa aktarımının ve nms=True segmentasyon ya da poz dışa aktarımının çıktısındaki satır sayısı. nms=True tespit dışa aktarımında böyle bir sınır yoktur. |
dynamic | bool | False | Girdi için grup boyutunu, yüksekliği ve genişliği dinamik hâle getirir ve girdiyi görüntü yerine dizi olarak değiştirir. Sınıflandırma ve RT-DETR modellerinde veya nms=True ile kullanılamaz. Dağıtım bölümüne bak. |
batch | int | 1 | dynamic=True dışa aktarımının en büyük grup boyutu. Varsayılan dışa aktarmada grup boyutu 1'dir; diğer değerler hata oluşturur. |
device | str | None | Dönüştürme için modeli izleyen aygıt; varsayılan olarak cpu. mps ile izlenen bir FP32 dışa aktarımı, CPU üzerinde izlenenle aynı paket boyutuna sahipti ve aynı çıktıları döndürdü. |
Tüm biçimlerde ortak olan bağımsız değişkenler için Dışa aktarma modu belgelerine bak.
Resmî Core ML, LiteRT ve QNN mobil modelleri imgsz=640 boyutunda, sınıflandırma içinse imgsz=224 boyutunda dışa aktarılır. Cityscapes anlamsal segmentasyon, derinlik ve OBB kontrol noktaları varsayılan olarak daha büyük boyutta dışa aktarılır; bunlarla eşleşmesi için imgsz=640 değerini geçir. Ultralytics iOS SDK Core ML modelleri quantize=8 nms=False ile dışa aktarılır.
Kesinlik#
quantize, ağırlıkların nasıl saklanacağını ve Core ML'nin hangi hassasiyette hesaplama yapacağını belirler. Üç hassasiyetin hiçbiri kalibrasyon verisi gerektirmez. Boyutlar, imgsz=640 boyutunda dışa aktarılan YOLO26n tespit modeli içindir:
quantize | Ağırlıklar | Hesaplama | En düşük işletim sistemi sürümü | YOLO26n boyutu |
|---|---|---|---|---|
belirtilmemiş veya 32 | FP32 | FP32 | iOS 15, macOS 12 | 9.9 MB |
16 | FP16 | FP16 | iOS 15, macOS 12 | 5.1 MB |
8 veya 'w8a16' | 8 bit | FP16 | iOS 16, macOS 13 | 2.7 MB |
- FP32:
nms=Trueayarlanmadığında varsayılan değerdir. Apple M4 üzerinde, yedi görevin tümüne ait FP32 dışa aktarımları Ultralytics'in kullandığıCPU_AND_NEhesaplama birimleriyle,CPU_ONLYile aynı çıktıları döndürdü ve bu birimlerle daha hızlı çalışmadı. Neural Engine'i kullanmak için FP16 veya INT8 biçiminde dışa aktar. iPhone 17 Pro'da FP32 YOLO26n tespit modeli, üç çalıştırmanın ortanca süresine göre Neural Engine ile en fazla %5 daha hızlıydı; Ölçülen Performans bölümüne bak. - FP16:
quantize=16, ağırlıkları saklar ve yarı hassasiyette hesaplama yapar. Görüntü girdisi ve çıktı dizileri, FP32 dışa aktarımının türlerini korur (float32veya anlamsal segmentasyon içinint32); bu nedenle FP32 modeli için yazılmış çıkarım kodu, hiçbir değişiklik yapılmadan çalışır. - INT8:
quantize=8vequantize="w8a16"aynı dışa aktarmadır. Her katmanın ağırlıklarını k-means ile 256 değerlik gruplara ayırır ve her ağırlık için 8 bitlik bir indeks saklar (paletleştirme); hesaplamayı FP16 dışa aktarımı gibi FP16 ile yapar. 512 veya daha az değer içeren ağırlık tensörleri paletleştirilmez. Bu, ağırlık sıkıştırmasıdır;quantize=8seçeneğinin diğer biçimler için belirlediği kalibre edilmiş etkinleştirme nicelemesi değildir; bu nedenledatabağımsız değişkeni almaz.scikit-learnzaten yüklüyken YOLO26n tespit modelinin dışa aktarımı Apple M4'te 18–26 sn, x86-64 sunucuda 23–24 sn sürdü; YOLO26x'in dışa aktarımı aynı sunucuda 104 sn sürdü. - Doğruluk: Her hassasiyetteki COCO sonuçları için Apple M4 tablolarına bak. Dağıtıma almadan önce dışa aktarılan modeli kendi verilerinle doğrula.
Çıktı Biçimi#
Dışa aktarma, Xcode, Core ML ve coremltools uygulamalarının tek bir model olarak açtığı bir dizin olan tek bir paket yazar:
yolo26n.mlpackage/ içindeki dosya | İçindekiler |
|---|---|
Manifest.json | Paketteki dosyaların listesi |
Data/com.apple.CoreML/model.mlmodel | Ağ grafiği, girdi ve çıktı açıklamaları ile meta veriler: sınıf adları, görev, görüntü boyutu, grup boyutu, adım boyutu ve dışa aktarma bağımsız değişkenleri; Ultralytics modeli yüklerken bunları okur |
Data/com.apple.CoreML/weights/weight.bin | Ağırlıklar |
Model, image adlı tek bir girdi alır. Varsayılan dışa aktarmada bu, Core ML görüntü girdisidir: dışa aktarma imgsz boyutlarında, piksel değerleri 0 ile 255 arasında olan bir RGB görüntüsü. 255'e bölme işlemi modelin içindedir; bu nedenle görüntüyü kendin ölçeklendirme. Bir uygulamada Apple'ın Vision çerçevesi, kamera karesini bu girdiye göre yeniden boyutlandırabilir. dynamic=True ile dışa aktarılan model bunun yerine (batch, 3, height, width) biçimindeki bir float32 dizisi alır; bu dizi RGB'dir ve 0-1 aralığına ölçeklendirilmiştir.
var_1401 gibi çıktı dizilerinin adları dönüştürücü tarafından oluşturulur ve modeller ile dışa aktarma ayarları arasında değişir; bu nedenle adları sabit kodlamak yerine model açıklamasından oku. nms bağımsız değişkeni ve görev, çıktıları belirler. Aşağıdaki şekiller, anlamsal segmentasyon için Cityscapes kontrol noktası yolo26n-sem.pt dâhil, varsayılan dışa aktarma boyutlarındaki resmî YOLO26n kontrol noktalarına aittir:
| Görev | Varsayılan imgsz | nms=None ile çıktı | nms=False ile çıktı | nms=True ile çıktı |
|---|---|---|---|---|
| Detect | 640 | (1, 84, 8400) | (1, 300, 6) | confidence (boxes, 80) ve coordinates (boxes, 4) |
| Segment | 640 | (1, 116, 8400) ve (1, 32, 160, 160) | (1, 300, 38) ve (1, 32, 160, 160) | (1, 300, 38) ve (1, 32, 160, 160) |
| Anlamsal | 1024 | (1, 1024, 1024), her piksel için sınıf indeksi | nms=None ile aynı | nms=None ile aynı |
| Derinlik | 768 | (1, 1, 768, 768), derinlik haritası | nms=None ile aynı | nms=None ile aynı |
| Sınıflandırma | 224 | classLabel ve classLabel_probs | nms=None ile aynı | nms=None ile aynı |
| Poz | 640 | (1, 56, 8400) | (1, 300, 57): 6 kutu değeri, ardından 17 anahtar nokta x 3 | (1, 300, 57) |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 kutu değeri, skor, sınıf, açı | nms=None ile aynı |
- Ham çıktı (
nms=None):(1, values, anchors)biçiminde; varsayılan bir ONNX dışa aktarımı ile aynı ham tahminler: her bağlantı noktası için girdi piksellerinde kutu merkezi x, kutu merkezi y, genişlik ve yükseklik; ardından sınıf puanları ve görev değerleri (32 maske katsayısı, 17 x 3 kilit nokta değeri veya radyan cinsinden OBB açısı). NMS'yi kendin uygula. - NMS içermeyen çıktı (
nms=False): Girdi piksellerindex1, y1, x2, y2, score, classdeğerinden oluşanmax_detsatır (varsayılan 300); NMS adımı yoktur. OBB satırlarıcenter x, center y, width, height, score, class, anglebiçimindedir. Satırları puana göre filtrele. YOLO26 ve YOLOv10 gibi NMS içermeyen başlığa sahip modellerde kullanılabilir. - Tespit için yerleşik NMS (
nms=True): paket, modelden ve Apple'ın NMS aşamasından oluşan bir Core ML işlem hattıdır.confidencedeğerini (tutulan her kutu için bir satır sınıf puanını) vecoordinatesdeğerini (görüntü boyutuna göre 0-1 aralığında, tutulan her kutunun kutu merkezi x, kutu merkezi y, genişlik ve yüksekliğini) döndürür. Satır sayısı görüntüden görüntüye değişir.conf(varsayılan0.25),iou(varsayılan0.5) veagnostic_nmsdışa aktarma sırasında işlem hattında saklanır; atlanabilenconfidenceThresholdveiouThresholdgirdileri ise tek bir tahmin için iki eşiğin yerini alır.max_detuygulanmaz:max_det=2ile yapılan dışa aktarma, bir test görüntüsü için yine de beş kutu döndürdü. Sınıf sayısı 80'in katı olmayan bir modelde dışa aktarma,confidencedeğerine bir sonraki 80 katına ulaşana kadar ek sütunlar ekler. - Segmentasyon ve poz için yerleşik NMS (
nms=True): NMS model grafiğinin içinde çalışır ve ardından maske katsayıları ya da kilit noktalarla birliktex1, y1, x2, y2, score, classdeğerinden oluşanmax_detsatırı döndürür. Son tespitin ardından gelen satırların puanı 0'dır; bu nedenle satırları puana göre filtrele.conf,iou,agnostic_nmsvemax_detdışa aktarma sırasında sabitlenir; bu dışa aktarımlar her zaman FP16 veya INT8 biçimindedir. - Segmentasyon: 3 boyutlu çıktı tahminleri, 4 boyutlu çıktı ise maske prototiplerini içerir.
- Anlamsal segmentasyon: çıktı, her sınıf için bir puan değil,
int32olarak her pikselin sınıf indeksidir. - Sınıflandırma: paket, Core ML sınıflandırıcısıdır ve en üst sıradaki sınıfın adını içeren
classLabeldeğerini ve sınıf adlarıyla olasılıkların sözlüğü olanclassLabel_probsdeğerini döndürür.coremltools, olasılıkları(1, classes)dizisi olarak da döndürür.
YOLO("yolo26n.mlpackage"), düzeni model meta verilerinden okur; bu nedenle modeli yalnızca kendi kodunda çalıştırırken şu ayrıntılara ihtiyacın olur. Meta veriler, modelin kullanıcı tanımlı meta verilerinde dizeler olarak saklanır. Anahtarlar arasında names, task, imgsz, stride, batch, end2end, args ve poz modelleri için kpt_shape bulunur.
coremltools ile çalıştırma#
Paketi Mac'te Ultralytics paketi dışında çalıştırmak için coremltools ile yükle; bu işlem aynı zamanda hesaplama birimlerini seçer:
# Önce dışa aktar: 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)) # letterbox uygulanmış görüntün: RGB, 0-255
outputs = model.predict({"image": image})
detections = next(iter(outputs.values()))[0] # tek çıktı dizisi, ilk görüntü: şekil (300, 6)
assert detections.shape == (300, 6), "export a detection model at imgsz=640 with nms=False"
detections = detections[detections[:, 4] > 0.25] # güven eşiğinin üzerindeki satırları tut
names = ast.literal_eval(model.user_defined_metadata["names"]) # {0: 'person', 1: 'bicycle', ...}Dağıt#
iPhone veya iPad'de .mlpackage öğesini Xcode projenize ekle ya da bu öğeyi senin için yükleyip çıktıları çözen Ultralytics iOS SDK'yi kullan. Mac'te paketi pip install ultralytics ile yükle ve .mlpackage dosyasını içine kopyala: YOLO("yolo26n.mlpackage"), modeli Ultralytics'in ilk kullanımda yüklediği coremltools ile çalıştırır.
- Hesaplama birimleri: Ultralytics, modeli Core ML hesaplama birimleri
CPU_AND_NE(CPU ve Neural Engine) ile, RT-DETR modellerini iseALLile yükler. Model bunlarla yüklenmezseCPU_ONLYile yükler. Başka hesaplama birimleri seçmek için bir bağımsız değişken yoktur; bunu yapmak için paketicoremltoolsile yükle. macOS 27.2 yüklü Apple M4 üzerindeALLveCPU_AND_GPU, yedi YOLO26n görevinin tümüne ait FP32, FP16 ve INT8 modellerini de çalıştırdı; diğer macOS sürümleri test edilmedi. device:devicebağımsız değişkeni Core ML donanımını seçmez.device="mps"ile Ultralytics, ön ve son işlemeyi Apple GPU'sunda yaparken Core ML aynı hesaplama birimlerini kullanmaya devam eder. M4 üzerinde bu, çıkarımı hızlandırmadı: FP16 YOLO26n modelidevice="mps"ile görüntü başına yaklaşık 8 ms, bu seçenek olmadan yaklaşık 6 ms sürdü; bu nedenledevicedeğerini ayarlama.- Hassasiyet ve Neural Engine: Apple M4 üzerinde
YOLO()çıkarım aşaması, FP32 YOLO26n modeli içinpredictile görüntü başına 18–20 ms sürdü (Apple M4 sayfasındaki COCO doğrulamasında 21,0 ms); FP16 ve INT8 modellerinde ise macOS 27.2 ile tek bir test görüntüsünde, varsayılan (nms=None) dışa aktarımlar için yaklaşık 6 ms sürdü. Yalnızcacoremltoolskullanıldığında aynı FP16 ve INT8 modelleriCPU_AND_NEile yaklaşık 2 ms,CPU_ONLYile 9–10 ms sürdü. - Sabit girdi şekli: varsayılan bir dışa aktarma her zaman dışa aktarma
imgszdeğerinde çalışır; Ultralytics bunu model meta verilerinden okur.predictveyavalöğesine geçirilenimgszyok sayılır. Ultralytics, bir gruptaki her görüntüyü ayrı bir tek görüntülü istek olarak Core ML'ye iletir; bu nedenle herhangi bir sayıda görüntü kullanılabilir veval,batch=1değerini ayarlar. - Dinamik dışa aktarma (
dynamic=True): model, batch boyutlarını 1'den dışa aktarma için kullanılanbatchdeğerine kadar, görüntü boyutlarını ise 32 pikselden dışa aktarma için kullanılanimgszdeğerinin iki katına kadar tanımlar; Ultralytics, görüntü boyutlarını modelin adım boyutunun katları olacak şekilde iletir. Ultralytics, daha büyük batch'leri dışa aktarma için kullanılanbatchboyutunda parçalara böler. NMS içermeyen başlıkta en küçük boyut daha büyüktür:imgsz=640boyutunda venms=Falseile dışa aktarılan bir YOLO26n modeli için bu değer 128 pikseldir. Bir algılama modeli 320, 640 ve 1280 piksel çözünürlüklerinde, bir segmentasyon modeli ise 640 piksel çözünürlüğünde test edildi.
Ultralytics iOS SDK ve Flutter Eklentisi#
Ultralytics iOS SDK, yedi YOLO26 görevinin tümüne ait Core ML dışa aktarımlarını yükleyen ve çözümlenmiş sonuçları döndüren bir Swift paketidir. Resmî uygulama modellerinin ayarlarıyla dışa aktar:
# 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=640Swift Package Manager ile uygulamana https://github.com/ultralytics/yolo-ios-app.git ekle, ardından dışa aktarılan paketi yükle:
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
}
}SDK, Core ML modellerini Vision'ın VNCoreMLRequest bileşeni üzerinden çalıştırır; bu bileşen her görüntüyü model girdisi boyutuna ölçeklendirir. Kamera uygulamaları için SDK'nın YOLOView bileşeni, yerel bindirmelerle gerçek zamanlı çıkarım yapar; Ultralytics YOLO Flutter eklentisi ise aynı Core ML dışa aktarımlarını Android ile ortak bir kod tabanından iOS üzerinde çalıştırır. Kamera uygulamasında GPU önizleme ve bindirmelerle zaten meşgul olduğundan SDK, iOS 16 ve sonraki sürümlerde Core ML'den .all yerine .cpuAndNeuralEngine ister.
Dağıtım Kılavuzları#
- Core ML Modelini Uygulamaya Entegre Etme: modele Xcode projesinde yer verme ve modeli çağırma konusunda Apple'ın kılavuzu.
- Canlı Görüntüdeki Nesneleri Tanıma: Vision ve
VNCoreMLRequestile kamera karelerinde Core ML detektörü çalıştırmaya yönelik Apple örneği. - MLComputeUnits: CPU, GPU ve Neural Engine'i seçen
MLModelConfigurationayarınıncomputeUnitsdeğeri. - Core ML kullanımını optimize etme: bir aygıtta her katmanın hesaplama birimini ve gecikmesini gösteren Xcode performans raporları hakkındaki Apple oturumu.
- Core ML Tools kılavuzu: bu dışa aktarmanın kullandığı
coremltoolspaketi için dönüştürme ve optimizasyon başvuru kaynağı. - Ultralytics Platform: QR kodunu tarayarak iPhone'daki Ultralytics YOLO uygulamasında bir Core ML dışa aktarımını aç.
- Core AI, LiteRT ve Qualcomm QNN: iOS 27 için Apple biçimi; Android aygıtları ve Snapdragon NPU'ları için biçimler.
Sınırlamalar ve Sorun Giderme#
- Yalın kurulumdan sonraki ilk dışa aktarma: ilk dışa aktarmanın
numpyöğesini değiştirmesi gerektiğinde (2.3.5 üzerindeki sürümler dönüştürmeyi bozar), UltralyticsRestart runtime or rerun command for updates to take effectgünlüğünü yazar ve dışa aktarmaTypeError: only 0-dimensional arrays can be converted to Python scalarshatasıyla başarısız olur. Dışa aktarmayı yeni bir işlemde yeniden çalıştır; not defterinde bu, çekirdeği yeniden başlatmak anlamına gelir. Alternatif olarak Hızlı Başlangıç bölümündeki gibi ilk dışa aktarmadan önce"ultralytics[export-coreml]"öğesini yükle. - Dışa aktarma ana makinesi: dışa aktarma macOS ve x86-64 Linux üzerinde çalışır. Windows veya Raspberry Pi gibi ARM64 Linux sistemleri desteklenmez:
coremltools9.0, yalnızca macOS ve x86-64 Linux için önceden derlenmiş paketler yayımlar. - Python sürümü:
coremltools9.0, Python 3.13 ve önceki sürümler için önceden derlenmiş paketlere sahiptir. Python 3.14'tepip install "ultralytics[export-coreml]", Core ML paketlerinin hiçbirini yüklemez; bu nedenle dışa aktarmacoremltoolsöğesini kaynaktan derler. İlk dışa aktarma, yalın kurulumdan sonraki gibi başarısız olur;RuntimeError: BlobWriter not loadedile yapılan sonraki dışa aktarma ise başarılı olur. Ortamı Python 3.13 veya daha eski bir sürümle oluştur. - Çıkarım için macOS gerekir: Linux'ta
YOLO("yolo26n.mlpackage")ile tahmin veya doğrulama yapmakModel prediction is only supported on macOS version 10.13 or later.hatasıyla başarısız olur. PyTorch kontrol noktasını orada doğrula veya paketi Mac'e kopyala. - Otomatik yükleme kapalı:
YOLO_AUTOINSTALL=falseile, paketin yüklü olmadığı bir ortamda dışa aktarmaNo module named 'coremltools'hatasıyla başarısız olur. quantize=8ile eğitilmiş kontrol noktaları: niceleme farkındalıklı eğitim ile ince ayar yapılmış bir kontrol noktası,format='coreml' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backendsile başarısız olur. Bunun yerine ince ayara başladığın kontrol noktasınıquantize=8ile dışa aktar veya ince ayarlı kontrol noktasını ONNX ya da TensorRT biçiminde dışa aktar.quantize="w8a32":quantize='w8a32' is not supported; format='coreml' supports quantize=16 (FP16), 8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 32 or None (FP32).hatasıyla başarısız olur. Core ML için'w8a16', FP16 hesaplamayla8ile aynı dışa aktarmadır.- Diğer görevlerde yerleşik NMS:
nms=True, tespit, segmentasyon ve poz modellerinde çalışır. OBB ve sınıflandırma modellerinde dışa aktarmaCoreML 'nms=True' is only supported for detect, segment and pose models. Forcing 'nms=None'.günlüğünü; anlamsal segmentasyon ve derinlik tahmini modellerinde'nms=True' is not valid for semantic models. Forcing 'nms=None'.(veyadepth models) günlüğünü; RT-DETR modellerinde ise'nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.günlüğünü yazar. Bunların tümü varsayılan dışa aktarmanın çıktısını yazar. - Yerleşik NMS hassasiyeti:
quantizeiçermeyen birnms=Truedışa aktarımı FP16'dır.quantize=32, bir tespit modeli için FP32 işlem hattı oluşturur; segmentasyon ve poz modellerinde dışa aktarmaCoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'.(veyapose models) günlüğünü yazar. - Yerleşik NMS ve doğrulama:
nms=Truedışa aktarımı,valgörmeden önceconfeşiğinin altındaki kutuları kaldırır; bu nedenle aynı modelin harici NMS kullanan sürümünden daha düşük puan alır: COCO val2017'de,nms=Trueiçeren FP16 YOLO26n dışa aktarımı, varsayılanconf=0.25ile 33,8 mAPval 50-95 puanına,conf=0.001ile dışa aktarıldığında ise 39,9 puanına ulaştı; bu değer, varsayılan FP16 dışa aktarımının 40,9 puanından hâlâ 1,0 düşüktür. Böyle bir modeli doğrulamak içinconf=0.001ile dışa aktar ve dağıtım eşiğini ayrıca seç. - Diğer modellerde NMS içermeyen başlık:
nms=False, YOLO26 veya YOLOv10 gibi NMS içermeyen başlığa sahip bir model gerektirir. Örneğin YOLO11 gibi diğer modellerde dışa aktarmaThis model has no one-to-one head; using one-to-many outputs.uyarısı verir ve ham(1, 84, 8400)çıktısını yazar. - Grup boyutu: 1'den büyük bir
batch,dynamic=Trueolmadanbatch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'.hatasıyla başarısız olur. - Dinamik şekiller:
batchiçermeyendynamic=True,'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.günlüğünü yazar ve en fazla 1 grup boyutuna sahip bir modeli dışa aktarır.nms=Trueile'nms=True' cannot be used together with 'dynamic=True' for CoreML export. Please disable one of them.hatasıyla başarısız olur; sınıflandırma ve RT-DETR modellerinde ise'dynamic=True' is not supported for CoreML classification or RT-DETR models.hatasıyla başarısız olur. Aralık dışındaki bir görüntü boyutu, tahmin sırasındaSize (1312) of dimension (2) is not in allowed range (32..1280)gibi bir hataya neden olur. - Neural Engine'de anlamsal segmentasyon: Apple M4 üzerinde YOLO26n-sem modeli, tek bir test görüntüsünde yalnızca
coremltoolskullanıldığında,CPU_ONLYileCPU_AND_NEdeğerinden daha uzun sürdü:imgsz=1024boyutundaki FP16 dışa aktarımında 22 ms'ye kıyasla 59–64 ms;imgsz=640boyutundaki INT8 dışa aktarımında ise 9 ms'ye kıyasla yaklaşık 15 ms. Diğer altı görevin FP16 modelleri veimgsz=640boyutundaki INT8 modelleri (sınıflandırma için 224),CPU_AND_NEile daha hızlı çalıştı; ayrıca iPhone 17 Pro üzerinde INT8 anlamsal model de Neural Engine ile daha hızlıydı.YOLO(), bu modeller için her zamanCPU_AND_NEkullanır; bu nedenle anlamsal modeli kendi kodunda her iki ayarla da ölç. .cpuOnlyiOS 27.0.1'de: iPhone 17 Pro'da YOLO26l ve YOLO26x derinlik, poz ve OBB modellerinin.cpuOnlyçıkarımı, Core ML'nin CPU çekirdeklerinde (libBNNSiçindekiEXC_BAD_ACCESS) çöktü. iOS SDK'nın istediği.cpuAndNeuralEngineile çalışırlar.- Paket adı: bir kontrol noktasının her dışa aktarımı,
quantize,imgsz,nmsveyadynamicne olursa olsun aynıyolo26n.mlpackagedosyasına yazar; bu nedenle sonraki dışa aktarma öncekinin üzerine yazar. İkisini de korumak için paketi yeniden adlandır, ancak.mlpackagesonekini bırakma; örneğinyolo26n_fp16.mlpackage, çünkü Ultralytics biçimi bu sonekten tanır. Soneki olmayan bir paketis not a supported model formathatasıyla başarısız olur. - PyTorch sürümü uyarısı: güncel bir PyTorch ile
coremltools, yüklenirkenTorch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors.günlüğünü yazar; güncel birscikit-learnile isescikit-learn version 1.9.1 is not supported.günlüğünü yazar. Bu sayfadaki dışa aktarımlar ve Mac sonuçları şu sürümlerle elde edildi. - Eski
.mlmodeldosyaları:format="mlmodel", ML Program yükleyemeyen uygulamalar için önceki Core ML sinir ağı biçimini tek biryolo26n.mlmodeldosyası olarak dışa aktarır. Bu biçimdequantize=8ve'w8a16', doğrusal 8 bit ağırlık nicelemesi uygular. Yeni projeler için varsayılan.mlpackagedeğerini kullan.
Diğer hatalar için Yaygın Sorunlar kılavuzuna bak.
Ölçülen Performans#
Aşağıdaki tablolar iPhone 17 Pro ve Apple M4 Mac üzerinde ölçüldü. YOLO26 model sayfasında her görev için PyTorch kontrol noktalarının doğruluğu listelenir.
iPhone 17 Pro#
Donanım: iOS 26.6 yüklü iPhone 17 Pro. A19 Pro; 6 çekirdekli CPU'ya (2 Performans ve 4 Verimlilik çekirdeği), 6 çekirdekli GPU'ya ve 16 çekirdekli Neural Engine'e sahiptir.
İlk tablo, her görev için resmi INT8 modelinin tek bir görüntüdeki gecikmesini gösterir. Bu modeller, v8.3.0 varlıkları, nms=False ile dışa aktarılan Ultralytics iOS SDK modelleridir. Her hücre, milisaniye cinsinden toplam süreyi ve altında ön işleme / çıkarım / son işleme dağılımını gösterir; daha hızlı hesaplama birimi kalın yazılmıştır:
| Model | Görev | boyut (piksel) | CPU Core ML .cpuOnly(ms) | CPU + Neural Engine Core ML .cpuAndNeuralEngine(ms) |
|---|---|---|---|---|
| YOLO26n | Detect | 640 | 9.7 0.0 / 9.7 / 0.0 | 4.7 0.0 / 4.7 / 0.0 |
| YOLO26n-seg | Segment | 640 | 12.8 0.0 / 12.2 / 0.6 | 5.8 0.0 / 5.0 / 0.7 |
| YOLO26n-sem | Anlamsal | 640 | 9.3 0.0 / 8.9 / 0.5 | 5.3 0.0 / 4.8 / 0.5 |
| YOLO26n-depth | Derinlik | 640 | 25.8 0.0 / 24.8 / 1.0 | 8.0 0.0 / 6.9 / 1.1 |
| YOLO26n-cls | Sınıflandırma | 224 | 2.1 0.0 / 2.0 / 0.0 | 1.8 0.0 / 1.8 / 0.0 |
| YOLO26n-pose | Poz | 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 |
Beş algılama modeli için aynı ölçüm ve SDK'nın her modeli yüklemek için harcadığı süre:
| Model | CPU.cpuOnly(ms) | CPU + Neural Engine.cpuAndNeuralEngine(ms) | Model yükleme.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 |
Üç hassasiyet düzeyinde ve iki nms ayarıyla YOLO26n algılama; imgsz=640 sürümünde ultralytics 8.4.215 ile dışa aktarıldı. Toplam süre milisaniye cinsindendir:
| Kesinlik | 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 |
- Yöntem:
bus.jpgüzerinde 3 ısınma tahmininin ardından alınan 15 tahminin ortalaması; Swift SDK 8.9.23 kullanılarak bir sürüm derlemesinde ölçüldü..cpuOnlyve.cpuAndNeuralEngine, SDK'nın istediği Core ML hesaplama birimleridir; her katmanın nerede çalışacağına Core ML karar verir. Her tablo, birbirinden ayrı üç çalıştırmada ölçüldü ve ortanca değeri gösteriyor..cpuAndNeuralEnginekullanan YOLO26n dışında, üç çalıştırmanın sonuçları %15 içinde uyuştu. Bu model boyut tablosunda 2.6–4.8 ms, INT8nms=Nonedışa aktarımında ise 3.8–4.8 ms sürdü. Görev ve boyut tablolarında resmiv8.3.0varlıkları, hassasiyet tablosunda iseultralytics8.4.215 ile oluşturulan dışa aktarımlar kullanıldı; bu nedenle YOLO26n hücreleri farklılık gösteriyor: Neural Engine ile en fazla 0.5 ms, CPU'da ise 0.6 ms. - Ön işleme: Vision, çıkarım isteği sırasında görüntüyü ölçeklendirir; bu nedenle ön işleme 0 olarak raporlanır ve maliyeti çıkarım süresine dahildir.
- FP32: Bu ortanca değerlere göre FP32 dışa aktarımı,
.cpuOnlyyerine.cpuAndNeuralEngineile en fazla %5 daha hızlıydı; FP16 ve INT8 ise yaklaşık iki kat daha hızlıydı. Neural Engine için FP16 veya INT8 ile dışa aktar. nms: YOLO26n algılamada, NMS içermeyen başlık (nms=False) ve SDK'da NMS uygulanan ham çıktı (nms=None), Neural Engine ile FP16 ve INT8'de 4–5 ms sürdü.- Kamera uygulamaları: Bunlar tek görüntü için ölçülen gecikmelerdir. Gerçek zamanlı bir kamera uygulamasında görüntü yakalama ve görüntüleme süresi de eklenir; iOS SDK performans notlarına bak.
- Android CPU/GPU sonuçlarını LiteRT entegrasyonundaki ve MediaTek Dimensity sonuçlarıyla; Snapdragon NPU sonuçlarını ise Qualcomm QNN entegrasyonundaki sonuçlarla karşılaştır.
Apple M4#
Aşağıdaki tablolar, Apple M4 (4 performans ve 6 verimlilik çekirdeği) ve macOS 27.2 üzerinde, COCO val2017'de YOLO() ile doğrulanmış, her YOLO26 algılama modelinin FP32, FP16 ve INT8 Core ML modellerini PyTorch ile karşılaştırıyor. PyTorch CPU'da 8 iş parçacığıyla, batch=1 ve rect=False kullanılarak çalıştırıldı; böylece Core ML modelleriyle aynı 640x640 girdiyi aldı. Core ML modelleri ise Ultralytics'in varsayılan hesaplama birimleriyle çalıştı.
Görüntü başına milisaniye; düşük değer daha iyidir. Her model için en hızlı biçim kalın yazılmıştır.
| Model | 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 |
NMS içermeyen başlıkla (nms=False) YOLO26n, PyTorch'ta ve FP32'de 40.3 mAPval 50-95, FP16'da 40.2 ve INT8'de 40.1 değerine ulaştı.
YOLO26n'in her Core ML hesaplama birimindeki gecikmesi, yalnızca coremltools ile tek bir görüntü üzerinde alınan 20 tahminin ortanca değeri olarak ölçülmüştür; süre milisaniye cinsindendir:
| Kesinlik | 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 ve INT8,
YOLO()üzerinden FP32'den 3.5 ila 14 kat daha hızlı çalıştı. Doğruluk, FP16'da FP32'nin 0.1 mAP, INT8'de ise 0.2 mAP yakınındaydı. INT8, YOLO26n'de FP16 kadar hızlıydı ve daha büyük modellerde 1.3 kata kadar daha hızlıydı. - FP32,
CPU_AND_NEileCPU_ONLYkullanıldığındaki çıktılarla aynı çıktıları verdi. Yalnızca GPU hesaplama birimleri daha hızlı olmasını sağladı. - INT8, paketi FP32'den 3.7 ila 4.0 kat daha küçük hale getirdi.
ultralytics 8.4.215, coremltools 9.0 ve PyTorch 2.15.0 ile batch=1 üzerinde 17 Kasım 2026'da ölçüldü. Gecikme, val tarafından bildirilen çıkarım aşamasını kapsar; ön işleme veya son işlemeyi içermez. Aynı gün YOLO26n Core ML'in üç senaryosunda yapılan ikinci çalıştırmanın sonuçları 2.3 ms'ye kadar farklılık gösterdi; FP32 için 21.0 ms'ye karşı 18.8 ms.
Core ML hakkında#
Core ML; iOS, iPadOS, macOS, watchOS, tvOS ve visionOS'a yerleşik olarak gelir. Bu dışa aktarımın yazdığı .mlpackage ML Program biçimindeki modelleri yükler ve her katmanı CPU'da, GPU'da veya Apple Neural Engine'de çalıştırır. Apple silikonun NPU'su sayesinde çıkarım çevrimdışı çalışır ve veriler aygıtta kalır. Kapsamlı başvuru için Core ML belgelerine bak.
İzle: Ultralytics YOLO26'yı INT8 nicelemesiyle CoreML'ye aktarma | Apple dağıtımı | iOS/MacOS 🍎
Sık Sorulan Sorular#
İkisi de Neural Engine'de çalışır ve FP16 ile hesaplama yapar; dolayısıyla seçim, boyuta bağlıdır. FP16 (
quantize=16) paketi yarıya indirir: YOLO26n için 9.9 MB yerine 5.1 MB. INT8 (quantize=8) ise 8 bit ağırlıklar kullanır, YOLO26n için 2.7 MB boyutundadır ve resmi Ultralytics uygulama modellerinde kullanılan hassasiyet düzeyidir. COCO val2017'de varsayılan YOLO26n dışa aktarımı, Apple M4'te FP16 ile 40.9 mAPval 50-95, INT8 ile 40.8 değerine ulaştı ve her ikisi de görüntü başına yaklaşık aynı sürede çalıştı. iPhone 17 Pro'da ikisi de Neural Engine ile YOLO26n için 4–5 ms sürdü; bu fark çalıştırmalar arasındaki değişkenlik sınırları içindeydi. INT8 için iOS 16 veya macOS 13 gerekirken FP16, iOS 15 ve macOS 12'de de çalışır. İkisi için de kalibrasyon verisi gerekmez. Dağıtımda varsayılan FP32 dışa aktarımından kaçın: bu seçenek en büyük boyuta sahiptir ve testlerimizde Neural Engine hesaplama birimleriyle yalnızca CPU'dan en fazla %5 daha hızlıydı; Hassasiyet bölümüne bak. Modeli kullanıma sunmadan önce kendi verilerin ve aygıtında doğrula.Bu, çıktıyı kimin çözdüğüne bağlıdır. Ultralytics iOS SDK veya Flutter eklentisiyle çalışıyorsan, YOLO26 modellerini resmi modellerde olduğu gibi
nms=Falseile dışa aktar: SDK daha sonra NMS içermeyen başlığın nihai algılamalarını okur ve NMS adımına ihtiyaç duymaz. COCO val2017'de INT8 ile YOLO26n, NMS içermeyen başlıkla 40.1 mAPval 50-95 değerine, varsayılan çıktı ve harici NMS ile ise 40.8 değerine ulaştı. iPhone 17 Pro'da her ikisi de görüntü başına 4–5 ms sürdü. Apple'ın Vision çatısı ve kendi kodunlanms=True, algılama modelini Apple'ın NMS aşamasını içeren bir Core ML işlem hattına dönüştürür; bu aşamanın eşiklerini her tahmin için değiştirebilirsin. Vision, algılamalarınıVNRecognizedObjectObservationnesneleri olarak döndürür ve bir kutunun puanı, gözleminconfidencedeğeridir. SDK ile birnms=Truealgılama modeli yükleme: iOS 26.6 yüklü iPhone 17 Pro'da yapılan bir testte SDK 8.9.23, kutu puanları yerine her kutunun en üst etiketinin güven değerini (yaklaşık 1.0) bildirdi. Varsayılannms=None, ham tahminleri döndürür ve NMS'i koduna bırakır. Her ayarın çıktıları için Çıktı Biçimi bölümüne bak.Mac olmadan dışa aktarabilirsin: dışa aktarma x86-64 Linux'ta çalışır ve Ultralytics Platform bulutta dışa aktarma yapar. Modeli çalıştırmak için Apple donanımı gerekir; çünkü Core ML, Apple işletim sistemlerinin bir parçasıdır. Linux ve Windows'ta PyTorch kontrol noktasını veya onun ONNX dışa aktarımını doğrula, ardından
YOLO("yolo26n.mlpackage").val()modelin çalıştırıldığı bir Mac'te ya da aygıtta Core ML modelinin kendisini doğrula.
Yorumlar13
Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.
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(düzenlendi)@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! 😊
