Apple Core ML 导出
Core ML 是 Apple 用于在 iPhone、iPad、Mac、Apple Watch、Apple TV 和 Apple Vision Pro 上运行机器学习模型的框架。使用 format="coreml" 导出 Ultralytics YOLO26 模型会创建一个 yolo26n.mlpackage 模型包,Core ML 可在 CPU、GPU 和 Apple Neural Engine 上以 FP32、FP16 或 8 位权重运行该模型。
Apple 为 iOS 27 和 macOS 27 这一代系统推出了新的 Core AI 框架和 .aimodel 格式,Ultralytics 使用 format="coreai" 导出该格式。Core ML 仍是 Ultralytics iOS 和 Flutter SDK 的默认格式;在 iOS 27 设备上,这些 SDK 可选择加载 Core AI,而较早的 Apple 操作系统仍使用 Core ML 格式。
概览#
| 属性 | 详情 |
|---|---|
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 中,macOS 上的 coremltools 包 |
| 精确率 | FP32、FP16、INT8(8 位权重)。YOLO26n 的 FP32、FP16 和 INT8 版本分别为 9.9 MB、5.1 MB 和 2.7 MB |
| 导出主机 | macOS 或 Linux x86-64,需使用 Python 3.13 或更早版本。不支持 Windows。导出不需要 GPU |
Ultralytics Platform 可帮你将训练好的模型导出为 Core ML,因此你不需要本地导出环境。
快速入门#
在 macOS 或 x86-64 Linux 上安装带有 Core ML 导出依赖项的 Ultralytics 包:
pip install "ultralytics[export-coreml]"这会安装 coremltools、scikit-learn,以及一个与 coremltools 兼容的 numpy 版本。使用普通的 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 extra 会安装 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,因此第二次导出会替换第一次的结果。预测和验证只能在 macOS 上运行:
from ultralytics import YOLO
# 在 Mac 上加载导出的 Core ML 模型
model = YOLO("yolo26n.mlpackage")
# 运行推理
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# 在 Mac 上加载导出的 Core ML 模型
model = YOLO("yolo26n.mlpackage")
# 在 COCO8 数据集上验证准确率
metrics = model.val(data="coco8.yaml")支持的任务#
Core ML 导出支持 YOLOv8、YOLO11 和 YOLO26 模型的全部七种 Ultralytics 任务:目标检测、实例分割、语义分割、深度估计、分类、姿态估计和 OBB。语义分割和深度估计仅适用于 YOLO26,因为只有 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(使用 FP16 计算的 8 位权重;'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 | 存储在 nms=True 导出模型中的 IoU 阈值。 |
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。使用 mps 追踪的 FP32 导出模型与在 CPU 上追踪的模型包大小相同,输出也相同。 |
所有格式共有的参数请参阅导出模式文档。
官方 Core ML、LiteRT 和 QNN 移动模型以 imgsz=640 导出,分类模型则以 imgsz=224 导出。Cityscapes 语义分割、深度估计和 OBB 检查点默认以更大的尺寸导出,因此要与它们保持一致,请传入 imgsz=640。Ultralytics iOS SDK 的 Core ML 模型使用 quantize=8 nms=False 导出。
精确率#
quantize 用于选择权重的存储方式和 Core ML 的计算精度。这三种精度都不需要校准数据。以下尺寸以在 imgsz=640 导出的 YOLO26n 检测模型为准:
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 上,使用CPU_AND_NE计算单元时,七种任务的 FP32 导出模型输出都与使用CPU_ONLY时相同,而且速度并未更快。要使用 Neural Engine,请以 FP16 或 INT8 导出。在 iPhone 17 Pro 上,FP32 YOLO26n 检测模型使用 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 检测模型在 Apple M4 上耗时 18 到 26 秒,在 x86-64 服务器上耗时 23 到 24 秒;YOLO26x 在该服务器上的导出耗时 104 秒。 - 精度:参见 Apple M4 表格,查看各精度下的 COCO 结果。部署前,请使用你自己的数据验证导出的模型。
输出格式#
导出会写入一个模型包,即一个目录,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 图像输入:尺寸为导出 imgsz 的 RGB 图像,像素值范围为 0 到 255。模型内部会将像素值除以 255,因此不要自行缩放图像;在应用中,Apple 的 Vision 框架可以将摄像头帧调整为此输入尺寸。使用 dynamic=True 导出的模型则接收形状为 (batch, 3, height, width) 的 float32 数组,内容为 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):模型包是由模型和 Apple NMS 阶段组成的 Core ML 流水线。它返回confidence(每个保留框对应一行类别分数)和coordinates(每个保留框的中心 x、中心 y、宽度和高度,均相对于图像尺寸,范围为 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。 - 分割:3-D 输出包含预测结果,4-D 输出包含掩码原型。
- 语义分割:输出为每个像素的类别索引
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)) # 你经过 letterbox 处理的图像: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加载模型包。在运行 macOS 27.2 的 Apple M4 上,ALL和CPU_AND_GPU也能运行 YOLO26n 七种任务的 FP32、FP16 和 INT8 模型;其他 macOS 版本未经测试。 device:device参数不会选择 Core ML 硬件。使用device="mps"时,Ultralytics 会在 Apple GPU 上进行预处理和后处理,而 Core ML 仍使用相同的计算单元。在 M4 上,这并未提升推理速度:FP16 YOLO26n 模型使用device="mps"时每张图像耗时约 8 毫秒,不使用时约 6 毫秒,因此不要设置device。- 精度与 Neural Engine:在 Apple M4 上,FP32 YOLO26n 模型的
YOLO()推理阶段使用predict时,每张图像耗时 18 到 20 毫秒(在 Apple M4 的 COCO 验证中为 21.0 毫秒);FP16 和 INT8 模型耗时约 6 毫秒。这些数据是在 macOS 27.2 上对一张测试图像测得,使用的是默认(nms=None)导出模型。单独使用coremltools时,相同的 FP16 和 INT8 模型使用CPU_AND_NE耗时约 2 毫秒,而使用CPU_ONLY耗时 9 到 10 毫秒。 - 固定输入形状:默认导出模型始终以其导出时的
imgsz运行,Ultralytics 会从模型元数据中读取此值。传给predict或val的imgsz会被忽略。Ultralytics 会将批次中的每张图像分别作为单图像请求传给 Core ML,因此图像数量不受限制;val用于设置batch=1。 - 动态导出(
dynamic=True):模型声明批次大小范围为 1 到导出时的batch,图像尺寸范围为 32 像素到导出时imgsz的两倍;Ultralytics 传入的图像尺寸是模型步长的整数倍。Ultralytics 会将较大的批次拆分为大小由导出batch指定的多个块。使用无 NMS 检测头时,最小尺寸会更大:对于在imgsz=640下使用nms=False导出的 YOLO26n 模型,最小尺寸为 128 像素。检测模型分别在 320、640 和 1280 像素下测试,分割模型则在 640 像素下测试。
Ultralytics iOS SDK 和 Flutter 插件#
Ultralytics iOS SDK 是一个 Swift 包,可加载 YOLO26 全部七种任务的 Core ML 导出模型,并返回解码后的结果。请使用官方应用模型的设置导出:
# INT8 weights and the NMS-free head; use imgsz=224 for classification models
yolo export model=yolo26n.pt format=coreml quantize=8 nms=False imgsz=640使用 Swift Package Manager 将 https://github.com/ultralytics/yolo-ios-app.git 添加到你的应用,然后加载导出的模型包:
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 通过 Vision 的 VNCoreMLRequest 运行 Core ML 模型,并将每张图像缩放到模型输入尺寸。对于摄像头应用,SDK 的 YOLOView 可通过原生叠加层进行实时推理;Ultralytics YOLO Flutter 插件则可在 iOS 上运行相同的 Core ML 导出模型,并与 Android 共用代码库。在 iOS 16 及更高版本上,SDK 会请求 Core ML 使用 .cpuAndNeuralEngine,而不是 .all,因为摄像头应用中的 GPU 已在处理预览画面和叠加层。
部署指南#
- 将 Core ML 模型集成到你的应用中:Apple 提供的指南,介绍如何将模型添加到 Xcode 项目并调用模型。
- 识别实时捕获的对象:Apple 提供的示例,演示如何使用 Vision 和
VNCoreMLRequest在摄像头帧上运行 Core ML 检测器。 - MLComputeUnits:
MLModelConfiguration的computeUnits设置,用于选择 CPU、GPU 和 Neural Engine。 - 优化 Core ML 的使用:Apple 关于 Xcode 性能报告的讲解;性能报告会显示设备上每一层使用的计算单元和延迟。
- Core ML Tools 指南:本次导出所用
coremltools包的转换与优化参考文档。 - Ultralytics Platform:扫描二维码,即可在 iPhone 上的 Ultralytics YOLO 应用中打开 Core ML 导出模型。
- Core AI、LiteRT 和 Qualcomm QNN:用于 iOS 27 的 Apple 格式,以及适用于 Android 设备和 Snapdragon NPU 的格式。
限制和故障排查#
- 普通安装后的首次导出:如果首次导出需要替换
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而失败。请在新进程中再次运行导出;如果在 Notebook 中运行,则需重启内核。或者按照快速入门中的说明,在首次导出前安装"ultralytics[export-coreml]"。 - 导出主机:导出可在 macOS 和 x86-64 Linux 上运行。Windows 和 ARM64 Linux(例如 Raspberry Pi)不受支持:
coremltools9.0 仅为 macOS 和 x86-64 Linux 提供预编译包。 - Python 版本:
coremltools9.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 的精度:未使用
quantize的nms=True导出模型采用 FP16。quantize=32会为检测模型生成 FP32 流水线;对于分割和姿态模型,导出会记录CoreML 'nms=True' requires FP16 for segment models. Forcing 'quantize=16'.(或pose models)。 - 内嵌 NMS 与验证:
nms=True导出模型会在val处理框之前,移除分数低于其conf的框,因此得分低于使用外部 NMS 的同一模型:在 COCO val2017 上,使用默认conf=0.25和nms=True导出的 FP16 YOLO26n 模型达到 33.8 mAPval 50-95;使用conf=0.001导出时达到 39.9,仍比默认 FP16 导出模型的 40.9 低 1.0。请使用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时也是如此:在imgsz=1024下导出的 FP16 模型耗时 59 到 64 毫秒,而 FP16 导出模型耗时 22 毫秒;在imgsz=640下导出的 INT8 模型耗时约 15 毫秒,而 INT8 导出模型耗时 9 毫秒。其他六种任务的 FP16 模型,以及使用imgsz=640导出的 INT8 模型(分类为 224),使用CPU_AND_NE时运行更快;在 iPhone 17 Pro 上,INT8 语义分割模型使用 Neural Engine 时也更快。YOLO()始终对这些模型使用CPU_AND_NE,因此请在自己的代码中使用这两种设置测试语义分割模型。 - iOS 27.0.1 上的
.cpuOnly:在 iPhone 17 Pro 上,使用.cpuOnly推理 YOLO26l 和 YOLO26x 的深度、姿态及 OBB 模型时,会在 Core ML 的 CPU 内核中崩溃(libBNNS中的EXC_BAD_ACCESS)。使用.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文件:对于无法加载 ML Program 的应用,format="mlmodel"会将较早的 Core ML 神经网络格式导出为单个yolo26n.mlmodel文件。在该格式中,quantize=8和'w8a16'用于线性 8 位权重量化。新项目请使用默认的.mlpackage。
其他错误请参阅常见问题指南。
实测性能#
下表数据是在 iPhone 17 Pro 和 Apple M4 Mac 上测得的。YOLO26 模型页面列出了各项任务的 PyTorch 检查点精度。
iPhone 17 Pro#
硬件:iPhone 17 Pro,搭载 iOS 26.6。其 A19 Pro 配备 6 核 CPU(2 个性能核心和 4 个能效核心)、6 核 GPU 和 16 核 Neural Engine。
第一个表格列出了每项任务官方 INT8 模型处理单张图像的延迟。这些模型是Ultralytics iOS SDK的 v8.3.0 资源,使用 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 |
- 方法:在
bus.jpg上进行 3 次预热预测后,取 15 次预测的平均值;测试通过 Swift SDK 8.9.23 的发布版本进行。.cpuOnly和.cpuAndNeuralEngine是 SDK 请求的 Core ML 计算单元,具体每一层在哪运行由 Core ML 决定。每张表分别测量了三次,并显示中位数。除使用.cpuAndNeuralEngine的 YOLO26n 外,三次运行的结果差异均在 15% 以内;该模型在尺寸表中的耗时为 2.6 至 4.8 ms,在 INT8nms=None导出中的耗时为 3.8 至 4.8 ms。任务和尺寸表使用官方v8.3.0资源,精度表使用ultralytics8.4.215 导出的模型,因此 YOLO26n 对应单元格的结果有所不同:使用 Neural Engine 时最多相差 0.5 ms,使用 CPU 时最多相差 0.6 ms。 - 预处理:Vision 会在推理请求中缩放图像,因此预处理耗时记为 0,其开销计入推理阶段。
- FP32:从这些中位数来看,FP32 导出使用
.cpuAndNeuralEngine时最多比使用.cpuOnly快 5%,而 FP16 和 INT8 的速度约快一倍。要使用 Neural Engine,请导出为 FP16 或 INT8。 nms:对于 YOLO26n 检测,使用 Neural Engine 和 FP16、INT8 时,无 NMS 检测头(nms=False)和由 SDK 执行 NMS 的原始输出(nms=None)耗时均为 4 到 5 ms。- 相机应用:这些是单张图像的延迟。实时相机应用还会增加采集和显示耗时;请参阅iOS SDK 性能说明。
- 在 LiteRT 集成、MediaTek Dimensity 的结果,以及 Qualcomm QNN 集成中的 Snapdragon NPU 结果之间比较 Android CPU/GPU 性能。
Apple M4#
下表比较了 Apple M4(4 个性能核心和 6 个能效核心)上每个 YOLO26 检测模型的 PyTorch FP32、FP16 和 INT8 Core ML 模型。设备运行 macOS 27.2,并通过 YOLO() 在 COCO val2017 上进行验证。PyTorch 使用 CPU、8 个线程、batch=1 和 rect=False 运行,以确保输入与 Core ML 模型相同,均为 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 在 PyTorch 和 FP32 下均达到 40.3 mAPval 50-95,FP16 下为 40.2,INT8 下为 40.1。
下列数据是 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通过
YOLO()运行时,比 FP32 快 3.5 到 14 倍;FP16 的精度与 FP32 相差不超过 0.1 mAP,INT8 则相差不超过 0.2。YOLO26n 的 INT8 速度与 FP16 相同,较大模型的 INT8 速度最高快 1.3 倍。 - FP32通过
CPU_AND_NE得到的输出与通过CPU_ONLY得到的相同。只有 GPU 计算单元能提升速度。 - INT8使软件包比 FP32 小 3.7 到 4.0 倍。
测量使用了 ultralytics 8.4.215、coremltools 9.0 和 PyTorch 2.15.0,于 2026 年 11 月 17 日在 batch=1 上进行。延迟是 val 报告的推理阶段耗时,不包括预处理或后处理。当天对三种 YOLO26n Core ML 情况进行了第二次测试,结果最多相差 2.3 ms;FP32 的耗时分别为 21.0 和 18.8 ms。
关于 Core ML#
Core ML 内置于 iOS、iPadOS、macOS、watchOS、tvOS 和 visionOS。它会加载 ML Program 格式的模型,即此导出生成的 .mlpackage,并在 CPU、GPU 或 Apple Neural Engine(Apple 芯片的 NPU)上运行每一层,因此推理可以离线运行,数据也会保留在设备上。完整参考资料请参阅 Core ML 文档。
观看: 如何将 Ultralytics YOLO26 导出为 CoreML 并进行 INT8 量化 | Apple 部署 | iOS/MacOS 🍎
常见问题#
两者都能在 Neural Engine 上运行,并以 FP16 进行计算,因此选择取决于模型大小。FP16(
quantize=16)会将软件包大小减半:YOLO26n 为 5.1 MB,而非 9.9 MB;INT8(quantize=8)以 8 位权重存储,YOLO26n 大小为 2.7 MB,也是 Ultralytics 官方应用模型采用的精度。在 COCO val2017 上,默认 YOLO26n 导出模型在 Apple M4 上的 FP16 精度为 40.9 mAPval 50-95,INT8 精度为 40.8,两者处理每张图像所需的时间也大致相同。在 iPhone 17 Pro 上,YOLO26n 使用 Neural Engine 和这两种精度时,耗时均为 4 到 5 ms,处于多次运行的波动范围内。INT8 需要 iOS 16 或 macOS 13,而 FP16 也能在 iOS 15 和 macOS 12 上运行。两者都不需要校准数据。部署时应避免使用默认的 FP32 导出:它体积最大,而且在我们的测试中,使用 Neural Engine 计算单元最多只比单独使用 CPU 快 5%;请参阅精度。发布前,请在你自己的数据和设备上验证导出的模型。这取决于由谁解码输出。使用 Ultralytics iOS SDK 或 Flutter 插件时,请像官方模型一样,使用
nms=False导出 YOLO26 模型:随后,SDK 会读取无 NMS 检测头的最终检测结果,因此无需执行 NMS。在 COCO val2017 上,采用无 NMS 检测头的 YOLO26n 在 INT8 下达到 40.1 mAPval 50-95,而默认输出配合外部 NMS 时达到 40.8。在 iPhone 17 Pro 上,两种方式的每张图像处理时间都是 4 到 5 毫秒。使用 Apple 的 Vision 框架和你自己的代码时,nms=True会将检测模型转换为包含 Apple NMS 阶段的 Core ML 流水线,你可以为每次预测更改阈值。Vision 会将检测结果作为VNRecognizedObjectObservation对象返回,而边界框的分数就是观测结果的confidence。对于nms=True检测模型,SDK 8.9.23 及更早版本会返回约 1.0(即每个边界框中最高类别标签的置信度)来代替边界框分数;较新版本则会返回观测结果的confidence。默认的nms=None会返回原始预测结果,并将 NMS 留给你的代码处理。请参阅输出格式,了解各项设置对应的输出。你可以在没有 Mac 的情况下导出:导出可在 x86-64 Linux 上运行,Ultralytics Platform也支持在云端导出。运行模型则需要 Apple 硬件,因为 Core ML 是 Apple 操作系统的一部分。在 Linux 和 Windows 上,你可以验证 PyTorch 检查点或其 ONNX 导出,然后在能够运行
YOLO("yolo26n.mlpackage").val()的 Mac 上或设备上验证 Core ML 模型本身。
评论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! 😊
