Empezar

Exportación de CoreML para modelos YOLO26

Apple incluye silicio de IA específico —Neural Engine— en todos los iPhone, iPad y Mac modernos, y CoreML es actualmente la ruta compatible de Ultralytics para desplegar modelos en él. Exportar modelos Ultralytics YOLO26 a CoreML convierte un punto de control .pt entrenado en un .mlpackage nativo que ejecuta las siete tareas de YOLO en el dispositivo con baja latencia, sin conexión de red y sin que los datos salgan del dispositivo.

Ejecuta YOLO hoy en Apple Neural Engine con las aplicaciones móviles oficiales

El SDK oficial de Ultralytics YOLO para iOS y el complemento de Flutter ejecutan las exportaciones de CoreML en Apple Neural Engine desde el primer momento: inferencia en tiempo real con la cámara, predicción de imágenes individuales y descarga automática de modelos para las siete tareas de YOLO26, incluida la profundidad. Para el despliegue en NPU de Android, consulta la integración de Qualcomm QNN.

Tamaños de entrada oficiales para móviles

Exporta modelos de clasificación en imgsz=224. Exporta modelos de detección, segmentación, segmentación semántica, profundidad, pose y OBB en imgsz=640. Este estándar 224/640 es común a los recursos móviles oficiales de CoreML, LiteRT y QNN.

El nuevo formato Core AI de Apple

Apple ha presentado el nuevo framework Core AI y el formato .aimodel para la generación de iOS 27 y macOS 27, y Ultralytics lo exporta con format="coreai". CoreML sigue siendo el formato predeterminado para los SDK de iOS y Flutter de Ultralytics, que cargan Core AI como opción en los dispositivos con iOS 27, y el formato para una mayor compatibilidad con dispositivos Apple.



Ver: Cómo exportar Ultralytics YOLO26 a CoreML con cuantización INT8 | Implementación en Apple | iOS/MacOS 🍎

¿Qué es CoreML?#

Apple CoreML deployment pipeline

CoreML (que Apple denomina «Core ML») es el framework de aprendizaje automático de Apple para dispositivos. Carga modelos en el formato moderno ML Program —el paquete .mlpackage que genera el exportador de Ultralytics— y los distribuye entre la CPU, la GPU y Apple Neural Engine (ANE) del dispositivo, la NPU dedicada de cada chip de Apple silicon. Como todo se ejecuta localmente, la inferencia funciona sin conexión, no añade latencia de red y mantiene los datos del usuario en el dispositivo.

CoreML se integra directamente con Vision framework de Apple, que se encarga del escalado y la orientación de la imagen antes de introducirla en el modelo; así es como el SDK de iOS de Ultralytics envía fotogramas de la cámara a YOLO prácticamente sin coste de preprocesamiento.

¿Por qué exportar YOLO26 a CoreML?#

  • Velocidad del Neural Engine: CoreML distribuye las operaciones compatibles en el Neural Engine de Apple para lograr una inferencia en el dispositivo con baja latencia. Consulta la tabla de dispositivos físicos que aparece a continuación y compara tu exportación exacta en el hardware de destino.
  • Elige el formato de salida: Las exportaciones predeterminadas dejan la NMS a cargo de tu aplicación. Usa nms=True para integrar NMS, o nms=False para usar el cabezal de YOLO26 sin NMS.
  • Privado y sin conexión: Todo el procesamiento se realiza en el dispositivo: sin viajes de ida y vuelta a la nube, sin claves de API y con total privacidad de los datos.
  • Una exportación para todo el ecosistema: el mismo .mlpackage funciona en iOS, iPadOS, macOS, watchOS, tvOS y visionOS, y es la base del SDK de iOS y el plugin de Flutter oficiales de Ultralytics.

Rendimiento medido#

Inferencia de extremo a extremo de una sola imagen con los recursos CoreML INT8 YOLO26n estandarizados v8.3.0 en un iPhone 17 Pro con 12 GB de memoria e iOS 27.0.1. Su A19 Pro cuenta con una CPU de 6 núcleos (2 de rendimiento y 4 de eficiencia), una GPU de 6 núcleos con aceleradores neuronales y un motor neuronal de 16 núcleos. Cada celda muestra el tiempo total (preprocesamiento + inferencia + posprocesamiento, sin incluir la anotación) y, debajo, el desglose por etapa. En iOS, Vision realiza el escalado de entrada dentro de la solicitud de inferencia, por lo que el preprocesamiento se indica como 0 y su coste se incluye en la inferencia.

ModeloTareatamaño
(píxeles)
CPU
Core ML .cpuOnly
(ms)
CPU + ANE preferido
Core ML .cpuAndNeuralEngine
(ms)
YOLO26nDetección6408.8
0.0 / 8.8 / 0.0
3.7
0.0 / 3.7 / 0.0
YOLO26n-segSegmentación64012.3
0.0 / 11.7 / 0.6
4.9
0.0 / 4.3 / 0.6
YOLO26n-semSemántica6409.3
0.0 / 9.0 / 0.3
4.4
0.0 / 4.1 / 0.3
YOLO26n-depthProfundidad64026.0
0.0 / 25.1 / 1.0
5.5
0.0 / 4.7 / 0.9
YOLO26n-clsClasificar2244.1
0.0 / 4.1 / 0.0
2.0
0.0 / 1.9 / 0.0
YOLO26n-posePose64012.0
0.0 / 12.0 / 0.0
4.0
0.0 / 4.0 / 0.0
YOLO26n-obbOBB64010.7
0.0 / 10.7 / 0.0
3.9
0.0 / 3.9 / 0.0
  • Los recursos exactos de la versión v8.3.0 declaran entradas de 224×224 para clasificación y de 640×640 para todas las demás tareas.
  • En iOS 27.0.1, la inferencia .cpuOnly de los modelos de profundidad, pose y OBB l y x se bloquea dentro de los núcleos de CPU de Core ML (EXC_BAD_ACCESS en libBNNS); los mismos modelos se ejecutan con .cpuAndNeuralEngine, y todas las demás tareas y tamaños se ejecutan en la CPU.
  • Los valores de velocidad son latencias de ráfaga para una sola imagen: la media de 15 ejecuciones tras 3 ejecuciones de calentamiento en bus.jpg, medidas mediante la temporización por etapas del SDK de iOS a través del entorno de pruebas del plugin de Flutter en modo de perfil (código nativo optimizado). El orden de CPU/acelerador se alternó entre tareas en una única secuencia de medición. Las filas de CPU solicitan Core ML .cpuOnly; las filas de CPU + ANE preferido solicitan .cpuAndNeuralEngine, y Core ML determina la ubicación final de las operaciones. El funcionamiento sostenido de la cámara en tiempo real es más lento porque incluye el proceso de captura y escalado, además de la estabilización térmica. Una medición histórica de cámara, anterior a la estandarización, registró 11,3 ms/fotograma para la detección con YOLO26n y 16,5 ms/fotograma para Depth con YOLO26n en el mismo dispositivo; consulta el documento de rendimiento del SDK de iOS para ver el perfil en estado estable.
  • Compara los resultados de CPU/GPU en Android en la integración de LiteRT, los resultados de MediaTek Dimensity y los resultados de NPU de Snapdragon en la integración de Qualcomm QNN.

Tareas compatibles#

La exportación a CoreML admite las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esas cabezas.

TareaYOLOv8YOLO11YOLO26
Detectar✅✅✅
Segmentar✅✅✅
Semántica❌❌✅
Profundidad❌❌✅
Clasificar✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportar modelos YOLO26 a CoreML#

Instalación#

Para instalar el paquete necesario, ejecuta:

Instalación
# Install the required package for YOLO26
pip install ultralytics

El convertidor coremltools se instala automáticamente en la primera exportación. La exportación se ejecuta en macOS o Linux x86; para ver instrucciones detalladas y prácticas recomendadas, consulta nuestra guía de instalación y la guía de problemas comunes.

Uso#

El formato CoreML admite los modos Export, Predict y Validate. La inferencia y la validación con CoreML solo se ejecutan en macOS. Exporta tu modelo y, después, carga el modelo exportado para ejecutar inferencias o validar su precisión.

Exportar
from ultralytics import YOLO

# Carga un modelo YOLO26
model = YOLO("yolo26n.pt")

# Exportar a CoreML con cuantización de pesos INT8, como en los modelos oficiales de la aplicación
model.export(format="coreml", quantize=8, imgsz=640)  # usa imgsz=224 para clasificación
Predecir
from ultralytics import YOLO

# Cargar el modelo CoreML exportado (macOS)
model = YOLO("yolo26n.mlpackage")

# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")
Validar
from ultralytics import YOLO

# Cargar el modelo CoreML exportado (macOS)
model = YOLO("yolo26n.mlpackage")

# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'coreml'Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación.
imgszint o tuple640Tamaño de imagen deseado para la entrada del modelo. Puede ser un número entero para imágenes cuadradas o una tupla (height, width) para dimensiones específicas.
quantizeint o strNonePrecisión de cuantización: 16 (FP16), 8 o "w8a16" (idénticos: pesos cuantizados de 8 bits mediante k-means, con cálculo FP16), o 32 o sin valor (FP32). Los programas ML de NMS usan FP16 (para la vista previa de Xcode y porque es necesario para segmentación y pose); pasa 32 para anularlo en detección. Sustituye las opciones obsoletas half/int8.
nmsbool, opcionalNoneSelecciona la salida sin procesar (None, predeterminada), NMS integrado (True) o la cabeza sin NMS (False). El NMS integrado admite detección, segmentación y pose con dynamic=False.
dynamicboolFalsePermite tamaños de entrada dinámicos. No es compatible con modelos de clasificación o RT-DETR y no se puede combinar con nms=True.
batchint1Especifica el tamaño del lote de inferencia del modelo exportado o el número máximo de imágenes que procesará simultáneamente en el modo predict. Los valores superiores a 1 requieren dynamic=True.
devicestrNoneEspecifica el dispositivo para la exportación: GPU (device=0), CPU (device=cpu), MPS para Apple silicon (device=mps).

Para obtener más información sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.

Uso del Neural Engine#

CoreML elige el hardware mediante MLModelConfiguration.computeUnits. El SDK de iOS de Ultralytics usa .cpuAndNeuralEngine de forma predeterminada en iOS 16 y versiones posteriores, en lugar de .all: en una aplicación de cámara en tiempo real, la GPU ya está ocupada componiendo la vista previa y las superposiciones, por lo que excluirla evita la contención y las fluctuaciones en el tiempo por fotograma mientras el ANE se encarga del trabajo pesado. Fija .cpuOnly solo para pruebas de compatibilidad; la tabla anterior muestra el coste.

Ejecutar un modelo CoreML desde Python en un host Mac (con Ultralytics o coremltools) sigue la misma regla: Ultralytics lo carga con ComputeUnit.CPU_AND_NE (macOS 13 o posterior; en versiones anteriores de macOS, recurre a CPU_ONLY), manteniendo la inferencia en el Neural Engine (~3× más rápido que la CPU). Esto también evita una limitación actual del host macOS por la que los valores predeterminados ComputeUnit.ALL / CPU_AND_GPU —que añaden la ruta de compilación GPU/MPSGraph— interrumpen el proceso con una aserción Error: MLIR pass manager failed en coremltools 9.x. Los modelos RT-DETR son la excepción: se cargan con ComputeUnit.ALL, porque la precisión FP16 disminuye si se usa únicamente Neural Engine.

Implementar modelos YOLO26 CoreML exportados#

La forma más rápida es usar el SDK oficial de Ultralytics YOLO para iOS, el mismo paquete de Swift que impulsa la aplicación de iOS de Ultralytics y el plugin de Flutter. Resuelve automáticamente los nombres de los modelos oficiales, descarga y guarda en caché .mlpackage y devuelve resultados totalmente decodificados:

import UltralyticsYOLO

// Loads the official INT8 model (downloaded and cached on first use), then runs inference
let yolo = YOLO("yolo26n", task: .detect) { result in
    if case .success(let model) = result {
        let results = model(uiImage)  // boxes, labels, confidences, timing
    }
}

Para aplicaciones de cámara, añade el YOLOView del SDK para realizar inferencias en tiempo real con superposiciones nativas, o usa el plugin de Flutter para aplicaciones multiplataforma que compartan una misma base de código con Android.

También es sencillo integrar por tu cuenta un .mlpackage sin procesar con las herramientas de Apple: cárgalo con MLModel, envuélvelo en un VNCoreMLRequest y envía las imágenes a través de VNImageRequestHandler. Estos recursos explican los detalles:

Incluye el modelo en el paquete de la aplicación (disponibilidad inmediata, ideal para modelos nano/pequeños) o descárgalo la primera vez que se ejecute la aplicación y guárdalo en caché (binario más pequeño y actualizaciones de modelos sencillas). Las aplicaciones oficiales combinan ambos métodos: los modelos nano predeterminados se incluyen para usarlos de inmediato, mientras que las variantes más grandes se descargan cuando se necesitan y se guardan localmente en caché.

  1. Entrena tu modelo con el modo Train de Ultralytics o empieza con los pesos oficiales de YOLO26.
  2. Exporta con model.export(format="coreml", quantize=8, imgsz=640) en macOS o Linux x86 (imgsz=224 para clasificación)
  3. Verifica la precisión con model.val() en un Mac y crea un perfil con un informe de rendimiento de Core ML de Xcode en el dispositivo de destino
  4. Implementa con el SDK de iOS, el plugin de Flutter o tu propia integración de Vision, con el objetivo .cpuAndNeuralEngine

Resumen#

En esta guía has aprendido a exportar modelos de Ultralytics YOLO26 al formato .mlpackage de CoreML, cuantizarlos para Apple Neural Engine e implementarlos con latencias de pocos milisegundos, ya sea mediante el SDK oficial para iOS y el complemento de Flutter o con tu propia integración de Vision.

Preguntas frecuentes#

  • Ejecuta model.export(format="coreml", imgsz=640) en Python o yolo export model=yolo26n.pt format=coreml imgsz=640 desde la CLI en macOS o Linux x86. Usa imgsz=224 para clasificación y añade quantize=8 para reproducir los modelos oficiales de la aplicación. La exportación genera un ML Program yolo26n.mlpackage listo para Xcode, el SDK de iOS o el plugin de Flutter.

  • Usa nms=True si tu aplicación necesita detecciones con NMS integrado. La opción predeterminada nms=None exporta las salidas sin procesar de uno a muchos para que las procese tu aplicación; nms=False selecciona la cabeza de YOLO26 sin NMS. El NMS integrado admite detección, segmentación y pose con formas estáticas; las demás tareas mantienen sus salidas nativas.

  • Los modelos oficiales de la aplicación de Ultralytics se distribuyen en INT8, lo que minimiza el tamaño de descarga y ofrece las velocidades indicadas en la tabla anterior. quantize=16 (FP16) es una alternativa conservadora que prácticamente no reduce la precisión. Valida tu exportación concreta con model.val() en un Mac antes de publicarla.

  • Configura MLModelConfiguration.computeUnits = .cpuAndNeuralEngine (la opción predeterminada del SDK de iOS en iOS 16 y versiones posteriores). Evita .all en aplicaciones de cámara: la GPU está ocupada componiendo la vista previa y programar la inferencia allí provoca fluctuaciones en el tiempo por fotograma. Confirma la ubicación con un informe de rendimiento de Core ML de Xcode.

  • Sí, en macOS: yolo predict model=yolo26n.mlpackage source=image.jpg y yolo val model=yolo26n.mlpackage data=coco8.yaml funcionan como con cualquier otro formato. La ejecución de CoreML requiere hardware Apple, por lo que estos modos no están disponibles en Linux ni Windows.

  • Usa el SDK oficial de Ultralytics YOLO para iOS (paquete Swift) o el plugin de Flutter. Ambos cargan los modelos oficiales por nombre con descarga y almacenamiento en caché automáticos, los ejecutan en el Neural Engine e incluyen interfaces completas de cámara en tiempo real; la tabla de rendimiento medida anterior se obtuvo precisamente con esta tecnología.

Comentarios13

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  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(editado)

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