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.

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 16 / API 36. Su Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) cuenta con una CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime de hasta 4,6 GHz y 6 núcleos Performance de hasta 3,62 GHz), GPU Adreno y NPU Hexagon.

• 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 con el complemento de Flutter de Ultralytics 0.6.10 y los recursos estandarizados v0.6.6. El orden de CPU/GPU se alternó entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaban LiteRT CPU/XNNPACK y que todas las filas de GPU delegaban 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.6.6 de yolo-flutter-app; encontrarás el registro detallado de la evaluación comparativa en el documento de rendimiento de Flutter.
• Las cifras correspondientes a la NPU Hexagon de Snapdragon y a CPU/GPU de LiteRT 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 estandarizados v0.6.6.

Google Pixel 10#

Hardware: Google Pixel 10 con 12 GB de memoria y Android 16 / API 36. 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 Performance de hasta 3,05 GHz y 2 núcleos Efficiency de hasta 2,25 GHz), GPU PowerVR D-Series y TPU de Google. Las frecuencias de los núcleos y el nombre del controlador de GPU se consultaron en el dispositivo de prueba, ya que Google no los publica en las especificaciones enlazadas.

Evaluación comparativa: Media de 15 llamadas a predict() después de 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.6.10 y los recursos oficiales v0.6.6. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaban LiteRT CPU/XNNPACK y que todas las filas de GPU delegaban el grafo completo en LiteRT OpenCL (LITERT_CL).

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) con 12 GB de memoria y Android 16 / API 36. 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 alto rendimiento de hasta 3,26 GHz y 6 núcleos C1-Pro de bajo consumo de hasta 2,76 GHz), GPU Xclipse 960 y NPU de Samsung.

Evaluación comparativa: Media de 15 llamadas a predict() después de 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.6.10 y los recursos oficiales v0.6.6. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaban LiteRT CPU/XNNPACK y que todas las filas de GPU delegaban el grafo completo en LiteRT OpenCL (LITERT_CL).

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() después de 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.6.10 y los recursos oficiales v0.6.6. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaban LiteRT CPU/XNNPACK y que todas las filas de GPU delegaban el grafo completo en LiteRT OpenCL (LITERT_CL).

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.

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#