Начать

Экспорт в 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-битными весами.

Новый формат Core AI от Apple

Apple представила новый фреймворк Core AI и формат .aimodel для поколения iOS 27 и macOS 27, а Ultralytics поддерживает его экспорт с помощью format="coreai". Core ML остается форматом по умолчанию для Ultralytics iOS SDK и Flutter SDK: они загружают Core AI как дополнительный вариант на устройствах с iOS 27, а также поддерживают этот формат в более ранних операционных системах Apple.

Краткий обзор#

СвойствоОписание
Аргумент formatcoreml (псевдонимы: 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, экспорт завершается с ошибкой; следующий экспорт проходит успешно. Для экспорта требуются следующие версии:

ПакетТребуемая версия
Python3.13 или более ранняя версия — самая новая версия, для которой coremltools 9.0 предлагает готовые пакеты
coremltools9.0 или новее
numpy2.3.5 или более ранняя версия. При экспорте поверх более новой версии устанавливается 2.3.5
torch1.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.

Аргументы экспорта#

АргументТипПо умолчаниюОписание
formatstr'coreml'Целевой формат экспортируемой модели, определяющий совместимость с различными средами развертывания.
imgszint или tuple640Размер входного изображения модели, фиксируемый при экспорте по умолчанию: целое число для квадратных изображений или кортеж (height, width). Если не указать значение, экспорт использует размер, на котором обучали чекпойнт. В официальных чекпойнтах YOLO26 для моделей обнаружения, сегментации и оценки позы, а также для семантических моделей, предварительно обученных на ADE20K, используется 640; для моделей OBB и семантических моделей, предварительно обученных на Cityscapes, — 1024; для оценки глубины — 768; для классификации — 224.
quantizeint или strNoneТочность: 16 (FP16) или 8 (8-битные веса с вычислениями в FP16; 'w8a16' выполняет такой же экспорт); 32 или отсутствие значения означает FP32. При nms=True отсутствие значения означает FP16. Чекпойнт, обученный с quantize=8, нельзя экспортировать в Core ML; см. раздел Ограничения и устранение неполадок. Заменяет устаревшие флаги half/int8.
nmsbool, необязательноNoneВыбери необработанный выход (None, по умолчанию), встроенный NMS (True, для моделей обнаружения, сегментации и оценки позы с dynamic=False) или голову без NMS (False). См. раздел Формат выходных данных.
conffloatNoneПорог уверенности, сохраняемый в экспорте nms=True. Если значение не задано, используется 0.25.
ioufloat0.5Порог IoU, сохраняемый в экспорте nms=True.
agnostic_nmsboolFalseВыбор без учета класса: в экспорте nms=True рамка также подавляет пересекающиеся рамки других классов. Это также меняет выбор строк в экспорте nms=False.
max_detint300Количество строк в выходных данных экспорта nms=False и экспорта сегментации или оценки позы nms=True. Для экспорта обнаружения nms=True такого ограничения нет.
dynamicboolFalseДелает размер пакета, высоту и ширину входных данных динамическими и меняет тип входных данных с изображения на массив. Недоступно для моделей классификации и RT-DETR, а также при nms=True. См. раздел Развертывание.
batchint1Максимальный размер пакета для экспорта dynamic=True. По умолчанию размер пакета равен 1; другие значения приводят к ошибке.
devicestrNoneУстройство, на котором модель трассируется для преобразования; по умолчанию — 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
не задано или 32FP32FP32iOS 15, macOS 129.9 MB
16FP16FP16iOS 15, macOS 125.1 MB
8 или 'w8a16'8-битнаяFP16iOS 16, macOS 132.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
Классификация224classLabel и classLabel_probsТо же, что и nms=NoneТо же, что и nms=None
Поза640(1, 56, 8400)(1, 300, 57): 6 значений рамки, затем 17 ключевых точек × 3(1, 300, 57)
OBB1024(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.2 ALL и 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 уже занят предварительным просмотром и наложениями.

Руководства по развертыванию#

Ограничения и устранение неполадок#

  • Первый экспорт после обычной установки: если при первом экспорте требуется заменить 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, не поддерживаются: coremltools 9.0 публикует готовые пакеты только для macOS и Linux x86-64.
  • Версия Python: coremltools 9.0 предлагает готовые пакеты для Python 3.13 и более ранних версий. В Python 3.14 pip 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Обнаружение6409.7
0.0 / 9.7 / 0.0
4.7
0.0 / 4.7 / 0.0
YOLO26n-segСегментация64012.8
0.0 / 12.2 / 0.6
5.8
0.0 / 5.0 / 0.7
YOLO26n-semСемантическая6409.3
0.0 / 8.9 / 0.5
5.3
0.0 / 4.8 / 0.5
YOLO26n-depthГлубина64025.8
0.0 / 24.8 / 1.0
8.0
0.0 / 6.9 / 1.1
YOLO26n-clsКлассификация2242.1
0.0 / 2.0 / 0.0
1.8
0.0 / 1.8 / 0.0
YOLO26n-poseПоза64011.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

Та же замеренная величина для пяти моделей обнаружения, а также время, необходимое SDK для загрузки каждой модели:

МодельCPU
.cpuOnly
(мс)
CPU + Neural Engine
.cpuAndNeuralEngine
(мс)
Загрузка модели
.cpuAndNeuralEngine
(с)
YOLO26n9.24.50.9
YOLO26s19.510.51.3
YOLO26m46.711.81.8
YOLO26l60.112.02.4
YOLO26x125.920.53.3

Обнаружение объектов YOLO26n в трёх форматах точности и с двумя настройками nms, экспортированной с помощью ultralytics 8.4.215 в imgsz=640; указано общее время в миллисекундах:

Точностьnms=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
  • Методика: среднее время 15 предсказаний после 3 прогревочных предсказаний на bus.jpg, через Swift SDK 8.9.23 в релизной сборке. .cpuOnly и .cpuAndNeuralEngine — это вычислительные блоки Core ML, запрашиваемые SDK; Core ML сам решает, где выполнять каждый слой. Каждую таблицу измеряли в трёх отдельных запусках и приводят медианное значение. Результаты трёх запусков отличались не более чем на 15%, за исключением YOLO26n с .cpuAndNeuralEngine: в таблице размеров время составило от 2.6 до 4.8 мс, а для экспорта INT8 nms=None — от 3.8 до 4.8 мс. В таблицах задач и размеров используются официальные артефакты v8.3.0, а в таблице точности — экспорты, созданные с помощью ultralytics 8.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.

Миллисекунды на изображение; меньше — лучше. Для каждой модели жирным выделен самый быстрый формат.

МодельimgszPyTorchCore 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 (nms=False) YOLO26n достигла 40.3 mAPval 50-95 в PyTorch и FP32, 40.2 в FP16 и 40.1 в INT8.

Задержка YOLO26n с каждым вычислительным блоком Core ML, измеренная только с помощью coremltools как медиана 20 предсказаний для одного изображения, в миллисекундах:

ТочностьCPU_ONLYCPU_AND_NEALLCPU_AND_GPU
FP3213.713.68.38.0
FP169.61.82.07.7
INT89.41.81.88.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.

Apple Core ML deployment pipeline



Смотри: Как экспортировать 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=True SDK версии 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

Задай вопрос, поделись результатами или помоги кому-нибудь.

  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(изменено)

      @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! 😊