Экспорт в Apple Core ML
Core ML — это фреймворк Apple для запуска моделей машинного обучения на iPhone, iPad, Mac, Apple Watch, Apple TV и Apple Vision Pro. Экспорт модели Ultralytics YOLO26 с помощью format="coreml" создает пакет модели yolo26n.mlpackage, который Core ML запускает на CPU, GPU и Apple Neural Engine — в FP32, FP16 или с 8-битными весами.
Apple представила новый фреймворк Core AI и формат .aimodel для поколения iOS 27 и macOS 27, а Ultralytics поддерживает его экспорт с помощью format="coreai". Core ML остается форматом по умолчанию для Ultralytics iOS SDK и Flutter SDK: они загружают Core AI как дополнительный вариант на устройствах с iOS 27, а также поддерживают этот формат в более ранних операционных системах Apple.
Краткий обзор#
| Свойство | Описание |
|---|---|
Аргумент format | coreml (псевдонимы: mlpackage, mlprogram, apple, ios). mlmodel экспортирует более ранний формат нейронной сети |
| Результат | yolo26n.mlpackage — пакет модели (каталог) в формате ML Program, в котором в виде метаданных сохранены названия классов, задача и размер изображения |
| Поддерживаемые устройства | iPhone, iPad, Mac, Apple Watch, Apple TV и Apple Vision Pro; CPU, GPU и Apple Neural Engine |
| Среда выполнения | Core ML, встроенный в операционные системы Apple; экспортированная ML Program объявляет спецификацию Core ML 6 (iOS 15, macOS 12) или, для INT8, спецификацию 7 (iOS 16, macOS 13). В Python — пакет coremltools для macOS |
| Точность | FP32, FP16, INT8 (8-битные веса). YOLO26n занимает 9.9 MB в FP32, 5.1 MB в FP16 и 2.7 MB в INT8 |
| Среда для экспорта | macOS или Linux x86-64 с Python 3.13 или более ранней версией. Не Windows. Для экспорта GPU не требуется |
Ultralytics Platform может экспортировать обученную модель в Core ML за тебя, поэтому локальная среда для экспорта не нужна.
Быстрый старт#
Установи пакет Ultralytics с зависимостями для экспорта в Core ML на macOS или Linux x86-64:
pip install "ultralytics[export-coreml]"При этом устанавливаются coremltools, scikit-learn и версия numpy, совместимая с coremltools. При обычной установке pip install ultralytics первый экспорт устанавливает coremltools, а если при этом нужно заменить более новую numpy, экспорт завершается с ошибкой; следующий экспорт проходит успешно. Для экспорта требуются следующие версии:
| Пакет | Требуемая версия |
|---|---|
| Python | 3.13 или более ранняя версия — самая новая версия, для которой coremltools 9.0 предлагает готовые пакеты |
coremltools | 9.0 или новее |
numpy | 2.3.5 или более ранняя версия. При экспорте поверх более новой версии устанавливается 2.3.5 |
torch | 1.11 или новее |
scikit-learn | Только для quantize=8 и 'w8a16'. Дополнение export-coreml устанавливает версию 1.3.2 или новее; если пакет отсутствует, его устанавливает экспорт |
О других способах установки читай в руководстве по установке. Затем экспортируй модель и загрузи экспортированный пакет, чтобы запустить инференс или проверить точность.
from ultralytics import YOLO
# Загрузи модель YOLO26
model = YOLO("yolo26n.pt")
# Экспортируй модель в формате Core ML
model.export(format="coreml") # создает 'yolo26n.mlpackage'
# Или экспортируй в FP16: размер уменьшится вдвое, а модель будет работать на Neural Engine
model.export(format="coreml", quantize=16) # создает 'yolo26n.mlpackage'Оба экспорта записывают один и тот же yolo26n.mlpackage, поэтому второй заменяет первый. Predict и Validate работают только на macOS:
from ultralytics import YOLO
# Загрузи экспортированную модель Core ML на Mac
model = YOLO("yolo26n.mlpackage")
# Выполнить инференс
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Загрузи экспортированную модель Core ML на Mac
model = YOLO("yolo26n.mlpackage")
# Проверить точность на наборе данных COCO8
metrics = model.val(data="coco8.yaml")Поддерживаемые задачи#
Экспорт в Core ML поддерживает все семь задач Ultralytics для моделей YOLOv8, YOLO11 и YOLO26: обнаружение объектов, сегментацию, семантическую сегментацию, оценку глубины, классификацию, оценку позы и OBB. Семантическая сегментация и оценка глубины доступны только в YOLO26 — единственном семействе, в котором есть соответствующие выходные головы. Также экспортируются модели обнаружения YOLOv5u, YOLOv9, YOLOv10 и YOLO12, а еще модели RT-DETR и YOLO-Worldv2. Каждую задачу проверили на одном чекпойнте, например yolo11n-seg.pt, rtdetr-l.pt и yolov8s-worldv2.pt.
Аргументы экспорта#
| Аргумент | Тип | По умолчанию | Описание |
|---|---|---|---|
format | str | 'coreml' | Целевой формат экспортируемой модели, определяющий совместимость с различными средами развертывания. |
imgsz | int или tuple | 640 | Размер входного изображения модели, фиксируемый при экспорте по умолчанию: целое число для квадратных изображений или кортеж (height, width). Если не указать значение, экспорт использует размер, на котором обучали чекпойнт. В официальных чекпойнтах YOLO26 для моделей обнаружения, сегментации и оценки позы, а также для семантических моделей, предварительно обученных на ADE20K, используется 640; для моделей OBB и семантических моделей, предварительно обученных на Cityscapes, — 1024; для оценки глубины — 768; для классификации — 224. |
quantize | int или str | None | Точность: 16 (FP16) или 8 (8-битные веса с вычислениями в FP16; 'w8a16' выполняет такой же экспорт); 32 или отсутствие значения означает FP32. При nms=True отсутствие значения означает FP16. Чекпойнт, обученный с quantize=8, нельзя экспортировать в Core ML; см. раздел Ограничения и устранение неполадок. Заменяет устаревшие флаги half/int8. |
nms | bool, необязательно | None | Выбери необработанный выход (None, по умолчанию), встроенный NMS (True, для моделей обнаружения, сегментации и оценки позы с dynamic=False) или голову без NMS (False). См. раздел Формат выходных данных. |
conf | float | None | Порог уверенности, сохраняемый в экспорте nms=True. Если значение не задано, используется 0.25. |
iou | float | 0.5 | Порог IoU, сохраняемый в экспорте nms=True. |
agnostic_nms | bool | False | Выбор без учета класса: в экспорте nms=True рамка также подавляет пересекающиеся рамки других классов. Это также меняет выбор строк в экспорте nms=False. |
max_det | int | 300 | Количество строк в выходных данных экспорта nms=False и экспорта сегментации или оценки позы nms=True. Для экспорта обнаружения nms=True такого ограничения нет. |
dynamic | bool | False | Делает размер пакета, высоту и ширину входных данных динамическими и меняет тип входных данных с изображения на массив. Недоступно для моделей классификации и RT-DETR, а также при nms=True. См. раздел Развертывание. |
batch | int | 1 | Максимальный размер пакета для экспорта dynamic=True. По умолчанию размер пакета равен 1; другие значения приводят к ошибке. |
device | str | None | Устройство, на котором модель трассируется для преобразования; по умолчанию — cpu. Экспорт FP32, трассированный с mps, имел тот же размер пакета и возвращал те же результаты, что и экспорт, трассированный на CPU. |
Аргументы, общие для всех форматов, описаны в документации по режиму экспорта.
Официальные мобильные модели Core ML, LiteRT и QNN экспортируются с размером imgsz=640, а модели классификации — с размером imgsz=224. Чекпойнты семантической сегментации Cityscapes, оценки глубины и OBB по умолчанию экспортируются с большим размером, поэтому укажи imgsz=640, чтобы привести их к нужному размеру. Модели Core ML для Ultralytics iOS SDK экспортируются с quantize=8 nms=False.
Точность#
quantize задает способ хранения весов и точность вычислений Core ML. Для всех трех вариантов точности калибровочные данные не требуются. Размеры указаны для модели обнаружения YOLO26n, экспортированной с imgsz=640:
quantize | Веса | Вычисления | Минимальная версия ОС | Размер YOLO26n |
|---|---|---|---|---|
не задано или 32 | FP32 | FP32 | iOS 15, macOS 12 | 9.9 MB |
16 | FP16 | FP16 | iOS 15, macOS 12 | 5.1 MB |
8 или 'w8a16' | 8-битная | FP16 | iOS 16, macOS 13 | 2.7 MB |
- FP32: используется по умолчанию, если
nms=Trueне задан. На Apple M4 экспорты FP32 всех семи задач возвращали одинаковые результаты как при единицах вычисленийCPU_AND_NE, которые использует Ultralytics, так и приCPU_ONLY; с ними модель не работала быстрее. Чтобы использовать Neural Engine, экспортируй модель в FP16 или INT8. На iPhone 17 Pro модель обнаружения YOLO26n в FP32 была быстрее с Neural Engine не более чем на 5% по медиане трех запусков; см. Измеренную производительность. - FP16:
quantize=16сохраняет веса и выполняет вычисления с пониженной точностью. Типы входного изображения и выходных массивов остаются такими же, как у экспорта FP32 (float32илиint32для семантической сегментации), поэтому код инференса, написанный для модели FP32, работает без изменений. - INT8:
quantize=8иquantize="w8a16"выполняют одинаковый экспорт. Метод k-means группирует веса каждого слоя в наборы по 256 значений и сохраняет для каждого веса 8-битный индекс (палетизация); вычисления при этом выполняются в FP16, как и при экспорте FP16. Тензоры весов, содержащие не более 512 значений, не палетизируются. Это сжатие весов, а не калибровочное квантование активаций, выбираемое параметромquantize=8для других форматов, поэтому аргументdataне требуется. Еслиscikit-learnуже установлен, экспорт модели обнаружения YOLO26n занимает 18–26 с на Apple M4 и 23–24 с на сервере x86-64, а экспорт YOLO26x — 104 с на этом сервере. - Точность: результаты COCO для разных вариантов точности см. в таблицах для Apple M4. Перед развертыванием проверь точность экспортированной модели на собственных данных.
Формат вывода#
Экспорт создает один пакет — каталог, который Xcode, Core ML и coremltools открывают как единую модель:
Файл в yolo26n.mlpackage/ | Содержимое |
|---|---|
Manifest.json | Список файлов в пакете |
Data/com.apple.CoreML/model.mlmodel | Граф нейросети, описания входных и выходных данных и метаданные: названия классов, задача, размер изображения, размер пакета, шаг и аргументы экспорта, которые Ultralytics считывает при загрузке модели |
Data/com.apple.CoreML/weights/weight.bin | Веса |
Модель принимает один вход с именем image. При экспорте по умолчанию это входное изображение Core ML: изображение RGB размера imgsz с пиксельными значениями от 0 до 255. Деление на 255 выполняется внутри модели, поэтому не масштабируй изображение самостоятельно; в приложении фреймворк Vision от Apple может изменить размер кадра с камеры под этот вход. Экспорт с dynamic=True принимает вместо него массив float32 формы (batch, 3, height, width), в RGB и с масштабированием до диапазона 0–1.
Названия выходных массивов генерирует конвертер, например var_1401; они меняются в зависимости от модели и настроек экспорта, поэтому считывай их из описания модели, а не задавай жестко в коде. Аргумент nms и задача определяют выходные данные. Ниже приведены размеры для официальных чекпойнтов YOLO26n, экспортированных с размером по умолчанию; для семантической сегментации использован чекпойнт Cityscapes yolo26n-sem.pt:
| Задача | imgsz по умолчанию | Выход с nms=None | Выход с nms=False | Выход с nms=True |
|---|---|---|---|---|
| Обнаружение | 640 | (1, 84, 8400) | (1, 300, 6) | confidence (boxes, 80) и coordinates (boxes, 4) |
| Сегментация | 640 | (1, 116, 8400) и (1, 32, 160, 160) | (1, 300, 38) и (1, 32, 160, 160) | (1, 300, 38) и (1, 32, 160, 160) |
| Семантическая | 1024 | (1, 1024, 1024) — индекс класса для каждого пикселя | То же, что и nms=None | То же, что и nms=None |
| Глубина | 768 | (1, 1, 768, 768): карта глубины | То же, что и nms=None | То же, что и nms=None |
| Классификация | 224 | classLabel и classLabel_probs | То же, что и nms=None | То же, что и nms=None |
| Поза | 640 | (1, 56, 8400) | (1, 300, 57): 6 значений рамки, затем 17 ключевых точек × 3 | (1, 300, 57) |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 значения рамки, оценка, класс, угол | То же, что и nms=None |
- Необработанный выход (
nms=None): форма(1, values, anchors); те же необработанные предсказания, что и при экспорте ONNX по умолчанию: для каждого якоря — координаты центра рамки x и y, ширина и высота в пикселях входного изображения, затем оценки классов и значения для задачи (32 коэффициента маски, значения 17 x 3 ключевых точек или угол OBB в радианах). Примени NMS самостоятельно. - Выход без NMS (
nms=False):max_det(по умолчанию 300) строкx1, y1, x2, y2, score, classв пикселях входного изображения, без этапа NMS. Строки OBB имеют видcenter x, center y, width, height, score, class, angle. Отфильтруй строки по оценке. Доступно для моделей с головой без NMS, например YOLO26 и YOLOv10. - Встроенный NMS для обнаружения (
nms=True): пакет представляет собой конвейер Core ML из модели и этапа NMS от Apple. Он возвращаетconfidence— по одной строке оценок классов для каждой оставленной рамки, иcoordinates— координаты центра каждой оставленной рамки, ее ширину и высоту относительно размера изображения (0–1). Число строк меняется от изображения к изображению. Параметрыconf(по умолчанию0.25),iou(по умолчанию0.5) иagnostic_nmsсохраняются в конвейере при экспорте; входные параметрыconfidenceThresholdиiouThreshold, которые можно не указывать, заменяют два порога для отдельного предсказания. Параметрmax_detне действует: экспорт сmax_det=2все равно вернул пять рамок для тестового изображения. Если число классов модели не кратно 80, экспорт дополняетconfidenceдополнительными столбцами до ближайшего числа, кратного 80. - Встроенный NMS для сегментации и оценки позы (
nms=True): NMS выполняется внутри графа модели, который возвращаетmax_detстрокx1, y1, x2, y2, score, class, за которыми следуют коэффициенты масок или ключевые точки. Оценка строк после последнего обнаружения равна 0, поэтому отфильтруй строки по оценке. Параметрыconf,iou,agnostic_nmsиmax_detфиксируются при экспорте; такие экспорты всегда выполняются в FP16 или INT8. - Сегментация: трехмерный выход содержит предсказания, а четырехмерный — прототипы масок.
- Семантическая сегментация: выход содержит индекс класса каждого пикселя в виде
int32, а не оценку для каждого класса. - Классификация: пакет представляет собой классификатор Core ML, который возвращает
classLabel— название класса с наивысшей оценкой — иclassLabel_probs, словарь названий классов и вероятностей.coremltoolsтакже возвращает вероятности в виде массива(1, classes).
YOLO("yolo26n.mlpackage") считывает структуру данных из метаданных модели, поэтому эти сведения нужны только при запуске модели в собственном коде. Метаданные хранятся в пользовательских метаданных модели в виде строк. Среди ключей: names, task, imgsz, stride, batch, end2end, args и, для моделей оценки позы, kpt_shape.
Запуск с помощью coremltools#
Чтобы запустить пакет на Mac вне пакета Ultralytics, загрузи его с помощью coremltools, который также выбирает вычислительные блоки:
# Сначала экспортируй модель: 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)) # изображение с добавленными полями: RGB, 0–255
outputs = model.predict({"image": image})
detections = next(iter(outputs.values()))[0] # единственный выходной массив, первое изображение: форма (300, 6)
assert detections.shape == (300, 6), "export a detection model at imgsz=640 with nms=False"
detections = detections[detections[:, 4] > 0.25] # оставить строки выше порога уверенности
names = ast.literal_eval(model.user_defined_metadata["names"]) # {0: 'person', 1: 'bicycle', ...}Разверни#
На iPhone или iPad добавь .mlpackage в проект Xcode или воспользуйся Ultralytics iOS SDK, который сам загружает модель и декодирует выходные данные. На Mac установи пакет с помощью pip install ultralytics и скопируй в него .mlpackage: YOLO("yolo26n.mlpackage") запускает модель с coremltools, который Ultralytics устанавливает при первом использовании.
- Вычислительные блоки: Ultralytics загружает модель с вычислительными блоками Core ML
CPU_AND_NE— CPU и Neural Engine, а модели RT-DETR — сALL. Если модель не загружается с ними, она загружается сCPU_ONLY. Выбрать другие вычислительные блоки через аргумент нельзя; чтобы сделать это, загрузи пакет с помощьюcoremltools. На Apple M4 с macOS 27.2ALLиCPU_AND_GPUтакже запускали модели FP32, FP16 и INT8 для всех семи задач YOLO26n; другие версии macOS не проверялись. device: аргументdeviceне выбирает оборудование Core ML. Приdevice="mps"Ultralytics выполняет предобработку и постобработку на GPU Apple, а Core ML по-прежнему использует те же вычислительные блоки. На M4 это не ускорило инференс: модель YOLO26n в FP16 обрабатывала одно изображение примерно за 8 мс сdevice="mps"и за 6 мс без него, поэтому оставьdeviceнезаданным.- Точность и Neural Engine: на Apple M4 этап инференса
YOLO()для модели YOLO26n в FP32 занимал 18–20 мс на изображение приpredict(21.0 мс при проверке на COCO в тестах Apple M4), а для моделей FP16 и INT8 — около 6 мс. Это результаты экспорта по умолчанию (nms=None) на одном тестовом изображении с macOS 27.2. Только сcoremltoolsте же модели FP16 и INT8 обрабатывали изображение примерно за 2 мс сCPU_AND_NEпротив 9–10 мс сCPU_ONLY. - Фиксированная форма входных данных: экспорт по умолчанию всегда работает с размером
imgsz, заданным при экспорте и считываемым Ultralytics из метаданных модели. Параметрimgsz, переданный вpredictилиval, игнорируется. Ultralytics передает каждое изображение из пакета в Core ML отдельным запросом с одним изображением, поэтому можно обрабатывать любое количество изображений; параметрvalзадаетbatch=1. - Экспорт с динамическими размерами (
dynamic=True): модель поддерживает размеры пакета от 1 доbatch, заданного при экспорте, и размеры изображений от 32 пикселей до удвоенного значенияimgsz, заданного при экспорте; Ultralytics передает размеры изображений, кратные шагу модели. Ultralytics разбивает пакеты большего размера на части поbatch, заданному при экспорте. Для головы без NMS минимальный размер больше: 128 пикселей для модели YOLO26n, экспортированной сimgsz=640приnms=False. Проверено на модели обнаружения с размерами 320, 640 и 1280 пикселей и на модели сегментации размером 640 пикселей.
Ultralytics iOS SDK и Flutter Plugin#
Ultralytics iOS SDK — это пакет Swift, который загружает экспорты Core ML для всех семи задач YOLO26 и возвращает декодированные результаты. Экспортируй модель с настройками официальных моделей приложения:
# 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Добавь https://github.com/ultralytics/yolo-ios-app.git в приложение с помощью Swift Package Manager, а затем загрузи экспортированный пакет:
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 через VNCoreMLRequest из Vision, который масштабирует каждое изображение до размера входных данных модели. Для приложений с камерой YOLOView из SDK выполняет инференс в реальном времени с нативными наложениями, а плагин Ultralytics YOLO для Flutter запускает те же экспорты Core ML на iOS из общей с Android кодовой базы. На iOS 16 и новее SDK запрашивает у Core ML .cpuAndNeuralEngine вместо .all, поскольку в приложении с камерой GPU уже занят предварительным просмотром и наложениями.
Руководства по развертыванию#
- Интеграция модели Core ML в приложение: руководство Apple по добавлению модели в проект Xcode и ее вызову.
- Распознавание объектов в видеопотоке: пример Apple, показывающий запуск детектора Core ML на кадрах с камеры с помощью Vision и
VNCoreMLRequest. - MLComputeUnits: настройка
computeUnitsдляMLModelConfiguration, которая выбирает CPU, GPU и Neural Engine. - Оптимизация использования Core ML: сессия Apple о отчетах производительности Xcode, в которых для каждого слоя на устройстве указаны вычислительный блок и задержка.
- Руководство по Core ML Tools: справочник по преобразованию и оптимизации пакета
coremltools, используемого при экспорте. - Ultralytics Platform: открой экспорт Core ML в приложении Ultralytics YOLO на iPhone, отсканировав QR-код.
- Core AI, LiteRT и Qualcomm QNN: формат Apple для iOS 27, а также форматы для устройств Android и NPU Snapdragon.
Ограничения и устранение неполадок#
- Первый экспорт после обычной установки: если при первом экспорте требуется заменить
numpy(версии новее 2.3.5 нарушают процесс преобразования), Ultralytics выводит в журналRestart runtime or rerun command for updates to take effect, и этот экспорт завершается ошибкойTypeError: only 0-dimensional arrays can be converted to Python scalars. Запусти экспорт еще раз в новом процессе — в ноутбуке для этого перезапусти ядро — или установи"ultralytics[export-coreml]"перед первым экспортом, как описано в разделе Быстрый старт. - Система для экспорта: экспорт выполняется на macOS и Linux x86-64. Windows и Linux ARM64, например на Raspberry Pi, не поддерживаются:
coremltools9.0 публикует готовые пакеты только для macOS и Linux x86-64. - Версия Python:
coremltools9.0 предлагает готовые пакеты для Python 3.13 и более ранних версий. В Python 3.14pip install "ultralytics[export-coreml]"не устанавливает пакеты Core ML, поэтому при экспортеcoremltoolsсобирается из исходного кода. Первый экспорт завершается ошибкой, как и после обычной установки; следующий проходит сRuntimeError: BlobWriter not loaded. Создай среду с Python 3.13 или более ранней версией. - Для инференса требуется macOS: на Linux предсказание или проверка с
YOLO("yolo26n.mlpackage")завершаются ошибкойModel prediction is only supported on macOS version 10.13 or later.. Проверь там чекпойнт PyTorch или скопируй пакет на Mac. - Автоматическая установка отключена: при
YOLO_AUTOINSTALL=falseэкспорт завершается ошибкойNo module named 'coremltools', если пакет отсутствует в среде. - Контрольные точки, обученные с
quantize=8: дообученная с помощью квантования с учетом обучения контрольная точка не экспортируется сformat='coreml' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Вместо нее экспортируй исходную контрольную точку, с которой ты начал дообучение, используяquantize=8, либо экспортируй дообученную контрольную точку в ONNX или TensorRT. quantize="w8a32": завершается ошибкойquantize='w8a32' is not supported; format='coreml' supports quantize=16 (FP16), 8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 32 or None (FP32).. Для Core ML'w8a16'выполняет тот же экспорт, что и8, с вычислениями в FP16.- Встроенный NMS для других задач:
nms=Trueработает для моделей обнаружения, сегментации и оценки позы. Для моделей OBB и классификации экспорт выводит в журналCoreML 'nms=True' is only supported for detect, segment and pose models. Forcing 'nms=None'., для моделей семантической сегментации и оценки глубины —'nms=True' is not valid for semantic models. Forcing 'nms=None'.(илиdepth models), а для моделей RT-DETR —'nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.. Во всех этих случаях записывается выход экспорта по умолчанию. - Точность встроенного NMS: экспорт
nms=Trueбезquantizeвыполняется в FP16.quantize=32создает конвейер FP32 для модели обнаружения; для моделей сегментации и оценки позы экспорт выводит в журналCoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'.(илиpose models). - Встроенный NMS и проверка: экспорт
nms=Trueудаляет рамки с оценкой нижеconfдо того, как их увидитval, поэтому его результат ниже, чем у той же модели с внешним NMS: на COCO val2017 экспорт YOLO26n в FP16 сnms=Trueпоказал 33.8 mAPval 50-95 при значенииconf=0.25по умолчанию и 39.9 при экспорте сconf=0.001— все еще на 1.0 ниже результата 40.9 для экспорта FP16 по умолчанию. Чтобы проверить такую модель, экспортируй ее сconf=0.001, а порог для развертывания выбери отдельно. - Голова без NMS на других моделях: для
nms=Falseнужна модель с головой без NMS, например YOLO26 или YOLOv10. Для остальных моделей, например YOLO11, экспорт выводит предупреждениеThis model has no one-to-one head; using one-to-many outputs.и записывает необработанный выход(1, 84, 8400). - Размер пакета: значение
batchбольше 1 безdynamic=Trueприводит к ошибкеbatch sizes > 1 are not supported without 'dynamic=True' for CoreML export. Please retry at 'dynamic=True'.. - Динамические размеры: если для
dynamic=Trueне заданbatch, в журнал выводится'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'., а модель экспортируется с максимальным размером пакета 1. Сnms=Trueэкспорт завершается ошибкой'nms=True' cannot be used together with 'dynamic=True' for CoreML export. Please disable one of them., а для моделей классификации и RT-DETR —'dynamic=True' is not supported for CoreML classification or RT-DETR models.. Если размер изображения выходит за допустимый диапазон, при предсказании возникает ошибка, напримерSize (1312) of dimension (2) is not in allowed range (32..1280). - Семантическая сегментация на Neural Engine: на Apple M4 модель YOLO26n-sem обрабатывала изображения дольше с
CPU_AND_NE, чем сCPU_ONLY, используя толькоcoremltoolsна одном тестовом изображении: 59–64 мс против 22 мс для экспорта FP16 сimgsz=1024и около 15 мс против 9 мс для экспорта INT8 сimgsz=640. Модели FP16 для остальных шести задач и их модели INT8 сimgsz=640(224 для классификации) работали быстрее сCPU_AND_NE; на iPhone 17 Pro модель семантической сегментации INT8 также работала быстрее с Neural Engine. Для этих моделейYOLO()всегда используетCPU_AND_NE, поэтому измерь производительность семантической модели в собственном коде при обоих вариантах настройки. .cpuOnlyна iOS 27.0.1: на iPhone 17 Pro инференс.cpuOnlyдля моделей YOLO26l и YOLO26x задач оценки глубины, позы и OBB аварийно завершался внутри ядер CPU Core ML (EXC_BAD_ACCESSвlibBNNS). Эти модели работают с.cpuAndNeuralEngine, который запрашивает iOS SDK.- Имя пакета: каждый экспорт одного чекпойнта записывает один и тот же
yolo26n.mlpackageнезависимо отquantize,imgsz,nmsилиdynamic, поэтому более поздний экспорт заменяет предыдущий. Чтобы сохранить обе версии, переименуй пакет, оставив суффикс.mlpackage, напримерyolo26n_fp16.mlpackage, так как Ultralytics определяет формат по этому суффиксу. Пакет без суффикса завершается ошибкойis not a supported model format. - Предупреждение о версии PyTorch: с недавней версией PyTorch при загрузке
coremltoolsвыводит в журналTorch version 2.15.0 has not been tested with coremltools. You may run into unexpected errors., а с недавней версиейscikit-learn—scikit-learn version 1.9.1 is not supported.. Экспорты и результаты на Mac, представленные на этой странице, получены с использованием этих версий. - Устаревшие файлы
.mlmodel:format="mlmodel"экспортирует более ранний формат нейронной сети Core ML в виде одного файлаyolo26n.mlmodelдля приложений, которые не могут загружать ML Program. В этом форматеquantize=8и'w8a16'применяют линейное 8-битное квантование весов. Для новых проектов используй.mlpackageпо умолчанию.
Другие ошибки описаны в руководстве по распространённым проблемам.
Измеренная производительность#
Таблицы ниже составлены по результатам измерений на iPhone 17 Pro и Mac с Apple M4. На странице моделей YOLO26 указана точность чекпойнтов PyTorch для каждой задачи.
iPhone 17 Pro#
Оборудование: iPhone 17 Pro с iOS 26.6. Его A19 Pro оснащён 6-ядерным CPU (2 производительными и 4 энергоэффективными ядрами), 6-ядерным GPU и 16-ядерным Neural Engine.
В первой таблице указана задержка обработки одного изображения официальной INT8-моделью для каждой задачи — речь об артефактах v8.3.0 из iOS SDK Ultralytics, экспортированных с помощью nms=False. В каждой ячейке показано общее время в миллисекундах, а ниже — разбивка на предварительную обработку / инференс / постобработку; более быстрый вычислительный блок выделен жирным:
| Модель | Задача | размер (пиксели) | CPU Core ML .cpuOnly(мс) | CPU + Neural Engine Core ML .cpuAndNeuralEngine(мс) |
|---|---|---|---|---|
| YOLO26n | Обнаружение | 640 | 9.7 0.0 / 9.7 / 0.0 | 4.7 0.0 / 4.7 / 0.0 |
| YOLO26n-seg | Сегментация | 640 | 12.8 0.0 / 12.2 / 0.6 | 5.8 0.0 / 5.0 / 0.7 |
| YOLO26n-sem | Семантическая | 640 | 9.3 0.0 / 8.9 / 0.5 | 5.3 0.0 / 4.8 / 0.5 |
| YOLO26n-depth | Глубина | 640 | 25.8 0.0 / 24.8 / 1.0 | 8.0 0.0 / 6.9 / 1.1 |
| YOLO26n-cls | Классификация | 224 | 2.1 0.0 / 2.0 / 0.0 | 1.8 0.0 / 1.8 / 0.0 |
| YOLO26n-pose | Поза | 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 |
Та же замеренная величина для пяти моделей обнаружения, а также время, необходимое SDK для загрузки каждой модели:
| Модель | CPU.cpuOnly(мс) | CPU + Neural Engine.cpuAndNeuralEngine(мс) | Загрузка модели.cpuAndNeuralEngine(с) |
|---|---|---|---|
| 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 |
Обнаружение объектов YOLO26n в трёх форматах точности и с двумя настройками nms, экспортированной с помощью ultralytics 8.4.215 в imgsz=640; указано общее время в миллисекундах:
| Точность | 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 |
- Методика: среднее время 15 предсказаний после 3 прогревочных предсказаний на
bus.jpg, через Swift SDK 8.9.23 в релизной сборке..cpuOnlyи.cpuAndNeuralEngine— это вычислительные блоки Core ML, запрашиваемые SDK; Core ML сам решает, где выполнять каждый слой. Каждую таблицу измеряли в трёх отдельных запусках и приводят медианное значение. Результаты трёх запусков отличались не более чем на 15%, за исключением YOLO26n с.cpuAndNeuralEngine: в таблице размеров время составило от 2.6 до 4.8 мс, а для экспорта INT8nms=None— от 3.8 до 4.8 мс. В таблицах задач и размеров используются официальные артефактыv8.3.0, а в таблице точности — экспорты, созданные с помощьюultralytics8.4.215, поэтому значения для YOLO26n различаются: до 0.5 мс с Neural Engine и до 0.6 мс на CPU. - Предварительная обработка: Vision масштабирует изображение в рамках запроса на инференс, поэтому предварительная обработка указана как 0, а её стоимость учитывается в инференсе.
- FP32: согласно этим медианным значениям, экспорт FP32 был максимум на 5% быстрее с
.cpuAndNeuralEngine, чем с.cpuOnly, тогда как FP16 и INT8 работали примерно вдвое быстрее. Для Neural Engine экспортируй модель в FP16 или INT8. nms: при обнаружении объектов YOLO26n голова без NMS (nms=False) и исходный выход с NMS в SDK (nms=None) обрабатывались с Neural Engine за 4–5 мс в FP16 и INT8.- Приложения с камерой: здесь указана задержка обработки одного изображения. В приложении камеры реального времени добавляется время захвата и отображения; см. примечания о производительности iOS SDK.
- Сравни результаты для CPU/GPU на Android в интеграции LiteRT, результаты для MediaTek Dimensity и результаты для NPU Snapdragon в интеграции Qualcomm QNN.
Apple M4#
В таблицах ниже сравниваются PyTorch в FP32, FP16 и INT8-модели Core ML для всех моделей обнаружения YOLO26 на Apple M4 (4 производительных и 6 энергоэффективных ядер) с macOS 27.2. Проверка выполнена через YOLO() на COCO val2017. PyTorch работал на CPU с 8 потоками, batch=1 и rect=False, чтобы получить те же входные изображения 640x640, что и модели Core ML, запущенные со стандартными вычислительными блоками Ultralytics.
Миллисекунды на изображение; меньше — лучше. Для каждой модели жирным выделен самый быстрый формат.
| Модель | 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 (nms=False) YOLO26n достигла 40.3 mAPval 50-95 в PyTorch и FP32, 40.2 в FP16 и 40.1 в INT8.
Задержка YOLO26n с каждым вычислительным блоком Core ML, измеренная только с помощью coremltools как медиана 20 предсказаний для одного изображения, в миллисекундах:
| Точность | 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 и INT8 работали в 3.5–14 раз быстрее FP32 через
YOLO(); точность FP16 отличалась от FP32 не более чем на 0.1 mAP, а INT8 — не более чем на 0.2. Для YOLO26n INT8 был таким же быстрым, как FP16, а для более крупных моделей — до 1.3 раза быстрее. - FP32 выдавал такие же результаты с
CPU_AND_NE, как и сCPU_ONLY. Ускорение обеспечивали только вычислительные блоки GPU. - INT8 уменьшил размер пакета в 3.7–4.0 раза по сравнению с FP32.
Измерено с ultralytics 8.4.215, coremltools 9.0 и PyTorch 2.15.0 в batch=1 17 ноября 2026 года. Задержка — это этап инференса, который показывает val; предварительная обработка и постобработка не учитываются. При повторном запуске в тот же день трёх случаев Core ML для YOLO26n разница составила до 2.3 мс: 21.0 против 18.8 мс для FP32.
О Core ML#
Core ML встроен в iOS, iPadOS, macOS, watchOS, tvOS и visionOS. Он загружает модели в формате ML Program, который создаёт этот экспорт .mlpackage, и выполняет каждый слой на CPU, GPU или Apple Neural Engine — NPU чипов Apple. Поэтому инференс работает без подключения к сети, а данные остаются на устройстве. Полную справочную информацию см. в документации Core ML.
Смотри: Как экспортировать Ultralytics YOLO26 в CoreML с квантованием INT8 | Развертывание на устройствах Apple | iOS/MacOS 🍎
Часто задаваемые вопросы#
Оба формата работают на Neural Engine и выполняют вычисления в FP16, поэтому выбирать нужно по размеру. FP16 (
quantize=16) уменьшает размер пакета вдвое: 5.1 МБ против 9.9 МБ для YOLO26n. INT8 (quantize=8) хранит веса в 8-битном формате, занимает 2.7 МБ для YOLO26n и используется в официальных моделях приложения Ultralytics. На COCO val2017 экспорт YOLO26n со стандартными настройками достиг 40.9 mAPval 50-95 в FP16 и 40.8 в INT8 на Apple M4; время обработки одного изображения в обоих форматах было примерно одинаковым. На iPhone 17 Pro оба формата обрабатывали YOLO26n за 4–5 мс с Neural Engine — разница укладывалась в разброс между запусками. Для INT8 требуется iOS 16 или macOS 13, тогда как FP16 работает также на iOS 15 и macOS 12. Ни для одного из форматов не нужны калибровочные данные. Не используй стандартный экспорт FP32 для развёртывания: он самый большой, а в наших тестах с вычислительными блоками Neural Engine был максимум на 5% быстрее, чем только на CPU; см. Точность. Перед выпуском проверь экспортированную модель на собственных данных и устройстве.Всё зависит от того, кто декодирует выходные данные. С Ultralytics iOS SDK или плагином Flutter экспортируй модели YOLO26 с помощью
nms=False, как это сделано в официальных моделях: SDK считывает итоговые детекции от головы без NMS, поэтому этап NMS не нужен. На COCO val2017 YOLO26n в INT8 достигла 40.1 mAPval 50-95 с головой без NMS против 40.8 с выходными данными по умолчанию и внешним NMS. На iPhone 17 Pro оба варианта обрабатывали изображение за 4–5 мс. С фреймворком Vision от Apple и собственным кодомnms=Trueпреобразует модель детекции в конвейер Core ML с этапом NMS от Apple, пороги которого можно менять для каждого предсказания. Vision возвращает детекции в виде объектовVNRecognizedObjectObservation, а оценка объекта — этоconfidenceнаблюдения. Для модели детекцииnms=TrueSDK версии 8.9.23 и ниже сообщают примерно 1.0 — уверенность метки с наивысшей оценкой для каждого объекта — вместо оценок объектов; более поздние версии сообщаютconfidenceнаблюдения. По умолчаниюnms=Noneвозвращает необработанные предсказания и оставляет NMS твоему коду. Описание выходных данных для каждого параметра см. в разделе Формат выходных данных.Экспортировать модель можно и без Mac: экспорт выполняется на Linux с архитектурой x86-64, а Ultralytics Platform выполняет экспорт в облаке. Для запуска модели требуется оборудование Apple, поскольку Core ML входит в операционные системы Apple. В Linux и Windows проверь контрольную точку PyTorch или её экспорт в ONNX, а затем проверь саму модель Core ML на Mac, где её запускает
YOLO("yolo26n.mlpackage").val(), или непосредственно на устройстве.
Комментарии13
Задай вопрос, поделись результатами или помоги кому-нибудь.
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(изменено)@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! 😊
