Başla

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'ın yeni Core AI biçimi

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ış#

ÖzellikAyrıntılar
format bağımsız değişkenicoreml (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ığı ortamlariPhone, 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
KesinlikFP32, 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 makinesimacOS 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
Bulutta dışa aktar

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:

PaketGerekli sürüm
Python3.13 veya daha eski; coremltools 9.0 sürümünün önceden derlenmiş paketlerini sunduğu en yeni sürüm
coremltools9.0 veya daha yeni
numpy2.3.5 veya daha eski. Dışa aktarma, daha yeni bir sürümün üzerine 2.3.5'i yükler
torch1.11 veya daha yeni
scikit-learnYalnı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.

Dışa aktar
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şturur

Her 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:

Tahmin
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")
Doğrula
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şkenTürVarsayılanAçıklama
formatstr'coreml'Dışa aktarılan modelin hedef biçimi; çeşitli dağıtım ortamlarıyla uyumluluğu tanımlar.
imgszint veya tuple640Varsayı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.
quantizeint veya strNoneHassasiyet: 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.
nmsbool, isteğe bağlıNoneHam çı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.
conffloatNonenms=True dışa aktarımında saklanan güven eşiği. Belirtilmezse 0.25 kullanılır.
ioufloat0.5nms=True dışa aktarımında saklanan IoU eşiği.
agnostic_nmsboolFalseSı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_detint300nms=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.
dynamicboolFalseGirdi 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.
batchint1dynamic=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.
devicestrNoneDö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î mobil modellerin görüntü boyutu ve ayarları

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:

quantizeAğırlıklarHesaplamaEn düşük işletim sistemi sürümüYOLO26n boyutu
belirtilmemiş veya 32FP32FP32iOS 15, macOS 129.9 MB
16FP16FP16iOS 15, macOS 125.1 MB
8 veya 'w8a16'8 bitFP16iOS 16, macOS 132.7 MB
  • FP32: nms=True ayarlanmadığı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_NE hesaplama birimleriyle, CPU_ONLY ile 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 (float32 veya anlamsal segmentasyon için int32); bu nedenle FP32 modeli için yazılmış çıkarım kodu, hiçbir değişiklik yapılmadan çalışır.
  • INT8: quantize=8 ve quantize="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=8 seçeneğinin diğer biçimler için belirlediği kalibre edilmiş etkinleştirme nicelemesi değildir; bu nedenle data bağımsız değişkeni almaz. scikit-learn zaten 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.jsonPaketteki dosyaların listesi
Data/com.apple.CoreML/model.mlmodelAğ 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.binAğı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örevVarsayılan imgsznms=None ile çıktınms=False ile çıktınms=True ile çıktı
Detect640(1, 84, 8400)(1, 300, 6)confidence (boxes, 80) ve coordinates (boxes, 4)
Segment640(1, 116, 8400) ve (1, 32, 160, 160)(1, 300, 38) ve (1, 32, 160, 160)(1, 300, 38) ve (1, 32, 160, 160)
Anlamsal1024(1, 1024, 1024), her piksel için sınıf indeksinms=None ile aynınms=None ile aynı
Derinlik768(1, 1, 768, 768), derinlik haritasınms=None ile aynınms=None ile aynı
Sınıflandırma224classLabel ve classLabel_probsnms=None ile aynınms=None ile aynı
Poz640(1, 56, 8400)(1, 300, 57): 6 kutu değeri, ardından 17 anahtar nokta x 3(1, 300, 57)
OBB1024(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 piksellerinde x1, y1, x2, y2, score, class değerinden oluşan max_det satır (varsayılan 300); NMS adımı yoktur. OBB satırları center x, center y, width, height, score, class, angle biç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. confidence değerini (tutulan her kutu için bir satır sınıf puanını) ve coordinates değ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ılan 0.25), iou (varsayılan 0.5) ve agnostic_nms dışa aktarma sırasında işlem hattında saklanır; atlanabilen confidenceThreshold ve iouThreshold girdileri ise tek bir tahmin için iki eşiğin yerini alır. max_det uygulanmaz: max_det=2 ile 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, confidence değ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 birlikte x1, y1, x2, y2, score, class değerinden oluşan max_det satı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_nms ve max_det dış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, int32 olarak 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 classLabel değerini ve sınıf adlarıyla olasılıkların sözlüğü olan classLabel_probs değ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 ise ALL ile yükler. Model bunlarla yüklenmezse CPU_ONLY ile yükler. Başka hesaplama birimleri seçmek için bir bağımsız değişken yoktur; bunu yapmak için paketi coremltools ile yükle. macOS 27.2 yüklü Apple M4 üzerinde ALL ve CPU_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: device bağı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 modeli device="mps" ile görüntü başına yaklaşık 8 ms, bu seçenek olmadan yaklaşık 6 ms sürdü; bu nedenle device değerini ayarlama.
  • Hassasiyet ve Neural Engine: Apple M4 üzerinde YOLO() çıkarım aşaması, FP32 YOLO26n modeli için predict ile 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ızca coremltools kullanıldığında aynı FP16 ve INT8 modelleri CPU_AND_NE ile yaklaşık 2 ms, CPU_ONLY ile 9–10 ms sürdü.
  • Sabit girdi şekli: varsayılan bir dışa aktarma her zaman dışa aktarma imgsz değerinde çalışır; Ultralytics bunu model meta verilerinden okur. predict veya val öğesine geçirilen imgsz yok 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 ve val, batch=1 değerini ayarlar.
  • Dinamik dışa aktarma (dynamic=True): model, batch boyutlarını 1'den dışa aktarma için kullanılan batch değerine kadar, görüntü boyutlarını ise 32 pikselden dışa aktarma için kullanılan imgsz değ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ılan batch boyutunda parçalara böler. NMS içermeyen başlıkta en küçük boyut daha büyüktür: imgsz=640 boyutunda ve nms=False ile 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=640

Swift 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ı#

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), Ultralytics Restart runtime or rerun command for updates to take effect günlüğünü yazar ve dışa aktarma TypeError: only 0-dimensional arrays can be converted to Python scalars hatası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: coremltools 9.0, yalnızca macOS ve x86-64 Linux için önceden derlenmiş paketler yayımlar.
  • Python sürümü: coremltools 9.0, Python 3.13 ve önceki sürümler için önceden derlenmiş paketlere sahiptir. Python 3.14'te pip install "ultralytics[export-coreml]", Core ML paketlerinin hiçbirini yüklemez; bu nedenle dışa aktarma coremltools öğesini kaynaktan derler. İlk dışa aktarma, yalın kurulumdan sonraki gibi başarısız olur; RuntimeError: BlobWriter not loaded ile 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 yapmak Model 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=false ile, paketin yüklü olmadığı bir ortamda dışa aktarma No module named 'coremltools' hatasıyla başarısız olur.
  • quantize=8 ile 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' backends ile başarısız olur. Bunun yerine ince ayara başladığın kontrol noktasını quantize=8 ile 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 hesaplamayla 8 ile 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 aktarma CoreML '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'. (veya depth 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: quantize içermeyen bir nms=True dış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 aktarma CoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'. (veya pose models) günlüğünü yazar.
  • Yerleşik NMS ve doğrulama: nms=True dışa aktarımı, val görmeden önce conf eş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=True içeren FP16 YOLO26n dışa aktarımı, varsayılan conf=0.25 ile 33,8 mAPval 50-95 puanına, conf=0.001 ile 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çin conf=0.001 ile 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 aktarma This 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=True olmadan batch 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: batch içermeyen dynamic=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=True ile '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ında Size (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 coremltools kullanıldığında, CPU_ONLY ile CPU_AND_NE değerinden daha uzun sürdü: imgsz=1024 boyutundaki FP16 dışa aktarımında 22 ms'ye kıyasla 59–64 ms; imgsz=640 boyutundaki INT8 dışa aktarımında ise 9 ms'ye kıyasla yaklaşık 15 ms. Diğer altı görevin FP16 modelleri ve imgsz=640 boyutundaki INT8 modelleri (sınıflandırma için 224), CPU_AND_NE ile 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 zaman CPU_AND_NE kullanır; bu nedenle anlamsal modeli kendi kodunda her iki ayarla da ölç.
  • .cpuOnly iOS 27.0.1'de: iPhone 17 Pro'da YOLO26l ve YOLO26x derinlik, poz ve OBB modellerinin .cpuOnly çıkarımı, Core ML'nin CPU çekirdeklerinde (libBNNS içindeki EXC_BAD_ACCESS) çöktü. iOS SDK'nın istediği .cpuAndNeuralEngine ile çalışırlar.
  • Paket adı: bir kontrol noktasının her dışa aktarımı, quantize, imgsz, nms veya dynamic ne olursa olsun aynı yolo26n.mlpackage dosyasına yazar; bu nedenle sonraki dışa aktarma öncekinin üzerine yazar. İkisini de korumak için paketi yeniden adlandır, ancak .mlpackage sonekini bırakma; örneğin yolo26n_fp16.mlpackage, çünkü Ultralytics biçimi bu sonekten tanır. Soneki olmayan bir paket is not a supported model format hatasıyla başarısız olur.
  • PyTorch sürümü uyarısı: güncel bir PyTorch ile coremltools, yüklenirken Torch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors. günlüğünü yazar; güncel bir scikit-learn ile ise scikit-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 .mlmodel dosyaları: format="mlmodel", ML Program yükleyemeyen uygulamalar için önceki Core ML sinir ağı biçimini tek bir yolo26n.mlmodel dosyası olarak dışa aktarır. Bu biçimde quantize=8 ve 'w8a16', doğrusal 8 bit ağırlık nicelemesi uygular. Yeni projeler için varsayılan .mlpackage değ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:

ModelGörevboyut
(piksel)
CPU
Core ML .cpuOnly
(ms)
CPU + Neural Engine
Core ML .cpuAndNeuralEngine
(ms)
YOLO26nDetect6409.7
0.0 / 9.7 / 0.0
4.7
0.0 / 4.7 / 0.0
YOLO26n-segSegment64012.8
0.0 / 12.2 / 0.6
5.8
0.0 / 5.0 / 0.7
YOLO26n-semAnlamsal6409.3
0.0 / 8.9 / 0.5
5.3
0.0 / 4.8 / 0.5
YOLO26n-depthDerinlik64025.8
0.0 / 24.8 / 1.0
8.0
0.0 / 6.9 / 1.1
YOLO26n-clsSınıflandırma2242.1
0.0 / 2.0 / 0.0
1.8
0.0 / 1.8 / 0.0
YOLO26n-posePoz64011.9
0.0 / 11.9 / 0.0
5.4
0.0 / 5.4 / 0.0
YOLO26n-obbOBB64010.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:

ModelCPU
.cpuOnly
(ms)
CPU + Neural Engine
.cpuAndNeuralEngine
(ms)
Model yükleme
.cpuAndNeuralEngine
(s)
YOLO26n9.24.50.9
YOLO26s19.510.51.3
YOLO26m46.711.81.8
YOLO26l60.112.02.4
YOLO26x125.920.53.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:

Kesinliknms=None, CPUnms=None, CPU + Neural Enginenms=False, CPUnms=False, CPU + Neural Engine
FP3215.514.714.514.4
FP169.24.99.25.0
INT89.24.29.15.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ü. .cpuOnly ve .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. .cpuAndNeuralEngine kullanan YOLO26n dışında, üç çalıştırmanın sonuçları %15 içinde uyuştu. Bu model boyut tablosunda 2.6–4.8 ms, INT8 nms=None dışa aktarımında ise 3.8–4.8 ms sürdü. Görev ve boyut tablolarında resmi v8.3.0 varlıkları, hassasiyet tablosunda ise ultralytics 8.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ı, .cpuOnly yerine .cpuAndNeuralEngine ile 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.

ModelimgszPyTorchCore ML FP32Core ML FP16Core ML INT8
YOLO26n64025.621.06.06.0
YOLO26s64060.050.07.97.6
YOLO26m640137.2127.614.311.3
YOLO26l640191.2187.717.213.5
YOLO26x640341.1334.228.624.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:

KesinlikCPU_ONLYCPU_AND_NEALLCPU_AND_GPU
FP3213.713.68.38.0
FP169.61.82.07.7
INT89.41.81.88.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_NE ile CPU_ONLY kullanı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.

Apple Core ML deployment pipeline



İ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=False ile 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 kodunla nms=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ı VNRecognizedObjectObservation nesneleri olarak döndürür ve bir kutunun puanı, gözlemin confidence değeridir. SDK ile bir nms=True algı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ılan nms=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.

  1. Afool4UGitHub

    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.

  2. SebastianxhjGitHub

    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.

    1. 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.

  3. smadsenjcGitHub

    I have a trained model that is doing very well in Python, but once I convert it to CoreML .mlpackage format 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 from VNCoreMLRequest: a single VNCoreMLFeatureValueObservation instead of an array of VNRecognizedObjectObservation.

    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; True fails).

    This was working back in November, but I got side-tracked with other work. I haven't touched the model.

    1. 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=True requires 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.

  4. CharanPrasadKGitHub

    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.

    1. 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 names attribute in the model. If the issue persists, please verify that you're using the latest ultralytics package. For further details, refer to the CoreML export documentation. Let us know if you need additional assistance!

  5. ChristalZhuGitHub

    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?

    1. 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 .mlpackage file.

      To assist you better, could you please confirm the following:

      1. Are you using the latest versions of torch and ultralytics? If not, please upgrade and try the export process again.
      2. 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 .pt file, 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.

  6. ChristalZhuGitHub

    我按照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.

    1. Paula DerrengerUltralytics

      Hello @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 torch and ultralytics. You can update them using the following commands:

      pip install --upgrade torch ultralytics

      If 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 detection

      After exporting, you can manually check the .mlpackage to 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!

    2. ChristalZhuGitHub

      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?

    3. Paula DerrengerUltralytics

      Hello @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 torch and ultralytics. You can update them using the following commands:

      pip install --upgrade torch ultralytics

      If 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 detection

      After exporting, you can manually check the .mlpackage to 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! 😊