Exportación a CoreML para modelos YOLO26#

Apple incluye silicio dedicado para IA (el Neural Engine) en cada iPhone, iPad y Mac modernos, y CoreML es la vía recomendada por Ultralytics para desplegar modelos en él hoy en día. Exportar modelos de Ultralytics YOLO26 a CoreML convierte un archivo de puntos de control entrenado de .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 los datos salgan del dispositivo.

¿Qué es CoreML?#

CoreML (denominado "Core ML" por Apple) es el marco de aprendizaje automático en el dispositivo de Apple. Carga modelos en el formato moderno ML Program (el paquete .mlpackage que produce el exportador de Ultralytics) y los programa en la CPU, la GPU y el Apple Neural Engine (ANE) del dispositivo, la NPU dedicada en cada chip con silicio 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 marco Vision de Apple, que gestiona el escalado y la orientación de la imagen en su camino hacia el modelo; así es como el SDK de iOS de Ultralytics alimenta los 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 planifica las operaciones compatibles en el Neural Engine de Apple para la inferencia en el dispositivo de baja latencia. Consulta la tabla de dispositivos físicos a continuación y evalúa tu exportación exacta en tu hardware de destino.
• Sin NMS por diseño: YOLO26 es de extremo a extremo, por lo que el grafo exportado no necesita ninguna tubería de NMS y la decodificación toma menos de un milisegundo. Los modelos de detección más antiguos, como YOLO11, pueden integrar una tubería de NMS de CoreML con nms=True.
• Privado y sin conexión: Todo el cálculo permanece en el dispositivo; sin idas y vueltas a la nube, sin claves de API y con total privacidad de los datos.
• Una exportación, todo el ecosistema: El mismo .mlpackage se ejecuta en iOS, iPadOS, macOS, watchOS, tvOS y visionOS, y alimenta el SDK de iOS y el complemento de Flutter oficiales de Ultralytics.

Rendimiento medido#

Inferencia de extremo a extremo para una sola imagen para los recursos CoreML INT8 de YOLO26n estandarizados v8.3.0 en un iPhone 17 Pro con 12 GB de memoria e iOS 26.5.2. 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 Neural Engine de 16 núcleos. Cada celda muestra el tiempo total (preprocesamiento + inferencia + postprocesamiento, excluyendo 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 registra como 0 y su coste se incluye en la inferencia.

• Los recursos de lanzamiento exactos de v8.3.0 declaran entradas de 224×224 para clasificación y de 640×640 para cualquier otra tarea.
• 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 a través de la temporización por etapa del SDK de iOS mediante el banco de pruebas del complemento de Flutter en modo de perfil (código nativo optimizado). El orden de CPU/acelerador alternó entre tareas en un barrido secuencial. Las filas de CPU solicitan Core ML .cpuOnly; las filas de CPU + ANE preferido solicitan .cpuAndNeuralEngine, y la ubicación final de la operación la controla Core ML. La operación continua de la cámara en tiempo real se ejecuta a un nivel superior porque incluye la captura y la tubería de escalado más el asentamiento térmico. Un barrido de cámara preestándar histórico midió 11,3 ms/fotograma para la detección de YOLO26n y 16,5 ms/fotograma para la profundidad de YOLO26n en el mismo dispositivo; consulta el documento de rendimiento del SDK de iOS para ver la perfilación en estado estacionario.
• Compara los resultados de CPU/GPU en Android en la integración con LiteRT y los resultados de la NPU Snapdragon en la integración con Qualcomm QNN.

Tareas compatibles#

La exportación a CoreML es compatible con 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 conversor de coremltools se instala automáticamente en la primera exportación. La exportación se ejecuta en macOS o Linux x86; para obtener instrucciones detalladas y mejores prácticas, consulta nuestra guía de instalación y la guía de problemas comunes.

Uso#

El formato CoreML es compatible con los modos Export, Predict y Validate. La inferencia y la validación con CoreML se ejecutan únicamente en macOS. Exporta tu modelo y luego cárgalo para ejecutar la inferencia 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 más detalles sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.

Dirigido al Neural Engine#

CoreML selecciona el hardware mediante MLModelConfiguration.computeUnits. El SDK de iOS de Ultralytics utiliza de forma predeterminada .cpuAndNeuralEngine en iOS 16+ 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 conflictos y fluctuaciones en el tiempo de los fotogramas mientras el ANE realiza el trabajo pesado. Fija .cpuOnly únicamente para pruebas de compatibilidad; la tabla anterior muestra lo que cuesta.

Ejecutar un modelo CoreML desde Python en un Mac host (a través de Ultralytics o coremltools) sigue la misma regla: Ultralytics se carga con ComputeUnit.CPU_AND_NE (macOS 13+, recurriendo a CPU_ONLY en macOS más antiguos), manteniendo la inferencia en el Neural Engine (~3 veces más rápido que la CPU). Esto también evita una limitación actual del host macOS donde el ComputeUnit.ALL / CPU_AND_GPU predeterminado —que añade la ruta de compilación de GPU/MPSGraph— aborta el proceso con una aserción de Error: MLIR pass manager failed en coremltools 9.x.

Desplegar modelos CoreML de YOLO26 exportados#

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

Integrar un .mlpackage en bruto por ti mismo también es sencillo con la pila de Apple: cárgalo con MLModel, envuélvelo en un VNCoreMLRequest y alimenta las imágenes a través de VNImageRequestHandler. Estos recursos cubren los detalles:

• Integrating a Core ML Model into Your App: La guía de Apple para empaquetar y llamar a un modelo CoreML.
• CoreML Tools: Referencia de conversión, cuantización y optimización para la cadena de herramientas coremltools que impulsa esta exportación.
• Xcode Core ML Performance Reports: Ubicación del dispositivo por capa y perfilado de latencia para tu modelo y dispositivo exactos.

Distribuye el modelo ya sea integrado en el paquete de la aplicación (disponibilidad instantánea, ideal para modelos nano/small) o descargado en la primera ejecución y almacenado en caché (binario más pequeño, actualizaciones de modelos sencillas). Las aplicaciones oficiales combinan ambos enfoques: los modelos nano predeterminados se empaquetan para un uso inmediato, mientras que las variantes más grandes se descargan bajo demanda y se almacenan en caché localmente.

Flujo de trabajo recomendado#

1. Entrena tu modelo con el modo Train de Ultralytics, o comienza a partir 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 perfila con un informe de rendimiento de Xcode Core ML en tu dispositivo de destino
4. Despliega con el SDK de iOS, el complemento de Flutter o tu propia integración de Vision, apuntando a .cpuAndNeuralEngine

Resumen#

En esta guía, has aprendido a exportar modelos de Ultralytics YOLO26 al formato .mlpackage de CoreML, cuantizarlos para el Apple Neural Engine y desplegarlos con latencias de un solo dígito en milisegundos, ya sea a través del SDK de iOS y el complemento de Flutter oficiales o de tu propia integración de Vision. Para otros destinos de despliegue, explora la página de la guía de integración y compara formatos con el modo Benchmark.

FAQ#