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.

¿Qué es CoreML?#

CoreML (que Apple escribe «Core ML») es el framework de aprendizaje automático integrado en los dispositivos de Apple. Carga modelos en el moderno formato 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, el NPU dedicado presente en todos los chips 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 la salida: las exportaciones predeterminadas dejan el NMS a cargo de tu aplicación. Usa nms=True para incorporar NMS o nms=False para la cabeza sin NMS de YOLO26.
• 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 integral de una sola imagen para los recursos estandarizados v8.3.0 de YOLO26n INT8 CoreML en un iPhone 17 Pro con 12 GB de memoria e iOS 26.5.2. Su A19 Pro tiene una CPU de 6 núcleos (2 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) 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 aparece 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 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 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 de Android en la integración de LiteRT y los resultados del NPU 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.

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 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.

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

from ultralytics import YOLO

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

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

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#

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 Mac anfitrión (a través de Ultralytics o de coremltools) sigue la misma regla: Ultralytics carga con ComputeUnit.CPU_AND_NE (macOS 13 o posterior, con fallback a CPU_ONLY en versiones anteriores de macOS), de modo que la inferencia se ejecuta en el Neural Engine (unas ~3 veces más rápido que en la CPU). Esto también evita una limitación actual de macOS en equipos anfitriones por la que las opciones predeterminadas ComputeUnit.ALL / CPU_AND_GPU —que añaden la ruta de compilación de GPU/MPSGraph— interrumpen el proceso con una aserción Error: MLIR pass manager failed en coremltools 9.x.

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:

• Integrar un modelo Core ML en tu aplicación: guía de Apple para incluir y ejecutar un modelo CoreML.
• CoreML Tools: referencia de conversión, cuantización y optimización para la cadena de herramientas coremltools que permite esta exportación.
• Informes de rendimiento de Core ML de Xcode: perfil de ubicación de cada capa en el dispositivo y de 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 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é.

Flujo de trabajo recomendado#

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 Ultralytics YOLO26 al formato .mlpackage de CoreML, cuantizarlos para el Apple Neural Engine e implementarlos con latencias de un solo dígito en milisegundos, ya sea mediante el SDK oficial de iOS y el plugin de Flutter o con tu propia integración de Vision. Para otros destinos de implementación, consulta la página de la guía de integraciones y compara formatos con el modo Benchmark.

Preguntas frecuentes#