Exportación de CoreML para modelos YOLO26#

Apple incluye silicio dedicado para IA —el Neural Engine— en todos los iPhone, iPad y Mac modernos, y CoreML es actualmente la vía compatible de Ultralytics para desplegar modelos en él. Exportar modelos de Ultralytics YOLO26 a CoreML convierte un checkpoint entrenado .pt 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 ningún dato salga del dispositivo.

¿Qué es CoreML?#

CoreML (Apple lo presenta como «Core ML») es el framework de aprendizaje automático en el dispositivo de Apple. 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 el Apple Neural Engine (ANE) del dispositivo, la NPU dedicada de todos los chips de Apple. 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 el framework Vision de Apple, que gestiona el escalado y la orientación de la imagen al introducirla en el modelo; así es como el SDK de Ultralytics para iOS proporciona fotogramas de la cámara a YOLO con un coste de preprocesamiento prácticamente nulo.

¿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 la salida: Las exportaciones predeterminadas dejan NMS a tu aplicación. Usa nms=True para integrar NMS, o nms=False para la cabeza sin NMS de YOLO26.
• Privado y sin conexión: Todo el procesamiento permanece en el dispositivo —sin comunicaciones de ida y vuelta con la nube, sin claves de API y con privacidad de los datos total.
• 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 para iOS oficial de Ultralytics y del plugin de Flutter.

Rendimiento medido#

Inferencia de extremo a extremo de una sola imagen para los recursos estandarizados de CoreML v8.3.0 YOLO26n INT8 en un iPhone 17 Pro con 12 GB de memoria y iOS 26.5.2. Su A19 Pro tiene una CPU de 6 núcleos (2 núcleos de rendimiento y 4 de eficiencia), una GPU de 6 núcleos con aceleradores neuronales y un Neural Engine de 16 núcleos. Cada celda muestra el tiempo total (preprocesamiento + inferencia + posprocesamiento, sin incluir la anotación), con el desglose por etapa debajo. 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.

• Los recursos exactos de la versión v8.3.0 declaran entradas de 224×224 para la clasificación y de 640×640 para todas las demás tareas.
• Los valores de velocidad son latencias de ráfaga para una sola imagen: la media de 15 ejecuciones después de 3 ejecuciones de calentamiento en bus.jpg, medidas mediante la temporización por etapas del SDK de iOS a través del sistema de pruebas del plugin de Flutter en modo de perfil (código nativo optimizado). El orden de CPU/acelerador se alternó entre tareas en un único recorrido secuencial. Las filas de CPU solicitan Core ML .cpuOnly; las filas de CPU + ANE preferido solicitan .cpuAndNeuralEngine, y Core ML controla la asignación final de las operaciones. El funcionamiento sostenido de la cámara en tiempo real alcanza valores superiores porque incluye la canalización de captura y escalado, además de la estabilización térmica. En una prueba histórica de cámara anterior a la estandarización se midieron 11.3 ms/fotograma para la detección con YOLO26n y 16.5 ms/fotograma para Depth con YOLO26n en el mismo dispositivo; consulta la documentación de rendimiento del SDK de iOS para el perfilado en régimen estable.
• Compara los resultados de CPU/GPU de Android en la integración de LiteRT y los resultados de la NPU de Snapdragon en la integración de Qualcomm QNN.

Tareas compatibles#

La exportación de 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.

Exportar modelos YOLO26 a CoreML#

Instalación#

Para instalar el paquete necesario, ejecuta:

# Install the required package for YOLO26
pip install ultralytics

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

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.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export to CoreML with INT8 weight quantization, matching the official app models
model.export(format="coreml", quantize=8, imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported CoreML model (macOS)
model = YOLO("yolo26n.mlpackage")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de exportación#

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

Orientación al Neural Engine#

CoreML selecciona el hardware mediante MLModelConfiguration.computeUnits. El SDK de Ultralytics para iOS utiliza .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 competencia por recursos y las variaciones del tiempo por fotograma mientras el ANE realiza la mayor parte del trabajo. Fija .cpuOnly solo para pruebas de compatibilidad; la tabla anterior muestra el coste.

Ejecutar un modelo de CoreML desde Python en un Mac anfitrión (mediante Ultralytics o coremltools) sigue la misma regla: Ultralytics carga con ComputeUnit.CPU_AND_NE (macOS 13 o posterior, y recurre a CPU_ONLY en versiones anteriores de macOS), manteniendo la inferencia en el Neural Engine (aproximadamente 3 veces más rápida que en la CPU). Esto también evita una limitación actual del anfitrión 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.

Desplegar modelos YOLO26 de CoreML exportados#

La vía más rápida es el SDK oficial de Ultralytics YOLO para iOS, el mismo paquete Swift que impulsa la aplicación de Ultralytics para iOS y el plugin de Flutter. Resuelve automáticamente los nombres oficiales de los modelos, descarga y almacena en caché el .mlpackage, y devuelve resultados completamente 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 obtener inferencia en tiempo real con superposiciones nativas, o utiliza el plugin de Flutter para aplicaciones multiplataforma que compartan una base de código con Android.

También es sencillo integrar directamente un .mlpackage sin procesar con la pila de Apple: cárgalo con MLModel, envuélvelo en un VNCoreMLRequest y proporciona las imágenes mediante VNImageRequestHandler. Estos recursos explican los detalles:

• Integrar un modelo de Core ML en tu aplicación: guía de Apple para empaquetar y utilizar un modelo de CoreML.
• CoreML Tools: referencia de conversión, cuantización y optimización para la cadena de herramientas coremltools que impulsa esta exportación.
• Informes de rendimiento de Core ML de Xcode: perfilado de la asignación de cada capa al dispositivo y de la latencia para tu modelo y dispositivo concretos.

Incluye el modelo en el paquete de la aplicación (disponibilidad inmediata, ideal para modelos nano/pequeños) o descárgalo durante la primera ejecución y guárdalo en caché (binario más pequeño y actualizaciones sencillas del modelo). Las aplicaciones oficiales combinan ambos enfoques: los modelos nano predeterminados se incluyen para poder utilizarlos de inmediato, mientras que las variantes más grandes se descargan bajo demanda y se almacenan localmente en caché.

Flujo de trabajo recomendado#

1. Entrena tu modelo con el modo Train de Ultralytics o parte de 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 tu dispositivo de destino
4. Despliega con el SDK para iOS, el plugin de Flutter o tu propia integración con Vision, orientada a .cpuAndNeuralEngine

Resumen#

En esta guía has aprendido a exportar modelos Ultralytics YOLO26 al formato .mlpackage de CoreML, cuantificarlos para el Apple Neural Engine y desplegarlos con latencias de un solo dígito en milisegundos, ya sea mediante el SDK oficial para iOS y el plugin de Flutter o mediante tu propia integración con Vision. Para conocer otros destinos de despliegue, consulta la página de la guía de integraciones y compara formatos con el modo Benchmark.

Preguntas frecuentes#