Exporta modelos YOLO a LiteRT para implementarlos en dispositivos periféricos y en la web#

LiteRT (abreviatura de entorno de ejecución ligero) es el entorno de ejecución de alto rendimiento de Google para la IA en el dispositivo. Es la siguiente generación y el nuevo nombre de TensorFlow Lite (TFLite), y ejecuta el mismo formato de modelo .tflite. Con LiteRT, un único modelo Ultralytics YOLO exportado se implementa en móviles, sistemas integrados, dispositivos periféricos y navegadores: abarca todos los casos que antes gestionaban por separado los formatos de exportación tflite y tfjs, ahora bajo una misma solución.

Ver: Cómo exportar Ultralytics YOLO26 a Google LiteRT | Implementa IA para visión en Android e iOS | IA móvil 📱🚀

El formato de exportación LiteRT optimiza tus modelos para tareas como la detección de objetos, la segmentación, la estimación de pose y la clasificación, para que se ejecuten con rapidez y sin conexión en una amplia variedad de dispositivos.

npm i @ultralytics/yolo @litertjs/core

¿Por qué exportar a LiteRT?#

LiteRT es un marco de trabajo de código abierto diseñado para la inferencia en el dispositivo, también conocida como computación en el borde. Proporciona a los desarrolladores herramientas para ejecutar modelos entrenados en dispositivos móviles, sistemas integrados e IoT, ordenadores tradicionales y, mediante LiteRT.js, directamente en navegadores web y Node.js.

Un formato de modelo para todos los destinos:

• Móviles y sistemas integrados: Android, iOS, Linux integrado y microcontroladores (MCU).
• Aceleradores periféricos: Compatible con Coral Edge TPU para obtener más aceleración.
• Navegador y Node.js: LiteRT.js ejecuta en la web el mismo modelo .tflite con aceleración WebGPU/WASM, lo que evita tener que exportarlo por separado a TensorFlow.js.

Funciones clave de los modelos LiteRT#

• Optimización en el dispositivo: Reduce la latencia al procesar los datos localmente, mejora la privacidad al no transmitir datos personales y minimiza el tamaño del modelo para ahorrar espacio.
• Compatibilidad con varias plataformas: Funciona en Android, iOS, Linux integrado, microcontroladores y navegadores web modernos.
• Aceleración por hardware: Aprovecha XNNPACK en CPU y la aceleración de GPU mediante OpenCL, Metal y WebGPU. El delegado de GPU funciona en FP16 de forma predeterminada para ofrecer más velocidad.
• Cuantización: Admite FP32, INT8 estático (quantize=8, pesos int8 + activaciones int8), INT16 estático para las activaciones (quantize="w8a16", pesos int8 + activaciones int16 para una mayor precisión) e INT8 dinámico (quantize="w8a32", pesos int8 + activaciones FP32, sin necesidad de datos de calibración) para comprimir modelos y acelerar la inferencia con una pérdida mínima de precisión.
• Compatibilidad con diversos lenguajes: Compatible con Java/Kotlin, Swift, Objective-C, C++, Python y JavaScript.

Rendimiento medido#

Hardware: Xiaomi 17 con 12 GB de memoria LPDDR5X y Android 17 / API 37. Su Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) tiene una CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime de hasta 4,6 GHz y 6 núcleos de rendimiento de hasta 3,62 GHz), una GPU Adreno y una NPU Hexagon.

• 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 con el complemento Flutter de Ultralytics 0.7.1 y los recursos oficiales v0.7.0 (exportaciones de Ultralytics 8.4.188). El orden de CPU/GPU se alternó entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL).
• La exportación de LiteRT traza directamente el modelo PyTorch y genera un .tflite NCHW con una entrada de tipo float: el delegado de GPU compila todo el grafo (las siete tareas se ejecutan aquí en la GPU Adreno) y w8a32 no necesita datos de calibración. En lugar de dar por hecho que se usa el diseño NHWC heredado de onnx2tf o los nombres de salida Identity, quienes consuman el modelo deben consultar las formas de los tensores y los nombres de las firmas; deben empaquetar los datos RGB directamente como CHW planar o transponerlos antes de la inferencia. Las exportaciones semánticas devuelven logits NCHW y requieren un argmax de clases en el host. Los recursos oficiales para Android están alojados en la versión v0.7.0 de yolo-flutter-app; encontrarás el registro detallado de la evaluación comparativa en el documento de rendimiento de Flutter.
• La columna NPU corresponde a la ruta NPU propia de LiteRT: una exportación FP32 (yolo export format=litert, sin quantize) compilada en el dispositivo por los tiempos de ejecución litert-npu-runtime-qualcomm y -mediatek 2.3.0, medida con una compilación prototipo para NPU del complemento Flutter (aún no publicada). La primera carga incluye esa compilación (unos 0,3 s para n y hasta 6 s para x). Los recursos w8a32 no se compilan por completo en estas NPU. LiteRT indica que se ha compilado para NPU incluso cuando ejecuta el grafo silenciosamente en la GPU, por lo que se comprobó cada fila de NPU frente al tiempo de GPU; las filas que recurrieron a la GPU se muestran como —.
• Las cifras correspondientes de la NPU Hexagon de Snapdragon para los recursos oficiales QNN están en la integración de Qualcomm QNN.
• Compara los resultados de CPU/acelerador de Apple en la integración de CoreML.

Las siguientes pruebas en distintos dispositivos utilizan los mismos recursos oficiales v0.7.0.

Google Pixel 10#

Hardware: Google Pixel 10 con 12 GB de memoria y Android 17 / API 37. Su Google Tensor G5 de 3 nm tiene una CPU de 8 núcleos (1 núcleo Prime de hasta 3,78 GHz, 5 núcleos de rendimiento de hasta 3,05 GHz y 2 núcleos de eficiencia de hasta 2,25 GHz), una GPU PowerVR D-Series y una TPU de Google. Las frecuencias de los núcleos y el nombre del controlador de la GPU se consultaron en el dispositivo de pruebas, ya que Google no los publica en las especificaciones enlazadas.

Prueba de rendimiento: media de 15 llamadas predict() tras 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.7.1 y los recursos oficiales v0.7.0. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL). La TPU Tensor no tiene una fila de LiteRT: el servicio EdgeTPU de Google rechaza las aplicaciones que no están en su lista de permitidas, y LiteRT ejecuta entonces el modelo en la GPU.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) con 12 GB de memoria y Android 17 / API 37. Su Exynos 2600 de 2 nm tiene una CPU Armv9.3 de 10 núcleos (1 núcleo C1-Ultra de hasta 3,8 GHz, 3 núcleos C1-Pro de rendimiento de hasta 3,26 GHz y 6 núcleos C1-Pro de eficiencia de hasta 2,76 GHz), una GPU Xclipse 960 y una NPU de Samsung.

Prueba de rendimiento: media de 15 llamadas predict() tras 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.7.1 y los recursos oficiales v0.7.0. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL). La columna NPU utiliza los recursos w8a32 compilados de antemano para Exynos 2600 (E9965) con el complemento del compilador de Samsung para LiteRT. Samsung no tiene un compilador en el dispositivo en LiteRT 2.3 y Google aún no publica un entorno de ejecución para la NPU de Samsung, así que estas filas utilizaron una biblioteca de envío creada a partir del código fuente de LiteRT 2.3.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) con 12 GB de memoria LPDDR5X y Android 16 / API 36. Su MediaTek Dimensity 9500 de 3 nm (MT6993) tiene una CPU Armv9.3 de 8 núcleos (1 núcleo C1-Ultra de hasta 4,21 GHz, 3 núcleos C1-Premium de hasta 3,5 GHz y 4 núcleos C1-Pro de hasta 2,7 GHz), GPU Mali-G1 Ultra MC12 y NPU MediaTek 990.

Evaluación comparativa: media de 15 llamadas a predict() tras 3 ejecuciones de calentamiento en bus.jpg, usando ultralytics_yolo 0.7.1 y los recursos oficiales de v0.7.0. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL). Depth y OBB no tienen resultados de NPU: el compilador de NPU de MediaTek rechaza sus operaciones exponenciales y trigonométricas, y LiteRT ejecuta esos grafos en la GPU.

Tareas compatibles#

La exportación a LiteRT 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 esos cabezales.

Exportar a LiteRT: convierte tu modelo YOLO#

Puedes mejorar la eficiencia de ejecución en el dispositivo y ampliar las opciones de implementación convirtiendo tus modelos al formato LiteRT.

Instalación#

Para instalar el paquete necesario, ejecuta:

# Install the required package for YOLO
pip install ultralytics

Para obtener instrucciones detalladas y conocer las prácticas recomendadas, consulta nuestra guía de instalación de Ultralytics. Si tienes algún problema, consulta nuestra guía de problemas frecuentes.

Uso#

Todos los modelos YOLO de Ultralytics admiten la exportación de forma predeterminada. El formato LiteRT admite los modos Exportar, Predecir y Validar, así que puedes exportar un modelo y, después, cargarlo para ejecutar inferencias o validar su precisión localmente.

from ultralytics import YOLO

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

# Exporta el modelo al formato LiteRT
model.export(format="litert", imgsz=640)  # crea 'yolo26n.tflite'; usa imgsz=224 para la clasificación

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# INT8 dinámico: pesos int8, activaciones FP32; no se necesitan datos de calibración
model.export(format="litert", quantize="w8a32", imgsz=640)  # crea 'yolo26n_w8a32.tflite'

# INT8 estático: pesos int8 + activaciones int8; necesita datos de calibración
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # crea 'yolo26n_int8.tflite'

# w8a16 estático: pesos int8 + activaciones int16 (mayor precisión); necesita datos de calibración
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # crea 'yolo26n_w8a16.tflite'

from ultralytics import YOLO

# Carga el modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

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

from ultralytics import YOLO

# Carga el modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

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

Inferencia en CPU y NPU de Intel#

Los modelos .tflite exportados se ejecutan en hardware Intel mediante el complemento LiteRT Intel OpenVINO. Pasa device=intel:cpu o device=intel:npu, y Ultralytics instalará ai-edge-litert>=2.3.0 y ai-edge-litert-sdk-intel la primera vez que los uses. La NPU necesita un procesador Intel Core Ultra con el controlador de NPU de Intel instalado.

from ultralytics import YOLO

model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="intel:npu")  # o "intel:cpu"

Hardware: Intel Core Ultra X7 358H (Panther Lake) e Intel AI Boost NPU 5010, Fedora Linux, controlador de NPU 1.38.0, ai-edge-litert 2.3.0.

Prueba de rendimiento: Media de 15 llamadas a predict() tras 3 calentamientos en bus.jpg, con ultralytics 8.4.174 y ai-edge-litert 2.3.0 mediante exportaciones de w8a32. Cada celda muestra el tiempo total y, debajo, el desglose entre preprocesamiento, inferencia y posprocesamiento.

Implementación de modelos YOLO LiteRT exportados#

Después de exportar tu modelo Ultralytics YOLO a LiteRT, puedes implementarlo en distintas plataformas. La forma más rápida de comprobarlo localmente es el método YOLO("yolo26n.tflite") mostrado arriba. Para implementarlo en otros entornos, consulta los siguientes recursos:

Móviles e integrados#

• Android: Guía de inicio rápido para integrar LiteRT en aplicaciones de Android.
• iOS: Guía para integrar y desplegar modelos LiteRT en aplicaciones de iOS.
• Linux integrado y Raspberry Pi: Ejecuta modelos LiteRT en ordenadores de placa única, con aceleración opcional mediante una Coral Edge TPU.
• Microcontroladores: Despliega en MCU con solo unos pocos kilobytes de memoria: el entorno de ejecución principal ocupa aproximadamente 16 KB en un Arm Cortex-M3.

Navegador y Node.js (LiteRT.js)#

• Descripción general de LiteRT.js: Ejecuta el mismo modelo .tflite directamente en el navegador con aceleración WebGPU/WASM, eliminando los cálculos en el servidor y manteniendo los datos en el dispositivo del usuario.
• Ejemplos integrales: Ejemplos prácticos y tutoriales para implementar LiteRT en dispositivos móviles, periféricos y la web.

Resumen#

En esta guía hemos explicado cómo exportar modelos Ultralytics YOLO al formato LiteRT. Al unificar el despliegue en móviles/periféricos (antes TFLite) y en navegadores (antes TF.js) en un único modelo .tflite, LiteRT hace que tus modelos YOLO sean más rápidos, compactos y portátiles en prácticamente cualquier dispositivo.

Para obtener más información, visita la documentación oficial de LiteRT.

Además, si te interesan otras integraciones de Ultralytics YOLO, consulta nuestra página de guías de integración, donde encontrarás muchos recursos útiles.

Preguntas frecuentes#